2011-12-04 00:10:08 +01:00
|
|
|
/*
|
|
|
|
* QEMU Object Model
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2011
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*/
|
|
|
|
|
2016-01-29 18:50:02 +01: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.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2012-12-17 18:19:50 +01:00
|
|
|
#include "qom/object.h"
|
qom: Add object_new_with_props() / object_new_withpropv() helpers
It is reasonably common to want to create an object, set a
number of properties, register it in the hierarchy and then
mark it as complete (if a user creatable type). This requires
quite a lot of error prone, verbose, boilerplate code to achieve.
First a pair of functions object_set_props() / object_set_propv()
are added which allow for a list of objects to be set in
one single API call.
Then object_new_with_props() / object_new_with_propv() constructors
are added which simplify the sequence of calls to create an
object, populate properties, register in the object composition
tree and mark the object complete, into a single method call.
Usage would be:
Error *err = NULL;
Object *obj;
obj = object_new_with_propv(TYPE_MEMORY_BACKEND_FILE,
object_get_objects_root(),
"hostmem0",
&err,
"share", "yes",
"mem-path", "/dev/shm/somefile",
"prealloc", "yes",
"size", "1048576",
NULL);
Note all property values are passed in string form and will
be parsed into their required data types, using normal QOM
semantics for parsing from string format.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:06 +02:00
|
|
|
#include "qom/object_interfaces.h"
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/visitor.h"
|
2014-05-14 11:43:33 +02:00
|
|
|
#include "qapi-visit.h"
|
2012-02-09 09:52:59 +01:00
|
|
|
#include "qapi/string-input-visitor.h"
|
|
|
|
#include "qapi/string-output-visitor.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2013-05-10 14:16:39 +02:00
|
|
|
#include "trace.h"
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2012-02-01 17:16:22 +01:00
|
|
|
/* TODO: replace QObject with a simpler visitor to avoid a dependency
|
|
|
|
* of the QOM core on QObject? */
|
2012-12-17 18:19:50 +01:00
|
|
|
#include "qom/qom-qobject.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qobject.h"
|
|
|
|
#include "qapi/qmp/qbool.h"
|
|
|
|
#include "qapi/qmp/qint.h"
|
|
|
|
#include "qapi/qmp/qstring.h"
|
2012-02-01 17:16:22 +01:00
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
#define MAX_INTERFACES 32
|
|
|
|
|
|
|
|
typedef struct InterfaceImpl InterfaceImpl;
|
|
|
|
typedef struct TypeImpl TypeImpl;
|
|
|
|
|
|
|
|
struct InterfaceImpl
|
|
|
|
{
|
2012-08-10 05:16:10 +02:00
|
|
|
const char *typename;
|
2011-12-04 00:10:08 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
struct TypeImpl
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
size_t class_size;
|
|
|
|
|
|
|
|
size_t instance_size;
|
|
|
|
|
|
|
|
void (*class_init)(ObjectClass *klass, void *data);
|
2012-05-02 13:30:55 +02:00
|
|
|
void (*class_base_init)(ObjectClass *klass, void *data);
|
2011-12-04 00:10:08 +01:00
|
|
|
void (*class_finalize)(ObjectClass *klass, void *data);
|
|
|
|
|
|
|
|
void *class_data;
|
|
|
|
|
|
|
|
void (*instance_init)(Object *obj);
|
2013-07-10 22:08:41 +02:00
|
|
|
void (*instance_post_init)(Object *obj);
|
2011-12-04 00:10:08 +01:00
|
|
|
void (*instance_finalize)(Object *obj);
|
|
|
|
|
|
|
|
bool abstract;
|
|
|
|
|
|
|
|
const char *parent;
|
|
|
|
TypeImpl *parent_type;
|
|
|
|
|
|
|
|
ObjectClass *class;
|
|
|
|
|
|
|
|
int num_interfaces;
|
|
|
|
InterfaceImpl interfaces[MAX_INTERFACES];
|
|
|
|
};
|
|
|
|
|
2012-02-03 11:51:39 +01:00
|
|
|
static Type type_interface;
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
static GHashTable *type_table_get(void)
|
|
|
|
{
|
|
|
|
static GHashTable *type_table;
|
|
|
|
|
|
|
|
if (type_table == NULL) {
|
|
|
|
type_table = g_hash_table_new(g_str_hash, g_str_equal);
|
|
|
|
}
|
|
|
|
|
|
|
|
return type_table;
|
|
|
|
}
|
|
|
|
|
2013-12-03 16:42:00 +01:00
|
|
|
static bool enumerating_types;
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
static void type_table_add(TypeImpl *ti)
|
|
|
|
{
|
2013-12-03 16:42:00 +01:00
|
|
|
assert(!enumerating_types);
|
2011-12-04 00:10:08 +01:00
|
|
|
g_hash_table_insert(type_table_get(), (void *)ti->name, ti);
|
|
|
|
}
|
|
|
|
|
|
|
|
static TypeImpl *type_table_lookup(const char *name)
|
|
|
|
{
|
|
|
|
return g_hash_table_lookup(type_table_get(), name);
|
|
|
|
}
|
|
|
|
|
2013-12-03 16:41:59 +01:00
|
|
|
static TypeImpl *type_new(const TypeInfo *info)
|
2011-12-04 00:10:08 +01:00
|
|
|
{
|
|
|
|
TypeImpl *ti = g_malloc0(sizeof(*ti));
|
2012-08-10 05:16:10 +02:00
|
|
|
int i;
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
g_assert(info->name != NULL);
|
|
|
|
|
2012-01-25 20:37:36 +01:00
|
|
|
if (type_table_lookup(info->name) != NULL) {
|
|
|
|
fprintf(stderr, "Registering `%s' which already exists\n", info->name);
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
ti->name = g_strdup(info->name);
|
|
|
|
ti->parent = g_strdup(info->parent);
|
|
|
|
|
|
|
|
ti->class_size = info->class_size;
|
|
|
|
ti->instance_size = info->instance_size;
|
|
|
|
|
|
|
|
ti->class_init = info->class_init;
|
2012-05-02 13:30:55 +02:00
|
|
|
ti->class_base_init = info->class_base_init;
|
2011-12-04 00:10:08 +01:00
|
|
|
ti->class_finalize = info->class_finalize;
|
|
|
|
ti->class_data = info->class_data;
|
|
|
|
|
|
|
|
ti->instance_init = info->instance_init;
|
2013-07-10 22:08:41 +02:00
|
|
|
ti->instance_post_init = info->instance_post_init;
|
2011-12-04 00:10:08 +01:00
|
|
|
ti->instance_finalize = info->instance_finalize;
|
|
|
|
|
|
|
|
ti->abstract = info->abstract;
|
|
|
|
|
2012-08-10 05:16:10 +02:00
|
|
|
for (i = 0; info->interfaces && info->interfaces[i].type; i++) {
|
|
|
|
ti->interfaces[i].typename = g_strdup(info->interfaces[i].type);
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
2012-08-10 05:16:10 +02:00
|
|
|
ti->num_interfaces = i;
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2013-12-03 16:41:59 +01:00
|
|
|
return ti;
|
|
|
|
}
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2013-12-03 16:41:59 +01:00
|
|
|
static TypeImpl *type_register_internal(const TypeInfo *info)
|
|
|
|
{
|
|
|
|
TypeImpl *ti;
|
|
|
|
ti = type_new(info);
|
|
|
|
|
|
|
|
type_table_add(ti);
|
2011-12-04 00:10:08 +01:00
|
|
|
return ti;
|
|
|
|
}
|
|
|
|
|
2012-04-04 15:58:40 +02:00
|
|
|
TypeImpl *type_register(const TypeInfo *info)
|
|
|
|
{
|
|
|
|
assert(info->parent);
|
|
|
|
return type_register_internal(info);
|
|
|
|
}
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
TypeImpl *type_register_static(const TypeInfo *info)
|
|
|
|
{
|
|
|
|
return type_register(info);
|
|
|
|
}
|
|
|
|
|
|
|
|
static TypeImpl *type_get_by_name(const char *name)
|
|
|
|
{
|
|
|
|
if (name == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return type_table_lookup(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static TypeImpl *type_get_parent(TypeImpl *type)
|
|
|
|
{
|
|
|
|
if (!type->parent_type && type->parent) {
|
|
|
|
type->parent_type = type_get_by_name(type->parent);
|
|
|
|
g_assert(type->parent_type != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
return type->parent_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool type_has_parent(TypeImpl *type)
|
|
|
|
{
|
|
|
|
return (type->parent != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t type_class_get_size(TypeImpl *ti)
|
|
|
|
{
|
|
|
|
if (ti->class_size) {
|
|
|
|
return ti->class_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type_has_parent(ti)) {
|
|
|
|
return type_class_get_size(type_get_parent(ti));
|
|
|
|
}
|
|
|
|
|
|
|
|
return sizeof(ObjectClass);
|
|
|
|
}
|
|
|
|
|
2012-02-28 12:57:10 +01:00
|
|
|
static size_t type_object_get_size(TypeImpl *ti)
|
|
|
|
{
|
|
|
|
if (ti->instance_size) {
|
|
|
|
return ti->instance_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type_has_parent(ti)) {
|
|
|
|
return type_object_get_size(type_get_parent(ti));
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-10 02:59:00 +02:00
|
|
|
size_t object_type_get_instance_size(const char *typename)
|
|
|
|
{
|
|
|
|
TypeImpl *type = type_get_by_name(typename);
|
|
|
|
|
|
|
|
g_assert(type != NULL);
|
|
|
|
return type_object_get_size(type);
|
|
|
|
}
|
|
|
|
|
2012-08-10 05:16:10 +02:00
|
|
|
static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type)
|
2011-12-04 00:10:08 +01:00
|
|
|
{
|
2012-08-10 05:16:10 +02:00
|
|
|
assert(target_type);
|
|
|
|
|
2015-11-03 03:36:42 +01:00
|
|
|
/* Check if target_type is a direct ancestor of type */
|
2012-08-10 05:16:10 +02:00
|
|
|
while (type) {
|
|
|
|
if (type == target_type) {
|
|
|
|
return true;
|
|
|
|
}
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2012-08-10 05:16:10 +02:00
|
|
|
type = type_get_parent(type);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void type_initialize(TypeImpl *ti);
|
|
|
|
|
2013-12-03 16:41:59 +01:00
|
|
|
static void type_initialize_interface(TypeImpl *ti, TypeImpl *interface_type,
|
|
|
|
TypeImpl *parent_type)
|
2012-08-10 05:16:10 +02:00
|
|
|
{
|
|
|
|
InterfaceClass *new_iface;
|
|
|
|
TypeInfo info = { };
|
|
|
|
TypeImpl *iface_impl;
|
|
|
|
|
2013-12-03 16:41:59 +01:00
|
|
|
info.parent = parent_type->name;
|
|
|
|
info.name = g_strdup_printf("%s::%s", ti->name, interface_type->name);
|
2012-08-10 05:16:10 +02:00
|
|
|
info.abstract = true;
|
|
|
|
|
2013-12-03 16:41:59 +01:00
|
|
|
iface_impl = type_new(&info);
|
|
|
|
iface_impl->parent_type = parent_type;
|
2012-08-10 05:16:10 +02:00
|
|
|
type_initialize(iface_impl);
|
|
|
|
g_free((char *)info.name);
|
|
|
|
|
|
|
|
new_iface = (InterfaceClass *)iface_impl->class;
|
|
|
|
new_iface->concrete_class = ti->class;
|
2013-12-03 16:41:59 +01:00
|
|
|
new_iface->interface_type = interface_type;
|
2012-08-10 05:16:10 +02:00
|
|
|
|
|
|
|
ti->class->interfaces = g_slist_append(ti->class->interfaces,
|
|
|
|
iface_impl->class);
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
static void object_property_free(gpointer data)
|
|
|
|
{
|
|
|
|
ObjectProperty *prop = data;
|
|
|
|
|
|
|
|
g_free(prop->name);
|
|
|
|
g_free(prop->type);
|
|
|
|
g_free(prop->description);
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
|
2012-02-28 12:57:11 +01:00
|
|
|
static void type_initialize(TypeImpl *ti)
|
2011-12-04 00:10:08 +01:00
|
|
|
{
|
2012-03-31 16:45:54 +02:00
|
|
|
TypeImpl *parent;
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
if (ti->class) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ti->class_size = type_class_get_size(ti);
|
2012-02-28 12:57:10 +01:00
|
|
|
ti->instance_size = type_object_get_size(ti);
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
ti->class = g_malloc0(ti->class_size);
|
|
|
|
|
2012-03-31 16:45:54 +02:00
|
|
|
parent = type_get_parent(ti);
|
|
|
|
if (parent) {
|
2012-02-28 12:57:11 +01:00
|
|
|
type_initialize(parent);
|
2012-08-10 05:16:10 +02:00
|
|
|
GSList *e;
|
|
|
|
int i;
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2015-11-16 17:49:20 +01:00
|
|
|
g_assert_cmpint(parent->class_size, <=, ti->class_size);
|
2012-03-31 16:45:54 +02:00
|
|
|
memcpy(ti->class, parent->class, parent->class_size);
|
2013-02-19 05:02:09 +01:00
|
|
|
ti->class->interfaces = NULL;
|
2015-10-13 14:37:46 +02:00
|
|
|
ti->class->properties = g_hash_table_new_full(
|
|
|
|
g_str_hash, g_str_equal, g_free, object_property_free);
|
2012-08-10 05:16:10 +02:00
|
|
|
|
|
|
|
for (e = parent->class->interfaces; e; e = e->next) {
|
2013-12-03 16:41:59 +01:00
|
|
|
InterfaceClass *iface = e->data;
|
|
|
|
ObjectClass *klass = OBJECT_CLASS(iface);
|
|
|
|
|
|
|
|
type_initialize_interface(ti, iface->interface_type, klass->type);
|
2012-08-10 05:16:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ti->num_interfaces; i++) {
|
|
|
|
TypeImpl *t = type_get_by_name(ti->interfaces[i].typename);
|
|
|
|
for (e = ti->class->interfaces; e; e = e->next) {
|
|
|
|
TypeImpl *target_type = OBJECT_CLASS(e->data)->type;
|
|
|
|
|
|
|
|
if (type_is_ancestor(target_type, t)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (e) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-12-03 16:41:59 +01:00
|
|
|
type_initialize_interface(ti, t, t);
|
2012-08-10 05:16:10 +02:00
|
|
|
}
|
2015-10-13 14:37:46 +02:00
|
|
|
} else {
|
|
|
|
ti->class->properties = g_hash_table_new_full(
|
|
|
|
g_str_hash, g_str_equal, g_free, object_property_free);
|
2012-03-31 16:45:54 +02:00
|
|
|
}
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2012-03-31 16:45:54 +02:00
|
|
|
ti->class->type = ti;
|
2012-05-02 13:30:55 +02:00
|
|
|
|
2012-03-31 16:45:54 +02:00
|
|
|
while (parent) {
|
|
|
|
if (parent->class_base_init) {
|
|
|
|
parent->class_base_init(ti->class, ti->class_data);
|
2012-05-02 13:30:55 +02:00
|
|
|
}
|
2012-03-31 16:45:54 +02:00
|
|
|
parent = type_get_parent(parent);
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ti->class_init) {
|
|
|
|
ti->class_init(ti->class, ti->class_data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void object_init_with_type(Object *obj, TypeImpl *ti)
|
|
|
|
{
|
|
|
|
if (type_has_parent(ti)) {
|
|
|
|
object_init_with_type(obj, type_get_parent(ti));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ti->instance_init) {
|
|
|
|
ti->instance_init(obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-10 22:08:41 +02:00
|
|
|
static void object_post_init_with_type(Object *obj, TypeImpl *ti)
|
|
|
|
{
|
|
|
|
if (ti->instance_post_init) {
|
|
|
|
ti->instance_post_init(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type_has_parent(ti)) {
|
|
|
|
object_post_init_with_type(obj, type_get_parent(ti));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-30 18:28:37 +02:00
|
|
|
void object_initialize_with_type(void *data, size_t size, TypeImpl *type)
|
2011-12-04 00:10:08 +01:00
|
|
|
{
|
|
|
|
Object *obj = data;
|
|
|
|
|
|
|
|
g_assert(type != NULL);
|
2012-02-28 12:57:11 +01:00
|
|
|
type_initialize(type);
|
2012-02-28 12:57:10 +01:00
|
|
|
|
2015-11-16 17:49:20 +01:00
|
|
|
g_assert_cmpint(type->instance_size, >=, sizeof(Object));
|
2011-12-04 00:10:08 +01:00
|
|
|
g_assert(type->abstract == false);
|
2015-11-16 17:49:20 +01:00
|
|
|
g_assert_cmpint(size, >=, type->instance_size);
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
memset(obj, 0, type->instance_size);
|
|
|
|
obj->class = type->class;
|
2012-11-23 09:47:12 +01:00
|
|
|
object_ref(obj);
|
2015-10-13 14:37:45 +02:00
|
|
|
obj->properties = g_hash_table_new_full(g_str_hash, g_str_equal,
|
|
|
|
NULL, object_property_free);
|
2011-12-04 00:10:08 +01:00
|
|
|
object_init_with_type(obj, type);
|
2013-07-10 22:08:41 +02:00
|
|
|
object_post_init_with_type(obj, type);
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
|
|
|
|
2013-08-23 19:37:12 +02:00
|
|
|
void object_initialize(void *data, size_t size, const char *typename)
|
2011-12-04 00:10:08 +01:00
|
|
|
{
|
|
|
|
TypeImpl *type = type_get_by_name(typename);
|
|
|
|
|
2013-08-30 18:28:37 +02:00
|
|
|
object_initialize_with_type(data, size, type);
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
|
|
|
|
2012-05-27 00:32:40 +02:00
|
|
|
static inline bool object_property_is_child(ObjectProperty *prop)
|
|
|
|
{
|
|
|
|
return strstart(prop->type, "child<", NULL);
|
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
static void object_property_del_all(Object *obj)
|
|
|
|
{
|
2015-10-13 14:37:45 +02:00
|
|
|
ObjectProperty *prop;
|
|
|
|
GHashTableIter iter;
|
|
|
|
gpointer key, value;
|
|
|
|
bool released;
|
|
|
|
|
|
|
|
do {
|
|
|
|
released = false;
|
|
|
|
g_hash_table_iter_init(&iter, obj->properties);
|
|
|
|
while (g_hash_table_iter_next(&iter, &key, &value)) {
|
|
|
|
prop = value;
|
|
|
|
if (prop->release) {
|
|
|
|
prop->release(obj, prop->name, prop->opaque);
|
|
|
|
prop->release = NULL;
|
|
|
|
released = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
g_hash_table_iter_remove(&iter);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
2015-10-13 14:37:45 +02:00
|
|
|
} while (released);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2015-10-13 14:37:45 +02:00
|
|
|
g_hash_table_unref(obj->properties);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void object_property_del_child(Object *obj, Object *child, Error **errp)
|
|
|
|
{
|
|
|
|
ObjectProperty *prop;
|
2015-10-13 14:37:45 +02:00
|
|
|
GHashTableIter iter;
|
|
|
|
gpointer key, value;
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2015-10-13 14:37:45 +02:00
|
|
|
g_hash_table_iter_init(&iter, obj->properties);
|
|
|
|
while (g_hash_table_iter_next(&iter, &key, &value)) {
|
|
|
|
prop = value;
|
|
|
|
if (object_property_is_child(prop) && prop->opaque == child) {
|
|
|
|
if (prop->release) {
|
|
|
|
prop->release(obj, prop->name, prop->opaque);
|
|
|
|
prop->release = NULL;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_hash_table_iter_init(&iter, obj->properties);
|
|
|
|
while (g_hash_table_iter_next(&iter, &key, &value)) {
|
|
|
|
prop = value;
|
2012-05-27 00:32:40 +02:00
|
|
|
if (object_property_is_child(prop) && prop->opaque == child) {
|
2015-10-13 14:37:45 +02:00
|
|
|
g_hash_table_iter_remove(&iter);
|
2012-02-28 09:54:15 +01:00
|
|
|
break;
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void object_unparent(Object *obj)
|
|
|
|
{
|
2013-03-18 20:01:37 +01:00
|
|
|
if (obj->parent) {
|
|
|
|
object_property_del_child(obj->parent, obj, NULL);
|
|
|
|
}
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
static void object_deinit(Object *obj, TypeImpl *type)
|
|
|
|
{
|
|
|
|
if (type->instance_finalize) {
|
|
|
|
type->instance_finalize(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type_has_parent(type)) {
|
|
|
|
object_deinit(obj, type_get_parent(type));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-23 09:47:16 +01:00
|
|
|
static void object_finalize(void *data)
|
2011-12-04 00:10:08 +01:00
|
|
|
{
|
|
|
|
Object *obj = data;
|
|
|
|
TypeImpl *ti = obj->class->type;
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
object_property_del_all(obj);
|
2014-06-11 11:58:30 +02:00
|
|
|
object_deinit(obj, ti);
|
2011-12-23 15:47:39 +01:00
|
|
|
|
2015-11-16 17:49:20 +01:00
|
|
|
g_assert_cmpint(obj->ref, ==, 0);
|
2012-11-23 09:47:14 +01:00
|
|
|
if (obj->free) {
|
|
|
|
obj->free(obj);
|
|
|
|
}
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Object *object_new_with_type(Type type)
|
|
|
|
{
|
|
|
|
Object *obj;
|
|
|
|
|
|
|
|
g_assert(type != NULL);
|
2012-02-28 12:57:11 +01:00
|
|
|
type_initialize(type);
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
obj = g_malloc(type->instance_size);
|
2013-08-30 18:28:37 +02:00
|
|
|
object_initialize_with_type(obj, type->instance_size, type);
|
2012-11-23 09:47:14 +01:00
|
|
|
obj->free = g_free;
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
Object *object_new(const char *typename)
|
|
|
|
{
|
|
|
|
TypeImpl *ti = type_get_by_name(typename);
|
|
|
|
|
|
|
|
return object_new_with_type(ti);
|
|
|
|
}
|
|
|
|
|
qom: Add object_new_with_props() / object_new_withpropv() helpers
It is reasonably common to want to create an object, set a
number of properties, register it in the hierarchy and then
mark it as complete (if a user creatable type). This requires
quite a lot of error prone, verbose, boilerplate code to achieve.
First a pair of functions object_set_props() / object_set_propv()
are added which allow for a list of objects to be set in
one single API call.
Then object_new_with_props() / object_new_with_propv() constructors
are added which simplify the sequence of calls to create an
object, populate properties, register in the object composition
tree and mark the object complete, into a single method call.
Usage would be:
Error *err = NULL;
Object *obj;
obj = object_new_with_propv(TYPE_MEMORY_BACKEND_FILE,
object_get_objects_root(),
"hostmem0",
&err,
"share", "yes",
"mem-path", "/dev/shm/somefile",
"prealloc", "yes",
"size", "1048576",
NULL);
Note all property values are passed in string form and will
be parsed into their required data types, using normal QOM
semantics for parsing from string format.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:06 +02:00
|
|
|
|
|
|
|
Object *object_new_with_props(const char *typename,
|
|
|
|
Object *parent,
|
|
|
|
const char *id,
|
|
|
|
Error **errp,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
va_list vargs;
|
|
|
|
Object *obj;
|
|
|
|
|
|
|
|
va_start(vargs, errp);
|
|
|
|
obj = object_new_with_propv(typename, parent, id, errp, vargs);
|
|
|
|
va_end(vargs);
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Object *object_new_with_propv(const char *typename,
|
|
|
|
Object *parent,
|
|
|
|
const char *id,
|
|
|
|
Error **errp,
|
|
|
|
va_list vargs)
|
|
|
|
{
|
|
|
|
Object *obj;
|
|
|
|
ObjectClass *klass;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
klass = object_class_by_name(typename);
|
|
|
|
if (!klass) {
|
|
|
|
error_setg(errp, "invalid object type: %s", typename);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (object_class_is_abstract(klass)) {
|
|
|
|
error_setg(errp, "object type '%s' is abstract", typename);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
obj = object_new(typename);
|
|
|
|
|
|
|
|
if (object_set_propv(obj, &local_err, vargs) < 0) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
object_property_add_child(parent, id, obj, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (object_dynamic_cast(obj, TYPE_USER_CREATABLE)) {
|
|
|
|
user_creatable_complete(obj, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
object_unparent(obj);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
object_unref(OBJECT(obj));
|
|
|
|
return obj;
|
|
|
|
|
|
|
|
error:
|
2016-06-13 23:57:56 +02:00
|
|
|
error_propagate(errp, local_err);
|
qom: Add object_new_with_props() / object_new_withpropv() helpers
It is reasonably common to want to create an object, set a
number of properties, register it in the hierarchy and then
mark it as complete (if a user creatable type). This requires
quite a lot of error prone, verbose, boilerplate code to achieve.
First a pair of functions object_set_props() / object_set_propv()
are added which allow for a list of objects to be set in
one single API call.
Then object_new_with_props() / object_new_with_propv() constructors
are added which simplify the sequence of calls to create an
object, populate properties, register in the object composition
tree and mark the object complete, into a single method call.
Usage would be:
Error *err = NULL;
Object *obj;
obj = object_new_with_propv(TYPE_MEMORY_BACKEND_FILE,
object_get_objects_root(),
"hostmem0",
&err,
"share", "yes",
"mem-path", "/dev/shm/somefile",
"prealloc", "yes",
"size", "1048576",
NULL);
Note all property values are passed in string form and will
be parsed into their required data types, using normal QOM
semantics for parsing from string format.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:06 +02:00
|
|
|
object_unref(obj);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int object_set_props(Object *obj,
|
|
|
|
Error **errp,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
va_list vargs;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
va_start(vargs, errp);
|
|
|
|
ret = object_set_propv(obj, errp, vargs);
|
|
|
|
va_end(vargs);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int object_set_propv(Object *obj,
|
|
|
|
Error **errp,
|
|
|
|
va_list vargs)
|
|
|
|
{
|
|
|
|
const char *propname;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
propname = va_arg(vargs, char *);
|
|
|
|
while (propname != NULL) {
|
|
|
|
const char *value = va_arg(vargs, char *);
|
|
|
|
|
|
|
|
g_assert(value != NULL);
|
|
|
|
object_property_parse(obj, value, propname, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
propname = va_arg(vargs, char *);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
Object *object_dynamic_cast(Object *obj, const char *typename)
|
|
|
|
{
|
2012-11-23 16:56:17 +01:00
|
|
|
if (obj && object_class_dynamic_cast(object_get_class(obj), typename)) {
|
2012-02-03 11:57:23 +01:00
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-05-10 14:16:38 +02:00
|
|
|
Object *object_dynamic_cast_assert(Object *obj, const char *typename,
|
|
|
|
const char *file, int line, const char *func)
|
2011-12-04 00:10:08 +01:00
|
|
|
{
|
2013-05-10 14:16:39 +02:00
|
|
|
trace_object_dynamic_cast_assert(obj ? obj->class->type->name : "(null)",
|
|
|
|
typename, file, line, func);
|
|
|
|
|
2013-05-10 14:16:40 +02:00
|
|
|
#ifdef CONFIG_QOM_CAST_DEBUG
|
2013-05-13 22:22:24 +02:00
|
|
|
int i;
|
|
|
|
Object *inst;
|
|
|
|
|
2013-05-22 03:19:16 +02:00
|
|
|
for (i = 0; obj && i < OBJECT_CLASS_CAST_CACHE; i++) {
|
2016-09-30 23:30:57 +02:00
|
|
|
if (atomic_read(&obj->class->object_cast_cache[i]) == typename) {
|
2013-05-13 22:22:24 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inst = object_dynamic_cast(obj, typename);
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2012-11-23 16:56:17 +01:00
|
|
|
if (!inst && obj) {
|
2013-05-10 14:16:38 +02:00
|
|
|
fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
|
|
|
|
file, line, func, obj, typename);
|
2011-12-04 00:10:08 +01:00
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2013-05-10 14:16:40 +02:00
|
|
|
assert(obj == inst);
|
2013-05-13 22:22:24 +02:00
|
|
|
|
2013-05-22 03:19:16 +02:00
|
|
|
if (obj && obj == inst) {
|
2013-05-13 22:22:24 +02:00
|
|
|
for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
|
2016-09-30 23:30:57 +02:00
|
|
|
atomic_set(&obj->class->object_cast_cache[i - 1],
|
|
|
|
atomic_read(&obj->class->object_cast_cache[i]));
|
2013-05-13 22:22:24 +02:00
|
|
|
}
|
2016-09-30 23:30:57 +02:00
|
|
|
atomic_set(&obj->class->object_cast_cache[i - 1], typename);
|
2013-05-13 22:22:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2013-05-10 14:16:40 +02:00
|
|
|
#endif
|
|
|
|
return obj;
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ObjectClass *object_class_dynamic_cast(ObjectClass *class,
|
|
|
|
const char *typename)
|
|
|
|
{
|
2012-08-10 05:16:10 +02:00
|
|
|
ObjectClass *ret = NULL;
|
2013-05-10 14:16:36 +02:00
|
|
|
TypeImpl *target_type;
|
|
|
|
TypeImpl *type;
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2013-05-10 14:16:36 +02:00
|
|
|
if (!class) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-05-10 14:16:37 +02:00
|
|
|
/* A simple fast path that can trigger a lot for leaf classes. */
|
2013-05-10 14:16:36 +02:00
|
|
|
type = class->type;
|
2013-05-10 14:16:37 +02:00
|
|
|
if (type->name == typename) {
|
|
|
|
return class;
|
|
|
|
}
|
|
|
|
|
2013-05-10 14:16:36 +02:00
|
|
|
target_type = type_get_by_name(typename);
|
2013-04-30 15:02:16 +02:00
|
|
|
if (!target_type) {
|
|
|
|
/* target class type unknown, so fail the cast */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-02-19 05:02:10 +01:00
|
|
|
if (type->class->interfaces &&
|
|
|
|
type_is_ancestor(target_type, type_interface)) {
|
2012-08-10 05:16:10 +02:00
|
|
|
int found = 0;
|
|
|
|
GSList *i;
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2012-08-10 05:16:10 +02:00
|
|
|
for (i = class->interfaces; i; i = i->next) {
|
|
|
|
ObjectClass *target_class = i->data;
|
|
|
|
|
|
|
|
if (type_is_ancestor(target_class->type, target_type)) {
|
|
|
|
ret = target_class;
|
|
|
|
found++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The match was ambiguous, don't allow a cast */
|
|
|
|
if (found > 1) {
|
|
|
|
ret = NULL;
|
|
|
|
}
|
|
|
|
} else if (type_is_ancestor(type, target_type)) {
|
|
|
|
ret = class;
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
|
|
|
|
2012-08-10 05:16:10 +02:00
|
|
|
return ret;
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class,
|
2013-05-10 14:16:38 +02:00
|
|
|
const char *typename,
|
|
|
|
const char *file, int line,
|
|
|
|
const char *func)
|
2011-12-04 00:10:08 +01:00
|
|
|
{
|
2013-05-10 14:16:39 +02:00
|
|
|
ObjectClass *ret;
|
|
|
|
|
|
|
|
trace_object_class_dynamic_cast_assert(class ? class->type->name : "(null)",
|
|
|
|
typename, file, line, func);
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2013-05-13 22:22:24 +02:00
|
|
|
#ifdef CONFIG_QOM_CAST_DEBUG
|
|
|
|
int i;
|
|
|
|
|
2013-06-18 11:18:59 +02:00
|
|
|
for (i = 0; class && i < OBJECT_CLASS_CAST_CACHE; i++) {
|
2016-09-30 23:30:57 +02:00
|
|
|
if (atomic_read(&class->class_cast_cache[i]) == typename) {
|
2013-05-13 22:22:24 +02:00
|
|
|
ret = class;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2013-06-18 11:18:59 +02:00
|
|
|
if (!class || !class->interfaces) {
|
2013-05-10 14:16:40 +02:00
|
|
|
return class;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-05-10 14:16:39 +02:00
|
|
|
ret = object_class_dynamic_cast(class, typename);
|
2013-05-10 14:16:36 +02:00
|
|
|
if (!ret && class) {
|
2013-05-10 14:16:38 +02:00
|
|
|
fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
|
|
|
|
file, line, func, class, typename);
|
2011-12-04 00:10:08 +01:00
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2013-05-13 22:22:24 +02:00
|
|
|
#ifdef CONFIG_QOM_CAST_DEBUG
|
2013-06-18 11:18:59 +02:00
|
|
|
if (class && ret == class) {
|
2013-05-13 22:22:24 +02:00
|
|
|
for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
|
2016-09-30 23:30:57 +02:00
|
|
|
atomic_set(&class->class_cast_cache[i - 1],
|
|
|
|
atomic_read(&class->class_cast_cache[i]));
|
2013-05-13 22:22:24 +02:00
|
|
|
}
|
2016-09-30 23:30:57 +02:00
|
|
|
atomic_set(&class->class_cast_cache[i - 1], typename);
|
2013-05-13 22:22:24 +02:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
#endif
|
2011-12-04 00:10:08 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *object_get_typename(Object *obj)
|
|
|
|
{
|
|
|
|
return obj->class->type->name;
|
|
|
|
}
|
|
|
|
|
|
|
|
ObjectClass *object_get_class(Object *obj)
|
|
|
|
{
|
|
|
|
return obj->class;
|
|
|
|
}
|
|
|
|
|
2013-01-23 12:20:18 +01:00
|
|
|
bool object_class_is_abstract(ObjectClass *klass)
|
|
|
|
{
|
|
|
|
return klass->type->abstract;
|
|
|
|
}
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
const char *object_class_get_name(ObjectClass *klass)
|
|
|
|
{
|
|
|
|
return klass->type->name;
|
|
|
|
}
|
|
|
|
|
|
|
|
ObjectClass *object_class_by_name(const char *typename)
|
|
|
|
{
|
|
|
|
TypeImpl *type = type_get_by_name(typename);
|
|
|
|
|
|
|
|
if (!type) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-02-28 12:57:11 +01:00
|
|
|
type_initialize(type);
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
return type->class;
|
|
|
|
}
|
|
|
|
|
2012-05-02 13:30:54 +02:00
|
|
|
ObjectClass *object_class_get_parent(ObjectClass *class)
|
|
|
|
{
|
|
|
|
TypeImpl *type = type_get_parent(class->type);
|
|
|
|
|
|
|
|
if (!type) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
type_initialize(type);
|
|
|
|
|
|
|
|
return type->class;
|
|
|
|
}
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
typedef struct OCFData
|
|
|
|
{
|
|
|
|
void (*fn)(ObjectClass *klass, void *opaque);
|
2011-12-22 21:11:53 +01:00
|
|
|
const char *implements_type;
|
|
|
|
bool include_abstract;
|
2011-12-04 00:10:08 +01:00
|
|
|
void *opaque;
|
|
|
|
} OCFData;
|
|
|
|
|
|
|
|
static void object_class_foreach_tramp(gpointer key, gpointer value,
|
|
|
|
gpointer opaque)
|
|
|
|
{
|
|
|
|
OCFData *data = opaque;
|
|
|
|
TypeImpl *type = value;
|
2011-12-22 21:11:53 +01:00
|
|
|
ObjectClass *k;
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2012-02-28 12:57:11 +01:00
|
|
|
type_initialize(type);
|
2011-12-22 21:11:53 +01:00
|
|
|
k = type->class;
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2011-12-22 21:11:53 +01:00
|
|
|
if (!data->include_abstract && type->abstract) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data->implements_type &&
|
|
|
|
!object_class_dynamic_cast(k, data->implements_type)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
data->fn(k, data->opaque);
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque),
|
2011-12-22 21:11:53 +01:00
|
|
|
const char *implements_type, bool include_abstract,
|
2011-12-04 00:10:08 +01:00
|
|
|
void *opaque)
|
|
|
|
{
|
2011-12-22 21:11:53 +01:00
|
|
|
OCFData data = { fn, implements_type, include_abstract, opaque };
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2013-12-03 16:42:00 +01:00
|
|
|
enumerating_types = true;
|
2011-12-04 00:10:08 +01:00
|
|
|
g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data);
|
2013-12-03 16:42:00 +01:00
|
|
|
enumerating_types = false;
|
2011-12-04 00:10:08 +01:00
|
|
|
}
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2015-09-08 18:38:43 +02:00
|
|
|
static int do_object_child_foreach(Object *obj,
|
|
|
|
int (*fn)(Object *child, void *opaque),
|
|
|
|
void *opaque, bool recurse)
|
2012-04-11 23:30:20 +02:00
|
|
|
{
|
2015-10-13 14:37:45 +02:00
|
|
|
GHashTableIter iter;
|
|
|
|
ObjectProperty *prop;
|
2012-04-11 23:30:20 +02:00
|
|
|
int ret = 0;
|
|
|
|
|
2015-10-13 14:37:45 +02:00
|
|
|
g_hash_table_iter_init(&iter, obj->properties);
|
|
|
|
while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
|
2012-04-11 23:30:20 +02:00
|
|
|
if (object_property_is_child(prop)) {
|
2015-09-08 18:38:43 +02:00
|
|
|
Object *child = prop->opaque;
|
|
|
|
|
|
|
|
ret = fn(child, opaque);
|
2012-04-11 23:30:20 +02:00
|
|
|
if (ret != 0) {
|
|
|
|
break;
|
|
|
|
}
|
2015-09-08 18:38:43 +02:00
|
|
|
if (recurse) {
|
|
|
|
do_object_child_foreach(child, fn, opaque, true);
|
|
|
|
}
|
2012-04-11 23:30:20 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-09-08 18:38:43 +02:00
|
|
|
int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque),
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
return do_object_child_foreach(obj, fn, opaque, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
int object_child_foreach_recursive(Object *obj,
|
|
|
|
int (*fn)(Object *child, void *opaque),
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
return do_object_child_foreach(obj, fn, opaque, true);
|
|
|
|
}
|
|
|
|
|
2012-02-25 23:07:34 +01:00
|
|
|
static void object_class_get_list_tramp(ObjectClass *klass, void *opaque)
|
|
|
|
{
|
|
|
|
GSList **list = opaque;
|
|
|
|
|
|
|
|
*list = g_slist_prepend(*list, klass);
|
|
|
|
}
|
|
|
|
|
|
|
|
GSList *object_class_get_list(const char *implements_type,
|
|
|
|
bool include_abstract)
|
|
|
|
{
|
|
|
|
GSList *list = NULL;
|
|
|
|
|
|
|
|
object_class_foreach(object_class_get_list_tramp,
|
|
|
|
implements_type, include_abstract, &list);
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
void object_ref(Object *obj)
|
|
|
|
{
|
2014-06-06 08:13:36 +02:00
|
|
|
if (!obj) {
|
|
|
|
return;
|
|
|
|
}
|
2015-11-16 17:49:20 +01:00
|
|
|
atomic_inc(&obj->ref);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void object_unref(Object *obj)
|
|
|
|
{
|
2014-06-06 08:13:36 +02:00
|
|
|
if (!obj) {
|
|
|
|
return;
|
|
|
|
}
|
2015-11-16 17:49:20 +01:00
|
|
|
g_assert_cmpint(obj->ref, >, 0);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
|
|
|
/* parent always holds a reference to its children */
|
2013-07-02 11:36:39 +02:00
|
|
|
if (atomic_fetch_dec(&obj->ref) == 1) {
|
2012-01-30 15:55:55 +01:00
|
|
|
object_finalize(obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-05 13:11:51 +02:00
|
|
|
ObjectProperty *
|
|
|
|
object_property_add(Object *obj, const char *name, const char *type,
|
|
|
|
ObjectPropertyAccessor *get,
|
|
|
|
ObjectPropertyAccessor *set,
|
|
|
|
ObjectPropertyRelease *release,
|
|
|
|
void *opaque, Error **errp)
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
2013-03-25 14:15:13 +01:00
|
|
|
ObjectProperty *prop;
|
2014-08-20 08:55:52 +02:00
|
|
|
size_t name_len = strlen(name);
|
|
|
|
|
|
|
|
if (name_len >= 3 && !memcmp(name + name_len - 3, "[*]", 4)) {
|
|
|
|
int i;
|
|
|
|
ObjectProperty *ret;
|
|
|
|
char *name_no_array = g_strdup(name);
|
|
|
|
|
|
|
|
name_no_array[name_len - 3] = '\0';
|
|
|
|
for (i = 0; ; ++i) {
|
|
|
|
char *full_name = g_strdup_printf("%s[%d]", name_no_array, i);
|
|
|
|
|
|
|
|
ret = object_property_add(obj, full_name, type, get, set,
|
|
|
|
release, opaque, NULL);
|
|
|
|
g_free(full_name);
|
|
|
|
if (ret) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_free(name_no_array);
|
|
|
|
return ret;
|
|
|
|
}
|
2013-03-25 14:15:13 +01:00
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
if (object_property_find(obj, name, NULL) != NULL) {
|
2015-10-13 14:37:45 +02:00
|
|
|
error_setg(errp, "attempt to add duplicate property '%s'"
|
2015-10-13 14:37:46 +02:00
|
|
|
" to object (type '%s')", name,
|
|
|
|
object_get_typename(obj));
|
2015-10-13 14:37:45 +02:00
|
|
|
return NULL;
|
2013-03-25 14:15:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
prop = g_malloc0(sizeof(*prop));
|
2012-01-30 15:55:55 +01:00
|
|
|
|
|
|
|
prop->name = g_strdup(name);
|
|
|
|
prop->type = g_strdup(type);
|
|
|
|
|
|
|
|
prop->get = get;
|
|
|
|
prop->set = set;
|
|
|
|
prop->release = release;
|
|
|
|
prop->opaque = opaque;
|
|
|
|
|
2015-10-13 14:37:45 +02:00
|
|
|
g_hash_table_insert(obj->properties, prop->name, prop);
|
2014-06-05 13:11:51 +02:00
|
|
|
return prop;
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
ObjectProperty *
|
|
|
|
object_class_property_add(ObjectClass *klass,
|
|
|
|
const char *name,
|
|
|
|
const char *type,
|
|
|
|
ObjectPropertyAccessor *get,
|
|
|
|
ObjectPropertyAccessor *set,
|
|
|
|
ObjectPropertyRelease *release,
|
|
|
|
void *opaque,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
ObjectProperty *prop;
|
|
|
|
|
|
|
|
if (object_class_property_find(klass, name, NULL) != NULL) {
|
|
|
|
error_setg(errp, "attempt to add duplicate property '%s'"
|
|
|
|
" to object (type '%s')", name,
|
|
|
|
object_class_get_name(klass));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
prop = g_malloc0(sizeof(*prop));
|
|
|
|
|
|
|
|
prop->name = g_strdup(name);
|
|
|
|
prop->type = g_strdup(type);
|
|
|
|
|
|
|
|
prop->get = get;
|
|
|
|
prop->set = set;
|
|
|
|
prop->release = release;
|
|
|
|
prop->opaque = opaque;
|
|
|
|
|
|
|
|
g_hash_table_insert(klass->properties, g_strdup(name), prop);
|
|
|
|
|
|
|
|
return prop;
|
|
|
|
}
|
|
|
|
|
2012-04-12 18:00:18 +02:00
|
|
|
ObjectProperty *object_property_find(Object *obj, const char *name,
|
|
|
|
Error **errp)
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
|
|
|
ObjectProperty *prop;
|
2015-10-13 14:37:46 +02:00
|
|
|
ObjectClass *klass = object_get_class(obj);
|
|
|
|
|
|
|
|
prop = object_class_property_find(klass, name, NULL);
|
|
|
|
if (prop) {
|
|
|
|
return prop;
|
|
|
|
}
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2015-10-13 14:37:45 +02:00
|
|
|
prop = g_hash_table_lookup(obj->properties, name);
|
|
|
|
if (prop) {
|
|
|
|
return prop;
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
2014-03-22 00:42:26 +01:00
|
|
|
error_setg(errp, "Property '.%s' not found", name);
|
2012-01-30 15:55:55 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-12-09 13:34:02 +01:00
|
|
|
void object_property_iter_init(ObjectPropertyIterator *iter,
|
|
|
|
Object *obj)
|
2015-10-13 14:37:40 +02:00
|
|
|
{
|
2015-12-09 13:34:02 +01:00
|
|
|
g_hash_table_iter_init(&iter->iter, obj->properties);
|
|
|
|
iter->nextclass = object_get_class(obj);
|
2015-10-13 14:37:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ObjectProperty *object_property_iter_next(ObjectPropertyIterator *iter)
|
|
|
|
{
|
2015-10-13 14:37:45 +02:00
|
|
|
gpointer key, val;
|
2015-10-13 14:37:46 +02:00
|
|
|
while (!g_hash_table_iter_next(&iter->iter, &key, &val)) {
|
|
|
|
if (!iter->nextclass) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
g_hash_table_iter_init(&iter->iter, iter->nextclass->properties);
|
|
|
|
iter->nextclass = object_class_get_parent(iter->nextclass);
|
2015-10-13 14:37:40 +02:00
|
|
|
}
|
2015-10-13 14:37:45 +02:00
|
|
|
return val;
|
2015-10-13 14:37:40 +02:00
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
ObjectProperty *object_class_property_find(ObjectClass *klass, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
ObjectProperty *prop;
|
|
|
|
ObjectClass *parent_klass;
|
|
|
|
|
|
|
|
parent_klass = object_class_get_parent(klass);
|
|
|
|
if (parent_klass) {
|
|
|
|
prop = object_class_property_find(parent_klass, name, NULL);
|
|
|
|
if (prop) {
|
|
|
|
return prop;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
prop = g_hash_table_lookup(klass->properties, name);
|
|
|
|
if (!prop) {
|
|
|
|
error_setg(errp, "Property '.%s' not found", name);
|
|
|
|
}
|
|
|
|
return prop;
|
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
void object_property_del(Object *obj, const char *name, Error **errp)
|
|
|
|
{
|
2015-10-13 14:37:45 +02:00
|
|
|
ObjectProperty *prop = g_hash_table_lookup(obj->properties, name);
|
|
|
|
|
|
|
|
if (!prop) {
|
|
|
|
error_setg(errp, "Property '.%s' not found", name);
|
2011-12-23 22:34:39 +01:00
|
|
|
return;
|
|
|
|
}
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2011-12-23 22:34:39 +01:00
|
|
|
if (prop->release) {
|
|
|
|
prop->release(obj, name, prop->opaque);
|
|
|
|
}
|
2015-10-13 14:37:45 +02:00
|
|
|
g_hash_table_remove(obj->properties, name);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_get(Object *obj, Visitor *v, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
2012-04-12 18:00:18 +02:00
|
|
|
ObjectProperty *prop = object_property_find(obj, name, errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
if (prop == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!prop->get) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_PERMISSION_DENIED);
|
2012-01-30 15:55:55 +01:00
|
|
|
} else {
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
prop->get(obj, v, name, prop->opaque, errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_set(Object *obj, Visitor *v, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
2012-04-12 18:00:18 +02:00
|
|
|
ObjectProperty *prop = object_property_find(obj, name, errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
if (prop == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!prop->set) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_PERMISSION_DENIED);
|
2012-01-30 15:55:55 +01:00
|
|
|
} else {
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
prop->set(obj, v, name, prop->opaque, errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-01 17:16:22 +01:00
|
|
|
void object_property_set_str(Object *obj, const char *value,
|
|
|
|
const char *name, Error **errp)
|
|
|
|
{
|
|
|
|
QString *qstr = qstring_from_str(value);
|
|
|
|
object_property_set_qobject(obj, QOBJECT(qstr), name, errp);
|
|
|
|
|
|
|
|
QDECREF(qstr);
|
|
|
|
}
|
|
|
|
|
|
|
|
char *object_property_get_str(Object *obj, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QObject *ret = object_property_get_qobject(obj, name, errp);
|
|
|
|
QString *qstring;
|
|
|
|
char *retval;
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
qstring = qobject_to_qstring(ret);
|
|
|
|
if (!qstring) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
|
2012-02-01 17:16:22 +01:00
|
|
|
retval = NULL;
|
|
|
|
} else {
|
|
|
|
retval = g_strdup(qstring_get_str(qstring));
|
|
|
|
}
|
|
|
|
|
|
|
|
QDECREF(qstring);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2012-02-02 10:51:57 +01:00
|
|
|
void object_property_set_link(Object *obj, Object *value,
|
|
|
|
const char *name, Error **errp)
|
|
|
|
{
|
2014-09-26 07:19:19 +02:00
|
|
|
if (value) {
|
|
|
|
gchar *path = object_get_canonical_path(value);
|
|
|
|
object_property_set_str(obj, path, name, errp);
|
|
|
|
g_free(path);
|
|
|
|
} else {
|
|
|
|
object_property_set_str(obj, "", name, errp);
|
|
|
|
}
|
2012-02-02 10:51:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Object *object_property_get_link(Object *obj, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
char *str = object_property_get_str(obj, name, errp);
|
|
|
|
Object *target = NULL;
|
|
|
|
|
|
|
|
if (str && *str) {
|
|
|
|
target = object_resolve_path(str, NULL);
|
|
|
|
if (!target) {
|
2015-03-16 08:57:47 +01:00
|
|
|
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
|
|
|
|
"Device '%s' not found", str);
|
2012-02-02 10:51:57 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free(str);
|
|
|
|
return target;
|
|
|
|
}
|
|
|
|
|
2012-02-01 17:16:22 +01:00
|
|
|
void object_property_set_bool(Object *obj, bool value,
|
|
|
|
const char *name, Error **errp)
|
|
|
|
{
|
2015-05-16 00:24:59 +02:00
|
|
|
QBool *qbool = qbool_from_bool(value);
|
2012-02-01 17:16:22 +01:00
|
|
|
object_property_set_qobject(obj, QOBJECT(qbool), name, errp);
|
|
|
|
|
|
|
|
QDECREF(qbool);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool object_property_get_bool(Object *obj, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QObject *ret = object_property_get_qobject(obj, name, errp);
|
|
|
|
QBool *qbool;
|
|
|
|
bool retval;
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
qbool = qobject_to_qbool(ret);
|
|
|
|
if (!qbool) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean");
|
2012-02-01 17:16:22 +01:00
|
|
|
retval = false;
|
|
|
|
} else {
|
2015-05-16 00:24:59 +02:00
|
|
|
retval = qbool_get_bool(qbool);
|
2012-02-01 17:16:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
QDECREF(qbool);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_set_int(Object *obj, int64_t value,
|
|
|
|
const char *name, Error **errp)
|
|
|
|
{
|
|
|
|
QInt *qint = qint_from_int(value);
|
|
|
|
object_property_set_qobject(obj, QOBJECT(qint), name, errp);
|
|
|
|
|
|
|
|
QDECREF(qint);
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t object_property_get_int(Object *obj, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QObject *ret = object_property_get_qobject(obj, name, errp);
|
|
|
|
QInt *qint;
|
|
|
|
int64_t retval;
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
qint = qobject_to_qint(ret);
|
|
|
|
if (!qint) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "int");
|
2012-02-01 17:16:22 +01:00
|
|
|
retval = -1;
|
|
|
|
} else {
|
|
|
|
retval = qint_get_int(qint);
|
|
|
|
}
|
|
|
|
|
|
|
|
QDECREF(qint);
|
|
|
|
return retval;
|
2012-02-09 09:52:59 +01:00
|
|
|
}
|
|
|
|
|
qom: Add an object_property_add_enum() helper function
A QOM property can be parsed as enum using the visit_type_enum()
helper function, but this forces callers to use the more complex
generic object_property_add() method when registering it. It
also requires that users of that object have access to the
string map when they want to read the property value.
This patch introduces a specialized object_property_add_enum()
method which simplifies the use of enum properties, so the
setters/getters directly get passed the int value.
typedef enum {
MYDEV_TYPE_FROG,
MYDEV_TYPE_ALLIGATOR,
MYDEV_TYPE_PLATYPUS,
MYDEV_TYPE_LAST
} MyDevType;
Then provide a table of enum <-> string mappings
static const char *const mydevtypemap[MYDEV_TYPE_LAST + 1] = {
[MYDEV_TYPE_FROG] = "frog",
[MYDEV_TYPE_ALLIGATOR] = "alligator",
[MYDEV_TYPE_PLATYPUS] = "platypus",
[MYDEV_TYPE_LAST] = NULL,
};
Assuming an object struct of
typedef struct {
Object parent_obj;
MyDevType devtype;
...other fields...
} MyDev;
The property can then be registered as follows:
static int mydev_prop_get_devtype(Object *obj,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
return dev->devtype;
}
static void mydev_prop_set_devtype(Object *obj,
int value,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
dev->devtype = value;
}
object_property_add_enum(obj, "devtype",
mydevtypemap, "MyDevType",
mydev_prop_get_devtype,
mydev_prop_set_devtype,
NULL);
Note there is no need to check the range of 'value' in
the setter, because the string->enum conversion code will
have already done that and reported an error as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:08 +02:00
|
|
|
typedef struct EnumProperty {
|
|
|
|
const char * const *strings;
|
|
|
|
int (*get)(Object *, Error **);
|
|
|
|
void (*set)(Object *, int, Error **);
|
|
|
|
} EnumProperty;
|
|
|
|
|
2014-05-14 11:43:33 +02:00
|
|
|
int object_property_get_enum(Object *obj, const char *name,
|
2015-05-27 17:07:56 +02:00
|
|
|
const char *typename, Error **errp)
|
2014-05-14 11:43:33 +02:00
|
|
|
{
|
2015-08-25 20:00:45 +02:00
|
|
|
Error *err = NULL;
|
2016-06-09 18:48:37 +02:00
|
|
|
Visitor *v;
|
2014-08-18 08:46:34 +02:00
|
|
|
char *str;
|
2014-05-14 11:43:33 +02:00
|
|
|
int ret;
|
2015-05-27 17:07:56 +02:00
|
|
|
ObjectProperty *prop = object_property_find(obj, name, errp);
|
|
|
|
EnumProperty *enumprop;
|
|
|
|
|
|
|
|
if (prop == NULL) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!g_str_equal(prop->type, typename)) {
|
|
|
|
error_setg(errp, "Property %s on %s is not '%s' enum type",
|
|
|
|
name, object_class_get_name(
|
|
|
|
object_get_class(obj)), typename);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
enumprop = prop->opaque;
|
2014-05-14 11:43:33 +02:00
|
|
|
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:43 +02:00
|
|
|
v = string_output_visitor_new(false, &str);
|
2016-06-09 18:48:39 +02:00
|
|
|
object_property_get(obj, v, name, &err);
|
2015-08-25 20:00:45 +02:00
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
2016-06-09 18:48:39 +02:00
|
|
|
visit_free(v);
|
2015-08-25 20:00:45 +02:00
|
|
|
return 0;
|
|
|
|
}
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:43 +02:00
|
|
|
visit_complete(v, &str);
|
2016-06-09 18:48:39 +02:00
|
|
|
visit_free(v);
|
2016-06-09 18:48:37 +02:00
|
|
|
v = string_input_visitor_new(str);
|
|
|
|
visit_type_enum(v, name, &ret, enumprop->strings, errp);
|
2014-08-18 08:46:34 +02:00
|
|
|
|
|
|
|
g_free(str);
|
2016-06-09 18:48:37 +02:00
|
|
|
visit_free(v);
|
2014-05-14 11:43:33 +02:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_get_uint16List(Object *obj, const char *name,
|
|
|
|
uint16List **list, Error **errp)
|
|
|
|
{
|
2015-08-25 20:00:45 +02:00
|
|
|
Error *err = NULL;
|
2016-06-09 18:48:37 +02:00
|
|
|
Visitor *v;
|
2014-08-18 08:46:34 +02:00
|
|
|
char *str;
|
2014-05-14 11:43:33 +02:00
|
|
|
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:43 +02:00
|
|
|
v = string_output_visitor_new(false, &str);
|
|
|
|
object_property_get(obj, v, name, &err);
|
2015-08-25 20:00:45 +02:00
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
|
|
|
goto out;
|
|
|
|
}
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:43 +02:00
|
|
|
visit_complete(v, &str);
|
|
|
|
visit_free(v);
|
2016-06-09 18:48:37 +02:00
|
|
|
v = string_input_visitor_new(str);
|
|
|
|
visit_type_uint16List(v, NULL, list, errp);
|
2014-08-18 08:46:34 +02:00
|
|
|
|
|
|
|
g_free(str);
|
2015-08-25 20:00:45 +02:00
|
|
|
out:
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:43 +02:00
|
|
|
visit_free(v);
|
2014-05-14 11:43:33 +02:00
|
|
|
}
|
|
|
|
|
2012-02-09 09:52:59 +01:00
|
|
|
void object_property_parse(Object *obj, const char *string,
|
|
|
|
const char *name, Error **errp)
|
|
|
|
{
|
2016-06-09 18:48:37 +02:00
|
|
|
Visitor *v = string_input_visitor_new(string);
|
|
|
|
object_property_set(obj, v, name, errp);
|
|
|
|
visit_free(v);
|
2012-02-09 09:52:59 +01:00
|
|
|
}
|
|
|
|
|
2014-02-08 11:01:50 +01:00
|
|
|
char *object_property_print(Object *obj, const char *name, bool human,
|
2012-02-09 09:52:59 +01:00
|
|
|
Error **errp)
|
|
|
|
{
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:43 +02:00
|
|
|
Visitor *v;
|
2014-09-27 07:13:55 +02:00
|
|
|
char *string = NULL;
|
|
|
|
Error *local_err = NULL;
|
2012-02-09 09:52:59 +01:00
|
|
|
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:43 +02:00
|
|
|
v = string_output_visitor_new(human, &string);
|
|
|
|
object_property_get(obj, v, name, &local_err);
|
2014-09-27 07:13:55 +02:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:43 +02:00
|
|
|
visit_complete(v, &string);
|
2014-09-27 07:13:55 +02:00
|
|
|
|
|
|
|
out:
|
qapi: Add new visit_complete() function
Making each output visitor provide its own output collection
function was the only remaining reason for exposing visitor
sub-types to the rest of the code base. Add a polymorphic
visit_complete() function which is a no-op for input visitors,
and which populates an opaque pointer for output visitors. For
maximum type-safety, also add a parameter to the output visitor
constructors with a type-correct version of the output pointer,
and assert that the two uses match.
This approach was considered superior to either passing the
output parameter only during construction (action at a distance
during visit_free() feels awkward) or only during visit_complete()
(defeating type safety makes it easier to use incorrectly).
Most callers were function-local, and therefore a mechanical
conversion; the testsuite was a bit trickier, but the previous
cleanup patch minimized the churn here.
The visit_complete() function may be called at most once; doing
so lets us use transfer semantics rather than duplication or
ref-count semantics to get the just-built output back to the
caller, even though it means our behavior is not idempotent.
Generated code is simplified as follows for events:
|@@ -26,7 +26,7 @@ void qapi_event_send_acpi_device_ost(ACP
| QDict *qmp;
| Error *err = NULL;
| QMPEventFuncEmit emit;
|- QmpOutputVisitor *qov;
|+ QObject *obj;
| Visitor *v;
| q_obj_ACPI_DEVICE_OST_arg param = {
| info
|@@ -39,8 +39,7 @@ void qapi_event_send_acpi_device_ost(ACP
|
| qmp = qmp_event_build_dict("ACPI_DEVICE_OST");
|
|- qov = qmp_output_visitor_new();
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(&obj);
|
| visit_start_struct(v, "ACPI_DEVICE_OST", NULL, 0, &err);
| if (err) {
|@@ -55,7 +54,8 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
|
|- qdict_put_obj(qmp, "data", qmp_output_get_qobject(qov));
|+ visit_complete(v, &obj);
|+ qdict_put_obj(qmp, "data", obj);
| emit(QAPI_EVENT_ACPI_DEVICE_OST, qmp, &err);
and for commands:
| {
| Error *err = NULL;
|- QmpOutputVisitor *qov = qmp_output_visitor_new();
| Visitor *v;
|
|- v = qmp_output_get_visitor(qov);
|+ v = qmp_output_visitor_new(ret_out);
| visit_type_AddfdInfo(v, "unused", &ret_in, &err);
|- if (err) {
|- goto out;
|+ if (!err) {
|+ visit_complete(v, ret_out);
| }
|- *ret_out = qmp_output_get_qobject(qov);
|-
|-out:
| error_propagate(errp, err);
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:43 +02:00
|
|
|
visit_free(v);
|
2012-02-09 09:52:59 +01:00
|
|
|
return string;
|
2012-02-01 17:16:22 +01:00
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
const char *object_property_get_type(Object *obj, const char *name, Error **errp)
|
|
|
|
{
|
2012-04-12 18:00:18 +02:00
|
|
|
ObjectProperty *prop = object_property_find(obj, name, errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
if (prop == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return prop->type;
|
|
|
|
}
|
|
|
|
|
|
|
|
Object *object_get_root(void)
|
|
|
|
{
|
2011-12-23 16:08:05 +01:00
|
|
|
static Object *root;
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2011-12-23 16:08:05 +01:00
|
|
|
if (!root) {
|
|
|
|
root = object_new("container");
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
2011-12-23 16:08:05 +01:00
|
|
|
return root;
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
2015-05-13 18:14:05 +02:00
|
|
|
Object *object_get_objects_root(void)
|
|
|
|
{
|
|
|
|
return container_get(object_get_root(), "/objects");
|
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void object_get_child_property(Object *obj, Visitor *v,
|
|
|
|
const char *name, void *opaque,
|
|
|
|
Error **errp)
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
|
|
|
Object *child = opaque;
|
|
|
|
gchar *path;
|
|
|
|
|
|
|
|
path = object_get_canonical_path(child);
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_str(v, name, &path, errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
g_free(path);
|
|
|
|
}
|
|
|
|
|
2014-06-05 13:11:51 +02:00
|
|
|
static Object *object_resolve_child_property(Object *parent, void *opaque, const gchar *part)
|
|
|
|
{
|
|
|
|
return opaque;
|
|
|
|
}
|
|
|
|
|
2011-12-23 15:47:39 +01:00
|
|
|
static void object_finalize_child_property(Object *obj, const char *name,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
Object *child = opaque;
|
|
|
|
|
2014-06-11 11:57:38 +02:00
|
|
|
if (child->class->unparent) {
|
|
|
|
(child->class->unparent)(child);
|
|
|
|
}
|
|
|
|
child->parent = NULL;
|
2011-12-23 15:47:39 +01:00
|
|
|
object_unref(child);
|
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
void object_property_add_child(Object *obj, const char *name,
|
|
|
|
Object *child, Error **errp)
|
|
|
|
{
|
2013-12-20 23:21:08 +01:00
|
|
|
Error *local_err = NULL;
|
2012-01-30 15:55:55 +01:00
|
|
|
gchar *type;
|
2014-06-05 13:11:51 +02:00
|
|
|
ObjectProperty *op;
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2014-09-26 07:19:52 +02:00
|
|
|
if (child->parent != NULL) {
|
|
|
|
error_setg(errp, "child object is already parented");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
type = g_strdup_printf("child<%s>", object_get_typename(OBJECT(child)));
|
|
|
|
|
2014-06-05 13:11:51 +02:00
|
|
|
op = object_property_add(obj, name, type, object_get_child_property, NULL,
|
|
|
|
object_finalize_child_property, child, &local_err);
|
2013-12-20 23:21:08 +01:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
goto out;
|
|
|
|
}
|
2014-06-05 13:11:51 +02:00
|
|
|
|
|
|
|
op->resolve = object_resolve_child_property;
|
2012-01-30 15:55:55 +01:00
|
|
|
object_ref(child);
|
|
|
|
child->parent = obj;
|
|
|
|
|
2013-12-20 23:21:08 +01:00
|
|
|
out:
|
2012-01-30 15:55:55 +01:00
|
|
|
g_free(type);
|
|
|
|
}
|
|
|
|
|
2014-03-19 08:58:56 +01:00
|
|
|
void object_property_allow_set_link(Object *obj, const char *name,
|
|
|
|
Object *val, Error **errp)
|
|
|
|
{
|
|
|
|
/* Allow the link to be set, always */
|
|
|
|
}
|
|
|
|
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
typedef struct {
|
|
|
|
Object **child;
|
2014-03-19 08:58:56 +01:00
|
|
|
void (*check)(Object *, const char *, Object *, Error **);
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
ObjectPropertyLinkFlags flags;
|
|
|
|
} LinkProperty;
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void object_get_link_property(Object *obj, Visitor *v,
|
|
|
|
const char *name, void *opaque,
|
|
|
|
Error **errp)
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
LinkProperty *lprop = opaque;
|
|
|
|
Object **child = lprop->child;
|
2012-01-30 15:55:55 +01:00
|
|
|
gchar *path;
|
|
|
|
|
|
|
|
if (*child) {
|
|
|
|
path = object_get_canonical_path(*child);
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_str(v, name, &path, errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
g_free(path);
|
|
|
|
} else {
|
|
|
|
path = (gchar *)"";
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_str(v, name, &path, errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-19 08:58:53 +01:00
|
|
|
/*
|
|
|
|
* object_resolve_link:
|
|
|
|
*
|
|
|
|
* Lookup an object and ensure its type matches the link property type. This
|
|
|
|
* is similar to object_resolve_path() except type verification against the
|
|
|
|
* link property is performed.
|
|
|
|
*
|
|
|
|
* Returns: The matched object or NULL on path lookup failures.
|
|
|
|
*/
|
|
|
|
static Object *object_resolve_link(Object *obj, const char *name,
|
|
|
|
const char *path, Error **errp)
|
|
|
|
{
|
|
|
|
const char *type;
|
|
|
|
gchar *target_type;
|
|
|
|
bool ambiguous = false;
|
|
|
|
Object *target;
|
|
|
|
|
|
|
|
/* Go from link<FOO> to FOO. */
|
|
|
|
type = object_property_get_type(obj, name, NULL);
|
|
|
|
target_type = g_strndup(&type[5], strlen(type) - 6);
|
|
|
|
target = object_resolve_path_type(path, target_type, &ambiguous);
|
|
|
|
|
|
|
|
if (ambiguous) {
|
2015-11-11 07:51:20 +01:00
|
|
|
error_setg(errp, "Path '%s' does not uniquely identify an object",
|
|
|
|
path);
|
2014-03-19 08:58:53 +01:00
|
|
|
} else if (!target) {
|
|
|
|
target = object_resolve_path(path, &ambiguous);
|
|
|
|
if (target || ambiguous) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, target_type);
|
2014-03-19 08:58:53 +01:00
|
|
|
} else {
|
2015-03-16 08:57:47 +01:00
|
|
|
error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
|
|
|
|
"Device '%s' not found", path);
|
2014-03-19 08:58:53 +01:00
|
|
|
}
|
|
|
|
target = NULL;
|
|
|
|
}
|
|
|
|
g_free(target_type);
|
|
|
|
|
|
|
|
return target;
|
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void object_set_link_property(Object *obj, Visitor *v,
|
|
|
|
const char *name, void *opaque,
|
|
|
|
Error **errp)
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
2014-03-19 08:58:54 +01:00
|
|
|
Error *local_err = NULL;
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
LinkProperty *prop = opaque;
|
|
|
|
Object **child = prop->child;
|
2014-03-19 08:58:54 +01:00
|
|
|
Object *old_target = *child;
|
|
|
|
Object *new_target = NULL;
|
|
|
|
char *path = NULL;
|
2012-01-30 15:55:55 +01:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_str(v, name, &path, &local_err);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2014-03-19 08:58:54 +01:00
|
|
|
if (!local_err && strcmp(path, "") != 0) {
|
|
|
|
new_target = object_resolve_link(obj, name, path, &local_err);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
g_free(path);
|
2014-03-19 08:58:54 +01:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2012-02-22 18:22:26 +01:00
|
|
|
|
2014-03-19 08:58:56 +01:00
|
|
|
prop->check(obj, name, new_target, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-06-06 08:13:36 +02:00
|
|
|
object_ref(new_target);
|
2014-03-19 08:58:54 +01:00
|
|
|
*child = new_target;
|
2014-06-06 08:13:36 +02:00
|
|
|
object_unref(old_target);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
2014-06-05 13:11:51 +02:00
|
|
|
static Object *object_resolve_link_property(Object *parent, void *opaque, const gchar *part)
|
|
|
|
{
|
|
|
|
LinkProperty *lprop = opaque;
|
|
|
|
|
|
|
|
return *lprop->child;
|
|
|
|
}
|
|
|
|
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
static void object_release_link_property(Object *obj, const char *name,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
LinkProperty *prop = opaque;
|
|
|
|
|
|
|
|
if ((prop->flags & OBJ_PROP_LINK_UNREF_ON_RELEASE) && *prop->child) {
|
|
|
|
object_unref(*prop->child);
|
|
|
|
}
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
void object_property_add_link(Object *obj, const char *name,
|
|
|
|
const char *type, Object **child,
|
2014-03-19 08:58:56 +01:00
|
|
|
void (*check)(Object *, const char *,
|
|
|
|
Object *, Error **),
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
ObjectPropertyLinkFlags flags,
|
2012-01-30 15:55:55 +01:00
|
|
|
Error **errp)
|
|
|
|
{
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
Error *local_err = NULL;
|
|
|
|
LinkProperty *prop = g_malloc(sizeof(*prop));
|
2012-01-30 15:55:55 +01:00
|
|
|
gchar *full_type;
|
2014-06-05 13:11:51 +02:00
|
|
|
ObjectProperty *op;
|
2012-01-30 15:55:55 +01:00
|
|
|
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
prop->child = child;
|
2014-03-19 08:58:56 +01:00
|
|
|
prop->check = check;
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
prop->flags = flags;
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
full_type = g_strdup_printf("link<%s>", type);
|
|
|
|
|
2014-06-05 13:11:51 +02:00
|
|
|
op = object_property_add(obj, name, full_type,
|
|
|
|
object_get_link_property,
|
|
|
|
check ? object_set_link_property : NULL,
|
|
|
|
object_release_link_property,
|
|
|
|
prop,
|
|
|
|
&local_err);
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
2014-06-05 13:11:51 +02:00
|
|
|
goto out;
|
qom: Make QOM link property unref optional
Some object_property_add_link() callers expect property deletion to
unref the link property object. Other callers expect to manage the
refcount themselves. The former are currently broken and therefore leak
the link property object.
This patch adds a flags argument to object_property_add_link() so the
caller can specify which refcount behavior they require. The new
OBJ_PROP_LINK_UNREF_ON_RELEASE flag causes the link pointer to be
unreferenced when the property is deleted.
This fixes refcount leaks in qdev.c, xilinx_axidma.c, xilinx_axienet.c,
s390-virtio-bus.c, virtio-pci.c, virtio-rng.c, and ui/console.c.
Rationale for refcount behavior:
* hw/core/qdev.c
- bus children are explicitly unreferenced, don't interfere
- parent_bus is essentially a read-only property that doesn't hold a
refcount, don't unref
- hotplug_handler is leaked, do unref
* hw/dma/xilinx_axidma.c
- rx stream "dma" links are set using set_link, therefore they
need unref
- tx streams are set using set_link, therefore they need unref
* hw/net/xilinx_axienet.c
- same reasoning as hw/dma/xilinx_axidma.c
* hw/pcmcia/pxa2xx.c
- pxa2xx bypasses set_link and therefore does not use refcounts
* hw/s390x/s390-virtio-bus.c
* hw/virtio/virtio-pci.c
* hw/virtio/virtio-rng.c
* ui/console.c
- set_link is used and there is no explicit unref, do unref
Cc: Peter Crosthwaite <peter.crosthwaite@petalogix.com>
Cc: Alexander Graf <agraf@suse.de>
Cc: Anthony Liguori <aliguori@amazon.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2014-03-19 08:58:55 +01:00
|
|
|
}
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2014-06-05 13:11:51 +02:00
|
|
|
op->resolve = object_resolve_link_property;
|
|
|
|
|
|
|
|
out:
|
2012-01-30 15:55:55 +01:00
|
|
|
g_free(full_type);
|
|
|
|
}
|
|
|
|
|
2015-05-05 18:29:00 +02:00
|
|
|
void object_property_add_const_link(Object *obj, const char *name,
|
|
|
|
Object *target, Error **errp)
|
|
|
|
{
|
|
|
|
char *link_type;
|
|
|
|
ObjectProperty *op;
|
|
|
|
|
|
|
|
link_type = g_strdup_printf("link<%s>", object_get_typename(target));
|
|
|
|
op = object_property_add(obj, name, link_type,
|
|
|
|
object_get_child_property, NULL,
|
|
|
|
NULL, target, errp);
|
|
|
|
if (op != NULL) {
|
|
|
|
op->resolve = object_resolve_child_property;
|
|
|
|
}
|
|
|
|
g_free(link_type);
|
|
|
|
}
|
|
|
|
|
2014-03-03 11:30:02 +01:00
|
|
|
gchar *object_get_canonical_path_component(Object *obj)
|
|
|
|
{
|
|
|
|
ObjectProperty *prop = NULL;
|
2015-10-13 14:37:45 +02:00
|
|
|
GHashTableIter iter;
|
2014-03-03 11:30:02 +01:00
|
|
|
|
|
|
|
g_assert(obj);
|
|
|
|
g_assert(obj->parent != NULL);
|
|
|
|
|
2015-10-13 14:37:45 +02:00
|
|
|
g_hash_table_iter_init(&iter, obj->parent->properties);
|
|
|
|
while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
|
2014-03-03 11:30:02 +01:00
|
|
|
if (!object_property_is_child(prop)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prop->opaque == obj) {
|
|
|
|
return g_strdup(prop->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* obj had a parent but was not a child, should never happen */
|
|
|
|
g_assert_not_reached();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
gchar *object_get_canonical_path(Object *obj)
|
|
|
|
{
|
|
|
|
Object *root = object_get_root();
|
2014-03-03 11:30:02 +01:00
|
|
|
char *newpath, *path = NULL;
|
2012-01-30 15:55:55 +01:00
|
|
|
|
|
|
|
while (obj != root) {
|
2014-03-03 11:30:02 +01:00
|
|
|
char *component = object_get_canonical_path_component(obj);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2014-03-03 11:30:02 +01:00
|
|
|
if (path) {
|
|
|
|
newpath = g_strdup_printf("%s/%s", component, path);
|
|
|
|
g_free(component);
|
|
|
|
g_free(path);
|
|
|
|
path = newpath;
|
|
|
|
} else {
|
|
|
|
path = component;
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
obj = obj->parent;
|
|
|
|
}
|
|
|
|
|
2014-03-03 11:30:02 +01:00
|
|
|
newpath = g_strdup_printf("/%s", path ? path : "");
|
2012-01-30 15:55:55 +01:00
|
|
|
g_free(path);
|
|
|
|
|
|
|
|
return newpath;
|
|
|
|
}
|
|
|
|
|
2013-01-15 02:55:10 +01:00
|
|
|
Object *object_resolve_path_component(Object *parent, const gchar *part)
|
2012-03-27 18:38:45 +02:00
|
|
|
{
|
2012-04-12 18:00:18 +02:00
|
|
|
ObjectProperty *prop = object_property_find(parent, part, NULL);
|
2012-03-27 18:38:45 +02:00
|
|
|
if (prop == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-06-05 13:11:51 +02:00
|
|
|
if (prop->resolve) {
|
|
|
|
return prop->resolve(parent, prop->opaque, part);
|
2012-03-27 18:38:45 +02:00
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
static Object *object_resolve_abs_path(Object *parent,
|
|
|
|
gchar **parts,
|
2012-02-03 11:21:01 +01:00
|
|
|
const char *typename,
|
2012-01-30 15:55:55 +01:00
|
|
|
int index)
|
|
|
|
{
|
|
|
|
Object *child;
|
|
|
|
|
|
|
|
if (parts[index] == NULL) {
|
2012-02-03 11:21:01 +01:00
|
|
|
return object_dynamic_cast(parent, typename);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(parts[index], "") == 0) {
|
2012-02-03 11:21:01 +01:00
|
|
|
return object_resolve_abs_path(parent, parts, typename, index + 1);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
2012-03-27 18:38:45 +02:00
|
|
|
child = object_resolve_path_component(parent, parts[index]);
|
2012-01-30 15:55:55 +01:00
|
|
|
if (!child) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-02-03 11:21:01 +01:00
|
|
|
return object_resolve_abs_path(child, parts, typename, index + 1);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static Object *object_resolve_partial_path(Object *parent,
|
|
|
|
gchar **parts,
|
2012-02-03 11:21:01 +01:00
|
|
|
const char *typename,
|
2012-01-30 15:55:55 +01:00
|
|
|
bool *ambiguous)
|
|
|
|
{
|
|
|
|
Object *obj;
|
2015-10-13 14:37:45 +02:00
|
|
|
GHashTableIter iter;
|
2012-01-30 15:55:55 +01:00
|
|
|
ObjectProperty *prop;
|
|
|
|
|
2012-02-03 11:21:01 +01:00
|
|
|
obj = object_resolve_abs_path(parent, parts, typename, 0);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2015-10-13 14:37:45 +02:00
|
|
|
g_hash_table_iter_init(&iter, parent->properties);
|
|
|
|
while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
|
2012-01-30 15:55:55 +01:00
|
|
|
Object *found;
|
|
|
|
|
2012-05-27 00:32:40 +02:00
|
|
|
if (!object_property_is_child(prop)) {
|
2012-01-30 15:55:55 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-02-03 11:21:01 +01:00
|
|
|
found = object_resolve_partial_path(prop->opaque, parts,
|
|
|
|
typename, ambiguous);
|
2012-01-30 15:55:55 +01:00
|
|
|
if (found) {
|
|
|
|
if (obj) {
|
|
|
|
if (ambiguous) {
|
|
|
|
*ambiguous = true;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
obj = found;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ambiguous && *ambiguous) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2012-02-03 11:21:01 +01:00
|
|
|
Object *object_resolve_path_type(const char *path, const char *typename,
|
|
|
|
bool *ambiguous)
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
|
|
|
Object *obj;
|
|
|
|
gchar **parts;
|
|
|
|
|
|
|
|
parts = g_strsplit(path, "/", 0);
|
2013-04-18 18:44:02 +02:00
|
|
|
assert(parts);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2013-04-18 18:44:02 +02:00
|
|
|
if (parts[0] == NULL || strcmp(parts[0], "") != 0) {
|
2012-01-30 15:55:55 +01:00
|
|
|
if (ambiguous) {
|
|
|
|
*ambiguous = false;
|
|
|
|
}
|
2012-02-03 11:21:01 +01:00
|
|
|
obj = object_resolve_partial_path(object_get_root(), parts,
|
|
|
|
typename, ambiguous);
|
2012-01-30 15:55:55 +01:00
|
|
|
} else {
|
2012-02-03 11:21:01 +01:00
|
|
|
obj = object_resolve_abs_path(object_get_root(), parts, typename, 1);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
g_strfreev(parts);
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2012-02-03 11:21:01 +01:00
|
|
|
Object *object_resolve_path(const char *path, bool *ambiguous)
|
|
|
|
{
|
|
|
|
return object_resolve_path_type(path, TYPE_OBJECT, ambiguous);
|
|
|
|
}
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
typedef struct StringProperty
|
|
|
|
{
|
|
|
|
char *(*get)(Object *, Error **);
|
|
|
|
void (*set)(Object *, const char *, Error **);
|
|
|
|
} StringProperty;
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_get_str(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
|
|
|
StringProperty *prop = opaque;
|
|
|
|
char *value;
|
2015-08-25 20:00:46 +02:00
|
|
|
Error *err = NULL;
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2015-08-25 20:00:46 +02:00
|
|
|
value = prop->get(obj, &err);
|
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
|
|
|
return;
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
2015-08-25 20:00:46 +02:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_str(v, name, &value, errp);
|
2015-08-25 20:00:46 +02:00
|
|
|
g_free(value);
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_set_str(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
|
|
|
StringProperty *prop = opaque;
|
|
|
|
char *value;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_str(v, name, &value, &local_err);
|
2012-01-30 15:55:55 +01:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
prop->set(obj, value, errp);
|
|
|
|
g_free(value);
|
|
|
|
}
|
|
|
|
|
2012-02-01 17:16:22 +01:00
|
|
|
static void property_release_str(Object *obj, const char *name,
|
|
|
|
void *opaque)
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
|
|
|
StringProperty *prop = opaque;
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_add_str(Object *obj, const char *name,
|
|
|
|
char *(*get)(Object *, Error **),
|
|
|
|
void (*set)(Object *, const char *, Error **),
|
|
|
|
Error **errp)
|
|
|
|
{
|
2014-03-04 15:28:18 +01:00
|
|
|
Error *local_err = NULL;
|
2012-01-30 15:55:55 +01:00
|
|
|
StringProperty *prop = g_malloc0(sizeof(*prop));
|
|
|
|
|
|
|
|
prop->get = get;
|
|
|
|
prop->set = set;
|
|
|
|
|
|
|
|
object_property_add(obj, name, "string",
|
2012-02-01 17:16:22 +01:00
|
|
|
get ? property_get_str : NULL,
|
|
|
|
set ? property_set_str : NULL,
|
|
|
|
property_release_str,
|
2014-03-04 15:28:18 +01:00
|
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
|
|
|
}
|
2012-01-30 15:55:55 +01:00
|
|
|
}
|
2012-03-31 16:45:54 +02:00
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_add_str(ObjectClass *klass, const char *name,
|
|
|
|
char *(*get)(Object *, Error **),
|
|
|
|
void (*set)(Object *, const char *,
|
|
|
|
Error **),
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
StringProperty *prop = g_malloc0(sizeof(*prop));
|
|
|
|
|
|
|
|
prop->get = get;
|
|
|
|
prop->set = set;
|
|
|
|
|
|
|
|
object_class_property_add(klass, name, "string",
|
|
|
|
get ? property_get_str : NULL,
|
|
|
|
set ? property_set_str : NULL,
|
|
|
|
property_release_str,
|
|
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-25 17:32:46 +02:00
|
|
|
typedef struct BoolProperty
|
|
|
|
{
|
|
|
|
bool (*get)(Object *, Error **);
|
|
|
|
void (*set)(Object *, bool, Error **);
|
|
|
|
} BoolProperty;
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_get_bool(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2012-06-25 17:32:46 +02:00
|
|
|
{
|
|
|
|
BoolProperty *prop = opaque;
|
|
|
|
bool value;
|
2015-08-25 20:00:45 +02:00
|
|
|
Error *err = NULL;
|
|
|
|
|
|
|
|
value = prop->get(obj, &err);
|
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
|
|
|
return;
|
|
|
|
}
|
2012-06-25 17:32:46 +02:00
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_bool(v, name, &value, errp);
|
2012-06-25 17:32:46 +02:00
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_set_bool(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2012-06-25 17:32:46 +02:00
|
|
|
{
|
|
|
|
BoolProperty *prop = opaque;
|
|
|
|
bool value;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_bool(v, name, &value, &local_err);
|
2012-06-25 17:32:46 +02:00
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
prop->set(obj, value, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void property_release_bool(Object *obj, const char *name,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
BoolProperty *prop = opaque;
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_add_bool(Object *obj, const char *name,
|
|
|
|
bool (*get)(Object *, Error **),
|
|
|
|
void (*set)(Object *, bool, Error **),
|
|
|
|
Error **errp)
|
|
|
|
{
|
2014-03-04 15:28:18 +01:00
|
|
|
Error *local_err = NULL;
|
2012-06-25 17:32:46 +02:00
|
|
|
BoolProperty *prop = g_malloc0(sizeof(*prop));
|
|
|
|
|
|
|
|
prop->get = get;
|
|
|
|
prop->set = set;
|
|
|
|
|
|
|
|
object_property_add(obj, name, "bool",
|
|
|
|
get ? property_get_bool : NULL,
|
|
|
|
set ? property_set_bool : NULL,
|
|
|
|
property_release_bool,
|
2014-03-04 15:28:18 +01:00
|
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
|
|
|
}
|
2012-06-25 17:32:46 +02:00
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_add_bool(ObjectClass *klass, const char *name,
|
|
|
|
bool (*get)(Object *, Error **),
|
|
|
|
void (*set)(Object *, bool, Error **),
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
BoolProperty *prop = g_malloc0(sizeof(*prop));
|
|
|
|
|
|
|
|
prop->get = get;
|
|
|
|
prop->set = set;
|
|
|
|
|
|
|
|
object_class_property_add(klass, name, "bool",
|
|
|
|
get ? property_get_bool : NULL,
|
|
|
|
set ? property_set_bool : NULL,
|
|
|
|
property_release_bool,
|
|
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_get_enum(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
qom: Add an object_property_add_enum() helper function
A QOM property can be parsed as enum using the visit_type_enum()
helper function, but this forces callers to use the more complex
generic object_property_add() method when registering it. It
also requires that users of that object have access to the
string map when they want to read the property value.
This patch introduces a specialized object_property_add_enum()
method which simplifies the use of enum properties, so the
setters/getters directly get passed the int value.
typedef enum {
MYDEV_TYPE_FROG,
MYDEV_TYPE_ALLIGATOR,
MYDEV_TYPE_PLATYPUS,
MYDEV_TYPE_LAST
} MyDevType;
Then provide a table of enum <-> string mappings
static const char *const mydevtypemap[MYDEV_TYPE_LAST + 1] = {
[MYDEV_TYPE_FROG] = "frog",
[MYDEV_TYPE_ALLIGATOR] = "alligator",
[MYDEV_TYPE_PLATYPUS] = "platypus",
[MYDEV_TYPE_LAST] = NULL,
};
Assuming an object struct of
typedef struct {
Object parent_obj;
MyDevType devtype;
...other fields...
} MyDev;
The property can then be registered as follows:
static int mydev_prop_get_devtype(Object *obj,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
return dev->devtype;
}
static void mydev_prop_set_devtype(Object *obj,
int value,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
dev->devtype = value;
}
object_property_add_enum(obj, "devtype",
mydevtypemap, "MyDevType",
mydev_prop_get_devtype,
mydev_prop_set_devtype,
NULL);
Note there is no need to check the range of 'value' in
the setter, because the string->enum conversion code will
have already done that and reported an error as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:08 +02:00
|
|
|
{
|
|
|
|
EnumProperty *prop = opaque;
|
|
|
|
int value;
|
2015-08-25 20:00:45 +02:00
|
|
|
Error *err = NULL;
|
|
|
|
|
|
|
|
value = prop->get(obj, &err);
|
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
|
|
|
return;
|
|
|
|
}
|
qom: Add an object_property_add_enum() helper function
A QOM property can be parsed as enum using the visit_type_enum()
helper function, but this forces callers to use the more complex
generic object_property_add() method when registering it. It
also requires that users of that object have access to the
string map when they want to read the property value.
This patch introduces a specialized object_property_add_enum()
method which simplifies the use of enum properties, so the
setters/getters directly get passed the int value.
typedef enum {
MYDEV_TYPE_FROG,
MYDEV_TYPE_ALLIGATOR,
MYDEV_TYPE_PLATYPUS,
MYDEV_TYPE_LAST
} MyDevType;
Then provide a table of enum <-> string mappings
static const char *const mydevtypemap[MYDEV_TYPE_LAST + 1] = {
[MYDEV_TYPE_FROG] = "frog",
[MYDEV_TYPE_ALLIGATOR] = "alligator",
[MYDEV_TYPE_PLATYPUS] = "platypus",
[MYDEV_TYPE_LAST] = NULL,
};
Assuming an object struct of
typedef struct {
Object parent_obj;
MyDevType devtype;
...other fields...
} MyDev;
The property can then be registered as follows:
static int mydev_prop_get_devtype(Object *obj,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
return dev->devtype;
}
static void mydev_prop_set_devtype(Object *obj,
int value,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
dev->devtype = value;
}
object_property_add_enum(obj, "devtype",
mydevtypemap, "MyDevType",
mydev_prop_get_devtype,
mydev_prop_set_devtype,
NULL);
Note there is no need to check the range of 'value' in
the setter, because the string->enum conversion code will
have already done that and reported an error as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:08 +02:00
|
|
|
|
2016-01-29 14:48:57 +01:00
|
|
|
visit_type_enum(v, name, &value, prop->strings, errp);
|
qom: Add an object_property_add_enum() helper function
A QOM property can be parsed as enum using the visit_type_enum()
helper function, but this forces callers to use the more complex
generic object_property_add() method when registering it. It
also requires that users of that object have access to the
string map when they want to read the property value.
This patch introduces a specialized object_property_add_enum()
method which simplifies the use of enum properties, so the
setters/getters directly get passed the int value.
typedef enum {
MYDEV_TYPE_FROG,
MYDEV_TYPE_ALLIGATOR,
MYDEV_TYPE_PLATYPUS,
MYDEV_TYPE_LAST
} MyDevType;
Then provide a table of enum <-> string mappings
static const char *const mydevtypemap[MYDEV_TYPE_LAST + 1] = {
[MYDEV_TYPE_FROG] = "frog",
[MYDEV_TYPE_ALLIGATOR] = "alligator",
[MYDEV_TYPE_PLATYPUS] = "platypus",
[MYDEV_TYPE_LAST] = NULL,
};
Assuming an object struct of
typedef struct {
Object parent_obj;
MyDevType devtype;
...other fields...
} MyDev;
The property can then be registered as follows:
static int mydev_prop_get_devtype(Object *obj,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
return dev->devtype;
}
static void mydev_prop_set_devtype(Object *obj,
int value,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
dev->devtype = value;
}
object_property_add_enum(obj, "devtype",
mydevtypemap, "MyDevType",
mydev_prop_get_devtype,
mydev_prop_set_devtype,
NULL);
Note there is no need to check the range of 'value' in
the setter, because the string->enum conversion code will
have already done that and reported an error as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:08 +02:00
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_set_enum(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
qom: Add an object_property_add_enum() helper function
A QOM property can be parsed as enum using the visit_type_enum()
helper function, but this forces callers to use the more complex
generic object_property_add() method when registering it. It
also requires that users of that object have access to the
string map when they want to read the property value.
This patch introduces a specialized object_property_add_enum()
method which simplifies the use of enum properties, so the
setters/getters directly get passed the int value.
typedef enum {
MYDEV_TYPE_FROG,
MYDEV_TYPE_ALLIGATOR,
MYDEV_TYPE_PLATYPUS,
MYDEV_TYPE_LAST
} MyDevType;
Then provide a table of enum <-> string mappings
static const char *const mydevtypemap[MYDEV_TYPE_LAST + 1] = {
[MYDEV_TYPE_FROG] = "frog",
[MYDEV_TYPE_ALLIGATOR] = "alligator",
[MYDEV_TYPE_PLATYPUS] = "platypus",
[MYDEV_TYPE_LAST] = NULL,
};
Assuming an object struct of
typedef struct {
Object parent_obj;
MyDevType devtype;
...other fields...
} MyDev;
The property can then be registered as follows:
static int mydev_prop_get_devtype(Object *obj,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
return dev->devtype;
}
static void mydev_prop_set_devtype(Object *obj,
int value,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
dev->devtype = value;
}
object_property_add_enum(obj, "devtype",
mydevtypemap, "MyDevType",
mydev_prop_get_devtype,
mydev_prop_set_devtype,
NULL);
Note there is no need to check the range of 'value' in
the setter, because the string->enum conversion code will
have already done that and reported an error as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:08 +02:00
|
|
|
{
|
|
|
|
EnumProperty *prop = opaque;
|
|
|
|
int value;
|
2015-08-25 20:00:45 +02:00
|
|
|
Error *err = NULL;
|
qom: Add an object_property_add_enum() helper function
A QOM property can be parsed as enum using the visit_type_enum()
helper function, but this forces callers to use the more complex
generic object_property_add() method when registering it. It
also requires that users of that object have access to the
string map when they want to read the property value.
This patch introduces a specialized object_property_add_enum()
method which simplifies the use of enum properties, so the
setters/getters directly get passed the int value.
typedef enum {
MYDEV_TYPE_FROG,
MYDEV_TYPE_ALLIGATOR,
MYDEV_TYPE_PLATYPUS,
MYDEV_TYPE_LAST
} MyDevType;
Then provide a table of enum <-> string mappings
static const char *const mydevtypemap[MYDEV_TYPE_LAST + 1] = {
[MYDEV_TYPE_FROG] = "frog",
[MYDEV_TYPE_ALLIGATOR] = "alligator",
[MYDEV_TYPE_PLATYPUS] = "platypus",
[MYDEV_TYPE_LAST] = NULL,
};
Assuming an object struct of
typedef struct {
Object parent_obj;
MyDevType devtype;
...other fields...
} MyDev;
The property can then be registered as follows:
static int mydev_prop_get_devtype(Object *obj,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
return dev->devtype;
}
static void mydev_prop_set_devtype(Object *obj,
int value,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
dev->devtype = value;
}
object_property_add_enum(obj, "devtype",
mydevtypemap, "MyDevType",
mydev_prop_get_devtype,
mydev_prop_set_devtype,
NULL);
Note there is no need to check the range of 'value' in
the setter, because the string->enum conversion code will
have already done that and reported an error as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:08 +02:00
|
|
|
|
2016-01-29 14:48:57 +01:00
|
|
|
visit_type_enum(v, name, &value, prop->strings, &err);
|
2015-08-25 20:00:45 +02:00
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
|
|
|
return;
|
|
|
|
}
|
qom: Add an object_property_add_enum() helper function
A QOM property can be parsed as enum using the visit_type_enum()
helper function, but this forces callers to use the more complex
generic object_property_add() method when registering it. It
also requires that users of that object have access to the
string map when they want to read the property value.
This patch introduces a specialized object_property_add_enum()
method which simplifies the use of enum properties, so the
setters/getters directly get passed the int value.
typedef enum {
MYDEV_TYPE_FROG,
MYDEV_TYPE_ALLIGATOR,
MYDEV_TYPE_PLATYPUS,
MYDEV_TYPE_LAST
} MyDevType;
Then provide a table of enum <-> string mappings
static const char *const mydevtypemap[MYDEV_TYPE_LAST + 1] = {
[MYDEV_TYPE_FROG] = "frog",
[MYDEV_TYPE_ALLIGATOR] = "alligator",
[MYDEV_TYPE_PLATYPUS] = "platypus",
[MYDEV_TYPE_LAST] = NULL,
};
Assuming an object struct of
typedef struct {
Object parent_obj;
MyDevType devtype;
...other fields...
} MyDev;
The property can then be registered as follows:
static int mydev_prop_get_devtype(Object *obj,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
return dev->devtype;
}
static void mydev_prop_set_devtype(Object *obj,
int value,
Error **errp G_GNUC_UNUSED)
{
MyDev *dev = MYDEV(obj);
dev->devtype = value;
}
object_property_add_enum(obj, "devtype",
mydevtypemap, "MyDevType",
mydev_prop_get_devtype,
mydev_prop_set_devtype,
NULL);
Note there is no need to check the range of 'value' in
the setter, because the string->enum conversion code will
have already done that and reported an error as required.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Andreas Färber <afaerber@suse.de>
2015-05-13 18:14:08 +02:00
|
|
|
prop->set(obj, value, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void property_release_enum(Object *obj, const char *name,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
EnumProperty *prop = opaque;
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_add_enum(Object *obj, const char *name,
|
|
|
|
const char *typename,
|
|
|
|
const char * const *strings,
|
|
|
|
int (*get)(Object *, Error **),
|
|
|
|
void (*set)(Object *, int, Error **),
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
EnumProperty *prop = g_malloc(sizeof(*prop));
|
|
|
|
|
|
|
|
prop->strings = strings;
|
|
|
|
prop->get = get;
|
|
|
|
prop->set = set;
|
|
|
|
|
|
|
|
object_property_add(obj, name, typename,
|
|
|
|
get ? property_get_enum : NULL,
|
|
|
|
set ? property_set_enum : NULL,
|
|
|
|
property_release_enum,
|
|
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_add_enum(ObjectClass *klass, const char *name,
|
|
|
|
const char *typename,
|
|
|
|
const char * const *strings,
|
|
|
|
int (*get)(Object *, Error **),
|
|
|
|
void (*set)(Object *, int, Error **),
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
EnumProperty *prop = g_malloc(sizeof(*prop));
|
|
|
|
|
|
|
|
prop->strings = strings;
|
|
|
|
prop->get = get;
|
|
|
|
prop->set = set;
|
|
|
|
|
|
|
|
object_class_property_add(klass, name, typename,
|
|
|
|
get ? property_get_enum : NULL,
|
|
|
|
set ? property_set_enum : NULL,
|
|
|
|
property_release_enum,
|
|
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-06 04:55:45 +01:00
|
|
|
typedef struct TMProperty {
|
|
|
|
void (*get)(Object *, struct tm *, Error **);
|
|
|
|
} TMProperty;
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_get_tm(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2015-02-06 04:55:45 +01:00
|
|
|
{
|
|
|
|
TMProperty *prop = opaque;
|
|
|
|
Error *err = NULL;
|
|
|
|
struct tm value;
|
|
|
|
|
|
|
|
prop->get(obj, &value, &err);
|
|
|
|
if (err) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-01-29 14:48:57 +01:00
|
|
|
visit_start_struct(v, name, NULL, 0, &err);
|
2015-02-06 04:55:45 +01:00
|
|
|
if (err) {
|
|
|
|
goto out;
|
|
|
|
}
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_int32(v, "tm_year", &value.tm_year, &err);
|
2015-02-06 04:55:45 +01:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_int32(v, "tm_mon", &value.tm_mon, &err);
|
2015-02-06 04:55:45 +01:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_int32(v, "tm_mday", &value.tm_mday, &err);
|
2015-02-06 04:55:45 +01:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_int32(v, "tm_hour", &value.tm_hour, &err);
|
2015-02-06 04:55:45 +01:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_int32(v, "tm_min", &value.tm_min, &err);
|
2015-02-06 04:55:45 +01:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_int32(v, "tm_sec", &value.tm_sec, &err);
|
2015-02-06 04:55:45 +01:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
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;
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1461879932-9020-20-git-send-email-eblake@redhat.com>
[Conflict with a doc fixup resolved]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-04-28 23:45:27 +02:00
|
|
|
visit_check_struct(v, &err);
|
2015-02-06 04:55:45 +01:00
|
|
|
out_end:
|
qapi: Add parameter to visit_end_*
Rather than making the dealloc visitor track of stack of pointers
remembered during visit_start_* in order to free them during
visit_end_*, it's a lot easier to just make all callers pass the
same pointer to visit_end_*. The generated code has access to the
same pointer, while all other users are doing virtual walks and
can pass NULL. The dealloc visitor is then greatly simplified.
All three visit_end_*() functions intentionally take a void**,
even though the visit_start_*() functions differ between void**,
GenericList**, and GenericAlternate**. This is done for several
reasons: when doing a virtual walk, passing NULL doesn't care
what the type is, but when doing a generated walk, we already
have to cast the caller's specific FOO* to call visit_start,
while using void** lets us use visit_end without a cast. Also,
an upcoming patch will add a clone visitor that wants to use
the same implementation for all three visit_end callbacks,
which is made easier if all three share the same signature.
For visitors with already track per-object state (the QMP visitors
via a stack, and the string visitors which do not allow nesting),
add an assertion that the caller is indeed passing the same
pointer to paired calls.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1465490926-28625-4-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-06-09 18:48:34 +02:00
|
|
|
visit_end_struct(v, NULL);
|
2015-02-06 04:55:45 +01:00
|
|
|
out:
|
|
|
|
error_propagate(errp, err);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void property_release_tm(Object *obj, const char *name,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
TMProperty *prop = opaque;
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_add_tm(Object *obj, const char *name,
|
|
|
|
void (*get)(Object *, struct tm *, Error **),
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
TMProperty *prop = g_malloc0(sizeof(*prop));
|
|
|
|
|
|
|
|
prop->get = get;
|
|
|
|
|
|
|
|
object_property_add(obj, name, "struct tm",
|
|
|
|
get ? property_get_tm : NULL, NULL,
|
|
|
|
property_release_tm,
|
|
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_add_tm(ObjectClass *klass, const char *name,
|
|
|
|
void (*get)(Object *, struct tm *, Error **),
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
|
|
|
TMProperty *prop = g_malloc0(sizeof(*prop));
|
|
|
|
|
|
|
|
prop->get = get;
|
|
|
|
|
|
|
|
object_class_property_add(klass, name, "struct tm",
|
|
|
|
get ? property_get_tm : NULL, NULL,
|
|
|
|
property_release_tm,
|
|
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-02 17:33:51 +02:00
|
|
|
static char *qdev_get_type(Object *obj, Error **errp)
|
|
|
|
{
|
|
|
|
return g_strdup(object_get_typename(obj));
|
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_get_uint8_ptr(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2013-09-22 09:10:17 +02:00
|
|
|
{
|
|
|
|
uint8_t value = *(uint8_t *)opaque;
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_uint8(v, name, &value, errp);
|
2013-09-22 09:10:17 +02:00
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_get_uint16_ptr(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2013-09-22 09:10:17 +02:00
|
|
|
{
|
|
|
|
uint16_t value = *(uint16_t *)opaque;
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_uint16(v, name, &value, errp);
|
2013-09-22 09:10:17 +02:00
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_get_uint32_ptr(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2013-09-22 09:10:17 +02:00
|
|
|
{
|
|
|
|
uint32_t value = *(uint32_t *)opaque;
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_uint32(v, name, &value, errp);
|
2013-09-22 09:10:17 +02:00
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_get_uint64_ptr(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2013-09-22 09:10:17 +02:00
|
|
|
{
|
|
|
|
uint64_t value = *(uint64_t *)opaque;
|
qapi: Swap visit_* arguments for consistent 'name' placement
JSON uses "name":value, but many of our visitor interfaces were
called with visit_type_FOO(v, &value, name, errp). This can be
a bit confusing to have to mentally swap the parameter order to
match JSON order. It's particularly bad for visit_start_struct(),
where the 'name' parameter is smack in the middle of the
otherwise-related group of 'obj, kind, size' parameters! It's
time to do a global swap of the parameter ordering, so that the
'name' parameter is always immediately after the Visitor argument.
Additional reason in favor of the swap: the existing include/qjson.h
prefers listing 'name' first in json_prop_*(), and I have plans to
unify that file with the qapi visitors; listing 'name' first in
qapi will minimize churn to the (admittedly few) qjson.h clients.
Later patches will then fix docs, object.h, visitor-impl.h, and
those clients to match.
Done by first patching scripts/qapi*.py by hand to make generated
files do what I want, then by running the following Coccinelle
script to affect the rest of the code base:
$ spatch --sp-file script `git grep -l '\bvisit_' -- '**/*.[ch]'`
I then had to apply some touchups (Coccinelle insisted on TAB
indentation in visitor.h, and botched the signature of
visit_type_enum() by rewriting 'const char *const strings[]' to
the syntactically invalid 'const char*const[] strings'). The
movement of parameters is sufficient to provoke compiler errors
if any callers were missed.
// Part 1: Swap declaration order
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_start_struct
-(TV v, TObj OBJ, T1 ARG1, const char *name, T2 ARG2, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type bool, TV, T1;
identifier ARG1;
@@
bool visit_optional
-(TV v, T1 ARG1, const char *name)
+(TV v, const char *name, T1 ARG1)
{ ... }
@@
type TV, TErr, TObj, T1;
identifier OBJ, ARG1;
@@
void visit_get_next_type
-(TV v, TObj OBJ, T1 ARG1, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, TErr errp)
{ ... }
@@
type TV, TErr, TObj, T1, T2;
identifier OBJ, ARG1, ARG2;
@@
void visit_type_enum
-(TV v, TObj OBJ, T1 ARG1, T2 ARG2, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, T1 ARG1, T2 ARG2, TErr errp)
{ ... }
@@
type TV, TErr, TObj;
identifier OBJ;
identifier VISIT_TYPE =~ "^visit_type_";
@@
void VISIT_TYPE
-(TV v, TObj OBJ, const char *name, TErr errp)
+(TV v, const char *name, TObj OBJ, TErr errp)
{ ... }
// Part 2: swap caller order
@@
expression V, NAME, OBJ, ARG1, ARG2, ERR;
identifier VISIT_TYPE =~ "^visit_type_";
@@
(
-visit_start_struct(V, OBJ, ARG1, NAME, ARG2, ERR)
+visit_start_struct(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-visit_optional(V, ARG1, NAME)
+visit_optional(V, NAME, ARG1)
|
-visit_get_next_type(V, OBJ, ARG1, NAME, ERR)
+visit_get_next_type(V, NAME, OBJ, ARG1, ERR)
|
-visit_type_enum(V, OBJ, ARG1, ARG2, NAME, ERR)
+visit_type_enum(V, NAME, OBJ, ARG1, ARG2, ERR)
|
-VISIT_TYPE(V, OBJ, NAME, ERR)
+VISIT_TYPE(V, NAME, OBJ, ERR)
)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-19-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:54 +01:00
|
|
|
visit_type_uint64(v, name, &value, errp);
|
2013-09-22 09:10:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_add_uint8_ptr(Object *obj, const char *name,
|
|
|
|
const uint8_t *v, Error **errp)
|
|
|
|
{
|
|
|
|
object_property_add(obj, name, "uint8", property_get_uint8_ptr,
|
|
|
|
NULL, NULL, (void *)v, errp);
|
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_add_uint8_ptr(ObjectClass *klass, const char *name,
|
|
|
|
const uint8_t *v, Error **errp)
|
|
|
|
{
|
|
|
|
object_class_property_add(klass, name, "uint8", property_get_uint8_ptr,
|
|
|
|
NULL, NULL, (void *)v, errp);
|
|
|
|
}
|
|
|
|
|
2013-09-22 09:10:17 +02:00
|
|
|
void object_property_add_uint16_ptr(Object *obj, const char *name,
|
|
|
|
const uint16_t *v, Error **errp)
|
|
|
|
{
|
|
|
|
object_property_add(obj, name, "uint16", property_get_uint16_ptr,
|
|
|
|
NULL, NULL, (void *)v, errp);
|
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_add_uint16_ptr(ObjectClass *klass, const char *name,
|
|
|
|
const uint16_t *v, Error **errp)
|
|
|
|
{
|
|
|
|
object_class_property_add(klass, name, "uint16", property_get_uint16_ptr,
|
|
|
|
NULL, NULL, (void *)v, errp);
|
|
|
|
}
|
|
|
|
|
2013-09-22 09:10:17 +02:00
|
|
|
void object_property_add_uint32_ptr(Object *obj, const char *name,
|
|
|
|
const uint32_t *v, Error **errp)
|
|
|
|
{
|
|
|
|
object_property_add(obj, name, "uint32", property_get_uint32_ptr,
|
|
|
|
NULL, NULL, (void *)v, errp);
|
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_add_uint32_ptr(ObjectClass *klass, const char *name,
|
|
|
|
const uint32_t *v, Error **errp)
|
|
|
|
{
|
|
|
|
object_class_property_add(klass, name, "uint32", property_get_uint32_ptr,
|
|
|
|
NULL, NULL, (void *)v, errp);
|
|
|
|
}
|
|
|
|
|
2013-09-22 09:10:17 +02:00
|
|
|
void object_property_add_uint64_ptr(Object *obj, const char *name,
|
|
|
|
const uint64_t *v, Error **errp)
|
|
|
|
{
|
|
|
|
object_property_add(obj, name, "uint64", property_get_uint64_ptr,
|
|
|
|
NULL, NULL, (void *)v, errp);
|
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_add_uint64_ptr(ObjectClass *klass, const char *name,
|
|
|
|
const uint64_t *v, Error **errp)
|
|
|
|
{
|
|
|
|
object_class_property_add(klass, name, "uint64", property_get_uint64_ptr,
|
|
|
|
NULL, NULL, (void *)v, errp);
|
|
|
|
}
|
|
|
|
|
2014-06-18 11:58:28 +02:00
|
|
|
typedef struct {
|
|
|
|
Object *target_obj;
|
2015-04-09 21:57:29 +02:00
|
|
|
char *target_name;
|
2014-06-18 11:58:28 +02:00
|
|
|
} AliasProperty;
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_get_alias(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2014-06-18 11:58:28 +02:00
|
|
|
{
|
|
|
|
AliasProperty *prop = opaque;
|
|
|
|
|
|
|
|
object_property_get(prop->target_obj, v, prop->target_name, errp);
|
|
|
|
}
|
|
|
|
|
qom: Swap 'name' next to visitor in ObjectPropertyAccessor
Similar to the previous patch, it's nice to have all functions
in the tree that involve a visitor and a name for conversion to
or from QAPI to consistently stick the 'name' parameter next
to the Visitor parameter.
Done by manually changing include/qom/object.h and qom/object.c,
then running this Coccinelle script and touching up the fallout
(Coccinelle insisted on adding some trailing whitespace).
@ rule1 @
identifier fn;
typedef Object, Visitor, Error;
identifier obj, v, opaque, name, errp;
@@
void fn
- (Object *obj, Visitor *v, void *opaque, const char *name,
+ (Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp) { ... }
@@
identifier rule1.fn;
expression obj, v, opaque, name, errp;
@@
fn(obj, v,
- opaque, name,
+ name, opaque,
errp)
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <1454075341-13658-20-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-01-29 14:48:55 +01:00
|
|
|
static void property_set_alias(Object *obj, Visitor *v, const char *name,
|
|
|
|
void *opaque, Error **errp)
|
2014-06-18 11:58:28 +02:00
|
|
|
{
|
|
|
|
AliasProperty *prop = opaque;
|
|
|
|
|
|
|
|
object_property_set(prop->target_obj, v, prop->target_name, errp);
|
|
|
|
}
|
|
|
|
|
2014-06-05 13:11:51 +02:00
|
|
|
static Object *property_resolve_alias(Object *obj, void *opaque,
|
|
|
|
const gchar *part)
|
|
|
|
{
|
|
|
|
AliasProperty *prop = opaque;
|
|
|
|
|
|
|
|
return object_resolve_path_component(prop->target_obj, prop->target_name);
|
|
|
|
}
|
|
|
|
|
2014-06-18 11:58:28 +02:00
|
|
|
static void property_release_alias(Object *obj, const char *name, void *opaque)
|
|
|
|
{
|
|
|
|
AliasProperty *prop = opaque;
|
|
|
|
|
2015-04-09 21:57:29 +02:00
|
|
|
g_free(prop->target_name);
|
2014-06-18 11:58:28 +02:00
|
|
|
g_free(prop);
|
|
|
|
}
|
|
|
|
|
|
|
|
void object_property_add_alias(Object *obj, const char *name,
|
|
|
|
Object *target_obj, const char *target_name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
AliasProperty *prop;
|
2014-06-05 13:11:51 +02:00
|
|
|
ObjectProperty *op;
|
2014-06-18 11:58:28 +02:00
|
|
|
ObjectProperty *target_prop;
|
2014-06-10 11:17:35 +02:00
|
|
|
gchar *prop_type;
|
2014-09-27 07:13:56 +02:00
|
|
|
Error *local_err = NULL;
|
2014-06-18 11:58:28 +02:00
|
|
|
|
|
|
|
target_prop = object_property_find(target_obj, target_name, errp);
|
|
|
|
if (!target_prop) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-06-10 11:17:35 +02:00
|
|
|
if (object_property_is_child(target_prop)) {
|
|
|
|
prop_type = g_strdup_printf("link%s",
|
|
|
|
target_prop->type + strlen("child"));
|
|
|
|
} else {
|
|
|
|
prop_type = g_strdup(target_prop->type);
|
|
|
|
}
|
|
|
|
|
2014-06-18 11:58:28 +02:00
|
|
|
prop = g_malloc(sizeof(*prop));
|
|
|
|
prop->target_obj = target_obj;
|
2015-04-09 21:57:29 +02:00
|
|
|
prop->target_name = g_strdup(target_name);
|
2014-06-18 11:58:28 +02:00
|
|
|
|
2014-06-10 11:17:35 +02:00
|
|
|
op = object_property_add(obj, name, prop_type,
|
2014-06-05 13:11:51 +02:00
|
|
|
property_get_alias,
|
|
|
|
property_set_alias,
|
|
|
|
property_release_alias,
|
2014-09-27 07:13:56 +02:00
|
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
g_free(prop);
|
|
|
|
goto out;
|
|
|
|
}
|
2014-06-05 13:11:51 +02:00
|
|
|
op->resolve = property_resolve_alias;
|
2014-06-10 11:17:35 +02:00
|
|
|
|
2015-03-27 17:34:10 +01:00
|
|
|
object_property_set_description(obj, op->name,
|
2014-10-07 08:33:21 +02:00
|
|
|
target_prop->description,
|
|
|
|
&error_abort);
|
|
|
|
|
2014-09-27 07:13:56 +02:00
|
|
|
out:
|
2014-06-10 11:17:35 +02:00
|
|
|
g_free(prop_type);
|
2014-06-18 11:58:28 +02:00
|
|
|
}
|
|
|
|
|
2014-10-07 08:33:21 +02:00
|
|
|
void object_property_set_description(Object *obj, const char *name,
|
|
|
|
const char *description, Error **errp)
|
|
|
|
{
|
|
|
|
ObjectProperty *op;
|
|
|
|
|
|
|
|
op = object_property_find(obj, name, errp);
|
|
|
|
if (!op) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free(op->description);
|
|
|
|
op->description = g_strdup(description);
|
|
|
|
}
|
|
|
|
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_set_description(ObjectClass *klass,
|
|
|
|
const char *name,
|
|
|
|
const char *description,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
ObjectProperty *op;
|
|
|
|
|
|
|
|
op = g_hash_table_lookup(klass->properties, name);
|
|
|
|
if (!op) {
|
|
|
|
error_setg(errp, "Property '.%s' not found", name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free(op->description);
|
|
|
|
op->description = g_strdup(description);
|
|
|
|
}
|
|
|
|
|
2012-04-02 17:33:51 +02:00
|
|
|
static void object_instance_init(Object *obj)
|
|
|
|
{
|
|
|
|
object_property_add_str(obj, "type", qdev_get_type, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
2012-03-31 16:45:54 +02:00
|
|
|
static void register_types(void)
|
|
|
|
{
|
|
|
|
static TypeInfo interface_info = {
|
|
|
|
.name = TYPE_INTERFACE,
|
2012-08-10 05:16:10 +02:00
|
|
|
.class_size = sizeof(InterfaceClass),
|
2012-03-31 16:45:54 +02:00
|
|
|
.abstract = true,
|
|
|
|
};
|
|
|
|
|
|
|
|
static TypeInfo object_info = {
|
|
|
|
.name = TYPE_OBJECT,
|
|
|
|
.instance_size = sizeof(Object),
|
2012-04-02 17:33:51 +02:00
|
|
|
.instance_init = object_instance_init,
|
2012-03-31 16:45:54 +02:00
|
|
|
.abstract = true,
|
|
|
|
};
|
|
|
|
|
2012-04-04 15:58:40 +02:00
|
|
|
type_interface = type_register_internal(&interface_info);
|
|
|
|
type_register_internal(&object_info);
|
2012-03-31 16:45:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
type_init(register_types)
|