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 "qemu/memalign.h"
20 #include "qapi/visitor.h"
21 #include "qapi/string-input-visitor.h"
22 #include "qapi/string-output-visitor.h"
23 #include "qapi/qobject-input-visitor.h"
24 #include "qapi/forward-visitor.h"
25 #include "qapi/qapi-builtin-visit.h"
26 #include "qapi/qmp/qerror.h"
27 #include "qapi/qmp/qjson.h"
30 /* TODO: replace QObject with a simpler visitor to avoid a dependency
31 * of the QOM core on QObject? */
32 #include "qom/qom-qobject.h"
33 #include "qapi/qmp/qbool.h"
34 #include "qapi/qmp/qnum.h"
35 #include "qapi/qmp/qstring.h"
36 #include "qemu/error-report.h"
38 #define MAX_INTERFACES 32
40 typedef struct InterfaceImpl InterfaceImpl
;
41 typedef struct TypeImpl TypeImpl
;
55 size_t instance_align
;
57 void (*class_init
)(ObjectClass
*klass
, void *data
);
58 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
62 void (*instance_init
)(Object
*obj
);
63 void (*instance_post_init
)(Object
*obj
);
64 void (*instance_finalize
)(Object
*obj
);
69 TypeImpl
*parent_type
;
74 InterfaceImpl interfaces
[MAX_INTERFACES
];
77 static Type type_interface
;
79 static GHashTable
*type_table_get(void)
81 static GHashTable
*type_table
;
83 if (type_table
== NULL
) {
84 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
90 static bool enumerating_types
;
92 static void type_table_add(TypeImpl
*ti
)
94 assert(!enumerating_types
);
95 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
98 static TypeImpl
*type_table_lookup(const char *name
)
100 return g_hash_table_lookup(type_table_get(), name
);
103 static TypeImpl
*type_new(const TypeInfo
*info
)
105 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
108 g_assert(info
->name
!= NULL
);
110 if (type_table_lookup(info
->name
) != NULL
) {
111 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
115 ti
->name
= g_strdup(info
->name
);
116 ti
->parent
= g_strdup(info
->parent
);
118 ti
->class_size
= info
->class_size
;
119 ti
->instance_size
= info
->instance_size
;
120 ti
->instance_align
= info
->instance_align
;
122 ti
->class_init
= info
->class_init
;
123 ti
->class_base_init
= info
->class_base_init
;
124 ti
->class_data
= info
->class_data
;
126 ti
->instance_init
= info
->instance_init
;
127 ti
->instance_post_init
= info
->instance_post_init
;
128 ti
->instance_finalize
= info
->instance_finalize
;
130 ti
->abstract
= info
->abstract
;
132 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
133 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
135 ti
->num_interfaces
= i
;
140 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
149 TypeImpl
*type_register(const TypeInfo
*info
)
151 assert(info
->parent
);
152 return type_register_internal(info
);
155 TypeImpl
*type_register_static(const TypeInfo
*info
)
157 return type_register(info
);
160 void type_register_static_array(const TypeInfo
*infos
, int nr_infos
)
164 for (i
= 0; i
< nr_infos
; i
++) {
165 type_register_static(&infos
[i
]);
169 static TypeImpl
*type_get_by_name(const char *name
)
175 return type_table_lookup(name
);
178 static TypeImpl
*type_get_parent(TypeImpl
*type
)
180 if (!type
->parent_type
&& type
->parent
) {
181 type
->parent_type
= type_get_by_name(type
->parent
);
182 if (!type
->parent_type
) {
183 fprintf(stderr
, "Type '%s' is missing its parent '%s'\n",
184 type
->name
, type
->parent
);
189 return type
->parent_type
;
192 static bool type_has_parent(TypeImpl
*type
)
194 return (type
->parent
!= NULL
);
197 static size_t type_class_get_size(TypeImpl
*ti
)
199 if (ti
->class_size
) {
200 return ti
->class_size
;
203 if (type_has_parent(ti
)) {
204 return type_class_get_size(type_get_parent(ti
));
207 return sizeof(ObjectClass
);
210 static size_t type_object_get_size(TypeImpl
*ti
)
212 if (ti
->instance_size
) {
213 return ti
->instance_size
;
216 if (type_has_parent(ti
)) {
217 return type_object_get_size(type_get_parent(ti
));
223 size_t object_type_get_instance_size(const char *typename
)
225 TypeImpl
*type
= type_get_by_name(typename
);
227 g_assert(type
!= NULL
);
228 return type_object_get_size(type
);
231 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
235 /* Check if target_type is a direct ancestor of type */
237 if (type
== target_type
) {
241 type
= type_get_parent(type
);
247 static void type_initialize(TypeImpl
*ti
);
249 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
250 TypeImpl
*parent_type
)
252 InterfaceClass
*new_iface
;
254 TypeImpl
*iface_impl
;
256 info
.parent
= parent_type
->name
;
257 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
258 info
.abstract
= true;
260 iface_impl
= type_new(&info
);
261 iface_impl
->parent_type
= parent_type
;
262 type_initialize(iface_impl
);
263 g_free((char *)info
.name
);
265 new_iface
= (InterfaceClass
*)iface_impl
->class;
266 new_iface
->concrete_class
= ti
->class;
267 new_iface
->interface_type
= interface_type
;
269 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
, new_iface
);
272 static void object_property_free(gpointer data
)
274 ObjectProperty
*prop
= data
;
277 qobject_unref(prop
->defval
);
282 g_free(prop
->description
);
286 static void type_initialize(TypeImpl
*ti
)
294 ti
->class_size
= type_class_get_size(ti
);
295 ti
->instance_size
= type_object_get_size(ti
);
296 /* Any type with zero instance_size is implicitly abstract.
297 * This means interface types are all abstract.
299 if (ti
->instance_size
== 0) {
302 if (type_is_ancestor(ti
, type_interface
)) {
303 assert(ti
->instance_size
== 0);
304 assert(ti
->abstract
);
305 assert(!ti
->instance_init
);
306 assert(!ti
->instance_post_init
);
307 assert(!ti
->instance_finalize
);
308 assert(!ti
->num_interfaces
);
310 ti
->class = g_malloc0(ti
->class_size
);
312 parent
= type_get_parent(ti
);
314 type_initialize(parent
);
318 g_assert(parent
->class_size
<= ti
->class_size
);
319 g_assert(parent
->instance_size
<= ti
->instance_size
);
320 memcpy(ti
->class, parent
->class, parent
->class_size
);
321 ti
->class->interfaces
= NULL
;
323 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
324 InterfaceClass
*iface
= e
->data
;
325 ObjectClass
*klass
= OBJECT_CLASS(iface
);
327 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
330 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
331 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
333 error_report("missing interface '%s' for object '%s'",
334 ti
->interfaces
[i
].typename
, parent
->name
);
337 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
338 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
340 if (type_is_ancestor(target_type
, t
)) {
349 type_initialize_interface(ti
, t
, t
);
353 ti
->class->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
, NULL
,
354 object_property_free
);
356 ti
->class->type
= ti
;
359 if (parent
->class_base_init
) {
360 parent
->class_base_init(ti
->class, ti
->class_data
);
362 parent
= type_get_parent(parent
);
365 if (ti
->class_init
) {
366 ti
->class_init(ti
->class, ti
->class_data
);
370 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
372 if (type_has_parent(ti
)) {
373 object_init_with_type(obj
, type_get_parent(ti
));
376 if (ti
->instance_init
) {
377 ti
->instance_init(obj
);
381 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
383 if (ti
->instance_post_init
) {
384 ti
->instance_post_init(obj
);
387 if (type_has_parent(ti
)) {
388 object_post_init_with_type(obj
, type_get_parent(ti
));
392 bool object_apply_global_props(Object
*obj
, const GPtrArray
*props
,
401 for (i
= 0; i
< props
->len
; i
++) {
402 GlobalProperty
*p
= g_ptr_array_index(props
, i
);
405 if (object_dynamic_cast(obj
, p
->driver
) == NULL
) {
408 if (p
->optional
&& !object_property_find(obj
, p
->property
)) {
412 if (!object_property_parse(obj
, p
->property
, p
->value
, &err
)) {
413 error_prepend(&err
, "can't apply global %s.%s=%s: ",
414 p
->driver
, p
->property
, p
->value
);
416 * If errp != NULL, propagate error and return.
417 * If errp == NULL, report a warning, but keep going
418 * with the remaining globals.
421 error_propagate(errp
, err
);
424 warn_report_err(err
);
433 * Global property defaults
434 * Slot 0: accelerator's global property defaults
435 * Slot 1: machine's global property defaults
436 * Slot 2: global properties from legacy command line option
437 * Each is a GPtrArray of of GlobalProperty.
438 * Applied in order, later entries override earlier ones.
440 static GPtrArray
*object_compat_props
[3];
443 * Retrieve @GPtrArray for global property defined with options
444 * other than "-global". These are generally used for syntactic
445 * sugar and legacy command line options.
447 void object_register_sugar_prop(const char *driver
, const char *prop
,
448 const char *value
, bool optional
)
451 if (!object_compat_props
[2]) {
452 object_compat_props
[2] = g_ptr_array_new();
454 g
= g_new0(GlobalProperty
, 1);
455 g
->driver
= g_strdup(driver
);
456 g
->property
= g_strdup(prop
);
457 g
->value
= g_strdup(value
);
458 g
->optional
= optional
;
459 g_ptr_array_add(object_compat_props
[2], g
);
463 * Set machine's global property defaults to @compat_props.
464 * May be called at most once.
466 void object_set_machine_compat_props(GPtrArray
*compat_props
)
468 assert(!object_compat_props
[1]);
469 object_compat_props
[1] = compat_props
;
473 * Set accelerator's global property defaults to @compat_props.
474 * May be called at most once.
476 void object_set_accelerator_compat_props(GPtrArray
*compat_props
)
478 assert(!object_compat_props
[0]);
479 object_compat_props
[0] = compat_props
;
482 void object_apply_compat_props(Object
*obj
)
486 for (i
= 0; i
< ARRAY_SIZE(object_compat_props
); i
++) {
487 object_apply_global_props(obj
, object_compat_props
[i
],
488 i
== 2 ? &error_fatal
: &error_abort
);
492 static void object_class_property_init_all(Object
*obj
)
494 ObjectPropertyIterator iter
;
495 ObjectProperty
*prop
;
497 object_class_property_iter_init(&iter
, object_get_class(obj
));
498 while ((prop
= object_property_iter_next(&iter
))) {
500 prop
->init(obj
, prop
);
505 static void object_initialize_with_type(Object
*obj
, size_t size
, TypeImpl
*type
)
507 type_initialize(type
);
509 g_assert(type
->instance_size
>= sizeof(Object
));
510 g_assert(type
->abstract
== false);
511 g_assert(size
>= type
->instance_size
);
513 memset(obj
, 0, type
->instance_size
);
514 obj
->class = type
->class;
516 object_class_property_init_all(obj
);
517 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
518 NULL
, object_property_free
);
519 object_init_with_type(obj
, type
);
520 object_post_init_with_type(obj
, type
);
523 void object_initialize(void *data
, size_t size
, const char *typename
)
525 TypeImpl
*type
= type_get_by_name(typename
);
527 #ifdef CONFIG_MODULES
529 module_load_qom_one(typename
);
530 type
= type_get_by_name(typename
);
534 error_report("missing object type '%s'", typename
);
538 object_initialize_with_type(data
, size
, type
);
541 bool object_initialize_child_with_props(Object
*parentobj
,
542 const char *propname
,
543 void *childobj
, size_t size
,
550 va_start(vargs
, errp
);
551 ok
= object_initialize_child_with_propsv(parentobj
, propname
,
552 childobj
, size
, type
, errp
,
558 bool object_initialize_child_with_propsv(Object
*parentobj
,
559 const char *propname
,
560 void *childobj
, size_t size
,
562 Error
**errp
, va_list vargs
)
568 object_initialize(childobj
, size
, type
);
569 obj
= OBJECT(childobj
);
571 if (!object_set_propv(obj
, errp
, vargs
)) {
575 object_property_add_child(parentobj
, propname
, obj
);
577 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
579 if (!user_creatable_complete(uc
, errp
)) {
580 object_unparent(obj
);
589 * We want @obj's reference to be 1 on success, 0 on failure.
590 * On success, it's 2: one taken by object_initialize(), and one
591 * by object_property_add_child().
592 * On failure in object_initialize() or earlier, it's 1.
593 * On failure afterwards, it's also 1: object_unparent() releases
594 * the reference taken by object_property_add_child().
600 void object_initialize_child_internal(Object
*parent
,
601 const char *propname
,
602 void *child
, size_t size
,
605 object_initialize_child_with_props(parent
, propname
, child
, size
, type
,
609 static inline bool object_property_is_child(ObjectProperty
*prop
)
611 return strstart(prop
->type
, "child<", NULL
);
614 static void object_property_del_all(Object
*obj
)
616 g_autoptr(GHashTable
) done
= g_hash_table_new(NULL
, NULL
);
617 ObjectProperty
*prop
;
618 ObjectPropertyIterator iter
;
623 object_property_iter_init(&iter
, obj
);
624 while ((prop
= object_property_iter_next(&iter
)) != NULL
) {
625 if (g_hash_table_add(done
, prop
)) {
627 prop
->release(obj
, prop
->name
, prop
->opaque
);
635 g_hash_table_unref(obj
->properties
);
638 static void object_property_del_child(Object
*obj
, Object
*child
)
640 ObjectProperty
*prop
;
644 g_hash_table_iter_init(&iter
, obj
->properties
);
645 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
647 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
649 prop
->release(obj
, prop
->name
, prop
->opaque
);
650 prop
->release
= NULL
;
655 g_hash_table_iter_init(&iter
, obj
->properties
);
656 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
658 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
659 g_hash_table_iter_remove(&iter
);
665 void object_unparent(Object
*obj
)
668 object_property_del_child(obj
->parent
, obj
);
672 static void object_deinit(Object
*obj
, TypeImpl
*type
)
674 if (type
->instance_finalize
) {
675 type
->instance_finalize(obj
);
678 if (type_has_parent(type
)) {
679 object_deinit(obj
, type_get_parent(type
));
683 static void object_finalize(void *data
)
686 TypeImpl
*ti
= obj
->class->type
;
688 object_property_del_all(obj
);
689 object_deinit(obj
, ti
);
691 g_assert(obj
->ref
== 0);
692 g_assert(obj
->parent
== NULL
);
698 /* Find the minimum alignment guaranteed by the system malloc. */
699 #if __STDC_VERSION__ >= 201112L
700 typedef max_align_t qemu_max_align_t
;
710 static Object
*object_new_with_type(Type type
)
714 void (*obj_free
)(void *);
716 g_assert(type
!= NULL
);
717 type_initialize(type
);
719 size
= type
->instance_size
;
720 align
= type
->instance_align
;
723 * Do not use qemu_memalign unless required. Depending on the
724 * implementation, extra alignment implies extra overhead.
726 if (likely(align
<= __alignof__(qemu_max_align_t
))) {
727 obj
= g_malloc(size
);
730 obj
= qemu_memalign(align
, size
);
731 obj_free
= qemu_vfree
;
734 object_initialize_with_type(obj
, size
, type
);
735 obj
->free
= obj_free
;
740 Object
*object_new_with_class(ObjectClass
*klass
)
742 return object_new_with_type(klass
->type
);
745 Object
*object_new(const char *typename
)
747 TypeImpl
*ti
= type_get_by_name(typename
);
749 return object_new_with_type(ti
);
753 Object
*object_new_with_props(const char *typename
,
762 va_start(vargs
, errp
);
763 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
770 Object
*object_new_with_propv(const char *typename
,
780 klass
= object_class_by_name(typename
);
782 error_setg(errp
, "invalid object type: %s", typename
);
786 if (object_class_is_abstract(klass
)) {
787 error_setg(errp
, "object type '%s' is abstract", typename
);
790 obj
= object_new_with_type(klass
->type
);
792 if (!object_set_propv(obj
, errp
, vargs
)) {
797 object_property_add_child(parent
, id
, obj
);
800 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
802 if (!user_creatable_complete(uc
, errp
)) {
804 object_unparent(obj
);
819 bool object_set_props(Object
*obj
,
826 va_start(vargs
, errp
);
827 ret
= object_set_propv(obj
, errp
, vargs
);
834 bool object_set_propv(Object
*obj
,
838 const char *propname
;
840 propname
= va_arg(vargs
, char *);
841 while (propname
!= NULL
) {
842 const char *value
= va_arg(vargs
, char *);
844 g_assert(value
!= NULL
);
845 if (!object_property_parse(obj
, propname
, value
, errp
)) {
848 propname
= va_arg(vargs
, char *);
855 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
857 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
864 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
865 const char *file
, int line
, const char *func
)
867 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
868 typename
, file
, line
, func
);
870 #ifdef CONFIG_QOM_CAST_DEBUG
874 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
875 if (qatomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
880 inst
= object_dynamic_cast(obj
, typename
);
883 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
884 file
, line
, func
, obj
, typename
);
890 if (obj
&& obj
== inst
) {
891 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
892 qatomic_set(&obj
->class->object_cast_cache
[i
- 1],
893 qatomic_read(&obj
->class->object_cast_cache
[i
]));
895 qatomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
903 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
904 const char *typename
)
906 ObjectClass
*ret
= NULL
;
907 TypeImpl
*target_type
;
914 /* A simple fast path that can trigger a lot for leaf classes. */
916 if (type
->name
== typename
) {
920 target_type
= type_get_by_name(typename
);
922 /* target class type unknown, so fail the cast */
926 if (type
->class->interfaces
&&
927 type_is_ancestor(target_type
, type_interface
)) {
931 for (i
= class->interfaces
; i
; i
= i
->next
) {
932 ObjectClass
*target_class
= i
->data
;
934 if (type_is_ancestor(target_class
->type
, target_type
)) {
940 /* The match was ambiguous, don't allow a cast */
944 } else if (type_is_ancestor(type
, target_type
)) {
951 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
952 const char *typename
,
953 const char *file
, int line
,
958 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
959 typename
, file
, line
, func
);
961 #ifdef CONFIG_QOM_CAST_DEBUG
964 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
965 if (qatomic_read(&class->class_cast_cache
[i
]) == typename
) {
971 if (!class || !class->interfaces
) {
976 ret
= object_class_dynamic_cast(class, typename
);
978 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
979 file
, line
, func
, class, typename
);
983 #ifdef CONFIG_QOM_CAST_DEBUG
984 if (class && ret
== class) {
985 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
986 qatomic_set(&class->class_cast_cache
[i
- 1],
987 qatomic_read(&class->class_cast_cache
[i
]));
989 qatomic_set(&class->class_cast_cache
[i
- 1], typename
);
996 const char *object_get_typename(const Object
*obj
)
998 return obj
->class->type
->name
;
1001 ObjectClass
*object_get_class(Object
*obj
)
1006 bool object_class_is_abstract(ObjectClass
*klass
)
1008 return klass
->type
->abstract
;
1011 const char *object_class_get_name(ObjectClass
*klass
)
1013 return klass
->type
->name
;
1016 ObjectClass
*object_class_by_name(const char *typename
)
1018 TypeImpl
*type
= type_get_by_name(typename
);
1024 type_initialize(type
);
1029 ObjectClass
*module_object_class_by_name(const char *typename
)
1033 oc
= object_class_by_name(typename
);
1034 #ifdef CONFIG_MODULES
1036 module_load_qom_one(typename
);
1037 oc
= object_class_by_name(typename
);
1043 ObjectClass
*object_class_get_parent(ObjectClass
*class)
1045 TypeImpl
*type
= type_get_parent(class->type
);
1051 type_initialize(type
);
1056 typedef struct OCFData
1058 void (*fn
)(ObjectClass
*klass
, void *opaque
);
1059 const char *implements_type
;
1060 bool include_abstract
;
1064 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
1067 OCFData
*data
= opaque
;
1068 TypeImpl
*type
= value
;
1071 type_initialize(type
);
1074 if (!data
->include_abstract
&& type
->abstract
) {
1078 if (data
->implements_type
&&
1079 !object_class_dynamic_cast(k
, data
->implements_type
)) {
1083 data
->fn(k
, data
->opaque
);
1086 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
1087 const char *implements_type
, bool include_abstract
,
1090 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
1092 enumerating_types
= true;
1093 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
1094 enumerating_types
= false;
1097 static int do_object_child_foreach(Object
*obj
,
1098 int (*fn
)(Object
*child
, void *opaque
),
1099 void *opaque
, bool recurse
)
1101 GHashTableIter iter
;
1102 ObjectProperty
*prop
;
1105 g_hash_table_iter_init(&iter
, obj
->properties
);
1106 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1107 if (object_property_is_child(prop
)) {
1108 Object
*child
= prop
->opaque
;
1110 ret
= fn(child
, opaque
);
1115 ret
= do_object_child_foreach(child
, fn
, opaque
, true);
1125 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
1128 return do_object_child_foreach(obj
, fn
, opaque
, false);
1131 int object_child_foreach_recursive(Object
*obj
,
1132 int (*fn
)(Object
*child
, void *opaque
),
1135 return do_object_child_foreach(obj
, fn
, opaque
, true);
1138 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
1140 GSList
**list
= opaque
;
1142 *list
= g_slist_prepend(*list
, klass
);
1145 GSList
*object_class_get_list(const char *implements_type
,
1146 bool include_abstract
)
1148 GSList
*list
= NULL
;
1150 object_class_foreach(object_class_get_list_tramp
,
1151 implements_type
, include_abstract
, &list
);
1155 static gint
object_class_cmp(gconstpointer a
, gconstpointer b
)
1157 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
1158 object_class_get_name((ObjectClass
*)b
));
1161 GSList
*object_class_get_list_sorted(const char *implements_type
,
1162 bool include_abstract
)
1164 return g_slist_sort(object_class_get_list(implements_type
, include_abstract
),
1168 Object
*object_ref(void *objptr
)
1170 Object
*obj
= OBJECT(objptr
);
1176 ref
= qatomic_fetch_inc(&obj
->ref
);
1177 /* Assert waaay before the integer overflows */
1178 g_assert(ref
< INT_MAX
);
1182 void object_unref(void *objptr
)
1184 Object
*obj
= OBJECT(objptr
);
1188 g_assert(obj
->ref
> 0);
1190 /* parent always holds a reference to its children */
1191 if (qatomic_fetch_dec(&obj
->ref
) == 1) {
1192 object_finalize(obj
);
1197 object_property_try_add(Object
*obj
, const char *name
, const char *type
,
1198 ObjectPropertyAccessor
*get
,
1199 ObjectPropertyAccessor
*set
,
1200 ObjectPropertyRelease
*release
,
1201 void *opaque
, Error
**errp
)
1203 ObjectProperty
*prop
;
1204 size_t name_len
= strlen(name
);
1206 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
1208 ObjectProperty
*ret
= NULL
;
1209 char *name_no_array
= g_strdup(name
);
1211 name_no_array
[name_len
- 3] = '\0';
1212 for (i
= 0; i
< INT16_MAX
; ++i
) {
1213 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
1215 ret
= object_property_try_add(obj
, full_name
, type
, get
, set
,
1216 release
, opaque
, NULL
);
1222 g_free(name_no_array
);
1227 if (object_property_find(obj
, name
) != NULL
) {
1228 error_setg(errp
, "attempt to add duplicate property '%s' to object (type '%s')",
1229 name
, object_get_typename(obj
));
1233 prop
= g_malloc0(sizeof(*prop
));
1235 prop
->name
= g_strdup(name
);
1236 prop
->type
= g_strdup(type
);
1240 prop
->release
= release
;
1241 prop
->opaque
= opaque
;
1243 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
1248 object_property_add(Object
*obj
, const char *name
, const char *type
,
1249 ObjectPropertyAccessor
*get
,
1250 ObjectPropertyAccessor
*set
,
1251 ObjectPropertyRelease
*release
,
1254 return object_property_try_add(obj
, name
, type
, get
, set
, release
,
1255 opaque
, &error_abort
);
1259 object_class_property_add(ObjectClass
*klass
,
1262 ObjectPropertyAccessor
*get
,
1263 ObjectPropertyAccessor
*set
,
1264 ObjectPropertyRelease
*release
,
1267 ObjectProperty
*prop
;
1269 assert(!object_class_property_find(klass
, name
));
1271 prop
= g_malloc0(sizeof(*prop
));
1273 prop
->name
= g_strdup(name
);
1274 prop
->type
= g_strdup(type
);
1278 prop
->release
= release
;
1279 prop
->opaque
= opaque
;
1281 g_hash_table_insert(klass
->properties
, prop
->name
, prop
);
1286 ObjectProperty
*object_property_find(Object
*obj
, const char *name
)
1288 ObjectProperty
*prop
;
1289 ObjectClass
*klass
= object_get_class(obj
);
1291 prop
= object_class_property_find(klass
, name
);
1296 return g_hash_table_lookup(obj
->properties
, name
);
1299 ObjectProperty
*object_property_find_err(Object
*obj
, const char *name
,
1302 ObjectProperty
*prop
= object_property_find(obj
, name
);
1304 error_setg(errp
, "Property '%s.%s' not found",
1305 object_get_typename(obj
), name
);
1310 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1313 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1314 iter
->nextclass
= object_get_class(obj
);
1317 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1320 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1321 if (!iter
->nextclass
) {
1324 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1325 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1330 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1333 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1334 iter
->nextclass
= object_class_get_parent(klass
);
1337 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
)
1339 ObjectClass
*parent_klass
;
1341 parent_klass
= object_class_get_parent(klass
);
1343 ObjectProperty
*prop
=
1344 object_class_property_find(parent_klass
, name
);
1350 return g_hash_table_lookup(klass
->properties
, name
);
1353 ObjectProperty
*object_class_property_find_err(ObjectClass
*klass
,
1357 ObjectProperty
*prop
= object_class_property_find(klass
, name
);
1359 error_setg(errp
, "Property '.%s' not found", name
);
1365 void object_property_del(Object
*obj
, const char *name
)
1367 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1369 if (prop
->release
) {
1370 prop
->release(obj
, name
, prop
->opaque
);
1372 g_hash_table_remove(obj
->properties
, name
);
1375 bool object_property_get(Object
*obj
, const char *name
, Visitor
*v
,
1379 ObjectProperty
*prop
= object_property_find_err(obj
, name
, errp
);
1386 error_setg(errp
, "Property '%s.%s' is not readable",
1387 object_get_typename(obj
), name
);
1390 prop
->get(obj
, v
, name
, prop
->opaque
, &err
);
1391 error_propagate(errp
, err
);
1395 bool object_property_set(Object
*obj
, const char *name
, Visitor
*v
,
1399 ObjectProperty
*prop
= object_property_find_err(obj
, name
, errp
);
1406 error_setg(errp
, "Property '%s.%s' is not writable",
1407 object_get_typename(obj
), name
);
1410 prop
->set(obj
, v
, name
, prop
->opaque
, errp
);
1414 bool object_property_set_str(Object
*obj
, const char *name
,
1415 const char *value
, Error
**errp
)
1417 QString
*qstr
= qstring_from_str(value
);
1418 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qstr
), errp
);
1420 qobject_unref(qstr
);
1424 char *object_property_get_str(Object
*obj
, const char *name
,
1427 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1434 qstring
= qobject_to(QString
, ret
);
1436 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1439 retval
= g_strdup(qstring_get_str(qstring
));
1446 bool object_property_set_link(Object
*obj
, const char *name
,
1447 Object
*value
, Error
**errp
)
1449 g_autofree
char *path
= NULL
;
1452 path
= object_get_canonical_path(value
);
1454 return object_property_set_str(obj
, name
, path
?: "", errp
);
1457 Object
*object_property_get_link(Object
*obj
, const char *name
,
1460 char *str
= object_property_get_str(obj
, name
, errp
);
1461 Object
*target
= NULL
;
1464 target
= object_resolve_path(str
, NULL
);
1466 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1467 "Device '%s' not found", str
);
1475 bool object_property_set_bool(Object
*obj
, const char *name
,
1476 bool value
, Error
**errp
)
1478 QBool
*qbool
= qbool_from_bool(value
);
1479 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qbool
), errp
);
1481 qobject_unref(qbool
);
1485 bool object_property_get_bool(Object
*obj
, const char *name
,
1488 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1495 qbool
= qobject_to(QBool
, ret
);
1497 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1500 retval
= qbool_get_bool(qbool
);
1507 bool object_property_set_int(Object
*obj
, const char *name
,
1508 int64_t value
, Error
**errp
)
1510 QNum
*qnum
= qnum_from_int(value
);
1511 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qnum
), errp
);
1513 qobject_unref(qnum
);
1517 int64_t object_property_get_int(Object
*obj
, const char *name
,
1520 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1528 qnum
= qobject_to(QNum
, ret
);
1529 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1530 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1538 static void object_property_init_defval(Object
*obj
, ObjectProperty
*prop
)
1540 Visitor
*v
= qobject_input_visitor_new(prop
->defval
);
1542 assert(prop
->set
!= NULL
);
1543 prop
->set(obj
, v
, prop
->name
, prop
->opaque
, &error_abort
);
1548 static void object_property_set_default(ObjectProperty
*prop
, QObject
*defval
)
1550 assert(!prop
->defval
);
1551 assert(!prop
->init
);
1553 prop
->defval
= defval
;
1554 prop
->init
= object_property_init_defval
;
1557 void object_property_set_default_bool(ObjectProperty
*prop
, bool value
)
1559 object_property_set_default(prop
, QOBJECT(qbool_from_bool(value
)));
1562 void object_property_set_default_str(ObjectProperty
*prop
, const char *value
)
1564 object_property_set_default(prop
, QOBJECT(qstring_from_str(value
)));
1567 void object_property_set_default_int(ObjectProperty
*prop
, int64_t value
)
1569 object_property_set_default(prop
, QOBJECT(qnum_from_int(value
)));
1572 void object_property_set_default_uint(ObjectProperty
*prop
, uint64_t value
)
1574 object_property_set_default(prop
, QOBJECT(qnum_from_uint(value
)));
1577 bool object_property_set_uint(Object
*obj
, const char *name
,
1578 uint64_t value
, Error
**errp
)
1580 QNum
*qnum
= qnum_from_uint(value
);
1581 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qnum
), errp
);
1583 qobject_unref(qnum
);
1587 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1590 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1597 qnum
= qobject_to(QNum
, ret
);
1598 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1599 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "uint");
1607 typedef struct EnumProperty
{
1608 const QEnumLookup
*lookup
;
1609 int (*get
)(Object
*, Error
**);
1610 void (*set
)(Object
*, int, Error
**);
1613 int object_property_get_enum(Object
*obj
, const char *name
,
1614 const char *typename
, Error
**errp
)
1618 ObjectProperty
*prop
= object_property_find_err(obj
, name
, errp
);
1619 EnumProperty
*enumprop
;
1625 if (!g_str_equal(prop
->type
, typename
)) {
1626 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1627 name
, object_class_get_name(
1628 object_get_class(obj
)), typename
);
1632 enumprop
= prop
->opaque
;
1634 str
= object_property_get_str(obj
, name
, errp
);
1639 ret
= qapi_enum_parse(enumprop
->lookup
, str
, -1, errp
);
1645 bool object_property_parse(Object
*obj
, const char *name
,
1646 const char *string
, Error
**errp
)
1648 Visitor
*v
= string_input_visitor_new(string
);
1649 bool ok
= object_property_set(obj
, name
, v
, errp
);
1655 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1659 char *string
= NULL
;
1661 v
= string_output_visitor_new(human
, &string
);
1662 if (!object_property_get(obj
, name
, v
, errp
)) {
1666 visit_complete(v
, &string
);
1673 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1675 ObjectProperty
*prop
= object_property_find_err(obj
, name
, errp
);
1683 Object
*object_get_root(void)
1685 static Object
*root
;
1688 root
= object_new("container");
1694 Object
*object_get_objects_root(void)
1696 return container_get(object_get_root(), "/objects");
1699 Object
*object_get_internal_root(void)
1701 static Object
*internal_root
;
1703 if (!internal_root
) {
1704 internal_root
= object_new("container");
1707 return internal_root
;
1710 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1711 const char *name
, void *opaque
,
1714 Object
*child
= opaque
;
1717 path
= object_get_canonical_path(child
);
1718 visit_type_str(v
, name
, &path
, errp
);
1722 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
,
1728 static void object_finalize_child_property(Object
*obj
, const char *name
,
1731 Object
*child
= opaque
;
1733 if (child
->class->unparent
) {
1734 (child
->class->unparent
)(child
);
1736 child
->parent
= NULL
;
1737 object_unref(child
);
1741 object_property_try_add_child(Object
*obj
, const char *name
,
1742 Object
*child
, Error
**errp
)
1744 g_autofree
char *type
= NULL
;
1747 assert(!child
->parent
);
1749 type
= g_strdup_printf("child<%s>", object_get_typename(child
));
1751 op
= object_property_try_add(obj
, name
, type
, object_get_child_property
,
1752 NULL
, object_finalize_child_property
,
1757 op
->resolve
= object_resolve_child_property
;
1759 child
->parent
= obj
;
1764 object_property_add_child(Object
*obj
, const char *name
,
1767 return object_property_try_add_child(obj
, name
, child
, &error_abort
);
1770 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1771 Object
*val
, Error
**errp
)
1773 /* Allow the link to be set, always */
1779 Object
*target
; /* if OBJ_PROP_LINK_DIRECT, when holding the pointer */
1780 ptrdiff_t offset
; /* if OBJ_PROP_LINK_CLASS */
1782 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1783 ObjectPropertyLinkFlags flags
;
1787 object_link_get_targetp(Object
*obj
, LinkProperty
*lprop
)
1789 if (lprop
->flags
& OBJ_PROP_LINK_DIRECT
) {
1790 return &lprop
->target
;
1791 } else if (lprop
->flags
& OBJ_PROP_LINK_CLASS
) {
1792 return (void *)obj
+ lprop
->offset
;
1794 return lprop
->targetp
;
1798 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1799 const char *name
, void *opaque
,
1802 LinkProperty
*lprop
= opaque
;
1803 Object
**targetp
= object_link_get_targetp(obj
, lprop
);
1807 path
= object_get_canonical_path(*targetp
);
1808 visit_type_str(v
, name
, &path
, errp
);
1812 visit_type_str(v
, name
, &path
, errp
);
1817 * object_resolve_link:
1819 * Lookup an object and ensure its type matches the link property type. This
1820 * is similar to object_resolve_path() except type verification against the
1821 * link property is performed.
1823 * Returns: The matched object or NULL on path lookup failures.
1825 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1826 const char *path
, Error
**errp
)
1830 bool ambiguous
= false;
1833 /* Go from link<FOO> to FOO. */
1834 type
= object_property_get_type(obj
, name
, NULL
);
1835 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1836 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1839 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1841 } else if (!target
) {
1842 target
= object_resolve_path(path
, &ambiguous
);
1843 if (target
|| ambiguous
) {
1844 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1846 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1847 "Device '%s' not found", path
);
1851 g_free(target_type
);
1856 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1857 const char *name
, void *opaque
,
1860 Error
*local_err
= NULL
;
1861 LinkProperty
*prop
= opaque
;
1862 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1863 Object
*old_target
= *targetp
;
1867 if (!visit_type_str(v
, name
, &path
, errp
)) {
1872 new_target
= object_resolve_link(obj
, name
, path
, errp
);
1883 prop
->check(obj
, name
, new_target
, &local_err
);
1885 error_propagate(errp
, local_err
);
1889 *targetp
= new_target
;
1890 if (prop
->flags
& OBJ_PROP_LINK_STRONG
) {
1891 object_ref(new_target
);
1892 object_unref(old_target
);
1896 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
,
1899 LinkProperty
*lprop
= opaque
;
1901 return *object_link_get_targetp(parent
, lprop
);
1904 static void object_release_link_property(Object
*obj
, const char *name
,
1907 LinkProperty
*prop
= opaque
;
1908 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1910 if ((prop
->flags
& OBJ_PROP_LINK_STRONG
) && *targetp
) {
1911 object_unref(*targetp
);
1913 if (!(prop
->flags
& OBJ_PROP_LINK_CLASS
)) {
1918 static ObjectProperty
*
1919 object_add_link_prop(Object
*obj
, const char *name
,
1920 const char *type
, void *ptr
,
1921 void (*check
)(const Object
*, const char *,
1922 Object
*, Error
**),
1923 ObjectPropertyLinkFlags flags
)
1925 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1926 g_autofree
char *full_type
= NULL
;
1929 if (flags
& OBJ_PROP_LINK_DIRECT
) {
1932 prop
->targetp
= ptr
;
1934 prop
->check
= check
;
1935 prop
->flags
= flags
;
1937 full_type
= g_strdup_printf("link<%s>", type
);
1939 op
= object_property_add(obj
, name
, full_type
,
1940 object_get_link_property
,
1941 check
? object_set_link_property
: NULL
,
1942 object_release_link_property
,
1944 op
->resolve
= object_resolve_link_property
;
1949 object_property_add_link(Object
*obj
, const char *name
,
1950 const char *type
, Object
**targetp
,
1951 void (*check
)(const Object
*, const char *,
1952 Object
*, Error
**),
1953 ObjectPropertyLinkFlags flags
)
1955 return object_add_link_prop(obj
, name
, type
, targetp
, check
, flags
);
1959 object_class_property_add_link(ObjectClass
*oc
,
1961 const char *type
, ptrdiff_t offset
,
1962 void (*check
)(const Object
*obj
, const char *name
,
1963 Object
*val
, Error
**errp
),
1964 ObjectPropertyLinkFlags flags
)
1966 LinkProperty
*prop
= g_new0(LinkProperty
, 1);
1970 prop
->offset
= offset
;
1971 prop
->check
= check
;
1972 prop
->flags
= flags
| OBJ_PROP_LINK_CLASS
;
1974 full_type
= g_strdup_printf("link<%s>", type
);
1976 op
= object_class_property_add(oc
, name
, full_type
,
1977 object_get_link_property
,
1978 check
? object_set_link_property
: NULL
,
1979 object_release_link_property
,
1982 op
->resolve
= object_resolve_link_property
;
1989 object_property_add_const_link(Object
*obj
, const char *name
,
1992 return object_add_link_prop(obj
, name
,
1993 object_get_typename(target
), target
,
1994 NULL
, OBJ_PROP_LINK_DIRECT
);
1997 const char *object_get_canonical_path_component(const Object
*obj
)
1999 ObjectProperty
*prop
= NULL
;
2000 GHashTableIter iter
;
2002 if (obj
->parent
== NULL
) {
2006 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
2007 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
2008 if (!object_property_is_child(prop
)) {
2012 if (prop
->opaque
== obj
) {
2017 /* obj had a parent but was not a child, should never happen */
2018 g_assert_not_reached();
2022 char *object_get_canonical_path(const Object
*obj
)
2024 Object
*root
= object_get_root();
2025 char *newpath
, *path
= NULL
;
2028 return g_strdup("/");
2032 const char *component
= object_get_canonical_path_component(obj
);
2035 /* A canonical path must be complete, so discard what was
2042 newpath
= g_strdup_printf("/%s%s", component
, path
? path
: "");
2046 } while (obj
!= root
);
2051 Object
*object_resolve_path_component(Object
*parent
, const char *part
)
2053 ObjectProperty
*prop
= object_property_find(parent
, part
);
2058 if (prop
->resolve
) {
2059 return prop
->resolve(parent
, prop
->opaque
, part
);
2065 static Object
*object_resolve_abs_path(Object
*parent
,
2067 const char *typename
)
2071 if (*parts
== NULL
) {
2072 return object_dynamic_cast(parent
, typename
);
2075 if (strcmp(*parts
, "") == 0) {
2076 return object_resolve_abs_path(parent
, parts
+ 1, typename
);
2079 child
= object_resolve_path_component(parent
, *parts
);
2084 return object_resolve_abs_path(child
, parts
+ 1, typename
);
2087 static Object
*object_resolve_partial_path(Object
*parent
,
2089 const char *typename
,
2093 GHashTableIter iter
;
2094 ObjectProperty
*prop
;
2096 obj
= object_resolve_abs_path(parent
, parts
, typename
);
2098 g_hash_table_iter_init(&iter
, parent
->properties
);
2099 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
2102 if (!object_property_is_child(prop
)) {
2106 found
= object_resolve_partial_path(prop
->opaque
, parts
,
2107 typename
, ambiguous
);
2124 Object
*object_resolve_path_type(const char *path
, const char *typename
,
2130 parts
= g_strsplit(path
, "/", 0);
2133 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
2134 bool ambiguous
= false;
2135 obj
= object_resolve_partial_path(object_get_root(), parts
,
2136 typename
, &ambiguous
);
2138 *ambiguousp
= ambiguous
;
2141 obj
= object_resolve_abs_path(object_get_root(), parts
+ 1, typename
);
2149 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
2151 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
2154 Object
*object_resolve_path_at(Object
*parent
, const char *path
)
2156 g_auto(GStrv
) parts
= g_strsplit(path
, "/", 0);
2159 return object_resolve_abs_path(object_get_root(), parts
+ 1,
2162 return object_resolve_abs_path(parent
, parts
, TYPE_OBJECT
);
2165 typedef struct StringProperty
2167 char *(*get
)(Object
*, Error
**);
2168 void (*set
)(Object
*, const char *, Error
**);
2171 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
2172 void *opaque
, Error
**errp
)
2174 StringProperty
*prop
= opaque
;
2178 value
= prop
->get(obj
, &err
);
2180 error_propagate(errp
, err
);
2184 visit_type_str(v
, name
, &value
, errp
);
2188 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
2189 void *opaque
, Error
**errp
)
2191 StringProperty
*prop
= opaque
;
2194 if (!visit_type_str(v
, name
, &value
, errp
)) {
2198 prop
->set(obj
, value
, errp
);
2202 static void property_release_data(Object
*obj
, const char *name
,
2209 object_property_add_str(Object
*obj
, const char *name
,
2210 char *(*get
)(Object
*, Error
**),
2211 void (*set
)(Object
*, const char *, Error
**))
2213 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2218 return object_property_add(obj
, name
, "string",
2219 get
? property_get_str
: NULL
,
2220 set
? property_set_str
: NULL
,
2221 property_release_data
,
2226 object_class_property_add_str(ObjectClass
*klass
, const char *name
,
2227 char *(*get
)(Object
*, Error
**),
2228 void (*set
)(Object
*, const char *,
2231 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2236 return object_class_property_add(klass
, name
, "string",
2237 get
? property_get_str
: NULL
,
2238 set
? property_set_str
: NULL
,
2243 typedef struct BoolProperty
2245 bool (*get
)(Object
*, Error
**);
2246 void (*set
)(Object
*, bool, Error
**);
2249 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
2250 void *opaque
, Error
**errp
)
2252 BoolProperty
*prop
= opaque
;
2256 value
= prop
->get(obj
, &err
);
2258 error_propagate(errp
, err
);
2262 visit_type_bool(v
, name
, &value
, errp
);
2265 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
2266 void *opaque
, Error
**errp
)
2268 BoolProperty
*prop
= opaque
;
2271 if (!visit_type_bool(v
, name
, &value
, errp
)) {
2275 prop
->set(obj
, value
, errp
);
2279 object_property_add_bool(Object
*obj
, const char *name
,
2280 bool (*get
)(Object
*, Error
**),
2281 void (*set
)(Object
*, bool, Error
**))
2283 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2288 return object_property_add(obj
, name
, "bool",
2289 get
? property_get_bool
: NULL
,
2290 set
? property_set_bool
: NULL
,
2291 property_release_data
,
2296 object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
2297 bool (*get
)(Object
*, Error
**),
2298 void (*set
)(Object
*, bool, Error
**))
2300 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2305 return object_class_property_add(klass
, name
, "bool",
2306 get
? property_get_bool
: NULL
,
2307 set
? property_set_bool
: NULL
,
2312 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
2313 void *opaque
, Error
**errp
)
2315 EnumProperty
*prop
= opaque
;
2319 value
= prop
->get(obj
, &err
);
2321 error_propagate(errp
, err
);
2325 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
2328 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
2329 void *opaque
, Error
**errp
)
2331 EnumProperty
*prop
= opaque
;
2334 if (!visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
)) {
2337 prop
->set(obj
, value
, errp
);
2341 object_property_add_enum(Object
*obj
, const char *name
,
2342 const char *typename
,
2343 const QEnumLookup
*lookup
,
2344 int (*get
)(Object
*, Error
**),
2345 void (*set
)(Object
*, int, Error
**))
2347 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2349 prop
->lookup
= lookup
;
2353 return object_property_add(obj
, name
, typename
,
2354 get
? property_get_enum
: NULL
,
2355 set
? property_set_enum
: NULL
,
2356 property_release_data
,
2361 object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2362 const char *typename
,
2363 const QEnumLookup
*lookup
,
2364 int (*get
)(Object
*, Error
**),
2365 void (*set
)(Object
*, int, Error
**))
2367 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2369 prop
->lookup
= lookup
;
2373 return object_class_property_add(klass
, name
, typename
,
2374 get
? property_get_enum
: NULL
,
2375 set
? property_set_enum
: NULL
,
2380 typedef struct TMProperty
{
2381 void (*get
)(Object
*, struct tm
*, Error
**);
2384 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2385 void *opaque
, Error
**errp
)
2387 TMProperty
*prop
= opaque
;
2391 prop
->get(obj
, &value
, &err
);
2393 error_propagate(errp
, err
);
2397 if (!visit_start_struct(v
, name
, NULL
, 0, errp
)) {
2400 if (!visit_type_int32(v
, "tm_year", &value
.tm_year
, errp
)) {
2403 if (!visit_type_int32(v
, "tm_mon", &value
.tm_mon
, errp
)) {
2406 if (!visit_type_int32(v
, "tm_mday", &value
.tm_mday
, errp
)) {
2409 if (!visit_type_int32(v
, "tm_hour", &value
.tm_hour
, errp
)) {
2412 if (!visit_type_int32(v
, "tm_min", &value
.tm_min
, errp
)) {
2415 if (!visit_type_int32(v
, "tm_sec", &value
.tm_sec
, errp
)) {
2418 visit_check_struct(v
, errp
);
2420 visit_end_struct(v
, NULL
);
2424 object_property_add_tm(Object
*obj
, const char *name
,
2425 void (*get
)(Object
*, struct tm
*, Error
**))
2427 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2431 return object_property_add(obj
, name
, "struct tm",
2432 get
? property_get_tm
: NULL
, NULL
,
2433 property_release_data
,
2438 object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2439 void (*get
)(Object
*, struct tm
*, Error
**))
2441 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2445 return object_class_property_add(klass
, name
, "struct tm",
2446 get
? property_get_tm
: NULL
,
2450 static char *object_get_type(Object
*obj
, Error
**errp
)
2452 return g_strdup(object_get_typename(obj
));
2455 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2456 void *opaque
, Error
**errp
)
2458 uint8_t value
= *(uint8_t *)opaque
;
2459 visit_type_uint8(v
, name
, &value
, errp
);
2462 static void property_set_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2463 void *opaque
, Error
**errp
)
2465 uint8_t *field
= opaque
;
2468 if (!visit_type_uint8(v
, name
, &value
, errp
)) {
2475 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2476 void *opaque
, Error
**errp
)
2478 uint16_t value
= *(uint16_t *)opaque
;
2479 visit_type_uint16(v
, name
, &value
, errp
);
2482 static void property_set_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2483 void *opaque
, Error
**errp
)
2485 uint16_t *field
= opaque
;
2488 if (!visit_type_uint16(v
, name
, &value
, errp
)) {
2495 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2496 void *opaque
, Error
**errp
)
2498 uint32_t value
= *(uint32_t *)opaque
;
2499 visit_type_uint32(v
, name
, &value
, errp
);
2502 static void property_set_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2503 void *opaque
, Error
**errp
)
2505 uint32_t *field
= opaque
;
2508 if (!visit_type_uint32(v
, name
, &value
, errp
)) {
2515 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2516 void *opaque
, Error
**errp
)
2518 uint64_t value
= *(uint64_t *)opaque
;
2519 visit_type_uint64(v
, name
, &value
, errp
);
2522 static void property_set_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2523 void *opaque
, Error
**errp
)
2525 uint64_t *field
= opaque
;
2528 if (!visit_type_uint64(v
, name
, &value
, errp
)) {
2536 object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2538 ObjectPropertyFlags flags
)
2540 ObjectPropertyAccessor
*getter
= NULL
;
2541 ObjectPropertyAccessor
*setter
= NULL
;
2543 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2544 getter
= property_get_uint8_ptr
;
2547 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2548 setter
= property_set_uint8_ptr
;
2551 return object_property_add(obj
, name
, "uint8",
2552 getter
, setter
, NULL
, (void *)v
);
2556 object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2558 ObjectPropertyFlags flags
)
2560 ObjectPropertyAccessor
*getter
= NULL
;
2561 ObjectPropertyAccessor
*setter
= NULL
;
2563 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2564 getter
= property_get_uint8_ptr
;
2567 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2568 setter
= property_set_uint8_ptr
;
2571 return object_class_property_add(klass
, name
, "uint8",
2572 getter
, setter
, NULL
, (void *)v
);
2576 object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2578 ObjectPropertyFlags flags
)
2580 ObjectPropertyAccessor
*getter
= NULL
;
2581 ObjectPropertyAccessor
*setter
= NULL
;
2583 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2584 getter
= property_get_uint16_ptr
;
2587 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2588 setter
= property_set_uint16_ptr
;
2591 return object_property_add(obj
, name
, "uint16",
2592 getter
, setter
, NULL
, (void *)v
);
2596 object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2598 ObjectPropertyFlags flags
)
2600 ObjectPropertyAccessor
*getter
= NULL
;
2601 ObjectPropertyAccessor
*setter
= NULL
;
2603 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2604 getter
= property_get_uint16_ptr
;
2607 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2608 setter
= property_set_uint16_ptr
;
2611 return object_class_property_add(klass
, name
, "uint16",
2612 getter
, setter
, NULL
, (void *)v
);
2616 object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2618 ObjectPropertyFlags flags
)
2620 ObjectPropertyAccessor
*getter
= NULL
;
2621 ObjectPropertyAccessor
*setter
= NULL
;
2623 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2624 getter
= property_get_uint32_ptr
;
2627 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2628 setter
= property_set_uint32_ptr
;
2631 return object_property_add(obj
, name
, "uint32",
2632 getter
, setter
, NULL
, (void *)v
);
2636 object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2638 ObjectPropertyFlags flags
)
2640 ObjectPropertyAccessor
*getter
= NULL
;
2641 ObjectPropertyAccessor
*setter
= NULL
;
2643 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2644 getter
= property_get_uint32_ptr
;
2647 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2648 setter
= property_set_uint32_ptr
;
2651 return object_class_property_add(klass
, name
, "uint32",
2652 getter
, setter
, NULL
, (void *)v
);
2656 object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2658 ObjectPropertyFlags flags
)
2660 ObjectPropertyAccessor
*getter
= NULL
;
2661 ObjectPropertyAccessor
*setter
= NULL
;
2663 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2664 getter
= property_get_uint64_ptr
;
2667 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2668 setter
= property_set_uint64_ptr
;
2671 return object_property_add(obj
, name
, "uint64",
2672 getter
, setter
, NULL
, (void *)v
);
2676 object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2678 ObjectPropertyFlags flags
)
2680 ObjectPropertyAccessor
*getter
= NULL
;
2681 ObjectPropertyAccessor
*setter
= NULL
;
2683 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2684 getter
= property_get_uint64_ptr
;
2687 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2688 setter
= property_set_uint64_ptr
;
2691 return object_class_property_add(klass
, name
, "uint64",
2692 getter
, setter
, NULL
, (void *)v
);
2700 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2701 void *opaque
, Error
**errp
)
2703 AliasProperty
*prop
= opaque
;
2704 Visitor
*alias_v
= visitor_forward_field(v
, prop
->target_name
, name
);
2706 object_property_get(prop
->target_obj
, prop
->target_name
, alias_v
, errp
);
2707 visit_free(alias_v
);
2710 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2711 void *opaque
, Error
**errp
)
2713 AliasProperty
*prop
= opaque
;
2714 Visitor
*alias_v
= visitor_forward_field(v
, prop
->target_name
, name
);
2716 object_property_set(prop
->target_obj
, prop
->target_name
, alias_v
, errp
);
2717 visit_free(alias_v
);
2720 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2723 AliasProperty
*prop
= opaque
;
2725 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2728 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2730 AliasProperty
*prop
= opaque
;
2732 g_free(prop
->target_name
);
2737 object_property_add_alias(Object
*obj
, const char *name
,
2738 Object
*target_obj
, const char *target_name
)
2740 AliasProperty
*prop
;
2742 ObjectProperty
*target_prop
;
2743 g_autofree
char *prop_type
= NULL
;
2745 target_prop
= object_property_find_err(target_obj
, target_name
,
2748 if (object_property_is_child(target_prop
)) {
2749 prop_type
= g_strdup_printf("link%s",
2750 target_prop
->type
+ strlen("child"));
2752 prop_type
= g_strdup(target_prop
->type
);
2755 prop
= g_malloc(sizeof(*prop
));
2756 prop
->target_obj
= target_obj
;
2757 prop
->target_name
= g_strdup(target_name
);
2759 op
= object_property_add(obj
, name
, prop_type
,
2762 property_release_alias
,
2764 op
->resolve
= property_resolve_alias
;
2765 if (target_prop
->defval
) {
2766 op
->defval
= qobject_ref(target_prop
->defval
);
2769 object_property_set_description(obj
, op
->name
,
2770 target_prop
->description
);
2774 void object_property_set_description(Object
*obj
, const char *name
,
2775 const char *description
)
2779 op
= object_property_find_err(obj
, name
, &error_abort
);
2780 g_free(op
->description
);
2781 op
->description
= g_strdup(description
);
2784 void object_class_property_set_description(ObjectClass
*klass
,
2786 const char *description
)
2790 op
= g_hash_table_lookup(klass
->properties
, name
);
2791 g_free(op
->description
);
2792 op
->description
= g_strdup(description
);
2795 static void object_class_init(ObjectClass
*klass
, void *data
)
2797 object_class_property_add_str(klass
, "type", object_get_type
,
2801 static void register_types(void)
2803 static const TypeInfo interface_info
= {
2804 .name
= TYPE_INTERFACE
,
2805 .class_size
= sizeof(InterfaceClass
),
2809 static const TypeInfo object_info
= {
2810 .name
= TYPE_OBJECT
,
2811 .instance_size
= sizeof(Object
),
2812 .class_init
= object_class_init
,
2816 type_interface
= type_register_internal(&interface_info
);
2817 type_register_internal(&object_info
);
2820 type_init(register_types
)