4 * Copyright IBM, Corp. 2011
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "hw/qdev-core.h"
15 #include "qapi/error.h"
16 #include "qom/object.h"
17 #include "qom/object_interfaces.h"
18 #include "qemu/cutils.h"
19 #include "qapi/visitor.h"
20 #include "qapi/string-input-visitor.h"
21 #include "qapi/string-output-visitor.h"
22 #include "qapi/qobject-input-visitor.h"
23 #include "qapi/qapi-builtin-visit.h"
24 #include "qapi/qmp/qerror.h"
25 #include "qapi/qmp/qjson.h"
28 /* TODO: replace QObject with a simpler visitor to avoid a dependency
29 * of the QOM core on QObject? */
30 #include "qom/qom-qobject.h"
31 #include "qapi/qmp/qbool.h"
32 #include "qapi/qmp/qnum.h"
33 #include "qapi/qmp/qstring.h"
34 #include "qemu/error-report.h"
36 #define MAX_INTERFACES 32
38 typedef struct InterfaceImpl InterfaceImpl
;
39 typedef struct TypeImpl TypeImpl
;
53 size_t instance_align
;
55 void (*class_init
)(ObjectClass
*klass
, void *data
);
56 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
60 void (*instance_init
)(Object
*obj
);
61 void (*instance_post_init
)(Object
*obj
);
62 void (*instance_finalize
)(Object
*obj
);
67 TypeImpl
*parent_type
;
72 InterfaceImpl interfaces
[MAX_INTERFACES
];
75 static Type type_interface
;
77 static GHashTable
*type_table_get(void)
79 static GHashTable
*type_table
;
81 if (type_table
== NULL
) {
82 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
88 static bool enumerating_types
;
90 static void type_table_add(TypeImpl
*ti
)
92 assert(!enumerating_types
);
93 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
96 static TypeImpl
*type_table_lookup(const char *name
)
98 return g_hash_table_lookup(type_table_get(), name
);
101 static TypeImpl
*type_new(const TypeInfo
*info
)
103 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
106 g_assert(info
->name
!= NULL
);
108 if (type_table_lookup(info
->name
) != NULL
) {
109 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
113 ti
->name
= g_strdup(info
->name
);
114 ti
->parent
= g_strdup(info
->parent
);
116 ti
->class_size
= info
->class_size
;
117 ti
->instance_size
= info
->instance_size
;
118 ti
->instance_align
= info
->instance_align
;
120 ti
->class_init
= info
->class_init
;
121 ti
->class_base_init
= info
->class_base_init
;
122 ti
->class_data
= info
->class_data
;
124 ti
->instance_init
= info
->instance_init
;
125 ti
->instance_post_init
= info
->instance_post_init
;
126 ti
->instance_finalize
= info
->instance_finalize
;
128 ti
->abstract
= info
->abstract
;
130 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
131 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
133 ti
->num_interfaces
= i
;
138 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
147 TypeImpl
*type_register(const TypeInfo
*info
)
149 assert(info
->parent
);
150 return type_register_internal(info
);
153 TypeImpl
*type_register_static(const TypeInfo
*info
)
155 return type_register(info
);
158 void type_register_static_array(const TypeInfo
*infos
, int nr_infos
)
162 for (i
= 0; i
< nr_infos
; i
++) {
163 type_register_static(&infos
[i
]);
167 static TypeImpl
*type_get_by_name(const char *name
)
173 return type_table_lookup(name
);
176 static TypeImpl
*type_get_parent(TypeImpl
*type
)
178 if (!type
->parent_type
&& type
->parent
) {
179 type
->parent_type
= type_get_by_name(type
->parent
);
180 if (!type
->parent_type
) {
181 fprintf(stderr
, "Type '%s' is missing its parent '%s'\n",
182 type
->name
, type
->parent
);
187 return type
->parent_type
;
190 static bool type_has_parent(TypeImpl
*type
)
192 return (type
->parent
!= NULL
);
195 static size_t type_class_get_size(TypeImpl
*ti
)
197 if (ti
->class_size
) {
198 return ti
->class_size
;
201 if (type_has_parent(ti
)) {
202 return type_class_get_size(type_get_parent(ti
));
205 return sizeof(ObjectClass
);
208 static size_t type_object_get_size(TypeImpl
*ti
)
210 if (ti
->instance_size
) {
211 return ti
->instance_size
;
214 if (type_has_parent(ti
)) {
215 return type_object_get_size(type_get_parent(ti
));
221 size_t object_type_get_instance_size(const char *typename
)
223 TypeImpl
*type
= type_get_by_name(typename
);
225 g_assert(type
!= NULL
);
226 return type_object_get_size(type
);
229 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
233 /* Check if target_type is a direct ancestor of type */
235 if (type
== target_type
) {
239 type
= type_get_parent(type
);
245 static void type_initialize(TypeImpl
*ti
);
247 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
248 TypeImpl
*parent_type
)
250 InterfaceClass
*new_iface
;
252 TypeImpl
*iface_impl
;
254 info
.parent
= parent_type
->name
;
255 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
256 info
.abstract
= true;
258 iface_impl
= type_new(&info
);
259 iface_impl
->parent_type
= parent_type
;
260 type_initialize(iface_impl
);
261 g_free((char *)info
.name
);
263 new_iface
= (InterfaceClass
*)iface_impl
->class;
264 new_iface
->concrete_class
= ti
->class;
265 new_iface
->interface_type
= interface_type
;
267 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
, new_iface
);
270 static void object_property_free(gpointer data
)
272 ObjectProperty
*prop
= data
;
275 qobject_unref(prop
->defval
);
280 g_free(prop
->description
);
284 static void type_initialize(TypeImpl
*ti
)
292 ti
->class_size
= type_class_get_size(ti
);
293 ti
->instance_size
= type_object_get_size(ti
);
294 /* Any type with zero instance_size is implicitly abstract.
295 * This means interface types are all abstract.
297 if (ti
->instance_size
== 0) {
300 if (type_is_ancestor(ti
, type_interface
)) {
301 assert(ti
->instance_size
== 0);
302 assert(ti
->abstract
);
303 assert(!ti
->instance_init
);
304 assert(!ti
->instance_post_init
);
305 assert(!ti
->instance_finalize
);
306 assert(!ti
->num_interfaces
);
308 ti
->class = g_malloc0(ti
->class_size
);
310 parent
= type_get_parent(ti
);
312 type_initialize(parent
);
316 g_assert(parent
->class_size
<= ti
->class_size
);
317 g_assert(parent
->instance_size
<= ti
->instance_size
);
318 memcpy(ti
->class, parent
->class, parent
->class_size
);
319 ti
->class->interfaces
= NULL
;
321 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
322 InterfaceClass
*iface
= e
->data
;
323 ObjectClass
*klass
= OBJECT_CLASS(iface
);
325 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
328 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
329 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
331 error_report("missing interface '%s' for object '%s'",
332 ti
->interfaces
[i
].typename
, parent
->name
);
335 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
336 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
338 if (type_is_ancestor(target_type
, t
)) {
347 type_initialize_interface(ti
, t
, t
);
351 ti
->class->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
, NULL
,
352 object_property_free
);
354 ti
->class->type
= ti
;
357 if (parent
->class_base_init
) {
358 parent
->class_base_init(ti
->class, ti
->class_data
);
360 parent
= type_get_parent(parent
);
363 if (ti
->class_init
) {
364 ti
->class_init(ti
->class, ti
->class_data
);
368 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
370 if (type_has_parent(ti
)) {
371 object_init_with_type(obj
, type_get_parent(ti
));
374 if (ti
->instance_init
) {
375 ti
->instance_init(obj
);
379 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
381 if (ti
->instance_post_init
) {
382 ti
->instance_post_init(obj
);
385 if (type_has_parent(ti
)) {
386 object_post_init_with_type(obj
, type_get_parent(ti
));
390 bool object_apply_global_props(Object
*obj
, const GPtrArray
*props
,
399 for (i
= 0; i
< props
->len
; i
++) {
400 GlobalProperty
*p
= g_ptr_array_index(props
, i
);
403 if (object_dynamic_cast(obj
, p
->driver
) == NULL
) {
406 if (p
->optional
&& !object_property_find(obj
, p
->property
, NULL
)) {
410 if (!object_property_parse(obj
, p
->property
, p
->value
, &err
)) {
411 error_prepend(&err
, "can't apply global %s.%s=%s: ",
412 p
->driver
, p
->property
, p
->value
);
414 * If errp != NULL, propagate error and return.
415 * If errp == NULL, report a warning, but keep going
416 * with the remaining globals.
419 error_propagate(errp
, err
);
422 warn_report_err(err
);
431 * Global property defaults
432 * Slot 0: accelerator's global property defaults
433 * Slot 1: machine's global property defaults
434 * Slot 2: global properties from legacy command line option
435 * Each is a GPtrArray of of GlobalProperty.
436 * Applied in order, later entries override earlier ones.
438 static GPtrArray
*object_compat_props
[3];
441 * Retrieve @GPtrArray for global property defined with options
442 * other than "-global". These are generally used for syntactic
443 * sugar and legacy command line options.
445 void object_register_sugar_prop(const char *driver
, const char *prop
, const char *value
)
448 if (!object_compat_props
[2]) {
449 object_compat_props
[2] = g_ptr_array_new();
451 g
= g_new0(GlobalProperty
, 1);
452 g
->driver
= g_strdup(driver
);
453 g
->property
= g_strdup(prop
);
454 g
->value
= g_strdup(value
);
455 g_ptr_array_add(object_compat_props
[2], g
);
459 * Set machine's global property defaults to @compat_props.
460 * May be called at most once.
462 void object_set_machine_compat_props(GPtrArray
*compat_props
)
464 assert(!object_compat_props
[1]);
465 object_compat_props
[1] = compat_props
;
469 * Set accelerator's global property defaults to @compat_props.
470 * May be called at most once.
472 void object_set_accelerator_compat_props(GPtrArray
*compat_props
)
474 assert(!object_compat_props
[0]);
475 object_compat_props
[0] = compat_props
;
478 void object_apply_compat_props(Object
*obj
)
482 for (i
= 0; i
< ARRAY_SIZE(object_compat_props
); i
++) {
483 object_apply_global_props(obj
, object_compat_props
[i
],
484 i
== 2 ? &error_fatal
: &error_abort
);
488 static void object_class_property_init_all(Object
*obj
)
490 ObjectPropertyIterator iter
;
491 ObjectProperty
*prop
;
493 object_class_property_iter_init(&iter
, object_get_class(obj
));
494 while ((prop
= object_property_iter_next(&iter
))) {
496 prop
->init(obj
, prop
);
501 static void object_initialize_with_type(Object
*obj
, size_t size
, TypeImpl
*type
)
503 type_initialize(type
);
505 g_assert(type
->instance_size
>= sizeof(Object
));
506 g_assert(type
->abstract
== false);
507 g_assert(size
>= type
->instance_size
);
509 memset(obj
, 0, type
->instance_size
);
510 obj
->class = type
->class;
512 object_class_property_init_all(obj
);
513 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
514 NULL
, object_property_free
);
515 object_init_with_type(obj
, type
);
516 object_post_init_with_type(obj
, type
);
519 void object_initialize(void *data
, size_t size
, const char *typename
)
521 TypeImpl
*type
= type_get_by_name(typename
);
523 #ifdef CONFIG_MODULES
525 module_load_qom_one(typename
);
526 type
= type_get_by_name(typename
);
530 error_report("missing object type '%s'", typename
);
534 object_initialize_with_type(data
, size
, type
);
537 bool object_initialize_child_with_props(Object
*parentobj
,
538 const char *propname
,
539 void *childobj
, size_t size
,
546 va_start(vargs
, errp
);
547 ok
= object_initialize_child_with_propsv(parentobj
, propname
,
548 childobj
, size
, type
, errp
,
554 bool object_initialize_child_with_propsv(Object
*parentobj
,
555 const char *propname
,
556 void *childobj
, size_t size
,
558 Error
**errp
, va_list vargs
)
564 object_initialize(childobj
, size
, type
);
565 obj
= OBJECT(childobj
);
567 if (!object_set_propv(obj
, errp
, vargs
)) {
571 object_property_add_child(parentobj
, propname
, obj
);
573 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
575 if (!user_creatable_complete(uc
, errp
)) {
576 object_unparent(obj
);
585 * We want @obj's reference to be 1 on success, 0 on failure.
586 * On success, it's 2: one taken by object_initialize(), and one
587 * by object_property_add_child().
588 * On failure in object_initialize() or earlier, it's 1.
589 * On failure afterwards, it's also 1: object_unparent() releases
590 * the reference taken by object_property_add_child().
596 void object_initialize_child_internal(Object
*parent
,
597 const char *propname
,
598 void *child
, size_t size
,
601 object_initialize_child_with_props(parent
, propname
, child
, size
, type
,
605 static inline bool object_property_is_child(ObjectProperty
*prop
)
607 return strstart(prop
->type
, "child<", NULL
);
610 static void object_property_del_all(Object
*obj
)
612 g_autoptr(GHashTable
) done
= g_hash_table_new(NULL
, NULL
);
613 ObjectProperty
*prop
;
614 ObjectPropertyIterator iter
;
619 object_property_iter_init(&iter
, obj
);
620 while ((prop
= object_property_iter_next(&iter
)) != NULL
) {
621 if (g_hash_table_add(done
, prop
)) {
623 prop
->release(obj
, prop
->name
, prop
->opaque
);
631 g_hash_table_unref(obj
->properties
);
634 static void object_property_del_child(Object
*obj
, Object
*child
)
636 ObjectProperty
*prop
;
640 g_hash_table_iter_init(&iter
, obj
->properties
);
641 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
643 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
645 prop
->release(obj
, prop
->name
, prop
->opaque
);
646 prop
->release
= NULL
;
651 g_hash_table_iter_init(&iter
, obj
->properties
);
652 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
654 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
655 g_hash_table_iter_remove(&iter
);
661 void object_unparent(Object
*obj
)
664 object_property_del_child(obj
->parent
, obj
);
668 static void object_deinit(Object
*obj
, TypeImpl
*type
)
670 if (type
->instance_finalize
) {
671 type
->instance_finalize(obj
);
674 if (type_has_parent(type
)) {
675 object_deinit(obj
, type_get_parent(type
));
679 static void object_finalize(void *data
)
682 TypeImpl
*ti
= obj
->class->type
;
684 object_property_del_all(obj
);
685 object_deinit(obj
, ti
);
687 g_assert(obj
->ref
== 0);
693 /* Find the minimum alignment guaranteed by the system malloc. */
694 #if __STDC_VERSION__ >= 201112L
695 typddef max_align_t qemu_max_align_t
;
705 static Object
*object_new_with_type(Type type
)
709 void (*obj_free
)(void *);
711 g_assert(type
!= NULL
);
712 type_initialize(type
);
714 size
= type
->instance_size
;
715 align
= type
->instance_align
;
718 * Do not use qemu_memalign unless required. Depending on the
719 * implementation, extra alignment implies extra overhead.
721 if (likely(align
<= __alignof__(qemu_max_align_t
))) {
722 obj
= g_malloc(size
);
725 obj
= qemu_memalign(align
, size
);
726 obj_free
= qemu_vfree
;
729 object_initialize_with_type(obj
, size
, type
);
730 obj
->free
= obj_free
;
735 Object
*object_new_with_class(ObjectClass
*klass
)
737 return object_new_with_type(klass
->type
);
740 Object
*object_new(const char *typename
)
742 TypeImpl
*ti
= type_get_by_name(typename
);
744 return object_new_with_type(ti
);
748 Object
*object_new_with_props(const char *typename
,
757 va_start(vargs
, errp
);
758 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
765 Object
*object_new_with_propv(const char *typename
,
775 klass
= object_class_by_name(typename
);
777 error_setg(errp
, "invalid object type: %s", typename
);
781 if (object_class_is_abstract(klass
)) {
782 error_setg(errp
, "object type '%s' is abstract", typename
);
785 obj
= object_new_with_type(klass
->type
);
787 if (!object_set_propv(obj
, errp
, vargs
)) {
792 object_property_add_child(parent
, id
, obj
);
795 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
797 if (!user_creatable_complete(uc
, errp
)) {
799 object_unparent(obj
);
814 bool object_set_props(Object
*obj
,
821 va_start(vargs
, errp
);
822 ret
= object_set_propv(obj
, errp
, vargs
);
829 bool object_set_propv(Object
*obj
,
833 const char *propname
;
835 propname
= va_arg(vargs
, char *);
836 while (propname
!= NULL
) {
837 const char *value
= va_arg(vargs
, char *);
839 g_assert(value
!= NULL
);
840 if (!object_property_parse(obj
, propname
, value
, errp
)) {
843 propname
= va_arg(vargs
, char *);
850 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
852 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
859 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
860 const char *file
, int line
, const char *func
)
862 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
863 typename
, file
, line
, func
);
865 #ifdef CONFIG_QOM_CAST_DEBUG
869 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
870 if (atomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
875 inst
= object_dynamic_cast(obj
, typename
);
878 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
879 file
, line
, func
, obj
, typename
);
885 if (obj
&& obj
== inst
) {
886 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
887 atomic_set(&obj
->class->object_cast_cache
[i
- 1],
888 atomic_read(&obj
->class->object_cast_cache
[i
]));
890 atomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
898 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
899 const char *typename
)
901 ObjectClass
*ret
= NULL
;
902 TypeImpl
*target_type
;
909 /* A simple fast path that can trigger a lot for leaf classes. */
911 if (type
->name
== typename
) {
915 target_type
= type_get_by_name(typename
);
917 /* target class type unknown, so fail the cast */
921 if (type
->class->interfaces
&&
922 type_is_ancestor(target_type
, type_interface
)) {
926 for (i
= class->interfaces
; i
; i
= i
->next
) {
927 ObjectClass
*target_class
= i
->data
;
929 if (type_is_ancestor(target_class
->type
, target_type
)) {
935 /* The match was ambiguous, don't allow a cast */
939 } else if (type_is_ancestor(type
, target_type
)) {
946 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
947 const char *typename
,
948 const char *file
, int line
,
953 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
954 typename
, file
, line
, func
);
956 #ifdef CONFIG_QOM_CAST_DEBUG
959 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
960 if (atomic_read(&class->class_cast_cache
[i
]) == typename
) {
966 if (!class || !class->interfaces
) {
971 ret
= object_class_dynamic_cast(class, typename
);
973 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
974 file
, line
, func
, class, typename
);
978 #ifdef CONFIG_QOM_CAST_DEBUG
979 if (class && ret
== class) {
980 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
981 atomic_set(&class->class_cast_cache
[i
- 1],
982 atomic_read(&class->class_cast_cache
[i
]));
984 atomic_set(&class->class_cast_cache
[i
- 1], typename
);
991 const char *object_get_typename(const Object
*obj
)
993 return obj
->class->type
->name
;
996 ObjectClass
*object_get_class(Object
*obj
)
1001 bool object_class_is_abstract(ObjectClass
*klass
)
1003 return klass
->type
->abstract
;
1006 const char *object_class_get_name(ObjectClass
*klass
)
1008 return klass
->type
->name
;
1011 ObjectClass
*object_class_by_name(const char *typename
)
1013 TypeImpl
*type
= type_get_by_name(typename
);
1019 type_initialize(type
);
1024 ObjectClass
*module_object_class_by_name(const char *typename
)
1028 oc
= object_class_by_name(typename
);
1029 #ifdef CONFIG_MODULES
1031 module_load_qom_one(typename
);
1032 oc
= object_class_by_name(typename
);
1038 ObjectClass
*object_class_get_parent(ObjectClass
*class)
1040 TypeImpl
*type
= type_get_parent(class->type
);
1046 type_initialize(type
);
1051 typedef struct OCFData
1053 void (*fn
)(ObjectClass
*klass
, void *opaque
);
1054 const char *implements_type
;
1055 bool include_abstract
;
1059 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
1062 OCFData
*data
= opaque
;
1063 TypeImpl
*type
= value
;
1066 type_initialize(type
);
1069 if (!data
->include_abstract
&& type
->abstract
) {
1073 if (data
->implements_type
&&
1074 !object_class_dynamic_cast(k
, data
->implements_type
)) {
1078 data
->fn(k
, data
->opaque
);
1081 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
1082 const char *implements_type
, bool include_abstract
,
1085 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
1087 enumerating_types
= true;
1088 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
1089 enumerating_types
= false;
1092 static int do_object_child_foreach(Object
*obj
,
1093 int (*fn
)(Object
*child
, void *opaque
),
1094 void *opaque
, bool recurse
)
1096 GHashTableIter iter
;
1097 ObjectProperty
*prop
;
1100 g_hash_table_iter_init(&iter
, obj
->properties
);
1101 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1102 if (object_property_is_child(prop
)) {
1103 Object
*child
= prop
->opaque
;
1105 ret
= fn(child
, opaque
);
1110 ret
= do_object_child_foreach(child
, fn
, opaque
, true);
1120 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
1123 return do_object_child_foreach(obj
, fn
, opaque
, false);
1126 int object_child_foreach_recursive(Object
*obj
,
1127 int (*fn
)(Object
*child
, void *opaque
),
1130 return do_object_child_foreach(obj
, fn
, opaque
, true);
1133 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
1135 GSList
**list
= opaque
;
1137 *list
= g_slist_prepend(*list
, klass
);
1140 GSList
*object_class_get_list(const char *implements_type
,
1141 bool include_abstract
)
1143 GSList
*list
= NULL
;
1145 object_class_foreach(object_class_get_list_tramp
,
1146 implements_type
, include_abstract
, &list
);
1150 static gint
object_class_cmp(gconstpointer a
, gconstpointer b
)
1152 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
1153 object_class_get_name((ObjectClass
*)b
));
1156 GSList
*object_class_get_list_sorted(const char *implements_type
,
1157 bool include_abstract
)
1159 return g_slist_sort(object_class_get_list(implements_type
, include_abstract
),
1163 Object
*object_ref(void *objptr
)
1165 Object
*obj
= OBJECT(objptr
);
1169 atomic_inc(&obj
->ref
);
1173 void object_unref(void *objptr
)
1175 Object
*obj
= OBJECT(objptr
);
1179 g_assert(obj
->ref
> 0);
1181 /* parent always holds a reference to its children */
1182 if (atomic_fetch_dec(&obj
->ref
) == 1) {
1183 object_finalize(obj
);
1188 object_property_try_add(Object
*obj
, const char *name
, const char *type
,
1189 ObjectPropertyAccessor
*get
,
1190 ObjectPropertyAccessor
*set
,
1191 ObjectPropertyRelease
*release
,
1192 void *opaque
, Error
**errp
)
1194 ObjectProperty
*prop
;
1195 size_t name_len
= strlen(name
);
1197 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
1199 ObjectProperty
*ret
;
1200 char *name_no_array
= g_strdup(name
);
1202 name_no_array
[name_len
- 3] = '\0';
1203 for (i
= 0; ; ++i
) {
1204 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
1206 ret
= object_property_try_add(obj
, full_name
, type
, get
, set
,
1207 release
, opaque
, NULL
);
1213 g_free(name_no_array
);
1217 if (object_property_find(obj
, name
, NULL
) != NULL
) {
1218 error_setg(errp
, "attempt to add duplicate property '%s' to object (type '%s')",
1219 name
, object_get_typename(obj
));
1223 prop
= g_malloc0(sizeof(*prop
));
1225 prop
->name
= g_strdup(name
);
1226 prop
->type
= g_strdup(type
);
1230 prop
->release
= release
;
1231 prop
->opaque
= opaque
;
1233 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
1238 object_property_add(Object
*obj
, const char *name
, const char *type
,
1239 ObjectPropertyAccessor
*get
,
1240 ObjectPropertyAccessor
*set
,
1241 ObjectPropertyRelease
*release
,
1244 return object_property_try_add(obj
, name
, type
, get
, set
, release
,
1245 opaque
, &error_abort
);
1249 object_class_property_add(ObjectClass
*klass
,
1252 ObjectPropertyAccessor
*get
,
1253 ObjectPropertyAccessor
*set
,
1254 ObjectPropertyRelease
*release
,
1257 ObjectProperty
*prop
;
1259 assert(!object_class_property_find(klass
, name
, NULL
));
1261 prop
= g_malloc0(sizeof(*prop
));
1263 prop
->name
= g_strdup(name
);
1264 prop
->type
= g_strdup(type
);
1268 prop
->release
= release
;
1269 prop
->opaque
= opaque
;
1271 g_hash_table_insert(klass
->properties
, prop
->name
, prop
);
1276 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
1279 ObjectProperty
*prop
;
1280 ObjectClass
*klass
= object_get_class(obj
);
1282 prop
= object_class_property_find(klass
, name
, NULL
);
1287 prop
= g_hash_table_lookup(obj
->properties
, name
);
1292 error_setg(errp
, "Property '.%s' not found", name
);
1296 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1299 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1300 iter
->nextclass
= object_get_class(obj
);
1303 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1306 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1307 if (!iter
->nextclass
) {
1310 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1311 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1316 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1319 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1320 iter
->nextclass
= object_class_get_parent(klass
);
1323 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
,
1326 ObjectProperty
*prop
;
1327 ObjectClass
*parent_klass
;
1329 parent_klass
= object_class_get_parent(klass
);
1331 prop
= object_class_property_find(parent_klass
, name
, NULL
);
1337 prop
= g_hash_table_lookup(klass
->properties
, name
);
1339 error_setg(errp
, "Property '.%s' not found", name
);
1344 void object_property_del(Object
*obj
, const char *name
)
1346 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1348 if (prop
->release
) {
1349 prop
->release(obj
, name
, prop
->opaque
);
1351 g_hash_table_remove(obj
->properties
, name
);
1354 bool object_property_get(Object
*obj
, const char *name
, Visitor
*v
,
1358 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1365 error_setg(errp
, QERR_PERMISSION_DENIED
);
1368 prop
->get(obj
, v
, name
, prop
->opaque
, &err
);
1369 error_propagate(errp
, err
);
1373 bool object_property_set(Object
*obj
, const char *name
, Visitor
*v
,
1377 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1384 error_setg(errp
, QERR_PERMISSION_DENIED
);
1387 prop
->set(obj
, v
, name
, prop
->opaque
, &err
);
1388 error_propagate(errp
, err
);
1392 bool object_property_set_str(Object
*obj
, const char *name
,
1393 const char *value
, Error
**errp
)
1395 QString
*qstr
= qstring_from_str(value
);
1396 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qstr
), errp
);
1398 qobject_unref(qstr
);
1402 char *object_property_get_str(Object
*obj
, const char *name
,
1405 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1412 retval
= g_strdup(qobject_get_try_str(ret
));
1414 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1421 bool object_property_set_link(Object
*obj
, const char *name
,
1422 Object
*value
, Error
**errp
)
1424 g_autofree
char *path
= NULL
;
1427 path
= object_get_canonical_path(value
);
1429 return object_property_set_str(obj
, name
, path
?: "", errp
);
1432 Object
*object_property_get_link(Object
*obj
, const char *name
,
1435 char *str
= object_property_get_str(obj
, name
, errp
);
1436 Object
*target
= NULL
;
1439 target
= object_resolve_path(str
, NULL
);
1441 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1442 "Device '%s' not found", str
);
1450 bool object_property_set_bool(Object
*obj
, const char *name
,
1451 bool value
, Error
**errp
)
1453 QBool
*qbool
= qbool_from_bool(value
);
1454 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qbool
), errp
);
1456 qobject_unref(qbool
);
1460 bool object_property_get_bool(Object
*obj
, const char *name
,
1463 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1470 qbool
= qobject_to(QBool
, ret
);
1472 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1475 retval
= qbool_get_bool(qbool
);
1482 bool object_property_set_int(Object
*obj
, const char *name
,
1483 int64_t value
, Error
**errp
)
1485 QNum
*qnum
= qnum_from_int(value
);
1486 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qnum
), errp
);
1488 qobject_unref(qnum
);
1492 int64_t object_property_get_int(Object
*obj
, const char *name
,
1495 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1503 qnum
= qobject_to(QNum
, ret
);
1504 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1505 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1513 static void object_property_init_defval(Object
*obj
, ObjectProperty
*prop
)
1515 Visitor
*v
= qobject_input_visitor_new(prop
->defval
);
1517 assert(prop
->set
!= NULL
);
1518 prop
->set(obj
, v
, prop
->name
, prop
->opaque
, &error_abort
);
1523 static void object_property_set_default(ObjectProperty
*prop
, QObject
*defval
)
1525 assert(!prop
->defval
);
1526 assert(!prop
->init
);
1528 prop
->defval
= defval
;
1529 prop
->init
= object_property_init_defval
;
1532 void object_property_set_default_bool(ObjectProperty
*prop
, bool value
)
1534 object_property_set_default(prop
, QOBJECT(qbool_from_bool(value
)));
1537 void object_property_set_default_str(ObjectProperty
*prop
, const char *value
)
1539 object_property_set_default(prop
, QOBJECT(qstring_from_str(value
)));
1542 void object_property_set_default_int(ObjectProperty
*prop
, int64_t value
)
1544 object_property_set_default(prop
, QOBJECT(qnum_from_int(value
)));
1547 void object_property_set_default_uint(ObjectProperty
*prop
, uint64_t value
)
1549 object_property_set_default(prop
, QOBJECT(qnum_from_uint(value
)));
1552 bool object_property_set_uint(Object
*obj
, const char *name
,
1553 uint64_t value
, Error
**errp
)
1555 QNum
*qnum
= qnum_from_uint(value
);
1556 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qnum
), errp
);
1558 qobject_unref(qnum
);
1562 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1565 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1572 qnum
= qobject_to(QNum
, ret
);
1573 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1574 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "uint");
1582 typedef struct EnumProperty
{
1583 const QEnumLookup
*lookup
;
1584 int (*get
)(Object
*, Error
**);
1585 void (*set
)(Object
*, int, Error
**);
1588 int object_property_get_enum(Object
*obj
, const char *name
,
1589 const char *typename
, Error
**errp
)
1593 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1594 EnumProperty
*enumprop
;
1600 if (!g_str_equal(prop
->type
, typename
)) {
1601 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1602 name
, object_class_get_name(
1603 object_get_class(obj
)), typename
);
1607 enumprop
= prop
->opaque
;
1609 str
= object_property_get_str(obj
, name
, errp
);
1614 ret
= qapi_enum_parse(enumprop
->lookup
, str
, -1, errp
);
1620 bool object_property_parse(Object
*obj
, const char *name
,
1621 const char *string
, Error
**errp
)
1623 Visitor
*v
= string_input_visitor_new(string
);
1624 bool ok
= object_property_set(obj
, name
, v
, errp
);
1630 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1634 char *string
= NULL
;
1636 v
= string_output_visitor_new(human
, &string
);
1637 if (!object_property_get(obj
, name
, v
, errp
)) {
1641 visit_complete(v
, &string
);
1648 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1650 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1658 Object
*object_get_root(void)
1660 static Object
*root
;
1663 root
= object_new("container");
1669 Object
*object_get_objects_root(void)
1671 return container_get(object_get_root(), "/objects");
1674 Object
*object_get_internal_root(void)
1676 static Object
*internal_root
;
1678 if (!internal_root
) {
1679 internal_root
= object_new("container");
1682 return internal_root
;
1685 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1686 const char *name
, void *opaque
,
1689 Object
*child
= opaque
;
1692 path
= object_get_canonical_path(child
);
1693 visit_type_str(v
, name
, &path
, errp
);
1697 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
,
1703 static void object_finalize_child_property(Object
*obj
, const char *name
,
1706 Object
*child
= opaque
;
1708 if (child
->class->unparent
) {
1709 (child
->class->unparent
)(child
);
1711 child
->parent
= NULL
;
1712 object_unref(child
);
1716 object_property_try_add_child(Object
*obj
, const char *name
,
1717 Object
*child
, Error
**errp
)
1719 g_autofree
char *type
= NULL
;
1722 assert(!child
->parent
);
1724 type
= g_strdup_printf("child<%s>", object_get_typename(child
));
1726 op
= object_property_try_add(obj
, name
, type
, object_get_child_property
,
1727 NULL
, object_finalize_child_property
,
1732 op
->resolve
= object_resolve_child_property
;
1734 child
->parent
= obj
;
1739 object_property_add_child(Object
*obj
, const char *name
,
1742 return object_property_try_add_child(obj
, name
, child
, &error_abort
);
1745 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1746 Object
*val
, Error
**errp
)
1748 /* Allow the link to be set, always */
1754 Object
*target
; /* if OBJ_PROP_LINK_DIRECT, when holding the pointer */
1755 ptrdiff_t offset
; /* if OBJ_PROP_LINK_CLASS */
1757 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1758 ObjectPropertyLinkFlags flags
;
1762 object_link_get_targetp(Object
*obj
, LinkProperty
*lprop
)
1764 if (lprop
->flags
& OBJ_PROP_LINK_DIRECT
) {
1765 return &lprop
->target
;
1766 } else if (lprop
->flags
& OBJ_PROP_LINK_CLASS
) {
1767 return (void *)obj
+ lprop
->offset
;
1769 return lprop
->targetp
;
1773 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1774 const char *name
, void *opaque
,
1777 LinkProperty
*lprop
= opaque
;
1778 Object
**targetp
= object_link_get_targetp(obj
, lprop
);
1782 path
= object_get_canonical_path(*targetp
);
1783 visit_type_str(v
, name
, &path
, errp
);
1787 visit_type_str(v
, name
, &path
, errp
);
1792 * object_resolve_link:
1794 * Lookup an object and ensure its type matches the link property type. This
1795 * is similar to object_resolve_path() except type verification against the
1796 * link property is performed.
1798 * Returns: The matched object or NULL on path lookup failures.
1800 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1801 const char *path
, Error
**errp
)
1805 bool ambiguous
= false;
1808 /* Go from link<FOO> to FOO. */
1809 type
= object_property_get_type(obj
, name
, NULL
);
1810 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1811 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1814 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1816 } else if (!target
) {
1817 target
= object_resolve_path(path
, &ambiguous
);
1818 if (target
|| ambiguous
) {
1819 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1821 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1822 "Device '%s' not found", path
);
1826 g_free(target_type
);
1831 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1832 const char *name
, void *opaque
,
1835 Error
*local_err
= NULL
;
1836 LinkProperty
*prop
= opaque
;
1837 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1838 Object
*old_target
= *targetp
;
1842 if (!visit_type_str(v
, name
, &path
, errp
)) {
1847 new_target
= object_resolve_link(obj
, name
, path
, errp
);
1858 prop
->check(obj
, name
, new_target
, &local_err
);
1860 error_propagate(errp
, local_err
);
1864 *targetp
= new_target
;
1865 if (prop
->flags
& OBJ_PROP_LINK_STRONG
) {
1866 object_ref(new_target
);
1867 object_unref(old_target
);
1871 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
,
1874 LinkProperty
*lprop
= opaque
;
1876 return *object_link_get_targetp(parent
, lprop
);
1879 static void object_release_link_property(Object
*obj
, const char *name
,
1882 LinkProperty
*prop
= opaque
;
1883 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1885 if ((prop
->flags
& OBJ_PROP_LINK_STRONG
) && *targetp
) {
1886 object_unref(*targetp
);
1888 if (!(prop
->flags
& OBJ_PROP_LINK_CLASS
)) {
1893 static ObjectProperty
*
1894 object_add_link_prop(Object
*obj
, const char *name
,
1895 const char *type
, void *ptr
,
1896 void (*check
)(const Object
*, const char *,
1897 Object
*, Error
**),
1898 ObjectPropertyLinkFlags flags
)
1900 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1901 g_autofree
char *full_type
= NULL
;
1904 if (flags
& OBJ_PROP_LINK_DIRECT
) {
1907 prop
->targetp
= ptr
;
1909 prop
->check
= check
;
1910 prop
->flags
= flags
;
1912 full_type
= g_strdup_printf("link<%s>", type
);
1914 op
= object_property_add(obj
, name
, full_type
,
1915 object_get_link_property
,
1916 check
? object_set_link_property
: NULL
,
1917 object_release_link_property
,
1919 op
->resolve
= object_resolve_link_property
;
1924 object_property_add_link(Object
*obj
, const char *name
,
1925 const char *type
, Object
**targetp
,
1926 void (*check
)(const Object
*, const char *,
1927 Object
*, Error
**),
1928 ObjectPropertyLinkFlags flags
)
1930 return object_add_link_prop(obj
, name
, type
, targetp
, check
, flags
);
1934 object_class_property_add_link(ObjectClass
*oc
,
1936 const char *type
, ptrdiff_t offset
,
1937 void (*check
)(const Object
*obj
, const char *name
,
1938 Object
*val
, Error
**errp
),
1939 ObjectPropertyLinkFlags flags
)
1941 LinkProperty
*prop
= g_new0(LinkProperty
, 1);
1945 prop
->offset
= offset
;
1946 prop
->check
= check
;
1947 prop
->flags
= flags
| OBJ_PROP_LINK_CLASS
;
1949 full_type
= g_strdup_printf("link<%s>", type
);
1951 op
= object_class_property_add(oc
, name
, full_type
,
1952 object_get_link_property
,
1953 check
? object_set_link_property
: NULL
,
1954 object_release_link_property
,
1957 op
->resolve
= object_resolve_link_property
;
1964 object_property_add_const_link(Object
*obj
, const char *name
,
1967 return object_add_link_prop(obj
, name
,
1968 object_get_typename(target
), target
,
1969 NULL
, OBJ_PROP_LINK_DIRECT
);
1972 const char *object_get_canonical_path_component(const Object
*obj
)
1974 ObjectProperty
*prop
= NULL
;
1975 GHashTableIter iter
;
1977 if (obj
->parent
== NULL
) {
1981 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
1982 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1983 if (!object_property_is_child(prop
)) {
1987 if (prop
->opaque
== obj
) {
1992 /* obj had a parent but was not a child, should never happen */
1993 g_assert_not_reached();
1997 char *object_get_canonical_path(const Object
*obj
)
1999 Object
*root
= object_get_root();
2000 char *newpath
, *path
= NULL
;
2003 return g_strdup("/");
2007 const char *component
= object_get_canonical_path_component(obj
);
2010 /* A canonical path must be complete, so discard what was
2017 newpath
= g_strdup_printf("/%s%s", component
, path
? path
: "");
2021 } while (obj
!= root
);
2026 Object
*object_resolve_path_component(Object
*parent
, const char *part
)
2028 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
2033 if (prop
->resolve
) {
2034 return prop
->resolve(parent
, prop
->opaque
, part
);
2040 static Object
*object_resolve_abs_path(Object
*parent
,
2042 const char *typename
)
2046 if (*parts
== NULL
) {
2047 return object_dynamic_cast(parent
, typename
);
2050 if (strcmp(*parts
, "") == 0) {
2051 return object_resolve_abs_path(parent
, parts
+ 1, typename
);
2054 child
= object_resolve_path_component(parent
, *parts
);
2059 return object_resolve_abs_path(child
, parts
+ 1, typename
);
2062 static Object
*object_resolve_partial_path(Object
*parent
,
2064 const char *typename
,
2068 GHashTableIter iter
;
2069 ObjectProperty
*prop
;
2071 obj
= object_resolve_abs_path(parent
, parts
, typename
);
2073 g_hash_table_iter_init(&iter
, parent
->properties
);
2074 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
2077 if (!object_property_is_child(prop
)) {
2081 found
= object_resolve_partial_path(prop
->opaque
, parts
,
2082 typename
, ambiguous
);
2099 Object
*object_resolve_path_type(const char *path
, const char *typename
,
2105 parts
= g_strsplit(path
, "/", 0);
2108 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
2109 bool ambiguous
= false;
2110 obj
= object_resolve_partial_path(object_get_root(), parts
,
2111 typename
, &ambiguous
);
2113 *ambiguousp
= ambiguous
;
2116 obj
= object_resolve_abs_path(object_get_root(), parts
+ 1, typename
);
2124 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
2126 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
2129 typedef struct StringProperty
2131 char *(*get
)(Object
*, Error
**);
2132 void (*set
)(Object
*, const char *, Error
**);
2135 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
2136 void *opaque
, Error
**errp
)
2138 StringProperty
*prop
= opaque
;
2142 value
= prop
->get(obj
, &err
);
2144 error_propagate(errp
, err
);
2148 visit_type_str(v
, name
, &value
, errp
);
2152 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
2153 void *opaque
, Error
**errp
)
2155 StringProperty
*prop
= opaque
;
2158 if (!visit_type_str(v
, name
, &value
, errp
)) {
2162 prop
->set(obj
, value
, errp
);
2166 static void property_release_str(Object
*obj
, const char *name
,
2169 StringProperty
*prop
= opaque
;
2174 object_property_add_str(Object
*obj
, const char *name
,
2175 char *(*get
)(Object
*, Error
**),
2176 void (*set
)(Object
*, const char *, Error
**))
2178 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2183 return object_property_add(obj
, name
, "string",
2184 get
? property_get_str
: NULL
,
2185 set
? property_set_str
: NULL
,
2186 property_release_str
,
2191 object_class_property_add_str(ObjectClass
*klass
, const char *name
,
2192 char *(*get
)(Object
*, Error
**),
2193 void (*set
)(Object
*, const char *,
2196 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2201 return object_class_property_add(klass
, name
, "string",
2202 get
? property_get_str
: NULL
,
2203 set
? property_set_str
: NULL
,
2208 typedef struct BoolProperty
2210 bool (*get
)(Object
*, Error
**);
2211 void (*set
)(Object
*, bool, Error
**);
2214 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
2215 void *opaque
, Error
**errp
)
2217 BoolProperty
*prop
= opaque
;
2221 value
= prop
->get(obj
, &err
);
2223 error_propagate(errp
, err
);
2227 visit_type_bool(v
, name
, &value
, errp
);
2230 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
2231 void *opaque
, Error
**errp
)
2233 BoolProperty
*prop
= opaque
;
2236 if (!visit_type_bool(v
, name
, &value
, errp
)) {
2240 prop
->set(obj
, value
, errp
);
2243 static void property_release_bool(Object
*obj
, const char *name
,
2246 BoolProperty
*prop
= opaque
;
2251 object_property_add_bool(Object
*obj
, const char *name
,
2252 bool (*get
)(Object
*, Error
**),
2253 void (*set
)(Object
*, bool, Error
**))
2255 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2260 return object_property_add(obj
, name
, "bool",
2261 get
? property_get_bool
: NULL
,
2262 set
? property_set_bool
: NULL
,
2263 property_release_bool
,
2268 object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
2269 bool (*get
)(Object
*, Error
**),
2270 void (*set
)(Object
*, bool, Error
**))
2272 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2277 return object_class_property_add(klass
, name
, "bool",
2278 get
? property_get_bool
: NULL
,
2279 set
? property_set_bool
: NULL
,
2284 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
2285 void *opaque
, Error
**errp
)
2287 EnumProperty
*prop
= opaque
;
2291 value
= prop
->get(obj
, &err
);
2293 error_propagate(errp
, err
);
2297 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
2300 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
2301 void *opaque
, Error
**errp
)
2303 EnumProperty
*prop
= opaque
;
2306 if (!visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
)) {
2309 prop
->set(obj
, value
, errp
);
2312 static void property_release_enum(Object
*obj
, const char *name
,
2315 EnumProperty
*prop
= opaque
;
2320 object_property_add_enum(Object
*obj
, const char *name
,
2321 const char *typename
,
2322 const QEnumLookup
*lookup
,
2323 int (*get
)(Object
*, Error
**),
2324 void (*set
)(Object
*, int, Error
**))
2326 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2328 prop
->lookup
= lookup
;
2332 return object_property_add(obj
, name
, typename
,
2333 get
? property_get_enum
: NULL
,
2334 set
? property_set_enum
: NULL
,
2335 property_release_enum
,
2340 object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2341 const char *typename
,
2342 const QEnumLookup
*lookup
,
2343 int (*get
)(Object
*, Error
**),
2344 void (*set
)(Object
*, int, Error
**))
2346 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2348 prop
->lookup
= lookup
;
2352 return object_class_property_add(klass
, name
, typename
,
2353 get
? property_get_enum
: NULL
,
2354 set
? property_set_enum
: NULL
,
2359 typedef struct TMProperty
{
2360 void (*get
)(Object
*, struct tm
*, Error
**);
2363 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2364 void *opaque
, Error
**errp
)
2366 TMProperty
*prop
= opaque
;
2370 prop
->get(obj
, &value
, &err
);
2372 error_propagate(errp
, err
);
2376 if (!visit_start_struct(v
, name
, NULL
, 0, errp
)) {
2379 if (!visit_type_int32(v
, "tm_year", &value
.tm_year
, errp
)) {
2382 if (!visit_type_int32(v
, "tm_mon", &value
.tm_mon
, errp
)) {
2385 if (!visit_type_int32(v
, "tm_mday", &value
.tm_mday
, errp
)) {
2388 if (!visit_type_int32(v
, "tm_hour", &value
.tm_hour
, errp
)) {
2391 if (!visit_type_int32(v
, "tm_min", &value
.tm_min
, errp
)) {
2394 if (!visit_type_int32(v
, "tm_sec", &value
.tm_sec
, errp
)) {
2397 visit_check_struct(v
, errp
);
2399 visit_end_struct(v
, NULL
);
2402 static void property_release_tm(Object
*obj
, const char *name
,
2405 TMProperty
*prop
= opaque
;
2410 object_property_add_tm(Object
*obj
, const char *name
,
2411 void (*get
)(Object
*, struct tm
*, Error
**))
2413 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2417 return object_property_add(obj
, name
, "struct tm",
2418 get
? property_get_tm
: NULL
, NULL
,
2419 property_release_tm
,
2424 object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2425 void (*get
)(Object
*, struct tm
*, Error
**))
2427 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2431 return object_class_property_add(klass
, name
, "struct tm",
2432 get
? property_get_tm
: NULL
,
2436 static char *object_get_type(Object
*obj
, Error
**errp
)
2438 return g_strdup(object_get_typename(obj
));
2441 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2442 void *opaque
, Error
**errp
)
2444 uint8_t value
= *(uint8_t *)opaque
;
2445 visit_type_uint8(v
, name
, &value
, errp
);
2448 static void property_set_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2449 void *opaque
, Error
**errp
)
2451 uint8_t *field
= opaque
;
2454 if (!visit_type_uint8(v
, name
, &value
, errp
)) {
2461 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2462 void *opaque
, Error
**errp
)
2464 uint16_t value
= *(uint16_t *)opaque
;
2465 visit_type_uint16(v
, name
, &value
, errp
);
2468 static void property_set_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2469 void *opaque
, Error
**errp
)
2471 uint16_t *field
= opaque
;
2474 if (!visit_type_uint16(v
, name
, &value
, errp
)) {
2481 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2482 void *opaque
, Error
**errp
)
2484 uint32_t value
= *(uint32_t *)opaque
;
2485 visit_type_uint32(v
, name
, &value
, errp
);
2488 static void property_set_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2489 void *opaque
, Error
**errp
)
2491 uint32_t *field
= opaque
;
2494 if (!visit_type_uint32(v
, name
, &value
, errp
)) {
2501 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2502 void *opaque
, Error
**errp
)
2504 uint64_t value
= *(uint64_t *)opaque
;
2505 visit_type_uint64(v
, name
, &value
, errp
);
2508 static void property_set_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2509 void *opaque
, Error
**errp
)
2511 uint64_t *field
= opaque
;
2514 if (!visit_type_uint64(v
, name
, &value
, errp
)) {
2522 object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2524 ObjectPropertyFlags flags
)
2526 ObjectPropertyAccessor
*getter
= NULL
;
2527 ObjectPropertyAccessor
*setter
= NULL
;
2529 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2530 getter
= property_get_uint8_ptr
;
2533 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2534 setter
= property_set_uint8_ptr
;
2537 return object_property_add(obj
, name
, "uint8",
2538 getter
, setter
, NULL
, (void *)v
);
2542 object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2544 ObjectPropertyFlags flags
)
2546 ObjectPropertyAccessor
*getter
= NULL
;
2547 ObjectPropertyAccessor
*setter
= NULL
;
2549 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2550 getter
= property_get_uint8_ptr
;
2553 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2554 setter
= property_set_uint8_ptr
;
2557 return object_class_property_add(klass
, name
, "uint8",
2558 getter
, setter
, NULL
, (void *)v
);
2562 object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2564 ObjectPropertyFlags flags
)
2566 ObjectPropertyAccessor
*getter
= NULL
;
2567 ObjectPropertyAccessor
*setter
= NULL
;
2569 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2570 getter
= property_get_uint16_ptr
;
2573 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2574 setter
= property_set_uint16_ptr
;
2577 return object_property_add(obj
, name
, "uint16",
2578 getter
, setter
, NULL
, (void *)v
);
2582 object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2584 ObjectPropertyFlags flags
)
2586 ObjectPropertyAccessor
*getter
= NULL
;
2587 ObjectPropertyAccessor
*setter
= NULL
;
2589 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2590 getter
= property_get_uint16_ptr
;
2593 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2594 setter
= property_set_uint16_ptr
;
2597 return object_class_property_add(klass
, name
, "uint16",
2598 getter
, setter
, NULL
, (void *)v
);
2602 object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2604 ObjectPropertyFlags flags
)
2606 ObjectPropertyAccessor
*getter
= NULL
;
2607 ObjectPropertyAccessor
*setter
= NULL
;
2609 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2610 getter
= property_get_uint32_ptr
;
2613 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2614 setter
= property_set_uint32_ptr
;
2617 return object_property_add(obj
, name
, "uint32",
2618 getter
, setter
, NULL
, (void *)v
);
2622 object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2624 ObjectPropertyFlags flags
)
2626 ObjectPropertyAccessor
*getter
= NULL
;
2627 ObjectPropertyAccessor
*setter
= NULL
;
2629 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2630 getter
= property_get_uint32_ptr
;
2633 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2634 setter
= property_set_uint32_ptr
;
2637 return object_class_property_add(klass
, name
, "uint32",
2638 getter
, setter
, NULL
, (void *)v
);
2642 object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2644 ObjectPropertyFlags flags
)
2646 ObjectPropertyAccessor
*getter
= NULL
;
2647 ObjectPropertyAccessor
*setter
= NULL
;
2649 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2650 getter
= property_get_uint64_ptr
;
2653 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2654 setter
= property_set_uint64_ptr
;
2657 return object_property_add(obj
, name
, "uint64",
2658 getter
, setter
, NULL
, (void *)v
);
2662 object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2664 ObjectPropertyFlags flags
)
2666 ObjectPropertyAccessor
*getter
= NULL
;
2667 ObjectPropertyAccessor
*setter
= NULL
;
2669 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2670 getter
= property_get_uint64_ptr
;
2673 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2674 setter
= property_set_uint64_ptr
;
2677 return object_class_property_add(klass
, name
, "uint64",
2678 getter
, setter
, NULL
, (void *)v
);
2686 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2687 void *opaque
, Error
**errp
)
2689 AliasProperty
*prop
= opaque
;
2691 object_property_get(prop
->target_obj
, prop
->target_name
, v
, errp
);
2694 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2695 void *opaque
, Error
**errp
)
2697 AliasProperty
*prop
= opaque
;
2699 object_property_set(prop
->target_obj
, prop
->target_name
, v
, errp
);
2702 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2705 AliasProperty
*prop
= opaque
;
2707 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2710 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2712 AliasProperty
*prop
= opaque
;
2714 g_free(prop
->target_name
);
2719 object_property_add_alias(Object
*obj
, const char *name
,
2720 Object
*target_obj
, const char *target_name
)
2722 AliasProperty
*prop
;
2724 ObjectProperty
*target_prop
;
2725 g_autofree
char *prop_type
= NULL
;
2727 target_prop
= object_property_find(target_obj
, target_name
,
2730 if (object_property_is_child(target_prop
)) {
2731 prop_type
= g_strdup_printf("link%s",
2732 target_prop
->type
+ strlen("child"));
2734 prop_type
= g_strdup(target_prop
->type
);
2737 prop
= g_malloc(sizeof(*prop
));
2738 prop
->target_obj
= target_obj
;
2739 prop
->target_name
= g_strdup(target_name
);
2741 op
= object_property_add(obj
, name
, prop_type
,
2744 property_release_alias
,
2746 op
->resolve
= property_resolve_alias
;
2747 if (target_prop
->defval
) {
2748 op
->defval
= qobject_ref(target_prop
->defval
);
2751 object_property_set_description(obj
, op
->name
,
2752 target_prop
->description
);
2756 void object_property_set_description(Object
*obj
, const char *name
,
2757 const char *description
)
2761 op
= object_property_find(obj
, name
, &error_abort
);
2762 g_free(op
->description
);
2763 op
->description
= g_strdup(description
);
2766 void object_class_property_set_description(ObjectClass
*klass
,
2768 const char *description
)
2772 op
= g_hash_table_lookup(klass
->properties
, name
);
2773 g_free(op
->description
);
2774 op
->description
= g_strdup(description
);
2777 static void object_class_init(ObjectClass
*klass
, void *data
)
2779 object_class_property_add_str(klass
, "type", object_get_type
,
2783 static void register_types(void)
2785 static TypeInfo interface_info
= {
2786 .name
= TYPE_INTERFACE
,
2787 .class_size
= sizeof(InterfaceClass
),
2791 static TypeInfo object_info
= {
2792 .name
= TYPE_OBJECT
,
2793 .instance_size
= sizeof(Object
),
2794 .class_init
= object_class_init
,
2798 type_interface
= type_register_internal(&interface_info
);
2799 type_register_internal(&object_info
);
2802 type_init(register_types
)