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 "qapi/error.h"
15 #include "qom/object.h"
16 #include "qom/object_interfaces.h"
17 #include "qemu/cutils.h"
18 #include "qapi/visitor.h"
19 #include "qapi/string-input-visitor.h"
20 #include "qapi/string-output-visitor.h"
21 #include "qapi/qapi-builtin-visit.h"
22 #include "qapi/qmp/qerror.h"
25 /* TODO: replace QObject with a simpler visitor to avoid a dependency
26 * of the QOM core on QObject? */
27 #include "qom/qom-qobject.h"
28 #include "qapi/qmp/qbool.h"
29 #include "qapi/qmp/qnum.h"
30 #include "qapi/qmp/qstring.h"
32 #define MAX_INTERFACES 32
34 typedef struct InterfaceImpl InterfaceImpl
;
35 typedef struct TypeImpl TypeImpl
;
50 void (*class_init
)(ObjectClass
*klass
, void *data
);
51 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
55 void (*instance_init
)(Object
*obj
);
56 void (*instance_post_init
)(Object
*obj
);
57 void (*instance_finalize
)(Object
*obj
);
62 TypeImpl
*parent_type
;
67 InterfaceImpl interfaces
[MAX_INTERFACES
];
70 static Type type_interface
;
72 static GHashTable
*type_table_get(void)
74 static GHashTable
*type_table
;
76 if (type_table
== NULL
) {
77 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
83 static bool enumerating_types
;
85 static void type_table_add(TypeImpl
*ti
)
87 assert(!enumerating_types
);
88 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
91 static TypeImpl
*type_table_lookup(const char *name
)
93 return g_hash_table_lookup(type_table_get(), name
);
96 static TypeImpl
*type_new(const TypeInfo
*info
)
98 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
101 g_assert(info
->name
!= NULL
);
103 if (type_table_lookup(info
->name
) != NULL
) {
104 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
108 ti
->name
= g_strdup(info
->name
);
109 ti
->parent
= g_strdup(info
->parent
);
111 ti
->class_size
= info
->class_size
;
112 ti
->instance_size
= info
->instance_size
;
114 ti
->class_init
= info
->class_init
;
115 ti
->class_base_init
= info
->class_base_init
;
116 ti
->class_data
= info
->class_data
;
118 ti
->instance_init
= info
->instance_init
;
119 ti
->instance_post_init
= info
->instance_post_init
;
120 ti
->instance_finalize
= info
->instance_finalize
;
122 ti
->abstract
= info
->abstract
;
124 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
125 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
127 ti
->num_interfaces
= i
;
132 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
141 TypeImpl
*type_register(const TypeInfo
*info
)
143 assert(info
->parent
);
144 return type_register_internal(info
);
147 TypeImpl
*type_register_static(const TypeInfo
*info
)
149 return type_register(info
);
152 void type_register_static_array(const TypeInfo
*infos
, int nr_infos
)
156 for (i
= 0; i
< nr_infos
; i
++) {
157 type_register_static(&infos
[i
]);
161 static TypeImpl
*type_get_by_name(const char *name
)
167 return type_table_lookup(name
);
170 static TypeImpl
*type_get_parent(TypeImpl
*type
)
172 if (!type
->parent_type
&& type
->parent
) {
173 type
->parent_type
= type_get_by_name(type
->parent
);
174 g_assert(type
->parent_type
!= NULL
);
177 return type
->parent_type
;
180 static bool type_has_parent(TypeImpl
*type
)
182 return (type
->parent
!= NULL
);
185 static size_t type_class_get_size(TypeImpl
*ti
)
187 if (ti
->class_size
) {
188 return ti
->class_size
;
191 if (type_has_parent(ti
)) {
192 return type_class_get_size(type_get_parent(ti
));
195 return sizeof(ObjectClass
);
198 static size_t type_object_get_size(TypeImpl
*ti
)
200 if (ti
->instance_size
) {
201 return ti
->instance_size
;
204 if (type_has_parent(ti
)) {
205 return type_object_get_size(type_get_parent(ti
));
211 size_t object_type_get_instance_size(const char *typename
)
213 TypeImpl
*type
= type_get_by_name(typename
);
215 g_assert(type
!= NULL
);
216 return type_object_get_size(type
);
219 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
223 /* Check if target_type is a direct ancestor of type */
225 if (type
== target_type
) {
229 type
= type_get_parent(type
);
235 static void type_initialize(TypeImpl
*ti
);
237 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
238 TypeImpl
*parent_type
)
240 InterfaceClass
*new_iface
;
242 TypeImpl
*iface_impl
;
244 info
.parent
= parent_type
->name
;
245 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
246 info
.abstract
= true;
248 iface_impl
= type_new(&info
);
249 iface_impl
->parent_type
= parent_type
;
250 type_initialize(iface_impl
);
251 g_free((char *)info
.name
);
253 new_iface
= (InterfaceClass
*)iface_impl
->class;
254 new_iface
->concrete_class
= ti
->class;
255 new_iface
->interface_type
= interface_type
;
257 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
261 static void object_property_free(gpointer data
)
263 ObjectProperty
*prop
= data
;
267 g_free(prop
->description
);
271 static void type_initialize(TypeImpl
*ti
)
279 ti
->class_size
= type_class_get_size(ti
);
280 ti
->instance_size
= type_object_get_size(ti
);
281 /* Any type with zero instance_size is implicitly abstract.
282 * This means interface types are all abstract.
284 if (ti
->instance_size
== 0) {
287 if (type_is_ancestor(ti
, type_interface
)) {
288 assert(ti
->instance_size
== 0);
289 assert(ti
->abstract
);
290 assert(!ti
->instance_init
);
291 assert(!ti
->instance_post_init
);
292 assert(!ti
->instance_finalize
);
293 assert(!ti
->num_interfaces
);
295 ti
->class = g_malloc0(ti
->class_size
);
297 parent
= type_get_parent(ti
);
299 type_initialize(parent
);
303 g_assert(parent
->class_size
<= ti
->class_size
);
304 memcpy(ti
->class, parent
->class, parent
->class_size
);
305 ti
->class->interfaces
= NULL
;
306 ti
->class->properties
= g_hash_table_new_full(
307 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
309 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
310 InterfaceClass
*iface
= e
->data
;
311 ObjectClass
*klass
= OBJECT_CLASS(iface
);
313 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
316 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
317 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
318 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
319 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
321 if (type_is_ancestor(target_type
, t
)) {
330 type_initialize_interface(ti
, t
, t
);
333 ti
->class->properties
= g_hash_table_new_full(
334 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
337 ti
->class->type
= ti
;
340 if (parent
->class_base_init
) {
341 parent
->class_base_init(ti
->class, ti
->class_data
);
343 parent
= type_get_parent(parent
);
346 if (ti
->class_init
) {
347 ti
->class_init(ti
->class, ti
->class_data
);
351 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
353 if (type_has_parent(ti
)) {
354 object_init_with_type(obj
, type_get_parent(ti
));
357 if (ti
->instance_init
) {
358 ti
->instance_init(obj
);
362 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
364 if (ti
->instance_post_init
) {
365 ti
->instance_post_init(obj
);
368 if (type_has_parent(ti
)) {
369 object_post_init_with_type(obj
, type_get_parent(ti
));
373 static void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
377 g_assert(type
!= NULL
);
378 type_initialize(type
);
380 g_assert(type
->instance_size
>= sizeof(Object
));
381 g_assert(type
->abstract
== false);
382 g_assert(size
>= type
->instance_size
);
384 memset(obj
, 0, type
->instance_size
);
385 obj
->class = type
->class;
387 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
388 NULL
, object_property_free
);
389 object_init_with_type(obj
, type
);
390 object_post_init_with_type(obj
, type
);
393 void object_initialize(void *data
, size_t size
, const char *typename
)
395 TypeImpl
*type
= type_get_by_name(typename
);
397 object_initialize_with_type(data
, size
, type
);
400 void object_initialize_child(Object
*parentobj
, const char *propname
,
401 void *childobj
, size_t size
, const char *type
,
406 va_start(vargs
, errp
);
407 object_initialize_childv(parentobj
, propname
, childobj
, size
, type
, errp
,
412 void object_initialize_childv(Object
*parentobj
, const char *propname
,
413 void *childobj
, size_t size
, const char *type
,
414 Error
**errp
, va_list vargs
)
416 Error
*local_err
= NULL
;
420 object_initialize(childobj
, size
, type
);
421 obj
= OBJECT(childobj
);
423 object_set_propv(obj
, &local_err
, vargs
);
428 object_property_add_child(parentobj
, propname
, obj
, &local_err
);
433 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
435 user_creatable_complete(uc
, &local_err
);
437 object_unparent(obj
);
443 * Since object_property_add_child added a reference to the child object,
444 * we can drop the reference added by object_initialize(), so the child
445 * property will own the only reference to the object.
451 error_propagate(errp
, local_err
);
456 static inline bool object_property_is_child(ObjectProperty
*prop
)
458 return strstart(prop
->type
, "child<", NULL
);
461 static void object_property_del_all(Object
*obj
)
463 ObjectProperty
*prop
;
470 g_hash_table_iter_init(&iter
, obj
->properties
);
471 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
474 prop
->release(obj
, prop
->name
, prop
->opaque
);
475 prop
->release
= NULL
;
479 g_hash_table_iter_remove(&iter
);
483 g_hash_table_unref(obj
->properties
);
486 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
488 ObjectProperty
*prop
;
492 g_hash_table_iter_init(&iter
, obj
->properties
);
493 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
495 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
497 prop
->release(obj
, prop
->name
, prop
->opaque
);
498 prop
->release
= NULL
;
503 g_hash_table_iter_init(&iter
, obj
->properties
);
504 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
506 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
507 g_hash_table_iter_remove(&iter
);
513 void object_unparent(Object
*obj
)
516 object_property_del_child(obj
->parent
, obj
, NULL
);
520 static void object_deinit(Object
*obj
, TypeImpl
*type
)
522 if (type
->instance_finalize
) {
523 type
->instance_finalize(obj
);
526 if (type_has_parent(type
)) {
527 object_deinit(obj
, type_get_parent(type
));
531 static void object_finalize(void *data
)
534 TypeImpl
*ti
= obj
->class->type
;
536 object_property_del_all(obj
);
537 object_deinit(obj
, ti
);
539 g_assert(obj
->ref
== 0);
545 static Object
*object_new_with_type(Type type
)
549 g_assert(type
!= NULL
);
550 type_initialize(type
);
552 obj
= g_malloc(type
->instance_size
);
553 object_initialize_with_type(obj
, type
->instance_size
, type
);
559 Object
*object_new(const char *typename
)
561 TypeImpl
*ti
= type_get_by_name(typename
);
563 return object_new_with_type(ti
);
567 Object
*object_new_with_props(const char *typename
,
576 va_start(vargs
, errp
);
577 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
584 Object
*object_new_with_propv(const char *typename
,
592 Error
*local_err
= NULL
;
595 klass
= object_class_by_name(typename
);
597 error_setg(errp
, "invalid object type: %s", typename
);
601 if (object_class_is_abstract(klass
)) {
602 error_setg(errp
, "object type '%s' is abstract", typename
);
605 obj
= object_new(typename
);
607 if (object_set_propv(obj
, &local_err
, vargs
) < 0) {
611 object_property_add_child(parent
, id
, obj
, &local_err
);
616 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
618 user_creatable_complete(uc
, &local_err
);
620 object_unparent(obj
);
625 object_unref(OBJECT(obj
));
629 error_propagate(errp
, local_err
);
635 int object_set_props(Object
*obj
,
642 va_start(vargs
, errp
);
643 ret
= object_set_propv(obj
, errp
, vargs
);
650 int object_set_propv(Object
*obj
,
654 const char *propname
;
655 Error
*local_err
= NULL
;
657 propname
= va_arg(vargs
, char *);
658 while (propname
!= NULL
) {
659 const char *value
= va_arg(vargs
, char *);
661 g_assert(value
!= NULL
);
662 object_property_parse(obj
, value
, propname
, &local_err
);
664 error_propagate(errp
, local_err
);
667 propname
= va_arg(vargs
, char *);
674 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
676 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
683 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
684 const char *file
, int line
, const char *func
)
686 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
687 typename
, file
, line
, func
);
689 #ifdef CONFIG_QOM_CAST_DEBUG
693 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
694 if (atomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
699 inst
= object_dynamic_cast(obj
, typename
);
702 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
703 file
, line
, func
, obj
, typename
);
709 if (obj
&& obj
== inst
) {
710 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
711 atomic_set(&obj
->class->object_cast_cache
[i
- 1],
712 atomic_read(&obj
->class->object_cast_cache
[i
]));
714 atomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
722 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
723 const char *typename
)
725 ObjectClass
*ret
= NULL
;
726 TypeImpl
*target_type
;
733 /* A simple fast path that can trigger a lot for leaf classes. */
735 if (type
->name
== typename
) {
739 target_type
= type_get_by_name(typename
);
741 /* target class type unknown, so fail the cast */
745 if (type
->class->interfaces
&&
746 type_is_ancestor(target_type
, type_interface
)) {
750 for (i
= class->interfaces
; i
; i
= i
->next
) {
751 ObjectClass
*target_class
= i
->data
;
753 if (type_is_ancestor(target_class
->type
, target_type
)) {
759 /* The match was ambiguous, don't allow a cast */
763 } else if (type_is_ancestor(type
, target_type
)) {
770 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
771 const char *typename
,
772 const char *file
, int line
,
777 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
778 typename
, file
, line
, func
);
780 #ifdef CONFIG_QOM_CAST_DEBUG
783 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
784 if (atomic_read(&class->class_cast_cache
[i
]) == typename
) {
790 if (!class || !class->interfaces
) {
795 ret
= object_class_dynamic_cast(class, typename
);
797 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
798 file
, line
, func
, class, typename
);
802 #ifdef CONFIG_QOM_CAST_DEBUG
803 if (class && ret
== class) {
804 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
805 atomic_set(&class->class_cast_cache
[i
- 1],
806 atomic_read(&class->class_cast_cache
[i
]));
808 atomic_set(&class->class_cast_cache
[i
- 1], typename
);
815 const char *object_get_typename(const Object
*obj
)
817 return obj
->class->type
->name
;
820 ObjectClass
*object_get_class(Object
*obj
)
825 bool object_class_is_abstract(ObjectClass
*klass
)
827 return klass
->type
->abstract
;
830 const char *object_class_get_name(ObjectClass
*klass
)
832 return klass
->type
->name
;
835 ObjectClass
*object_class_by_name(const char *typename
)
837 TypeImpl
*type
= type_get_by_name(typename
);
843 type_initialize(type
);
848 ObjectClass
*object_class_get_parent(ObjectClass
*class)
850 TypeImpl
*type
= type_get_parent(class->type
);
856 type_initialize(type
);
861 typedef struct OCFData
863 void (*fn
)(ObjectClass
*klass
, void *opaque
);
864 const char *implements_type
;
865 bool include_abstract
;
869 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
872 OCFData
*data
= opaque
;
873 TypeImpl
*type
= value
;
876 type_initialize(type
);
879 if (!data
->include_abstract
&& type
->abstract
) {
883 if (data
->implements_type
&&
884 !object_class_dynamic_cast(k
, data
->implements_type
)) {
888 data
->fn(k
, data
->opaque
);
891 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
892 const char *implements_type
, bool include_abstract
,
895 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
897 enumerating_types
= true;
898 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
899 enumerating_types
= false;
902 static int do_object_child_foreach(Object
*obj
,
903 int (*fn
)(Object
*child
, void *opaque
),
904 void *opaque
, bool recurse
)
907 ObjectProperty
*prop
;
910 g_hash_table_iter_init(&iter
, obj
->properties
);
911 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
912 if (object_property_is_child(prop
)) {
913 Object
*child
= prop
->opaque
;
915 ret
= fn(child
, opaque
);
920 do_object_child_foreach(child
, fn
, opaque
, true);
927 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
930 return do_object_child_foreach(obj
, fn
, opaque
, false);
933 int object_child_foreach_recursive(Object
*obj
,
934 int (*fn
)(Object
*child
, void *opaque
),
937 return do_object_child_foreach(obj
, fn
, opaque
, true);
940 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
942 GSList
**list
= opaque
;
944 *list
= g_slist_prepend(*list
, klass
);
947 GSList
*object_class_get_list(const char *implements_type
,
948 bool include_abstract
)
952 object_class_foreach(object_class_get_list_tramp
,
953 implements_type
, include_abstract
, &list
);
957 static gint
object_class_cmp(gconstpointer a
, gconstpointer b
)
959 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
960 object_class_get_name((ObjectClass
*)b
));
963 GSList
*object_class_get_list_sorted(const char *implements_type
,
964 bool include_abstract
)
966 return g_slist_sort(object_class_get_list(implements_type
, include_abstract
),
970 void object_ref(Object
*obj
)
975 atomic_inc(&obj
->ref
);
978 void object_unref(Object
*obj
)
983 g_assert(obj
->ref
> 0);
985 /* parent always holds a reference to its children */
986 if (atomic_fetch_dec(&obj
->ref
) == 1) {
987 object_finalize(obj
);
992 object_property_add(Object
*obj
, const char *name
, const char *type
,
993 ObjectPropertyAccessor
*get
,
994 ObjectPropertyAccessor
*set
,
995 ObjectPropertyRelease
*release
,
996 void *opaque
, Error
**errp
)
998 ObjectProperty
*prop
;
999 size_t name_len
= strlen(name
);
1001 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
1003 ObjectProperty
*ret
;
1004 char *name_no_array
= g_strdup(name
);
1006 name_no_array
[name_len
- 3] = '\0';
1007 for (i
= 0; ; ++i
) {
1008 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
1010 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
1011 release
, opaque
, NULL
);
1017 g_free(name_no_array
);
1021 if (object_property_find(obj
, name
, NULL
) != NULL
) {
1022 error_setg(errp
, "attempt to add duplicate property '%s'"
1023 " to object (type '%s')", name
,
1024 object_get_typename(obj
));
1028 prop
= g_malloc0(sizeof(*prop
));
1030 prop
->name
= g_strdup(name
);
1031 prop
->type
= g_strdup(type
);
1035 prop
->release
= release
;
1036 prop
->opaque
= opaque
;
1038 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
1043 object_class_property_add(ObjectClass
*klass
,
1046 ObjectPropertyAccessor
*get
,
1047 ObjectPropertyAccessor
*set
,
1048 ObjectPropertyRelease
*release
,
1052 ObjectProperty
*prop
;
1054 if (object_class_property_find(klass
, name
, NULL
) != NULL
) {
1055 error_setg(errp
, "attempt to add duplicate property '%s'"
1056 " to object (type '%s')", name
,
1057 object_class_get_name(klass
));
1061 prop
= g_malloc0(sizeof(*prop
));
1063 prop
->name
= g_strdup(name
);
1064 prop
->type
= g_strdup(type
);
1068 prop
->release
= release
;
1069 prop
->opaque
= opaque
;
1071 g_hash_table_insert(klass
->properties
, g_strdup(name
), prop
);
1076 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
1079 ObjectProperty
*prop
;
1080 ObjectClass
*klass
= object_get_class(obj
);
1082 prop
= object_class_property_find(klass
, name
, NULL
);
1087 prop
= g_hash_table_lookup(obj
->properties
, name
);
1092 error_setg(errp
, "Property '.%s' not found", name
);
1096 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1099 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1100 iter
->nextclass
= object_get_class(obj
);
1103 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1106 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1107 if (!iter
->nextclass
) {
1110 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1111 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1116 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1119 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1120 iter
->nextclass
= object_class_get_parent(klass
);
1123 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
,
1126 ObjectProperty
*prop
;
1127 ObjectClass
*parent_klass
;
1129 parent_klass
= object_class_get_parent(klass
);
1131 prop
= object_class_property_find(parent_klass
, name
, NULL
);
1137 prop
= g_hash_table_lookup(klass
->properties
, name
);
1139 error_setg(errp
, "Property '.%s' not found", name
);
1144 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
1146 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1149 error_setg(errp
, "Property '.%s' not found", name
);
1153 if (prop
->release
) {
1154 prop
->release(obj
, name
, prop
->opaque
);
1156 g_hash_table_remove(obj
->properties
, name
);
1159 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
1162 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1168 error_setg(errp
, QERR_PERMISSION_DENIED
);
1170 prop
->get(obj
, v
, name
, prop
->opaque
, errp
);
1174 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
1177 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1183 error_setg(errp
, QERR_PERMISSION_DENIED
);
1185 prop
->set(obj
, v
, name
, prop
->opaque
, errp
);
1189 void object_property_set_str(Object
*obj
, const char *value
,
1190 const char *name
, Error
**errp
)
1192 QString
*qstr
= qstring_from_str(value
);
1193 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
1195 qobject_unref(qstr
);
1198 char *object_property_get_str(Object
*obj
, const char *name
,
1201 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1208 retval
= g_strdup(qobject_get_try_str(ret
));
1210 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1217 void object_property_set_link(Object
*obj
, Object
*value
,
1218 const char *name
, Error
**errp
)
1221 gchar
*path
= object_get_canonical_path(value
);
1222 object_property_set_str(obj
, path
, name
, errp
);
1225 object_property_set_str(obj
, "", name
, errp
);
1229 Object
*object_property_get_link(Object
*obj
, const char *name
,
1232 char *str
= object_property_get_str(obj
, name
, errp
);
1233 Object
*target
= NULL
;
1236 target
= object_resolve_path(str
, NULL
);
1238 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1239 "Device '%s' not found", str
);
1247 void object_property_set_bool(Object
*obj
, bool value
,
1248 const char *name
, Error
**errp
)
1250 QBool
*qbool
= qbool_from_bool(value
);
1251 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
1253 qobject_unref(qbool
);
1256 bool object_property_get_bool(Object
*obj
, const char *name
,
1259 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1266 qbool
= qobject_to(QBool
, ret
);
1268 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1271 retval
= qbool_get_bool(qbool
);
1278 void object_property_set_int(Object
*obj
, int64_t value
,
1279 const char *name
, Error
**errp
)
1281 QNum
*qnum
= qnum_from_int(value
);
1282 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1284 qobject_unref(qnum
);
1287 int64_t object_property_get_int(Object
*obj
, const char *name
,
1290 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1298 qnum
= qobject_to(QNum
, ret
);
1299 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1300 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1308 void object_property_set_uint(Object
*obj
, uint64_t value
,
1309 const char *name
, Error
**errp
)
1311 QNum
*qnum
= qnum_from_uint(value
);
1313 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1314 qobject_unref(qnum
);
1317 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1320 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1327 qnum
= qobject_to(QNum
, ret
);
1328 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1329 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "uint");
1337 typedef struct EnumProperty
{
1338 const QEnumLookup
*lookup
;
1339 int (*get
)(Object
*, Error
**);
1340 void (*set
)(Object
*, int, Error
**);
1343 int object_property_get_enum(Object
*obj
, const char *name
,
1344 const char *typename
, Error
**errp
)
1350 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1351 EnumProperty
*enumprop
;
1357 if (!g_str_equal(prop
->type
, typename
)) {
1358 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1359 name
, object_class_get_name(
1360 object_get_class(obj
)), typename
);
1364 enumprop
= prop
->opaque
;
1366 v
= string_output_visitor_new(false, &str
);
1367 object_property_get(obj
, v
, name
, &err
);
1369 error_propagate(errp
, err
);
1373 visit_complete(v
, &str
);
1375 v
= string_input_visitor_new(str
);
1376 visit_type_enum(v
, name
, &ret
, enumprop
->lookup
, errp
);
1384 void object_property_get_uint16List(Object
*obj
, const char *name
,
1385 uint16List
**list
, Error
**errp
)
1391 v
= string_output_visitor_new(false, &str
);
1392 object_property_get(obj
, v
, name
, &err
);
1394 error_propagate(errp
, err
);
1397 visit_complete(v
, &str
);
1399 v
= string_input_visitor_new(str
);
1400 visit_type_uint16List(v
, NULL
, list
, errp
);
1407 void object_property_parse(Object
*obj
, const char *string
,
1408 const char *name
, Error
**errp
)
1410 Visitor
*v
= string_input_visitor_new(string
);
1411 object_property_set(obj
, v
, name
, errp
);
1415 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1419 char *string
= NULL
;
1420 Error
*local_err
= NULL
;
1422 v
= string_output_visitor_new(human
, &string
);
1423 object_property_get(obj
, v
, name
, &local_err
);
1425 error_propagate(errp
, local_err
);
1429 visit_complete(v
, &string
);
1436 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1438 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1446 Object
*object_get_root(void)
1448 static Object
*root
;
1451 root
= object_new("container");
1457 Object
*object_get_objects_root(void)
1459 return container_get(object_get_root(), "/objects");
1462 Object
*object_get_internal_root(void)
1464 static Object
*internal_root
;
1466 if (!internal_root
) {
1467 internal_root
= object_new("container");
1470 return internal_root
;
1473 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1474 const char *name
, void *opaque
,
1477 Object
*child
= opaque
;
1480 path
= object_get_canonical_path(child
);
1481 visit_type_str(v
, name
, &path
, errp
);
1485 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1490 static void object_finalize_child_property(Object
*obj
, const char *name
,
1493 Object
*child
= opaque
;
1495 if (child
->class->unparent
) {
1496 (child
->class->unparent
)(child
);
1498 child
->parent
= NULL
;
1499 object_unref(child
);
1502 void object_property_add_child(Object
*obj
, const char *name
,
1503 Object
*child
, Error
**errp
)
1505 Error
*local_err
= NULL
;
1509 if (child
->parent
!= NULL
) {
1510 error_setg(errp
, "child object is already parented");
1514 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1516 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1517 object_finalize_child_property
, child
, &local_err
);
1519 error_propagate(errp
, local_err
);
1523 op
->resolve
= object_resolve_child_property
;
1525 child
->parent
= obj
;
1531 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1532 Object
*val
, Error
**errp
)
1534 /* Allow the link to be set, always */
1539 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1540 ObjectPropertyLinkFlags flags
;
1543 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1544 const char *name
, void *opaque
,
1547 LinkProperty
*lprop
= opaque
;
1548 Object
**child
= lprop
->child
;
1552 path
= object_get_canonical_path(*child
);
1553 visit_type_str(v
, name
, &path
, errp
);
1557 visit_type_str(v
, name
, &path
, errp
);
1562 * object_resolve_link:
1564 * Lookup an object and ensure its type matches the link property type. This
1565 * is similar to object_resolve_path() except type verification against the
1566 * link property is performed.
1568 * Returns: The matched object or NULL on path lookup failures.
1570 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1571 const char *path
, Error
**errp
)
1575 bool ambiguous
= false;
1578 /* Go from link<FOO> to FOO. */
1579 type
= object_property_get_type(obj
, name
, NULL
);
1580 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1581 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1584 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1586 } else if (!target
) {
1587 target
= object_resolve_path(path
, &ambiguous
);
1588 if (target
|| ambiguous
) {
1589 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1591 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1592 "Device '%s' not found", path
);
1596 g_free(target_type
);
1601 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1602 const char *name
, void *opaque
,
1605 Error
*local_err
= NULL
;
1606 LinkProperty
*prop
= opaque
;
1607 Object
**child
= prop
->child
;
1608 Object
*old_target
= *child
;
1609 Object
*new_target
= NULL
;
1612 visit_type_str(v
, name
, &path
, &local_err
);
1614 if (!local_err
&& strcmp(path
, "") != 0) {
1615 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1620 error_propagate(errp
, local_err
);
1624 prop
->check(obj
, name
, new_target
, &local_err
);
1626 error_propagate(errp
, local_err
);
1630 *child
= new_target
;
1631 if (prop
->flags
== OBJ_PROP_LINK_STRONG
) {
1632 object_ref(new_target
);
1633 object_unref(old_target
);
1637 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1639 LinkProperty
*lprop
= opaque
;
1641 return *lprop
->child
;
1644 static void object_release_link_property(Object
*obj
, const char *name
,
1647 LinkProperty
*prop
= opaque
;
1649 if ((prop
->flags
& OBJ_PROP_LINK_STRONG
) && *prop
->child
) {
1650 object_unref(*prop
->child
);
1655 void object_property_add_link(Object
*obj
, const char *name
,
1656 const char *type
, Object
**child
,
1657 void (*check
)(const Object
*, const char *,
1658 Object
*, Error
**),
1659 ObjectPropertyLinkFlags flags
,
1662 Error
*local_err
= NULL
;
1663 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1667 prop
->child
= child
;
1668 prop
->check
= check
;
1669 prop
->flags
= flags
;
1671 full_type
= g_strdup_printf("link<%s>", type
);
1673 op
= object_property_add(obj
, name
, full_type
,
1674 object_get_link_property
,
1675 check
? object_set_link_property
: NULL
,
1676 object_release_link_property
,
1680 error_propagate(errp
, local_err
);
1685 op
->resolve
= object_resolve_link_property
;
1691 void object_property_add_const_link(Object
*obj
, const char *name
,
1692 Object
*target
, Error
**errp
)
1697 link_type
= g_strdup_printf("link<%s>", object_get_typename(target
));
1698 op
= object_property_add(obj
, name
, link_type
,
1699 object_get_child_property
, NULL
,
1700 NULL
, target
, errp
);
1702 op
->resolve
= object_resolve_child_property
;
1707 gchar
*object_get_canonical_path_component(Object
*obj
)
1709 ObjectProperty
*prop
= NULL
;
1710 GHashTableIter iter
;
1712 if (obj
->parent
== NULL
) {
1716 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
1717 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1718 if (!object_property_is_child(prop
)) {
1722 if (prop
->opaque
== obj
) {
1723 return g_strdup(prop
->name
);
1727 /* obj had a parent but was not a child, should never happen */
1728 g_assert_not_reached();
1732 gchar
*object_get_canonical_path(Object
*obj
)
1734 Object
*root
= object_get_root();
1735 char *newpath
, *path
= NULL
;
1738 return g_strdup("/");
1742 char *component
= object_get_canonical_path_component(obj
);
1745 /* A canonical path must be complete, so discard what was
1752 newpath
= g_strdup_printf("/%s%s", component
, path
? path
: "");
1757 } while (obj
!= root
);
1762 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
1764 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1769 if (prop
->resolve
) {
1770 return prop
->resolve(parent
, prop
->opaque
, part
);
1776 static Object
*object_resolve_abs_path(Object
*parent
,
1778 const char *typename
,
1783 if (parts
[index
] == NULL
) {
1784 return object_dynamic_cast(parent
, typename
);
1787 if (strcmp(parts
[index
], "") == 0) {
1788 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
1791 child
= object_resolve_path_component(parent
, parts
[index
]);
1796 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
1799 static Object
*object_resolve_partial_path(Object
*parent
,
1801 const char *typename
,
1805 GHashTableIter iter
;
1806 ObjectProperty
*prop
;
1808 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
1810 g_hash_table_iter_init(&iter
, parent
->properties
);
1811 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1814 if (!object_property_is_child(prop
)) {
1818 found
= object_resolve_partial_path(prop
->opaque
, parts
,
1819 typename
, ambiguous
);
1836 Object
*object_resolve_path_type(const char *path
, const char *typename
,
1842 parts
= g_strsplit(path
, "/", 0);
1845 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
1846 bool ambiguous
= false;
1847 obj
= object_resolve_partial_path(object_get_root(), parts
,
1848 typename
, &ambiguous
);
1850 *ambiguousp
= ambiguous
;
1853 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
1861 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
1863 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
1866 typedef struct StringProperty
1868 char *(*get
)(Object
*, Error
**);
1869 void (*set
)(Object
*, const char *, Error
**);
1872 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
1873 void *opaque
, Error
**errp
)
1875 StringProperty
*prop
= opaque
;
1879 value
= prop
->get(obj
, &err
);
1881 error_propagate(errp
, err
);
1885 visit_type_str(v
, name
, &value
, errp
);
1889 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
1890 void *opaque
, Error
**errp
)
1892 StringProperty
*prop
= opaque
;
1894 Error
*local_err
= NULL
;
1896 visit_type_str(v
, name
, &value
, &local_err
);
1898 error_propagate(errp
, local_err
);
1902 prop
->set(obj
, value
, errp
);
1906 static void property_release_str(Object
*obj
, const char *name
,
1909 StringProperty
*prop
= opaque
;
1913 void object_property_add_str(Object
*obj
, const char *name
,
1914 char *(*get
)(Object
*, Error
**),
1915 void (*set
)(Object
*, const char *, Error
**),
1918 Error
*local_err
= NULL
;
1919 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1924 object_property_add(obj
, name
, "string",
1925 get
? property_get_str
: NULL
,
1926 set
? property_set_str
: NULL
,
1927 property_release_str
,
1930 error_propagate(errp
, local_err
);
1935 void object_class_property_add_str(ObjectClass
*klass
, const char *name
,
1936 char *(*get
)(Object
*, Error
**),
1937 void (*set
)(Object
*, const char *,
1941 Error
*local_err
= NULL
;
1942 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1947 object_class_property_add(klass
, name
, "string",
1948 get
? property_get_str
: NULL
,
1949 set
? property_set_str
: NULL
,
1950 property_release_str
,
1953 error_propagate(errp
, local_err
);
1958 typedef struct BoolProperty
1960 bool (*get
)(Object
*, Error
**);
1961 void (*set
)(Object
*, bool, Error
**);
1964 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
1965 void *opaque
, Error
**errp
)
1967 BoolProperty
*prop
= opaque
;
1971 value
= prop
->get(obj
, &err
);
1973 error_propagate(errp
, err
);
1977 visit_type_bool(v
, name
, &value
, errp
);
1980 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
1981 void *opaque
, Error
**errp
)
1983 BoolProperty
*prop
= opaque
;
1985 Error
*local_err
= NULL
;
1987 visit_type_bool(v
, name
, &value
, &local_err
);
1989 error_propagate(errp
, local_err
);
1993 prop
->set(obj
, value
, errp
);
1996 static void property_release_bool(Object
*obj
, const char *name
,
1999 BoolProperty
*prop
= opaque
;
2003 void object_property_add_bool(Object
*obj
, const char *name
,
2004 bool (*get
)(Object
*, Error
**),
2005 void (*set
)(Object
*, bool, Error
**),
2008 Error
*local_err
= NULL
;
2009 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2014 object_property_add(obj
, name
, "bool",
2015 get
? property_get_bool
: NULL
,
2016 set
? property_set_bool
: NULL
,
2017 property_release_bool
,
2020 error_propagate(errp
, local_err
);
2025 void object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
2026 bool (*get
)(Object
*, Error
**),
2027 void (*set
)(Object
*, bool, Error
**),
2030 Error
*local_err
= NULL
;
2031 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2036 object_class_property_add(klass
, name
, "bool",
2037 get
? property_get_bool
: NULL
,
2038 set
? property_set_bool
: NULL
,
2039 property_release_bool
,
2042 error_propagate(errp
, local_err
);
2047 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
2048 void *opaque
, Error
**errp
)
2050 EnumProperty
*prop
= opaque
;
2054 value
= prop
->get(obj
, &err
);
2056 error_propagate(errp
, err
);
2060 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
2063 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
2064 void *opaque
, Error
**errp
)
2066 EnumProperty
*prop
= opaque
;
2070 visit_type_enum(v
, name
, &value
, prop
->lookup
, &err
);
2072 error_propagate(errp
, err
);
2075 prop
->set(obj
, value
, errp
);
2078 static void property_release_enum(Object
*obj
, const char *name
,
2081 EnumProperty
*prop
= opaque
;
2085 void object_property_add_enum(Object
*obj
, const char *name
,
2086 const char *typename
,
2087 const QEnumLookup
*lookup
,
2088 int (*get
)(Object
*, Error
**),
2089 void (*set
)(Object
*, int, Error
**),
2092 Error
*local_err
= NULL
;
2093 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2095 prop
->lookup
= lookup
;
2099 object_property_add(obj
, name
, typename
,
2100 get
? property_get_enum
: NULL
,
2101 set
? property_set_enum
: NULL
,
2102 property_release_enum
,
2105 error_propagate(errp
, local_err
);
2110 void object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2111 const char *typename
,
2112 const QEnumLookup
*lookup
,
2113 int (*get
)(Object
*, Error
**),
2114 void (*set
)(Object
*, int, Error
**),
2117 Error
*local_err
= NULL
;
2118 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2120 prop
->lookup
= lookup
;
2124 object_class_property_add(klass
, name
, typename
,
2125 get
? property_get_enum
: NULL
,
2126 set
? property_set_enum
: NULL
,
2127 property_release_enum
,
2130 error_propagate(errp
, local_err
);
2135 typedef struct TMProperty
{
2136 void (*get
)(Object
*, struct tm
*, Error
**);
2139 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2140 void *opaque
, Error
**errp
)
2142 TMProperty
*prop
= opaque
;
2146 prop
->get(obj
, &value
, &err
);
2151 visit_start_struct(v
, name
, NULL
, 0, &err
);
2155 visit_type_int32(v
, "tm_year", &value
.tm_year
, &err
);
2159 visit_type_int32(v
, "tm_mon", &value
.tm_mon
, &err
);
2163 visit_type_int32(v
, "tm_mday", &value
.tm_mday
, &err
);
2167 visit_type_int32(v
, "tm_hour", &value
.tm_hour
, &err
);
2171 visit_type_int32(v
, "tm_min", &value
.tm_min
, &err
);
2175 visit_type_int32(v
, "tm_sec", &value
.tm_sec
, &err
);
2179 visit_check_struct(v
, &err
);
2181 visit_end_struct(v
, NULL
);
2183 error_propagate(errp
, err
);
2187 static void property_release_tm(Object
*obj
, const char *name
,
2190 TMProperty
*prop
= opaque
;
2194 void object_property_add_tm(Object
*obj
, const char *name
,
2195 void (*get
)(Object
*, struct tm
*, Error
**),
2198 Error
*local_err
= NULL
;
2199 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2203 object_property_add(obj
, name
, "struct tm",
2204 get
? property_get_tm
: NULL
, NULL
,
2205 property_release_tm
,
2208 error_propagate(errp
, local_err
);
2213 void object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2214 void (*get
)(Object
*, struct tm
*, Error
**),
2217 Error
*local_err
= NULL
;
2218 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2222 object_class_property_add(klass
, name
, "struct tm",
2223 get
? property_get_tm
: NULL
, NULL
,
2224 property_release_tm
,
2227 error_propagate(errp
, local_err
);
2232 static char *qdev_get_type(Object
*obj
, Error
**errp
)
2234 return g_strdup(object_get_typename(obj
));
2237 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2238 void *opaque
, Error
**errp
)
2240 uint8_t value
= *(uint8_t *)opaque
;
2241 visit_type_uint8(v
, name
, &value
, errp
);
2244 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2245 void *opaque
, Error
**errp
)
2247 uint16_t value
= *(uint16_t *)opaque
;
2248 visit_type_uint16(v
, name
, &value
, errp
);
2251 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2252 void *opaque
, Error
**errp
)
2254 uint32_t value
= *(uint32_t *)opaque
;
2255 visit_type_uint32(v
, name
, &value
, errp
);
2258 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2259 void *opaque
, Error
**errp
)
2261 uint64_t value
= *(uint64_t *)opaque
;
2262 visit_type_uint64(v
, name
, &value
, errp
);
2265 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2266 const uint8_t *v
, Error
**errp
)
2268 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
2269 NULL
, NULL
, (void *)v
, errp
);
2272 void object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2273 const uint8_t *v
, Error
**errp
)
2275 object_class_property_add(klass
, name
, "uint8", property_get_uint8_ptr
,
2276 NULL
, NULL
, (void *)v
, errp
);
2279 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2280 const uint16_t *v
, Error
**errp
)
2282 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
2283 NULL
, NULL
, (void *)v
, errp
);
2286 void object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2287 const uint16_t *v
, Error
**errp
)
2289 object_class_property_add(klass
, name
, "uint16", property_get_uint16_ptr
,
2290 NULL
, NULL
, (void *)v
, errp
);
2293 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2294 const uint32_t *v
, Error
**errp
)
2296 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
2297 NULL
, NULL
, (void *)v
, errp
);
2300 void object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2301 const uint32_t *v
, Error
**errp
)
2303 object_class_property_add(klass
, name
, "uint32", property_get_uint32_ptr
,
2304 NULL
, NULL
, (void *)v
, errp
);
2307 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2308 const uint64_t *v
, Error
**errp
)
2310 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
2311 NULL
, NULL
, (void *)v
, errp
);
2314 void object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2315 const uint64_t *v
, Error
**errp
)
2317 object_class_property_add(klass
, name
, "uint64", property_get_uint64_ptr
,
2318 NULL
, NULL
, (void *)v
, errp
);
2326 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2327 void *opaque
, Error
**errp
)
2329 AliasProperty
*prop
= opaque
;
2331 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
2334 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2335 void *opaque
, Error
**errp
)
2337 AliasProperty
*prop
= opaque
;
2339 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
2342 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2345 AliasProperty
*prop
= opaque
;
2347 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2350 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2352 AliasProperty
*prop
= opaque
;
2354 g_free(prop
->target_name
);
2358 void object_property_add_alias(Object
*obj
, const char *name
,
2359 Object
*target_obj
, const char *target_name
,
2362 AliasProperty
*prop
;
2364 ObjectProperty
*target_prop
;
2366 Error
*local_err
= NULL
;
2368 target_prop
= object_property_find(target_obj
, target_name
, errp
);
2373 if (object_property_is_child(target_prop
)) {
2374 prop_type
= g_strdup_printf("link%s",
2375 target_prop
->type
+ strlen("child"));
2377 prop_type
= g_strdup(target_prop
->type
);
2380 prop
= g_malloc(sizeof(*prop
));
2381 prop
->target_obj
= target_obj
;
2382 prop
->target_name
= g_strdup(target_name
);
2384 op
= object_property_add(obj
, name
, prop_type
,
2387 property_release_alias
,
2390 error_propagate(errp
, local_err
);
2394 op
->resolve
= property_resolve_alias
;
2396 object_property_set_description(obj
, op
->name
,
2397 target_prop
->description
,
2404 void object_property_set_description(Object
*obj
, const char *name
,
2405 const char *description
, Error
**errp
)
2409 op
= object_property_find(obj
, name
, errp
);
2414 g_free(op
->description
);
2415 op
->description
= g_strdup(description
);
2418 void object_class_property_set_description(ObjectClass
*klass
,
2420 const char *description
,
2425 op
= g_hash_table_lookup(klass
->properties
, name
);
2427 error_setg(errp
, "Property '.%s' not found", name
);
2431 g_free(op
->description
);
2432 op
->description
= g_strdup(description
);
2435 static void object_class_init(ObjectClass
*klass
, void *data
)
2437 object_class_property_add_str(klass
, "type", qdev_get_type
,
2438 NULL
, &error_abort
);
2441 static void register_types(void)
2443 static TypeInfo interface_info
= {
2444 .name
= TYPE_INTERFACE
,
2445 .class_size
= sizeof(InterfaceClass
),
2449 static TypeInfo object_info
= {
2450 .name
= TYPE_OBJECT
,
2451 .instance_size
= sizeof(Object
),
2452 .class_init
= object_class_init
,
2456 type_interface
= type_register_internal(&interface_info
);
2457 type_register_internal(&object_info
);
2460 type_init(register_types
)