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/qlist.h"
35 #include "qapi/qmp/qnum.h"
36 #include "qapi/qmp/qstring.h"
37 #include "qemu/error-report.h"
39 #define MAX_INTERFACES 32
41 typedef struct InterfaceImpl InterfaceImpl
;
42 typedef struct TypeImpl TypeImpl
;
56 size_t instance_align
;
58 void (*class_init
)(ObjectClass
*klass
, void *data
);
59 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
63 void (*instance_init
)(Object
*obj
);
64 void (*instance_post_init
)(Object
*obj
);
65 void (*instance_finalize
)(Object
*obj
);
70 TypeImpl
*parent_type
;
75 InterfaceImpl interfaces
[MAX_INTERFACES
];
78 static Type type_interface
;
80 static GHashTable
*type_table_get(void)
82 static GHashTable
*type_table
;
84 if (type_table
== NULL
) {
85 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
91 static bool enumerating_types
;
93 static void type_table_add(TypeImpl
*ti
)
95 assert(!enumerating_types
);
96 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
99 static TypeImpl
*type_table_lookup(const char *name
)
101 return g_hash_table_lookup(type_table_get(), name
);
104 static TypeImpl
*type_new(const TypeInfo
*info
)
106 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
109 g_assert(info
->name
!= NULL
);
111 if (type_table_lookup(info
->name
) != NULL
) {
112 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
116 ti
->name
= g_strdup(info
->name
);
117 ti
->parent
= g_strdup(info
->parent
);
119 ti
->class_size
= info
->class_size
;
120 ti
->instance_size
= info
->instance_size
;
121 ti
->instance_align
= info
->instance_align
;
123 ti
->class_init
= info
->class_init
;
124 ti
->class_base_init
= info
->class_base_init
;
125 ti
->class_data
= info
->class_data
;
127 ti
->instance_init
= info
->instance_init
;
128 ti
->instance_post_init
= info
->instance_post_init
;
129 ti
->instance_finalize
= info
->instance_finalize
;
131 ti
->abstract
= info
->abstract
;
133 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
134 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
136 ti
->num_interfaces
= i
;
141 static bool type_name_is_valid(const char *name
)
143 const int slen
= strlen(name
);
149 * Ideally, the name should start with a letter - however, we've got
150 * too many names starting with a digit already, so allow digits here,
151 * too (except '0' which is not used yet)
153 if (!g_ascii_isalnum(name
[0]) || name
[0] == '0') {
157 plen
= strspn(name
, "abcdefghijklmnopqrstuvwxyz"
158 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
161 /* Allow some legacy names with '+' in it for compatibility reasons */
162 if (name
[plen
] == '+') {
163 if (plen
>= 17 && g_str_has_prefix(name
, "Sun-UltraSparc-I")) {
164 /* Allow "Sun-UltraSparc-IV+" and "Sun-UltraSparc-IIIi+" */
172 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
176 if (!type_name_is_valid(info
->name
)) {
177 fprintf(stderr
, "Registering '%s' with illegal type name\n", info
->name
);
187 TypeImpl
*type_register(const TypeInfo
*info
)
189 assert(info
->parent
);
190 return type_register_internal(info
);
193 TypeImpl
*type_register_static(const TypeInfo
*info
)
195 return type_register(info
);
198 void type_register_static_array(const TypeInfo
*infos
, int nr_infos
)
202 for (i
= 0; i
< nr_infos
; i
++) {
203 type_register_static(&infos
[i
]);
207 static TypeImpl
*type_get_by_name(const char *name
)
213 return type_table_lookup(name
);
216 static TypeImpl
*type_get_parent(TypeImpl
*type
)
218 if (!type
->parent_type
&& type
->parent
) {
219 type
->parent_type
= type_get_by_name(type
->parent
);
220 if (!type
->parent_type
) {
221 fprintf(stderr
, "Type '%s' is missing its parent '%s'\n",
222 type
->name
, type
->parent
);
227 return type
->parent_type
;
230 static bool type_has_parent(TypeImpl
*type
)
232 return (type
->parent
!= NULL
);
235 static size_t type_class_get_size(TypeImpl
*ti
)
237 if (ti
->class_size
) {
238 return ti
->class_size
;
241 if (type_has_parent(ti
)) {
242 return type_class_get_size(type_get_parent(ti
));
245 return sizeof(ObjectClass
);
248 static size_t type_object_get_size(TypeImpl
*ti
)
250 if (ti
->instance_size
) {
251 return ti
->instance_size
;
254 if (type_has_parent(ti
)) {
255 return type_object_get_size(type_get_parent(ti
));
261 static size_t type_object_get_align(TypeImpl
*ti
)
263 if (ti
->instance_align
) {
264 return ti
->instance_align
;
267 if (type_has_parent(ti
)) {
268 return type_object_get_align(type_get_parent(ti
));
274 size_t object_type_get_instance_size(const char *typename
)
276 TypeImpl
*type
= type_get_by_name(typename
);
278 g_assert(type
!= NULL
);
279 return type_object_get_size(type
);
282 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
286 /* Check if target_type is a direct ancestor of type */
288 if (type
== target_type
) {
292 type
= type_get_parent(type
);
298 static void type_initialize(TypeImpl
*ti
);
300 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
301 TypeImpl
*parent_type
)
303 InterfaceClass
*new_iface
;
305 TypeImpl
*iface_impl
;
307 info
.parent
= parent_type
->name
;
308 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
309 info
.abstract
= true;
311 iface_impl
= type_new(&info
);
312 iface_impl
->parent_type
= parent_type
;
313 type_initialize(iface_impl
);
314 g_free((char *)info
.name
);
316 new_iface
= (InterfaceClass
*)iface_impl
->class;
317 new_iface
->concrete_class
= ti
->class;
318 new_iface
->interface_type
= interface_type
;
320 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
, new_iface
);
323 static void object_property_free(gpointer data
)
325 ObjectProperty
*prop
= data
;
328 qobject_unref(prop
->defval
);
333 g_free(prop
->description
);
337 static void type_initialize(TypeImpl
*ti
)
345 ti
->class_size
= type_class_get_size(ti
);
346 ti
->instance_size
= type_object_get_size(ti
);
347 ti
->instance_align
= type_object_get_align(ti
);
348 /* Any type with zero instance_size is implicitly abstract.
349 * This means interface types are all abstract.
351 if (ti
->instance_size
== 0) {
354 if (type_is_ancestor(ti
, type_interface
)) {
355 assert(ti
->instance_size
== 0);
356 assert(ti
->abstract
);
357 assert(!ti
->instance_init
);
358 assert(!ti
->instance_post_init
);
359 assert(!ti
->instance_finalize
);
360 assert(!ti
->num_interfaces
);
362 ti
->class = g_malloc0(ti
->class_size
);
364 parent
= type_get_parent(ti
);
366 type_initialize(parent
);
370 g_assert(parent
->class_size
<= ti
->class_size
);
371 g_assert(parent
->instance_size
<= ti
->instance_size
);
372 memcpy(ti
->class, parent
->class, parent
->class_size
);
373 ti
->class->interfaces
= NULL
;
375 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
376 InterfaceClass
*iface
= e
->data
;
377 ObjectClass
*klass
= OBJECT_CLASS(iface
);
379 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
382 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
383 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
385 error_report("missing interface '%s' for object '%s'",
386 ti
->interfaces
[i
].typename
, parent
->name
);
389 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
390 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
392 if (type_is_ancestor(target_type
, t
)) {
401 type_initialize_interface(ti
, t
, t
);
405 ti
->class->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
, NULL
,
406 object_property_free
);
408 ti
->class->type
= ti
;
411 if (parent
->class_base_init
) {
412 parent
->class_base_init(ti
->class, ti
->class_data
);
414 parent
= type_get_parent(parent
);
417 if (ti
->class_init
) {
418 ti
->class_init(ti
->class, ti
->class_data
);
422 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
424 if (type_has_parent(ti
)) {
425 object_init_with_type(obj
, type_get_parent(ti
));
428 if (ti
->instance_init
) {
429 ti
->instance_init(obj
);
433 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
435 if (ti
->instance_post_init
) {
436 ti
->instance_post_init(obj
);
439 if (type_has_parent(ti
)) {
440 object_post_init_with_type(obj
, type_get_parent(ti
));
444 bool object_apply_global_props(Object
*obj
, const GPtrArray
*props
,
453 for (i
= 0; i
< props
->len
; i
++) {
454 GlobalProperty
*p
= g_ptr_array_index(props
, i
);
457 if (object_dynamic_cast(obj
, p
->driver
) == NULL
) {
460 if (p
->optional
&& !object_property_find(obj
, p
->property
)) {
464 if (!object_property_parse(obj
, p
->property
, p
->value
, &err
)) {
465 error_prepend(&err
, "can't apply global %s.%s=%s: ",
466 p
->driver
, p
->property
, p
->value
);
468 * If errp != NULL, propagate error and return.
469 * If errp == NULL, report a warning, but keep going
470 * with the remaining globals.
473 error_propagate(errp
, err
);
476 warn_report_err(err
);
485 * Global property defaults
486 * Slot 0: accelerator's global property defaults
487 * Slot 1: machine's global property defaults
488 * Slot 2: global properties from legacy command line option
489 * Each is a GPtrArray of of GlobalProperty.
490 * Applied in order, later entries override earlier ones.
492 static GPtrArray
*object_compat_props
[3];
495 * Retrieve @GPtrArray for global property defined with options
496 * other than "-global". These are generally used for syntactic
497 * sugar and legacy command line options.
499 void object_register_sugar_prop(const char *driver
, const char *prop
,
500 const char *value
, bool optional
)
503 if (!object_compat_props
[2]) {
504 object_compat_props
[2] = g_ptr_array_new();
506 g
= g_new0(GlobalProperty
, 1);
507 g
->driver
= g_strdup(driver
);
508 g
->property
= g_strdup(prop
);
509 g
->value
= g_strdup(value
);
510 g
->optional
= optional
;
511 g_ptr_array_add(object_compat_props
[2], g
);
515 * Set machine's global property defaults to @compat_props.
516 * May be called at most once.
518 void object_set_machine_compat_props(GPtrArray
*compat_props
)
520 assert(!object_compat_props
[1]);
521 object_compat_props
[1] = compat_props
;
525 * Set accelerator's global property defaults to @compat_props.
526 * May be called at most once.
528 void object_set_accelerator_compat_props(GPtrArray
*compat_props
)
530 assert(!object_compat_props
[0]);
531 object_compat_props
[0] = compat_props
;
534 void object_apply_compat_props(Object
*obj
)
538 for (i
= 0; i
< ARRAY_SIZE(object_compat_props
); i
++) {
539 object_apply_global_props(obj
, object_compat_props
[i
],
540 i
== 2 ? &error_fatal
: &error_abort
);
544 static void object_class_property_init_all(Object
*obj
)
546 ObjectPropertyIterator iter
;
547 ObjectProperty
*prop
;
549 object_class_property_iter_init(&iter
, object_get_class(obj
));
550 while ((prop
= object_property_iter_next(&iter
))) {
552 prop
->init(obj
, prop
);
557 static void object_initialize_with_type(Object
*obj
, size_t size
, TypeImpl
*type
)
559 type_initialize(type
);
561 g_assert(type
->instance_size
>= sizeof(Object
));
562 g_assert(type
->abstract
== false);
563 g_assert(size
>= type
->instance_size
);
565 memset(obj
, 0, type
->instance_size
);
566 obj
->class = type
->class;
568 object_class_property_init_all(obj
);
569 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
570 NULL
, object_property_free
);
571 object_init_with_type(obj
, type
);
572 object_post_init_with_type(obj
, type
);
575 void object_initialize(void *data
, size_t size
, const char *typename
)
577 TypeImpl
*type
= type_get_by_name(typename
);
579 #ifdef CONFIG_MODULES
581 int rv
= module_load_qom(typename
, &error_fatal
);
583 type
= type_get_by_name(typename
);
585 error_report("missing object type '%s'", typename
);
591 error_report("missing object type '%s'", typename
);
595 object_initialize_with_type(data
, size
, type
);
598 bool object_initialize_child_with_props(Object
*parentobj
,
599 const char *propname
,
600 void *childobj
, size_t size
,
607 va_start(vargs
, errp
);
608 ok
= object_initialize_child_with_propsv(parentobj
, propname
,
609 childobj
, size
, type
, errp
,
615 bool object_initialize_child_with_propsv(Object
*parentobj
,
616 const char *propname
,
617 void *childobj
, size_t size
,
619 Error
**errp
, va_list vargs
)
625 object_initialize(childobj
, size
, type
);
626 obj
= OBJECT(childobj
);
628 if (!object_set_propv(obj
, errp
, vargs
)) {
632 object_property_add_child(parentobj
, propname
, obj
);
634 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
636 if (!user_creatable_complete(uc
, errp
)) {
637 object_unparent(obj
);
646 * We want @obj's reference to be 1 on success, 0 on failure.
647 * On success, it's 2: one taken by object_initialize(), and one
648 * by object_property_add_child().
649 * On failure in object_initialize() or earlier, it's 1.
650 * On failure afterwards, it's also 1: object_unparent() releases
651 * the reference taken by object_property_add_child().
657 void object_initialize_child_internal(Object
*parent
,
658 const char *propname
,
659 void *child
, size_t size
,
662 object_initialize_child_with_props(parent
, propname
, child
, size
, type
,
666 static inline bool object_property_is_child(ObjectProperty
*prop
)
668 return strstart(prop
->type
, "child<", NULL
);
671 static void object_property_del_all(Object
*obj
)
673 g_autoptr(GHashTable
) done
= g_hash_table_new(NULL
, NULL
);
674 ObjectProperty
*prop
;
675 ObjectPropertyIterator iter
;
680 object_property_iter_init(&iter
, obj
);
681 while ((prop
= object_property_iter_next(&iter
)) != NULL
) {
682 if (g_hash_table_add(done
, prop
)) {
684 prop
->release(obj
, prop
->name
, prop
->opaque
);
692 g_hash_table_unref(obj
->properties
);
695 static void object_property_del_child(Object
*obj
, Object
*child
)
697 ObjectProperty
*prop
;
701 g_hash_table_iter_init(&iter
, obj
->properties
);
702 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
704 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
706 prop
->release(obj
, prop
->name
, prop
->opaque
);
707 prop
->release
= NULL
;
712 g_hash_table_iter_init(&iter
, obj
->properties
);
713 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
715 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
716 g_hash_table_iter_remove(&iter
);
722 void object_unparent(Object
*obj
)
725 object_property_del_child(obj
->parent
, obj
);
729 static void object_deinit(Object
*obj
, TypeImpl
*type
)
731 if (type
->instance_finalize
) {
732 type
->instance_finalize(obj
);
735 if (type_has_parent(type
)) {
736 object_deinit(obj
, type_get_parent(type
));
740 static void object_finalize(void *data
)
743 TypeImpl
*ti
= obj
->class->type
;
745 object_property_del_all(obj
);
746 object_deinit(obj
, ti
);
748 g_assert(obj
->ref
== 0);
749 g_assert(obj
->parent
== NULL
);
755 /* Find the minimum alignment guaranteed by the system malloc. */
756 #if __STDC_VERSION__ >= 201112L
757 typedef max_align_t qemu_max_align_t
;
767 static Object
*object_new_with_type(Type type
)
771 void (*obj_free
)(void *);
773 g_assert(type
!= NULL
);
774 type_initialize(type
);
776 size
= type
->instance_size
;
777 align
= type
->instance_align
;
780 * Do not use qemu_memalign unless required. Depending on the
781 * implementation, extra alignment implies extra overhead.
783 if (likely(align
<= __alignof__(qemu_max_align_t
))) {
784 obj
= g_malloc(size
);
787 obj
= qemu_memalign(align
, size
);
788 obj_free
= qemu_vfree
;
791 object_initialize_with_type(obj
, size
, type
);
792 obj
->free
= obj_free
;
797 Object
*object_new_with_class(ObjectClass
*klass
)
799 return object_new_with_type(klass
->type
);
802 Object
*object_new(const char *typename
)
804 TypeImpl
*ti
= type_get_by_name(typename
);
806 return object_new_with_type(ti
);
810 Object
*object_new_with_props(const char *typename
,
819 va_start(vargs
, errp
);
820 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
827 Object
*object_new_with_propv(const char *typename
,
837 klass
= object_class_by_name(typename
);
839 error_setg(errp
, "invalid object type: %s", typename
);
843 if (object_class_is_abstract(klass
)) {
844 error_setg(errp
, "object type '%s' is abstract", typename
);
847 obj
= object_new_with_type(klass
->type
);
849 if (!object_set_propv(obj
, errp
, vargs
)) {
854 object_property_add_child(parent
, id
, obj
);
857 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
859 if (!user_creatable_complete(uc
, errp
)) {
861 object_unparent(obj
);
876 bool object_set_props(Object
*obj
,
883 va_start(vargs
, errp
);
884 ret
= object_set_propv(obj
, errp
, vargs
);
891 bool object_set_propv(Object
*obj
,
895 const char *propname
;
897 propname
= va_arg(vargs
, char *);
898 while (propname
!= NULL
) {
899 const char *value
= va_arg(vargs
, char *);
901 g_assert(value
!= NULL
);
902 if (!object_property_parse(obj
, propname
, value
, errp
)) {
905 propname
= va_arg(vargs
, char *);
912 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
914 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
921 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
922 const char *file
, int line
, const char *func
)
924 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
925 typename
, file
, line
, func
);
927 #ifdef CONFIG_QOM_CAST_DEBUG
931 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
932 if (qatomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
937 inst
= object_dynamic_cast(obj
, typename
);
940 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
941 file
, line
, func
, obj
, typename
);
947 if (obj
&& obj
== inst
) {
948 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
949 qatomic_set(&obj
->class->object_cast_cache
[i
- 1],
950 qatomic_read(&obj
->class->object_cast_cache
[i
]));
952 qatomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
960 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
961 const char *typename
)
963 ObjectClass
*ret
= NULL
;
964 TypeImpl
*target_type
;
971 /* A simple fast path that can trigger a lot for leaf classes. */
973 if (type
->name
== typename
) {
977 target_type
= type_get_by_name(typename
);
979 /* target class type unknown, so fail the cast */
983 if (type
->class->interfaces
&&
984 type_is_ancestor(target_type
, type_interface
)) {
988 for (i
= class->interfaces
; i
; i
= i
->next
) {
989 ObjectClass
*target_class
= i
->data
;
991 if (type_is_ancestor(target_class
->type
, target_type
)) {
997 /* The match was ambiguous, don't allow a cast */
1001 } else if (type_is_ancestor(type
, target_type
)) {
1008 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
1009 const char *typename
,
1010 const char *file
, int line
,
1015 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
1016 typename
, file
, line
, func
);
1018 #ifdef CONFIG_QOM_CAST_DEBUG
1021 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
1022 if (qatomic_read(&class->class_cast_cache
[i
]) == typename
) {
1028 if (!class || !class->interfaces
) {
1033 ret
= object_class_dynamic_cast(class, typename
);
1034 if (!ret
&& class) {
1035 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
1036 file
, line
, func
, class, typename
);
1040 #ifdef CONFIG_QOM_CAST_DEBUG
1041 if (class && ret
== class) {
1042 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
1043 qatomic_set(&class->class_cast_cache
[i
- 1],
1044 qatomic_read(&class->class_cast_cache
[i
]));
1046 qatomic_set(&class->class_cast_cache
[i
- 1], typename
);
1053 const char *object_get_typename(const Object
*obj
)
1055 return obj
->class->type
->name
;
1058 ObjectClass
*object_get_class(Object
*obj
)
1063 bool object_class_is_abstract(ObjectClass
*klass
)
1065 return klass
->type
->abstract
;
1068 const char *object_class_get_name(ObjectClass
*klass
)
1070 return klass
->type
->name
;
1073 ObjectClass
*object_class_by_name(const char *typename
)
1075 TypeImpl
*type
= type_get_by_name(typename
);
1081 type_initialize(type
);
1086 ObjectClass
*module_object_class_by_name(const char *typename
)
1090 oc
= object_class_by_name(typename
);
1091 #ifdef CONFIG_MODULES
1093 Error
*local_err
= NULL
;
1094 int rv
= module_load_qom(typename
, &local_err
);
1096 oc
= object_class_by_name(typename
);
1097 } else if (rv
< 0) {
1098 error_report_err(local_err
);
1105 ObjectClass
*object_class_get_parent(ObjectClass
*class)
1107 TypeImpl
*type
= type_get_parent(class->type
);
1113 type_initialize(type
);
1118 typedef struct OCFData
1120 void (*fn
)(ObjectClass
*klass
, void *opaque
);
1121 const char *implements_type
;
1122 bool include_abstract
;
1126 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
1129 OCFData
*data
= opaque
;
1130 TypeImpl
*type
= value
;
1133 type_initialize(type
);
1136 if (!data
->include_abstract
&& type
->abstract
) {
1140 if (data
->implements_type
&&
1141 !object_class_dynamic_cast(k
, data
->implements_type
)) {
1145 data
->fn(k
, data
->opaque
);
1148 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
1149 const char *implements_type
, bool include_abstract
,
1152 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
1154 enumerating_types
= true;
1155 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
1156 enumerating_types
= false;
1159 static int do_object_child_foreach(Object
*obj
,
1160 int (*fn
)(Object
*child
, void *opaque
),
1161 void *opaque
, bool recurse
)
1163 GHashTableIter iter
;
1164 ObjectProperty
*prop
;
1167 g_hash_table_iter_init(&iter
, obj
->properties
);
1168 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1169 if (object_property_is_child(prop
)) {
1170 Object
*child
= prop
->opaque
;
1172 ret
= fn(child
, opaque
);
1177 ret
= do_object_child_foreach(child
, fn
, opaque
, true);
1187 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
1190 return do_object_child_foreach(obj
, fn
, opaque
, false);
1193 int object_child_foreach_recursive(Object
*obj
,
1194 int (*fn
)(Object
*child
, void *opaque
),
1197 return do_object_child_foreach(obj
, fn
, opaque
, true);
1200 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
1202 GSList
**list
= opaque
;
1204 *list
= g_slist_prepend(*list
, klass
);
1207 GSList
*object_class_get_list(const char *implements_type
,
1208 bool include_abstract
)
1210 GSList
*list
= NULL
;
1212 object_class_foreach(object_class_get_list_tramp
,
1213 implements_type
, include_abstract
, &list
);
1217 static gint
object_class_cmp(gconstpointer a
, gconstpointer b
)
1219 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
1220 object_class_get_name((ObjectClass
*)b
));
1223 GSList
*object_class_get_list_sorted(const char *implements_type
,
1224 bool include_abstract
)
1226 return g_slist_sort(object_class_get_list(implements_type
, include_abstract
),
1230 Object
*object_ref(void *objptr
)
1232 Object
*obj
= OBJECT(objptr
);
1238 ref
= qatomic_fetch_inc(&obj
->ref
);
1239 /* Assert waaay before the integer overflows */
1240 g_assert(ref
< INT_MAX
);
1244 void object_unref(void *objptr
)
1246 Object
*obj
= OBJECT(objptr
);
1250 g_assert(obj
->ref
> 0);
1252 /* parent always holds a reference to its children */
1253 if (qatomic_fetch_dec(&obj
->ref
) == 1) {
1254 object_finalize(obj
);
1259 object_property_try_add(Object
*obj
, const char *name
, const char *type
,
1260 ObjectPropertyAccessor
*get
,
1261 ObjectPropertyAccessor
*set
,
1262 ObjectPropertyRelease
*release
,
1263 void *opaque
, Error
**errp
)
1265 ObjectProperty
*prop
;
1266 size_t name_len
= strlen(name
);
1268 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
1270 ObjectProperty
*ret
= NULL
;
1271 char *name_no_array
= g_strdup(name
);
1273 name_no_array
[name_len
- 3] = '\0';
1274 for (i
= 0; i
< INT16_MAX
; ++i
) {
1275 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
1277 ret
= object_property_try_add(obj
, full_name
, type
, get
, set
,
1278 release
, opaque
, NULL
);
1284 g_free(name_no_array
);
1289 if (object_property_find(obj
, name
) != NULL
) {
1290 error_setg(errp
, "attempt to add duplicate property '%s' to object (type '%s')",
1291 name
, object_get_typename(obj
));
1295 prop
= g_malloc0(sizeof(*prop
));
1297 prop
->name
= g_strdup(name
);
1298 prop
->type
= g_strdup(type
);
1302 prop
->release
= release
;
1303 prop
->opaque
= opaque
;
1305 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
1310 object_property_add(Object
*obj
, const char *name
, const char *type
,
1311 ObjectPropertyAccessor
*get
,
1312 ObjectPropertyAccessor
*set
,
1313 ObjectPropertyRelease
*release
,
1316 return object_property_try_add(obj
, name
, type
, get
, set
, release
,
1317 opaque
, &error_abort
);
1321 object_class_property_add(ObjectClass
*klass
,
1324 ObjectPropertyAccessor
*get
,
1325 ObjectPropertyAccessor
*set
,
1326 ObjectPropertyRelease
*release
,
1329 ObjectProperty
*prop
;
1331 assert(!object_class_property_find(klass
, name
));
1333 prop
= g_malloc0(sizeof(*prop
));
1335 prop
->name
= g_strdup(name
);
1336 prop
->type
= g_strdup(type
);
1340 prop
->release
= release
;
1341 prop
->opaque
= opaque
;
1343 g_hash_table_insert(klass
->properties
, prop
->name
, prop
);
1348 ObjectProperty
*object_property_find(Object
*obj
, const char *name
)
1350 ObjectProperty
*prop
;
1351 ObjectClass
*klass
= object_get_class(obj
);
1353 prop
= object_class_property_find(klass
, name
);
1358 return g_hash_table_lookup(obj
->properties
, name
);
1361 ObjectProperty
*object_property_find_err(Object
*obj
, const char *name
,
1364 ObjectProperty
*prop
= object_property_find(obj
, name
);
1366 error_setg(errp
, "Property '%s.%s' not found",
1367 object_get_typename(obj
), name
);
1372 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1375 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1376 iter
->nextclass
= object_get_class(obj
);
1379 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1382 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1383 if (!iter
->nextclass
) {
1386 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1387 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1392 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1395 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1396 iter
->nextclass
= object_class_get_parent(klass
);
1399 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
)
1401 ObjectClass
*parent_klass
;
1403 parent_klass
= object_class_get_parent(klass
);
1405 ObjectProperty
*prop
=
1406 object_class_property_find(parent_klass
, name
);
1412 return g_hash_table_lookup(klass
->properties
, name
);
1415 ObjectProperty
*object_class_property_find_err(ObjectClass
*klass
,
1419 ObjectProperty
*prop
= object_class_property_find(klass
, name
);
1421 error_setg(errp
, "Property '.%s' not found", name
);
1427 void object_property_del(Object
*obj
, const char *name
)
1429 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1431 if (prop
->release
) {
1432 prop
->release(obj
, name
, prop
->opaque
);
1434 g_hash_table_remove(obj
->properties
, name
);
1437 bool object_property_get(Object
*obj
, const char *name
, Visitor
*v
,
1441 ObjectProperty
*prop
= object_property_find_err(obj
, name
, errp
);
1448 error_setg(errp
, "Property '%s.%s' is not readable",
1449 object_get_typename(obj
), name
);
1452 prop
->get(obj
, v
, name
, prop
->opaque
, &err
);
1453 error_propagate(errp
, err
);
1457 bool object_property_set(Object
*obj
, const char *name
, Visitor
*v
,
1461 ObjectProperty
*prop
= object_property_find_err(obj
, name
, errp
);
1468 error_setg(errp
, "Property '%s.%s' is not writable",
1469 object_get_typename(obj
), name
);
1472 prop
->set(obj
, v
, name
, prop
->opaque
, errp
);
1476 bool object_property_set_str(Object
*obj
, const char *name
,
1477 const char *value
, Error
**errp
)
1479 QString
*qstr
= qstring_from_str(value
);
1480 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qstr
), errp
);
1482 qobject_unref(qstr
);
1486 char *object_property_get_str(Object
*obj
, const char *name
,
1489 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1496 qstring
= qobject_to(QString
, ret
);
1498 error_setg(errp
, "Invalid parameter type for '%s', expected: string",
1502 retval
= g_strdup(qstring_get_str(qstring
));
1509 bool object_property_set_link(Object
*obj
, const char *name
,
1510 Object
*value
, Error
**errp
)
1512 g_autofree
char *path
= NULL
;
1515 path
= object_get_canonical_path(value
);
1517 return object_property_set_str(obj
, name
, path
?: "", errp
);
1520 Object
*object_property_get_link(Object
*obj
, const char *name
,
1523 char *str
= object_property_get_str(obj
, name
, errp
);
1524 Object
*target
= NULL
;
1527 target
= object_resolve_path(str
, NULL
);
1529 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1530 "Device '%s' not found", str
);
1538 bool object_property_set_bool(Object
*obj
, const char *name
,
1539 bool value
, Error
**errp
)
1541 QBool
*qbool
= qbool_from_bool(value
);
1542 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qbool
), errp
);
1544 qobject_unref(qbool
);
1548 bool object_property_get_bool(Object
*obj
, const char *name
,
1551 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1558 qbool
= qobject_to(QBool
, ret
);
1560 error_setg(errp
, "Invalid parameter type for '%s', expected: boolean",
1564 retval
= qbool_get_bool(qbool
);
1571 bool object_property_set_int(Object
*obj
, const char *name
,
1572 int64_t value
, Error
**errp
)
1574 QNum
*qnum
= qnum_from_int(value
);
1575 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qnum
), errp
);
1577 qobject_unref(qnum
);
1581 int64_t object_property_get_int(Object
*obj
, const char *name
,
1584 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1592 qnum
= qobject_to(QNum
, ret
);
1593 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1594 error_setg(errp
, "Invalid parameter type for '%s', expected: int",
1603 static void object_property_init_defval(Object
*obj
, ObjectProperty
*prop
)
1605 Visitor
*v
= qobject_input_visitor_new(prop
->defval
);
1607 assert(prop
->set
!= NULL
);
1608 prop
->set(obj
, v
, prop
->name
, prop
->opaque
, &error_abort
);
1613 static void object_property_set_default(ObjectProperty
*prop
, QObject
*defval
)
1615 assert(!prop
->defval
);
1616 assert(!prop
->init
);
1618 prop
->defval
= defval
;
1619 prop
->init
= object_property_init_defval
;
1622 void object_property_set_default_bool(ObjectProperty
*prop
, bool value
)
1624 object_property_set_default(prop
, QOBJECT(qbool_from_bool(value
)));
1627 void object_property_set_default_str(ObjectProperty
*prop
, const char *value
)
1629 object_property_set_default(prop
, QOBJECT(qstring_from_str(value
)));
1632 void object_property_set_default_list(ObjectProperty
*prop
)
1634 object_property_set_default(prop
, QOBJECT(qlist_new()));
1637 void object_property_set_default_int(ObjectProperty
*prop
, int64_t value
)
1639 object_property_set_default(prop
, QOBJECT(qnum_from_int(value
)));
1642 void object_property_set_default_uint(ObjectProperty
*prop
, uint64_t value
)
1644 object_property_set_default(prop
, QOBJECT(qnum_from_uint(value
)));
1647 bool object_property_set_uint(Object
*obj
, const char *name
,
1648 uint64_t value
, Error
**errp
)
1650 QNum
*qnum
= qnum_from_uint(value
);
1651 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qnum
), errp
);
1653 qobject_unref(qnum
);
1657 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1660 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1667 qnum
= qobject_to(QNum
, ret
);
1668 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1669 error_setg(errp
, "Invalid parameter type for '%s', expected: uint",
1678 typedef struct EnumProperty
{
1679 const QEnumLookup
*lookup
;
1680 int (*get
)(Object
*, Error
**);
1681 void (*set
)(Object
*, int, Error
**);
1684 int object_property_get_enum(Object
*obj
, const char *name
,
1685 const char *typename
, Error
**errp
)
1689 ObjectProperty
*prop
= object_property_find_err(obj
, name
, errp
);
1690 EnumProperty
*enumprop
;
1696 if (!g_str_equal(prop
->type
, typename
)) {
1697 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1698 name
, object_class_get_name(
1699 object_get_class(obj
)), typename
);
1703 enumprop
= prop
->opaque
;
1705 str
= object_property_get_str(obj
, name
, errp
);
1710 ret
= qapi_enum_parse(enumprop
->lookup
, str
, -1, errp
);
1716 bool object_property_parse(Object
*obj
, const char *name
,
1717 const char *string
, Error
**errp
)
1719 Visitor
*v
= string_input_visitor_new(string
);
1720 bool ok
= object_property_set(obj
, name
, v
, errp
);
1726 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1730 char *string
= NULL
;
1732 v
= string_output_visitor_new(human
, &string
);
1733 if (!object_property_get(obj
, name
, v
, errp
)) {
1737 visit_complete(v
, &string
);
1744 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1746 ObjectProperty
*prop
= object_property_find_err(obj
, name
, errp
);
1754 Object
*object_get_root(void)
1756 static Object
*root
;
1759 root
= object_new("container");
1765 Object
*object_get_objects_root(void)
1767 return container_get(object_get_root(), "/objects");
1770 Object
*object_get_internal_root(void)
1772 static Object
*internal_root
;
1774 if (!internal_root
) {
1775 internal_root
= object_new("container");
1778 return internal_root
;
1781 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1782 const char *name
, void *opaque
,
1785 Object
*child
= opaque
;
1788 path
= object_get_canonical_path(child
);
1789 visit_type_str(v
, name
, &path
, errp
);
1793 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
,
1799 static void object_finalize_child_property(Object
*obj
, const char *name
,
1802 Object
*child
= opaque
;
1804 if (child
->class->unparent
) {
1805 (child
->class->unparent
)(child
);
1807 child
->parent
= NULL
;
1808 object_unref(child
);
1812 object_property_try_add_child(Object
*obj
, const char *name
,
1813 Object
*child
, Error
**errp
)
1815 g_autofree
char *type
= NULL
;
1818 assert(!child
->parent
);
1820 type
= g_strdup_printf("child<%s>", object_get_typename(child
));
1822 op
= object_property_try_add(obj
, name
, type
, object_get_child_property
,
1823 NULL
, object_finalize_child_property
,
1828 op
->resolve
= object_resolve_child_property
;
1830 child
->parent
= obj
;
1835 object_property_add_child(Object
*obj
, const char *name
,
1838 return object_property_try_add_child(obj
, name
, child
, &error_abort
);
1841 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1842 Object
*val
, Error
**errp
)
1844 /* Allow the link to be set, always */
1850 Object
*target
; /* if OBJ_PROP_LINK_DIRECT, when holding the pointer */
1851 ptrdiff_t offset
; /* if OBJ_PROP_LINK_CLASS */
1853 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1854 ObjectPropertyLinkFlags flags
;
1858 object_link_get_targetp(Object
*obj
, LinkProperty
*lprop
)
1860 if (lprop
->flags
& OBJ_PROP_LINK_DIRECT
) {
1861 return &lprop
->target
;
1862 } else if (lprop
->flags
& OBJ_PROP_LINK_CLASS
) {
1863 return (void *)obj
+ lprop
->offset
;
1865 return lprop
->targetp
;
1869 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1870 const char *name
, void *opaque
,
1873 LinkProperty
*lprop
= opaque
;
1874 Object
**targetp
= object_link_get_targetp(obj
, lprop
);
1878 path
= object_get_canonical_path(*targetp
);
1879 visit_type_str(v
, name
, &path
, errp
);
1883 visit_type_str(v
, name
, &path
, errp
);
1888 * object_resolve_link:
1890 * Lookup an object and ensure its type matches the link property type. This
1891 * is similar to object_resolve_path() except type verification against the
1892 * link property is performed.
1894 * Returns: The matched object or NULL on path lookup failures.
1896 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1897 const char *path
, Error
**errp
)
1901 bool ambiguous
= false;
1904 /* Go from link<FOO> to FOO. */
1905 type
= object_property_get_type(obj
, name
, NULL
);
1906 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1907 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1910 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1912 } else if (!target
) {
1913 target
= object_resolve_path(path
, &ambiguous
);
1914 if (target
|| ambiguous
) {
1915 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1917 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1918 "Device '%s' not found", path
);
1922 g_free(target_type
);
1927 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1928 const char *name
, void *opaque
,
1931 Error
*local_err
= NULL
;
1932 LinkProperty
*prop
= opaque
;
1933 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1934 Object
*old_target
= *targetp
;
1938 if (!visit_type_str(v
, name
, &path
, errp
)) {
1943 new_target
= object_resolve_link(obj
, name
, path
, errp
);
1954 prop
->check(obj
, name
, new_target
, &local_err
);
1956 error_propagate(errp
, local_err
);
1960 *targetp
= new_target
;
1961 if (prop
->flags
& OBJ_PROP_LINK_STRONG
) {
1962 object_ref(new_target
);
1963 object_unref(old_target
);
1967 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
,
1970 LinkProperty
*lprop
= opaque
;
1972 return *object_link_get_targetp(parent
, lprop
);
1975 static void object_release_link_property(Object
*obj
, const char *name
,
1978 LinkProperty
*prop
= opaque
;
1979 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1981 if ((prop
->flags
& OBJ_PROP_LINK_STRONG
) && *targetp
) {
1982 object_unref(*targetp
);
1984 if (!(prop
->flags
& OBJ_PROP_LINK_CLASS
)) {
1989 static ObjectProperty
*
1990 object_add_link_prop(Object
*obj
, const char *name
,
1991 const char *type
, void *ptr
,
1992 void (*check
)(const Object
*, const char *,
1993 Object
*, Error
**),
1994 ObjectPropertyLinkFlags flags
)
1996 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1997 g_autofree
char *full_type
= NULL
;
2000 if (flags
& OBJ_PROP_LINK_DIRECT
) {
2003 prop
->targetp
= ptr
;
2005 prop
->check
= check
;
2006 prop
->flags
= flags
;
2008 full_type
= g_strdup_printf("link<%s>", type
);
2010 op
= object_property_add(obj
, name
, full_type
,
2011 object_get_link_property
,
2012 check
? object_set_link_property
: NULL
,
2013 object_release_link_property
,
2015 op
->resolve
= object_resolve_link_property
;
2020 object_property_add_link(Object
*obj
, const char *name
,
2021 const char *type
, Object
**targetp
,
2022 void (*check
)(const Object
*, const char *,
2023 Object
*, Error
**),
2024 ObjectPropertyLinkFlags flags
)
2026 return object_add_link_prop(obj
, name
, type
, targetp
, check
, flags
);
2030 object_class_property_add_link(ObjectClass
*oc
,
2032 const char *type
, ptrdiff_t offset
,
2033 void (*check
)(const Object
*obj
, const char *name
,
2034 Object
*val
, Error
**errp
),
2035 ObjectPropertyLinkFlags flags
)
2037 LinkProperty
*prop
= g_new0(LinkProperty
, 1);
2041 prop
->offset
= offset
;
2042 prop
->check
= check
;
2043 prop
->flags
= flags
| OBJ_PROP_LINK_CLASS
;
2045 full_type
= g_strdup_printf("link<%s>", type
);
2047 op
= object_class_property_add(oc
, name
, full_type
,
2048 object_get_link_property
,
2049 check
? object_set_link_property
: NULL
,
2050 object_release_link_property
,
2053 op
->resolve
= object_resolve_link_property
;
2060 object_property_add_const_link(Object
*obj
, const char *name
,
2063 return object_add_link_prop(obj
, name
,
2064 object_get_typename(target
), target
,
2065 NULL
, OBJ_PROP_LINK_DIRECT
);
2068 const char *object_get_canonical_path_component(const Object
*obj
)
2070 ObjectProperty
*prop
= NULL
;
2071 GHashTableIter iter
;
2073 if (obj
->parent
== NULL
) {
2077 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
2078 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
2079 if (!object_property_is_child(prop
)) {
2083 if (prop
->opaque
== obj
) {
2088 /* obj had a parent but was not a child, should never happen */
2089 g_assert_not_reached();
2093 char *object_get_canonical_path(const Object
*obj
)
2095 Object
*root
= object_get_root();
2096 char *newpath
, *path
= NULL
;
2099 return g_strdup("/");
2103 const char *component
= object_get_canonical_path_component(obj
);
2106 /* A canonical path must be complete, so discard what was
2113 newpath
= g_strdup_printf("/%s%s", component
, path
? path
: "");
2117 } while (obj
!= root
);
2122 Object
*object_resolve_path_component(Object
*parent
, const char *part
)
2124 ObjectProperty
*prop
= object_property_find(parent
, part
);
2129 if (prop
->resolve
) {
2130 return prop
->resolve(parent
, prop
->opaque
, part
);
2136 static Object
*object_resolve_abs_path(Object
*parent
,
2138 const char *typename
)
2142 if (*parts
== NULL
) {
2143 return object_dynamic_cast(parent
, typename
);
2146 if (strcmp(*parts
, "") == 0) {
2147 return object_resolve_abs_path(parent
, parts
+ 1, typename
);
2150 child
= object_resolve_path_component(parent
, *parts
);
2155 return object_resolve_abs_path(child
, parts
+ 1, typename
);
2158 static Object
*object_resolve_partial_path(Object
*parent
,
2160 const char *typename
,
2164 GHashTableIter iter
;
2165 ObjectProperty
*prop
;
2167 obj
= object_resolve_abs_path(parent
, parts
, typename
);
2169 g_hash_table_iter_init(&iter
, parent
->properties
);
2170 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
2173 if (!object_property_is_child(prop
)) {
2177 found
= object_resolve_partial_path(prop
->opaque
, parts
,
2178 typename
, ambiguous
);
2195 Object
*object_resolve_path_type(const char *path
, const char *typename
,
2201 parts
= g_strsplit(path
, "/", 0);
2204 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
2205 bool ambiguous
= false;
2206 obj
= object_resolve_partial_path(object_get_root(), parts
,
2207 typename
, &ambiguous
);
2209 *ambiguousp
= ambiguous
;
2212 obj
= object_resolve_abs_path(object_get_root(), parts
+ 1, typename
);
2220 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
2222 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
2225 Object
*object_resolve_path_at(Object
*parent
, const char *path
)
2227 g_auto(GStrv
) parts
= g_strsplit(path
, "/", 0);
2230 return object_resolve_abs_path(object_get_root(), parts
+ 1,
2233 return object_resolve_abs_path(parent
, parts
, TYPE_OBJECT
);
2236 Object
*object_resolve_type_unambiguous(const char *typename
, Error
**errp
)
2239 Object
*o
= object_resolve_path_type("", typename
, &ambig
);
2242 error_setg(errp
, "More than one object of type %s", typename
);
2246 error_setg(errp
, "No object found of type %s", typename
);
2252 typedef struct StringProperty
2254 char *(*get
)(Object
*, Error
**);
2255 void (*set
)(Object
*, const char *, Error
**);
2258 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
2259 void *opaque
, Error
**errp
)
2261 StringProperty
*prop
= opaque
;
2265 value
= prop
->get(obj
, &err
);
2267 error_propagate(errp
, err
);
2271 visit_type_str(v
, name
, &value
, errp
);
2275 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
2276 void *opaque
, Error
**errp
)
2278 StringProperty
*prop
= opaque
;
2281 if (!visit_type_str(v
, name
, &value
, errp
)) {
2285 prop
->set(obj
, value
, errp
);
2289 static void property_release_data(Object
*obj
, const char *name
,
2296 object_property_add_str(Object
*obj
, const char *name
,
2297 char *(*get
)(Object
*, Error
**),
2298 void (*set
)(Object
*, const char *, Error
**))
2300 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2305 return object_property_add(obj
, name
, "string",
2306 get
? property_get_str
: NULL
,
2307 set
? property_set_str
: NULL
,
2308 property_release_data
,
2313 object_class_property_add_str(ObjectClass
*klass
, const char *name
,
2314 char *(*get
)(Object
*, Error
**),
2315 void (*set
)(Object
*, const char *,
2318 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2323 return object_class_property_add(klass
, name
, "string",
2324 get
? property_get_str
: NULL
,
2325 set
? property_set_str
: NULL
,
2330 typedef struct BoolProperty
2332 bool (*get
)(Object
*, Error
**);
2333 void (*set
)(Object
*, bool, Error
**);
2336 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
2337 void *opaque
, Error
**errp
)
2339 BoolProperty
*prop
= opaque
;
2343 value
= prop
->get(obj
, &err
);
2345 error_propagate(errp
, err
);
2349 visit_type_bool(v
, name
, &value
, errp
);
2352 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
2353 void *opaque
, Error
**errp
)
2355 BoolProperty
*prop
= opaque
;
2358 if (!visit_type_bool(v
, name
, &value
, errp
)) {
2362 prop
->set(obj
, value
, errp
);
2366 object_property_add_bool(Object
*obj
, const char *name
,
2367 bool (*get
)(Object
*, Error
**),
2368 void (*set
)(Object
*, bool, Error
**))
2370 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2375 return object_property_add(obj
, name
, "bool",
2376 get
? property_get_bool
: NULL
,
2377 set
? property_set_bool
: NULL
,
2378 property_release_data
,
2383 object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
2384 bool (*get
)(Object
*, Error
**),
2385 void (*set
)(Object
*, bool, Error
**))
2387 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2392 return object_class_property_add(klass
, name
, "bool",
2393 get
? property_get_bool
: NULL
,
2394 set
? property_set_bool
: NULL
,
2399 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
2400 void *opaque
, Error
**errp
)
2402 EnumProperty
*prop
= opaque
;
2406 value
= prop
->get(obj
, &err
);
2408 error_propagate(errp
, err
);
2412 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
2415 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
2416 void *opaque
, Error
**errp
)
2418 EnumProperty
*prop
= opaque
;
2421 if (!visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
)) {
2424 prop
->set(obj
, value
, errp
);
2428 object_property_add_enum(Object
*obj
, const char *name
,
2429 const char *typename
,
2430 const QEnumLookup
*lookup
,
2431 int (*get
)(Object
*, Error
**),
2432 void (*set
)(Object
*, int, Error
**))
2434 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2436 prop
->lookup
= lookup
;
2440 return object_property_add(obj
, name
, typename
,
2441 get
? property_get_enum
: NULL
,
2442 set
? property_set_enum
: NULL
,
2443 property_release_data
,
2448 object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2449 const char *typename
,
2450 const QEnumLookup
*lookup
,
2451 int (*get
)(Object
*, Error
**),
2452 void (*set
)(Object
*, int, Error
**))
2454 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2456 prop
->lookup
= lookup
;
2460 return object_class_property_add(klass
, name
, typename
,
2461 get
? property_get_enum
: NULL
,
2462 set
? property_set_enum
: NULL
,
2467 typedef struct TMProperty
{
2468 void (*get
)(Object
*, struct tm
*, Error
**);
2471 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2472 void *opaque
, Error
**errp
)
2474 TMProperty
*prop
= opaque
;
2478 prop
->get(obj
, &value
, &err
);
2480 error_propagate(errp
, err
);
2484 if (!visit_start_struct(v
, name
, NULL
, 0, errp
)) {
2487 if (!visit_type_int32(v
, "tm_year", &value
.tm_year
, errp
)) {
2490 if (!visit_type_int32(v
, "tm_mon", &value
.tm_mon
, errp
)) {
2493 if (!visit_type_int32(v
, "tm_mday", &value
.tm_mday
, errp
)) {
2496 if (!visit_type_int32(v
, "tm_hour", &value
.tm_hour
, errp
)) {
2499 if (!visit_type_int32(v
, "tm_min", &value
.tm_min
, errp
)) {
2502 if (!visit_type_int32(v
, "tm_sec", &value
.tm_sec
, errp
)) {
2505 visit_check_struct(v
, errp
);
2507 visit_end_struct(v
, NULL
);
2511 object_property_add_tm(Object
*obj
, const char *name
,
2512 void (*get
)(Object
*, struct tm
*, Error
**))
2514 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2518 return object_property_add(obj
, name
, "struct tm",
2519 get
? property_get_tm
: NULL
, NULL
,
2520 property_release_data
,
2525 object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2526 void (*get
)(Object
*, struct tm
*, Error
**))
2528 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2532 return object_class_property_add(klass
, name
, "struct tm",
2533 get
? property_get_tm
: NULL
,
2537 static char *object_get_type(Object
*obj
, Error
**errp
)
2539 return g_strdup(object_get_typename(obj
));
2542 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2543 void *opaque
, Error
**errp
)
2545 uint8_t value
= *(uint8_t *)opaque
;
2546 visit_type_uint8(v
, name
, &value
, errp
);
2549 static void property_set_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2550 void *opaque
, Error
**errp
)
2552 uint8_t *field
= opaque
;
2555 if (!visit_type_uint8(v
, name
, &value
, errp
)) {
2562 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2563 void *opaque
, Error
**errp
)
2565 uint16_t value
= *(uint16_t *)opaque
;
2566 visit_type_uint16(v
, name
, &value
, errp
);
2569 static void property_set_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2570 void *opaque
, Error
**errp
)
2572 uint16_t *field
= opaque
;
2575 if (!visit_type_uint16(v
, name
, &value
, errp
)) {
2582 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2583 void *opaque
, Error
**errp
)
2585 uint32_t value
= *(uint32_t *)opaque
;
2586 visit_type_uint32(v
, name
, &value
, errp
);
2589 static void property_set_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2590 void *opaque
, Error
**errp
)
2592 uint32_t *field
= opaque
;
2595 if (!visit_type_uint32(v
, name
, &value
, errp
)) {
2602 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2603 void *opaque
, Error
**errp
)
2605 uint64_t value
= *(uint64_t *)opaque
;
2606 visit_type_uint64(v
, name
, &value
, errp
);
2609 static void property_set_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2610 void *opaque
, Error
**errp
)
2612 uint64_t *field
= opaque
;
2615 if (!visit_type_uint64(v
, name
, &value
, errp
)) {
2623 object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2625 ObjectPropertyFlags flags
)
2627 ObjectPropertyAccessor
*getter
= NULL
;
2628 ObjectPropertyAccessor
*setter
= NULL
;
2630 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2631 getter
= property_get_uint8_ptr
;
2634 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2635 setter
= property_set_uint8_ptr
;
2638 return object_property_add(obj
, name
, "uint8",
2639 getter
, setter
, NULL
, (void *)v
);
2643 object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2645 ObjectPropertyFlags flags
)
2647 ObjectPropertyAccessor
*getter
= NULL
;
2648 ObjectPropertyAccessor
*setter
= NULL
;
2650 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2651 getter
= property_get_uint8_ptr
;
2654 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2655 setter
= property_set_uint8_ptr
;
2658 return object_class_property_add(klass
, name
, "uint8",
2659 getter
, setter
, NULL
, (void *)v
);
2663 object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2665 ObjectPropertyFlags flags
)
2667 ObjectPropertyAccessor
*getter
= NULL
;
2668 ObjectPropertyAccessor
*setter
= NULL
;
2670 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2671 getter
= property_get_uint16_ptr
;
2674 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2675 setter
= property_set_uint16_ptr
;
2678 return object_property_add(obj
, name
, "uint16",
2679 getter
, setter
, NULL
, (void *)v
);
2683 object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2685 ObjectPropertyFlags flags
)
2687 ObjectPropertyAccessor
*getter
= NULL
;
2688 ObjectPropertyAccessor
*setter
= NULL
;
2690 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2691 getter
= property_get_uint16_ptr
;
2694 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2695 setter
= property_set_uint16_ptr
;
2698 return object_class_property_add(klass
, name
, "uint16",
2699 getter
, setter
, NULL
, (void *)v
);
2703 object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2705 ObjectPropertyFlags flags
)
2707 ObjectPropertyAccessor
*getter
= NULL
;
2708 ObjectPropertyAccessor
*setter
= NULL
;
2710 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2711 getter
= property_get_uint32_ptr
;
2714 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2715 setter
= property_set_uint32_ptr
;
2718 return object_property_add(obj
, name
, "uint32",
2719 getter
, setter
, NULL
, (void *)v
);
2723 object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2725 ObjectPropertyFlags flags
)
2727 ObjectPropertyAccessor
*getter
= NULL
;
2728 ObjectPropertyAccessor
*setter
= NULL
;
2730 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2731 getter
= property_get_uint32_ptr
;
2734 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2735 setter
= property_set_uint32_ptr
;
2738 return object_class_property_add(klass
, name
, "uint32",
2739 getter
, setter
, NULL
, (void *)v
);
2743 object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2745 ObjectPropertyFlags flags
)
2747 ObjectPropertyAccessor
*getter
= NULL
;
2748 ObjectPropertyAccessor
*setter
= NULL
;
2750 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2751 getter
= property_get_uint64_ptr
;
2754 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2755 setter
= property_set_uint64_ptr
;
2758 return object_property_add(obj
, name
, "uint64",
2759 getter
, setter
, NULL
, (void *)v
);
2763 object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2765 ObjectPropertyFlags flags
)
2767 ObjectPropertyAccessor
*getter
= NULL
;
2768 ObjectPropertyAccessor
*setter
= NULL
;
2770 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2771 getter
= property_get_uint64_ptr
;
2774 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2775 setter
= property_set_uint64_ptr
;
2778 return object_class_property_add(klass
, name
, "uint64",
2779 getter
, setter
, NULL
, (void *)v
);
2787 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2788 void *opaque
, Error
**errp
)
2790 AliasProperty
*prop
= opaque
;
2791 Visitor
*alias_v
= visitor_forward_field(v
, prop
->target_name
, name
);
2793 object_property_get(prop
->target_obj
, prop
->target_name
, alias_v
, errp
);
2794 visit_free(alias_v
);
2797 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2798 void *opaque
, Error
**errp
)
2800 AliasProperty
*prop
= opaque
;
2801 Visitor
*alias_v
= visitor_forward_field(v
, prop
->target_name
, name
);
2803 object_property_set(prop
->target_obj
, prop
->target_name
, alias_v
, errp
);
2804 visit_free(alias_v
);
2807 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2810 AliasProperty
*prop
= opaque
;
2812 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2815 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2817 AliasProperty
*prop
= opaque
;
2819 g_free(prop
->target_name
);
2824 object_property_add_alias(Object
*obj
, const char *name
,
2825 Object
*target_obj
, const char *target_name
)
2827 AliasProperty
*prop
;
2829 ObjectProperty
*target_prop
;
2830 g_autofree
char *prop_type
= NULL
;
2832 target_prop
= object_property_find_err(target_obj
, target_name
,
2835 if (object_property_is_child(target_prop
)) {
2836 prop_type
= g_strdup_printf("link%s",
2837 target_prop
->type
+ strlen("child"));
2839 prop_type
= g_strdup(target_prop
->type
);
2842 prop
= g_malloc(sizeof(*prop
));
2843 prop
->target_obj
= target_obj
;
2844 prop
->target_name
= g_strdup(target_name
);
2846 op
= object_property_add(obj
, name
, prop_type
,
2849 property_release_alias
,
2851 op
->resolve
= property_resolve_alias
;
2852 if (target_prop
->defval
) {
2853 op
->defval
= qobject_ref(target_prop
->defval
);
2856 object_property_set_description(obj
, op
->name
,
2857 target_prop
->description
);
2861 void object_property_set_description(Object
*obj
, const char *name
,
2862 const char *description
)
2866 op
= object_property_find_err(obj
, name
, &error_abort
);
2867 g_free(op
->description
);
2868 op
->description
= g_strdup(description
);
2871 void object_class_property_set_description(ObjectClass
*klass
,
2873 const char *description
)
2877 op
= g_hash_table_lookup(klass
->properties
, name
);
2878 g_free(op
->description
);
2879 op
->description
= g_strdup(description
);
2882 static void object_class_init(ObjectClass
*klass
, void *data
)
2884 object_class_property_add_str(klass
, "type", object_get_type
,
2888 static void register_types(void)
2890 static const TypeInfo interface_info
= {
2891 .name
= TYPE_INTERFACE
,
2892 .class_size
= sizeof(InterfaceClass
),
2896 static const TypeInfo object_info
= {
2897 .name
= TYPE_OBJECT
,
2898 .instance_size
= sizeof(Object
),
2899 .class_init
= object_class_init
,
2903 type_interface
= type_register_internal(&interface_info
);
2904 type_register_internal(&object_info
);
2907 type_init(register_types
)