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
);
52 void (*class_finalize
)(ObjectClass
*klass
, void *data
);
56 void (*instance_init
)(Object
*obj
);
57 void (*instance_post_init
)(Object
*obj
);
58 void (*instance_finalize
)(Object
*obj
);
63 TypeImpl
*parent_type
;
68 InterfaceImpl interfaces
[MAX_INTERFACES
];
71 static Type type_interface
;
73 static GHashTable
*type_table_get(void)
75 static GHashTable
*type_table
;
77 if (type_table
== NULL
) {
78 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
84 static bool enumerating_types
;
86 static void type_table_add(TypeImpl
*ti
)
88 assert(!enumerating_types
);
89 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
92 static TypeImpl
*type_table_lookup(const char *name
)
94 return g_hash_table_lookup(type_table_get(), name
);
97 static TypeImpl
*type_new(const TypeInfo
*info
)
99 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
102 g_assert(info
->name
!= NULL
);
104 if (type_table_lookup(info
->name
) != NULL
) {
105 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
109 ti
->name
= g_strdup(info
->name
);
110 ti
->parent
= g_strdup(info
->parent
);
112 ti
->class_size
= info
->class_size
;
113 ti
->instance_size
= info
->instance_size
;
115 ti
->class_init
= info
->class_init
;
116 ti
->class_base_init
= info
->class_base_init
;
117 ti
->class_finalize
= info
->class_finalize
;
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 g_assert(type
->parent_type
!= NULL
);
179 return type
->parent_type
;
182 static bool type_has_parent(TypeImpl
*type
)
184 return (type
->parent
!= NULL
);
187 static size_t type_class_get_size(TypeImpl
*ti
)
189 if (ti
->class_size
) {
190 return ti
->class_size
;
193 if (type_has_parent(ti
)) {
194 return type_class_get_size(type_get_parent(ti
));
197 return sizeof(ObjectClass
);
200 static size_t type_object_get_size(TypeImpl
*ti
)
202 if (ti
->instance_size
) {
203 return ti
->instance_size
;
206 if (type_has_parent(ti
)) {
207 return type_object_get_size(type_get_parent(ti
));
213 size_t object_type_get_instance_size(const char *typename
)
215 TypeImpl
*type
= type_get_by_name(typename
);
217 g_assert(type
!= NULL
);
218 return type_object_get_size(type
);
221 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
225 /* Check if target_type is a direct ancestor of type */
227 if (type
== target_type
) {
231 type
= type_get_parent(type
);
237 static void type_initialize(TypeImpl
*ti
);
239 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
240 TypeImpl
*parent_type
)
242 InterfaceClass
*new_iface
;
244 TypeImpl
*iface_impl
;
246 info
.parent
= parent_type
->name
;
247 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
248 info
.abstract
= true;
250 iface_impl
= type_new(&info
);
251 iface_impl
->parent_type
= parent_type
;
252 type_initialize(iface_impl
);
253 g_free((char *)info
.name
);
255 new_iface
= (InterfaceClass
*)iface_impl
->class;
256 new_iface
->concrete_class
= ti
->class;
257 new_iface
->interface_type
= interface_type
;
259 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
263 static void object_property_free(gpointer data
)
265 ObjectProperty
*prop
= data
;
269 g_free(prop
->description
);
273 static void type_initialize(TypeImpl
*ti
)
281 ti
->class_size
= type_class_get_size(ti
);
282 ti
->instance_size
= type_object_get_size(ti
);
283 /* Any type with zero instance_size is implicitly abstract.
284 * This means interface types are all abstract.
286 if (ti
->instance_size
== 0) {
290 ti
->class = g_malloc0(ti
->class_size
);
292 parent
= type_get_parent(ti
);
294 type_initialize(parent
);
298 g_assert_cmpint(parent
->class_size
, <=, ti
->class_size
);
299 memcpy(ti
->class, parent
->class, parent
->class_size
);
300 ti
->class->interfaces
= NULL
;
301 ti
->class->properties
= g_hash_table_new_full(
302 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
304 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
305 InterfaceClass
*iface
= e
->data
;
306 ObjectClass
*klass
= OBJECT_CLASS(iface
);
308 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
311 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
312 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
313 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
314 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
316 if (type_is_ancestor(target_type
, t
)) {
325 type_initialize_interface(ti
, t
, t
);
328 ti
->class->properties
= g_hash_table_new_full(
329 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
332 ti
->class->type
= ti
;
335 if (parent
->class_base_init
) {
336 parent
->class_base_init(ti
->class, ti
->class_data
);
338 parent
= type_get_parent(parent
);
341 if (ti
->class_init
) {
342 ti
->class_init(ti
->class, ti
->class_data
);
346 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
348 if (type_has_parent(ti
)) {
349 object_init_with_type(obj
, type_get_parent(ti
));
352 if (ti
->instance_init
) {
353 ti
->instance_init(obj
);
357 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
359 if (ti
->instance_post_init
) {
360 ti
->instance_post_init(obj
);
363 if (type_has_parent(ti
)) {
364 object_post_init_with_type(obj
, type_get_parent(ti
));
368 static void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
372 g_assert(type
!= NULL
);
373 type_initialize(type
);
375 g_assert_cmpint(type
->instance_size
, >=, sizeof(Object
));
376 g_assert(type
->abstract
== false);
377 g_assert_cmpint(size
, >=, type
->instance_size
);
379 memset(obj
, 0, type
->instance_size
);
380 obj
->class = type
->class;
382 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
383 NULL
, object_property_free
);
384 object_init_with_type(obj
, type
);
385 object_post_init_with_type(obj
, type
);
388 void object_initialize(void *data
, size_t size
, const char *typename
)
390 TypeImpl
*type
= type_get_by_name(typename
);
392 object_initialize_with_type(data
, size
, type
);
395 static inline bool object_property_is_child(ObjectProperty
*prop
)
397 return strstart(prop
->type
, "child<", NULL
);
400 static void object_property_del_all(Object
*obj
)
402 ObjectProperty
*prop
;
409 g_hash_table_iter_init(&iter
, obj
->properties
);
410 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
413 prop
->release(obj
, prop
->name
, prop
->opaque
);
414 prop
->release
= NULL
;
418 g_hash_table_iter_remove(&iter
);
422 g_hash_table_unref(obj
->properties
);
425 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
427 ObjectProperty
*prop
;
431 g_hash_table_iter_init(&iter
, obj
->properties
);
432 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
434 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
436 prop
->release(obj
, prop
->name
, prop
->opaque
);
437 prop
->release
= NULL
;
442 g_hash_table_iter_init(&iter
, obj
->properties
);
443 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
445 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
446 g_hash_table_iter_remove(&iter
);
452 void object_unparent(Object
*obj
)
455 object_property_del_child(obj
->parent
, obj
, NULL
);
459 static void object_deinit(Object
*obj
, TypeImpl
*type
)
461 if (type
->instance_finalize
) {
462 type
->instance_finalize(obj
);
465 if (type_has_parent(type
)) {
466 object_deinit(obj
, type_get_parent(type
));
470 static void object_finalize(void *data
)
473 TypeImpl
*ti
= obj
->class->type
;
475 object_property_del_all(obj
);
476 object_deinit(obj
, ti
);
478 g_assert_cmpint(obj
->ref
, ==, 0);
484 static Object
*object_new_with_type(Type type
)
488 g_assert(type
!= NULL
);
489 type_initialize(type
);
491 obj
= g_malloc(type
->instance_size
);
492 object_initialize_with_type(obj
, type
->instance_size
, type
);
498 Object
*object_new(const char *typename
)
500 TypeImpl
*ti
= type_get_by_name(typename
);
502 return object_new_with_type(ti
);
506 Object
*object_new_with_props(const char *typename
,
515 va_start(vargs
, errp
);
516 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
523 Object
*object_new_with_propv(const char *typename
,
531 Error
*local_err
= NULL
;
533 klass
= object_class_by_name(typename
);
535 error_setg(errp
, "invalid object type: %s", typename
);
539 if (object_class_is_abstract(klass
)) {
540 error_setg(errp
, "object type '%s' is abstract", typename
);
543 obj
= object_new(typename
);
545 if (object_set_propv(obj
, &local_err
, vargs
) < 0) {
549 object_property_add_child(parent
, id
, obj
, &local_err
);
554 if (object_dynamic_cast(obj
, TYPE_USER_CREATABLE
)) {
555 user_creatable_complete(obj
, &local_err
);
557 object_unparent(obj
);
562 object_unref(OBJECT(obj
));
566 error_propagate(errp
, local_err
);
572 int object_set_props(Object
*obj
,
579 va_start(vargs
, errp
);
580 ret
= object_set_propv(obj
, errp
, vargs
);
587 int object_set_propv(Object
*obj
,
591 const char *propname
;
592 Error
*local_err
= NULL
;
594 propname
= va_arg(vargs
, char *);
595 while (propname
!= NULL
) {
596 const char *value
= va_arg(vargs
, char *);
598 g_assert(value
!= NULL
);
599 object_property_parse(obj
, value
, propname
, &local_err
);
601 error_propagate(errp
, local_err
);
604 propname
= va_arg(vargs
, char *);
611 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
613 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
620 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
621 const char *file
, int line
, const char *func
)
623 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
624 typename
, file
, line
, func
);
626 #ifdef CONFIG_QOM_CAST_DEBUG
630 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
631 if (atomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
636 inst
= object_dynamic_cast(obj
, typename
);
639 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
640 file
, line
, func
, obj
, typename
);
646 if (obj
&& obj
== inst
) {
647 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
648 atomic_set(&obj
->class->object_cast_cache
[i
- 1],
649 atomic_read(&obj
->class->object_cast_cache
[i
]));
651 atomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
659 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
660 const char *typename
)
662 ObjectClass
*ret
= NULL
;
663 TypeImpl
*target_type
;
670 /* A simple fast path that can trigger a lot for leaf classes. */
672 if (type
->name
== typename
) {
676 target_type
= type_get_by_name(typename
);
678 /* target class type unknown, so fail the cast */
682 if (type
->class->interfaces
&&
683 type_is_ancestor(target_type
, type_interface
)) {
687 for (i
= class->interfaces
; i
; i
= i
->next
) {
688 ObjectClass
*target_class
= i
->data
;
690 if (type_is_ancestor(target_class
->type
, target_type
)) {
696 /* The match was ambiguous, don't allow a cast */
700 } else if (type_is_ancestor(type
, target_type
)) {
707 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
708 const char *typename
,
709 const char *file
, int line
,
714 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
715 typename
, file
, line
, func
);
717 #ifdef CONFIG_QOM_CAST_DEBUG
720 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
721 if (atomic_read(&class->class_cast_cache
[i
]) == typename
) {
727 if (!class || !class->interfaces
) {
732 ret
= object_class_dynamic_cast(class, typename
);
734 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
735 file
, line
, func
, class, typename
);
739 #ifdef CONFIG_QOM_CAST_DEBUG
740 if (class && ret
== class) {
741 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
742 atomic_set(&class->class_cast_cache
[i
- 1],
743 atomic_read(&class->class_cast_cache
[i
]));
745 atomic_set(&class->class_cast_cache
[i
- 1], typename
);
752 const char *object_get_typename(const Object
*obj
)
754 return obj
->class->type
->name
;
757 ObjectClass
*object_get_class(Object
*obj
)
762 bool object_class_is_abstract(ObjectClass
*klass
)
764 return klass
->type
->abstract
;
767 const char *object_class_get_name(ObjectClass
*klass
)
769 return klass
->type
->name
;
772 ObjectClass
*object_class_by_name(const char *typename
)
774 TypeImpl
*type
= type_get_by_name(typename
);
780 type_initialize(type
);
785 ObjectClass
*object_class_get_parent(ObjectClass
*class)
787 TypeImpl
*type
= type_get_parent(class->type
);
793 type_initialize(type
);
798 typedef struct OCFData
800 void (*fn
)(ObjectClass
*klass
, void *opaque
);
801 const char *implements_type
;
802 bool include_abstract
;
806 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
809 OCFData
*data
= opaque
;
810 TypeImpl
*type
= value
;
813 type_initialize(type
);
816 if (!data
->include_abstract
&& type
->abstract
) {
820 if (data
->implements_type
&&
821 !object_class_dynamic_cast(k
, data
->implements_type
)) {
825 data
->fn(k
, data
->opaque
);
828 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
829 const char *implements_type
, bool include_abstract
,
832 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
834 enumerating_types
= true;
835 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
836 enumerating_types
= false;
839 static int do_object_child_foreach(Object
*obj
,
840 int (*fn
)(Object
*child
, void *opaque
),
841 void *opaque
, bool recurse
)
844 ObjectProperty
*prop
;
847 g_hash_table_iter_init(&iter
, obj
->properties
);
848 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
849 if (object_property_is_child(prop
)) {
850 Object
*child
= prop
->opaque
;
852 ret
= fn(child
, opaque
);
857 do_object_child_foreach(child
, fn
, opaque
, true);
864 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
867 return do_object_child_foreach(obj
, fn
, opaque
, false);
870 int object_child_foreach_recursive(Object
*obj
,
871 int (*fn
)(Object
*child
, void *opaque
),
874 return do_object_child_foreach(obj
, fn
, opaque
, true);
877 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
879 GSList
**list
= opaque
;
881 *list
= g_slist_prepend(*list
, klass
);
884 GSList
*object_class_get_list(const char *implements_type
,
885 bool include_abstract
)
889 object_class_foreach(object_class_get_list_tramp
,
890 implements_type
, include_abstract
, &list
);
894 void object_ref(Object
*obj
)
899 atomic_inc(&obj
->ref
);
902 void object_unref(Object
*obj
)
907 g_assert_cmpint(obj
->ref
, >, 0);
909 /* parent always holds a reference to its children */
910 if (atomic_fetch_dec(&obj
->ref
) == 1) {
911 object_finalize(obj
);
916 object_property_add(Object
*obj
, const char *name
, const char *type
,
917 ObjectPropertyAccessor
*get
,
918 ObjectPropertyAccessor
*set
,
919 ObjectPropertyRelease
*release
,
920 void *opaque
, Error
**errp
)
922 ObjectProperty
*prop
;
923 size_t name_len
= strlen(name
);
925 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
928 char *name_no_array
= g_strdup(name
);
930 name_no_array
[name_len
- 3] = '\0';
932 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
934 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
935 release
, opaque
, NULL
);
941 g_free(name_no_array
);
945 if (object_property_find(obj
, name
, NULL
) != NULL
) {
946 error_setg(errp
, "attempt to add duplicate property '%s'"
947 " to object (type '%s')", name
,
948 object_get_typename(obj
));
952 prop
= g_malloc0(sizeof(*prop
));
954 prop
->name
= g_strdup(name
);
955 prop
->type
= g_strdup(type
);
959 prop
->release
= release
;
960 prop
->opaque
= opaque
;
962 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
967 object_class_property_add(ObjectClass
*klass
,
970 ObjectPropertyAccessor
*get
,
971 ObjectPropertyAccessor
*set
,
972 ObjectPropertyRelease
*release
,
976 ObjectProperty
*prop
;
978 if (object_class_property_find(klass
, name
, NULL
) != NULL
) {
979 error_setg(errp
, "attempt to add duplicate property '%s'"
980 " to object (type '%s')", name
,
981 object_class_get_name(klass
));
985 prop
= g_malloc0(sizeof(*prop
));
987 prop
->name
= g_strdup(name
);
988 prop
->type
= g_strdup(type
);
992 prop
->release
= release
;
993 prop
->opaque
= opaque
;
995 g_hash_table_insert(klass
->properties
, g_strdup(name
), prop
);
1000 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
1003 ObjectProperty
*prop
;
1004 ObjectClass
*klass
= object_get_class(obj
);
1006 prop
= object_class_property_find(klass
, name
, NULL
);
1011 prop
= g_hash_table_lookup(obj
->properties
, name
);
1016 error_setg(errp
, "Property '.%s' not found", name
);
1020 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1023 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1024 iter
->nextclass
= object_get_class(obj
);
1027 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1030 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1031 if (!iter
->nextclass
) {
1034 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1035 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1040 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1043 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1044 iter
->nextclass
= klass
;
1047 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
,
1050 ObjectProperty
*prop
;
1051 ObjectClass
*parent_klass
;
1053 parent_klass
= object_class_get_parent(klass
);
1055 prop
= object_class_property_find(parent_klass
, name
, NULL
);
1061 prop
= g_hash_table_lookup(klass
->properties
, name
);
1063 error_setg(errp
, "Property '.%s' not found", name
);
1068 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
1070 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1073 error_setg(errp
, "Property '.%s' not found", name
);
1077 if (prop
->release
) {
1078 prop
->release(obj
, name
, prop
->opaque
);
1080 g_hash_table_remove(obj
->properties
, name
);
1083 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
1086 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1092 error_setg(errp
, QERR_PERMISSION_DENIED
);
1094 prop
->get(obj
, v
, name
, prop
->opaque
, errp
);
1098 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
1101 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1107 error_setg(errp
, QERR_PERMISSION_DENIED
);
1109 prop
->set(obj
, v
, name
, prop
->opaque
, errp
);
1113 void object_property_set_str(Object
*obj
, const char *value
,
1114 const char *name
, Error
**errp
)
1116 QString
*qstr
= qstring_from_str(value
);
1117 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
1122 char *object_property_get_str(Object
*obj
, const char *name
,
1125 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1132 qstring
= qobject_to_qstring(ret
);
1134 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1137 retval
= g_strdup(qstring_get_str(qstring
));
1140 qobject_decref(ret
);
1144 void object_property_set_link(Object
*obj
, Object
*value
,
1145 const char *name
, Error
**errp
)
1148 gchar
*path
= object_get_canonical_path(value
);
1149 object_property_set_str(obj
, path
, name
, errp
);
1152 object_property_set_str(obj
, "", name
, errp
);
1156 Object
*object_property_get_link(Object
*obj
, const char *name
,
1159 char *str
= object_property_get_str(obj
, name
, errp
);
1160 Object
*target
= NULL
;
1163 target
= object_resolve_path(str
, NULL
);
1165 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1166 "Device '%s' not found", str
);
1174 void object_property_set_bool(Object
*obj
, bool value
,
1175 const char *name
, Error
**errp
)
1177 QBool
*qbool
= qbool_from_bool(value
);
1178 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
1183 bool object_property_get_bool(Object
*obj
, const char *name
,
1186 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1193 qbool
= qobject_to_qbool(ret
);
1195 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1198 retval
= qbool_get_bool(qbool
);
1201 qobject_decref(ret
);
1205 void object_property_set_int(Object
*obj
, int64_t value
,
1206 const char *name
, Error
**errp
)
1208 QNum
*qnum
= qnum_from_int(value
);
1209 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1214 int64_t object_property_get_int(Object
*obj
, const char *name
,
1217 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1225 qnum
= qobject_to_qnum(ret
);
1226 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1227 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1231 qobject_decref(ret
);
1235 void object_property_set_uint(Object
*obj
, uint64_t value
,
1236 const char *name
, Error
**errp
)
1238 QNum
*qnum
= qnum_from_uint(value
);
1240 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1244 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1247 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1254 qnum
= qobject_to_qnum(ret
);
1255 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1256 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "uint");
1260 qobject_decref(ret
);
1264 typedef struct EnumProperty
{
1265 const QEnumLookup
*lookup
;
1266 int (*get
)(Object
*, Error
**);
1267 void (*set
)(Object
*, int, Error
**);
1270 int object_property_get_enum(Object
*obj
, const char *name
,
1271 const char *typename
, Error
**errp
)
1277 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1278 EnumProperty
*enumprop
;
1284 if (!g_str_equal(prop
->type
, typename
)) {
1285 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1286 name
, object_class_get_name(
1287 object_get_class(obj
)), typename
);
1291 enumprop
= prop
->opaque
;
1293 v
= string_output_visitor_new(false, &str
);
1294 object_property_get(obj
, v
, name
, &err
);
1296 error_propagate(errp
, err
);
1300 visit_complete(v
, &str
);
1302 v
= string_input_visitor_new(str
);
1303 visit_type_enum(v
, name
, &ret
, enumprop
->lookup
, errp
);
1311 void object_property_get_uint16List(Object
*obj
, const char *name
,
1312 uint16List
**list
, Error
**errp
)
1318 v
= string_output_visitor_new(false, &str
);
1319 object_property_get(obj
, v
, name
, &err
);
1321 error_propagate(errp
, err
);
1324 visit_complete(v
, &str
);
1326 v
= string_input_visitor_new(str
);
1327 visit_type_uint16List(v
, NULL
, list
, errp
);
1334 void object_property_parse(Object
*obj
, const char *string
,
1335 const char *name
, Error
**errp
)
1337 Visitor
*v
= string_input_visitor_new(string
);
1338 object_property_set(obj
, v
, name
, errp
);
1342 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1346 char *string
= NULL
;
1347 Error
*local_err
= NULL
;
1349 v
= string_output_visitor_new(human
, &string
);
1350 object_property_get(obj
, v
, name
, &local_err
);
1352 error_propagate(errp
, local_err
);
1356 visit_complete(v
, &string
);
1363 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1365 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1373 Object
*object_get_root(void)
1375 static Object
*root
;
1378 root
= object_new("container");
1384 Object
*object_get_objects_root(void)
1386 return container_get(object_get_root(), "/objects");
1389 Object
*object_get_internal_root(void)
1391 static Object
*internal_root
;
1393 if (!internal_root
) {
1394 internal_root
= object_new("container");
1397 return internal_root
;
1400 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1401 const char *name
, void *opaque
,
1404 Object
*child
= opaque
;
1407 path
= object_get_canonical_path(child
);
1408 visit_type_str(v
, name
, &path
, errp
);
1412 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1417 static void object_finalize_child_property(Object
*obj
, const char *name
,
1420 Object
*child
= opaque
;
1422 if (child
->class->unparent
) {
1423 (child
->class->unparent
)(child
);
1425 child
->parent
= NULL
;
1426 object_unref(child
);
1429 void object_property_add_child(Object
*obj
, const char *name
,
1430 Object
*child
, Error
**errp
)
1432 Error
*local_err
= NULL
;
1436 if (child
->parent
!= NULL
) {
1437 error_setg(errp
, "child object is already parented");
1441 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1443 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1444 object_finalize_child_property
, child
, &local_err
);
1446 error_propagate(errp
, local_err
);
1450 op
->resolve
= object_resolve_child_property
;
1452 child
->parent
= obj
;
1458 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1459 Object
*val
, Error
**errp
)
1461 /* Allow the link to be set, always */
1466 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1467 ObjectPropertyLinkFlags flags
;
1470 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1471 const char *name
, void *opaque
,
1474 LinkProperty
*lprop
= opaque
;
1475 Object
**child
= lprop
->child
;
1479 path
= object_get_canonical_path(*child
);
1480 visit_type_str(v
, name
, &path
, errp
);
1484 visit_type_str(v
, name
, &path
, errp
);
1489 * object_resolve_link:
1491 * Lookup an object and ensure its type matches the link property type. This
1492 * is similar to object_resolve_path() except type verification against the
1493 * link property is performed.
1495 * Returns: The matched object or NULL on path lookup failures.
1497 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1498 const char *path
, Error
**errp
)
1502 bool ambiguous
= false;
1505 /* Go from link<FOO> to FOO. */
1506 type
= object_property_get_type(obj
, name
, NULL
);
1507 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1508 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1511 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1513 } else if (!target
) {
1514 target
= object_resolve_path(path
, &ambiguous
);
1515 if (target
|| ambiguous
) {
1516 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1518 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1519 "Device '%s' not found", path
);
1523 g_free(target_type
);
1528 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1529 const char *name
, void *opaque
,
1532 Error
*local_err
= NULL
;
1533 LinkProperty
*prop
= opaque
;
1534 Object
**child
= prop
->child
;
1535 Object
*old_target
= *child
;
1536 Object
*new_target
= NULL
;
1539 visit_type_str(v
, name
, &path
, &local_err
);
1541 if (!local_err
&& strcmp(path
, "") != 0) {
1542 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1547 error_propagate(errp
, local_err
);
1551 prop
->check(obj
, name
, new_target
, &local_err
);
1553 error_propagate(errp
, local_err
);
1557 object_ref(new_target
);
1558 *child
= new_target
;
1559 object_unref(old_target
);
1562 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1564 LinkProperty
*lprop
= opaque
;
1566 return *lprop
->child
;
1569 static void object_release_link_property(Object
*obj
, const char *name
,
1572 LinkProperty
*prop
= opaque
;
1574 if ((prop
->flags
& OBJ_PROP_LINK_UNREF_ON_RELEASE
) && *prop
->child
) {
1575 object_unref(*prop
->child
);
1580 void object_property_add_link(Object
*obj
, const char *name
,
1581 const char *type
, Object
**child
,
1582 void (*check
)(const Object
*, const char *,
1583 Object
*, Error
**),
1584 ObjectPropertyLinkFlags flags
,
1587 Error
*local_err
= NULL
;
1588 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1592 prop
->child
= child
;
1593 prop
->check
= check
;
1594 prop
->flags
= flags
;
1596 full_type
= g_strdup_printf("link<%s>", type
);
1598 op
= object_property_add(obj
, name
, full_type
,
1599 object_get_link_property
,
1600 check
? object_set_link_property
: NULL
,
1601 object_release_link_property
,
1605 error_propagate(errp
, local_err
);
1610 op
->resolve
= object_resolve_link_property
;
1616 void object_property_add_const_link(Object
*obj
, const char *name
,
1617 Object
*target
, Error
**errp
)
1622 link_type
= g_strdup_printf("link<%s>", object_get_typename(target
));
1623 op
= object_property_add(obj
, name
, link_type
,
1624 object_get_child_property
, NULL
,
1625 NULL
, target
, errp
);
1627 op
->resolve
= object_resolve_child_property
;
1632 gchar
*object_get_canonical_path_component(Object
*obj
)
1634 ObjectProperty
*prop
= NULL
;
1635 GHashTableIter iter
;
1638 g_assert(obj
->parent
!= NULL
);
1640 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
1641 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1642 if (!object_property_is_child(prop
)) {
1646 if (prop
->opaque
== obj
) {
1647 return g_strdup(prop
->name
);
1651 /* obj had a parent but was not a child, should never happen */
1652 g_assert_not_reached();
1656 gchar
*object_get_canonical_path(Object
*obj
)
1658 Object
*root
= object_get_root();
1659 char *newpath
, *path
= NULL
;
1661 while (obj
!= root
) {
1662 char *component
= object_get_canonical_path_component(obj
);
1665 newpath
= g_strdup_printf("%s/%s", component
, path
);
1676 newpath
= g_strdup_printf("/%s", path
? path
: "");
1682 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
1684 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1689 if (prop
->resolve
) {
1690 return prop
->resolve(parent
, prop
->opaque
, part
);
1696 static Object
*object_resolve_abs_path(Object
*parent
,
1698 const char *typename
,
1703 if (parts
[index
] == NULL
) {
1704 return object_dynamic_cast(parent
, typename
);
1707 if (strcmp(parts
[index
], "") == 0) {
1708 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
1711 child
= object_resolve_path_component(parent
, parts
[index
]);
1716 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
1719 static Object
*object_resolve_partial_path(Object
*parent
,
1721 const char *typename
,
1725 GHashTableIter iter
;
1726 ObjectProperty
*prop
;
1728 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
1730 g_hash_table_iter_init(&iter
, parent
->properties
);
1731 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1734 if (!object_property_is_child(prop
)) {
1738 found
= object_resolve_partial_path(prop
->opaque
, parts
,
1739 typename
, ambiguous
);
1756 Object
*object_resolve_path_type(const char *path
, const char *typename
,
1762 parts
= g_strsplit(path
, "/", 0);
1765 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
1766 bool ambiguous
= false;
1767 obj
= object_resolve_partial_path(object_get_root(), parts
,
1768 typename
, &ambiguous
);
1770 *ambiguousp
= ambiguous
;
1773 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
1781 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
1783 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
1786 typedef struct StringProperty
1788 char *(*get
)(Object
*, Error
**);
1789 void (*set
)(Object
*, const char *, Error
**);
1792 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
1793 void *opaque
, Error
**errp
)
1795 StringProperty
*prop
= opaque
;
1799 value
= prop
->get(obj
, &err
);
1801 error_propagate(errp
, err
);
1805 visit_type_str(v
, name
, &value
, errp
);
1809 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
1810 void *opaque
, Error
**errp
)
1812 StringProperty
*prop
= opaque
;
1814 Error
*local_err
= NULL
;
1816 visit_type_str(v
, name
, &value
, &local_err
);
1818 error_propagate(errp
, local_err
);
1822 prop
->set(obj
, value
, errp
);
1826 static void property_release_str(Object
*obj
, const char *name
,
1829 StringProperty
*prop
= opaque
;
1833 void object_property_add_str(Object
*obj
, const char *name
,
1834 char *(*get
)(Object
*, Error
**),
1835 void (*set
)(Object
*, const char *, Error
**),
1838 Error
*local_err
= NULL
;
1839 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1844 object_property_add(obj
, name
, "string",
1845 get
? property_get_str
: NULL
,
1846 set
? property_set_str
: NULL
,
1847 property_release_str
,
1850 error_propagate(errp
, local_err
);
1855 void object_class_property_add_str(ObjectClass
*klass
, const char *name
,
1856 char *(*get
)(Object
*, Error
**),
1857 void (*set
)(Object
*, const char *,
1861 Error
*local_err
= NULL
;
1862 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1867 object_class_property_add(klass
, name
, "string",
1868 get
? property_get_str
: NULL
,
1869 set
? property_set_str
: NULL
,
1870 property_release_str
,
1873 error_propagate(errp
, local_err
);
1878 typedef struct BoolProperty
1880 bool (*get
)(Object
*, Error
**);
1881 void (*set
)(Object
*, bool, Error
**);
1884 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
1885 void *opaque
, Error
**errp
)
1887 BoolProperty
*prop
= opaque
;
1891 value
= prop
->get(obj
, &err
);
1893 error_propagate(errp
, err
);
1897 visit_type_bool(v
, name
, &value
, errp
);
1900 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
1901 void *opaque
, Error
**errp
)
1903 BoolProperty
*prop
= opaque
;
1905 Error
*local_err
= NULL
;
1907 visit_type_bool(v
, name
, &value
, &local_err
);
1909 error_propagate(errp
, local_err
);
1913 prop
->set(obj
, value
, errp
);
1916 static void property_release_bool(Object
*obj
, const char *name
,
1919 BoolProperty
*prop
= opaque
;
1923 void object_property_add_bool(Object
*obj
, const char *name
,
1924 bool (*get
)(Object
*, Error
**),
1925 void (*set
)(Object
*, bool, Error
**),
1928 Error
*local_err
= NULL
;
1929 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
1934 object_property_add(obj
, name
, "bool",
1935 get
? property_get_bool
: NULL
,
1936 set
? property_set_bool
: NULL
,
1937 property_release_bool
,
1940 error_propagate(errp
, local_err
);
1945 void object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
1946 bool (*get
)(Object
*, Error
**),
1947 void (*set
)(Object
*, bool, Error
**),
1950 Error
*local_err
= NULL
;
1951 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
1956 object_class_property_add(klass
, name
, "bool",
1957 get
? property_get_bool
: NULL
,
1958 set
? property_set_bool
: NULL
,
1959 property_release_bool
,
1962 error_propagate(errp
, local_err
);
1967 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
1968 void *opaque
, Error
**errp
)
1970 EnumProperty
*prop
= opaque
;
1974 value
= prop
->get(obj
, &err
);
1976 error_propagate(errp
, err
);
1980 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
1983 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
1984 void *opaque
, Error
**errp
)
1986 EnumProperty
*prop
= opaque
;
1990 visit_type_enum(v
, name
, &value
, prop
->lookup
, &err
);
1992 error_propagate(errp
, err
);
1995 prop
->set(obj
, value
, errp
);
1998 static void property_release_enum(Object
*obj
, const char *name
,
2001 EnumProperty
*prop
= opaque
;
2005 void object_property_add_enum(Object
*obj
, const char *name
,
2006 const char *typename
,
2007 const QEnumLookup
*lookup
,
2008 int (*get
)(Object
*, Error
**),
2009 void (*set
)(Object
*, int, Error
**),
2012 Error
*local_err
= NULL
;
2013 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2015 prop
->lookup
= lookup
;
2019 object_property_add(obj
, name
, typename
,
2020 get
? property_get_enum
: NULL
,
2021 set
? property_set_enum
: NULL
,
2022 property_release_enum
,
2025 error_propagate(errp
, local_err
);
2030 void object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2031 const char *typename
,
2032 const QEnumLookup
*lookup
,
2033 int (*get
)(Object
*, Error
**),
2034 void (*set
)(Object
*, int, Error
**),
2037 Error
*local_err
= NULL
;
2038 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2040 prop
->lookup
= lookup
;
2044 object_class_property_add(klass
, name
, typename
,
2045 get
? property_get_enum
: NULL
,
2046 set
? property_set_enum
: NULL
,
2047 property_release_enum
,
2050 error_propagate(errp
, local_err
);
2055 typedef struct TMProperty
{
2056 void (*get
)(Object
*, struct tm
*, Error
**);
2059 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2060 void *opaque
, Error
**errp
)
2062 TMProperty
*prop
= opaque
;
2066 prop
->get(obj
, &value
, &err
);
2071 visit_start_struct(v
, name
, NULL
, 0, &err
);
2075 visit_type_int32(v
, "tm_year", &value
.tm_year
, &err
);
2079 visit_type_int32(v
, "tm_mon", &value
.tm_mon
, &err
);
2083 visit_type_int32(v
, "tm_mday", &value
.tm_mday
, &err
);
2087 visit_type_int32(v
, "tm_hour", &value
.tm_hour
, &err
);
2091 visit_type_int32(v
, "tm_min", &value
.tm_min
, &err
);
2095 visit_type_int32(v
, "tm_sec", &value
.tm_sec
, &err
);
2099 visit_check_struct(v
, &err
);
2101 visit_end_struct(v
, NULL
);
2103 error_propagate(errp
, err
);
2107 static void property_release_tm(Object
*obj
, const char *name
,
2110 TMProperty
*prop
= opaque
;
2114 void object_property_add_tm(Object
*obj
, const char *name
,
2115 void (*get
)(Object
*, struct tm
*, Error
**),
2118 Error
*local_err
= NULL
;
2119 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2123 object_property_add(obj
, name
, "struct tm",
2124 get
? property_get_tm
: NULL
, NULL
,
2125 property_release_tm
,
2128 error_propagate(errp
, local_err
);
2133 void object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2134 void (*get
)(Object
*, struct tm
*, Error
**),
2137 Error
*local_err
= NULL
;
2138 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2142 object_class_property_add(klass
, name
, "struct tm",
2143 get
? property_get_tm
: NULL
, NULL
,
2144 property_release_tm
,
2147 error_propagate(errp
, local_err
);
2152 static char *qdev_get_type(Object
*obj
, Error
**errp
)
2154 return g_strdup(object_get_typename(obj
));
2157 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2158 void *opaque
, Error
**errp
)
2160 uint8_t value
= *(uint8_t *)opaque
;
2161 visit_type_uint8(v
, name
, &value
, errp
);
2164 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2165 void *opaque
, Error
**errp
)
2167 uint16_t value
= *(uint16_t *)opaque
;
2168 visit_type_uint16(v
, name
, &value
, errp
);
2171 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2172 void *opaque
, Error
**errp
)
2174 uint32_t value
= *(uint32_t *)opaque
;
2175 visit_type_uint32(v
, name
, &value
, errp
);
2178 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2179 void *opaque
, Error
**errp
)
2181 uint64_t value
= *(uint64_t *)opaque
;
2182 visit_type_uint64(v
, name
, &value
, errp
);
2185 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2186 const uint8_t *v
, Error
**errp
)
2188 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
2189 NULL
, NULL
, (void *)v
, errp
);
2192 void object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2193 const uint8_t *v
, Error
**errp
)
2195 object_class_property_add(klass
, name
, "uint8", property_get_uint8_ptr
,
2196 NULL
, NULL
, (void *)v
, errp
);
2199 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2200 const uint16_t *v
, Error
**errp
)
2202 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
2203 NULL
, NULL
, (void *)v
, errp
);
2206 void object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2207 const uint16_t *v
, Error
**errp
)
2209 object_class_property_add(klass
, name
, "uint16", property_get_uint16_ptr
,
2210 NULL
, NULL
, (void *)v
, errp
);
2213 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2214 const uint32_t *v
, Error
**errp
)
2216 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
2217 NULL
, NULL
, (void *)v
, errp
);
2220 void object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2221 const uint32_t *v
, Error
**errp
)
2223 object_class_property_add(klass
, name
, "uint32", property_get_uint32_ptr
,
2224 NULL
, NULL
, (void *)v
, errp
);
2227 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2228 const uint64_t *v
, Error
**errp
)
2230 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
2231 NULL
, NULL
, (void *)v
, errp
);
2234 void object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2235 const uint64_t *v
, Error
**errp
)
2237 object_class_property_add(klass
, name
, "uint64", property_get_uint64_ptr
,
2238 NULL
, NULL
, (void *)v
, errp
);
2246 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2247 void *opaque
, Error
**errp
)
2249 AliasProperty
*prop
= opaque
;
2251 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
2254 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2255 void *opaque
, Error
**errp
)
2257 AliasProperty
*prop
= opaque
;
2259 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
2262 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2265 AliasProperty
*prop
= opaque
;
2267 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2270 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2272 AliasProperty
*prop
= opaque
;
2274 g_free(prop
->target_name
);
2278 void object_property_add_alias(Object
*obj
, const char *name
,
2279 Object
*target_obj
, const char *target_name
,
2282 AliasProperty
*prop
;
2284 ObjectProperty
*target_prop
;
2286 Error
*local_err
= NULL
;
2288 target_prop
= object_property_find(target_obj
, target_name
, errp
);
2293 if (object_property_is_child(target_prop
)) {
2294 prop_type
= g_strdup_printf("link%s",
2295 target_prop
->type
+ strlen("child"));
2297 prop_type
= g_strdup(target_prop
->type
);
2300 prop
= g_malloc(sizeof(*prop
));
2301 prop
->target_obj
= target_obj
;
2302 prop
->target_name
= g_strdup(target_name
);
2304 op
= object_property_add(obj
, name
, prop_type
,
2307 property_release_alias
,
2310 error_propagate(errp
, local_err
);
2314 op
->resolve
= property_resolve_alias
;
2316 object_property_set_description(obj
, op
->name
,
2317 target_prop
->description
,
2324 void object_property_set_description(Object
*obj
, const char *name
,
2325 const char *description
, Error
**errp
)
2329 op
= object_property_find(obj
, name
, errp
);
2334 g_free(op
->description
);
2335 op
->description
= g_strdup(description
);
2338 void object_class_property_set_description(ObjectClass
*klass
,
2340 const char *description
,
2345 op
= g_hash_table_lookup(klass
->properties
, name
);
2347 error_setg(errp
, "Property '.%s' not found", name
);
2351 g_free(op
->description
);
2352 op
->description
= g_strdup(description
);
2355 static void object_instance_init(Object
*obj
)
2357 object_property_add_str(obj
, "type", qdev_get_type
, NULL
, NULL
);
2360 static void register_types(void)
2362 static TypeInfo interface_info
= {
2363 .name
= TYPE_INTERFACE
,
2364 .class_size
= sizeof(InterfaceClass
),
2368 static TypeInfo object_info
= {
2369 .name
= TYPE_OBJECT
,
2370 .instance_size
= sizeof(Object
),
2371 .instance_init
= object_instance_init
,
2375 type_interface
= type_register_internal(&interface_info
);
2376 type_register_internal(&object_info
);
2379 type_init(register_types
)