4 * Copyright IBM, Corp. 2011
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "hw/qdev-core.h"
15 #include "qapi/error.h"
16 #include "qom/object.h"
17 #include "qom/object_interfaces.h"
18 #include "qemu/cutils.h"
19 #include "qapi/visitor.h"
20 #include "qapi/string-input-visitor.h"
21 #include "qapi/string-output-visitor.h"
22 #include "qapi/qobject-input-visitor.h"
23 #include "qapi/qapi-builtin-visit.h"
24 #include "qapi/qmp/qerror.h"
25 #include "qapi/qmp/qjson.h"
28 /* TODO: replace QObject with a simpler visitor to avoid a dependency
29 * of the QOM core on QObject? */
30 #include "qom/qom-qobject.h"
31 #include "qapi/qmp/qbool.h"
32 #include "qapi/qmp/qnum.h"
33 #include "qapi/qmp/qstring.h"
34 #include "qemu/error-report.h"
36 #define MAX_INTERFACES 32
38 typedef struct InterfaceImpl InterfaceImpl
;
39 typedef struct TypeImpl TypeImpl
;
54 void (*class_init
)(ObjectClass
*klass
, void *data
);
55 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
59 void (*instance_init
)(Object
*obj
);
60 void (*instance_post_init
)(Object
*obj
);
61 void (*instance_finalize
)(Object
*obj
);
66 TypeImpl
*parent_type
;
71 InterfaceImpl interfaces
[MAX_INTERFACES
];
74 static Type type_interface
;
76 static GHashTable
*type_table_get(void)
78 static GHashTable
*type_table
;
80 if (type_table
== NULL
) {
81 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
87 static bool enumerating_types
;
89 static void type_table_add(TypeImpl
*ti
)
91 assert(!enumerating_types
);
92 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
95 static TypeImpl
*type_table_lookup(const char *name
)
97 return g_hash_table_lookup(type_table_get(), name
);
100 static TypeImpl
*type_new(const TypeInfo
*info
)
102 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
105 g_assert(info
->name
!= NULL
);
107 if (type_table_lookup(info
->name
) != NULL
) {
108 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
112 ti
->name
= g_strdup(info
->name
);
113 ti
->parent
= g_strdup(info
->parent
);
115 ti
->class_size
= info
->class_size
;
116 ti
->instance_size
= info
->instance_size
;
118 ti
->class_init
= info
->class_init
;
119 ti
->class_base_init
= info
->class_base_init
;
120 ti
->class_data
= info
->class_data
;
122 ti
->instance_init
= info
->instance_init
;
123 ti
->instance_post_init
= info
->instance_post_init
;
124 ti
->instance_finalize
= info
->instance_finalize
;
126 ti
->abstract
= info
->abstract
;
128 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
129 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
131 ti
->num_interfaces
= i
;
136 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
145 TypeImpl
*type_register(const TypeInfo
*info
)
147 assert(info
->parent
);
148 return type_register_internal(info
);
151 TypeImpl
*type_register_static(const TypeInfo
*info
)
153 return type_register(info
);
156 void type_register_static_array(const TypeInfo
*infos
, int nr_infos
)
160 for (i
= 0; i
< nr_infos
; i
++) {
161 type_register_static(&infos
[i
]);
165 static TypeImpl
*type_get_by_name(const char *name
)
171 return type_table_lookup(name
);
174 static TypeImpl
*type_get_parent(TypeImpl
*type
)
176 if (!type
->parent_type
&& type
->parent
) {
177 type
->parent_type
= type_get_by_name(type
->parent
);
178 if (!type
->parent_type
) {
179 fprintf(stderr
, "Type '%s' is missing its parent '%s'\n",
180 type
->name
, type
->parent
);
185 return type
->parent_type
;
188 static bool type_has_parent(TypeImpl
*type
)
190 return (type
->parent
!= NULL
);
193 static size_t type_class_get_size(TypeImpl
*ti
)
195 if (ti
->class_size
) {
196 return ti
->class_size
;
199 if (type_has_parent(ti
)) {
200 return type_class_get_size(type_get_parent(ti
));
203 return sizeof(ObjectClass
);
206 static size_t type_object_get_size(TypeImpl
*ti
)
208 if (ti
->instance_size
) {
209 return ti
->instance_size
;
212 if (type_has_parent(ti
)) {
213 return type_object_get_size(type_get_parent(ti
));
219 size_t object_type_get_instance_size(const char *typename
)
221 TypeImpl
*type
= type_get_by_name(typename
);
223 g_assert(type
!= NULL
);
224 return type_object_get_size(type
);
227 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
231 /* Check if target_type is a direct ancestor of type */
233 if (type
== target_type
) {
237 type
= type_get_parent(type
);
243 static void type_initialize(TypeImpl
*ti
);
245 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
246 TypeImpl
*parent_type
)
248 InterfaceClass
*new_iface
;
250 TypeImpl
*iface_impl
;
252 info
.parent
= parent_type
->name
;
253 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
254 info
.abstract
= true;
256 iface_impl
= type_new(&info
);
257 iface_impl
->parent_type
= parent_type
;
258 type_initialize(iface_impl
);
259 g_free((char *)info
.name
);
261 new_iface
= (InterfaceClass
*)iface_impl
->class;
262 new_iface
->concrete_class
= ti
->class;
263 new_iface
->interface_type
= interface_type
;
265 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
, new_iface
);
268 static void object_property_free(gpointer data
)
270 ObjectProperty
*prop
= data
;
273 qobject_unref(prop
->defval
);
278 g_free(prop
->description
);
282 static void type_initialize(TypeImpl
*ti
)
290 ti
->class_size
= type_class_get_size(ti
);
291 ti
->instance_size
= type_object_get_size(ti
);
292 /* Any type with zero instance_size is implicitly abstract.
293 * This means interface types are all abstract.
295 if (ti
->instance_size
== 0) {
298 if (type_is_ancestor(ti
, type_interface
)) {
299 assert(ti
->instance_size
== 0);
300 assert(ti
->abstract
);
301 assert(!ti
->instance_init
);
302 assert(!ti
->instance_post_init
);
303 assert(!ti
->instance_finalize
);
304 assert(!ti
->num_interfaces
);
306 ti
->class = g_malloc0(ti
->class_size
);
308 parent
= type_get_parent(ti
);
310 type_initialize(parent
);
314 g_assert(parent
->class_size
<= ti
->class_size
);
315 g_assert(parent
->instance_size
<= ti
->instance_size
);
316 memcpy(ti
->class, parent
->class, parent
->class_size
);
317 ti
->class->interfaces
= NULL
;
319 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
320 InterfaceClass
*iface
= e
->data
;
321 ObjectClass
*klass
= OBJECT_CLASS(iface
);
323 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
326 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
327 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
329 error_report("missing interface '%s' for object '%s'",
330 ti
->interfaces
[i
].typename
, parent
->name
);
333 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
334 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
336 if (type_is_ancestor(target_type
, t
)) {
345 type_initialize_interface(ti
, t
, t
);
349 ti
->class->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
, NULL
,
350 object_property_free
);
352 ti
->class->type
= ti
;
355 if (parent
->class_base_init
) {
356 parent
->class_base_init(ti
->class, ti
->class_data
);
358 parent
= type_get_parent(parent
);
361 if (ti
->class_init
) {
362 ti
->class_init(ti
->class, ti
->class_data
);
366 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
368 if (type_has_parent(ti
)) {
369 object_init_with_type(obj
, type_get_parent(ti
));
372 if (ti
->instance_init
) {
373 ti
->instance_init(obj
);
377 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
379 if (ti
->instance_post_init
) {
380 ti
->instance_post_init(obj
);
383 if (type_has_parent(ti
)) {
384 object_post_init_with_type(obj
, type_get_parent(ti
));
388 bool object_apply_global_props(Object
*obj
, const GPtrArray
*props
,
397 for (i
= 0; i
< props
->len
; i
++) {
398 GlobalProperty
*p
= g_ptr_array_index(props
, i
);
401 if (object_dynamic_cast(obj
, p
->driver
) == NULL
) {
404 if (p
->optional
&& !object_property_find(obj
, p
->property
, NULL
)) {
408 if (!object_property_parse(obj
, p
->property
, p
->value
, &err
)) {
409 error_prepend(&err
, "can't apply global %s.%s=%s: ",
410 p
->driver
, p
->property
, p
->value
);
412 * If errp != NULL, propagate error and return.
413 * If errp == NULL, report a warning, but keep going
414 * with the remaining globals.
417 error_propagate(errp
, err
);
420 warn_report_err(err
);
429 * Global property defaults
430 * Slot 0: accelerator's global property defaults
431 * Slot 1: machine's global property defaults
432 * Slot 2: global properties from legacy command line option
433 * Each is a GPtrArray of of GlobalProperty.
434 * Applied in order, later entries override earlier ones.
436 static GPtrArray
*object_compat_props
[3];
439 * Retrieve @GPtrArray for global property defined with options
440 * other than "-global". These are generally used for syntactic
441 * sugar and legacy command line options.
443 void object_register_sugar_prop(const char *driver
, const char *prop
, const char *value
)
446 if (!object_compat_props
[2]) {
447 object_compat_props
[2] = g_ptr_array_new();
449 g
= g_new0(GlobalProperty
, 1);
450 g
->driver
= g_strdup(driver
);
451 g
->property
= g_strdup(prop
);
452 g
->value
= g_strdup(value
);
453 g_ptr_array_add(object_compat_props
[2], g
);
457 * Set machine's global property defaults to @compat_props.
458 * May be called at most once.
460 void object_set_machine_compat_props(GPtrArray
*compat_props
)
462 assert(!object_compat_props
[1]);
463 object_compat_props
[1] = compat_props
;
467 * Set accelerator's global property defaults to @compat_props.
468 * May be called at most once.
470 void object_set_accelerator_compat_props(GPtrArray
*compat_props
)
472 assert(!object_compat_props
[0]);
473 object_compat_props
[0] = compat_props
;
476 void object_apply_compat_props(Object
*obj
)
480 for (i
= 0; i
< ARRAY_SIZE(object_compat_props
); i
++) {
481 object_apply_global_props(obj
, object_compat_props
[i
],
482 i
== 2 ? &error_fatal
: &error_abort
);
486 static void object_class_property_init_all(Object
*obj
)
488 ObjectPropertyIterator iter
;
489 ObjectProperty
*prop
;
491 object_class_property_iter_init(&iter
, object_get_class(obj
));
492 while ((prop
= object_property_iter_next(&iter
))) {
494 prop
->init(obj
, prop
);
499 static void object_initialize_with_type(Object
*obj
, size_t size
, TypeImpl
*type
)
501 type_initialize(type
);
503 g_assert(type
->instance_size
>= sizeof(Object
));
504 g_assert(type
->abstract
== false);
505 g_assert(size
>= type
->instance_size
);
507 memset(obj
, 0, type
->instance_size
);
508 obj
->class = type
->class;
510 object_class_property_init_all(obj
);
511 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
512 NULL
, object_property_free
);
513 object_init_with_type(obj
, type
);
514 object_post_init_with_type(obj
, type
);
517 void object_initialize(void *data
, size_t size
, const char *typename
)
519 TypeImpl
*type
= type_get_by_name(typename
);
522 error_report("missing object type '%s'", typename
);
526 object_initialize_with_type(data
, size
, type
);
529 bool object_initialize_child_with_props(Object
*parentobj
,
530 const char *propname
,
531 void *childobj
, size_t size
,
538 va_start(vargs
, errp
);
539 ok
= object_initialize_child_with_propsv(parentobj
, propname
,
540 childobj
, size
, type
, errp
,
546 bool object_initialize_child_with_propsv(Object
*parentobj
,
547 const char *propname
,
548 void *childobj
, size_t size
,
550 Error
**errp
, va_list vargs
)
552 Error
*local_err
= NULL
;
557 object_initialize(childobj
, size
, type
);
558 obj
= OBJECT(childobj
);
560 if (object_set_propv(obj
, errp
, vargs
) < 0) {
564 object_property_add_child(parentobj
, propname
, obj
);
566 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
568 if (!user_creatable_complete(uc
, &local_err
)) {
569 object_unparent(obj
);
578 * We want @obj's reference to be 1 on success, 0 on failure.
579 * On success, it's 2: one taken by object_initialize(), and one
580 * by object_property_add_child().
581 * On failure in object_initialize() or earlier, it's 1.
582 * On failure afterwards, it's also 1: object_unparent() releases
583 * the reference taken by object_property_add_child().
587 error_propagate(errp
, local_err
);
591 void object_initialize_child_internal(Object
*parent
,
592 const char *propname
,
593 void *child
, size_t size
,
596 object_initialize_child_with_props(parent
, propname
, child
, size
, type
,
600 static inline bool object_property_is_child(ObjectProperty
*prop
)
602 return strstart(prop
->type
, "child<", NULL
);
605 static void object_property_del_all(Object
*obj
)
607 g_autoptr(GHashTable
) done
= g_hash_table_new(NULL
, NULL
);
608 ObjectProperty
*prop
;
609 ObjectPropertyIterator iter
;
614 object_property_iter_init(&iter
, obj
);
615 while ((prop
= object_property_iter_next(&iter
)) != NULL
) {
616 if (g_hash_table_add(done
, prop
)) {
618 prop
->release(obj
, prop
->name
, prop
->opaque
);
626 g_hash_table_unref(obj
->properties
);
629 static void object_property_del_child(Object
*obj
, Object
*child
)
631 ObjectProperty
*prop
;
635 g_hash_table_iter_init(&iter
, obj
->properties
);
636 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
638 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
640 prop
->release(obj
, prop
->name
, prop
->opaque
);
641 prop
->release
= NULL
;
646 g_hash_table_iter_init(&iter
, obj
->properties
);
647 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
649 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
650 g_hash_table_iter_remove(&iter
);
656 void object_unparent(Object
*obj
)
659 object_property_del_child(obj
->parent
, obj
);
663 static void object_deinit(Object
*obj
, TypeImpl
*type
)
665 if (type
->instance_finalize
) {
666 type
->instance_finalize(obj
);
669 if (type_has_parent(type
)) {
670 object_deinit(obj
, type_get_parent(type
));
674 static void object_finalize(void *data
)
677 TypeImpl
*ti
= obj
->class->type
;
679 object_property_del_all(obj
);
680 object_deinit(obj
, ti
);
682 g_assert(obj
->ref
== 0);
688 static Object
*object_new_with_type(Type type
)
692 g_assert(type
!= NULL
);
693 type_initialize(type
);
695 obj
= g_malloc(type
->instance_size
);
696 object_initialize_with_type(obj
, type
->instance_size
, type
);
702 Object
*object_new_with_class(ObjectClass
*klass
)
704 return object_new_with_type(klass
->type
);
707 Object
*object_new(const char *typename
)
709 TypeImpl
*ti
= type_get_by_name(typename
);
711 return object_new_with_type(ti
);
715 Object
*object_new_with_props(const char *typename
,
724 va_start(vargs
, errp
);
725 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
732 Object
*object_new_with_propv(const char *typename
,
740 Error
*local_err
= NULL
;
743 klass
= object_class_by_name(typename
);
745 error_setg(errp
, "invalid object type: %s", typename
);
749 if (object_class_is_abstract(klass
)) {
750 error_setg(errp
, "object type '%s' is abstract", typename
);
753 obj
= object_new_with_type(klass
->type
);
755 if (object_set_propv(obj
, errp
, vargs
) < 0) {
760 object_property_add_child(parent
, id
, obj
);
763 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
765 if (!user_creatable_complete(uc
, &local_err
)) {
767 object_unparent(obj
);
777 error_propagate(errp
, local_err
);
783 int object_set_props(Object
*obj
,
790 va_start(vargs
, errp
);
791 ret
= object_set_propv(obj
, errp
, vargs
);
798 int object_set_propv(Object
*obj
,
802 const char *propname
;
803 Error
*local_err
= NULL
;
805 propname
= va_arg(vargs
, char *);
806 while (propname
!= NULL
) {
807 const char *value
= va_arg(vargs
, char *);
809 g_assert(value
!= NULL
);
810 if (!object_property_parse(obj
, propname
, value
, &local_err
)) {
811 error_propagate(errp
, local_err
);
814 propname
= va_arg(vargs
, char *);
821 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
823 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
830 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
831 const char *file
, int line
, const char *func
)
833 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
834 typename
, file
, line
, func
);
836 #ifdef CONFIG_QOM_CAST_DEBUG
840 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
841 if (atomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
846 inst
= object_dynamic_cast(obj
, typename
);
849 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
850 file
, line
, func
, obj
, typename
);
856 if (obj
&& obj
== inst
) {
857 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
858 atomic_set(&obj
->class->object_cast_cache
[i
- 1],
859 atomic_read(&obj
->class->object_cast_cache
[i
]));
861 atomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
869 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
870 const char *typename
)
872 ObjectClass
*ret
= NULL
;
873 TypeImpl
*target_type
;
880 /* A simple fast path that can trigger a lot for leaf classes. */
882 if (type
->name
== typename
) {
886 target_type
= type_get_by_name(typename
);
888 /* target class type unknown, so fail the cast */
892 if (type
->class->interfaces
&&
893 type_is_ancestor(target_type
, type_interface
)) {
897 for (i
= class->interfaces
; i
; i
= i
->next
) {
898 ObjectClass
*target_class
= i
->data
;
900 if (type_is_ancestor(target_class
->type
, target_type
)) {
906 /* The match was ambiguous, don't allow a cast */
910 } else if (type_is_ancestor(type
, target_type
)) {
917 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
918 const char *typename
,
919 const char *file
, int line
,
924 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
925 typename
, file
, line
, func
);
927 #ifdef CONFIG_QOM_CAST_DEBUG
930 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
931 if (atomic_read(&class->class_cast_cache
[i
]) == typename
) {
937 if (!class || !class->interfaces
) {
942 ret
= object_class_dynamic_cast(class, typename
);
944 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
945 file
, line
, func
, class, typename
);
949 #ifdef CONFIG_QOM_CAST_DEBUG
950 if (class && ret
== class) {
951 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
952 atomic_set(&class->class_cast_cache
[i
- 1],
953 atomic_read(&class->class_cast_cache
[i
]));
955 atomic_set(&class->class_cast_cache
[i
- 1], typename
);
962 const char *object_get_typename(const Object
*obj
)
964 return obj
->class->type
->name
;
967 ObjectClass
*object_get_class(Object
*obj
)
972 bool object_class_is_abstract(ObjectClass
*klass
)
974 return klass
->type
->abstract
;
977 const char *object_class_get_name(ObjectClass
*klass
)
979 return klass
->type
->name
;
982 ObjectClass
*object_class_by_name(const char *typename
)
984 TypeImpl
*type
= type_get_by_name(typename
);
990 type_initialize(type
);
995 ObjectClass
*module_object_class_by_name(const char *typename
)
999 oc
= object_class_by_name(typename
);
1000 #ifdef CONFIG_MODULES
1002 module_load_qom_one(typename
);
1003 oc
= object_class_by_name(typename
);
1009 ObjectClass
*object_class_get_parent(ObjectClass
*class)
1011 TypeImpl
*type
= type_get_parent(class->type
);
1017 type_initialize(type
);
1022 typedef struct OCFData
1024 void (*fn
)(ObjectClass
*klass
, void *opaque
);
1025 const char *implements_type
;
1026 bool include_abstract
;
1030 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
1033 OCFData
*data
= opaque
;
1034 TypeImpl
*type
= value
;
1037 type_initialize(type
);
1040 if (!data
->include_abstract
&& type
->abstract
) {
1044 if (data
->implements_type
&&
1045 !object_class_dynamic_cast(k
, data
->implements_type
)) {
1049 data
->fn(k
, data
->opaque
);
1052 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
1053 const char *implements_type
, bool include_abstract
,
1056 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
1058 enumerating_types
= true;
1059 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
1060 enumerating_types
= false;
1063 static int do_object_child_foreach(Object
*obj
,
1064 int (*fn
)(Object
*child
, void *opaque
),
1065 void *opaque
, bool recurse
)
1067 GHashTableIter iter
;
1068 ObjectProperty
*prop
;
1071 g_hash_table_iter_init(&iter
, obj
->properties
);
1072 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1073 if (object_property_is_child(prop
)) {
1074 Object
*child
= prop
->opaque
;
1076 ret
= fn(child
, opaque
);
1081 ret
= do_object_child_foreach(child
, fn
, opaque
, true);
1091 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
1094 return do_object_child_foreach(obj
, fn
, opaque
, false);
1097 int object_child_foreach_recursive(Object
*obj
,
1098 int (*fn
)(Object
*child
, void *opaque
),
1101 return do_object_child_foreach(obj
, fn
, opaque
, true);
1104 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
1106 GSList
**list
= opaque
;
1108 *list
= g_slist_prepend(*list
, klass
);
1111 GSList
*object_class_get_list(const char *implements_type
,
1112 bool include_abstract
)
1114 GSList
*list
= NULL
;
1116 object_class_foreach(object_class_get_list_tramp
,
1117 implements_type
, include_abstract
, &list
);
1121 static gint
object_class_cmp(gconstpointer a
, gconstpointer b
)
1123 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
1124 object_class_get_name((ObjectClass
*)b
));
1127 GSList
*object_class_get_list_sorted(const char *implements_type
,
1128 bool include_abstract
)
1130 return g_slist_sort(object_class_get_list(implements_type
, include_abstract
),
1134 Object
*object_ref(Object
*obj
)
1139 atomic_inc(&obj
->ref
);
1143 void object_unref(Object
*obj
)
1148 g_assert(obj
->ref
> 0);
1150 /* parent always holds a reference to its children */
1151 if (atomic_fetch_dec(&obj
->ref
) == 1) {
1152 object_finalize(obj
);
1156 static ObjectProperty
*
1157 object_property_try_add(Object
*obj
, const char *name
, const char *type
,
1158 ObjectPropertyAccessor
*get
,
1159 ObjectPropertyAccessor
*set
,
1160 ObjectPropertyRelease
*release
,
1161 void *opaque
, Error
**errp
)
1163 ObjectProperty
*prop
;
1164 size_t name_len
= strlen(name
);
1166 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
1168 ObjectProperty
*ret
;
1169 char *name_no_array
= g_strdup(name
);
1171 name_no_array
[name_len
- 3] = '\0';
1172 for (i
= 0; ; ++i
) {
1173 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
1175 ret
= object_property_try_add(obj
, full_name
, type
, get
, set
,
1176 release
, opaque
, NULL
);
1182 g_free(name_no_array
);
1186 if (object_property_find(obj
, name
, NULL
) != NULL
) {
1187 error_setg(errp
, "attempt to add duplicate property '%s' to object (type '%s')",
1188 name
, object_get_typename(obj
));
1192 prop
= g_malloc0(sizeof(*prop
));
1194 prop
->name
= g_strdup(name
);
1195 prop
->type
= g_strdup(type
);
1199 prop
->release
= release
;
1200 prop
->opaque
= opaque
;
1202 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
1207 object_property_add(Object
*obj
, const char *name
, const char *type
,
1208 ObjectPropertyAccessor
*get
,
1209 ObjectPropertyAccessor
*set
,
1210 ObjectPropertyRelease
*release
,
1213 return object_property_try_add(obj
, name
, type
, get
, set
, release
,
1214 opaque
, &error_abort
);
1218 object_class_property_add(ObjectClass
*klass
,
1221 ObjectPropertyAccessor
*get
,
1222 ObjectPropertyAccessor
*set
,
1223 ObjectPropertyRelease
*release
,
1226 ObjectProperty
*prop
;
1228 assert(!object_class_property_find(klass
, name
, NULL
));
1230 prop
= g_malloc0(sizeof(*prop
));
1232 prop
->name
= g_strdup(name
);
1233 prop
->type
= g_strdup(type
);
1237 prop
->release
= release
;
1238 prop
->opaque
= opaque
;
1240 g_hash_table_insert(klass
->properties
, prop
->name
, prop
);
1245 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
1248 ObjectProperty
*prop
;
1249 ObjectClass
*klass
= object_get_class(obj
);
1251 prop
= object_class_property_find(klass
, name
, NULL
);
1256 prop
= g_hash_table_lookup(obj
->properties
, name
);
1261 error_setg(errp
, "Property '.%s' not found", name
);
1265 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1268 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1269 iter
->nextclass
= object_get_class(obj
);
1272 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1275 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1276 if (!iter
->nextclass
) {
1279 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1280 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1285 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1288 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1289 iter
->nextclass
= object_class_get_parent(klass
);
1292 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
,
1295 ObjectProperty
*prop
;
1296 ObjectClass
*parent_klass
;
1298 parent_klass
= object_class_get_parent(klass
);
1300 prop
= object_class_property_find(parent_klass
, name
, NULL
);
1306 prop
= g_hash_table_lookup(klass
->properties
, name
);
1308 error_setg(errp
, "Property '.%s' not found", name
);
1313 void object_property_del(Object
*obj
, const char *name
)
1315 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1317 if (prop
->release
) {
1318 prop
->release(obj
, name
, prop
->opaque
);
1320 g_hash_table_remove(obj
->properties
, name
);
1323 bool object_property_get(Object
*obj
, const char *name
, Visitor
*v
,
1327 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1334 error_setg(errp
, QERR_PERMISSION_DENIED
);
1337 prop
->get(obj
, v
, name
, prop
->opaque
, &err
);
1338 error_propagate(errp
, err
);
1342 bool object_property_set(Object
*obj
, const char *name
, Visitor
*v
,
1346 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1353 error_setg(errp
, QERR_PERMISSION_DENIED
);
1356 prop
->set(obj
, v
, name
, prop
->opaque
, &err
);
1357 error_propagate(errp
, err
);
1361 bool object_property_set_str(Object
*obj
, const char *name
,
1362 const char *value
, Error
**errp
)
1364 QString
*qstr
= qstring_from_str(value
);
1365 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qstr
), errp
);
1367 qobject_unref(qstr
);
1371 char *object_property_get_str(Object
*obj
, const char *name
,
1374 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1381 retval
= g_strdup(qobject_get_try_str(ret
));
1383 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1390 bool object_property_set_link(Object
*obj
, const char *name
,
1391 Object
*value
, Error
**errp
)
1393 g_autofree
char *path
= NULL
;
1396 path
= object_get_canonical_path(value
);
1398 return object_property_set_str(obj
, name
, path
?: "", errp
);
1401 Object
*object_property_get_link(Object
*obj
, const char *name
,
1404 char *str
= object_property_get_str(obj
, name
, errp
);
1405 Object
*target
= NULL
;
1408 target
= object_resolve_path(str
, NULL
);
1410 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1411 "Device '%s' not found", str
);
1419 bool object_property_set_bool(Object
*obj
, const char *name
,
1420 bool value
, Error
**errp
)
1422 QBool
*qbool
= qbool_from_bool(value
);
1423 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qbool
), errp
);
1425 qobject_unref(qbool
);
1429 bool object_property_get_bool(Object
*obj
, const char *name
,
1432 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1439 qbool
= qobject_to(QBool
, ret
);
1441 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1444 retval
= qbool_get_bool(qbool
);
1451 bool object_property_set_int(Object
*obj
, const char *name
,
1452 int64_t value
, Error
**errp
)
1454 QNum
*qnum
= qnum_from_int(value
);
1455 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qnum
), errp
);
1457 qobject_unref(qnum
);
1461 int64_t object_property_get_int(Object
*obj
, const char *name
,
1464 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1472 qnum
= qobject_to(QNum
, ret
);
1473 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1474 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1482 static void object_property_init_defval(Object
*obj
, ObjectProperty
*prop
)
1484 Visitor
*v
= qobject_input_visitor_new(prop
->defval
);
1486 assert(prop
->set
!= NULL
);
1487 prop
->set(obj
, v
, prop
->name
, prop
->opaque
, &error_abort
);
1492 static void object_property_set_default(ObjectProperty
*prop
, QObject
*defval
)
1494 assert(!prop
->defval
);
1495 assert(!prop
->init
);
1497 prop
->defval
= defval
;
1498 prop
->init
= object_property_init_defval
;
1501 void object_property_set_default_bool(ObjectProperty
*prop
, bool value
)
1503 object_property_set_default(prop
, QOBJECT(qbool_from_bool(value
)));
1506 void object_property_set_default_str(ObjectProperty
*prop
, const char *value
)
1508 object_property_set_default(prop
, QOBJECT(qstring_from_str(value
)));
1511 void object_property_set_default_int(ObjectProperty
*prop
, int64_t value
)
1513 object_property_set_default(prop
, QOBJECT(qnum_from_int(value
)));
1516 void object_property_set_default_uint(ObjectProperty
*prop
, uint64_t value
)
1518 object_property_set_default(prop
, QOBJECT(qnum_from_uint(value
)));
1521 bool object_property_set_uint(Object
*obj
, const char *name
,
1522 uint64_t value
, Error
**errp
)
1524 QNum
*qnum
= qnum_from_uint(value
);
1525 bool ok
= object_property_set_qobject(obj
, name
, QOBJECT(qnum
), errp
);
1527 qobject_unref(qnum
);
1531 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1534 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1541 qnum
= qobject_to(QNum
, ret
);
1542 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1543 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "uint");
1551 typedef struct EnumProperty
{
1552 const QEnumLookup
*lookup
;
1553 int (*get
)(Object
*, Error
**);
1554 void (*set
)(Object
*, int, Error
**);
1557 int object_property_get_enum(Object
*obj
, const char *name
,
1558 const char *typename
, Error
**errp
)
1562 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1563 EnumProperty
*enumprop
;
1569 if (!g_str_equal(prop
->type
, typename
)) {
1570 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1571 name
, object_class_get_name(
1572 object_get_class(obj
)), typename
);
1576 enumprop
= prop
->opaque
;
1578 str
= object_property_get_str(obj
, name
, errp
);
1583 ret
= qapi_enum_parse(enumprop
->lookup
, str
, -1, errp
);
1589 bool object_property_parse(Object
*obj
, const char *name
,
1590 const char *string
, Error
**errp
)
1592 Visitor
*v
= string_input_visitor_new(string
);
1593 bool ok
= object_property_set(obj
, name
, v
, errp
);
1599 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1603 char *string
= NULL
;
1604 Error
*local_err
= NULL
;
1606 v
= string_output_visitor_new(human
, &string
);
1607 if (!object_property_get(obj
, name
, v
, &local_err
)) {
1608 error_propagate(errp
, local_err
);
1612 visit_complete(v
, &string
);
1619 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1621 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1629 Object
*object_get_root(void)
1631 static Object
*root
;
1634 root
= object_new("container");
1640 Object
*object_get_objects_root(void)
1642 return container_get(object_get_root(), "/objects");
1645 Object
*object_get_internal_root(void)
1647 static Object
*internal_root
;
1649 if (!internal_root
) {
1650 internal_root
= object_new("container");
1653 return internal_root
;
1656 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1657 const char *name
, void *opaque
,
1660 Object
*child
= opaque
;
1663 path
= object_get_canonical_path(child
);
1664 visit_type_str(v
, name
, &path
, errp
);
1668 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
,
1674 static void object_finalize_child_property(Object
*obj
, const char *name
,
1677 Object
*child
= opaque
;
1679 if (child
->class->unparent
) {
1680 (child
->class->unparent
)(child
);
1682 child
->parent
= NULL
;
1683 object_unref(child
);
1687 object_property_add_child(Object
*obj
, const char *name
,
1690 g_autofree
char *type
= NULL
;
1693 assert(!child
->parent
);
1695 type
= g_strdup_printf("child<%s>", object_get_typename(child
));
1697 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1698 object_finalize_child_property
, child
);
1699 op
->resolve
= object_resolve_child_property
;
1701 child
->parent
= obj
;
1705 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1706 Object
*val
, Error
**errp
)
1708 /* Allow the link to be set, always */
1714 Object
*target
; /* if OBJ_PROP_LINK_DIRECT, when holding the pointer */
1715 ptrdiff_t offset
; /* if OBJ_PROP_LINK_CLASS */
1717 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1718 ObjectPropertyLinkFlags flags
;
1722 object_link_get_targetp(Object
*obj
, LinkProperty
*lprop
)
1724 if (lprop
->flags
& OBJ_PROP_LINK_DIRECT
) {
1725 return &lprop
->target
;
1726 } else if (lprop
->flags
& OBJ_PROP_LINK_CLASS
) {
1727 return (void *)obj
+ lprop
->offset
;
1729 return lprop
->targetp
;
1733 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1734 const char *name
, void *opaque
,
1737 LinkProperty
*lprop
= opaque
;
1738 Object
**targetp
= object_link_get_targetp(obj
, lprop
);
1742 path
= object_get_canonical_path(*targetp
);
1743 visit_type_str(v
, name
, &path
, errp
);
1747 visit_type_str(v
, name
, &path
, errp
);
1752 * object_resolve_link:
1754 * Lookup an object and ensure its type matches the link property type. This
1755 * is similar to object_resolve_path() except type verification against the
1756 * link property is performed.
1758 * Returns: The matched object or NULL on path lookup failures.
1760 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1761 const char *path
, Error
**errp
)
1765 bool ambiguous
= false;
1768 /* Go from link<FOO> to FOO. */
1769 type
= object_property_get_type(obj
, name
, NULL
);
1770 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1771 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1774 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1776 } else if (!target
) {
1777 target
= object_resolve_path(path
, &ambiguous
);
1778 if (target
|| ambiguous
) {
1779 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1781 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1782 "Device '%s' not found", path
);
1786 g_free(target_type
);
1791 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1792 const char *name
, void *opaque
,
1795 Error
*local_err
= NULL
;
1796 LinkProperty
*prop
= opaque
;
1797 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1798 Object
*old_target
= *targetp
;
1802 if (!visit_type_str(v
, name
, &path
, errp
)) {
1807 new_target
= object_resolve_link(obj
, name
, path
, errp
);
1818 prop
->check(obj
, name
, new_target
, &local_err
);
1820 error_propagate(errp
, local_err
);
1824 *targetp
= new_target
;
1825 if (prop
->flags
& OBJ_PROP_LINK_STRONG
) {
1826 object_ref(new_target
);
1827 object_unref(old_target
);
1831 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
,
1834 LinkProperty
*lprop
= opaque
;
1836 return *object_link_get_targetp(parent
, lprop
);
1839 static void object_release_link_property(Object
*obj
, const char *name
,
1842 LinkProperty
*prop
= opaque
;
1843 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1845 if ((prop
->flags
& OBJ_PROP_LINK_STRONG
) && *targetp
) {
1846 object_unref(*targetp
);
1848 if (!(prop
->flags
& OBJ_PROP_LINK_CLASS
)) {
1853 static ObjectProperty
*
1854 object_add_link_prop(Object
*obj
, const char *name
,
1855 const char *type
, void *ptr
,
1856 void (*check
)(const Object
*, const char *,
1857 Object
*, Error
**),
1858 ObjectPropertyLinkFlags flags
)
1860 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1861 g_autofree
char *full_type
= NULL
;
1864 if (flags
& OBJ_PROP_LINK_DIRECT
) {
1867 prop
->targetp
= ptr
;
1869 prop
->check
= check
;
1870 prop
->flags
= flags
;
1872 full_type
= g_strdup_printf("link<%s>", type
);
1874 op
= object_property_add(obj
, name
, full_type
,
1875 object_get_link_property
,
1876 check
? object_set_link_property
: NULL
,
1877 object_release_link_property
,
1879 op
->resolve
= object_resolve_link_property
;
1884 object_property_add_link(Object
*obj
, const char *name
,
1885 const char *type
, Object
**targetp
,
1886 void (*check
)(const Object
*, const char *,
1887 Object
*, Error
**),
1888 ObjectPropertyLinkFlags flags
)
1890 return object_add_link_prop(obj
, name
, type
, targetp
, check
, flags
);
1894 object_class_property_add_link(ObjectClass
*oc
,
1896 const char *type
, ptrdiff_t offset
,
1897 void (*check
)(const Object
*obj
, const char *name
,
1898 Object
*val
, Error
**errp
),
1899 ObjectPropertyLinkFlags flags
)
1901 LinkProperty
*prop
= g_new0(LinkProperty
, 1);
1905 prop
->offset
= offset
;
1906 prop
->check
= check
;
1907 prop
->flags
= flags
| OBJ_PROP_LINK_CLASS
;
1909 full_type
= g_strdup_printf("link<%s>", type
);
1911 op
= object_class_property_add(oc
, name
, full_type
,
1912 object_get_link_property
,
1913 check
? object_set_link_property
: NULL
,
1914 object_release_link_property
,
1917 op
->resolve
= object_resolve_link_property
;
1924 object_property_add_const_link(Object
*obj
, const char *name
,
1927 return object_add_link_prop(obj
, name
,
1928 object_get_typename(target
), target
,
1929 NULL
, OBJ_PROP_LINK_DIRECT
);
1932 char *object_get_canonical_path_component(const Object
*obj
)
1934 ObjectProperty
*prop
= NULL
;
1935 GHashTableIter iter
;
1937 if (obj
->parent
== NULL
) {
1941 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
1942 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1943 if (!object_property_is_child(prop
)) {
1947 if (prop
->opaque
== obj
) {
1948 return g_strdup(prop
->name
);
1952 /* obj had a parent but was not a child, should never happen */
1953 g_assert_not_reached();
1957 char *object_get_canonical_path(const Object
*obj
)
1959 Object
*root
= object_get_root();
1960 char *newpath
, *path
= NULL
;
1963 return g_strdup("/");
1967 char *component
= object_get_canonical_path_component(obj
);
1970 /* A canonical path must be complete, so discard what was
1977 newpath
= g_strdup_printf("/%s%s", component
, path
? path
: "");
1982 } while (obj
!= root
);
1987 Object
*object_resolve_path_component(Object
*parent
, const char *part
)
1989 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1994 if (prop
->resolve
) {
1995 return prop
->resolve(parent
, prop
->opaque
, part
);
2001 static Object
*object_resolve_abs_path(Object
*parent
,
2003 const char *typename
)
2007 if (*parts
== NULL
) {
2008 return object_dynamic_cast(parent
, typename
);
2011 if (strcmp(*parts
, "") == 0) {
2012 return object_resolve_abs_path(parent
, parts
+ 1, typename
);
2015 child
= object_resolve_path_component(parent
, *parts
);
2020 return object_resolve_abs_path(child
, parts
+ 1, typename
);
2023 static Object
*object_resolve_partial_path(Object
*parent
,
2025 const char *typename
,
2029 GHashTableIter iter
;
2030 ObjectProperty
*prop
;
2032 obj
= object_resolve_abs_path(parent
, parts
, typename
);
2034 g_hash_table_iter_init(&iter
, parent
->properties
);
2035 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
2038 if (!object_property_is_child(prop
)) {
2042 found
= object_resolve_partial_path(prop
->opaque
, parts
,
2043 typename
, ambiguous
);
2060 Object
*object_resolve_path_type(const char *path
, const char *typename
,
2066 parts
= g_strsplit(path
, "/", 0);
2069 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
2070 bool ambiguous
= false;
2071 obj
= object_resolve_partial_path(object_get_root(), parts
,
2072 typename
, &ambiguous
);
2074 *ambiguousp
= ambiguous
;
2077 obj
= object_resolve_abs_path(object_get_root(), parts
+ 1, typename
);
2085 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
2087 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
2090 typedef struct StringProperty
2092 char *(*get
)(Object
*, Error
**);
2093 void (*set
)(Object
*, const char *, Error
**);
2096 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
2097 void *opaque
, Error
**errp
)
2099 StringProperty
*prop
= opaque
;
2103 value
= prop
->get(obj
, &err
);
2105 error_propagate(errp
, err
);
2109 visit_type_str(v
, name
, &value
, errp
);
2113 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
2114 void *opaque
, Error
**errp
)
2116 StringProperty
*prop
= opaque
;
2118 Error
*local_err
= NULL
;
2120 if (!visit_type_str(v
, name
, &value
, &local_err
)) {
2121 error_propagate(errp
, local_err
);
2125 prop
->set(obj
, value
, errp
);
2129 static void property_release_str(Object
*obj
, const char *name
,
2132 StringProperty
*prop
= opaque
;
2137 object_property_add_str(Object
*obj
, const char *name
,
2138 char *(*get
)(Object
*, Error
**),
2139 void (*set
)(Object
*, const char *, Error
**))
2141 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2146 return object_property_add(obj
, name
, "string",
2147 get
? property_get_str
: NULL
,
2148 set
? property_set_str
: NULL
,
2149 property_release_str
,
2154 object_class_property_add_str(ObjectClass
*klass
, const char *name
,
2155 char *(*get
)(Object
*, Error
**),
2156 void (*set
)(Object
*, const char *,
2159 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2164 return object_class_property_add(klass
, name
, "string",
2165 get
? property_get_str
: NULL
,
2166 set
? property_set_str
: NULL
,
2171 typedef struct BoolProperty
2173 bool (*get
)(Object
*, Error
**);
2174 void (*set
)(Object
*, bool, Error
**);
2177 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
2178 void *opaque
, Error
**errp
)
2180 BoolProperty
*prop
= opaque
;
2184 value
= prop
->get(obj
, &err
);
2186 error_propagate(errp
, err
);
2190 visit_type_bool(v
, name
, &value
, errp
);
2193 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
2194 void *opaque
, Error
**errp
)
2196 BoolProperty
*prop
= opaque
;
2198 Error
*local_err
= NULL
;
2200 if (!visit_type_bool(v
, name
, &value
, &local_err
)) {
2201 error_propagate(errp
, local_err
);
2205 prop
->set(obj
, value
, errp
);
2208 static void property_release_bool(Object
*obj
, const char *name
,
2211 BoolProperty
*prop
= opaque
;
2216 object_property_add_bool(Object
*obj
, const char *name
,
2217 bool (*get
)(Object
*, Error
**),
2218 void (*set
)(Object
*, bool, Error
**))
2220 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2225 return object_property_add(obj
, name
, "bool",
2226 get
? property_get_bool
: NULL
,
2227 set
? property_set_bool
: NULL
,
2228 property_release_bool
,
2233 object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
2234 bool (*get
)(Object
*, Error
**),
2235 void (*set
)(Object
*, bool, Error
**))
2237 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2242 return object_class_property_add(klass
, name
, "bool",
2243 get
? property_get_bool
: NULL
,
2244 set
? property_set_bool
: NULL
,
2249 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
2250 void *opaque
, Error
**errp
)
2252 EnumProperty
*prop
= opaque
;
2256 value
= prop
->get(obj
, &err
);
2258 error_propagate(errp
, err
);
2262 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
2265 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
2266 void *opaque
, Error
**errp
)
2268 EnumProperty
*prop
= opaque
;
2272 if (!visit_type_enum(v
, name
, &value
, prop
->lookup
, &err
)) {
2273 error_propagate(errp
, err
);
2276 prop
->set(obj
, value
, errp
);
2279 static void property_release_enum(Object
*obj
, const char *name
,
2282 EnumProperty
*prop
= opaque
;
2287 object_property_add_enum(Object
*obj
, const char *name
,
2288 const char *typename
,
2289 const QEnumLookup
*lookup
,
2290 int (*get
)(Object
*, Error
**),
2291 void (*set
)(Object
*, int, Error
**))
2293 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2295 prop
->lookup
= lookup
;
2299 return object_property_add(obj
, name
, typename
,
2300 get
? property_get_enum
: NULL
,
2301 set
? property_set_enum
: NULL
,
2302 property_release_enum
,
2307 object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2308 const char *typename
,
2309 const QEnumLookup
*lookup
,
2310 int (*get
)(Object
*, Error
**),
2311 void (*set
)(Object
*, int, Error
**))
2313 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2315 prop
->lookup
= lookup
;
2319 return object_class_property_add(klass
, name
, typename
,
2320 get
? property_get_enum
: NULL
,
2321 set
? property_set_enum
: NULL
,
2326 typedef struct TMProperty
{
2327 void (*get
)(Object
*, struct tm
*, Error
**);
2330 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2331 void *opaque
, Error
**errp
)
2333 TMProperty
*prop
= opaque
;
2337 prop
->get(obj
, &value
, &err
);
2342 if (!visit_start_struct(v
, name
, NULL
, 0, &err
)) {
2345 if (!visit_type_int32(v
, "tm_year", &value
.tm_year
, &err
)) {
2348 if (!visit_type_int32(v
, "tm_mon", &value
.tm_mon
, &err
)) {
2351 if (!visit_type_int32(v
, "tm_mday", &value
.tm_mday
, &err
)) {
2354 if (!visit_type_int32(v
, "tm_hour", &value
.tm_hour
, &err
)) {
2357 if (!visit_type_int32(v
, "tm_min", &value
.tm_min
, &err
)) {
2360 if (!visit_type_int32(v
, "tm_sec", &value
.tm_sec
, &err
)) {
2363 visit_check_struct(v
, &err
);
2365 visit_end_struct(v
, NULL
);
2367 error_propagate(errp
, err
);
2371 static void property_release_tm(Object
*obj
, const char *name
,
2374 TMProperty
*prop
= opaque
;
2379 object_property_add_tm(Object
*obj
, const char *name
,
2380 void (*get
)(Object
*, struct tm
*, Error
**))
2382 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2386 return object_property_add(obj
, name
, "struct tm",
2387 get
? property_get_tm
: NULL
, NULL
,
2388 property_release_tm
,
2393 object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2394 void (*get
)(Object
*, struct tm
*, Error
**))
2396 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2400 return object_class_property_add(klass
, name
, "struct tm",
2401 get
? property_get_tm
: NULL
,
2405 static char *object_get_type(Object
*obj
, Error
**errp
)
2407 return g_strdup(object_get_typename(obj
));
2410 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2411 void *opaque
, Error
**errp
)
2413 uint8_t value
= *(uint8_t *)opaque
;
2414 visit_type_uint8(v
, name
, &value
, errp
);
2417 static void property_set_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2418 void *opaque
, Error
**errp
)
2420 uint8_t *field
= opaque
;
2422 Error
*local_err
= NULL
;
2424 if (!visit_type_uint8(v
, name
, &value
, &local_err
)) {
2425 error_propagate(errp
, local_err
);
2432 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2433 void *opaque
, Error
**errp
)
2435 uint16_t value
= *(uint16_t *)opaque
;
2436 visit_type_uint16(v
, name
, &value
, errp
);
2439 static void property_set_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2440 void *opaque
, Error
**errp
)
2442 uint16_t *field
= opaque
;
2444 Error
*local_err
= NULL
;
2446 if (!visit_type_uint16(v
, name
, &value
, &local_err
)) {
2447 error_propagate(errp
, local_err
);
2454 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2455 void *opaque
, Error
**errp
)
2457 uint32_t value
= *(uint32_t *)opaque
;
2458 visit_type_uint32(v
, name
, &value
, errp
);
2461 static void property_set_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2462 void *opaque
, Error
**errp
)
2464 uint32_t *field
= opaque
;
2466 Error
*local_err
= NULL
;
2468 if (!visit_type_uint32(v
, name
, &value
, &local_err
)) {
2469 error_propagate(errp
, local_err
);
2476 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2477 void *opaque
, Error
**errp
)
2479 uint64_t value
= *(uint64_t *)opaque
;
2480 visit_type_uint64(v
, name
, &value
, errp
);
2483 static void property_set_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2484 void *opaque
, Error
**errp
)
2486 uint64_t *field
= opaque
;
2488 Error
*local_err
= NULL
;
2490 if (!visit_type_uint64(v
, name
, &value
, &local_err
)) {
2491 error_propagate(errp
, local_err
);
2499 object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2501 ObjectPropertyFlags flags
)
2503 ObjectPropertyAccessor
*getter
= NULL
;
2504 ObjectPropertyAccessor
*setter
= NULL
;
2506 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2507 getter
= property_get_uint8_ptr
;
2510 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2511 setter
= property_set_uint8_ptr
;
2514 return object_property_add(obj
, name
, "uint8",
2515 getter
, setter
, NULL
, (void *)v
);
2519 object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2521 ObjectPropertyFlags flags
)
2523 ObjectPropertyAccessor
*getter
= NULL
;
2524 ObjectPropertyAccessor
*setter
= NULL
;
2526 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2527 getter
= property_get_uint8_ptr
;
2530 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2531 setter
= property_set_uint8_ptr
;
2534 return object_class_property_add(klass
, name
, "uint8",
2535 getter
, setter
, NULL
, (void *)v
);
2539 object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2541 ObjectPropertyFlags flags
)
2543 ObjectPropertyAccessor
*getter
= NULL
;
2544 ObjectPropertyAccessor
*setter
= NULL
;
2546 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2547 getter
= property_get_uint16_ptr
;
2550 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2551 setter
= property_set_uint16_ptr
;
2554 return object_property_add(obj
, name
, "uint16",
2555 getter
, setter
, NULL
, (void *)v
);
2559 object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2561 ObjectPropertyFlags flags
)
2563 ObjectPropertyAccessor
*getter
= NULL
;
2564 ObjectPropertyAccessor
*setter
= NULL
;
2566 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2567 getter
= property_get_uint16_ptr
;
2570 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2571 setter
= property_set_uint16_ptr
;
2574 return object_class_property_add(klass
, name
, "uint16",
2575 getter
, setter
, NULL
, (void *)v
);
2579 object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2581 ObjectPropertyFlags flags
)
2583 ObjectPropertyAccessor
*getter
= NULL
;
2584 ObjectPropertyAccessor
*setter
= NULL
;
2586 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2587 getter
= property_get_uint32_ptr
;
2590 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2591 setter
= property_set_uint32_ptr
;
2594 return object_property_add(obj
, name
, "uint32",
2595 getter
, setter
, NULL
, (void *)v
);
2599 object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2601 ObjectPropertyFlags flags
)
2603 ObjectPropertyAccessor
*getter
= NULL
;
2604 ObjectPropertyAccessor
*setter
= NULL
;
2606 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2607 getter
= property_get_uint32_ptr
;
2610 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2611 setter
= property_set_uint32_ptr
;
2614 return object_class_property_add(klass
, name
, "uint32",
2615 getter
, setter
, NULL
, (void *)v
);
2619 object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2621 ObjectPropertyFlags flags
)
2623 ObjectPropertyAccessor
*getter
= NULL
;
2624 ObjectPropertyAccessor
*setter
= NULL
;
2626 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2627 getter
= property_get_uint64_ptr
;
2630 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2631 setter
= property_set_uint64_ptr
;
2634 return object_property_add(obj
, name
, "uint64",
2635 getter
, setter
, NULL
, (void *)v
);
2639 object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2641 ObjectPropertyFlags flags
)
2643 ObjectPropertyAccessor
*getter
= NULL
;
2644 ObjectPropertyAccessor
*setter
= NULL
;
2646 if ((flags
& OBJ_PROP_FLAG_READ
) == OBJ_PROP_FLAG_READ
) {
2647 getter
= property_get_uint64_ptr
;
2650 if ((flags
& OBJ_PROP_FLAG_WRITE
) == OBJ_PROP_FLAG_WRITE
) {
2651 setter
= property_set_uint64_ptr
;
2654 return object_class_property_add(klass
, name
, "uint64",
2655 getter
, setter
, NULL
, (void *)v
);
2663 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2664 void *opaque
, Error
**errp
)
2666 AliasProperty
*prop
= opaque
;
2668 object_property_get(prop
->target_obj
, prop
->target_name
, v
, errp
);
2671 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2672 void *opaque
, Error
**errp
)
2674 AliasProperty
*prop
= opaque
;
2676 object_property_set(prop
->target_obj
, prop
->target_name
, v
, errp
);
2679 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2682 AliasProperty
*prop
= opaque
;
2684 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2687 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2689 AliasProperty
*prop
= opaque
;
2691 g_free(prop
->target_name
);
2696 object_property_add_alias(Object
*obj
, const char *name
,
2697 Object
*target_obj
, const char *target_name
)
2699 AliasProperty
*prop
;
2701 ObjectProperty
*target_prop
;
2702 g_autofree
char *prop_type
= NULL
;
2704 target_prop
= object_property_find(target_obj
, target_name
,
2707 if (object_property_is_child(target_prop
)) {
2708 prop_type
= g_strdup_printf("link%s",
2709 target_prop
->type
+ strlen("child"));
2711 prop_type
= g_strdup(target_prop
->type
);
2714 prop
= g_malloc(sizeof(*prop
));
2715 prop
->target_obj
= target_obj
;
2716 prop
->target_name
= g_strdup(target_name
);
2718 op
= object_property_add(obj
, name
, prop_type
,
2721 property_release_alias
,
2723 op
->resolve
= property_resolve_alias
;
2724 if (target_prop
->defval
) {
2725 op
->defval
= qobject_ref(target_prop
->defval
);
2728 object_property_set_description(obj
, op
->name
,
2729 target_prop
->description
);
2733 void object_property_set_description(Object
*obj
, const char *name
,
2734 const char *description
)
2738 op
= object_property_find(obj
, name
, &error_abort
);
2739 g_free(op
->description
);
2740 op
->description
= g_strdup(description
);
2743 void object_class_property_set_description(ObjectClass
*klass
,
2745 const char *description
)
2749 op
= g_hash_table_lookup(klass
->properties
, name
);
2750 g_free(op
->description
);
2751 op
->description
= g_strdup(description
);
2754 static void object_class_init(ObjectClass
*klass
, void *data
)
2756 object_class_property_add_str(klass
, "type", object_get_type
,
2760 static void register_types(void)
2762 static TypeInfo interface_info
= {
2763 .name
= TYPE_INTERFACE
,
2764 .class_size
= sizeof(InterfaceClass
),
2768 static TypeInfo object_info
= {
2769 .name
= TYPE_OBJECT
,
2770 .instance_size
= sizeof(Object
),
2771 .class_init
= object_class_init
,
2775 type_interface
= type_register_internal(&interface_info
);
2776 type_register_internal(&object_info
);
2779 type_init(register_types
)