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-visit.h"
20 #include "qapi/string-input-visitor.h"
21 #include "qapi/string-output-visitor.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/qobject.h"
29 #include "qapi/qmp/qbool.h"
30 #include "qapi/qmp/qint.h"
31 #include "qapi/qmp/qstring.h"
33 #define MAX_INTERFACES 32
35 typedef struct InterfaceImpl InterfaceImpl
;
36 typedef struct TypeImpl TypeImpl
;
51 void (*class_init
)(ObjectClass
*klass
, void *data
);
52 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
53 void (*class_finalize
)(ObjectClass
*klass
, void *data
);
57 void (*instance_init
)(Object
*obj
);
58 void (*instance_post_init
)(Object
*obj
);
59 void (*instance_finalize
)(Object
*obj
);
64 TypeImpl
*parent_type
;
69 InterfaceImpl interfaces
[MAX_INTERFACES
];
72 static Type type_interface
;
74 static GHashTable
*type_table_get(void)
76 static GHashTable
*type_table
;
78 if (type_table
== NULL
) {
79 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
85 static bool enumerating_types
;
87 static void type_table_add(TypeImpl
*ti
)
89 assert(!enumerating_types
);
90 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
93 static TypeImpl
*type_table_lookup(const char *name
)
95 return g_hash_table_lookup(type_table_get(), name
);
98 static TypeImpl
*type_new(const TypeInfo
*info
)
100 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
103 g_assert(info
->name
!= NULL
);
105 if (type_table_lookup(info
->name
) != NULL
) {
106 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
110 ti
->name
= g_strdup(info
->name
);
111 ti
->parent
= g_strdup(info
->parent
);
113 ti
->class_size
= info
->class_size
;
114 ti
->instance_size
= info
->instance_size
;
116 ti
->class_init
= info
->class_init
;
117 ti
->class_base_init
= info
->class_base_init
;
118 ti
->class_finalize
= info
->class_finalize
;
119 ti
->class_data
= info
->class_data
;
121 ti
->instance_init
= info
->instance_init
;
122 ti
->instance_post_init
= info
->instance_post_init
;
123 ti
->instance_finalize
= info
->instance_finalize
;
125 ti
->abstract
= info
->abstract
;
127 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
128 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
130 ti
->num_interfaces
= i
;
135 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
144 TypeImpl
*type_register(const TypeInfo
*info
)
146 assert(info
->parent
);
147 return type_register_internal(info
);
150 TypeImpl
*type_register_static(const TypeInfo
*info
)
152 return type_register(info
);
155 static TypeImpl
*type_get_by_name(const char *name
)
161 return type_table_lookup(name
);
164 static TypeImpl
*type_get_parent(TypeImpl
*type
)
166 if (!type
->parent_type
&& type
->parent
) {
167 type
->parent_type
= type_get_by_name(type
->parent
);
168 g_assert(type
->parent_type
!= NULL
);
171 return type
->parent_type
;
174 static bool type_has_parent(TypeImpl
*type
)
176 return (type
->parent
!= NULL
);
179 static size_t type_class_get_size(TypeImpl
*ti
)
181 if (ti
->class_size
) {
182 return ti
->class_size
;
185 if (type_has_parent(ti
)) {
186 return type_class_get_size(type_get_parent(ti
));
189 return sizeof(ObjectClass
);
192 static size_t type_object_get_size(TypeImpl
*ti
)
194 if (ti
->instance_size
) {
195 return ti
->instance_size
;
198 if (type_has_parent(ti
)) {
199 return type_object_get_size(type_get_parent(ti
));
205 size_t object_type_get_instance_size(const char *typename
)
207 TypeImpl
*type
= type_get_by_name(typename
);
209 g_assert(type
!= NULL
);
210 return type_object_get_size(type
);
213 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
217 /* Check if target_type is a direct ancestor of type */
219 if (type
== target_type
) {
223 type
= type_get_parent(type
);
229 static void type_initialize(TypeImpl
*ti
);
231 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
232 TypeImpl
*parent_type
)
234 InterfaceClass
*new_iface
;
236 TypeImpl
*iface_impl
;
238 info
.parent
= parent_type
->name
;
239 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
240 info
.abstract
= true;
242 iface_impl
= type_new(&info
);
243 iface_impl
->parent_type
= parent_type
;
244 type_initialize(iface_impl
);
245 g_free((char *)info
.name
);
247 new_iface
= (InterfaceClass
*)iface_impl
->class;
248 new_iface
->concrete_class
= ti
->class;
249 new_iface
->interface_type
= interface_type
;
251 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
255 static void object_property_free(gpointer data
)
257 ObjectProperty
*prop
= data
;
261 g_free(prop
->description
);
265 static void type_initialize(TypeImpl
*ti
)
273 ti
->class_size
= type_class_get_size(ti
);
274 ti
->instance_size
= type_object_get_size(ti
);
276 ti
->class = g_malloc0(ti
->class_size
);
278 parent
= type_get_parent(ti
);
280 type_initialize(parent
);
284 g_assert_cmpint(parent
->class_size
, <=, ti
->class_size
);
285 memcpy(ti
->class, parent
->class, parent
->class_size
);
286 ti
->class->interfaces
= NULL
;
287 ti
->class->properties
= g_hash_table_new_full(
288 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
290 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
291 InterfaceClass
*iface
= e
->data
;
292 ObjectClass
*klass
= OBJECT_CLASS(iface
);
294 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
297 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
298 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
299 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
300 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
302 if (type_is_ancestor(target_type
, t
)) {
311 type_initialize_interface(ti
, t
, t
);
314 ti
->class->properties
= g_hash_table_new_full(
315 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
318 ti
->class->type
= ti
;
321 if (parent
->class_base_init
) {
322 parent
->class_base_init(ti
->class, ti
->class_data
);
324 parent
= type_get_parent(parent
);
327 if (ti
->class_init
) {
328 ti
->class_init(ti
->class, ti
->class_data
);
332 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
334 if (type_has_parent(ti
)) {
335 object_init_with_type(obj
, type_get_parent(ti
));
338 if (ti
->instance_init
) {
339 ti
->instance_init(obj
);
343 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
345 if (ti
->instance_post_init
) {
346 ti
->instance_post_init(obj
);
349 if (type_has_parent(ti
)) {
350 object_post_init_with_type(obj
, type_get_parent(ti
));
354 void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
358 g_assert(type
!= NULL
);
359 type_initialize(type
);
361 g_assert_cmpint(type
->instance_size
, >=, sizeof(Object
));
362 g_assert(type
->abstract
== false);
363 g_assert_cmpint(size
, >=, type
->instance_size
);
365 memset(obj
, 0, type
->instance_size
);
366 obj
->class = type
->class;
368 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
369 NULL
, object_property_free
);
370 object_init_with_type(obj
, type
);
371 object_post_init_with_type(obj
, type
);
374 void object_initialize(void *data
, size_t size
, const char *typename
)
376 TypeImpl
*type
= type_get_by_name(typename
);
378 object_initialize_with_type(data
, size
, type
);
381 static inline bool object_property_is_child(ObjectProperty
*prop
)
383 return strstart(prop
->type
, "child<", NULL
);
386 static void object_property_del_all(Object
*obj
)
388 ObjectProperty
*prop
;
395 g_hash_table_iter_init(&iter
, obj
->properties
);
396 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
399 prop
->release(obj
, prop
->name
, prop
->opaque
);
400 prop
->release
= NULL
;
404 g_hash_table_iter_remove(&iter
);
408 g_hash_table_unref(obj
->properties
);
411 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
413 ObjectProperty
*prop
;
417 g_hash_table_iter_init(&iter
, obj
->properties
);
418 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
420 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
422 prop
->release(obj
, prop
->name
, prop
->opaque
);
423 prop
->release
= NULL
;
428 g_hash_table_iter_init(&iter
, obj
->properties
);
429 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
431 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
432 g_hash_table_iter_remove(&iter
);
438 void object_unparent(Object
*obj
)
441 object_property_del_child(obj
->parent
, obj
, NULL
);
445 static void object_deinit(Object
*obj
, TypeImpl
*type
)
447 if (type
->instance_finalize
) {
448 type
->instance_finalize(obj
);
451 if (type_has_parent(type
)) {
452 object_deinit(obj
, type_get_parent(type
));
456 static void object_finalize(void *data
)
459 TypeImpl
*ti
= obj
->class->type
;
461 object_property_del_all(obj
);
462 object_deinit(obj
, ti
);
464 g_assert_cmpint(obj
->ref
, ==, 0);
470 Object
*object_new_with_type(Type type
)
474 g_assert(type
!= NULL
);
475 type_initialize(type
);
477 obj
= g_malloc(type
->instance_size
);
478 object_initialize_with_type(obj
, type
->instance_size
, type
);
484 Object
*object_new(const char *typename
)
486 TypeImpl
*ti
= type_get_by_name(typename
);
488 return object_new_with_type(ti
);
492 Object
*object_new_with_props(const char *typename
,
501 va_start(vargs
, errp
);
502 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
509 Object
*object_new_with_propv(const char *typename
,
517 Error
*local_err
= NULL
;
519 klass
= object_class_by_name(typename
);
521 error_setg(errp
, "invalid object type: %s", typename
);
525 if (object_class_is_abstract(klass
)) {
526 error_setg(errp
, "object type '%s' is abstract", typename
);
529 obj
= object_new(typename
);
531 if (object_set_propv(obj
, &local_err
, vargs
) < 0) {
535 object_property_add_child(parent
, id
, obj
, &local_err
);
540 if (object_dynamic_cast(obj
, TYPE_USER_CREATABLE
)) {
541 user_creatable_complete(obj
, &local_err
);
543 object_unparent(obj
);
548 object_unref(OBJECT(obj
));
553 error_propagate(errp
, local_err
);
560 int object_set_props(Object
*obj
,
567 va_start(vargs
, errp
);
568 ret
= object_set_propv(obj
, errp
, vargs
);
575 int object_set_propv(Object
*obj
,
579 const char *propname
;
580 Error
*local_err
= NULL
;
582 propname
= va_arg(vargs
, char *);
583 while (propname
!= NULL
) {
584 const char *value
= va_arg(vargs
, char *);
586 g_assert(value
!= NULL
);
587 object_property_parse(obj
, value
, propname
, &local_err
);
589 error_propagate(errp
, local_err
);
592 propname
= va_arg(vargs
, char *);
599 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
601 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
608 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
609 const char *file
, int line
, const char *func
)
611 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
612 typename
, file
, line
, func
);
614 #ifdef CONFIG_QOM_CAST_DEBUG
618 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
619 if (obj
->class->object_cast_cache
[i
] == typename
) {
624 inst
= object_dynamic_cast(obj
, typename
);
627 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
628 file
, line
, func
, obj
, typename
);
634 if (obj
&& obj
== inst
) {
635 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
636 obj
->class->object_cast_cache
[i
- 1] =
637 obj
->class->object_cast_cache
[i
];
639 obj
->class->object_cast_cache
[i
- 1] = typename
;
647 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
648 const char *typename
)
650 ObjectClass
*ret
= NULL
;
651 TypeImpl
*target_type
;
658 /* A simple fast path that can trigger a lot for leaf classes. */
660 if (type
->name
== typename
) {
664 target_type
= type_get_by_name(typename
);
666 /* target class type unknown, so fail the cast */
670 if (type
->class->interfaces
&&
671 type_is_ancestor(target_type
, type_interface
)) {
675 for (i
= class->interfaces
; i
; i
= i
->next
) {
676 ObjectClass
*target_class
= i
->data
;
678 if (type_is_ancestor(target_class
->type
, target_type
)) {
684 /* The match was ambiguous, don't allow a cast */
688 } else if (type_is_ancestor(type
, target_type
)) {
695 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
696 const char *typename
,
697 const char *file
, int line
,
702 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
703 typename
, file
, line
, func
);
705 #ifdef CONFIG_QOM_CAST_DEBUG
708 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
709 if (class->class_cast_cache
[i
] == typename
) {
715 if (!class || !class->interfaces
) {
720 ret
= object_class_dynamic_cast(class, typename
);
722 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
723 file
, line
, func
, class, typename
);
727 #ifdef CONFIG_QOM_CAST_DEBUG
728 if (class && ret
== class) {
729 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
730 class->class_cast_cache
[i
- 1] = class->class_cast_cache
[i
];
732 class->class_cast_cache
[i
- 1] = typename
;
739 const char *object_get_typename(Object
*obj
)
741 return obj
->class->type
->name
;
744 ObjectClass
*object_get_class(Object
*obj
)
749 bool object_class_is_abstract(ObjectClass
*klass
)
751 return klass
->type
->abstract
;
754 const char *object_class_get_name(ObjectClass
*klass
)
756 return klass
->type
->name
;
759 ObjectClass
*object_class_by_name(const char *typename
)
761 TypeImpl
*type
= type_get_by_name(typename
);
767 type_initialize(type
);
772 ObjectClass
*object_class_get_parent(ObjectClass
*class)
774 TypeImpl
*type
= type_get_parent(class->type
);
780 type_initialize(type
);
785 typedef struct OCFData
787 void (*fn
)(ObjectClass
*klass
, void *opaque
);
788 const char *implements_type
;
789 bool include_abstract
;
793 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
796 OCFData
*data
= opaque
;
797 TypeImpl
*type
= value
;
800 type_initialize(type
);
803 if (!data
->include_abstract
&& type
->abstract
) {
807 if (data
->implements_type
&&
808 !object_class_dynamic_cast(k
, data
->implements_type
)) {
812 data
->fn(k
, data
->opaque
);
815 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
816 const char *implements_type
, bool include_abstract
,
819 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
821 enumerating_types
= true;
822 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
823 enumerating_types
= false;
826 static int do_object_child_foreach(Object
*obj
,
827 int (*fn
)(Object
*child
, void *opaque
),
828 void *opaque
, bool recurse
)
831 ObjectProperty
*prop
;
834 g_hash_table_iter_init(&iter
, obj
->properties
);
835 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
836 if (object_property_is_child(prop
)) {
837 Object
*child
= prop
->opaque
;
839 ret
= fn(child
, opaque
);
844 do_object_child_foreach(child
, fn
, opaque
, true);
851 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
854 return do_object_child_foreach(obj
, fn
, opaque
, false);
857 int object_child_foreach_recursive(Object
*obj
,
858 int (*fn
)(Object
*child
, void *opaque
),
861 return do_object_child_foreach(obj
, fn
, opaque
, true);
864 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
866 GSList
**list
= opaque
;
868 *list
= g_slist_prepend(*list
, klass
);
871 GSList
*object_class_get_list(const char *implements_type
,
872 bool include_abstract
)
876 object_class_foreach(object_class_get_list_tramp
,
877 implements_type
, include_abstract
, &list
);
881 void object_ref(Object
*obj
)
886 atomic_inc(&obj
->ref
);
889 void object_unref(Object
*obj
)
894 g_assert_cmpint(obj
->ref
, >, 0);
896 /* parent always holds a reference to its children */
897 if (atomic_fetch_dec(&obj
->ref
) == 1) {
898 object_finalize(obj
);
903 object_property_add(Object
*obj
, const char *name
, const char *type
,
904 ObjectPropertyAccessor
*get
,
905 ObjectPropertyAccessor
*set
,
906 ObjectPropertyRelease
*release
,
907 void *opaque
, Error
**errp
)
909 ObjectProperty
*prop
;
910 size_t name_len
= strlen(name
);
912 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
915 char *name_no_array
= g_strdup(name
);
917 name_no_array
[name_len
- 3] = '\0';
919 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
921 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
922 release
, opaque
, NULL
);
928 g_free(name_no_array
);
932 if (object_property_find(obj
, name
, NULL
) != NULL
) {
933 error_setg(errp
, "attempt to add duplicate property '%s'"
934 " to object (type '%s')", name
,
935 object_get_typename(obj
));
939 prop
= g_malloc0(sizeof(*prop
));
941 prop
->name
= g_strdup(name
);
942 prop
->type
= g_strdup(type
);
946 prop
->release
= release
;
947 prop
->opaque
= opaque
;
949 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
954 object_class_property_add(ObjectClass
*klass
,
957 ObjectPropertyAccessor
*get
,
958 ObjectPropertyAccessor
*set
,
959 ObjectPropertyRelease
*release
,
963 ObjectProperty
*prop
;
965 if (object_class_property_find(klass
, name
, NULL
) != NULL
) {
966 error_setg(errp
, "attempt to add duplicate property '%s'"
967 " to object (type '%s')", name
,
968 object_class_get_name(klass
));
972 prop
= g_malloc0(sizeof(*prop
));
974 prop
->name
= g_strdup(name
);
975 prop
->type
= g_strdup(type
);
979 prop
->release
= release
;
980 prop
->opaque
= opaque
;
982 g_hash_table_insert(klass
->properties
, g_strdup(name
), prop
);
987 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
990 ObjectProperty
*prop
;
991 ObjectClass
*klass
= object_get_class(obj
);
993 prop
= object_class_property_find(klass
, name
, NULL
);
998 prop
= g_hash_table_lookup(obj
->properties
, name
);
1003 error_setg(errp
, "Property '.%s' not found", name
);
1007 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1010 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1011 iter
->nextclass
= object_get_class(obj
);
1014 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1017 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1018 if (!iter
->nextclass
) {
1021 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1022 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1027 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
,
1030 ObjectProperty
*prop
;
1031 ObjectClass
*parent_klass
;
1033 parent_klass
= object_class_get_parent(klass
);
1035 prop
= object_class_property_find(parent_klass
, name
, NULL
);
1041 prop
= g_hash_table_lookup(klass
->properties
, name
);
1043 error_setg(errp
, "Property '.%s' not found", name
);
1048 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
1050 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1053 error_setg(errp
, "Property '.%s' not found", name
);
1057 if (prop
->release
) {
1058 prop
->release(obj
, name
, prop
->opaque
);
1060 g_hash_table_remove(obj
->properties
, name
);
1063 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
1066 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1072 error_setg(errp
, QERR_PERMISSION_DENIED
);
1074 prop
->get(obj
, v
, name
, prop
->opaque
, errp
);
1078 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
1081 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1087 error_setg(errp
, QERR_PERMISSION_DENIED
);
1089 prop
->set(obj
, v
, name
, prop
->opaque
, errp
);
1093 void object_property_set_str(Object
*obj
, const char *value
,
1094 const char *name
, Error
**errp
)
1096 QString
*qstr
= qstring_from_str(value
);
1097 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
1102 char *object_property_get_str(Object
*obj
, const char *name
,
1105 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1112 qstring
= qobject_to_qstring(ret
);
1114 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1117 retval
= g_strdup(qstring_get_str(qstring
));
1124 void object_property_set_link(Object
*obj
, Object
*value
,
1125 const char *name
, Error
**errp
)
1128 gchar
*path
= object_get_canonical_path(value
);
1129 object_property_set_str(obj
, path
, name
, errp
);
1132 object_property_set_str(obj
, "", name
, errp
);
1136 Object
*object_property_get_link(Object
*obj
, const char *name
,
1139 char *str
= object_property_get_str(obj
, name
, errp
);
1140 Object
*target
= NULL
;
1143 target
= object_resolve_path(str
, NULL
);
1145 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1146 "Device '%s' not found", str
);
1154 void object_property_set_bool(Object
*obj
, bool value
,
1155 const char *name
, Error
**errp
)
1157 QBool
*qbool
= qbool_from_bool(value
);
1158 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
1163 bool object_property_get_bool(Object
*obj
, const char *name
,
1166 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1173 qbool
= qobject_to_qbool(ret
);
1175 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1178 retval
= qbool_get_bool(qbool
);
1185 void object_property_set_int(Object
*obj
, int64_t value
,
1186 const char *name
, Error
**errp
)
1188 QInt
*qint
= qint_from_int(value
);
1189 object_property_set_qobject(obj
, QOBJECT(qint
), name
, errp
);
1194 int64_t object_property_get_int(Object
*obj
, const char *name
,
1197 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1204 qint
= qobject_to_qint(ret
);
1206 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1209 retval
= qint_get_int(qint
);
1216 typedef struct EnumProperty
{
1217 const char * const *strings
;
1218 int (*get
)(Object
*, Error
**);
1219 void (*set
)(Object
*, int, Error
**);
1222 int object_property_get_enum(Object
*obj
, const char *name
,
1223 const char *typename
, Error
**errp
)
1226 StringOutputVisitor
*sov
;
1227 StringInputVisitor
*siv
;
1230 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1231 EnumProperty
*enumprop
;
1237 if (!g_str_equal(prop
->type
, typename
)) {
1238 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1239 name
, object_class_get_name(
1240 object_get_class(obj
)), typename
);
1244 enumprop
= prop
->opaque
;
1246 sov
= string_output_visitor_new(false);
1247 object_property_get(obj
, string_output_get_visitor(sov
), name
, &err
);
1249 error_propagate(errp
, err
);
1250 string_output_visitor_cleanup(sov
);
1253 str
= string_output_get_string(sov
);
1254 siv
= string_input_visitor_new(str
);
1255 string_output_visitor_cleanup(sov
);
1256 visit_type_enum(string_input_get_visitor(siv
), name
, &ret
,
1257 enumprop
->strings
, errp
);
1260 string_input_visitor_cleanup(siv
);
1265 void object_property_get_uint16List(Object
*obj
, const char *name
,
1266 uint16List
**list
, Error
**errp
)
1269 StringOutputVisitor
*ov
;
1270 StringInputVisitor
*iv
;
1273 ov
= string_output_visitor_new(false);
1274 object_property_get(obj
, string_output_get_visitor(ov
),
1277 error_propagate(errp
, err
);
1280 str
= string_output_get_string(ov
);
1281 iv
= string_input_visitor_new(str
);
1282 visit_type_uint16List(string_input_get_visitor(iv
), NULL
, list
, errp
);
1285 string_input_visitor_cleanup(iv
);
1287 string_output_visitor_cleanup(ov
);
1290 void object_property_parse(Object
*obj
, const char *string
,
1291 const char *name
, Error
**errp
)
1293 StringInputVisitor
*siv
;
1294 siv
= string_input_visitor_new(string
);
1295 object_property_set(obj
, string_input_get_visitor(siv
), name
, errp
);
1297 string_input_visitor_cleanup(siv
);
1300 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1303 StringOutputVisitor
*sov
;
1304 char *string
= NULL
;
1305 Error
*local_err
= NULL
;
1307 sov
= string_output_visitor_new(human
);
1308 object_property_get(obj
, string_output_get_visitor(sov
), name
, &local_err
);
1310 error_propagate(errp
, local_err
);
1314 string
= string_output_get_string(sov
);
1317 string_output_visitor_cleanup(sov
);
1321 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1323 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1331 Object
*object_get_root(void)
1333 static Object
*root
;
1336 root
= object_new("container");
1342 Object
*object_get_objects_root(void)
1344 return container_get(object_get_root(), "/objects");
1347 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1348 const char *name
, void *opaque
,
1351 Object
*child
= opaque
;
1354 path
= object_get_canonical_path(child
);
1355 visit_type_str(v
, name
, &path
, errp
);
1359 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1364 static void object_finalize_child_property(Object
*obj
, const char *name
,
1367 Object
*child
= opaque
;
1369 if (child
->class->unparent
) {
1370 (child
->class->unparent
)(child
);
1372 child
->parent
= NULL
;
1373 object_unref(child
);
1376 void object_property_add_child(Object
*obj
, const char *name
,
1377 Object
*child
, Error
**errp
)
1379 Error
*local_err
= NULL
;
1383 if (child
->parent
!= NULL
) {
1384 error_setg(errp
, "child object is already parented");
1388 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1390 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1391 object_finalize_child_property
, child
, &local_err
);
1393 error_propagate(errp
, local_err
);
1397 op
->resolve
= object_resolve_child_property
;
1399 child
->parent
= obj
;
1405 void object_property_allow_set_link(Object
*obj
, const char *name
,
1406 Object
*val
, Error
**errp
)
1408 /* Allow the link to be set, always */
1413 void (*check
)(Object
*, const char *, Object
*, Error
**);
1414 ObjectPropertyLinkFlags flags
;
1417 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1418 const char *name
, void *opaque
,
1421 LinkProperty
*lprop
= opaque
;
1422 Object
**child
= lprop
->child
;
1426 path
= object_get_canonical_path(*child
);
1427 visit_type_str(v
, name
, &path
, errp
);
1431 visit_type_str(v
, name
, &path
, errp
);
1436 * object_resolve_link:
1438 * Lookup an object and ensure its type matches the link property type. This
1439 * is similar to object_resolve_path() except type verification against the
1440 * link property is performed.
1442 * Returns: The matched object or NULL on path lookup failures.
1444 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1445 const char *path
, Error
**errp
)
1449 bool ambiguous
= false;
1452 /* Go from link<FOO> to FOO. */
1453 type
= object_property_get_type(obj
, name
, NULL
);
1454 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1455 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1458 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1460 } else if (!target
) {
1461 target
= object_resolve_path(path
, &ambiguous
);
1462 if (target
|| ambiguous
) {
1463 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1465 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1466 "Device '%s' not found", path
);
1470 g_free(target_type
);
1475 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1476 const char *name
, void *opaque
,
1479 Error
*local_err
= NULL
;
1480 LinkProperty
*prop
= opaque
;
1481 Object
**child
= prop
->child
;
1482 Object
*old_target
= *child
;
1483 Object
*new_target
= NULL
;
1486 visit_type_str(v
, name
, &path
, &local_err
);
1488 if (!local_err
&& strcmp(path
, "") != 0) {
1489 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1494 error_propagate(errp
, local_err
);
1498 prop
->check(obj
, name
, new_target
, &local_err
);
1500 error_propagate(errp
, local_err
);
1504 object_ref(new_target
);
1505 *child
= new_target
;
1506 object_unref(old_target
);
1509 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1511 LinkProperty
*lprop
= opaque
;
1513 return *lprop
->child
;
1516 static void object_release_link_property(Object
*obj
, const char *name
,
1519 LinkProperty
*prop
= opaque
;
1521 if ((prop
->flags
& OBJ_PROP_LINK_UNREF_ON_RELEASE
) && *prop
->child
) {
1522 object_unref(*prop
->child
);
1527 void object_property_add_link(Object
*obj
, const char *name
,
1528 const char *type
, Object
**child
,
1529 void (*check
)(Object
*, const char *,
1530 Object
*, Error
**),
1531 ObjectPropertyLinkFlags flags
,
1534 Error
*local_err
= NULL
;
1535 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1539 prop
->child
= child
;
1540 prop
->check
= check
;
1541 prop
->flags
= flags
;
1543 full_type
= g_strdup_printf("link<%s>", type
);
1545 op
= object_property_add(obj
, name
, full_type
,
1546 object_get_link_property
,
1547 check
? object_set_link_property
: NULL
,
1548 object_release_link_property
,
1552 error_propagate(errp
, local_err
);
1557 op
->resolve
= object_resolve_link_property
;
1563 void object_property_add_const_link(Object
*obj
, const char *name
,
1564 Object
*target
, Error
**errp
)
1569 link_type
= g_strdup_printf("link<%s>", object_get_typename(target
));
1570 op
= object_property_add(obj
, name
, link_type
,
1571 object_get_child_property
, NULL
,
1572 NULL
, target
, errp
);
1574 op
->resolve
= object_resolve_child_property
;
1579 gchar
*object_get_canonical_path_component(Object
*obj
)
1581 ObjectProperty
*prop
= NULL
;
1582 GHashTableIter iter
;
1585 g_assert(obj
->parent
!= NULL
);
1587 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
1588 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1589 if (!object_property_is_child(prop
)) {
1593 if (prop
->opaque
== obj
) {
1594 return g_strdup(prop
->name
);
1598 /* obj had a parent but was not a child, should never happen */
1599 g_assert_not_reached();
1603 gchar
*object_get_canonical_path(Object
*obj
)
1605 Object
*root
= object_get_root();
1606 char *newpath
, *path
= NULL
;
1608 while (obj
!= root
) {
1609 char *component
= object_get_canonical_path_component(obj
);
1612 newpath
= g_strdup_printf("%s/%s", component
, path
);
1623 newpath
= g_strdup_printf("/%s", path
? path
: "");
1629 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
1631 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1636 if (prop
->resolve
) {
1637 return prop
->resolve(parent
, prop
->opaque
, part
);
1643 static Object
*object_resolve_abs_path(Object
*parent
,
1645 const char *typename
,
1650 if (parts
[index
] == NULL
) {
1651 return object_dynamic_cast(parent
, typename
);
1654 if (strcmp(parts
[index
], "") == 0) {
1655 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
1658 child
= object_resolve_path_component(parent
, parts
[index
]);
1663 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
1666 static Object
*object_resolve_partial_path(Object
*parent
,
1668 const char *typename
,
1672 GHashTableIter iter
;
1673 ObjectProperty
*prop
;
1675 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
1677 g_hash_table_iter_init(&iter
, parent
->properties
);
1678 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1681 if (!object_property_is_child(prop
)) {
1685 found
= object_resolve_partial_path(prop
->opaque
, parts
,
1686 typename
, ambiguous
);
1697 if (ambiguous
&& *ambiguous
) {
1705 Object
*object_resolve_path_type(const char *path
, const char *typename
,
1711 parts
= g_strsplit(path
, "/", 0);
1714 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
1718 obj
= object_resolve_partial_path(object_get_root(), parts
,
1719 typename
, ambiguous
);
1721 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
1729 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
1731 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
1734 typedef struct StringProperty
1736 char *(*get
)(Object
*, Error
**);
1737 void (*set
)(Object
*, const char *, Error
**);
1740 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
1741 void *opaque
, Error
**errp
)
1743 StringProperty
*prop
= opaque
;
1747 value
= prop
->get(obj
, &err
);
1749 error_propagate(errp
, err
);
1753 visit_type_str(v
, name
, &value
, errp
);
1757 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
1758 void *opaque
, Error
**errp
)
1760 StringProperty
*prop
= opaque
;
1762 Error
*local_err
= NULL
;
1764 visit_type_str(v
, name
, &value
, &local_err
);
1766 error_propagate(errp
, local_err
);
1770 prop
->set(obj
, value
, errp
);
1774 static void property_release_str(Object
*obj
, const char *name
,
1777 StringProperty
*prop
= opaque
;
1781 void object_property_add_str(Object
*obj
, const char *name
,
1782 char *(*get
)(Object
*, Error
**),
1783 void (*set
)(Object
*, const char *, Error
**),
1786 Error
*local_err
= NULL
;
1787 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1792 object_property_add(obj
, name
, "string",
1793 get
? property_get_str
: NULL
,
1794 set
? property_set_str
: NULL
,
1795 property_release_str
,
1798 error_propagate(errp
, local_err
);
1803 void object_class_property_add_str(ObjectClass
*klass
, const char *name
,
1804 char *(*get
)(Object
*, Error
**),
1805 void (*set
)(Object
*, const char *,
1809 Error
*local_err
= NULL
;
1810 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1815 object_class_property_add(klass
, name
, "string",
1816 get
? property_get_str
: NULL
,
1817 set
? property_set_str
: NULL
,
1818 property_release_str
,
1821 error_propagate(errp
, local_err
);
1826 typedef struct BoolProperty
1828 bool (*get
)(Object
*, Error
**);
1829 void (*set
)(Object
*, bool, Error
**);
1832 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
1833 void *opaque
, Error
**errp
)
1835 BoolProperty
*prop
= opaque
;
1839 value
= prop
->get(obj
, &err
);
1841 error_propagate(errp
, err
);
1845 visit_type_bool(v
, name
, &value
, errp
);
1848 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
1849 void *opaque
, Error
**errp
)
1851 BoolProperty
*prop
= opaque
;
1853 Error
*local_err
= NULL
;
1855 visit_type_bool(v
, name
, &value
, &local_err
);
1857 error_propagate(errp
, local_err
);
1861 prop
->set(obj
, value
, errp
);
1864 static void property_release_bool(Object
*obj
, const char *name
,
1867 BoolProperty
*prop
= opaque
;
1871 void object_property_add_bool(Object
*obj
, const char *name
,
1872 bool (*get
)(Object
*, Error
**),
1873 void (*set
)(Object
*, bool, Error
**),
1876 Error
*local_err
= NULL
;
1877 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
1882 object_property_add(obj
, name
, "bool",
1883 get
? property_get_bool
: NULL
,
1884 set
? property_set_bool
: NULL
,
1885 property_release_bool
,
1888 error_propagate(errp
, local_err
);
1893 void object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
1894 bool (*get
)(Object
*, Error
**),
1895 void (*set
)(Object
*, bool, Error
**),
1898 Error
*local_err
= NULL
;
1899 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
1904 object_class_property_add(klass
, name
, "bool",
1905 get
? property_get_bool
: NULL
,
1906 set
? property_set_bool
: NULL
,
1907 property_release_bool
,
1910 error_propagate(errp
, local_err
);
1915 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
1916 void *opaque
, Error
**errp
)
1918 EnumProperty
*prop
= opaque
;
1922 value
= prop
->get(obj
, &err
);
1924 error_propagate(errp
, err
);
1928 visit_type_enum(v
, name
, &value
, prop
->strings
, errp
);
1931 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
1932 void *opaque
, Error
**errp
)
1934 EnumProperty
*prop
= opaque
;
1938 visit_type_enum(v
, name
, &value
, prop
->strings
, &err
);
1940 error_propagate(errp
, err
);
1943 prop
->set(obj
, value
, errp
);
1946 static void property_release_enum(Object
*obj
, const char *name
,
1949 EnumProperty
*prop
= opaque
;
1953 void object_property_add_enum(Object
*obj
, const char *name
,
1954 const char *typename
,
1955 const char * const *strings
,
1956 int (*get
)(Object
*, Error
**),
1957 void (*set
)(Object
*, int, Error
**),
1960 Error
*local_err
= NULL
;
1961 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
1963 prop
->strings
= strings
;
1967 object_property_add(obj
, name
, typename
,
1968 get
? property_get_enum
: NULL
,
1969 set
? property_set_enum
: NULL
,
1970 property_release_enum
,
1973 error_propagate(errp
, local_err
);
1978 void object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
1979 const char *typename
,
1980 const char * const *strings
,
1981 int (*get
)(Object
*, Error
**),
1982 void (*set
)(Object
*, int, Error
**),
1985 Error
*local_err
= NULL
;
1986 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
1988 prop
->strings
= strings
;
1992 object_class_property_add(klass
, name
, typename
,
1993 get
? property_get_enum
: NULL
,
1994 set
? property_set_enum
: NULL
,
1995 property_release_enum
,
1998 error_propagate(errp
, local_err
);
2003 typedef struct TMProperty
{
2004 void (*get
)(Object
*, struct tm
*, Error
**);
2007 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2008 void *opaque
, Error
**errp
)
2010 TMProperty
*prop
= opaque
;
2014 prop
->get(obj
, &value
, &err
);
2019 visit_start_struct(v
, name
, NULL
, 0, &err
);
2023 visit_type_int32(v
, "tm_year", &value
.tm_year
, &err
);
2027 visit_type_int32(v
, "tm_mon", &value
.tm_mon
, &err
);
2031 visit_type_int32(v
, "tm_mday", &value
.tm_mday
, &err
);
2035 visit_type_int32(v
, "tm_hour", &value
.tm_hour
, &err
);
2039 visit_type_int32(v
, "tm_min", &value
.tm_min
, &err
);
2043 visit_type_int32(v
, "tm_sec", &value
.tm_sec
, &err
);
2047 visit_check_struct(v
, &err
);
2049 visit_end_struct(v
);
2051 error_propagate(errp
, err
);
2055 static void property_release_tm(Object
*obj
, const char *name
,
2058 TMProperty
*prop
= opaque
;
2062 void object_property_add_tm(Object
*obj
, const char *name
,
2063 void (*get
)(Object
*, struct tm
*, Error
**),
2066 Error
*local_err
= NULL
;
2067 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2071 object_property_add(obj
, name
, "struct tm",
2072 get
? property_get_tm
: NULL
, NULL
,
2073 property_release_tm
,
2076 error_propagate(errp
, local_err
);
2081 void object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2082 void (*get
)(Object
*, struct tm
*, Error
**),
2085 Error
*local_err
= NULL
;
2086 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2090 object_class_property_add(klass
, name
, "struct tm",
2091 get
? property_get_tm
: NULL
, NULL
,
2092 property_release_tm
,
2095 error_propagate(errp
, local_err
);
2100 static char *qdev_get_type(Object
*obj
, Error
**errp
)
2102 return g_strdup(object_get_typename(obj
));
2105 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2106 void *opaque
, Error
**errp
)
2108 uint8_t value
= *(uint8_t *)opaque
;
2109 visit_type_uint8(v
, name
, &value
, errp
);
2112 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2113 void *opaque
, Error
**errp
)
2115 uint16_t value
= *(uint16_t *)opaque
;
2116 visit_type_uint16(v
, name
, &value
, errp
);
2119 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2120 void *opaque
, Error
**errp
)
2122 uint32_t value
= *(uint32_t *)opaque
;
2123 visit_type_uint32(v
, name
, &value
, errp
);
2126 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2127 void *opaque
, Error
**errp
)
2129 uint64_t value
= *(uint64_t *)opaque
;
2130 visit_type_uint64(v
, name
, &value
, errp
);
2133 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2134 const uint8_t *v
, Error
**errp
)
2136 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
2137 NULL
, NULL
, (void *)v
, errp
);
2140 void object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2141 const uint8_t *v
, Error
**errp
)
2143 object_class_property_add(klass
, name
, "uint8", property_get_uint8_ptr
,
2144 NULL
, NULL
, (void *)v
, errp
);
2147 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2148 const uint16_t *v
, Error
**errp
)
2150 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
2151 NULL
, NULL
, (void *)v
, errp
);
2154 void object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2155 const uint16_t *v
, Error
**errp
)
2157 object_class_property_add(klass
, name
, "uint16", property_get_uint16_ptr
,
2158 NULL
, NULL
, (void *)v
, errp
);
2161 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2162 const uint32_t *v
, Error
**errp
)
2164 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
2165 NULL
, NULL
, (void *)v
, errp
);
2168 void object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2169 const uint32_t *v
, Error
**errp
)
2171 object_class_property_add(klass
, name
, "uint32", property_get_uint32_ptr
,
2172 NULL
, NULL
, (void *)v
, errp
);
2175 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2176 const uint64_t *v
, Error
**errp
)
2178 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
2179 NULL
, NULL
, (void *)v
, errp
);
2182 void object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2183 const uint64_t *v
, Error
**errp
)
2185 object_class_property_add(klass
, name
, "uint64", property_get_uint64_ptr
,
2186 NULL
, NULL
, (void *)v
, errp
);
2194 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2195 void *opaque
, Error
**errp
)
2197 AliasProperty
*prop
= opaque
;
2199 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
2202 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2203 void *opaque
, Error
**errp
)
2205 AliasProperty
*prop
= opaque
;
2207 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
2210 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2213 AliasProperty
*prop
= opaque
;
2215 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2218 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2220 AliasProperty
*prop
= opaque
;
2222 g_free(prop
->target_name
);
2226 void object_property_add_alias(Object
*obj
, const char *name
,
2227 Object
*target_obj
, const char *target_name
,
2230 AliasProperty
*prop
;
2232 ObjectProperty
*target_prop
;
2234 Error
*local_err
= NULL
;
2236 target_prop
= object_property_find(target_obj
, target_name
, errp
);
2241 if (object_property_is_child(target_prop
)) {
2242 prop_type
= g_strdup_printf("link%s",
2243 target_prop
->type
+ strlen("child"));
2245 prop_type
= g_strdup(target_prop
->type
);
2248 prop
= g_malloc(sizeof(*prop
));
2249 prop
->target_obj
= target_obj
;
2250 prop
->target_name
= g_strdup(target_name
);
2252 op
= object_property_add(obj
, name
, prop_type
,
2255 property_release_alias
,
2258 error_propagate(errp
, local_err
);
2262 op
->resolve
= property_resolve_alias
;
2264 object_property_set_description(obj
, op
->name
,
2265 target_prop
->description
,
2272 void object_property_set_description(Object
*obj
, const char *name
,
2273 const char *description
, Error
**errp
)
2277 op
= object_property_find(obj
, name
, errp
);
2282 g_free(op
->description
);
2283 op
->description
= g_strdup(description
);
2286 void object_class_property_set_description(ObjectClass
*klass
,
2288 const char *description
,
2293 op
= g_hash_table_lookup(klass
->properties
, name
);
2295 error_setg(errp
, "Property '.%s' not found", name
);
2299 g_free(op
->description
);
2300 op
->description
= g_strdup(description
);
2303 static void object_instance_init(Object
*obj
)
2305 object_property_add_str(obj
, "type", qdev_get_type
, NULL
, NULL
);
2308 static void register_types(void)
2310 static TypeInfo interface_info
= {
2311 .name
= TYPE_INTERFACE
,
2312 .class_size
= sizeof(InterfaceClass
),
2316 static TypeInfo object_info
= {
2317 .name
= TYPE_OBJECT
,
2318 .instance_size
= sizeof(Object
),
2319 .instance_init
= object_instance_init
,
2323 type_interface
= type_register_internal(&interface_info
);
2324 type_register_internal(&object_info
);
2327 type_init(register_types
)