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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef QEMU_OBJECT_H
|
|
|
|
#define QEMU_OBJECT_H
|
|
|
|
|
2018-02-11 10:36:05 +01:00
|
|
|
#include "qapi/qapi-builtin-types.h"
|
2019-05-23 16:35:07 +02:00
|
|
|
#include "qemu/module.h"
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
struct TypeImpl;
|
|
|
|
typedef struct TypeImpl *Type;
|
|
|
|
|
|
|
|
typedef struct TypeInfo TypeInfo;
|
|
|
|
|
|
|
|
typedef struct InterfaceClass InterfaceClass;
|
|
|
|
typedef struct InterfaceInfo InterfaceInfo;
|
|
|
|
|
2012-03-31 16:45:54 +02:00
|
|
|
#define TYPE_OBJECT "object"
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2020-01-10 16:30:19 +01:00
|
|
|
typedef struct ObjectProperty ObjectProperty;
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* typedef ObjectPropertyAccessor:
|
2012-01-30 15:55:55 +01:00
|
|
|
* @obj: the object that owns the property
|
|
|
|
* @v: the visitor that contains the property data
|
|
|
|
* @name: the name of the property
|
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
|
|
|
* @opaque: the object property opaque
|
2012-01-30 15:55:55 +01:00
|
|
|
* @errp: a pointer to an Error that is filled if getting/setting fails.
|
|
|
|
*
|
|
|
|
* Called when trying to get/set a property.
|
|
|
|
*/
|
|
|
|
typedef void (ObjectPropertyAccessor)(Object *obj,
|
2016-01-29 14:48:53 +01:00
|
|
|
Visitor *v,
|
2012-01-30 15:55:55 +01:00
|
|
|
const char *name,
|
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
|
|
|
void *opaque,
|
2013-09-22 09:08:14 +02:00
|
|
|
Error **errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2014-06-05 13:11:51 +02:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* typedef ObjectPropertyResolve:
|
2014-06-05 13:11:51 +02:00
|
|
|
* @obj: the object that owns the property
|
|
|
|
* @opaque: the opaque registered with the property
|
|
|
|
* @part: the name of the property
|
|
|
|
*
|
|
|
|
* Resolves the #Object corresponding to property @part.
|
|
|
|
*
|
|
|
|
* The returned object can also be used as a starting point
|
|
|
|
* to resolve a relative path starting with "@part".
|
|
|
|
*
|
|
|
|
* Returns: If @path is the path that led to @obj, the function
|
|
|
|
* returns the #Object corresponding to "@path/@part".
|
|
|
|
* If "@path/@part" is not a valid object path, it returns #NULL.
|
|
|
|
*/
|
|
|
|
typedef Object *(ObjectPropertyResolve)(Object *obj,
|
|
|
|
void *opaque,
|
|
|
|
const char *part);
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* typedef ObjectPropertyRelease:
|
2012-01-30 15:55:55 +01:00
|
|
|
* @obj: the object that owns the property
|
|
|
|
* @name: the name of the property
|
|
|
|
* @opaque: the opaque registered with the property
|
|
|
|
*
|
|
|
|
* Called when a property is removed from a object.
|
|
|
|
*/
|
|
|
|
typedef void (ObjectPropertyRelease)(Object *obj,
|
|
|
|
const char *name,
|
|
|
|
void *opaque);
|
|
|
|
|
2020-01-10 16:30:19 +01:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* typedef ObjectPropertyInit:
|
2020-01-10 16:30:19 +01:00
|
|
|
* @obj: the object that owns the property
|
|
|
|
* @prop: the property to set
|
|
|
|
*
|
|
|
|
* Called when a property is initialized.
|
|
|
|
*/
|
|
|
|
typedef void (ObjectPropertyInit)(Object *obj, ObjectProperty *prop);
|
|
|
|
|
|
|
|
struct ObjectProperty
|
2012-01-30 15:55:55 +01:00
|
|
|
{
|
2020-05-05 17:29:10 +02:00
|
|
|
char *name;
|
|
|
|
char *type;
|
|
|
|
char *description;
|
2012-01-30 15:55:55 +01:00
|
|
|
ObjectPropertyAccessor *get;
|
|
|
|
ObjectPropertyAccessor *set;
|
2014-06-05 13:11:51 +02:00
|
|
|
ObjectPropertyResolve *resolve;
|
2012-01-30 15:55:55 +01:00
|
|
|
ObjectPropertyRelease *release;
|
2020-01-10 16:30:19 +01:00
|
|
|
ObjectPropertyInit *init;
|
2012-01-30 15:55:55 +01:00
|
|
|
void *opaque;
|
2020-01-10 16:30:23 +01:00
|
|
|
QObject *defval;
|
2020-01-10 16:30:19 +01:00
|
|
|
};
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2012-11-23 09:47:13 +01:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* typedef ObjectUnparent:
|
2012-11-23 09:47:13 +01:00
|
|
|
* @obj: the object that is being removed from the composition tree
|
|
|
|
*
|
|
|
|
* Called when an object is being removed from the QOM composition tree.
|
|
|
|
* The function should remove any backlinks from children objects to @obj.
|
|
|
|
*/
|
|
|
|
typedef void (ObjectUnparent)(Object *obj);
|
|
|
|
|
2012-11-23 09:47:14 +01:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* typedef ObjectFree:
|
2012-11-23 09:47:14 +01:00
|
|
|
* @obj: the object being freed
|
|
|
|
*
|
|
|
|
* Called when an object's last reference is removed.
|
|
|
|
*/
|
|
|
|
typedef void (ObjectFree)(void *obj);
|
|
|
|
|
2013-05-13 22:22:24 +02:00
|
|
|
#define OBJECT_CLASS_CAST_CACHE 4
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* struct ObjectClass:
|
2011-12-04 00:10:08 +01:00
|
|
|
*
|
|
|
|
* The base for all classes. The only thing that #ObjectClass contains is an
|
|
|
|
* integer type handle.
|
|
|
|
*/
|
|
|
|
struct ObjectClass
|
|
|
|
{
|
2020-09-11 00:15:19 +02:00
|
|
|
/* private: */
|
2011-12-04 00:10:08 +01:00
|
|
|
Type type;
|
2012-08-10 05:16:10 +02:00
|
|
|
GSList *interfaces;
|
2012-11-23 09:47:13 +01:00
|
|
|
|
2013-11-28 05:27:33 +01:00
|
|
|
const char *object_cast_cache[OBJECT_CLASS_CAST_CACHE];
|
|
|
|
const char *class_cast_cache[OBJECT_CLASS_CAST_CACHE];
|
2013-05-13 22:22:24 +02:00
|
|
|
|
2012-11-23 09:47:13 +01:00
|
|
|
ObjectUnparent *unparent;
|
2015-10-13 14:37:46 +02:00
|
|
|
|
|
|
|
GHashTable *properties;
|
2011-12-04 00:10:08 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* struct Object:
|
2011-12-04 00:10:08 +01:00
|
|
|
*
|
|
|
|
* The base for all objects. The first member of this object is a pointer to
|
|
|
|
* a #ObjectClass. Since C guarantees that the first member of a structure
|
|
|
|
* always begins at byte 0 of that structure, as long as any sub-object places
|
|
|
|
* its parent as the first member, we can cast directly to a #Object.
|
|
|
|
*
|
|
|
|
* As a result, #Object contains a reference to the objects type as its
|
|
|
|
* first member. This allows identification of the real type of the object at
|
|
|
|
* run time.
|
|
|
|
*/
|
|
|
|
struct Object
|
|
|
|
{
|
2020-09-11 00:15:19 +02:00
|
|
|
/* private: */
|
2011-12-04 00:10:08 +01:00
|
|
|
ObjectClass *class;
|
2012-11-23 09:47:14 +01:00
|
|
|
ObjectFree *free;
|
2015-10-13 14:37:45 +02:00
|
|
|
GHashTable *properties;
|
2012-01-30 15:55:55 +01:00
|
|
|
uint32_t ref;
|
|
|
|
Object *parent;
|
2011-12-04 00:10:08 +01:00
|
|
|
};
|
|
|
|
|
2020-08-31 23:07:26 +02:00
|
|
|
/**
|
|
|
|
* DECLARE_INSTANCE_CHECKER:
|
|
|
|
* @InstanceType: instance struct name
|
|
|
|
* @OBJ_NAME: the object name in uppercase with underscore separators
|
|
|
|
* @TYPENAME: type name
|
|
|
|
*
|
|
|
|
* Direct usage of this macro should be avoided, and the complete
|
|
|
|
* OBJECT_DECLARE_TYPE macro is recommended instead.
|
|
|
|
*
|
2020-10-03 04:54:19 +02:00
|
|
|
* This macro will provide the instance type cast functions for a
|
2020-08-31 23:07:26 +02:00
|
|
|
* QOM type.
|
|
|
|
*/
|
|
|
|
#define DECLARE_INSTANCE_CHECKER(InstanceType, OBJ_NAME, TYPENAME) \
|
|
|
|
static inline G_GNUC_UNUSED InstanceType * \
|
2020-08-31 23:07:27 +02:00
|
|
|
OBJ_NAME(const void *obj) \
|
2020-08-31 23:07:26 +02:00
|
|
|
{ return OBJECT_CHECK(InstanceType, obj, TYPENAME); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* DECLARE_CLASS_CHECKERS:
|
|
|
|
* @ClassType: class struct name
|
|
|
|
* @OBJ_NAME: the object name in uppercase with underscore separators
|
|
|
|
* @TYPENAME: type name
|
|
|
|
*
|
|
|
|
* Direct usage of this macro should be avoided, and the complete
|
|
|
|
* OBJECT_DECLARE_TYPE macro is recommended instead.
|
|
|
|
*
|
2020-10-03 04:54:19 +02:00
|
|
|
* This macro will provide the class type cast functions for a
|
2020-08-31 23:07:26 +02:00
|
|
|
* QOM type.
|
|
|
|
*/
|
|
|
|
#define DECLARE_CLASS_CHECKERS(ClassType, OBJ_NAME, TYPENAME) \
|
|
|
|
static inline G_GNUC_UNUSED ClassType * \
|
2020-08-31 23:07:27 +02:00
|
|
|
OBJ_NAME##_GET_CLASS(const void *obj) \
|
2020-08-31 23:07:26 +02:00
|
|
|
{ return OBJECT_GET_CLASS(ClassType, obj, TYPENAME); } \
|
|
|
|
\
|
|
|
|
static inline G_GNUC_UNUSED ClassType * \
|
2020-08-31 23:07:27 +02:00
|
|
|
OBJ_NAME##_CLASS(const void *klass) \
|
2020-08-31 23:07:26 +02:00
|
|
|
{ return OBJECT_CLASS_CHECK(ClassType, klass, TYPENAME); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* DECLARE_OBJ_CHECKERS:
|
|
|
|
* @InstanceType: instance struct name
|
|
|
|
* @ClassType: class struct name
|
|
|
|
* @OBJ_NAME: the object name in uppercase with underscore separators
|
|
|
|
* @TYPENAME: type name
|
|
|
|
*
|
|
|
|
* Direct usage of this macro should be avoided, and the complete
|
|
|
|
* OBJECT_DECLARE_TYPE macro is recommended instead.
|
|
|
|
*
|
|
|
|
* This macro will provide the three standard type cast functions for a
|
|
|
|
* QOM type.
|
|
|
|
*/
|
|
|
|
#define DECLARE_OBJ_CHECKERS(InstanceType, ClassType, OBJ_NAME, TYPENAME) \
|
|
|
|
DECLARE_INSTANCE_CHECKER(InstanceType, OBJ_NAME, TYPENAME) \
|
|
|
|
\
|
|
|
|
DECLARE_CLASS_CHECKERS(ClassType, OBJ_NAME, TYPENAME)
|
|
|
|
|
qom: provide convenient macros for declaring and defining types
When creating new QOM types, there is a lot of boilerplate code that
must be repeated using a standard pattern. This is tedious to write
and liable to suffer from subtle inconsistencies. Thus it would
benefit from some simple automation.
QOM was loosely inspired by GLib's GObject, and indeed GObject suffers
from the same burden of boilerplate code, but has long provided a set of
macros to eliminate this burden in the source implementation. More
recently it has also provided a set of macros to eliminate this burden
in the header declaration.
In GLib there are the G_DECLARE_* and G_DEFINE_* family of macros
for the header declaration and source implementation respectively:
https://developer.gnome.org/gobject/stable/chapter-gobject.html
https://developer.gnome.org/gobject/stable/howto-gobject.html
This patch takes inspiration from GObject to provide the equivalent
functionality for QOM.
In the header file, instead of:
typedef struct MyDevice MyDevice;
typedef struct MyDeviceClass MyDeviceClass;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MyDeviceClass, object_unref)
#define MY_DEVICE_GET_CLASS(void *obj) \
OBJECT_GET_CLASS(MyDeviceClass, obj, TYPE_MY_DEVICE)
#define MY_DEVICE_CLASS(void *klass) \
OBJECT_CLASS_CHECK(MyDeviceClass, klass, TYPE_MY_DEVICE)
#define MY_DEVICE(void *obj)
OBJECT_CHECK(MyDevice, obj, TYPE_MY_DEVICE)
struct MyDeviceClass {
DeviceClass parent_class;
};
We now have
OBJECT_DECLARE_SIMPLE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
In cases where the class needs some virtual methods, it can be left
to be implemented manually using
OBJECT_DECLARE_TYPE(MyDevice, my_device, MY_DEVICE)
Note that these macros are including support for g_autoptr() for the
object types, which is something previously only supported for variables
declared as the base Object * type.
Meanwhile in the source file, instead of:
static void my_device_finalize(Object *obj);
static void my_device_class_init(ObjectClass *oc, void *data);
static void my_device_init(Object *obj);
static const TypeInfo my_device_info = {
.parent = TYPE_DEVICE,
.name = TYPE_MY_DEVICE,
.instance_size = sizeof(MyDevice),
.instance_init = my_device_init,
.instance_finalize = my_device_finalize,
.class_size = sizeof(MyDeviceClass),
.class_init = my_device_class_init,
};
static void
my_device_register_types(void)
{
type_register_static(&my_device_info);
}
type_init(my_device_register_types);
We now have
OBJECT_DEFINE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
Or, if a class needs to implement interfaces:
OBJECT_DEFINE_TYPE_WITH_INTERFACES(MyDevice, my_device, MY_DEVICE, DEVICE,
{ TYPE_USER_CREATABLE }, { NULL })
Or, if a class needs to be abstract
OBJECT_DEFINE_ABSTRACT_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
IOW, in both cases the maintainer now only has to think about the
interesting part of the code which implements useful functionality
and avoids much of the boilerplate.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200723181410.3145233-3-berrange@redhat.com>
[ehabkost: Fix G_DEFINE_AUTOPTR_CLEANUP_FUNC usage]
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <20200831210740.126168-3-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-31 23:07:24 +02:00
|
|
|
/**
|
|
|
|
* OBJECT_DECLARE_TYPE:
|
2020-08-31 23:07:25 +02:00
|
|
|
* @InstanceType: instance struct name
|
|
|
|
* @ClassType: class struct name
|
qom: provide convenient macros for declaring and defining types
When creating new QOM types, there is a lot of boilerplate code that
must be repeated using a standard pattern. This is tedious to write
and liable to suffer from subtle inconsistencies. Thus it would
benefit from some simple automation.
QOM was loosely inspired by GLib's GObject, and indeed GObject suffers
from the same burden of boilerplate code, but has long provided a set of
macros to eliminate this burden in the source implementation. More
recently it has also provided a set of macros to eliminate this burden
in the header declaration.
In GLib there are the G_DECLARE_* and G_DEFINE_* family of macros
for the header declaration and source implementation respectively:
https://developer.gnome.org/gobject/stable/chapter-gobject.html
https://developer.gnome.org/gobject/stable/howto-gobject.html
This patch takes inspiration from GObject to provide the equivalent
functionality for QOM.
In the header file, instead of:
typedef struct MyDevice MyDevice;
typedef struct MyDeviceClass MyDeviceClass;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MyDeviceClass, object_unref)
#define MY_DEVICE_GET_CLASS(void *obj) \
OBJECT_GET_CLASS(MyDeviceClass, obj, TYPE_MY_DEVICE)
#define MY_DEVICE_CLASS(void *klass) \
OBJECT_CLASS_CHECK(MyDeviceClass, klass, TYPE_MY_DEVICE)
#define MY_DEVICE(void *obj)
OBJECT_CHECK(MyDevice, obj, TYPE_MY_DEVICE)
struct MyDeviceClass {
DeviceClass parent_class;
};
We now have
OBJECT_DECLARE_SIMPLE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
In cases where the class needs some virtual methods, it can be left
to be implemented manually using
OBJECT_DECLARE_TYPE(MyDevice, my_device, MY_DEVICE)
Note that these macros are including support for g_autoptr() for the
object types, which is something previously only supported for variables
declared as the base Object * type.
Meanwhile in the source file, instead of:
static void my_device_finalize(Object *obj);
static void my_device_class_init(ObjectClass *oc, void *data);
static void my_device_init(Object *obj);
static const TypeInfo my_device_info = {
.parent = TYPE_DEVICE,
.name = TYPE_MY_DEVICE,
.instance_size = sizeof(MyDevice),
.instance_init = my_device_init,
.instance_finalize = my_device_finalize,
.class_size = sizeof(MyDeviceClass),
.class_init = my_device_class_init,
};
static void
my_device_register_types(void)
{
type_register_static(&my_device_info);
}
type_init(my_device_register_types);
We now have
OBJECT_DEFINE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
Or, if a class needs to implement interfaces:
OBJECT_DEFINE_TYPE_WITH_INTERFACES(MyDevice, my_device, MY_DEVICE, DEVICE,
{ TYPE_USER_CREATABLE }, { NULL })
Or, if a class needs to be abstract
OBJECT_DEFINE_ABSTRACT_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
IOW, in both cases the maintainer now only has to think about the
interesting part of the code which implements useful functionality
and avoids much of the boilerplate.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200723181410.3145233-3-berrange@redhat.com>
[ehabkost: Fix G_DEFINE_AUTOPTR_CLEANUP_FUNC usage]
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <20200831210740.126168-3-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-31 23:07:24 +02:00
|
|
|
* @MODULE_OBJ_NAME: the object name in uppercase with underscore separators
|
|
|
|
*
|
|
|
|
* This macro is typically used in a header file, and will:
|
|
|
|
*
|
|
|
|
* - create the typedefs for the object and class structs
|
|
|
|
* - register the type for use with g_autoptr
|
|
|
|
* - provide three standard type cast functions
|
|
|
|
*
|
|
|
|
* The object struct and class struct need to be declared manually.
|
|
|
|
*/
|
qom: Remove module_obj_name parameter from OBJECT_DECLARE* macros
One of the goals of having less boilerplate on QOM declarations
is to avoid human error. Requiring an extra argument that is
never used is an opportunity for mistakes.
Remove the unused argument from OBJECT_DECLARE_TYPE and
OBJECT_DECLARE_SIMPLE_TYPE.
Coccinelle patch used to convert all users of the macros:
@@
declarer name OBJECT_DECLARE_TYPE;
identifier InstanceType, ClassType, lowercase, UPPERCASE;
@@
OBJECT_DECLARE_TYPE(InstanceType, ClassType,
- lowercase,
UPPERCASE);
@@
declarer name OBJECT_DECLARE_SIMPLE_TYPE;
identifier InstanceType, lowercase, UPPERCASE;
@@
OBJECT_DECLARE_SIMPLE_TYPE(InstanceType,
- lowercase,
UPPERCASE);
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Acked-by: Igor Mammedov <imammedo@redhat.com>
Acked-by: Paul Durrant <paul@xen.org>
Acked-by: Thomas Huth <thuth@redhat.com>
Message-Id: <20200916182519.415636-4-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-09-16 20:25:17 +02:00
|
|
|
#define OBJECT_DECLARE_TYPE(InstanceType, ClassType, MODULE_OBJ_NAME) \
|
2020-08-31 23:07:25 +02:00
|
|
|
typedef struct InstanceType InstanceType; \
|
|
|
|
typedef struct ClassType ClassType; \
|
qom: provide convenient macros for declaring and defining types
When creating new QOM types, there is a lot of boilerplate code that
must be repeated using a standard pattern. This is tedious to write
and liable to suffer from subtle inconsistencies. Thus it would
benefit from some simple automation.
QOM was loosely inspired by GLib's GObject, and indeed GObject suffers
from the same burden of boilerplate code, but has long provided a set of
macros to eliminate this burden in the source implementation. More
recently it has also provided a set of macros to eliminate this burden
in the header declaration.
In GLib there are the G_DECLARE_* and G_DEFINE_* family of macros
for the header declaration and source implementation respectively:
https://developer.gnome.org/gobject/stable/chapter-gobject.html
https://developer.gnome.org/gobject/stable/howto-gobject.html
This patch takes inspiration from GObject to provide the equivalent
functionality for QOM.
In the header file, instead of:
typedef struct MyDevice MyDevice;
typedef struct MyDeviceClass MyDeviceClass;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MyDeviceClass, object_unref)
#define MY_DEVICE_GET_CLASS(void *obj) \
OBJECT_GET_CLASS(MyDeviceClass, obj, TYPE_MY_DEVICE)
#define MY_DEVICE_CLASS(void *klass) \
OBJECT_CLASS_CHECK(MyDeviceClass, klass, TYPE_MY_DEVICE)
#define MY_DEVICE(void *obj)
OBJECT_CHECK(MyDevice, obj, TYPE_MY_DEVICE)
struct MyDeviceClass {
DeviceClass parent_class;
};
We now have
OBJECT_DECLARE_SIMPLE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
In cases where the class needs some virtual methods, it can be left
to be implemented manually using
OBJECT_DECLARE_TYPE(MyDevice, my_device, MY_DEVICE)
Note that these macros are including support for g_autoptr() for the
object types, which is something previously only supported for variables
declared as the base Object * type.
Meanwhile in the source file, instead of:
static void my_device_finalize(Object *obj);
static void my_device_class_init(ObjectClass *oc, void *data);
static void my_device_init(Object *obj);
static const TypeInfo my_device_info = {
.parent = TYPE_DEVICE,
.name = TYPE_MY_DEVICE,
.instance_size = sizeof(MyDevice),
.instance_init = my_device_init,
.instance_finalize = my_device_finalize,
.class_size = sizeof(MyDeviceClass),
.class_init = my_device_class_init,
};
static void
my_device_register_types(void)
{
type_register_static(&my_device_info);
}
type_init(my_device_register_types);
We now have
OBJECT_DEFINE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
Or, if a class needs to implement interfaces:
OBJECT_DEFINE_TYPE_WITH_INTERFACES(MyDevice, my_device, MY_DEVICE, DEVICE,
{ TYPE_USER_CREATABLE }, { NULL })
Or, if a class needs to be abstract
OBJECT_DEFINE_ABSTRACT_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
IOW, in both cases the maintainer now only has to think about the
interesting part of the code which implements useful functionality
and avoids much of the boilerplate.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200723181410.3145233-3-berrange@redhat.com>
[ehabkost: Fix G_DEFINE_AUTOPTR_CLEANUP_FUNC usage]
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <20200831210740.126168-3-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-31 23:07:24 +02:00
|
|
|
\
|
2020-08-31 23:07:25 +02:00
|
|
|
G_DEFINE_AUTOPTR_CLEANUP_FUNC(InstanceType, object_unref) \
|
qom: provide convenient macros for declaring and defining types
When creating new QOM types, there is a lot of boilerplate code that
must be repeated using a standard pattern. This is tedious to write
and liable to suffer from subtle inconsistencies. Thus it would
benefit from some simple automation.
QOM was loosely inspired by GLib's GObject, and indeed GObject suffers
from the same burden of boilerplate code, but has long provided a set of
macros to eliminate this burden in the source implementation. More
recently it has also provided a set of macros to eliminate this burden
in the header declaration.
In GLib there are the G_DECLARE_* and G_DEFINE_* family of macros
for the header declaration and source implementation respectively:
https://developer.gnome.org/gobject/stable/chapter-gobject.html
https://developer.gnome.org/gobject/stable/howto-gobject.html
This patch takes inspiration from GObject to provide the equivalent
functionality for QOM.
In the header file, instead of:
typedef struct MyDevice MyDevice;
typedef struct MyDeviceClass MyDeviceClass;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MyDeviceClass, object_unref)
#define MY_DEVICE_GET_CLASS(void *obj) \
OBJECT_GET_CLASS(MyDeviceClass, obj, TYPE_MY_DEVICE)
#define MY_DEVICE_CLASS(void *klass) \
OBJECT_CLASS_CHECK(MyDeviceClass, klass, TYPE_MY_DEVICE)
#define MY_DEVICE(void *obj)
OBJECT_CHECK(MyDevice, obj, TYPE_MY_DEVICE)
struct MyDeviceClass {
DeviceClass parent_class;
};
We now have
OBJECT_DECLARE_SIMPLE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
In cases where the class needs some virtual methods, it can be left
to be implemented manually using
OBJECT_DECLARE_TYPE(MyDevice, my_device, MY_DEVICE)
Note that these macros are including support for g_autoptr() for the
object types, which is something previously only supported for variables
declared as the base Object * type.
Meanwhile in the source file, instead of:
static void my_device_finalize(Object *obj);
static void my_device_class_init(ObjectClass *oc, void *data);
static void my_device_init(Object *obj);
static const TypeInfo my_device_info = {
.parent = TYPE_DEVICE,
.name = TYPE_MY_DEVICE,
.instance_size = sizeof(MyDevice),
.instance_init = my_device_init,
.instance_finalize = my_device_finalize,
.class_size = sizeof(MyDeviceClass),
.class_init = my_device_class_init,
};
static void
my_device_register_types(void)
{
type_register_static(&my_device_info);
}
type_init(my_device_register_types);
We now have
OBJECT_DEFINE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
Or, if a class needs to implement interfaces:
OBJECT_DEFINE_TYPE_WITH_INTERFACES(MyDevice, my_device, MY_DEVICE, DEVICE,
{ TYPE_USER_CREATABLE }, { NULL })
Or, if a class needs to be abstract
OBJECT_DEFINE_ABSTRACT_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
IOW, in both cases the maintainer now only has to think about the
interesting part of the code which implements useful functionality
and avoids much of the boilerplate.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200723181410.3145233-3-berrange@redhat.com>
[ehabkost: Fix G_DEFINE_AUTOPTR_CLEANUP_FUNC usage]
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <20200831210740.126168-3-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-31 23:07:24 +02:00
|
|
|
\
|
2020-08-31 23:07:26 +02:00
|
|
|
DECLARE_OBJ_CHECKERS(InstanceType, ClassType, \
|
|
|
|
MODULE_OBJ_NAME, TYPE_##MODULE_OBJ_NAME)
|
qom: provide convenient macros for declaring and defining types
When creating new QOM types, there is a lot of boilerplate code that
must be repeated using a standard pattern. This is tedious to write
and liable to suffer from subtle inconsistencies. Thus it would
benefit from some simple automation.
QOM was loosely inspired by GLib's GObject, and indeed GObject suffers
from the same burden of boilerplate code, but has long provided a set of
macros to eliminate this burden in the source implementation. More
recently it has also provided a set of macros to eliminate this burden
in the header declaration.
In GLib there are the G_DECLARE_* and G_DEFINE_* family of macros
for the header declaration and source implementation respectively:
https://developer.gnome.org/gobject/stable/chapter-gobject.html
https://developer.gnome.org/gobject/stable/howto-gobject.html
This patch takes inspiration from GObject to provide the equivalent
functionality for QOM.
In the header file, instead of:
typedef struct MyDevice MyDevice;
typedef struct MyDeviceClass MyDeviceClass;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MyDeviceClass, object_unref)
#define MY_DEVICE_GET_CLASS(void *obj) \
OBJECT_GET_CLASS(MyDeviceClass, obj, TYPE_MY_DEVICE)
#define MY_DEVICE_CLASS(void *klass) \
OBJECT_CLASS_CHECK(MyDeviceClass, klass, TYPE_MY_DEVICE)
#define MY_DEVICE(void *obj)
OBJECT_CHECK(MyDevice, obj, TYPE_MY_DEVICE)
struct MyDeviceClass {
DeviceClass parent_class;
};
We now have
OBJECT_DECLARE_SIMPLE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
In cases where the class needs some virtual methods, it can be left
to be implemented manually using
OBJECT_DECLARE_TYPE(MyDevice, my_device, MY_DEVICE)
Note that these macros are including support for g_autoptr() for the
object types, which is something previously only supported for variables
declared as the base Object * type.
Meanwhile in the source file, instead of:
static void my_device_finalize(Object *obj);
static void my_device_class_init(ObjectClass *oc, void *data);
static void my_device_init(Object *obj);
static const TypeInfo my_device_info = {
.parent = TYPE_DEVICE,
.name = TYPE_MY_DEVICE,
.instance_size = sizeof(MyDevice),
.instance_init = my_device_init,
.instance_finalize = my_device_finalize,
.class_size = sizeof(MyDeviceClass),
.class_init = my_device_class_init,
};
static void
my_device_register_types(void)
{
type_register_static(&my_device_info);
}
type_init(my_device_register_types);
We now have
OBJECT_DEFINE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
Or, if a class needs to implement interfaces:
OBJECT_DEFINE_TYPE_WITH_INTERFACES(MyDevice, my_device, MY_DEVICE, DEVICE,
{ TYPE_USER_CREATABLE }, { NULL })
Or, if a class needs to be abstract
OBJECT_DEFINE_ABSTRACT_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
IOW, in both cases the maintainer now only has to think about the
interesting part of the code which implements useful functionality
and avoids much of the boilerplate.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200723181410.3145233-3-berrange@redhat.com>
[ehabkost: Fix G_DEFINE_AUTOPTR_CLEANUP_FUNC usage]
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <20200831210740.126168-3-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-31 23:07:24 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* OBJECT_DECLARE_SIMPLE_TYPE:
|
2020-08-31 23:07:25 +02:00
|
|
|
* @InstanceType: instance struct name
|
qom: provide convenient macros for declaring and defining types
When creating new QOM types, there is a lot of boilerplate code that
must be repeated using a standard pattern. This is tedious to write
and liable to suffer from subtle inconsistencies. Thus it would
benefit from some simple automation.
QOM was loosely inspired by GLib's GObject, and indeed GObject suffers
from the same burden of boilerplate code, but has long provided a set of
macros to eliminate this burden in the source implementation. More
recently it has also provided a set of macros to eliminate this burden
in the header declaration.
In GLib there are the G_DECLARE_* and G_DEFINE_* family of macros
for the header declaration and source implementation respectively:
https://developer.gnome.org/gobject/stable/chapter-gobject.html
https://developer.gnome.org/gobject/stable/howto-gobject.html
This patch takes inspiration from GObject to provide the equivalent
functionality for QOM.
In the header file, instead of:
typedef struct MyDevice MyDevice;
typedef struct MyDeviceClass MyDeviceClass;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MyDeviceClass, object_unref)
#define MY_DEVICE_GET_CLASS(void *obj) \
OBJECT_GET_CLASS(MyDeviceClass, obj, TYPE_MY_DEVICE)
#define MY_DEVICE_CLASS(void *klass) \
OBJECT_CLASS_CHECK(MyDeviceClass, klass, TYPE_MY_DEVICE)
#define MY_DEVICE(void *obj)
OBJECT_CHECK(MyDevice, obj, TYPE_MY_DEVICE)
struct MyDeviceClass {
DeviceClass parent_class;
};
We now have
OBJECT_DECLARE_SIMPLE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
In cases where the class needs some virtual methods, it can be left
to be implemented manually using
OBJECT_DECLARE_TYPE(MyDevice, my_device, MY_DEVICE)
Note that these macros are including support for g_autoptr() for the
object types, which is something previously only supported for variables
declared as the base Object * type.
Meanwhile in the source file, instead of:
static void my_device_finalize(Object *obj);
static void my_device_class_init(ObjectClass *oc, void *data);
static void my_device_init(Object *obj);
static const TypeInfo my_device_info = {
.parent = TYPE_DEVICE,
.name = TYPE_MY_DEVICE,
.instance_size = sizeof(MyDevice),
.instance_init = my_device_init,
.instance_finalize = my_device_finalize,
.class_size = sizeof(MyDeviceClass),
.class_init = my_device_class_init,
};
static void
my_device_register_types(void)
{
type_register_static(&my_device_info);
}
type_init(my_device_register_types);
We now have
OBJECT_DEFINE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
Or, if a class needs to implement interfaces:
OBJECT_DEFINE_TYPE_WITH_INTERFACES(MyDevice, my_device, MY_DEVICE, DEVICE,
{ TYPE_USER_CREATABLE }, { NULL })
Or, if a class needs to be abstract
OBJECT_DEFINE_ABSTRACT_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
IOW, in both cases the maintainer now only has to think about the
interesting part of the code which implements useful functionality
and avoids much of the boilerplate.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200723181410.3145233-3-berrange@redhat.com>
[ehabkost: Fix G_DEFINE_AUTOPTR_CLEANUP_FUNC usage]
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <20200831210740.126168-3-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-31 23:07:24 +02:00
|
|
|
* @MODULE_OBJ_NAME: the object name in uppercase with underscore separators
|
|
|
|
*
|
2020-09-16 20:25:16 +02:00
|
|
|
* This does the same as OBJECT_DECLARE_TYPE(), but with no class struct
|
|
|
|
* declared.
|
qom: provide convenient macros for declaring and defining types
When creating new QOM types, there is a lot of boilerplate code that
must be repeated using a standard pattern. This is tedious to write
and liable to suffer from subtle inconsistencies. Thus it would
benefit from some simple automation.
QOM was loosely inspired by GLib's GObject, and indeed GObject suffers
from the same burden of boilerplate code, but has long provided a set of
macros to eliminate this burden in the source implementation. More
recently it has also provided a set of macros to eliminate this burden
in the header declaration.
In GLib there are the G_DECLARE_* and G_DEFINE_* family of macros
for the header declaration and source implementation respectively:
https://developer.gnome.org/gobject/stable/chapter-gobject.html
https://developer.gnome.org/gobject/stable/howto-gobject.html
This patch takes inspiration from GObject to provide the equivalent
functionality for QOM.
In the header file, instead of:
typedef struct MyDevice MyDevice;
typedef struct MyDeviceClass MyDeviceClass;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MyDeviceClass, object_unref)
#define MY_DEVICE_GET_CLASS(void *obj) \
OBJECT_GET_CLASS(MyDeviceClass, obj, TYPE_MY_DEVICE)
#define MY_DEVICE_CLASS(void *klass) \
OBJECT_CLASS_CHECK(MyDeviceClass, klass, TYPE_MY_DEVICE)
#define MY_DEVICE(void *obj)
OBJECT_CHECK(MyDevice, obj, TYPE_MY_DEVICE)
struct MyDeviceClass {
DeviceClass parent_class;
};
We now have
OBJECT_DECLARE_SIMPLE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
In cases where the class needs some virtual methods, it can be left
to be implemented manually using
OBJECT_DECLARE_TYPE(MyDevice, my_device, MY_DEVICE)
Note that these macros are including support for g_autoptr() for the
object types, which is something previously only supported for variables
declared as the base Object * type.
Meanwhile in the source file, instead of:
static void my_device_finalize(Object *obj);
static void my_device_class_init(ObjectClass *oc, void *data);
static void my_device_init(Object *obj);
static const TypeInfo my_device_info = {
.parent = TYPE_DEVICE,
.name = TYPE_MY_DEVICE,
.instance_size = sizeof(MyDevice),
.instance_init = my_device_init,
.instance_finalize = my_device_finalize,
.class_size = sizeof(MyDeviceClass),
.class_init = my_device_class_init,
};
static void
my_device_register_types(void)
{
type_register_static(&my_device_info);
}
type_init(my_device_register_types);
We now have
OBJECT_DEFINE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
Or, if a class needs to implement interfaces:
OBJECT_DEFINE_TYPE_WITH_INTERFACES(MyDevice, my_device, MY_DEVICE, DEVICE,
{ TYPE_USER_CREATABLE }, { NULL })
Or, if a class needs to be abstract
OBJECT_DEFINE_ABSTRACT_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
IOW, in both cases the maintainer now only has to think about the
interesting part of the code which implements useful functionality
and avoids much of the boilerplate.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200723181410.3145233-3-berrange@redhat.com>
[ehabkost: Fix G_DEFINE_AUTOPTR_CLEANUP_FUNC usage]
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <20200831210740.126168-3-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-31 23:07:24 +02:00
|
|
|
*
|
|
|
|
* This macro should be used unless the class struct needs to have
|
|
|
|
* virtual methods declared.
|
|
|
|
*/
|
qom: Remove module_obj_name parameter from OBJECT_DECLARE* macros
One of the goals of having less boilerplate on QOM declarations
is to avoid human error. Requiring an extra argument that is
never used is an opportunity for mistakes.
Remove the unused argument from OBJECT_DECLARE_TYPE and
OBJECT_DECLARE_SIMPLE_TYPE.
Coccinelle patch used to convert all users of the macros:
@@
declarer name OBJECT_DECLARE_TYPE;
identifier InstanceType, ClassType, lowercase, UPPERCASE;
@@
OBJECT_DECLARE_TYPE(InstanceType, ClassType,
- lowercase,
UPPERCASE);
@@
declarer name OBJECT_DECLARE_SIMPLE_TYPE;
identifier InstanceType, lowercase, UPPERCASE;
@@
OBJECT_DECLARE_SIMPLE_TYPE(InstanceType,
- lowercase,
UPPERCASE);
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Acked-by: Igor Mammedov <imammedo@redhat.com>
Acked-by: Paul Durrant <paul@xen.org>
Acked-by: Thomas Huth <thuth@redhat.com>
Message-Id: <20200916182519.415636-4-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-09-16 20:25:17 +02:00
|
|
|
#define OBJECT_DECLARE_SIMPLE_TYPE(InstanceType, MODULE_OBJ_NAME) \
|
2020-09-16 20:25:16 +02:00
|
|
|
typedef struct InstanceType InstanceType; \
|
|
|
|
\
|
|
|
|
G_DEFINE_AUTOPTR_CLEANUP_FUNC(InstanceType, object_unref) \
|
|
|
|
\
|
|
|
|
DECLARE_INSTANCE_CHECKER(InstanceType, MODULE_OBJ_NAME, TYPE_##MODULE_OBJ_NAME)
|
qom: provide convenient macros for declaring and defining types
When creating new QOM types, there is a lot of boilerplate code that
must be repeated using a standard pattern. This is tedious to write
and liable to suffer from subtle inconsistencies. Thus it would
benefit from some simple automation.
QOM was loosely inspired by GLib's GObject, and indeed GObject suffers
from the same burden of boilerplate code, but has long provided a set of
macros to eliminate this burden in the source implementation. More
recently it has also provided a set of macros to eliminate this burden
in the header declaration.
In GLib there are the G_DECLARE_* and G_DEFINE_* family of macros
for the header declaration and source implementation respectively:
https://developer.gnome.org/gobject/stable/chapter-gobject.html
https://developer.gnome.org/gobject/stable/howto-gobject.html
This patch takes inspiration from GObject to provide the equivalent
functionality for QOM.
In the header file, instead of:
typedef struct MyDevice MyDevice;
typedef struct MyDeviceClass MyDeviceClass;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MyDeviceClass, object_unref)
#define MY_DEVICE_GET_CLASS(void *obj) \
OBJECT_GET_CLASS(MyDeviceClass, obj, TYPE_MY_DEVICE)
#define MY_DEVICE_CLASS(void *klass) \
OBJECT_CLASS_CHECK(MyDeviceClass, klass, TYPE_MY_DEVICE)
#define MY_DEVICE(void *obj)
OBJECT_CHECK(MyDevice, obj, TYPE_MY_DEVICE)
struct MyDeviceClass {
DeviceClass parent_class;
};
We now have
OBJECT_DECLARE_SIMPLE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
In cases where the class needs some virtual methods, it can be left
to be implemented manually using
OBJECT_DECLARE_TYPE(MyDevice, my_device, MY_DEVICE)
Note that these macros are including support for g_autoptr() for the
object types, which is something previously only supported for variables
declared as the base Object * type.
Meanwhile in the source file, instead of:
static void my_device_finalize(Object *obj);
static void my_device_class_init(ObjectClass *oc, void *data);
static void my_device_init(Object *obj);
static const TypeInfo my_device_info = {
.parent = TYPE_DEVICE,
.name = TYPE_MY_DEVICE,
.instance_size = sizeof(MyDevice),
.instance_init = my_device_init,
.instance_finalize = my_device_finalize,
.class_size = sizeof(MyDeviceClass),
.class_init = my_device_class_init,
};
static void
my_device_register_types(void)
{
type_register_static(&my_device_info);
}
type_init(my_device_register_types);
We now have
OBJECT_DEFINE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
Or, if a class needs to implement interfaces:
OBJECT_DEFINE_TYPE_WITH_INTERFACES(MyDevice, my_device, MY_DEVICE, DEVICE,
{ TYPE_USER_CREATABLE }, { NULL })
Or, if a class needs to be abstract
OBJECT_DEFINE_ABSTRACT_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
IOW, in both cases the maintainer now only has to think about the
interesting part of the code which implements useful functionality
and avoids much of the boilerplate.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200723181410.3145233-3-berrange@redhat.com>
[ehabkost: Fix G_DEFINE_AUTOPTR_CLEANUP_FUNC usage]
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <20200831210740.126168-3-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-31 23:07:24 +02:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* OBJECT_DEFINE_TYPE_EXTENDED:
|
|
|
|
* @ModuleObjName: the object name with initial caps
|
|
|
|
* @module_obj_name: the object name in lowercase with underscore separators
|
|
|
|
* @MODULE_OBJ_NAME: the object name in uppercase with underscore separators
|
|
|
|
* @PARENT_MODULE_OBJ_NAME: the parent object name in uppercase with underscore
|
|
|
|
* separators
|
|
|
|
* @ABSTRACT: boolean flag to indicate whether the object can be instantiated
|
|
|
|
* @...: list of initializers for "InterfaceInfo" to declare implemented interfaces
|
|
|
|
*
|
|
|
|
* This macro is typically used in a source file, and will:
|
|
|
|
*
|
|
|
|
* - declare prototypes for _finalize, _class_init and _init methods
|
|
|
|
* - declare the TypeInfo struct instance
|
|
|
|
* - provide the constructor to register the type
|
|
|
|
*
|
|
|
|
* After using this macro, implementations of the _finalize, _class_init,
|
|
|
|
* and _init methods need to be written. Any of these can be zero-line
|
|
|
|
* no-op impls if no special logic is required for a given type.
|
|
|
|
*
|
|
|
|
* This macro should rarely be used, instead one of the more specialized
|
|
|
|
* macros is usually a better choice.
|
|
|
|
*/
|
|
|
|
#define OBJECT_DEFINE_TYPE_EXTENDED(ModuleObjName, module_obj_name, \
|
|
|
|
MODULE_OBJ_NAME, PARENT_MODULE_OBJ_NAME, \
|
|
|
|
ABSTRACT, ...) \
|
|
|
|
static void \
|
|
|
|
module_obj_name##_finalize(Object *obj); \
|
|
|
|
static void \
|
|
|
|
module_obj_name##_class_init(ObjectClass *oc, void *data); \
|
|
|
|
static void \
|
|
|
|
module_obj_name##_init(Object *obj); \
|
|
|
|
\
|
|
|
|
static const TypeInfo module_obj_name##_info = { \
|
|
|
|
.parent = TYPE_##PARENT_MODULE_OBJ_NAME, \
|
|
|
|
.name = TYPE_##MODULE_OBJ_NAME, \
|
|
|
|
.instance_size = sizeof(ModuleObjName), \
|
2020-09-16 02:46:34 +02:00
|
|
|
.instance_align = __alignof__(ModuleObjName), \
|
qom: provide convenient macros for declaring and defining types
When creating new QOM types, there is a lot of boilerplate code that
must be repeated using a standard pattern. This is tedious to write
and liable to suffer from subtle inconsistencies. Thus it would
benefit from some simple automation.
QOM was loosely inspired by GLib's GObject, and indeed GObject suffers
from the same burden of boilerplate code, but has long provided a set of
macros to eliminate this burden in the source implementation. More
recently it has also provided a set of macros to eliminate this burden
in the header declaration.
In GLib there are the G_DECLARE_* and G_DEFINE_* family of macros
for the header declaration and source implementation respectively:
https://developer.gnome.org/gobject/stable/chapter-gobject.html
https://developer.gnome.org/gobject/stable/howto-gobject.html
This patch takes inspiration from GObject to provide the equivalent
functionality for QOM.
In the header file, instead of:
typedef struct MyDevice MyDevice;
typedef struct MyDeviceClass MyDeviceClass;
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MyDeviceClass, object_unref)
#define MY_DEVICE_GET_CLASS(void *obj) \
OBJECT_GET_CLASS(MyDeviceClass, obj, TYPE_MY_DEVICE)
#define MY_DEVICE_CLASS(void *klass) \
OBJECT_CLASS_CHECK(MyDeviceClass, klass, TYPE_MY_DEVICE)
#define MY_DEVICE(void *obj)
OBJECT_CHECK(MyDevice, obj, TYPE_MY_DEVICE)
struct MyDeviceClass {
DeviceClass parent_class;
};
We now have
OBJECT_DECLARE_SIMPLE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
In cases where the class needs some virtual methods, it can be left
to be implemented manually using
OBJECT_DECLARE_TYPE(MyDevice, my_device, MY_DEVICE)
Note that these macros are including support for g_autoptr() for the
object types, which is something previously only supported for variables
declared as the base Object * type.
Meanwhile in the source file, instead of:
static void my_device_finalize(Object *obj);
static void my_device_class_init(ObjectClass *oc, void *data);
static void my_device_init(Object *obj);
static const TypeInfo my_device_info = {
.parent = TYPE_DEVICE,
.name = TYPE_MY_DEVICE,
.instance_size = sizeof(MyDevice),
.instance_init = my_device_init,
.instance_finalize = my_device_finalize,
.class_size = sizeof(MyDeviceClass),
.class_init = my_device_class_init,
};
static void
my_device_register_types(void)
{
type_register_static(&my_device_info);
}
type_init(my_device_register_types);
We now have
OBJECT_DEFINE_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
Or, if a class needs to implement interfaces:
OBJECT_DEFINE_TYPE_WITH_INTERFACES(MyDevice, my_device, MY_DEVICE, DEVICE,
{ TYPE_USER_CREATABLE }, { NULL })
Or, if a class needs to be abstract
OBJECT_DEFINE_ABSTRACT_TYPE(MyDevice, my_device, MY_DEVICE, DEVICE)
IOW, in both cases the maintainer now only has to think about the
interesting part of the code which implements useful functionality
and avoids much of the boilerplate.
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200723181410.3145233-3-berrange@redhat.com>
[ehabkost: Fix G_DEFINE_AUTOPTR_CLEANUP_FUNC usage]
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Message-Id: <20200831210740.126168-3-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-31 23:07:24 +02:00
|
|
|
.instance_init = module_obj_name##_init, \
|
|
|
|
.instance_finalize = module_obj_name##_finalize, \
|
|
|
|
.class_size = sizeof(ModuleObjName##Class), \
|
|
|
|
.class_init = module_obj_name##_class_init, \
|
|
|
|
.abstract = ABSTRACT, \
|
|
|
|
.interfaces = (InterfaceInfo[]) { __VA_ARGS__ } , \
|
|
|
|
}; \
|
|
|
|
\
|
|
|
|
static void \
|
|
|
|
module_obj_name##_register_types(void) \
|
|
|
|
{ \
|
|
|
|
type_register_static(&module_obj_name##_info); \
|
|
|
|
} \
|
|
|
|
type_init(module_obj_name##_register_types);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* OBJECT_DEFINE_TYPE:
|
|
|
|
* @ModuleObjName: the object name with initial caps
|
|
|
|
* @module_obj_name: the object name in lowercase with underscore separators
|
|
|
|
* @MODULE_OBJ_NAME: the object name in uppercase with underscore separators
|
|
|
|
* @PARENT_MODULE_OBJ_NAME: the parent object name in uppercase with underscore
|
|
|
|
* separators
|
|
|
|
*
|
|
|
|
* This is a specialization of OBJECT_DEFINE_TYPE_EXTENDED, which is suitable
|
|
|
|
* for the common case of a non-abstract type, without any interfaces.
|
|
|
|
*/
|
|
|
|
#define OBJECT_DEFINE_TYPE(ModuleObjName, module_obj_name, MODULE_OBJ_NAME, \
|
|
|
|
PARENT_MODULE_OBJ_NAME) \
|
|
|
|
OBJECT_DEFINE_TYPE_EXTENDED(ModuleObjName, module_obj_name, \
|
|
|
|
MODULE_OBJ_NAME, PARENT_MODULE_OBJ_NAME, \
|
|
|
|
false, { NULL })
|
|
|
|
|
|
|
|
/**
|
|
|
|
* OBJECT_DEFINE_TYPE_WITH_INTERFACES:
|
|
|
|
* @ModuleObjName: the object name with initial caps
|
|
|
|
* @module_obj_name: the object name in lowercase with underscore separators
|
|
|
|
* @MODULE_OBJ_NAME: the object name in uppercase with underscore separators
|
|
|
|
* @PARENT_MODULE_OBJ_NAME: the parent object name in uppercase with underscore
|
|
|
|
* separators
|
|
|
|
* @...: list of initializers for "InterfaceInfo" to declare implemented interfaces
|
|
|
|
*
|
|
|
|
* This is a specialization of OBJECT_DEFINE_TYPE_EXTENDED, which is suitable
|
|
|
|
* for the common case of a non-abstract type, with one or more implemented
|
|
|
|
* interfaces.
|
|
|
|
*
|
|
|
|
* Note when passing the list of interfaces, be sure to include the final
|
|
|
|
* NULL entry, e.g. { TYPE_USER_CREATABLE }, { NULL }
|
|
|
|
*/
|
|
|
|
#define OBJECT_DEFINE_TYPE_WITH_INTERFACES(ModuleObjName, module_obj_name, \
|
|
|
|
MODULE_OBJ_NAME, \
|
|
|
|
PARENT_MODULE_OBJ_NAME, ...) \
|
|
|
|
OBJECT_DEFINE_TYPE_EXTENDED(ModuleObjName, module_obj_name, \
|
|
|
|
MODULE_OBJ_NAME, PARENT_MODULE_OBJ_NAME, \
|
|
|
|
false, __VA_ARGS__)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* OBJECT_DEFINE_ABSTRACT_TYPE:
|
|
|
|
* @ModuleObjName: the object name with initial caps
|
|
|
|
* @module_obj_name: the object name in lowercase with underscore separators
|
|
|
|
* @MODULE_OBJ_NAME: the object name in uppercase with underscore separators
|
|
|
|
* @PARENT_MODULE_OBJ_NAME: the parent object name in uppercase with underscore
|
|
|
|
* separators
|
|
|
|
*
|
|
|
|
* This is a specialization of OBJECT_DEFINE_TYPE_EXTENDED, which is suitable
|
|
|
|
* for defining an abstract type, without any interfaces.
|
|
|
|
*/
|
|
|
|
#define OBJECT_DEFINE_ABSTRACT_TYPE(ModuleObjName, module_obj_name, \
|
|
|
|
MODULE_OBJ_NAME, PARENT_MODULE_OBJ_NAME) \
|
|
|
|
OBJECT_DEFINE_TYPE_EXTENDED(ModuleObjName, module_obj_name, \
|
|
|
|
MODULE_OBJ_NAME, PARENT_MODULE_OBJ_NAME, \
|
|
|
|
true, { NULL })
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* struct TypeInfo:
|
2011-12-04 00:10:08 +01:00
|
|
|
* @name: The name of the type.
|
|
|
|
* @parent: The name of the parent type.
|
|
|
|
* @instance_size: The size of the object (derivative of #Object). If
|
|
|
|
* @instance_size is 0, then the size of the object will be the size of the
|
|
|
|
* parent object.
|
2020-09-16 02:46:34 +02:00
|
|
|
* @instance_align: The required alignment of the object. If @instance_align
|
|
|
|
* is 0, then normal malloc alignment is sufficient; if non-zero, then we
|
|
|
|
* must use qemu_memalign for allocation.
|
2011-12-04 00:10:08 +01:00
|
|
|
* @instance_init: This function is called to initialize an object. The parent
|
|
|
|
* class will have already been initialized so the type is only responsible
|
|
|
|
* for initializing its own members.
|
2013-07-10 22:08:41 +02:00
|
|
|
* @instance_post_init: This function is called to finish initialization of
|
|
|
|
* an object, after all @instance_init functions were called.
|
2011-12-04 00:10:08 +01:00
|
|
|
* @instance_finalize: This function is called during object destruction. This
|
|
|
|
* is called before the parent @instance_finalize function has been called.
|
|
|
|
* An object should only free the members that are unique to its type in this
|
|
|
|
* function.
|
|
|
|
* @abstract: If this field is true, then the class is considered abstract and
|
|
|
|
* cannot be directly instantiated.
|
|
|
|
* @class_size: The size of the class object (derivative of #ObjectClass)
|
|
|
|
* for this object. If @class_size is 0, then the size of the class will be
|
|
|
|
* assumed to be the size of the parent class. This allows a type to avoid
|
|
|
|
* implementing an explicit class type if they are not adding additional
|
|
|
|
* virtual functions.
|
|
|
|
* @class_init: This function is called after all parent class initialization
|
2012-02-25 13:47:09 +01:00
|
|
|
* has occurred to allow a class to set its default virtual method pointers.
|
2011-12-04 00:10:08 +01:00
|
|
|
* This is also the function to use to override virtual methods from a parent
|
|
|
|
* class.
|
2012-05-02 13:30:55 +02:00
|
|
|
* @class_base_init: This function is called for all base classes after all
|
|
|
|
* parent class initialization has occurred, but before the class itself
|
|
|
|
* is initialized. This is the function to use to undo the effects of
|
2016-12-12 18:31:49 +01:00
|
|
|
* memcpy from the parent class to the descendants.
|
2018-12-04 15:20:10 +01:00
|
|
|
* @class_data: Data to pass to the @class_init,
|
|
|
|
* @class_base_init. This can be useful when building dynamic
|
2012-05-02 13:30:55 +02:00
|
|
|
* classes.
|
2011-12-04 00:10:08 +01:00
|
|
|
* @interfaces: The list of interfaces associated with this type. This
|
|
|
|
* should point to a static array that's terminated with a zero filled
|
|
|
|
* element.
|
|
|
|
*/
|
|
|
|
struct TypeInfo
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
const char *parent;
|
|
|
|
|
|
|
|
size_t instance_size;
|
2020-09-16 02:46:34 +02:00
|
|
|
size_t instance_align;
|
2011-12-04 00:10:08 +01:00
|
|
|
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;
|
|
|
|
size_t class_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_data;
|
|
|
|
|
|
|
|
InterfaceInfo *interfaces;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* OBJECT:
|
|
|
|
* @obj: A derivative of #Object
|
|
|
|
*
|
|
|
|
* Converts an object to a #Object. Since all objects are #Objects,
|
|
|
|
* this function will always succeed.
|
|
|
|
*/
|
|
|
|
#define OBJECT(obj) \
|
|
|
|
((Object *)(obj))
|
|
|
|
|
2012-02-03 11:48:11 +01:00
|
|
|
/**
|
|
|
|
* OBJECT_CLASS:
|
2012-02-16 18:03:18 +01:00
|
|
|
* @class: A derivative of #ObjectClass.
|
2012-02-03 11:48:11 +01:00
|
|
|
*
|
|
|
|
* Converts a class to an #ObjectClass. Since all objects are #Objects,
|
|
|
|
* this function will always succeed.
|
|
|
|
*/
|
|
|
|
#define OBJECT_CLASS(class) \
|
|
|
|
((ObjectClass *)(class))
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
|
|
|
* OBJECT_CHECK:
|
|
|
|
* @type: The C type to use for the return value.
|
|
|
|
* @obj: A derivative of @type to cast.
|
|
|
|
* @name: The QOM typename of @type
|
|
|
|
*
|
|
|
|
* A type safe version of @object_dynamic_cast_assert. Typically each class
|
|
|
|
* will define a macro based on this type to perform type safe dynamic_casts to
|
|
|
|
* this object type.
|
|
|
|
*
|
|
|
|
* If an invalid object is passed to this function, a run time assert will be
|
|
|
|
* generated.
|
|
|
|
*/
|
|
|
|
#define OBJECT_CHECK(type, obj, name) \
|
2013-05-10 14:16:38 +02:00
|
|
|
((type *)object_dynamic_cast_assert(OBJECT(obj), (name), \
|
|
|
|
__FILE__, __LINE__, __func__))
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* OBJECT_CLASS_CHECK:
|
2015-11-03 03:36:42 +01:00
|
|
|
* @class_type: The C type to use for the return value.
|
|
|
|
* @class: A derivative class of @class_type to cast.
|
|
|
|
* @name: the QOM typename of @class_type.
|
2011-12-04 00:10:08 +01:00
|
|
|
*
|
2012-02-03 11:48:11 +01:00
|
|
|
* A type safe version of @object_class_dynamic_cast_assert. This macro is
|
|
|
|
* typically wrapped by each type to perform type safe casts of a class to a
|
|
|
|
* specific class type.
|
2011-12-04 00:10:08 +01:00
|
|
|
*/
|
2015-11-03 03:36:42 +01:00
|
|
|
#define OBJECT_CLASS_CHECK(class_type, class, name) \
|
|
|
|
((class_type *)object_class_dynamic_cast_assert(OBJECT_CLASS(class), (name), \
|
2013-05-10 14:16:38 +02:00
|
|
|
__FILE__, __LINE__, __func__))
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* OBJECT_GET_CLASS:
|
|
|
|
* @class: The C type to use for the return value.
|
|
|
|
* @obj: The object to obtain the class for.
|
|
|
|
* @name: The QOM typename of @obj.
|
|
|
|
*
|
|
|
|
* This function will return a specific class for a given object. Its generally
|
|
|
|
* used by each type to provide a type safe macro to get a specific class type
|
|
|
|
* from an object.
|
|
|
|
*/
|
|
|
|
#define OBJECT_GET_CLASS(class, obj, name) \
|
|
|
|
OBJECT_CLASS_CHECK(class, object_get_class(OBJECT(obj)), name)
|
|
|
|
|
2012-08-10 05:16:10 +02:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* struct InterfaceInfo:
|
2012-08-10 05:16:10 +02:00
|
|
|
* @type: The name of the interface.
|
|
|
|
*
|
|
|
|
* The information associated with an interface.
|
|
|
|
*/
|
|
|
|
struct InterfaceInfo {
|
|
|
|
const char *type;
|
|
|
|
};
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
2020-10-03 04:41:21 +02:00
|
|
|
* struct InterfaceClass:
|
2011-12-04 00:10:08 +01:00
|
|
|
* @parent_class: the base class
|
|
|
|
*
|
|
|
|
* The class for all interfaces. Subclasses of this class should only add
|
|
|
|
* virtual methods.
|
|
|
|
*/
|
|
|
|
struct InterfaceClass
|
|
|
|
{
|
|
|
|
ObjectClass parent_class;
|
2020-09-11 00:15:19 +02:00
|
|
|
/* private: */
|
2012-08-10 05:16:10 +02:00
|
|
|
ObjectClass *concrete_class;
|
2013-12-03 16:41:59 +01:00
|
|
|
Type interface_type;
|
2011-12-04 00:10:08 +01:00
|
|
|
};
|
|
|
|
|
2012-08-10 05:16:10 +02:00
|
|
|
#define TYPE_INTERFACE "interface"
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
2012-08-10 05:16:10 +02:00
|
|
|
* INTERFACE_CLASS:
|
|
|
|
* @klass: class to cast from
|
|
|
|
* Returns: An #InterfaceClass or raise an error if cast is invalid
|
2011-12-04 00:10:08 +01:00
|
|
|
*/
|
2012-08-10 05:16:10 +02:00
|
|
|
#define INTERFACE_CLASS(klass) \
|
|
|
|
OBJECT_CLASS_CHECK(InterfaceClass, klass, TYPE_INTERFACE)
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2012-08-10 05:16:10 +02:00
|
|
|
/**
|
|
|
|
* INTERFACE_CHECK:
|
|
|
|
* @interface: the type to return
|
|
|
|
* @obj: the object to convert to an interface
|
|
|
|
* @name: the interface type name
|
|
|
|
*
|
|
|
|
* Returns: @obj casted to @interface if cast is valid, otherwise raise error.
|
|
|
|
*/
|
|
|
|
#define INTERFACE_CHECK(interface, obj, name) \
|
2013-05-10 14:16:38 +02:00
|
|
|
((interface *)object_dynamic_cast_assert(OBJECT((obj)), (name), \
|
|
|
|
__FILE__, __LINE__, __func__))
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2019-11-13 13:57:55 +01:00
|
|
|
/**
|
|
|
|
* object_new_with_class:
|
|
|
|
* @klass: The class to instantiate.
|
|
|
|
*
|
|
|
|
* This function will initialize a new object using heap allocated memory.
|
|
|
|
* The returned object has a reference count of 1, and will be freed when
|
|
|
|
* the last reference is dropped.
|
|
|
|
*
|
|
|
|
* Returns: The newly allocated and instantiated object.
|
|
|
|
*/
|
|
|
|
Object *object_new_with_class(ObjectClass *klass);
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
|
|
|
* object_new:
|
|
|
|
* @typename: The name of the type of the object to instantiate.
|
|
|
|
*
|
2013-01-25 14:12:39 +01:00
|
|
|
* This function will initialize a new object using heap allocated memory.
|
|
|
|
* The returned object has a reference count of 1, and will be freed when
|
|
|
|
* the last reference is dropped.
|
2011-12-04 00:10:08 +01:00
|
|
|
*
|
|
|
|
* Returns: The newly allocated and instantiated object.
|
|
|
|
*/
|
|
|
|
Object *object_new(const char *typename);
|
|
|
|
|
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_new_with_props:
|
|
|
|
* @typename: The name of the type of the object to instantiate.
|
|
|
|
* @parent: the parent object
|
|
|
|
* @id: The unique ID of the object
|
|
|
|
* @errp: pointer to error object
|
|
|
|
* @...: list of property names and values
|
|
|
|
*
|
|
|
|
* This function will initialize a new object using heap allocated memory.
|
|
|
|
* The returned object has a reference count of 1, and will be freed when
|
|
|
|
* the last reference is dropped.
|
|
|
|
*
|
|
|
|
* The @id parameter will be used when registering the object as a
|
|
|
|
* child of @parent in the composition tree.
|
|
|
|
*
|
|
|
|
* The variadic parameters are a list of pairs of (propname, propvalue)
|
|
|
|
* strings. The propname of %NULL indicates the end of the property
|
|
|
|
* list. If the object implements the user creatable interface, the
|
|
|
|
* object will be marked complete once all the properties have been
|
|
|
|
* processed.
|
|
|
|
*
|
2020-09-11 00:15:24 +02:00
|
|
|
* .. code-block:: c
|
|
|
|
* :caption: Creating an object with properties
|
|
|
|
*
|
2020-09-11 00:15:23 +02:00
|
|
|
* Error *err = NULL;
|
|
|
|
* Object *obj;
|
|
|
|
*
|
|
|
|
* obj = object_new_with_props(TYPE_MEMORY_BACKEND_FILE,
|
|
|
|
* object_get_objects_root(),
|
|
|
|
* "hostmem0",
|
|
|
|
* &err,
|
|
|
|
* "share", "yes",
|
|
|
|
* "mem-path", "/dev/shm/somefile",
|
|
|
|
* "prealloc", "yes",
|
|
|
|
* "size", "1048576",
|
|
|
|
* NULL);
|
|
|
|
*
|
|
|
|
* if (!obj) {
|
|
|
|
* error_reportf_err(err, "Cannot create memory backend: ");
|
|
|
|
* }
|
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
|
|
|
*
|
|
|
|
* The returned object will have one stable reference maintained
|
|
|
|
* for as long as it is present in the object hierarchy.
|
|
|
|
*
|
|
|
|
* Returns: The newly allocated, instantiated & initialized object.
|
|
|
|
*/
|
|
|
|
Object *object_new_with_props(const char *typename,
|
|
|
|
Object *parent,
|
|
|
|
const char *id,
|
|
|
|
Error **errp,
|
2022-02-23 21:58:22 +01:00
|
|
|
...) G_GNUC_NULL_TERMINATED;
|
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_new_with_propv:
|
|
|
|
* @typename: The name of the type of the object to instantiate.
|
|
|
|
* @parent: the parent object
|
|
|
|
* @id: The unique ID of the object
|
|
|
|
* @errp: pointer to error object
|
|
|
|
* @vargs: list of property names and values
|
|
|
|
*
|
|
|
|
* See object_new_with_props() for documentation.
|
|
|
|
*/
|
|
|
|
Object *object_new_with_propv(const char *typename,
|
|
|
|
Object *parent,
|
|
|
|
const char *id,
|
|
|
|
Error **errp,
|
|
|
|
va_list vargs);
|
|
|
|
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_apply_global_props(Object *obj, const GPtrArray *props,
|
2018-11-26 19:04:32 +01:00
|
|
|
Error **errp);
|
2019-03-08 14:14:35 +01:00
|
|
|
void object_set_machine_compat_props(GPtrArray *compat_props);
|
|
|
|
void object_set_accelerator_compat_props(GPtrArray *compat_props);
|
2020-08-14 09:24:50 +02:00
|
|
|
void object_register_sugar_prop(const char *driver, const char *prop,
|
|
|
|
const char *value, bool optional);
|
2019-03-08 14:14:35 +01:00
|
|
|
void object_apply_compat_props(Object *obj);
|
2018-11-26 19:04:32 +01:00
|
|
|
|
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_set_props:
|
|
|
|
* @obj: the object instance to set properties on
|
|
|
|
* @errp: pointer to error object
|
|
|
|
* @...: list of property names and values
|
|
|
|
*
|
|
|
|
* This function will set a list of properties on an existing object
|
|
|
|
* instance.
|
|
|
|
*
|
|
|
|
* The variadic parameters are a list of pairs of (propname, propvalue)
|
|
|
|
* strings. The propname of %NULL indicates the end of the property
|
|
|
|
* list.
|
|
|
|
*
|
2020-09-11 00:15:24 +02:00
|
|
|
* .. code-block:: c
|
|
|
|
* :caption: Update an object's properties
|
|
|
|
*
|
2020-09-11 00:15:23 +02:00
|
|
|
* Error *err = NULL;
|
|
|
|
* Object *obj = ...get / create object...;
|
|
|
|
*
|
|
|
|
* if (!object_set_props(obj,
|
|
|
|
* &err,
|
|
|
|
* "share", "yes",
|
|
|
|
* "mem-path", "/dev/shm/somefile",
|
|
|
|
* "prealloc", "yes",
|
|
|
|
* "size", "1048576",
|
|
|
|
* NULL)) {
|
|
|
|
* error_reportf_err(err, "Cannot set properties: ");
|
|
|
|
* }
|
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
|
|
|
*
|
|
|
|
* The returned object will have one stable reference maintained
|
|
|
|
* for as long as it is present in the object hierarchy.
|
|
|
|
*
|
2020-07-07 18:05:58 +02:00
|
|
|
* Returns: %true on success, %false on error.
|
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
|
|
|
*/
|
2022-02-23 21:58:22 +01:00
|
|
|
bool object_set_props(Object *obj, Error **errp, ...) G_GNUC_NULL_TERMINATED;
|
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_set_propv:
|
|
|
|
* @obj: the object instance to set properties on
|
|
|
|
* @errp: pointer to error object
|
|
|
|
* @vargs: list of property names and values
|
|
|
|
*
|
|
|
|
* See object_set_props() for documentation.
|
|
|
|
*
|
2020-07-07 18:05:58 +02:00
|
|
|
* Returns: %true on success, %false on error.
|
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
|
|
|
*/
|
2020-07-07 18:05:58 +02:00
|
|
|
bool object_set_propv(Object *obj, Error **errp, va_list vargs);
|
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
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
|
|
|
* object_initialize:
|
|
|
|
* @obj: A pointer to the memory to be used for the object.
|
2013-08-23 19:37:12 +02:00
|
|
|
* @size: The maximum size available at @obj for the object.
|
2011-12-04 00:10:08 +01:00
|
|
|
* @typename: The name of the type of the object to instantiate.
|
|
|
|
*
|
|
|
|
* This function will initialize an object. The memory for the object should
|
2013-01-25 14:12:39 +01:00
|
|
|
* have already been allocated. The returned object has a reference count of 1,
|
|
|
|
* and will be finalized when the last reference is dropped.
|
2011-12-04 00:10:08 +01:00
|
|
|
*/
|
2013-08-23 19:37:12 +02:00
|
|
|
void object_initialize(void *obj, size_t size, const char *typename);
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2018-07-16 14:59:18 +02:00
|
|
|
/**
|
qom: Less verbose object_initialize_child()
All users of object_initialize_child() pass the obvious child size
argument. Almost all pass &error_abort and no properties. Tiresome.
Rename object_initialize_child() to
object_initialize_child_with_props() to free the name. New
convenience wrapper object_initialize_child() automates the size
argument, and passes &error_abort and no properties.
Rename object_initialize_childv() to
object_initialize_child_with_propsv() for consistency.
Convert callers with this Coccinelle script:
@@
expression parent, propname, type;
expression child, size;
symbol error_abort;
@@
- object_initialize_child(parent, propname, OBJECT(child), size, type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, size, type, &error_abort, NULL)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, child, sizeof(*child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, type)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, &child, sizeof(child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, &child, type)
@@
expression parent, propname, type;
expression child, size, err;
expression list props;
@@
- object_initialize_child(parent, propname, child, size, type, err, props)
+ object_initialize_child_with_props(parent, propname, child, size, type, err, props)
Note that Coccinelle chokes on ARMSSE typedef vs. macro in
hw/arm/armsse.c. Worked around by temporarily renaming the macro for
the spatch run.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Alistair Francis <alistair.francis@wdc.com>
[Rebased: machine opentitan is new (commit fe0fe4735e7)]
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-37-armbru@redhat.com>
2020-06-10 07:32:25 +02:00
|
|
|
* object_initialize_child_with_props:
|
2018-07-16 14:59:18 +02:00
|
|
|
* @parentobj: The parent object to add a property to
|
|
|
|
* @propname: The name of the property
|
|
|
|
* @childobj: A pointer to the memory to be used for the object.
|
|
|
|
* @size: The maximum size available at @childobj for the object.
|
|
|
|
* @type: The name of the type of the object to instantiate.
|
|
|
|
* @errp: If an error occurs, a pointer to an area to store the error
|
|
|
|
* @...: list of property names and values
|
|
|
|
*
|
|
|
|
* This function will initialize an object. The memory for the object should
|
|
|
|
* have already been allocated. The object will then be added as child property
|
|
|
|
* to a parent with object_property_add_child() function. The returned object
|
|
|
|
* has a reference count of 1 (for the "child<...>" property from the parent),
|
|
|
|
* so the object will be finalized automatically when the parent gets removed.
|
|
|
|
*
|
|
|
|
* The variadic parameters are a list of pairs of (propname, propvalue)
|
|
|
|
* strings. The propname of %NULL indicates the end of the property list.
|
|
|
|
* If the object implements the user creatable interface, the object will
|
|
|
|
* be marked complete once all the properties have been processed.
|
2020-07-07 18:05:55 +02:00
|
|
|
*
|
|
|
|
* Returns: %true on success, %false on failure.
|
2018-07-16 14:59:18 +02:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_initialize_child_with_props(Object *parentobj,
|
qom: Less verbose object_initialize_child()
All users of object_initialize_child() pass the obvious child size
argument. Almost all pass &error_abort and no properties. Tiresome.
Rename object_initialize_child() to
object_initialize_child_with_props() to free the name. New
convenience wrapper object_initialize_child() automates the size
argument, and passes &error_abort and no properties.
Rename object_initialize_childv() to
object_initialize_child_with_propsv() for consistency.
Convert callers with this Coccinelle script:
@@
expression parent, propname, type;
expression child, size;
symbol error_abort;
@@
- object_initialize_child(parent, propname, OBJECT(child), size, type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, size, type, &error_abort, NULL)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, child, sizeof(*child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, type)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, &child, sizeof(child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, &child, type)
@@
expression parent, propname, type;
expression child, size, err;
expression list props;
@@
- object_initialize_child(parent, propname, child, size, type, err, props)
+ object_initialize_child_with_props(parent, propname, child, size, type, err, props)
Note that Coccinelle chokes on ARMSSE typedef vs. macro in
hw/arm/armsse.c. Worked around by temporarily renaming the macro for
the spatch run.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Alistair Francis <alistair.francis@wdc.com>
[Rebased: machine opentitan is new (commit fe0fe4735e7)]
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-37-armbru@redhat.com>
2020-06-10 07:32:25 +02:00
|
|
|
const char *propname,
|
2018-07-16 14:59:18 +02:00
|
|
|
void *childobj, size_t size, const char *type,
|
2022-02-23 21:58:22 +01:00
|
|
|
Error **errp, ...) G_GNUC_NULL_TERMINATED;
|
2018-07-16 14:59:18 +02:00
|
|
|
|
|
|
|
/**
|
qom: Less verbose object_initialize_child()
All users of object_initialize_child() pass the obvious child size
argument. Almost all pass &error_abort and no properties. Tiresome.
Rename object_initialize_child() to
object_initialize_child_with_props() to free the name. New
convenience wrapper object_initialize_child() automates the size
argument, and passes &error_abort and no properties.
Rename object_initialize_childv() to
object_initialize_child_with_propsv() for consistency.
Convert callers with this Coccinelle script:
@@
expression parent, propname, type;
expression child, size;
symbol error_abort;
@@
- object_initialize_child(parent, propname, OBJECT(child), size, type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, size, type, &error_abort, NULL)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, child, sizeof(*child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, type)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, &child, sizeof(child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, &child, type)
@@
expression parent, propname, type;
expression child, size, err;
expression list props;
@@
- object_initialize_child(parent, propname, child, size, type, err, props)
+ object_initialize_child_with_props(parent, propname, child, size, type, err, props)
Note that Coccinelle chokes on ARMSSE typedef vs. macro in
hw/arm/armsse.c. Worked around by temporarily renaming the macro for
the spatch run.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Alistair Francis <alistair.francis@wdc.com>
[Rebased: machine opentitan is new (commit fe0fe4735e7)]
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-37-armbru@redhat.com>
2020-06-10 07:32:25 +02:00
|
|
|
* object_initialize_child_with_propsv:
|
2018-07-16 14:59:18 +02:00
|
|
|
* @parentobj: The parent object to add a property to
|
|
|
|
* @propname: The name of the property
|
|
|
|
* @childobj: A pointer to the memory to be used for the object.
|
|
|
|
* @size: The maximum size available at @childobj for the object.
|
|
|
|
* @type: The name of the type of the object to instantiate.
|
|
|
|
* @errp: If an error occurs, a pointer to an area to store the error
|
|
|
|
* @vargs: list of property names and values
|
|
|
|
*
|
|
|
|
* See object_initialize_child() for documentation.
|
2020-07-07 18:05:55 +02:00
|
|
|
*
|
|
|
|
* Returns: %true on success, %false on failure.
|
2018-07-16 14:59:18 +02:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_initialize_child_with_propsv(Object *parentobj,
|
qom: Less verbose object_initialize_child()
All users of object_initialize_child() pass the obvious child size
argument. Almost all pass &error_abort and no properties. Tiresome.
Rename object_initialize_child() to
object_initialize_child_with_props() to free the name. New
convenience wrapper object_initialize_child() automates the size
argument, and passes &error_abort and no properties.
Rename object_initialize_childv() to
object_initialize_child_with_propsv() for consistency.
Convert callers with this Coccinelle script:
@@
expression parent, propname, type;
expression child, size;
symbol error_abort;
@@
- object_initialize_child(parent, propname, OBJECT(child), size, type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, size, type, &error_abort, NULL)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, child, sizeof(*child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, type)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, &child, sizeof(child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, &child, type)
@@
expression parent, propname, type;
expression child, size, err;
expression list props;
@@
- object_initialize_child(parent, propname, child, size, type, err, props)
+ object_initialize_child_with_props(parent, propname, child, size, type, err, props)
Note that Coccinelle chokes on ARMSSE typedef vs. macro in
hw/arm/armsse.c. Worked around by temporarily renaming the macro for
the spatch run.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Alistair Francis <alistair.francis@wdc.com>
[Rebased: machine opentitan is new (commit fe0fe4735e7)]
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-37-armbru@redhat.com>
2020-06-10 07:32:25 +02:00
|
|
|
const char *propname,
|
2018-07-16 14:59:18 +02:00
|
|
|
void *childobj, size_t size, const char *type,
|
|
|
|
Error **errp, va_list vargs);
|
|
|
|
|
qom: Less verbose object_initialize_child()
All users of object_initialize_child() pass the obvious child size
argument. Almost all pass &error_abort and no properties. Tiresome.
Rename object_initialize_child() to
object_initialize_child_with_props() to free the name. New
convenience wrapper object_initialize_child() automates the size
argument, and passes &error_abort and no properties.
Rename object_initialize_childv() to
object_initialize_child_with_propsv() for consistency.
Convert callers with this Coccinelle script:
@@
expression parent, propname, type;
expression child, size;
symbol error_abort;
@@
- object_initialize_child(parent, propname, OBJECT(child), size, type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, size, type, &error_abort, NULL)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, child, sizeof(*child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, type)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, &child, sizeof(child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, &child, type)
@@
expression parent, propname, type;
expression child, size, err;
expression list props;
@@
- object_initialize_child(parent, propname, child, size, type, err, props)
+ object_initialize_child_with_props(parent, propname, child, size, type, err, props)
Note that Coccinelle chokes on ARMSSE typedef vs. macro in
hw/arm/armsse.c. Worked around by temporarily renaming the macro for
the spatch run.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Alistair Francis <alistair.francis@wdc.com>
[Rebased: machine opentitan is new (commit fe0fe4735e7)]
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-37-armbru@redhat.com>
2020-06-10 07:32:25 +02:00
|
|
|
/**
|
|
|
|
* object_initialize_child:
|
|
|
|
* @parent: The parent object to add a property to
|
|
|
|
* @propname: The name of the property
|
|
|
|
* @child: A precisely typed pointer to the memory to be used for the
|
|
|
|
* object.
|
|
|
|
* @type: The name of the type of the object to instantiate.
|
|
|
|
*
|
2020-09-11 00:15:24 +02:00
|
|
|
* This is like::
|
|
|
|
*
|
|
|
|
* object_initialize_child_with_props(parent, propname,
|
|
|
|
* child, sizeof(*child), type,
|
|
|
|
* &error_abort, NULL)
|
qom: Less verbose object_initialize_child()
All users of object_initialize_child() pass the obvious child size
argument. Almost all pass &error_abort and no properties. Tiresome.
Rename object_initialize_child() to
object_initialize_child_with_props() to free the name. New
convenience wrapper object_initialize_child() automates the size
argument, and passes &error_abort and no properties.
Rename object_initialize_childv() to
object_initialize_child_with_propsv() for consistency.
Convert callers with this Coccinelle script:
@@
expression parent, propname, type;
expression child, size;
symbol error_abort;
@@
- object_initialize_child(parent, propname, OBJECT(child), size, type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, size, type, &error_abort, NULL)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, child, sizeof(*child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, child, type)
@@
expression parent, propname, type;
expression child;
symbol error_abort;
@@
- object_initialize_child(parent, propname, &child, sizeof(child), type, &error_abort, NULL)
+ object_initialize_child(parent, propname, &child, type)
@@
expression parent, propname, type;
expression child, size, err;
expression list props;
@@
- object_initialize_child(parent, propname, child, size, type, err, props)
+ object_initialize_child_with_props(parent, propname, child, size, type, err, props)
Note that Coccinelle chokes on ARMSSE typedef vs. macro in
hw/arm/armsse.c. Worked around by temporarily renaming the macro for
the spatch run.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Alistair Francis <alistair.francis@wdc.com>
[Rebased: machine opentitan is new (commit fe0fe4735e7)]
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-37-armbru@redhat.com>
2020-06-10 07:32:25 +02:00
|
|
|
*/
|
|
|
|
#define object_initialize_child(parent, propname, child, type) \
|
|
|
|
object_initialize_child_internal((parent), (propname), \
|
|
|
|
(child), sizeof(*(child)), (type))
|
|
|
|
void object_initialize_child_internal(Object *parent, const char *propname,
|
|
|
|
void *child, size_t size,
|
|
|
|
const char *type);
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
|
|
|
* object_dynamic_cast:
|
|
|
|
* @obj: The object to cast.
|
|
|
|
* @typename: The @typename to cast to.
|
|
|
|
*
|
|
|
|
* This function will determine if @obj is-a @typename. @obj can refer to an
|
|
|
|
* object or an interface associated with an object.
|
|
|
|
*
|
|
|
|
* Returns: This function returns @obj on success or #NULL on failure.
|
|
|
|
*/
|
|
|
|
Object *object_dynamic_cast(Object *obj, const char *typename);
|
|
|
|
|
|
|
|
/**
|
2012-02-16 18:03:19 +01:00
|
|
|
* object_dynamic_cast_assert:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: The object to cast.
|
|
|
|
* @typename: The @typename to cast to.
|
|
|
|
* @file: Source code file where function was called
|
|
|
|
* @line: Source code line where function was called
|
|
|
|
* @func: Name of function where this function was called
|
2011-12-04 00:10:08 +01:00
|
|
|
*
|
|
|
|
* See object_dynamic_cast() for a description of the parameters of this
|
|
|
|
* function. The only difference in behavior is that this function asserts
|
2013-05-10 14:16:40 +02:00
|
|
|
* instead of returning #NULL on failure if QOM cast debugging is enabled.
|
|
|
|
* This function is not meant to be called directly, but only through
|
|
|
|
* the wrapper macro OBJECT_CHECK.
|
2011-12-04 00:10:08 +01:00
|
|
|
*/
|
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
|
|
|
|
|
|
|
/**
|
|
|
|
* object_get_class:
|
|
|
|
* @obj: A derivative of #Object
|
|
|
|
*
|
|
|
|
* Returns: The #ObjectClass of the type associated with @obj.
|
|
|
|
*/
|
|
|
|
ObjectClass *object_get_class(Object *obj);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_get_typename:
|
|
|
|
* @obj: A derivative of #Object.
|
|
|
|
*
|
|
|
|
* Returns: The QOM typename of @obj.
|
|
|
|
*/
|
2017-07-14 04:14:50 +02:00
|
|
|
const char *object_get_typename(const Object *obj);
|
2011-12-04 00:10:08 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* type_register_static:
|
|
|
|
* @info: The #TypeInfo of the new type.
|
|
|
|
*
|
|
|
|
* @info and all of the strings it points to should exist for the life time
|
|
|
|
* that the type is registered.
|
|
|
|
*
|
2017-10-04 12:08:00 +02:00
|
|
|
* Returns: the new #Type.
|
2011-12-04 00:10:08 +01:00
|
|
|
*/
|
|
|
|
Type type_register_static(const TypeInfo *info);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* type_register:
|
|
|
|
* @info: The #TypeInfo of the new type
|
|
|
|
*
|
2012-02-26 18:46:12 +01:00
|
|
|
* Unlike type_register_static(), this call does not require @info or its
|
2011-12-04 00:10:08 +01:00
|
|
|
* string members to continue to exist after the call returns.
|
|
|
|
*
|
2017-10-04 12:08:00 +02:00
|
|
|
* Returns: the new #Type.
|
2011-12-04 00:10:08 +01:00
|
|
|
*/
|
|
|
|
Type type_register(const TypeInfo *info);
|
|
|
|
|
2017-10-09 21:50:49 +02:00
|
|
|
/**
|
|
|
|
* type_register_static_array:
|
|
|
|
* @infos: The array of the new type #TypeInfo structures.
|
|
|
|
* @nr_infos: number of entries in @infos
|
|
|
|
*
|
|
|
|
* @infos and all of the strings it points to should exist for the life time
|
|
|
|
* that the type is registered.
|
|
|
|
*/
|
|
|
|
void type_register_static_array(const TypeInfo *infos, int nr_infos);
|
|
|
|
|
2017-10-09 21:50:50 +02:00
|
|
|
/**
|
|
|
|
* DEFINE_TYPES:
|
|
|
|
* @type_array: The array containing #TypeInfo structures to register
|
|
|
|
*
|
|
|
|
* @type_array should be static constant that exists for the life time
|
|
|
|
* that the type is registered.
|
|
|
|
*/
|
|
|
|
#define DEFINE_TYPES(type_array) \
|
|
|
|
static void do_qemu_init_ ## type_array(void) \
|
|
|
|
{ \
|
|
|
|
type_register_static_array(type_array, ARRAY_SIZE(type_array)); \
|
|
|
|
} \
|
|
|
|
type_init(do_qemu_init_ ## type_array)
|
|
|
|
|
2020-11-02 17:08:07 +01:00
|
|
|
/**
|
|
|
|
* type_print_class_properties:
|
|
|
|
* @type: a QOM class name
|
|
|
|
*
|
|
|
|
* Print the object's class properties to stdout or the monitor.
|
|
|
|
* Return whether an object was found.
|
|
|
|
*/
|
|
|
|
bool type_print_class_properties(const char *type);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_set_properties_from_keyval:
|
|
|
|
* @obj: a QOM object
|
|
|
|
* @qdict: a dictionary with the properties to be set
|
|
|
|
* @from_json: true if leaf values of @qdict are typed, false if they
|
|
|
|
* are strings
|
|
|
|
* @errp: pointer to error object
|
|
|
|
*
|
|
|
|
* For each key in the dictionary, parse the value string if needed,
|
|
|
|
* then set the corresponding property in @obj.
|
|
|
|
*/
|
|
|
|
void object_set_properties_from_keyval(Object *obj, const QDict *qdict,
|
|
|
|
bool from_json, Error **errp);
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
|
|
|
* object_class_dynamic_cast_assert:
|
|
|
|
* @klass: The #ObjectClass to attempt to cast.
|
|
|
|
* @typename: The QOM typename of the class to cast to.
|
2020-09-11 00:15:18 +02:00
|
|
|
* @file: Source code file where function was called
|
|
|
|
* @line: Source code line where function was called
|
|
|
|
* @func: Name of function where this function was called
|
2011-12-04 00:10:08 +01:00
|
|
|
*
|
2013-05-10 14:16:35 +02:00
|
|
|
* See object_class_dynamic_cast() for a description of the parameters
|
|
|
|
* of this function. The only difference in behavior is that this function
|
2013-05-10 14:16:40 +02:00
|
|
|
* asserts instead of returning #NULL on failure if QOM cast debugging is
|
|
|
|
* enabled. This function is not meant to be called directly, but only through
|
2020-09-16 21:30:59 +02:00
|
|
|
* the wrapper macro OBJECT_CLASS_CHECK.
|
2011-12-04 00:10:08 +01:00
|
|
|
*/
|
|
|
|
ObjectClass *object_class_dynamic_cast_assert(ObjectClass *klass,
|
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:35 +02:00
|
|
|
/**
|
|
|
|
* object_class_dynamic_cast:
|
|
|
|
* @klass: The #ObjectClass to attempt to cast.
|
|
|
|
* @typename: The QOM typename of the class to cast to.
|
|
|
|
*
|
|
|
|
* Returns: If @typename is a class, this function returns @klass if
|
|
|
|
* @typename is a subtype of @klass, else returns #NULL.
|
|
|
|
*
|
|
|
|
* If @typename is an interface, this function returns the interface
|
|
|
|
* definition for @klass if @klass implements it unambiguously; #NULL
|
|
|
|
* is returned if @klass does not implement the interface or if multiple
|
|
|
|
* classes or interfaces on the hierarchy leading to @klass implement
|
|
|
|
* it. (FIXME: perhaps this can be detected at type definition time?)
|
|
|
|
*/
|
2011-12-04 00:10:08 +01:00
|
|
|
ObjectClass *object_class_dynamic_cast(ObjectClass *klass,
|
|
|
|
const char *typename);
|
|
|
|
|
2012-05-02 13:30:54 +02:00
|
|
|
/**
|
|
|
|
* object_class_get_parent:
|
|
|
|
* @klass: The class to obtain the parent for.
|
|
|
|
*
|
|
|
|
* Returns: The parent for @klass or %NULL if none.
|
|
|
|
*/
|
|
|
|
ObjectClass *object_class_get_parent(ObjectClass *klass);
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
/**
|
|
|
|
* object_class_get_name:
|
|
|
|
* @klass: The class to obtain the QOM typename for.
|
|
|
|
*
|
|
|
|
* Returns: The QOM typename for @klass.
|
|
|
|
*/
|
|
|
|
const char *object_class_get_name(ObjectClass *klass);
|
|
|
|
|
2013-01-23 12:20:18 +01:00
|
|
|
/**
|
|
|
|
* object_class_is_abstract:
|
|
|
|
* @klass: The class to obtain the abstractness for.
|
|
|
|
*
|
|
|
|
* Returns: %true if @klass is abstract, %false otherwise.
|
|
|
|
*/
|
|
|
|
bool object_class_is_abstract(ObjectClass *klass);
|
|
|
|
|
2012-05-02 13:30:53 +02:00
|
|
|
/**
|
|
|
|
* object_class_by_name:
|
|
|
|
* @typename: The QOM typename to obtain the class for.
|
|
|
|
*
|
|
|
|
* Returns: The class for @typename or %NULL if not found.
|
|
|
|
*/
|
2011-12-04 00:10:08 +01:00
|
|
|
ObjectClass *object_class_by_name(const char *typename);
|
|
|
|
|
2020-06-24 15:10:37 +02:00
|
|
|
/**
|
|
|
|
* module_object_class_by_name:
|
|
|
|
* @typename: The QOM typename to obtain the class for.
|
|
|
|
*
|
|
|
|
* For objects which might be provided by a module. Behaves like
|
|
|
|
* object_class_by_name, but additionally tries to load the module
|
|
|
|
* needed in case the class is not available.
|
|
|
|
*
|
|
|
|
* Returns: The class for @typename or %NULL if not found.
|
|
|
|
*/
|
|
|
|
ObjectClass *module_object_class_by_name(const char *typename);
|
|
|
|
|
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);
|
2012-02-25 23:07:34 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_class_get_list:
|
|
|
|
* @implements_type: The type to filter for, including its derivatives.
|
|
|
|
* @include_abstract: Whether to include abstract classes.
|
|
|
|
*
|
|
|
|
* Returns: A singly-linked list of the classes in reverse hashtable order.
|
|
|
|
*/
|
|
|
|
GSList *object_class_get_list(const char *implements_type,
|
|
|
|
bool include_abstract);
|
2018-03-03 08:33:10 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_class_get_list_sorted:
|
|
|
|
* @implements_type: The type to filter for, including its derivatives.
|
|
|
|
* @include_abstract: Whether to include abstract classes.
|
|
|
|
*
|
|
|
|
* Returns: A singly-linked list of the classes in alphabetical
|
|
|
|
* case-insensitive order.
|
|
|
|
*/
|
|
|
|
GSList *object_class_get_list_sorted(const char *implements_type,
|
|
|
|
bool include_abstract);
|
2012-02-25 23:07:34 +01:00
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
/**
|
|
|
|
* object_ref:
|
|
|
|
* @obj: the object
|
|
|
|
*
|
|
|
|
* Increase the reference count of a object. A object cannot be freed as long
|
|
|
|
* as its reference count is greater than zero.
|
2020-01-10 16:30:31 +01:00
|
|
|
* Returns: @obj
|
2012-01-30 15:55:55 +01:00
|
|
|
*/
|
2020-08-31 23:07:23 +02:00
|
|
|
Object *object_ref(void *obj);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
|
|
|
/**
|
2016-06-14 09:27:49 +02:00
|
|
|
* object_unref:
|
2012-01-30 15:55:55 +01:00
|
|
|
* @obj: the object
|
|
|
|
*
|
|
|
|
* Decrease the reference count of a object. A object cannot be freed as long
|
|
|
|
* as its reference count is greater than zero.
|
|
|
|
*/
|
2020-08-31 23:07:23 +02:00
|
|
|
void object_unref(void *obj);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
|
|
|
/**
|
2020-06-29 21:34:22 +02:00
|
|
|
* object_property_try_add:
|
2012-01-30 15:55:55 +01:00
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property. This can contain any character except for
|
|
|
|
* a forward slash. In general, you should use hyphens '-' instead of
|
|
|
|
* underscores '_' when naming properties.
|
|
|
|
* @type: the type name of the property. This namespace is pretty loosely
|
|
|
|
* defined. Sub namespaces are constructed by using a prefix and then
|
|
|
|
* to angle brackets. For instance, the type 'virtio-net-pci' in the
|
|
|
|
* 'link' namespace would be 'link<virtio-net-pci>'.
|
|
|
|
* @get: The getter to be called to read a property. If this is NULL, then
|
|
|
|
* the property cannot be read.
|
|
|
|
* @set: the setter to be called to write a property. If this is NULL,
|
|
|
|
* then the property cannot be written.
|
|
|
|
* @release: called when the property is removed from the object. This is
|
|
|
|
* meant to allow a property to free its opaque upon object
|
|
|
|
* destruction. This may be NULL.
|
|
|
|
* @opaque: an opaque pointer to pass to the callbacks for the property
|
2020-06-29 21:34:22 +02:00
|
|
|
* @errp: pointer to error object
|
2014-06-05 13:11:51 +02:00
|
|
|
*
|
|
|
|
* Returns: The #ObjectProperty; this can be used to set the @resolve
|
|
|
|
* callback for child and link properties.
|
2012-01-30 15:55:55 +01:00
|
|
|
*/
|
2020-06-29 21:34:22 +02:00
|
|
|
ObjectProperty *object_property_try_add(Object *obj, const char *name,
|
|
|
|
const char *type,
|
|
|
|
ObjectPropertyAccessor *get,
|
|
|
|
ObjectPropertyAccessor *set,
|
|
|
|
ObjectPropertyRelease *release,
|
|
|
|
void *opaque, Error **errp);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_add:
|
|
|
|
* Same as object_property_try_add() with @errp hardcoded to
|
|
|
|
* &error_abort.
|
2020-09-11 00:15:18 +02:00
|
|
|
*
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property. This can contain any character except for
|
|
|
|
* a forward slash. In general, you should use hyphens '-' instead of
|
|
|
|
* underscores '_' when naming properties.
|
|
|
|
* @type: the type name of the property. This namespace is pretty loosely
|
|
|
|
* defined. Sub namespaces are constructed by using a prefix and then
|
|
|
|
* to angle brackets. For instance, the type 'virtio-net-pci' in the
|
|
|
|
* 'link' namespace would be 'link<virtio-net-pci>'.
|
|
|
|
* @get: The getter to be called to read a property. If this is NULL, then
|
|
|
|
* the property cannot be read.
|
|
|
|
* @set: the setter to be called to write a property. If this is NULL,
|
|
|
|
* then the property cannot be written.
|
|
|
|
* @release: called when the property is removed from the object. This is
|
|
|
|
* meant to allow a property to free its opaque upon object
|
|
|
|
* destruction. This may be NULL.
|
|
|
|
* @opaque: an opaque pointer to pass to the callbacks for the property
|
2020-06-29 21:34:22 +02:00
|
|
|
*/
|
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,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
void *opaque);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2020-05-05 17:29:26 +02:00
|
|
|
void object_property_del(Object *obj, const char *name);
|
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,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
void *opaque);
|
2015-10-13 14:37:46 +02:00
|
|
|
|
2020-01-10 16:30:23 +01:00
|
|
|
/**
|
|
|
|
* object_property_set_default_bool:
|
|
|
|
* @prop: the property to set
|
|
|
|
* @value: the value to be written to the property
|
|
|
|
*
|
|
|
|
* Set the property default value.
|
|
|
|
*/
|
|
|
|
void object_property_set_default_bool(ObjectProperty *prop, bool value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_set_default_str:
|
|
|
|
* @prop: the property to set
|
|
|
|
* @value: the value to be written to the property
|
|
|
|
*
|
|
|
|
* Set the property default value.
|
|
|
|
*/
|
|
|
|
void object_property_set_default_str(ObjectProperty *prop, const char *value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_set_default_int:
|
|
|
|
* @prop: the property to set
|
|
|
|
* @value: the value to be written to the property
|
|
|
|
*
|
|
|
|
* Set the property default value.
|
|
|
|
*/
|
|
|
|
void object_property_set_default_int(ObjectProperty *prop, int64_t value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_set_default_uint:
|
|
|
|
* @prop: the property to set
|
|
|
|
* @value: the value to be written to the property
|
|
|
|
*
|
|
|
|
* Set the property default value.
|
|
|
|
*/
|
|
|
|
void object_property_set_default_uint(ObjectProperty *prop, uint64_t value);
|
|
|
|
|
2012-03-30 14:54:31 +02:00
|
|
|
/**
|
|
|
|
* object_property_find:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
2020-09-14 15:56:17 +02:00
|
|
|
*
|
|
|
|
* Look up a property for an object.
|
|
|
|
*
|
|
|
|
* Return its #ObjectProperty if found, or NULL.
|
|
|
|
*/
|
|
|
|
ObjectProperty *object_property_find(Object *obj, const char *name);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_find_err:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
2012-04-12 18:00:18 +02:00
|
|
|
* @errp: returns an error if this function fails
|
2012-03-30 14:54:31 +02:00
|
|
|
*
|
2020-09-14 15:56:17 +02:00
|
|
|
* Look up a property for an object.
|
|
|
|
*
|
|
|
|
* Return its #ObjectProperty if found, or NULL.
|
|
|
|
*/
|
|
|
|
ObjectProperty *object_property_find_err(Object *obj,
|
|
|
|
const char *name,
|
|
|
|
Error **errp);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_class_property_find:
|
|
|
|
* @klass: the object class
|
|
|
|
* @name: the name of the property
|
|
|
|
*
|
|
|
|
* Look up a property for an object class.
|
|
|
|
*
|
|
|
|
* Return its #ObjectProperty if found, or NULL.
|
|
|
|
*/
|
|
|
|
ObjectProperty *object_class_property_find(ObjectClass *klass,
|
|
|
|
const char *name);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_class_property_find_err:
|
|
|
|
* @klass: the object class
|
|
|
|
* @name: the name of the property
|
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Look up a property for an object class.
|
|
|
|
*
|
|
|
|
* Return its #ObjectProperty if found, or NULL.
|
2012-03-30 14:54:31 +02:00
|
|
|
*/
|
2020-09-14 15:56:17 +02:00
|
|
|
ObjectProperty *object_class_property_find_err(ObjectClass *klass,
|
|
|
|
const char *name,
|
|
|
|
Error **errp);
|
2012-03-30 14:54:31 +02:00
|
|
|
|
2015-12-09 13:34:02 +01:00
|
|
|
typedef struct ObjectPropertyIterator {
|
|
|
|
ObjectClass *nextclass;
|
|
|
|
GHashTableIter iter;
|
|
|
|
} ObjectPropertyIterator;
|
2015-10-13 14:37:40 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_iter_init:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @iter: the iterator instance
|
2015-10-13 14:37:40 +02:00
|
|
|
* @obj: the object
|
|
|
|
*
|
|
|
|
* Initializes an iterator for traversing all properties
|
2015-10-13 14:37:46 +02:00
|
|
|
* registered against an object instance, its class and all parent classes.
|
2015-10-13 14:37:40 +02:00
|
|
|
*
|
|
|
|
* It is forbidden to modify the property list while iterating,
|
|
|
|
* whether removing or adding properties.
|
|
|
|
*
|
|
|
|
* Typical usage pattern would be
|
|
|
|
*
|
2020-09-11 00:15:24 +02:00
|
|
|
* .. code-block:: c
|
|
|
|
* :caption: Using object property iterators
|
|
|
|
*
|
2020-09-11 00:15:23 +02:00
|
|
|
* ObjectProperty *prop;
|
|
|
|
* ObjectPropertyIterator iter;
|
|
|
|
*
|
|
|
|
* object_property_iter_init(&iter, obj);
|
|
|
|
* while ((prop = object_property_iter_next(&iter))) {
|
|
|
|
* ... do something with prop ...
|
|
|
|
* }
|
2015-10-13 14:37:40 +02:00
|
|
|
*/
|
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
|
|
|
|
2018-03-01 14:09:39 +01:00
|
|
|
/**
|
|
|
|
* object_class_property_iter_init:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @iter: the iterator instance
|
2018-03-01 14:09:39 +01:00
|
|
|
* @klass: the class
|
|
|
|
*
|
|
|
|
* Initializes an iterator for traversing all properties
|
|
|
|
* registered against an object class and all parent classes.
|
|
|
|
*
|
|
|
|
* It is forbidden to modify the property list while iterating,
|
|
|
|
* whether removing or adding properties.
|
|
|
|
*
|
|
|
|
* This can be used on abstract classes as it does not create a temporary
|
|
|
|
* instance.
|
|
|
|
*/
|
|
|
|
void object_class_property_iter_init(ObjectPropertyIterator *iter,
|
|
|
|
ObjectClass *klass);
|
|
|
|
|
2015-10-13 14:37:40 +02:00
|
|
|
/**
|
|
|
|
* object_property_iter_next:
|
|
|
|
* @iter: the iterator instance
|
|
|
|
*
|
2015-12-09 13:34:02 +01:00
|
|
|
* Return the next available property. If no further properties
|
|
|
|
* are available, a %NULL value will be returned and the @iter
|
|
|
|
* pointer should not be used again after this point without
|
|
|
|
* re-initializing it.
|
|
|
|
*
|
2015-10-13 14:37:40 +02:00
|
|
|
* Returns: the next property, or %NULL when all properties
|
|
|
|
* have been traversed.
|
|
|
|
*/
|
|
|
|
ObjectProperty *object_property_iter_next(ObjectPropertyIterator *iter);
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
void object_unparent(Object *obj);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_get:
|
|
|
|
* @obj: the object
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
* @name: the name of the property
|
2012-01-30 15:55:55 +01:00
|
|
|
* @v: the visitor that will receive the property value. This should be an
|
|
|
|
* Output visitor and the data will be written with @name as the name.
|
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Reads a property from a object.
|
2020-07-07 18:05:55 +02:00
|
|
|
*
|
|
|
|
* Returns: %true on success, %false on failure.
|
2012-01-30 15:55:55 +01:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_property_get(Object *obj, const char *name, Visitor *v,
|
2013-09-22 09:08:14 +02:00
|
|
|
Error **errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2012-02-01 17:16:22 +01:00
|
|
|
/**
|
|
|
|
* object_property_set_str:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: the object
|
2012-02-01 17:16:22 +01:00
|
|
|
* @name: the name of the property
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
* @value: the value to be written to the property
|
2012-02-01 17:16:22 +01:00
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Writes a string value to a property.
|
2020-07-07 18:05:55 +02:00
|
|
|
*
|
|
|
|
* Returns: %true on success, %false on failure.
|
2012-02-01 17:16:22 +01:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_property_set_str(Object *obj, const char *name,
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
const char *value, Error **errp);
|
2012-02-01 17:16:22 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_get_str:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Returns: the value of the property, converted to a C string, or NULL if
|
|
|
|
* an error occurs (including when the property value is not a string).
|
|
|
|
* The caller should free the string.
|
|
|
|
*/
|
|
|
|
char *object_property_get_str(Object *obj, const char *name,
|
2013-09-22 09:08:14 +02:00
|
|
|
Error **errp);
|
2012-02-01 17:16:22 +01:00
|
|
|
|
2012-02-02 10:51:57 +01:00
|
|
|
/**
|
|
|
|
* object_property_set_link:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: the object
|
2012-02-02 10:51:57 +01:00
|
|
|
* @name: the name of the property
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
* @value: the value to be written to the property
|
2012-02-02 10:51:57 +01:00
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Writes an object's canonical path to a property.
|
2018-05-31 21:51:17 +02:00
|
|
|
*
|
|
|
|
* If the link property was created with
|
2020-10-03 04:54:23 +02:00
|
|
|
* %OBJ_PROP_LINK_STRONG bit, the old target object is
|
2018-05-31 21:51:17 +02:00
|
|
|
* unreferenced, and a reference is added to the new target object.
|
|
|
|
*
|
2020-07-07 18:05:55 +02:00
|
|
|
* Returns: %true on success, %false on failure.
|
2012-02-02 10:51:57 +01:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_property_set_link(Object *obj, const char *name,
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
Object *value, Error **errp);
|
2012-02-02 10:51:57 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_get_link:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Returns: the value of the property, resolved from a path to an Object,
|
|
|
|
* or NULL if an error occurs (including when the property value is not a
|
|
|
|
* string or not a valid object path).
|
|
|
|
*/
|
|
|
|
Object *object_property_get_link(Object *obj, const char *name,
|
2013-09-22 09:08:14 +02:00
|
|
|
Error **errp);
|
2012-02-02 10:51:57 +01:00
|
|
|
|
2012-02-01 17:16:22 +01:00
|
|
|
/**
|
|
|
|
* object_property_set_bool:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: the object
|
2012-02-01 17:16:22 +01:00
|
|
|
* @name: the name of the property
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
* @value: the value to be written to the property
|
2012-02-01 17:16:22 +01:00
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Writes a bool value to a property.
|
2020-07-07 18:05:55 +02:00
|
|
|
*
|
|
|
|
* Returns: %true on success, %false on failure.
|
2012-02-01 17:16:22 +01:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_property_set_bool(Object *obj, const char *name,
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
bool value, Error **errp);
|
2012-02-01 17:16:22 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_get_bool:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
2020-09-17 14:55:40 +02:00
|
|
|
* Returns: the value of the property, converted to a boolean, or false if
|
2012-02-01 17:16:22 +01:00
|
|
|
* an error occurs (including when the property value is not a bool).
|
|
|
|
*/
|
|
|
|
bool object_property_get_bool(Object *obj, const char *name,
|
2013-09-22 09:08:14 +02:00
|
|
|
Error **errp);
|
2012-02-01 17:16:22 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_set_int:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: the object
|
2012-02-01 17:16:22 +01:00
|
|
|
* @name: the name of the property
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
* @value: the value to be written to the property
|
2012-02-01 17:16:22 +01:00
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Writes an integer value to a property.
|
2020-07-07 18:05:55 +02:00
|
|
|
*
|
|
|
|
* Returns: %true on success, %false on failure.
|
2012-02-01 17:16:22 +01:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_property_set_int(Object *obj, const char *name,
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
int64_t value, Error **errp);
|
2012-02-01 17:16:22 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_get_int:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
2020-09-17 14:55:40 +02:00
|
|
|
* Returns: the value of the property, converted to an integer, or -1 if
|
2012-02-01 17:16:22 +01:00
|
|
|
* an error occurs (including when the property value is not an integer).
|
|
|
|
*/
|
|
|
|
int64_t object_property_get_int(Object *obj, const char *name,
|
2013-09-22 09:08:14 +02:00
|
|
|
Error **errp);
|
2012-02-01 17:16:22 +01:00
|
|
|
|
2017-06-07 18:36:04 +02:00
|
|
|
/**
|
|
|
|
* object_property_set_uint:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: the object
|
2017-06-07 18:36:04 +02:00
|
|
|
* @name: the name of the property
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
* @value: the value to be written to the property
|
2017-06-07 18:36:04 +02:00
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Writes an unsigned integer value to a property.
|
2020-07-07 18:05:55 +02:00
|
|
|
*
|
|
|
|
* Returns: %true on success, %false on failure.
|
2017-06-07 18:36:04 +02:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_property_set_uint(Object *obj, const char *name,
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
uint64_t value, Error **errp);
|
2017-06-07 18:36:04 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_get_uint:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Returns: the value of the property, converted to an unsigned integer, or 0
|
|
|
|
* an error occurs (including when the property value is not an integer).
|
|
|
|
*/
|
|
|
|
uint64_t object_property_get_uint(Object *obj, const char *name,
|
|
|
|
Error **errp);
|
|
|
|
|
2014-05-14 11:43:33 +02:00
|
|
|
/**
|
|
|
|
* object_property_get_enum:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
2015-05-27 17:07:56 +02:00
|
|
|
* @typename: the name of the enum data type
|
2014-05-14 11:43:33 +02:00
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
2020-09-17 14:55:39 +02:00
|
|
|
* Returns: the value of the property, converted to an integer (which
|
|
|
|
* can't be negative), or -1 on error (including when the property
|
|
|
|
* value is not an enum).
|
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
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
/**
|
|
|
|
* object_property_set:
|
|
|
|
* @obj: the object
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
* @name: the name of the property
|
2012-01-30 15:55:55 +01:00
|
|
|
* @v: the visitor that will be used to write the property value. This should
|
|
|
|
* be an Input visitor and the data will be first read with @name as the
|
|
|
|
* name and then written as the property value.
|
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Writes a property to a object.
|
2020-07-07 18:05:55 +02:00
|
|
|
*
|
|
|
|
* Returns: %true on success, %false on failure.
|
2012-01-30 15:55:55 +01:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_property_set(Object *obj, const char *name, Visitor *v,
|
2013-09-22 09:08:14 +02:00
|
|
|
Error **errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2012-02-09 09:52:59 +01:00
|
|
|
/**
|
|
|
|
* object_property_parse:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
* @string: the string that will be used to parse the property value.
|
2012-02-09 09:52:59 +01:00
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Parses a string and writes the result into a property of an object.
|
2020-07-07 18:05:55 +02:00
|
|
|
*
|
|
|
|
* Returns: %true on success, %false on failure.
|
2012-02-09 09:52:59 +01:00
|
|
|
*/
|
2020-07-07 18:05:55 +02:00
|
|
|
bool object_property_parse(Object *obj, const char *name,
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 18:05:54 +02:00
|
|
|
const char *string, Error **errp);
|
2012-02-09 09:52:59 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_print:
|
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
2014-02-08 11:01:50 +01:00
|
|
|
* @human: if true, print for human consumption
|
2012-02-09 09:52:59 +01:00
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Returns a string representation of the value of the property. The
|
|
|
|
* caller shall free the string.
|
|
|
|
*/
|
2014-02-08 11:01:50 +01:00
|
|
|
char *object_property_print(Object *obj, const char *name, bool human,
|
2013-09-22 09:08:14 +02:00
|
|
|
Error **errp);
|
2012-02-09 09:52:59 +01:00
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
/**
|
2012-02-16 18:03:19 +01:00
|
|
|
* object_property_get_type:
|
2012-01-30 15:55:55 +01:00
|
|
|
* @obj: the object
|
|
|
|
* @name: the name of the property
|
|
|
|
* @errp: returns an error if this function fails
|
|
|
|
*
|
|
|
|
* Returns: The type name of the property.
|
|
|
|
*/
|
|
|
|
const char *object_property_get_type(Object *obj, const char *name,
|
2013-09-22 09:08:14 +02:00
|
|
|
Error **errp);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_get_root:
|
|
|
|
*
|
|
|
|
* Returns: the root object of the composition tree
|
|
|
|
*/
|
|
|
|
Object *object_get_root(void);
|
|
|
|
|
2015-05-13 18:14:05 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_get_objects_root:
|
|
|
|
*
|
|
|
|
* Get the container object that holds user created
|
|
|
|
* object instances. This is the object at path
|
|
|
|
* "/objects"
|
|
|
|
*
|
|
|
|
* Returns: the user object container
|
|
|
|
*/
|
|
|
|
Object *object_get_objects_root(void);
|
|
|
|
|
2017-09-28 04:59:54 +02:00
|
|
|
/**
|
|
|
|
* object_get_internal_root:
|
|
|
|
*
|
|
|
|
* Get the container object that holds internally used object
|
|
|
|
* instances. Any object which is put into this container must not be
|
|
|
|
* user visible, and it will not be exposed in the QOM tree.
|
|
|
|
*
|
|
|
|
* Returns: the internal object container
|
|
|
|
*/
|
|
|
|
Object *object_get_internal_root(void);
|
|
|
|
|
2014-03-03 11:30:02 +01:00
|
|
|
/**
|
|
|
|
* object_get_canonical_path_component:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: the object
|
2014-03-03 11:30:02 +01:00
|
|
|
*
|
|
|
|
* Returns: The final component in the object's canonical path. The canonical
|
|
|
|
* path is the path within the composition tree starting from the root.
|
2018-04-30 11:44:17 +02:00
|
|
|
* %NULL if the object doesn't have a parent (and thus a canonical path).
|
2014-03-03 11:30:02 +01:00
|
|
|
*/
|
2020-07-14 18:02:00 +02:00
|
|
|
const char *object_get_canonical_path_component(const Object *obj);
|
2014-03-03 11:30:02 +01:00
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
/**
|
|
|
|
* object_get_canonical_path:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: the object
|
2012-01-30 15:55:55 +01:00
|
|
|
*
|
2020-07-14 18:02:01 +02:00
|
|
|
* Returns: The canonical path for a object, newly allocated. This is
|
|
|
|
* the path within the composition tree starting from the root. Use
|
|
|
|
* g_free() to free it.
|
2012-01-30 15:55:55 +01:00
|
|
|
*/
|
2020-05-27 10:47:53 +02:00
|
|
|
char *object_get_canonical_path(const Object *obj);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_resolve_path:
|
|
|
|
* @path: the path to resolve
|
|
|
|
* @ambiguous: returns true if the path resolution failed because of an
|
|
|
|
* ambiguous match
|
|
|
|
*
|
|
|
|
* There are two types of supported paths--absolute paths and partial paths.
|
|
|
|
*
|
|
|
|
* Absolute paths are derived from the root object and can follow child<> or
|
|
|
|
* link<> properties. Since they can follow link<> properties, they can be
|
|
|
|
* arbitrarily long. Absolute paths look like absolute filenames and are
|
|
|
|
* prefixed with a leading slash.
|
|
|
|
*
|
|
|
|
* Partial paths look like relative filenames. They do not begin with a
|
|
|
|
* prefix. The matching rules for partial paths are subtle but designed to make
|
|
|
|
* specifying objects easy. At each level of the composition tree, the partial
|
|
|
|
* path is matched as an absolute path. The first match is not returned. At
|
|
|
|
* least two matches are searched for. A successful result is only returned if
|
2012-02-03 11:21:01 +01:00
|
|
|
* only one match is found. If more than one match is found, a flag is
|
|
|
|
* returned to indicate that the match was ambiguous.
|
2012-01-30 15:55:55 +01:00
|
|
|
*
|
|
|
|
* Returns: The matched object or NULL on path lookup failure.
|
|
|
|
*/
|
|
|
|
Object *object_resolve_path(const char *path, bool *ambiguous);
|
|
|
|
|
2012-02-03 11:21:01 +01:00
|
|
|
/**
|
|
|
|
* object_resolve_path_type:
|
|
|
|
* @path: the path to resolve
|
|
|
|
* @typename: the type to look for.
|
|
|
|
* @ambiguous: returns true if the path resolution failed because of an
|
|
|
|
* ambiguous match
|
|
|
|
*
|
|
|
|
* This is similar to object_resolve_path. However, when looking for a
|
|
|
|
* partial path only matches that implement the given type are considered.
|
|
|
|
* This restricts the search and avoids spuriously flagging matches as
|
|
|
|
* ambiguous.
|
|
|
|
*
|
|
|
|
* For both partial and absolute paths, the return value goes through
|
|
|
|
* a dynamic cast to @typename. This is important if either the link,
|
|
|
|
* or the typename itself are of interface types.
|
|
|
|
*
|
|
|
|
* Returns: The matched object or NULL on path lookup failure.
|
|
|
|
*/
|
|
|
|
Object *object_resolve_path_type(const char *path, const char *typename,
|
|
|
|
bool *ambiguous);
|
|
|
|
|
2021-10-19 10:57:11 +02:00
|
|
|
/**
|
|
|
|
* object_resolve_path_at:
|
|
|
|
* @parent: the object in which to resolve the path
|
|
|
|
* @path: the path to resolve
|
|
|
|
*
|
|
|
|
* This is like object_resolve_path(), except paths not starting with
|
|
|
|
* a slash are relative to @parent.
|
|
|
|
*
|
|
|
|
* Returns: The resolved object or NULL on path lookup failure.
|
|
|
|
*/
|
|
|
|
Object *object_resolve_path_at(Object *parent, const char *path);
|
|
|
|
|
2012-03-27 18:38:45 +02:00
|
|
|
/**
|
|
|
|
* object_resolve_path_component:
|
|
|
|
* @parent: the object in which to resolve the path
|
|
|
|
* @part: the component to resolve.
|
|
|
|
*
|
|
|
|
* This is similar to object_resolve_path with an absolute path, but it
|
|
|
|
* only resolves one element (@part) and takes the others from @parent.
|
|
|
|
*
|
|
|
|
* Returns: The resolved object or NULL on path lookup failure.
|
|
|
|
*/
|
2020-05-05 17:29:10 +02:00
|
|
|
Object *object_resolve_path_component(Object *parent, const char *part);
|
2012-03-27 18:38:45 +02:00
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
/**
|
2020-06-29 21:34:22 +02:00
|
|
|
* object_property_try_add_child:
|
2012-01-30 15:55:55 +01:00
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @child: the child object
|
2020-06-29 21:34:22 +02:00
|
|
|
* @errp: pointer to error object
|
2012-01-30 15:55:55 +01:00
|
|
|
*
|
|
|
|
* Child properties form the composition tree. All objects need to be a child
|
|
|
|
* of another object. Objects can only be a child of one object.
|
|
|
|
*
|
|
|
|
* There is no way for a child to determine what its parent is. It is not
|
|
|
|
* a bidirectional relationship. This is by design.
|
2012-02-21 11:14:22 +01:00
|
|
|
*
|
|
|
|
* The value of a child property as a C string will be the child object's
|
|
|
|
* canonical path. It can be retrieved using object_property_get_str().
|
|
|
|
* The child object itself can be retrieved using object_property_get_link().
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2012-01-30 15:55:55 +01:00
|
|
|
*/
|
2020-06-29 21:34:22 +02:00
|
|
|
ObjectProperty *object_property_try_add_child(Object *obj, const char *name,
|
|
|
|
Object *child, Error **errp);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_add_child:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @child: the child object
|
|
|
|
*
|
2020-06-29 21:34:22 +02:00
|
|
|
* Same as object_property_try_add_child() with @errp hardcoded to
|
|
|
|
* &error_abort
|
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_child(Object *obj, const char *name,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
Object *child);
|
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
|
|
|
typedef enum {
|
|
|
|
/* Unref the link pointer when the property is deleted */
|
2018-05-31 21:51:17 +02:00
|
|
|
OBJ_PROP_LINK_STRONG = 0x1,
|
2020-01-10 16:30:27 +01:00
|
|
|
|
|
|
|
/* private */
|
|
|
|
OBJ_PROP_LINK_DIRECT = 0x2,
|
2020-01-10 16:30:29 +01:00
|
|
|
OBJ_PROP_LINK_CLASS = 0x4,
|
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;
|
|
|
|
|
2014-03-19 08:58:56 +01:00
|
|
|
/**
|
|
|
|
* object_property_allow_set_link:
|
2020-09-11 00:15:18 +02:00
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @child: the child object
|
|
|
|
* @errp: pointer to error object
|
2014-03-19 08:58:56 +01:00
|
|
|
*
|
|
|
|
* The default implementation of the object_property_add_link() check()
|
|
|
|
* callback function. It allows the link property to be set and never returns
|
|
|
|
* an error.
|
|
|
|
*/
|
2020-09-11 00:15:18 +02:00
|
|
|
void object_property_allow_set_link(const Object *obj, const char *name,
|
|
|
|
Object *child, Error **errp);
|
2014-03-19 08:58:56 +01:00
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
/**
|
|
|
|
* object_property_add_link:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @type: the qobj type of the link
|
2020-01-10 16:30:26 +01:00
|
|
|
* @targetp: a pointer to where the link object reference is stored
|
2014-03-19 08:58:56 +01:00
|
|
|
* @check: callback to veto setting or NULL if the property is read-only
|
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
|
|
|
* @flags: additional options for the link
|
2012-01-30 15:55:55 +01:00
|
|
|
*
|
|
|
|
* Links establish relationships between objects. Links are unidirectional
|
|
|
|
* although two links can be combined to form a bidirectional relationship
|
|
|
|
* between objects.
|
|
|
|
*
|
|
|
|
* Links form the graph in the object model.
|
2013-01-25 14:12:31 +01:00
|
|
|
*
|
2020-10-03 04:54:23 +02:00
|
|
|
* The @check() callback is invoked when
|
2014-03-19 08:58:56 +01:00
|
|
|
* object_property_set_link() is called and can raise an error to prevent the
|
2020-10-03 04:54:23 +02:00
|
|
|
* link being set. If @check is NULL, the property is read-only
|
2014-03-19 08:58:56 +01:00
|
|
|
* and cannot be set.
|
|
|
|
*
|
2013-01-25 14:12:31 +01:00
|
|
|
* Ownership of the pointer that @child points to is transferred to the
|
2020-10-03 04:54:23 +02:00
|
|
|
* link property. The reference count for *@child is
|
2013-01-25 14:12:31 +01:00
|
|
|
* managed by the property from after the function returns till the
|
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
|
|
|
* property is deleted with object_property_del(). If the
|
2020-10-03 04:54:23 +02:00
|
|
|
* @flags %OBJ_PROP_LINK_STRONG bit is set,
|
2018-05-31 21:51:17 +02:00
|
|
|
* the reference count is decremented when the property is deleted or
|
|
|
|
* modified.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2012-01-30 15:55:55 +01:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_link(Object *obj, const char *name,
|
2020-01-10 16:30:26 +01:00
|
|
|
const char *type, Object **targetp,
|
2017-07-14 04:14:50 +02:00
|
|
|
void (*check)(const Object *obj, const char *name,
|
2014-03-19 08:58:56 +01:00
|
|
|
Object *val, Error **errp),
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
ObjectPropertyLinkFlags flags);
|
2012-01-30 15:55:55 +01:00
|
|
|
|
2020-01-10 16:30:29 +01:00
|
|
|
ObjectProperty *object_class_property_add_link(ObjectClass *oc,
|
|
|
|
const char *name,
|
|
|
|
const char *type, ptrdiff_t offset,
|
|
|
|
void (*check)(const Object *obj, const char *name,
|
|
|
|
Object *val, Error **errp),
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
ObjectPropertyLinkFlags flags);
|
2020-01-10 16:30:29 +01:00
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
/**
|
|
|
|
* object_property_add_str:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @get: the getter or NULL if the property is write-only. This function must
|
|
|
|
* return a string to be freed by g_free().
|
|
|
|
* @set: the setter or NULL if the property is read-only
|
|
|
|
*
|
|
|
|
* Add a string property using getters/setters. This function will add a
|
|
|
|
* property of type 'string'.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2012-01-30 15:55:55 +01:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_str(Object *obj, const char *name,
|
2013-09-22 09:08:14 +02:00
|
|
|
char *(*get)(Object *, Error **),
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
void (*set)(Object *, const char *, Error **));
|
2011-12-04 00:10:08 +01:00
|
|
|
|
2020-01-10 16:30:21 +01:00
|
|
|
ObjectProperty *object_class_property_add_str(ObjectClass *klass,
|
|
|
|
const char *name,
|
2015-10-13 14:37:46 +02:00
|
|
|
char *(*get)(Object *, Error **),
|
|
|
|
void (*set)(Object *, const char *,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
Error **));
|
2015-10-13 14:37:46 +02:00
|
|
|
|
2012-06-25 17:32:46 +02:00
|
|
|
/**
|
|
|
|
* object_property_add_bool:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @get: the getter or NULL if the property is write-only.
|
|
|
|
* @set: the setter or NULL if the property is read-only
|
|
|
|
*
|
|
|
|
* Add a bool property using getters/setters. This function will add a
|
|
|
|
* property of type 'bool'.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2012-06-25 17:32:46 +02:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_bool(Object *obj, const char *name,
|
2013-09-22 09:08:14 +02:00
|
|
|
bool (*get)(Object *, Error **),
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
void (*set)(Object *, bool, Error **));
|
2012-06-25 17:32:46 +02:00
|
|
|
|
2020-01-10 16:30:21 +01:00
|
|
|
ObjectProperty *object_class_property_add_bool(ObjectClass *klass,
|
|
|
|
const char *name,
|
2015-10-13 14:37:46 +02:00
|
|
|
bool (*get)(Object *, Error **),
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
void (*set)(Object *, bool, Error **));
|
2015-10-13 14:37:46 +02: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
|
|
|
/**
|
|
|
|
* object_property_add_enum:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @typename: the name of the enum data type
|
2020-09-11 00:15:18 +02:00
|
|
|
* @lookup: enum value namelookup table
|
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
|
|
|
* @get: the getter or %NULL if the property is write-only.
|
|
|
|
* @set: the setter or %NULL if the property is read-only
|
|
|
|
*
|
|
|
|
* Add an enum property using getters/setters. This function will add a
|
|
|
|
* property of type '@typename'.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
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
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_enum(Object *obj, const char *name,
|
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
|
|
|
const char *typename,
|
2017-08-24 10:46:10 +02:00
|
|
|
const QEnumLookup *lookup,
|
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
|
|
|
int (*get)(Object *, Error **),
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
void (*set)(Object *, int, Error **));
|
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
|
|
|
|
2020-01-10 16:30:21 +01:00
|
|
|
ObjectProperty *object_class_property_add_enum(ObjectClass *klass,
|
|
|
|
const char *name,
|
2015-10-13 14:37:46 +02:00
|
|
|
const char *typename,
|
2017-08-24 10:46:10 +02:00
|
|
|
const QEnumLookup *lookup,
|
2015-10-13 14:37:46 +02:00
|
|
|
int (*get)(Object *, Error **),
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
void (*set)(Object *, int, Error **));
|
2015-10-13 14:37:46 +02:00
|
|
|
|
2015-02-06 04:55:45 +01:00
|
|
|
/**
|
|
|
|
* object_property_add_tm:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @get: the getter or NULL if the property is write-only.
|
|
|
|
*
|
|
|
|
* Add a read-only struct tm valued property using a getter function.
|
|
|
|
* This function will add a property of type 'struct tm'.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2015-02-06 04:55:45 +01:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_tm(Object *obj, const char *name,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
void (*get)(Object *, struct tm *, Error **));
|
2015-02-06 04:55:45 +01:00
|
|
|
|
2020-01-10 16:30:21 +01:00
|
|
|
ObjectProperty *object_class_property_add_tm(ObjectClass *klass,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
const char *name,
|
|
|
|
void (*get)(Object *, struct tm *, Error **));
|
2015-10-13 14:37:46 +02:00
|
|
|
|
2020-02-04 14:15:58 +01:00
|
|
|
typedef enum {
|
|
|
|
/* Automatically add a getter to the property */
|
|
|
|
OBJ_PROP_FLAG_READ = 1 << 0,
|
|
|
|
/* Automatically add a setter to the property */
|
|
|
|
OBJ_PROP_FLAG_WRITE = 1 << 1,
|
|
|
|
/* Automatically add a getter and a setter to the property */
|
|
|
|
OBJ_PROP_FLAG_READWRITE = (OBJ_PROP_FLAG_READ | OBJ_PROP_FLAG_WRITE),
|
|
|
|
} ObjectPropertyFlags;
|
|
|
|
|
2013-10-07 11:35:01 +02:00
|
|
|
/**
|
|
|
|
* object_property_add_uint8_ptr:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @v: pointer to value
|
2020-02-04 14:15:58 +01:00
|
|
|
* @flags: bitwise-or'd ObjectPropertyFlags
|
2013-10-07 11:35:01 +02:00
|
|
|
*
|
|
|
|
* Add an integer property in memory. This function will add a
|
|
|
|
* property of type 'uint8'.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2013-10-07 11:35:01 +02:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_uint8_ptr(Object *obj, const char *name,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
const uint8_t *v,
|
|
|
|
ObjectPropertyFlags flags);
|
2020-02-04 14:15:58 +01:00
|
|
|
|
2020-01-10 16:30:21 +01:00
|
|
|
ObjectProperty *object_class_property_add_uint8_ptr(ObjectClass *klass,
|
|
|
|
const char *name,
|
2020-02-04 14:15:58 +01:00
|
|
|
const uint8_t *v,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
ObjectPropertyFlags flags);
|
2013-10-07 11:35:01 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_add_uint16_ptr:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @v: pointer to value
|
2020-02-04 14:15:58 +01:00
|
|
|
* @flags: bitwise-or'd ObjectPropertyFlags
|
2013-10-07 11:35:01 +02:00
|
|
|
*
|
|
|
|
* Add an integer property in memory. This function will add a
|
|
|
|
* property of type 'uint16'.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2013-10-07 11:35:01 +02:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_uint16_ptr(Object *obj, const char *name,
|
2020-02-04 14:15:58 +01:00
|
|
|
const uint16_t *v,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
ObjectPropertyFlags flags);
|
2020-02-04 14:15:58 +01:00
|
|
|
|
2020-01-10 16:30:21 +01:00
|
|
|
ObjectProperty *object_class_property_add_uint16_ptr(ObjectClass *klass,
|
|
|
|
const char *name,
|
2020-02-04 14:15:58 +01:00
|
|
|
const uint16_t *v,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
ObjectPropertyFlags flags);
|
2013-10-07 11:35:01 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_add_uint32_ptr:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @v: pointer to value
|
2020-02-04 14:15:58 +01:00
|
|
|
* @flags: bitwise-or'd ObjectPropertyFlags
|
2013-10-07 11:35:01 +02:00
|
|
|
*
|
|
|
|
* Add an integer property in memory. This function will add a
|
|
|
|
* property of type 'uint32'.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2013-10-07 11:35:01 +02:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_uint32_ptr(Object *obj, const char *name,
|
2020-02-04 14:15:58 +01:00
|
|
|
const uint32_t *v,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
ObjectPropertyFlags flags);
|
2020-02-04 14:15:58 +01:00
|
|
|
|
2020-01-10 16:30:21 +01:00
|
|
|
ObjectProperty *object_class_property_add_uint32_ptr(ObjectClass *klass,
|
|
|
|
const char *name,
|
2020-02-04 14:15:58 +01:00
|
|
|
const uint32_t *v,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
ObjectPropertyFlags flags);
|
2013-10-07 11:35:01 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* object_property_add_uint64_ptr:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @v: pointer to value
|
2020-02-04 14:15:58 +01:00
|
|
|
* @flags: bitwise-or'd ObjectPropertyFlags
|
2013-10-07 11:35:01 +02:00
|
|
|
*
|
|
|
|
* Add an integer property in memory. This function will add a
|
|
|
|
* property of type 'uint64'.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2013-10-07 11:35:01 +02:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_uint64_ptr(Object *obj, const char *name,
|
2020-02-04 14:15:58 +01:00
|
|
|
const uint64_t *v,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
ObjectPropertyFlags flags);
|
2020-02-04 14:15:58 +01:00
|
|
|
|
2020-01-10 16:30:21 +01:00
|
|
|
ObjectProperty *object_class_property_add_uint64_ptr(ObjectClass *klass,
|
|
|
|
const char *name,
|
2020-02-04 14:15:58 +01:00
|
|
|
const uint64_t *v,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
ObjectPropertyFlags flags);
|
2013-10-07 11:35:01 +02:00
|
|
|
|
2014-06-18 11:58:28 +02:00
|
|
|
/**
|
|
|
|
* object_property_add_alias:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @target_obj: the object to forward property access to
|
|
|
|
* @target_name: the name of the property on the forwarded object
|
|
|
|
*
|
|
|
|
* Add an alias for a property on an object. This function will add a property
|
|
|
|
* of the same type as the forwarded property.
|
|
|
|
*
|
2020-10-03 04:54:23 +02:00
|
|
|
* The caller must ensure that @target_obj stays alive as long as
|
2014-06-18 11:58:28 +02:00
|
|
|
* this property exists. In the case of a child object or an alias on the same
|
|
|
|
* object this will be the case. For aliases to other objects the caller is
|
|
|
|
* responsible for taking a reference.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2014-06-18 11:58:28 +02:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_alias(Object *obj, const char *name,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
Object *target_obj, const char *target_name);
|
2014-06-18 11:58:28 +02:00
|
|
|
|
2015-05-05 18:29:00 +02:00
|
|
|
/**
|
|
|
|
* object_property_add_const_link:
|
|
|
|
* @obj: the object to add a property to
|
|
|
|
* @name: the name of the property
|
|
|
|
* @target: the object to be referred by the link
|
|
|
|
*
|
|
|
|
* Add an unmodifiable link for a property on an object. This function will
|
|
|
|
* add a property of type link<TYPE> where TYPE is the type of @target.
|
|
|
|
*
|
|
|
|
* The caller must ensure that @target stays alive as long as
|
|
|
|
* this property exists. In the case @target is a child of @obj,
|
|
|
|
* this will be the case. Otherwise, the caller is responsible for
|
|
|
|
* taking a reference.
|
2020-05-05 17:29:14 +02:00
|
|
|
*
|
|
|
|
* Returns: The newly added property on success, or %NULL on failure.
|
2015-05-05 18:29:00 +02:00
|
|
|
*/
|
2020-05-05 17:29:14 +02:00
|
|
|
ObjectProperty *object_property_add_const_link(Object *obj, const char *name,
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
Object *target);
|
2015-05-05 18:29:00 +02:00
|
|
|
|
2014-10-07 08:33:21 +02:00
|
|
|
/**
|
|
|
|
* object_property_set_description:
|
|
|
|
* @obj: the object owning the property
|
|
|
|
* @name: the name of the property
|
|
|
|
* @description: the description of the property on the object
|
|
|
|
*
|
|
|
|
* Set an object property's description.
|
|
|
|
*
|
2020-07-07 18:05:55 +02:00
|
|
|
* Returns: %true on success, %false on failure.
|
2014-10-07 08:33:21 +02:00
|
|
|
*/
|
|
|
|
void object_property_set_description(Object *obj, const char *name,
|
2020-05-05 17:29:15 +02:00
|
|
|
const char *description);
|
2015-10-13 14:37:46 +02:00
|
|
|
void object_class_property_set_description(ObjectClass *klass, const char *name,
|
2020-05-05 17:29:15 +02:00
|
|
|
const char *description);
|
2014-10-07 08:33:21 +02:00
|
|
|
|
2012-04-11 23:30:20 +02:00
|
|
|
/**
|
|
|
|
* object_child_foreach:
|
|
|
|
* @obj: the object whose children will be navigated
|
|
|
|
* @fn: the iterator function to be called
|
|
|
|
* @opaque: an opaque value that will be passed to the iterator
|
|
|
|
*
|
|
|
|
* Call @fn passing each child of @obj and @opaque to it, until @fn returns
|
|
|
|
* non-zero.
|
|
|
|
*
|
2015-10-13 14:37:45 +02:00
|
|
|
* It is forbidden to add or remove children from @obj from the @fn
|
|
|
|
* callback.
|
|
|
|
*
|
2012-04-11 23:30:20 +02:00
|
|
|
* Returns: The last value returned by @fn, or 0 if there is no child.
|
|
|
|
*/
|
|
|
|
int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque),
|
|
|
|
void *opaque);
|
|
|
|
|
2015-09-08 18:38:43 +02:00
|
|
|
/**
|
|
|
|
* object_child_foreach_recursive:
|
|
|
|
* @obj: the object whose children will be navigated
|
|
|
|
* @fn: the iterator function to be called
|
|
|
|
* @opaque: an opaque value that will be passed to the iterator
|
|
|
|
*
|
|
|
|
* Call @fn passing each child of @obj and @opaque to it, until @fn returns
|
|
|
|
* non-zero. Calls recursively, all child nodes of @obj will also be passed
|
|
|
|
* all the way down to the leaf nodes of the tree. Depth first ordering.
|
|
|
|
*
|
2015-10-13 14:37:45 +02:00
|
|
|
* It is forbidden to add or remove children from @obj (or its
|
|
|
|
* child nodes) from the @fn callback.
|
|
|
|
*
|
2015-09-08 18:38:43 +02:00
|
|
|
* Returns: The last value returned by @fn, or 0 if there is no child.
|
|
|
|
*/
|
|
|
|
int object_child_foreach_recursive(Object *obj,
|
|
|
|
int (*fn)(Object *child, void *opaque),
|
|
|
|
void *opaque);
|
2012-03-27 18:38:45 +02:00
|
|
|
/**
|
|
|
|
* container_get:
|
2012-04-05 13:21:46 +02:00
|
|
|
* @root: root of the #path, e.g., object_get_root()
|
2012-03-27 18:38:45 +02:00
|
|
|
* @path: path to the container
|
|
|
|
*
|
|
|
|
* Return a container object whose path is @path. Create more containers
|
|
|
|
* along the path if necessary.
|
|
|
|
*
|
|
|
|
* Returns: the container object.
|
|
|
|
*/
|
2012-04-05 13:21:46 +02:00
|
|
|
Object *container_get(Object *root, const char *path);
|
2012-03-27 18:38:45 +02:00
|
|
|
|
2016-06-10 02:59:00 +02:00
|
|
|
/**
|
|
|
|
* object_type_get_instance_size:
|
|
|
|
* @typename: Name of the Type whose instance_size is required
|
|
|
|
*
|
|
|
|
* Returns the instance_size of the given @typename.
|
|
|
|
*/
|
|
|
|
size_t object_type_get_instance_size(const char *typename);
|
2019-11-08 15:02:25 +01:00
|
|
|
|
2020-01-10 16:30:37 +01:00
|
|
|
/**
|
|
|
|
* object_property_help:
|
|
|
|
* @name: the name of the property
|
|
|
|
* @type: the type of the property
|
|
|
|
* @defval: the default value
|
|
|
|
* @description: description of the property
|
|
|
|
*
|
|
|
|
* Returns: a user-friendly formatted string describing the property
|
|
|
|
* for help purposes.
|
|
|
|
*/
|
|
|
|
char *object_property_help(const char *name, const char *type,
|
|
|
|
QObject *defval, const char *description);
|
|
|
|
|
2019-11-08 15:02:25 +01:00
|
|
|
G_DEFINE_AUTOPTR_CLEANUP_FUNC(Object, object_unref)
|
|
|
|
|
2011-12-04 00:10:08 +01:00
|
|
|
#endif
|