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/qapi-builtin-visit.h"
23 #include "qapi/qmp/qerror.h"
26 /* TODO: replace QObject with a simpler visitor to avoid a dependency
27 * of the QOM core on QObject? */
28 #include "qom/qom-qobject.h"
29 #include "qapi/qmp/qbool.h"
30 #include "qapi/qmp/qnum.h"
31 #include "qapi/qmp/qstring.h"
32 #include "qemu/error-report.h"
34 #define MAX_INTERFACES 32
36 typedef struct InterfaceImpl InterfaceImpl
;
37 typedef struct TypeImpl TypeImpl
;
52 void (*class_init
)(ObjectClass
*klass
, void *data
);
53 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
57 void (*instance_init
)(Object
*obj
);
58 void (*instance_post_init
)(Object
*obj
);
59 void (*instance_finalize
)(Object
*obj
);
64 TypeImpl
*parent_type
;
69 InterfaceImpl interfaces
[MAX_INTERFACES
];
72 static Type type_interface
;
74 static GHashTable
*type_table_get(void)
76 static GHashTable
*type_table
;
78 if (type_table
== NULL
) {
79 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
85 static bool enumerating_types
;
87 static void type_table_add(TypeImpl
*ti
)
89 assert(!enumerating_types
);
90 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
93 static TypeImpl
*type_table_lookup(const char *name
)
95 return g_hash_table_lookup(type_table_get(), name
);
98 static TypeImpl
*type_new(const TypeInfo
*info
)
100 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
103 g_assert(info
->name
!= NULL
);
105 if (type_table_lookup(info
->name
) != NULL
) {
106 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
110 ti
->name
= g_strdup(info
->name
);
111 ti
->parent
= g_strdup(info
->parent
);
113 ti
->class_size
= info
->class_size
;
114 ti
->instance_size
= info
->instance_size
;
116 ti
->class_init
= info
->class_init
;
117 ti
->class_base_init
= info
->class_base_init
;
118 ti
->class_data
= info
->class_data
;
120 ti
->instance_init
= info
->instance_init
;
121 ti
->instance_post_init
= info
->instance_post_init
;
122 ti
->instance_finalize
= info
->instance_finalize
;
124 ti
->abstract
= info
->abstract
;
126 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
127 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
129 ti
->num_interfaces
= i
;
134 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
143 TypeImpl
*type_register(const TypeInfo
*info
)
145 assert(info
->parent
);
146 return type_register_internal(info
);
149 TypeImpl
*type_register_static(const TypeInfo
*info
)
151 return type_register(info
);
154 void type_register_static_array(const TypeInfo
*infos
, int nr_infos
)
158 for (i
= 0; i
< nr_infos
; i
++) {
159 type_register_static(&infos
[i
]);
163 static TypeImpl
*type_get_by_name(const char *name
)
169 return type_table_lookup(name
);
172 static TypeImpl
*type_get_parent(TypeImpl
*type
)
174 if (!type
->parent_type
&& type
->parent
) {
175 type
->parent_type
= type_get_by_name(type
->parent
);
176 if (!type
->parent_type
) {
177 fprintf(stderr
, "Type '%s' is missing its parent '%s'\n",
178 type
->name
, type
->parent
);
183 return type
->parent_type
;
186 static bool type_has_parent(TypeImpl
*type
)
188 return (type
->parent
!= NULL
);
191 static size_t type_class_get_size(TypeImpl
*ti
)
193 if (ti
->class_size
) {
194 return ti
->class_size
;
197 if (type_has_parent(ti
)) {
198 return type_class_get_size(type_get_parent(ti
));
201 return sizeof(ObjectClass
);
204 static size_t type_object_get_size(TypeImpl
*ti
)
206 if (ti
->instance_size
) {
207 return ti
->instance_size
;
210 if (type_has_parent(ti
)) {
211 return type_object_get_size(type_get_parent(ti
));
217 size_t object_type_get_instance_size(const char *typename
)
219 TypeImpl
*type
= type_get_by_name(typename
);
221 g_assert(type
!= NULL
);
222 return type_object_get_size(type
);
225 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
229 /* Check if target_type is a direct ancestor of type */
231 if (type
== target_type
) {
235 type
= type_get_parent(type
);
241 static void type_initialize(TypeImpl
*ti
);
243 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
244 TypeImpl
*parent_type
)
246 InterfaceClass
*new_iface
;
248 TypeImpl
*iface_impl
;
250 info
.parent
= parent_type
->name
;
251 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
252 info
.abstract
= true;
254 iface_impl
= type_new(&info
);
255 iface_impl
->parent_type
= parent_type
;
256 type_initialize(iface_impl
);
257 g_free((char *)info
.name
);
259 new_iface
= (InterfaceClass
*)iface_impl
->class;
260 new_iface
->concrete_class
= ti
->class;
261 new_iface
->interface_type
= interface_type
;
263 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
267 static void object_property_free(gpointer data
)
269 ObjectProperty
*prop
= data
;
273 g_free(prop
->description
);
277 static void type_initialize(TypeImpl
*ti
)
285 ti
->class_size
= type_class_get_size(ti
);
286 ti
->instance_size
= type_object_get_size(ti
);
287 /* Any type with zero instance_size is implicitly abstract.
288 * This means interface types are all abstract.
290 if (ti
->instance_size
== 0) {
293 if (type_is_ancestor(ti
, type_interface
)) {
294 assert(ti
->instance_size
== 0);
295 assert(ti
->abstract
);
296 assert(!ti
->instance_init
);
297 assert(!ti
->instance_post_init
);
298 assert(!ti
->instance_finalize
);
299 assert(!ti
->num_interfaces
);
301 ti
->class = g_malloc0(ti
->class_size
);
303 parent
= type_get_parent(ti
);
305 type_initialize(parent
);
309 g_assert(parent
->class_size
<= ti
->class_size
);
310 g_assert(parent
->instance_size
<= ti
->instance_size
);
311 memcpy(ti
->class, parent
->class, parent
->class_size
);
312 ti
->class->interfaces
= NULL
;
313 ti
->class->properties
= g_hash_table_new_full(
314 g_str_hash
, g_str_equal
, NULL
, object_property_free
);
316 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
317 InterfaceClass
*iface
= e
->data
;
318 ObjectClass
*klass
= OBJECT_CLASS(iface
);
320 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
323 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
324 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
326 error_report("missing interface '%s' for object '%s'",
327 ti
->interfaces
[i
].typename
, parent
->name
);
330 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
331 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
333 if (type_is_ancestor(target_type
, t
)) {
342 type_initialize_interface(ti
, t
, t
);
345 ti
->class->properties
= g_hash_table_new_full(
346 g_str_hash
, g_str_equal
, NULL
, object_property_free
);
349 ti
->class->type
= ti
;
352 if (parent
->class_base_init
) {
353 parent
->class_base_init(ti
->class, ti
->class_data
);
355 parent
= type_get_parent(parent
);
358 if (ti
->class_init
) {
359 ti
->class_init(ti
->class, ti
->class_data
);
363 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
365 if (type_has_parent(ti
)) {
366 object_init_with_type(obj
, type_get_parent(ti
));
369 if (ti
->instance_init
) {
370 ti
->instance_init(obj
);
374 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
376 if (ti
->instance_post_init
) {
377 ti
->instance_post_init(obj
);
380 if (type_has_parent(ti
)) {
381 object_post_init_with_type(obj
, type_get_parent(ti
));
385 void object_apply_global_props(Object
*obj
, const GPtrArray
*props
, Error
**errp
)
393 for (i
= 0; i
< props
->len
; i
++) {
394 GlobalProperty
*p
= g_ptr_array_index(props
, i
);
397 if (object_dynamic_cast(obj
, p
->driver
) == NULL
) {
400 if (p
->optional
&& !object_property_find(obj
, p
->property
, NULL
)) {
404 object_property_parse(obj
, p
->value
, p
->property
, &err
);
406 error_prepend(&err
, "can't apply global %s.%s=%s: ",
407 p
->driver
, p
->property
, p
->value
);
409 * If errp != NULL, propagate error and return.
410 * If errp == NULL, report a warning, but keep going
411 * with the remaining globals.
414 error_propagate(errp
, err
);
417 warn_report_err(err
);
424 * Global property defaults
425 * Slot 0: accelerator's global property defaults
426 * Slot 1: machine's global property defaults
427 * Slot 2: global properties from legacy command line option
428 * Each is a GPtrArray of of GlobalProperty.
429 * Applied in order, later entries override earlier ones.
431 static GPtrArray
*object_compat_props
[3];
434 * Retrieve @GPtrArray for global property defined with options
435 * other than "-global". These are generally used for syntactic
436 * sugar and legacy command line options.
438 void object_register_sugar_prop(const char *driver
, const char *prop
, const char *value
)
441 if (!object_compat_props
[2]) {
442 object_compat_props
[2] = g_ptr_array_new();
444 g
= g_new0(GlobalProperty
, 1);
445 g
->driver
= g_strdup(driver
);
446 g
->property
= g_strdup(prop
);
447 g
->value
= g_strdup(value
);
448 g_ptr_array_add(object_compat_props
[2], g
);
452 * Set machine's global property defaults to @compat_props.
453 * May be called at most once.
455 void object_set_machine_compat_props(GPtrArray
*compat_props
)
457 assert(!object_compat_props
[1]);
458 object_compat_props
[1] = compat_props
;
462 * Set accelerator's global property defaults to @compat_props.
463 * May be called at most once.
465 void object_set_accelerator_compat_props(GPtrArray
*compat_props
)
467 assert(!object_compat_props
[0]);
468 object_compat_props
[0] = compat_props
;
471 void object_apply_compat_props(Object
*obj
)
475 for (i
= 0; i
< ARRAY_SIZE(object_compat_props
); i
++) {
476 object_apply_global_props(obj
, object_compat_props
[i
],
477 i
== 2 ? &error_fatal
: &error_abort
);
481 static void object_class_property_init_all(Object
*obj
)
483 ObjectPropertyIterator iter
;
484 ObjectProperty
*prop
;
486 object_class_property_iter_init(&iter
, object_get_class(obj
));
487 while ((prop
= object_property_iter_next(&iter
))) {
489 prop
->init(obj
, prop
);
494 static void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
498 type_initialize(type
);
500 g_assert(type
->instance_size
>= sizeof(Object
));
501 g_assert(type
->abstract
== false);
502 g_assert(size
>= type
->instance_size
);
504 memset(obj
, 0, type
->instance_size
);
505 obj
->class = type
->class;
507 object_class_property_init_all(obj
);
508 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
509 NULL
, object_property_free
);
510 object_init_with_type(obj
, type
);
511 object_post_init_with_type(obj
, type
);
514 void object_initialize(void *data
, size_t size
, const char *typename
)
516 TypeImpl
*type
= type_get_by_name(typename
);
519 error_report("missing object type '%s'", typename
);
523 object_initialize_with_type(data
, size
, type
);
526 void object_initialize_child(Object
*parentobj
, const char *propname
,
527 void *childobj
, size_t size
, const char *type
,
532 va_start(vargs
, errp
);
533 object_initialize_childv(parentobj
, propname
, childobj
, size
, type
, errp
,
538 void object_initialize_childv(Object
*parentobj
, const char *propname
,
539 void *childobj
, size_t size
, const char *type
,
540 Error
**errp
, va_list vargs
)
542 Error
*local_err
= NULL
;
546 object_initialize(childobj
, size
, type
);
547 obj
= OBJECT(childobj
);
549 object_set_propv(obj
, &local_err
, vargs
);
554 object_property_add_child(parentobj
, propname
, obj
, &local_err
);
559 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
561 user_creatable_complete(uc
, &local_err
);
563 object_unparent(obj
);
569 * Since object_property_add_child added a reference to the child object,
570 * we can drop the reference added by object_initialize(), so the child
571 * property will own the only reference to the object.
577 error_propagate(errp
, local_err
);
582 static inline bool object_property_is_child(ObjectProperty
*prop
)
584 return strstart(prop
->type
, "child<", NULL
);
587 static void object_property_del_all(Object
*obj
)
589 ObjectProperty
*prop
;
596 g_hash_table_iter_init(&iter
, obj
->properties
);
597 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
600 prop
->release(obj
, prop
->name
, prop
->opaque
);
601 prop
->release
= NULL
;
605 g_hash_table_iter_remove(&iter
);
609 g_hash_table_unref(obj
->properties
);
612 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
614 ObjectProperty
*prop
;
618 g_hash_table_iter_init(&iter
, obj
->properties
);
619 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
621 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
623 prop
->release(obj
, prop
->name
, prop
->opaque
);
624 prop
->release
= NULL
;
629 g_hash_table_iter_init(&iter
, obj
->properties
);
630 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
632 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
633 g_hash_table_iter_remove(&iter
);
639 void object_unparent(Object
*obj
)
642 object_property_del_child(obj
->parent
, obj
, NULL
);
646 static void object_deinit(Object
*obj
, TypeImpl
*type
)
648 if (type
->instance_finalize
) {
649 type
->instance_finalize(obj
);
652 if (type_has_parent(type
)) {
653 object_deinit(obj
, type_get_parent(type
));
657 static void object_finalize(void *data
)
660 TypeImpl
*ti
= obj
->class->type
;
662 object_property_del_all(obj
);
663 object_deinit(obj
, ti
);
665 g_assert(obj
->ref
== 0);
671 static Object
*object_new_with_type(Type type
)
675 g_assert(type
!= NULL
);
676 type_initialize(type
);
678 obj
= g_malloc(type
->instance_size
);
679 object_initialize_with_type(obj
, type
->instance_size
, type
);
685 Object
*object_new_with_class(ObjectClass
*klass
)
687 return object_new_with_type(klass
->type
);
690 Object
*object_new(const char *typename
)
692 TypeImpl
*ti
= type_get_by_name(typename
);
694 return object_new_with_type(ti
);
698 Object
*object_new_with_props(const char *typename
,
707 va_start(vargs
, errp
);
708 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
715 Object
*object_new_with_propv(const char *typename
,
723 Error
*local_err
= NULL
;
726 klass
= object_class_by_name(typename
);
728 error_setg(errp
, "invalid object type: %s", typename
);
732 if (object_class_is_abstract(klass
)) {
733 error_setg(errp
, "object type '%s' is abstract", typename
);
736 obj
= object_new_with_type(klass
->type
);
738 if (object_set_propv(obj
, &local_err
, vargs
) < 0) {
743 object_property_add_child(parent
, id
, obj
, &local_err
);
749 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
751 user_creatable_complete(uc
, &local_err
);
754 object_unparent(obj
);
760 object_unref(OBJECT(obj
));
764 error_propagate(errp
, local_err
);
770 int object_set_props(Object
*obj
,
777 va_start(vargs
, errp
);
778 ret
= object_set_propv(obj
, errp
, vargs
);
785 int object_set_propv(Object
*obj
,
789 const char *propname
;
790 Error
*local_err
= NULL
;
792 propname
= va_arg(vargs
, char *);
793 while (propname
!= NULL
) {
794 const char *value
= va_arg(vargs
, char *);
796 g_assert(value
!= NULL
);
797 object_property_parse(obj
, value
, propname
, &local_err
);
799 error_propagate(errp
, local_err
);
802 propname
= va_arg(vargs
, char *);
809 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
811 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
818 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
819 const char *file
, int line
, const char *func
)
821 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
822 typename
, file
, line
, func
);
824 #ifdef CONFIG_QOM_CAST_DEBUG
828 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
829 if (atomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
834 inst
= object_dynamic_cast(obj
, typename
);
837 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
838 file
, line
, func
, obj
, typename
);
844 if (obj
&& obj
== inst
) {
845 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
846 atomic_set(&obj
->class->object_cast_cache
[i
- 1],
847 atomic_read(&obj
->class->object_cast_cache
[i
]));
849 atomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
857 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
858 const char *typename
)
860 ObjectClass
*ret
= NULL
;
861 TypeImpl
*target_type
;
868 /* A simple fast path that can trigger a lot for leaf classes. */
870 if (type
->name
== typename
) {
874 target_type
= type_get_by_name(typename
);
876 /* target class type unknown, so fail the cast */
880 if (type
->class->interfaces
&&
881 type_is_ancestor(target_type
, type_interface
)) {
885 for (i
= class->interfaces
; i
; i
= i
->next
) {
886 ObjectClass
*target_class
= i
->data
;
888 if (type_is_ancestor(target_class
->type
, target_type
)) {
894 /* The match was ambiguous, don't allow a cast */
898 } else if (type_is_ancestor(type
, target_type
)) {
905 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
906 const char *typename
,
907 const char *file
, int line
,
912 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
913 typename
, file
, line
, func
);
915 #ifdef CONFIG_QOM_CAST_DEBUG
918 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
919 if (atomic_read(&class->class_cast_cache
[i
]) == typename
) {
925 if (!class || !class->interfaces
) {
930 ret
= object_class_dynamic_cast(class, typename
);
932 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
933 file
, line
, func
, class, typename
);
937 #ifdef CONFIG_QOM_CAST_DEBUG
938 if (class && ret
== class) {
939 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
940 atomic_set(&class->class_cast_cache
[i
- 1],
941 atomic_read(&class->class_cast_cache
[i
]));
943 atomic_set(&class->class_cast_cache
[i
- 1], typename
);
950 const char *object_get_typename(const Object
*obj
)
952 return obj
->class->type
->name
;
955 ObjectClass
*object_get_class(Object
*obj
)
960 bool object_class_is_abstract(ObjectClass
*klass
)
962 return klass
->type
->abstract
;
965 const char *object_class_get_name(ObjectClass
*klass
)
967 return klass
->type
->name
;
970 ObjectClass
*object_class_by_name(const char *typename
)
972 TypeImpl
*type
= type_get_by_name(typename
);
978 type_initialize(type
);
983 ObjectClass
*object_class_get_parent(ObjectClass
*class)
985 TypeImpl
*type
= type_get_parent(class->type
);
991 type_initialize(type
);
996 typedef struct OCFData
998 void (*fn
)(ObjectClass
*klass
, void *opaque
);
999 const char *implements_type
;
1000 bool include_abstract
;
1004 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
1007 OCFData
*data
= opaque
;
1008 TypeImpl
*type
= value
;
1011 type_initialize(type
);
1014 if (!data
->include_abstract
&& type
->abstract
) {
1018 if (data
->implements_type
&&
1019 !object_class_dynamic_cast(k
, data
->implements_type
)) {
1023 data
->fn(k
, data
->opaque
);
1026 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
1027 const char *implements_type
, bool include_abstract
,
1030 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
1032 enumerating_types
= true;
1033 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
1034 enumerating_types
= false;
1037 static int do_object_child_foreach(Object
*obj
,
1038 int (*fn
)(Object
*child
, void *opaque
),
1039 void *opaque
, bool recurse
)
1041 GHashTableIter iter
;
1042 ObjectProperty
*prop
;
1045 g_hash_table_iter_init(&iter
, obj
->properties
);
1046 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1047 if (object_property_is_child(prop
)) {
1048 Object
*child
= prop
->opaque
;
1050 ret
= fn(child
, opaque
);
1055 do_object_child_foreach(child
, fn
, opaque
, true);
1062 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
1065 return do_object_child_foreach(obj
, fn
, opaque
, false);
1068 int object_child_foreach_recursive(Object
*obj
,
1069 int (*fn
)(Object
*child
, void *opaque
),
1072 return do_object_child_foreach(obj
, fn
, opaque
, true);
1075 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
1077 GSList
**list
= opaque
;
1079 *list
= g_slist_prepend(*list
, klass
);
1082 GSList
*object_class_get_list(const char *implements_type
,
1083 bool include_abstract
)
1085 GSList
*list
= NULL
;
1087 object_class_foreach(object_class_get_list_tramp
,
1088 implements_type
, include_abstract
, &list
);
1092 static gint
object_class_cmp(gconstpointer a
, gconstpointer b
)
1094 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
1095 object_class_get_name((ObjectClass
*)b
));
1098 GSList
*object_class_get_list_sorted(const char *implements_type
,
1099 bool include_abstract
)
1101 return g_slist_sort(object_class_get_list(implements_type
, include_abstract
),
1105 void object_ref(Object
*obj
)
1110 atomic_inc(&obj
->ref
);
1113 void object_unref(Object
*obj
)
1118 g_assert(obj
->ref
> 0);
1120 /* parent always holds a reference to its children */
1121 if (atomic_fetch_dec(&obj
->ref
) == 1) {
1122 object_finalize(obj
);
1127 object_property_add(Object
*obj
, const char *name
, const char *type
,
1128 ObjectPropertyAccessor
*get
,
1129 ObjectPropertyAccessor
*set
,
1130 ObjectPropertyRelease
*release
,
1131 void *opaque
, Error
**errp
)
1133 ObjectProperty
*prop
;
1134 size_t name_len
= strlen(name
);
1136 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
1138 ObjectProperty
*ret
;
1139 char *name_no_array
= g_strdup(name
);
1141 name_no_array
[name_len
- 3] = '\0';
1142 for (i
= 0; ; ++i
) {
1143 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
1145 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
1146 release
, opaque
, NULL
);
1152 g_free(name_no_array
);
1156 if (object_property_find(obj
, name
, NULL
) != NULL
) {
1157 error_setg(errp
, "attempt to add duplicate property '%s' to object (type '%s')",
1158 name
, object_get_typename(obj
));
1162 prop
= g_malloc0(sizeof(*prop
));
1164 prop
->name
= g_strdup(name
);
1165 prop
->type
= g_strdup(type
);
1169 prop
->release
= release
;
1170 prop
->opaque
= opaque
;
1172 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
1177 object_class_property_add(ObjectClass
*klass
,
1180 ObjectPropertyAccessor
*get
,
1181 ObjectPropertyAccessor
*set
,
1182 ObjectPropertyRelease
*release
,
1186 ObjectProperty
*prop
;
1188 if (object_class_property_find(klass
, name
, NULL
) != NULL
) {
1189 error_setg(errp
, "attempt to add duplicate property '%s' to class (type '%s')",
1190 name
, object_class_get_name(klass
));
1194 prop
= g_malloc0(sizeof(*prop
));
1196 prop
->name
= g_strdup(name
);
1197 prop
->type
= g_strdup(type
);
1201 prop
->release
= release
;
1202 prop
->opaque
= opaque
;
1204 g_hash_table_insert(klass
->properties
, prop
->name
, prop
);
1209 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
1212 ObjectProperty
*prop
;
1213 ObjectClass
*klass
= object_get_class(obj
);
1215 prop
= object_class_property_find(klass
, name
, NULL
);
1220 prop
= g_hash_table_lookup(obj
->properties
, name
);
1225 error_setg(errp
, "Property '.%s' not found", name
);
1229 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1232 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1233 iter
->nextclass
= object_get_class(obj
);
1236 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1239 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1240 if (!iter
->nextclass
) {
1243 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1244 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1249 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1252 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1253 iter
->nextclass
= object_class_get_parent(klass
);
1256 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
,
1259 ObjectProperty
*prop
;
1260 ObjectClass
*parent_klass
;
1262 parent_klass
= object_class_get_parent(klass
);
1264 prop
= object_class_property_find(parent_klass
, name
, NULL
);
1270 prop
= g_hash_table_lookup(klass
->properties
, name
);
1272 error_setg(errp
, "Property '.%s' not found", name
);
1277 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
1279 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1282 error_setg(errp
, "Property '.%s' not found", name
);
1286 if (prop
->release
) {
1287 prop
->release(obj
, name
, prop
->opaque
);
1289 g_hash_table_remove(obj
->properties
, name
);
1292 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
1295 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1301 error_setg(errp
, QERR_PERMISSION_DENIED
);
1303 prop
->get(obj
, v
, name
, prop
->opaque
, errp
);
1307 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
1310 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1316 error_setg(errp
, QERR_PERMISSION_DENIED
);
1318 prop
->set(obj
, v
, name
, prop
->opaque
, errp
);
1322 void object_property_set_str(Object
*obj
, const char *value
,
1323 const char *name
, Error
**errp
)
1325 QString
*qstr
= qstring_from_str(value
);
1326 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
1328 qobject_unref(qstr
);
1331 char *object_property_get_str(Object
*obj
, const char *name
,
1334 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1341 retval
= g_strdup(qobject_get_try_str(ret
));
1343 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1350 void object_property_set_link(Object
*obj
, Object
*value
,
1351 const char *name
, Error
**errp
)
1354 gchar
*path
= object_get_canonical_path(value
);
1355 object_property_set_str(obj
, path
, name
, errp
);
1358 object_property_set_str(obj
, "", name
, errp
);
1362 Object
*object_property_get_link(Object
*obj
, const char *name
,
1365 char *str
= object_property_get_str(obj
, name
, errp
);
1366 Object
*target
= NULL
;
1369 target
= object_resolve_path(str
, NULL
);
1371 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1372 "Device '%s' not found", str
);
1380 void object_property_set_bool(Object
*obj
, bool value
,
1381 const char *name
, Error
**errp
)
1383 QBool
*qbool
= qbool_from_bool(value
);
1384 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
1386 qobject_unref(qbool
);
1389 bool object_property_get_bool(Object
*obj
, const char *name
,
1392 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1399 qbool
= qobject_to(QBool
, ret
);
1401 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1404 retval
= qbool_get_bool(qbool
);
1411 void object_property_set_int(Object
*obj
, int64_t value
,
1412 const char *name
, Error
**errp
)
1414 QNum
*qnum
= qnum_from_int(value
);
1415 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1417 qobject_unref(qnum
);
1420 int64_t object_property_get_int(Object
*obj
, const char *name
,
1423 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1431 qnum
= qobject_to(QNum
, ret
);
1432 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1433 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1441 void object_property_set_uint(Object
*obj
, uint64_t value
,
1442 const char *name
, Error
**errp
)
1444 QNum
*qnum
= qnum_from_uint(value
);
1446 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1447 qobject_unref(qnum
);
1450 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1453 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1460 qnum
= qobject_to(QNum
, ret
);
1461 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1462 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "uint");
1470 typedef struct EnumProperty
{
1471 const QEnumLookup
*lookup
;
1472 int (*get
)(Object
*, Error
**);
1473 void (*set
)(Object
*, int, Error
**);
1476 int object_property_get_enum(Object
*obj
, const char *name
,
1477 const char *typename
, Error
**errp
)
1483 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1484 EnumProperty
*enumprop
;
1490 if (!g_str_equal(prop
->type
, typename
)) {
1491 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1492 name
, object_class_get_name(
1493 object_get_class(obj
)), typename
);
1497 enumprop
= prop
->opaque
;
1499 v
= string_output_visitor_new(false, &str
);
1500 object_property_get(obj
, v
, name
, &err
);
1502 error_propagate(errp
, err
);
1506 visit_complete(v
, &str
);
1508 v
= string_input_visitor_new(str
);
1509 visit_type_enum(v
, name
, &ret
, enumprop
->lookup
, errp
);
1517 void object_property_get_uint16List(Object
*obj
, const char *name
,
1518 uint16List
**list
, Error
**errp
)
1524 v
= string_output_visitor_new(false, &str
);
1525 object_property_get(obj
, v
, name
, &err
);
1527 error_propagate(errp
, err
);
1530 visit_complete(v
, &str
);
1532 v
= string_input_visitor_new(str
);
1533 visit_type_uint16List(v
, NULL
, list
, errp
);
1540 void object_property_parse(Object
*obj
, const char *string
,
1541 const char *name
, Error
**errp
)
1543 Visitor
*v
= string_input_visitor_new(string
);
1544 object_property_set(obj
, v
, name
, errp
);
1548 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1552 char *string
= NULL
;
1553 Error
*local_err
= NULL
;
1555 v
= string_output_visitor_new(human
, &string
);
1556 object_property_get(obj
, v
, name
, &local_err
);
1558 error_propagate(errp
, local_err
);
1562 visit_complete(v
, &string
);
1569 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1571 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1579 Object
*object_get_root(void)
1581 static Object
*root
;
1584 root
= object_new("container");
1590 Object
*object_get_objects_root(void)
1592 return container_get(object_get_root(), "/objects");
1595 Object
*object_get_internal_root(void)
1597 static Object
*internal_root
;
1599 if (!internal_root
) {
1600 internal_root
= object_new("container");
1603 return internal_root
;
1606 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1607 const char *name
, void *opaque
,
1610 Object
*child
= opaque
;
1613 path
= object_get_canonical_path(child
);
1614 visit_type_str(v
, name
, &path
, errp
);
1618 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1623 static void object_finalize_child_property(Object
*obj
, const char *name
,
1626 Object
*child
= opaque
;
1628 if (child
->class->unparent
) {
1629 (child
->class->unparent
)(child
);
1631 child
->parent
= NULL
;
1632 object_unref(child
);
1635 void object_property_add_child(Object
*obj
, const char *name
,
1636 Object
*child
, Error
**errp
)
1638 Error
*local_err
= NULL
;
1642 if (child
->parent
!= NULL
) {
1643 error_setg(errp
, "child object is already parented");
1647 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1649 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1650 object_finalize_child_property
, child
, &local_err
);
1652 error_propagate(errp
, local_err
);
1656 op
->resolve
= object_resolve_child_property
;
1658 child
->parent
= obj
;
1664 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1665 Object
*val
, Error
**errp
)
1667 /* Allow the link to be set, always */
1672 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1673 ObjectPropertyLinkFlags flags
;
1676 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1677 const char *name
, void *opaque
,
1680 LinkProperty
*lprop
= opaque
;
1681 Object
**child
= lprop
->child
;
1685 path
= object_get_canonical_path(*child
);
1686 visit_type_str(v
, name
, &path
, errp
);
1690 visit_type_str(v
, name
, &path
, errp
);
1695 * object_resolve_link:
1697 * Lookup an object and ensure its type matches the link property type. This
1698 * is similar to object_resolve_path() except type verification against the
1699 * link property is performed.
1701 * Returns: The matched object or NULL on path lookup failures.
1703 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1704 const char *path
, Error
**errp
)
1708 bool ambiguous
= false;
1711 /* Go from link<FOO> to FOO. */
1712 type
= object_property_get_type(obj
, name
, NULL
);
1713 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1714 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1717 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1719 } else if (!target
) {
1720 target
= object_resolve_path(path
, &ambiguous
);
1721 if (target
|| ambiguous
) {
1722 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1724 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1725 "Device '%s' not found", path
);
1729 g_free(target_type
);
1734 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1735 const char *name
, void *opaque
,
1738 Error
*local_err
= NULL
;
1739 LinkProperty
*prop
= opaque
;
1740 Object
**child
= prop
->child
;
1741 Object
*old_target
= *child
;
1742 Object
*new_target
= NULL
;
1745 visit_type_str(v
, name
, &path
, &local_err
);
1747 if (!local_err
&& strcmp(path
, "") != 0) {
1748 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1753 error_propagate(errp
, local_err
);
1757 prop
->check(obj
, name
, new_target
, &local_err
);
1759 error_propagate(errp
, local_err
);
1763 *child
= new_target
;
1764 if (prop
->flags
== OBJ_PROP_LINK_STRONG
) {
1765 object_ref(new_target
);
1766 object_unref(old_target
);
1770 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1772 LinkProperty
*lprop
= opaque
;
1774 return *lprop
->child
;
1777 static void object_release_link_property(Object
*obj
, const char *name
,
1780 LinkProperty
*prop
= opaque
;
1782 if ((prop
->flags
& OBJ_PROP_LINK_STRONG
) && *prop
->child
) {
1783 object_unref(*prop
->child
);
1788 void object_property_add_link(Object
*obj
, const char *name
,
1789 const char *type
, Object
**child
,
1790 void (*check
)(const Object
*, const char *,
1791 Object
*, Error
**),
1792 ObjectPropertyLinkFlags flags
,
1795 Error
*local_err
= NULL
;
1796 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1800 prop
->child
= child
;
1801 prop
->check
= check
;
1802 prop
->flags
= flags
;
1804 full_type
= g_strdup_printf("link<%s>", type
);
1806 op
= object_property_add(obj
, name
, full_type
,
1807 object_get_link_property
,
1808 check
? object_set_link_property
: NULL
,
1809 object_release_link_property
,
1813 error_propagate(errp
, local_err
);
1818 op
->resolve
= object_resolve_link_property
;
1824 void object_property_add_const_link(Object
*obj
, const char *name
,
1825 Object
*target
, Error
**errp
)
1830 link_type
= g_strdup_printf("link<%s>", object_get_typename(target
));
1831 op
= object_property_add(obj
, name
, link_type
,
1832 object_get_child_property
, NULL
,
1833 NULL
, target
, errp
);
1835 op
->resolve
= object_resolve_child_property
;
1840 gchar
*object_get_canonical_path_component(Object
*obj
)
1842 ObjectProperty
*prop
= NULL
;
1843 GHashTableIter iter
;
1845 if (obj
->parent
== NULL
) {
1849 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
1850 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1851 if (!object_property_is_child(prop
)) {
1855 if (prop
->opaque
== obj
) {
1856 return g_strdup(prop
->name
);
1860 /* obj had a parent but was not a child, should never happen */
1861 g_assert_not_reached();
1865 gchar
*object_get_canonical_path(Object
*obj
)
1867 Object
*root
= object_get_root();
1868 char *newpath
, *path
= NULL
;
1871 return g_strdup("/");
1875 char *component
= object_get_canonical_path_component(obj
);
1878 /* A canonical path must be complete, so discard what was
1885 newpath
= g_strdup_printf("/%s%s", component
, path
? path
: "");
1890 } while (obj
!= root
);
1895 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
1897 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1902 if (prop
->resolve
) {
1903 return prop
->resolve(parent
, prop
->opaque
, part
);
1909 static Object
*object_resolve_abs_path(Object
*parent
,
1911 const char *typename
,
1916 if (parts
[index
] == NULL
) {
1917 return object_dynamic_cast(parent
, typename
);
1920 if (strcmp(parts
[index
], "") == 0) {
1921 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
1924 child
= object_resolve_path_component(parent
, parts
[index
]);
1929 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
1932 static Object
*object_resolve_partial_path(Object
*parent
,
1934 const char *typename
,
1938 GHashTableIter iter
;
1939 ObjectProperty
*prop
;
1941 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
1943 g_hash_table_iter_init(&iter
, parent
->properties
);
1944 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1947 if (!object_property_is_child(prop
)) {
1951 found
= object_resolve_partial_path(prop
->opaque
, parts
,
1952 typename
, ambiguous
);
1969 Object
*object_resolve_path_type(const char *path
, const char *typename
,
1975 parts
= g_strsplit(path
, "/", 0);
1978 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
1979 bool ambiguous
= false;
1980 obj
= object_resolve_partial_path(object_get_root(), parts
,
1981 typename
, &ambiguous
);
1983 *ambiguousp
= ambiguous
;
1986 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
1994 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
1996 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
1999 typedef struct StringProperty
2001 char *(*get
)(Object
*, Error
**);
2002 void (*set
)(Object
*, const char *, Error
**);
2005 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
2006 void *opaque
, Error
**errp
)
2008 StringProperty
*prop
= opaque
;
2012 value
= prop
->get(obj
, &err
);
2014 error_propagate(errp
, err
);
2018 visit_type_str(v
, name
, &value
, errp
);
2022 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
2023 void *opaque
, Error
**errp
)
2025 StringProperty
*prop
= opaque
;
2027 Error
*local_err
= NULL
;
2029 visit_type_str(v
, name
, &value
, &local_err
);
2031 error_propagate(errp
, local_err
);
2035 prop
->set(obj
, value
, errp
);
2039 static void property_release_str(Object
*obj
, const char *name
,
2042 StringProperty
*prop
= opaque
;
2046 void object_property_add_str(Object
*obj
, const char *name
,
2047 char *(*get
)(Object
*, Error
**),
2048 void (*set
)(Object
*, const char *, Error
**),
2051 Error
*local_err
= NULL
;
2052 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2057 object_property_add(obj
, name
, "string",
2058 get
? property_get_str
: NULL
,
2059 set
? property_set_str
: NULL
,
2060 property_release_str
,
2063 error_propagate(errp
, local_err
);
2068 void object_class_property_add_str(ObjectClass
*klass
, const char *name
,
2069 char *(*get
)(Object
*, Error
**),
2070 void (*set
)(Object
*, const char *,
2074 Error
*local_err
= NULL
;
2075 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2080 object_class_property_add(klass
, name
, "string",
2081 get
? property_get_str
: NULL
,
2082 set
? property_set_str
: NULL
,
2083 property_release_str
,
2086 error_propagate(errp
, local_err
);
2091 typedef struct BoolProperty
2093 bool (*get
)(Object
*, Error
**);
2094 void (*set
)(Object
*, bool, Error
**);
2097 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
2098 void *opaque
, Error
**errp
)
2100 BoolProperty
*prop
= opaque
;
2104 value
= prop
->get(obj
, &err
);
2106 error_propagate(errp
, err
);
2110 visit_type_bool(v
, name
, &value
, errp
);
2113 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
2114 void *opaque
, Error
**errp
)
2116 BoolProperty
*prop
= opaque
;
2118 Error
*local_err
= NULL
;
2120 visit_type_bool(v
, name
, &value
, &local_err
);
2122 error_propagate(errp
, local_err
);
2126 prop
->set(obj
, value
, errp
);
2129 static void property_release_bool(Object
*obj
, const char *name
,
2132 BoolProperty
*prop
= opaque
;
2136 void object_property_add_bool(Object
*obj
, const char *name
,
2137 bool (*get
)(Object
*, Error
**),
2138 void (*set
)(Object
*, bool, Error
**),
2141 Error
*local_err
= NULL
;
2142 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2147 object_property_add(obj
, name
, "bool",
2148 get
? property_get_bool
: NULL
,
2149 set
? property_set_bool
: NULL
,
2150 property_release_bool
,
2153 error_propagate(errp
, local_err
);
2158 void object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
2159 bool (*get
)(Object
*, Error
**),
2160 void (*set
)(Object
*, bool, Error
**),
2163 Error
*local_err
= NULL
;
2164 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2169 object_class_property_add(klass
, name
, "bool",
2170 get
? property_get_bool
: NULL
,
2171 set
? property_set_bool
: NULL
,
2172 property_release_bool
,
2175 error_propagate(errp
, local_err
);
2180 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
2181 void *opaque
, Error
**errp
)
2183 EnumProperty
*prop
= opaque
;
2187 value
= prop
->get(obj
, &err
);
2189 error_propagate(errp
, err
);
2193 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
2196 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
2197 void *opaque
, Error
**errp
)
2199 EnumProperty
*prop
= opaque
;
2203 visit_type_enum(v
, name
, &value
, prop
->lookup
, &err
);
2205 error_propagate(errp
, err
);
2208 prop
->set(obj
, value
, errp
);
2211 static void property_release_enum(Object
*obj
, const char *name
,
2214 EnumProperty
*prop
= opaque
;
2218 void object_property_add_enum(Object
*obj
, const char *name
,
2219 const char *typename
,
2220 const QEnumLookup
*lookup
,
2221 int (*get
)(Object
*, Error
**),
2222 void (*set
)(Object
*, int, Error
**),
2225 Error
*local_err
= NULL
;
2226 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2228 prop
->lookup
= lookup
;
2232 object_property_add(obj
, name
, typename
,
2233 get
? property_get_enum
: NULL
,
2234 set
? property_set_enum
: NULL
,
2235 property_release_enum
,
2238 error_propagate(errp
, local_err
);
2243 void object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2244 const char *typename
,
2245 const QEnumLookup
*lookup
,
2246 int (*get
)(Object
*, Error
**),
2247 void (*set
)(Object
*, int, Error
**),
2250 Error
*local_err
= NULL
;
2251 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2253 prop
->lookup
= lookup
;
2257 object_class_property_add(klass
, name
, typename
,
2258 get
? property_get_enum
: NULL
,
2259 set
? property_set_enum
: NULL
,
2260 property_release_enum
,
2263 error_propagate(errp
, local_err
);
2268 typedef struct TMProperty
{
2269 void (*get
)(Object
*, struct tm
*, Error
**);
2272 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2273 void *opaque
, Error
**errp
)
2275 TMProperty
*prop
= opaque
;
2279 prop
->get(obj
, &value
, &err
);
2284 visit_start_struct(v
, name
, NULL
, 0, &err
);
2288 visit_type_int32(v
, "tm_year", &value
.tm_year
, &err
);
2292 visit_type_int32(v
, "tm_mon", &value
.tm_mon
, &err
);
2296 visit_type_int32(v
, "tm_mday", &value
.tm_mday
, &err
);
2300 visit_type_int32(v
, "tm_hour", &value
.tm_hour
, &err
);
2304 visit_type_int32(v
, "tm_min", &value
.tm_min
, &err
);
2308 visit_type_int32(v
, "tm_sec", &value
.tm_sec
, &err
);
2312 visit_check_struct(v
, &err
);
2314 visit_end_struct(v
, NULL
);
2316 error_propagate(errp
, err
);
2320 static void property_release_tm(Object
*obj
, const char *name
,
2323 TMProperty
*prop
= opaque
;
2327 void object_property_add_tm(Object
*obj
, const char *name
,
2328 void (*get
)(Object
*, struct tm
*, Error
**),
2331 Error
*local_err
= NULL
;
2332 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2336 object_property_add(obj
, name
, "struct tm",
2337 get
? property_get_tm
: NULL
, NULL
,
2338 property_release_tm
,
2341 error_propagate(errp
, local_err
);
2346 void object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2347 void (*get
)(Object
*, struct tm
*, Error
**),
2350 Error
*local_err
= NULL
;
2351 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2355 object_class_property_add(klass
, name
, "struct tm",
2356 get
? property_get_tm
: NULL
, NULL
,
2357 property_release_tm
,
2360 error_propagate(errp
, local_err
);
2365 static char *qdev_get_type(Object
*obj
, Error
**errp
)
2367 return g_strdup(object_get_typename(obj
));
2370 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2371 void *opaque
, Error
**errp
)
2373 uint8_t value
= *(uint8_t *)opaque
;
2374 visit_type_uint8(v
, name
, &value
, errp
);
2377 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2378 void *opaque
, Error
**errp
)
2380 uint16_t value
= *(uint16_t *)opaque
;
2381 visit_type_uint16(v
, name
, &value
, errp
);
2384 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2385 void *opaque
, Error
**errp
)
2387 uint32_t value
= *(uint32_t *)opaque
;
2388 visit_type_uint32(v
, name
, &value
, errp
);
2391 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2392 void *opaque
, Error
**errp
)
2394 uint64_t value
= *(uint64_t *)opaque
;
2395 visit_type_uint64(v
, name
, &value
, errp
);
2398 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2399 const uint8_t *v
, Error
**errp
)
2401 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
2402 NULL
, NULL
, (void *)v
, errp
);
2405 void object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2406 const uint8_t *v
, Error
**errp
)
2408 object_class_property_add(klass
, name
, "uint8", property_get_uint8_ptr
,
2409 NULL
, NULL
, (void *)v
, errp
);
2412 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2413 const uint16_t *v
, Error
**errp
)
2415 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
2416 NULL
, NULL
, (void *)v
, errp
);
2419 void object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2420 const uint16_t *v
, Error
**errp
)
2422 object_class_property_add(klass
, name
, "uint16", property_get_uint16_ptr
,
2423 NULL
, NULL
, (void *)v
, errp
);
2426 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2427 const uint32_t *v
, Error
**errp
)
2429 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
2430 NULL
, NULL
, (void *)v
, errp
);
2433 void object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2434 const uint32_t *v
, Error
**errp
)
2436 object_class_property_add(klass
, name
, "uint32", property_get_uint32_ptr
,
2437 NULL
, NULL
, (void *)v
, errp
);
2440 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2441 const uint64_t *v
, Error
**errp
)
2443 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
2444 NULL
, NULL
, (void *)v
, errp
);
2447 void object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2448 const uint64_t *v
, Error
**errp
)
2450 object_class_property_add(klass
, name
, "uint64", property_get_uint64_ptr
,
2451 NULL
, NULL
, (void *)v
, errp
);
2459 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2460 void *opaque
, Error
**errp
)
2462 AliasProperty
*prop
= opaque
;
2464 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
2467 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2468 void *opaque
, Error
**errp
)
2470 AliasProperty
*prop
= opaque
;
2472 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
2475 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2478 AliasProperty
*prop
= opaque
;
2480 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2483 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2485 AliasProperty
*prop
= opaque
;
2487 g_free(prop
->target_name
);
2491 void object_property_add_alias(Object
*obj
, const char *name
,
2492 Object
*target_obj
, const char *target_name
,
2495 AliasProperty
*prop
;
2497 ObjectProperty
*target_prop
;
2499 Error
*local_err
= NULL
;
2501 target_prop
= object_property_find(target_obj
, target_name
, errp
);
2506 if (object_property_is_child(target_prop
)) {
2507 prop_type
= g_strdup_printf("link%s",
2508 target_prop
->type
+ strlen("child"));
2510 prop_type
= g_strdup(target_prop
->type
);
2513 prop
= g_malloc(sizeof(*prop
));
2514 prop
->target_obj
= target_obj
;
2515 prop
->target_name
= g_strdup(target_name
);
2517 op
= object_property_add(obj
, name
, prop_type
,
2520 property_release_alias
,
2523 error_propagate(errp
, local_err
);
2527 op
->resolve
= property_resolve_alias
;
2529 object_property_set_description(obj
, op
->name
,
2530 target_prop
->description
,
2537 void object_property_set_description(Object
*obj
, const char *name
,
2538 const char *description
, Error
**errp
)
2542 op
= object_property_find(obj
, name
, errp
);
2547 g_free(op
->description
);
2548 op
->description
= g_strdup(description
);
2551 void object_class_property_set_description(ObjectClass
*klass
,
2553 const char *description
,
2558 op
= g_hash_table_lookup(klass
->properties
, name
);
2560 error_setg(errp
, "Property '.%s' not found", name
);
2564 g_free(op
->description
);
2565 op
->description
= g_strdup(description
);
2568 static void object_class_init(ObjectClass
*klass
, void *data
)
2570 object_class_property_add_str(klass
, "type", qdev_get_type
,
2571 NULL
, &error_abort
);
2574 static void register_types(void)
2576 static TypeInfo interface_info
= {
2577 .name
= TYPE_INTERFACE
,
2578 .class_size
= sizeof(InterfaceClass
),
2582 static TypeInfo object_info
= {
2583 .name
= TYPE_OBJECT
,
2584 .instance_size
= sizeof(Object
),
2585 .class_init
= object_class_init
,
2589 type_interface
= type_register_internal(&interface_info
);
2590 type_register_internal(&object_info
);
2593 type_init(register_types
)