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 "qom/object.h"
14 #include "qemu-common.h"
15 #include "qapi/visitor.h"
16 #include "qapi-visit.h"
17 #include "qapi/string-input-visitor.h"
18 #include "qapi/string-output-visitor.h"
19 #include "qapi/qmp/qerror.h"
22 /* TODO: replace QObject with a simpler visitor to avoid a dependency
23 * of the QOM core on QObject? */
24 #include "qom/qom-qobject.h"
25 #include "qapi/qmp/qobject.h"
26 #include "qapi/qmp/qbool.h"
27 #include "qapi/qmp/qint.h"
28 #include "qapi/qmp/qstring.h"
30 #define MAX_INTERFACES 32
32 typedef struct InterfaceImpl InterfaceImpl
;
33 typedef struct TypeImpl TypeImpl
;
48 void (*class_init
)(ObjectClass
*klass
, void *data
);
49 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
50 void (*class_finalize
)(ObjectClass
*klass
, void *data
);
54 void (*instance_init
)(Object
*obj
);
55 void (*instance_post_init
)(Object
*obj
);
56 void (*instance_finalize
)(Object
*obj
);
61 TypeImpl
*parent_type
;
66 InterfaceImpl interfaces
[MAX_INTERFACES
];
69 static Type type_interface
;
71 static GHashTable
*type_table_get(void)
73 static GHashTable
*type_table
;
75 if (type_table
== NULL
) {
76 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
82 static bool enumerating_types
;
84 static void type_table_add(TypeImpl
*ti
)
86 assert(!enumerating_types
);
87 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
90 static TypeImpl
*type_table_lookup(const char *name
)
92 return g_hash_table_lookup(type_table_get(), name
);
95 static TypeImpl
*type_new(const TypeInfo
*info
)
97 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
100 g_assert(info
->name
!= NULL
);
102 if (type_table_lookup(info
->name
) != NULL
) {
103 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
107 ti
->name
= g_strdup(info
->name
);
108 ti
->parent
= g_strdup(info
->parent
);
110 ti
->class_size
= info
->class_size
;
111 ti
->instance_size
= info
->instance_size
;
113 ti
->class_init
= info
->class_init
;
114 ti
->class_base_init
= info
->class_base_init
;
115 ti
->class_finalize
= info
->class_finalize
;
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 static TypeImpl
*type_get_by_name(const char *name
)
158 return type_table_lookup(name
);
161 static TypeImpl
*type_get_parent(TypeImpl
*type
)
163 if (!type
->parent_type
&& type
->parent
) {
164 type
->parent_type
= type_get_by_name(type
->parent
);
165 g_assert(type
->parent_type
!= NULL
);
168 return type
->parent_type
;
171 static bool type_has_parent(TypeImpl
*type
)
173 return (type
->parent
!= NULL
);
176 static size_t type_class_get_size(TypeImpl
*ti
)
178 if (ti
->class_size
) {
179 return ti
->class_size
;
182 if (type_has_parent(ti
)) {
183 return type_class_get_size(type_get_parent(ti
));
186 return sizeof(ObjectClass
);
189 static size_t type_object_get_size(TypeImpl
*ti
)
191 if (ti
->instance_size
) {
192 return ti
->instance_size
;
195 if (type_has_parent(ti
)) {
196 return type_object_get_size(type_get_parent(ti
));
202 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
206 /* Check if typename is a direct ancestor of type */
208 if (type
== target_type
) {
212 type
= type_get_parent(type
);
218 static void type_initialize(TypeImpl
*ti
);
220 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
221 TypeImpl
*parent_type
)
223 InterfaceClass
*new_iface
;
225 TypeImpl
*iface_impl
;
227 info
.parent
= parent_type
->name
;
228 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
229 info
.abstract
= true;
231 iface_impl
= type_new(&info
);
232 iface_impl
->parent_type
= parent_type
;
233 type_initialize(iface_impl
);
234 g_free((char *)info
.name
);
236 new_iface
= (InterfaceClass
*)iface_impl
->class;
237 new_iface
->concrete_class
= ti
->class;
238 new_iface
->interface_type
= interface_type
;
240 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
244 static void type_initialize(TypeImpl
*ti
)
252 ti
->class_size
= type_class_get_size(ti
);
253 ti
->instance_size
= type_object_get_size(ti
);
255 ti
->class = g_malloc0(ti
->class_size
);
257 parent
= type_get_parent(ti
);
259 type_initialize(parent
);
263 g_assert(parent
->class_size
<= ti
->class_size
);
264 memcpy(ti
->class, parent
->class, parent
->class_size
);
265 ti
->class->interfaces
= NULL
;
267 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
268 InterfaceClass
*iface
= e
->data
;
269 ObjectClass
*klass
= OBJECT_CLASS(iface
);
271 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
274 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
275 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
276 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
277 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
279 if (type_is_ancestor(target_type
, t
)) {
288 type_initialize_interface(ti
, t
, t
);
292 ti
->class->type
= ti
;
295 if (parent
->class_base_init
) {
296 parent
->class_base_init(ti
->class, ti
->class_data
);
298 parent
= type_get_parent(parent
);
301 if (ti
->class_init
) {
302 ti
->class_init(ti
->class, ti
->class_data
);
306 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
308 if (type_has_parent(ti
)) {
309 object_init_with_type(obj
, type_get_parent(ti
));
312 if (ti
->instance_init
) {
313 ti
->instance_init(obj
);
317 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
319 if (ti
->instance_post_init
) {
320 ti
->instance_post_init(obj
);
323 if (type_has_parent(ti
)) {
324 object_post_init_with_type(obj
, type_get_parent(ti
));
328 void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
332 g_assert(type
!= NULL
);
333 type_initialize(type
);
335 g_assert(type
->instance_size
>= sizeof(Object
));
336 g_assert(type
->abstract
== false);
337 g_assert(size
>= type
->instance_size
);
339 memset(obj
, 0, type
->instance_size
);
340 obj
->class = type
->class;
342 QTAILQ_INIT(&obj
->properties
);
343 object_init_with_type(obj
, type
);
344 object_post_init_with_type(obj
, type
);
347 void object_initialize(void *data
, size_t size
, const char *typename
)
349 TypeImpl
*type
= type_get_by_name(typename
);
351 object_initialize_with_type(data
, size
, type
);
354 static inline bool object_property_is_child(ObjectProperty
*prop
)
356 return strstart(prop
->type
, "child<", NULL
);
359 static void object_property_del_all(Object
*obj
)
361 while (!QTAILQ_EMPTY(&obj
->properties
)) {
362 ObjectProperty
*prop
= QTAILQ_FIRST(&obj
->properties
);
364 QTAILQ_REMOVE(&obj
->properties
, prop
, node
);
367 prop
->release(obj
, prop
->name
, prop
->opaque
);
372 g_free(prop
->description
);
377 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
379 ObjectProperty
*prop
;
381 QTAILQ_FOREACH(prop
, &obj
->properties
, node
) {
382 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
383 object_property_del(obj
, prop
->name
, errp
);
389 void object_unparent(Object
*obj
)
392 object_property_del_child(obj
->parent
, obj
, NULL
);
396 static void object_deinit(Object
*obj
, TypeImpl
*type
)
398 if (type
->instance_finalize
) {
399 type
->instance_finalize(obj
);
402 if (type_has_parent(type
)) {
403 object_deinit(obj
, type_get_parent(type
));
407 static void object_finalize(void *data
)
410 TypeImpl
*ti
= obj
->class->type
;
412 object_property_del_all(obj
);
413 object_deinit(obj
, ti
);
415 g_assert(obj
->ref
== 0);
421 Object
*object_new_with_type(Type type
)
425 g_assert(type
!= NULL
);
426 type_initialize(type
);
428 obj
= g_malloc(type
->instance_size
);
429 object_initialize_with_type(obj
, type
->instance_size
, type
);
435 Object
*object_new(const char *typename
)
437 TypeImpl
*ti
= type_get_by_name(typename
);
439 return object_new_with_type(ti
);
442 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
444 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
451 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
452 const char *file
, int line
, const char *func
)
454 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
455 typename
, file
, line
, func
);
457 #ifdef CONFIG_QOM_CAST_DEBUG
461 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
462 if (obj
->class->object_cast_cache
[i
] == typename
) {
467 inst
= object_dynamic_cast(obj
, typename
);
470 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
471 file
, line
, func
, obj
, typename
);
477 if (obj
&& obj
== inst
) {
478 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
479 obj
->class->object_cast_cache
[i
- 1] =
480 obj
->class->object_cast_cache
[i
];
482 obj
->class->object_cast_cache
[i
- 1] = typename
;
490 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
491 const char *typename
)
493 ObjectClass
*ret
= NULL
;
494 TypeImpl
*target_type
;
501 /* A simple fast path that can trigger a lot for leaf classes. */
503 if (type
->name
== typename
) {
507 target_type
= type_get_by_name(typename
);
509 /* target class type unknown, so fail the cast */
513 if (type
->class->interfaces
&&
514 type_is_ancestor(target_type
, type_interface
)) {
518 for (i
= class->interfaces
; i
; i
= i
->next
) {
519 ObjectClass
*target_class
= i
->data
;
521 if (type_is_ancestor(target_class
->type
, target_type
)) {
527 /* The match was ambiguous, don't allow a cast */
531 } else if (type_is_ancestor(type
, target_type
)) {
538 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
539 const char *typename
,
540 const char *file
, int line
,
545 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
546 typename
, file
, line
, func
);
548 #ifdef CONFIG_QOM_CAST_DEBUG
551 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
552 if (class->class_cast_cache
[i
] == typename
) {
558 if (!class || !class->interfaces
) {
563 ret
= object_class_dynamic_cast(class, typename
);
565 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
566 file
, line
, func
, class, typename
);
570 #ifdef CONFIG_QOM_CAST_DEBUG
571 if (class && ret
== class) {
572 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
573 class->class_cast_cache
[i
- 1] = class->class_cast_cache
[i
];
575 class->class_cast_cache
[i
- 1] = typename
;
582 const char *object_get_typename(Object
*obj
)
584 return obj
->class->type
->name
;
587 ObjectClass
*object_get_class(Object
*obj
)
592 bool object_class_is_abstract(ObjectClass
*klass
)
594 return klass
->type
->abstract
;
597 const char *object_class_get_name(ObjectClass
*klass
)
599 return klass
->type
->name
;
602 ObjectClass
*object_class_by_name(const char *typename
)
604 TypeImpl
*type
= type_get_by_name(typename
);
610 type_initialize(type
);
615 ObjectClass
*object_class_get_parent(ObjectClass
*class)
617 TypeImpl
*type
= type_get_parent(class->type
);
623 type_initialize(type
);
628 typedef struct OCFData
630 void (*fn
)(ObjectClass
*klass
, void *opaque
);
631 const char *implements_type
;
632 bool include_abstract
;
636 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
639 OCFData
*data
= opaque
;
640 TypeImpl
*type
= value
;
643 type_initialize(type
);
646 if (!data
->include_abstract
&& type
->abstract
) {
650 if (data
->implements_type
&&
651 !object_class_dynamic_cast(k
, data
->implements_type
)) {
655 data
->fn(k
, data
->opaque
);
658 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
659 const char *implements_type
, bool include_abstract
,
662 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
664 enumerating_types
= true;
665 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
666 enumerating_types
= false;
669 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
672 ObjectProperty
*prop
, *next
;
675 QTAILQ_FOREACH_SAFE(prop
, &obj
->properties
, node
, next
) {
676 if (object_property_is_child(prop
)) {
677 ret
= fn(prop
->opaque
, opaque
);
686 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
688 GSList
**list
= opaque
;
690 *list
= g_slist_prepend(*list
, klass
);
693 GSList
*object_class_get_list(const char *implements_type
,
694 bool include_abstract
)
698 object_class_foreach(object_class_get_list_tramp
,
699 implements_type
, include_abstract
, &list
);
703 void object_ref(Object
*obj
)
708 atomic_inc(&obj
->ref
);
711 void object_unref(Object
*obj
)
716 g_assert(obj
->ref
> 0);
718 /* parent always holds a reference to its children */
719 if (atomic_fetch_dec(&obj
->ref
) == 1) {
720 object_finalize(obj
);
725 object_property_add(Object
*obj
, const char *name
, const char *type
,
726 ObjectPropertyAccessor
*get
,
727 ObjectPropertyAccessor
*set
,
728 ObjectPropertyRelease
*release
,
729 void *opaque
, Error
**errp
)
731 ObjectProperty
*prop
;
732 size_t name_len
= strlen(name
);
734 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
737 char *name_no_array
= g_strdup(name
);
739 name_no_array
[name_len
- 3] = '\0';
741 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
743 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
744 release
, opaque
, NULL
);
750 g_free(name_no_array
);
754 QTAILQ_FOREACH(prop
, &obj
->properties
, node
) {
755 if (strcmp(prop
->name
, name
) == 0) {
756 error_setg(errp
, "attempt to add duplicate property '%s'"
757 " to object (type '%s')", name
,
758 object_get_typename(obj
));
763 prop
= g_malloc0(sizeof(*prop
));
765 prop
->name
= g_strdup(name
);
766 prop
->type
= g_strdup(type
);
770 prop
->release
= release
;
771 prop
->opaque
= opaque
;
773 QTAILQ_INSERT_TAIL(&obj
->properties
, prop
, node
);
777 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
780 ObjectProperty
*prop
;
782 QTAILQ_FOREACH(prop
, &obj
->properties
, node
) {
783 if (strcmp(prop
->name
, name
) == 0) {
788 error_setg(errp
, "Property '.%s' not found", name
);
792 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
794 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
800 prop
->release(obj
, name
, prop
->opaque
);
803 QTAILQ_REMOVE(&obj
->properties
, prop
, node
);
807 g_free(prop
->description
);
811 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
814 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
820 error_set(errp
, QERR_PERMISSION_DENIED
);
822 prop
->get(obj
, v
, prop
->opaque
, name
, errp
);
826 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
829 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
835 error_set(errp
, QERR_PERMISSION_DENIED
);
837 prop
->set(obj
, v
, prop
->opaque
, name
, errp
);
841 void object_property_set_str(Object
*obj
, const char *value
,
842 const char *name
, Error
**errp
)
844 QString
*qstr
= qstring_from_str(value
);
845 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
850 char *object_property_get_str(Object
*obj
, const char *name
,
853 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
860 qstring
= qobject_to_qstring(ret
);
862 error_set(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
865 retval
= g_strdup(qstring_get_str(qstring
));
872 void object_property_set_link(Object
*obj
, Object
*value
,
873 const char *name
, Error
**errp
)
876 gchar
*path
= object_get_canonical_path(value
);
877 object_property_set_str(obj
, path
, name
, errp
);
880 object_property_set_str(obj
, "", name
, errp
);
884 Object
*object_property_get_link(Object
*obj
, const char *name
,
887 char *str
= object_property_get_str(obj
, name
, errp
);
888 Object
*target
= NULL
;
891 target
= object_resolve_path(str
, NULL
);
893 error_set(errp
, QERR_DEVICE_NOT_FOUND
, str
);
901 void object_property_set_bool(Object
*obj
, bool value
,
902 const char *name
, Error
**errp
)
904 QBool
*qbool
= qbool_from_int(value
);
905 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
910 bool object_property_get_bool(Object
*obj
, const char *name
,
913 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
920 qbool
= qobject_to_qbool(ret
);
922 error_set(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
925 retval
= qbool_get_int(qbool
);
932 void object_property_set_int(Object
*obj
, int64_t value
,
933 const char *name
, Error
**errp
)
935 QInt
*qint
= qint_from_int(value
);
936 object_property_set_qobject(obj
, QOBJECT(qint
), name
, errp
);
941 int64_t object_property_get_int(Object
*obj
, const char *name
,
944 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
951 qint
= qobject_to_qint(ret
);
953 error_set(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
956 retval
= qint_get_int(qint
);
963 int object_property_get_enum(Object
*obj
, const char *name
,
964 const char *strings
[], Error
**errp
)
966 StringOutputVisitor
*sov
;
967 StringInputVisitor
*siv
;
971 sov
= string_output_visitor_new(false);
972 object_property_get(obj
, string_output_get_visitor(sov
), name
, errp
);
973 str
= string_output_get_string(sov
);
974 siv
= string_input_visitor_new(str
);
975 string_output_visitor_cleanup(sov
);
976 visit_type_enum(string_input_get_visitor(siv
),
977 &ret
, strings
, NULL
, name
, errp
);
980 string_input_visitor_cleanup(siv
);
985 void object_property_get_uint16List(Object
*obj
, const char *name
,
986 uint16List
**list
, Error
**errp
)
988 StringOutputVisitor
*ov
;
989 StringInputVisitor
*iv
;
992 ov
= string_output_visitor_new(false);
993 object_property_get(obj
, string_output_get_visitor(ov
),
995 str
= string_output_get_string(ov
);
996 iv
= string_input_visitor_new(str
);
997 visit_type_uint16List(string_input_get_visitor(iv
),
1001 string_output_visitor_cleanup(ov
);
1002 string_input_visitor_cleanup(iv
);
1005 void object_property_parse(Object
*obj
, const char *string
,
1006 const char *name
, Error
**errp
)
1008 StringInputVisitor
*mi
;
1009 mi
= string_input_visitor_new(string
);
1010 object_property_set(obj
, string_input_get_visitor(mi
), name
, errp
);
1012 string_input_visitor_cleanup(mi
);
1015 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1018 StringOutputVisitor
*mo
;
1019 char *string
= NULL
;
1020 Error
*local_err
= NULL
;
1022 mo
= string_output_visitor_new(human
);
1023 object_property_get(obj
, string_output_get_visitor(mo
), name
, &local_err
);
1025 error_propagate(errp
, local_err
);
1029 string
= string_output_get_string(mo
);
1032 string_output_visitor_cleanup(mo
);
1036 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1038 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1046 Object
*object_get_root(void)
1048 static Object
*root
;
1051 root
= object_new("container");
1057 static void object_get_child_property(Object
*obj
, Visitor
*v
, void *opaque
,
1058 const char *name
, Error
**errp
)
1060 Object
*child
= opaque
;
1063 path
= object_get_canonical_path(child
);
1064 visit_type_str(v
, &path
, name
, errp
);
1068 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1073 static void object_finalize_child_property(Object
*obj
, const char *name
,
1076 Object
*child
= opaque
;
1078 if (child
->class->unparent
) {
1079 (child
->class->unparent
)(child
);
1081 child
->parent
= NULL
;
1082 object_unref(child
);
1085 void object_property_add_child(Object
*obj
, const char *name
,
1086 Object
*child
, Error
**errp
)
1088 Error
*local_err
= NULL
;
1092 if (child
->parent
!= NULL
) {
1093 error_setg(errp
, "child object is already parented");
1097 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1099 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1100 object_finalize_child_property
, child
, &local_err
);
1102 error_propagate(errp
, local_err
);
1106 op
->resolve
= object_resolve_child_property
;
1108 child
->parent
= obj
;
1114 void object_property_allow_set_link(Object
*obj
, const char *name
,
1115 Object
*val
, Error
**errp
)
1117 /* Allow the link to be set, always */
1122 void (*check
)(Object
*, const char *, Object
*, Error
**);
1123 ObjectPropertyLinkFlags flags
;
1126 static void object_get_link_property(Object
*obj
, Visitor
*v
, void *opaque
,
1127 const char *name
, Error
**errp
)
1129 LinkProperty
*lprop
= opaque
;
1130 Object
**child
= lprop
->child
;
1134 path
= object_get_canonical_path(*child
);
1135 visit_type_str(v
, &path
, name
, errp
);
1139 visit_type_str(v
, &path
, name
, errp
);
1144 * object_resolve_link:
1146 * Lookup an object and ensure its type matches the link property type. This
1147 * is similar to object_resolve_path() except type verification against the
1148 * link property is performed.
1150 * Returns: The matched object or NULL on path lookup failures.
1152 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1153 const char *path
, Error
**errp
)
1157 bool ambiguous
= false;
1160 /* Go from link<FOO> to FOO. */
1161 type
= object_property_get_type(obj
, name
, NULL
);
1162 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1163 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1166 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
,
1167 "Path '%s' does not uniquely identify an object", path
);
1168 } else if (!target
) {
1169 target
= object_resolve_path(path
, &ambiguous
);
1170 if (target
|| ambiguous
) {
1171 error_set(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1173 error_set(errp
, QERR_DEVICE_NOT_FOUND
, path
);
1177 g_free(target_type
);
1182 static void object_set_link_property(Object
*obj
, Visitor
*v
, void *opaque
,
1183 const char *name
, Error
**errp
)
1185 Error
*local_err
= NULL
;
1186 LinkProperty
*prop
= opaque
;
1187 Object
**child
= prop
->child
;
1188 Object
*old_target
= *child
;
1189 Object
*new_target
= NULL
;
1192 visit_type_str(v
, &path
, name
, &local_err
);
1194 if (!local_err
&& strcmp(path
, "") != 0) {
1195 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1200 error_propagate(errp
, local_err
);
1204 prop
->check(obj
, name
, new_target
, &local_err
);
1206 error_propagate(errp
, local_err
);
1210 object_ref(new_target
);
1211 *child
= new_target
;
1212 object_unref(old_target
);
1215 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1217 LinkProperty
*lprop
= opaque
;
1219 return *lprop
->child
;
1222 static void object_release_link_property(Object
*obj
, const char *name
,
1225 LinkProperty
*prop
= opaque
;
1227 if ((prop
->flags
& OBJ_PROP_LINK_UNREF_ON_RELEASE
) && *prop
->child
) {
1228 object_unref(*prop
->child
);
1233 void object_property_add_link(Object
*obj
, const char *name
,
1234 const char *type
, Object
**child
,
1235 void (*check
)(Object
*, const char *,
1236 Object
*, Error
**),
1237 ObjectPropertyLinkFlags flags
,
1240 Error
*local_err
= NULL
;
1241 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1245 prop
->child
= child
;
1246 prop
->check
= check
;
1247 prop
->flags
= flags
;
1249 full_type
= g_strdup_printf("link<%s>", type
);
1251 op
= object_property_add(obj
, name
, full_type
,
1252 object_get_link_property
,
1253 check
? object_set_link_property
: NULL
,
1254 object_release_link_property
,
1258 error_propagate(errp
, local_err
);
1263 op
->resolve
= object_resolve_link_property
;
1269 gchar
*object_get_canonical_path_component(Object
*obj
)
1271 ObjectProperty
*prop
= NULL
;
1274 g_assert(obj
->parent
!= NULL
);
1276 QTAILQ_FOREACH(prop
, &obj
->parent
->properties
, node
) {
1277 if (!object_property_is_child(prop
)) {
1281 if (prop
->opaque
== obj
) {
1282 return g_strdup(prop
->name
);
1286 /* obj had a parent but was not a child, should never happen */
1287 g_assert_not_reached();
1291 gchar
*object_get_canonical_path(Object
*obj
)
1293 Object
*root
= object_get_root();
1294 char *newpath
, *path
= NULL
;
1296 while (obj
!= root
) {
1297 char *component
= object_get_canonical_path_component(obj
);
1300 newpath
= g_strdup_printf("%s/%s", component
, path
);
1311 newpath
= g_strdup_printf("/%s", path
? path
: "");
1317 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
1319 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1324 if (prop
->resolve
) {
1325 return prop
->resolve(parent
, prop
->opaque
, part
);
1331 static Object
*object_resolve_abs_path(Object
*parent
,
1333 const char *typename
,
1338 if (parts
[index
] == NULL
) {
1339 return object_dynamic_cast(parent
, typename
);
1342 if (strcmp(parts
[index
], "") == 0) {
1343 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
1346 child
= object_resolve_path_component(parent
, parts
[index
]);
1351 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
1354 static Object
*object_resolve_partial_path(Object
*parent
,
1356 const char *typename
,
1360 ObjectProperty
*prop
;
1362 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
1364 QTAILQ_FOREACH(prop
, &parent
->properties
, node
) {
1367 if (!object_property_is_child(prop
)) {
1371 found
= object_resolve_partial_path(prop
->opaque
, parts
,
1372 typename
, ambiguous
);
1383 if (ambiguous
&& *ambiguous
) {
1391 Object
*object_resolve_path_type(const char *path
, const char *typename
,
1397 parts
= g_strsplit(path
, "/", 0);
1400 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
1404 obj
= object_resolve_partial_path(object_get_root(), parts
,
1405 typename
, ambiguous
);
1407 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
1415 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
1417 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
1420 typedef struct StringProperty
1422 char *(*get
)(Object
*, Error
**);
1423 void (*set
)(Object
*, const char *, Error
**);
1426 static void property_get_str(Object
*obj
, Visitor
*v
, void *opaque
,
1427 const char *name
, Error
**errp
)
1429 StringProperty
*prop
= opaque
;
1432 value
= prop
->get(obj
, errp
);
1434 visit_type_str(v
, &value
, name
, errp
);
1439 static void property_set_str(Object
*obj
, Visitor
*v
, void *opaque
,
1440 const char *name
, Error
**errp
)
1442 StringProperty
*prop
= opaque
;
1444 Error
*local_err
= NULL
;
1446 visit_type_str(v
, &value
, name
, &local_err
);
1448 error_propagate(errp
, local_err
);
1452 prop
->set(obj
, value
, errp
);
1456 static void property_release_str(Object
*obj
, const char *name
,
1459 StringProperty
*prop
= opaque
;
1463 void object_property_add_str(Object
*obj
, const char *name
,
1464 char *(*get
)(Object
*, Error
**),
1465 void (*set
)(Object
*, const char *, Error
**),
1468 Error
*local_err
= NULL
;
1469 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1474 object_property_add(obj
, name
, "string",
1475 get
? property_get_str
: NULL
,
1476 set
? property_set_str
: NULL
,
1477 property_release_str
,
1480 error_propagate(errp
, local_err
);
1485 typedef struct BoolProperty
1487 bool (*get
)(Object
*, Error
**);
1488 void (*set
)(Object
*, bool, Error
**);
1491 static void property_get_bool(Object
*obj
, Visitor
*v
, void *opaque
,
1492 const char *name
, Error
**errp
)
1494 BoolProperty
*prop
= opaque
;
1497 value
= prop
->get(obj
, errp
);
1498 visit_type_bool(v
, &value
, name
, errp
);
1501 static void property_set_bool(Object
*obj
, Visitor
*v
, void *opaque
,
1502 const char *name
, Error
**errp
)
1504 BoolProperty
*prop
= opaque
;
1506 Error
*local_err
= NULL
;
1508 visit_type_bool(v
, &value
, name
, &local_err
);
1510 error_propagate(errp
, local_err
);
1514 prop
->set(obj
, value
, errp
);
1517 static void property_release_bool(Object
*obj
, const char *name
,
1520 BoolProperty
*prop
= opaque
;
1524 void object_property_add_bool(Object
*obj
, const char *name
,
1525 bool (*get
)(Object
*, Error
**),
1526 void (*set
)(Object
*, bool, Error
**),
1529 Error
*local_err
= NULL
;
1530 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
1535 object_property_add(obj
, name
, "bool",
1536 get
? property_get_bool
: NULL
,
1537 set
? property_set_bool
: NULL
,
1538 property_release_bool
,
1541 error_propagate(errp
, local_err
);
1546 typedef struct TMProperty
{
1547 void (*get
)(Object
*, struct tm
*, Error
**);
1550 static void property_get_tm(Object
*obj
, Visitor
*v
, void *opaque
,
1551 const char *name
, Error
**errp
)
1553 TMProperty
*prop
= opaque
;
1557 prop
->get(obj
, &value
, &err
);
1562 visit_start_struct(v
, NULL
, "struct tm", name
, 0, &err
);
1566 visit_type_int32(v
, &value
.tm_year
, "tm_year", &err
);
1570 visit_type_int32(v
, &value
.tm_mon
, "tm_mon", &err
);
1574 visit_type_int32(v
, &value
.tm_mday
, "tm_mday", &err
);
1578 visit_type_int32(v
, &value
.tm_hour
, "tm_hour", &err
);
1582 visit_type_int32(v
, &value
.tm_min
, "tm_min", &err
);
1586 visit_type_int32(v
, &value
.tm_sec
, "tm_sec", &err
);
1591 error_propagate(errp
, err
);
1593 visit_end_struct(v
, errp
);
1595 error_propagate(errp
, err
);
1599 static void property_release_tm(Object
*obj
, const char *name
,
1602 TMProperty
*prop
= opaque
;
1606 void object_property_add_tm(Object
*obj
, const char *name
,
1607 void (*get
)(Object
*, struct tm
*, Error
**),
1610 Error
*local_err
= NULL
;
1611 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
1615 object_property_add(obj
, name
, "struct tm",
1616 get
? property_get_tm
: NULL
, NULL
,
1617 property_release_tm
,
1620 error_propagate(errp
, local_err
);
1625 static char *qdev_get_type(Object
*obj
, Error
**errp
)
1627 return g_strdup(object_get_typename(obj
));
1630 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
,
1631 void *opaque
, const char *name
,
1634 uint8_t value
= *(uint8_t *)opaque
;
1635 visit_type_uint8(v
, &value
, name
, errp
);
1638 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
,
1639 void *opaque
, const char *name
,
1642 uint16_t value
= *(uint16_t *)opaque
;
1643 visit_type_uint16(v
, &value
, name
, errp
);
1646 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
,
1647 void *opaque
, const char *name
,
1650 uint32_t value
= *(uint32_t *)opaque
;
1651 visit_type_uint32(v
, &value
, name
, errp
);
1654 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
,
1655 void *opaque
, const char *name
,
1658 uint64_t value
= *(uint64_t *)opaque
;
1659 visit_type_uint64(v
, &value
, name
, errp
);
1662 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
1663 const uint8_t *v
, Error
**errp
)
1665 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
1666 NULL
, NULL
, (void *)v
, errp
);
1669 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
1670 const uint16_t *v
, Error
**errp
)
1672 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
1673 NULL
, NULL
, (void *)v
, errp
);
1676 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
1677 const uint32_t *v
, Error
**errp
)
1679 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
1680 NULL
, NULL
, (void *)v
, errp
);
1683 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
1684 const uint64_t *v
, Error
**errp
)
1686 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
1687 NULL
, NULL
, (void *)v
, errp
);
1692 const char *target_name
;
1695 static void property_get_alias(Object
*obj
, struct Visitor
*v
, void *opaque
,
1696 const char *name
, Error
**errp
)
1698 AliasProperty
*prop
= opaque
;
1700 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
1703 static void property_set_alias(Object
*obj
, struct Visitor
*v
, void *opaque
,
1704 const char *name
, Error
**errp
)
1706 AliasProperty
*prop
= opaque
;
1708 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
1711 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
1714 AliasProperty
*prop
= opaque
;
1716 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
1719 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
1721 AliasProperty
*prop
= opaque
;
1726 void object_property_add_alias(Object
*obj
, const char *name
,
1727 Object
*target_obj
, const char *target_name
,
1730 AliasProperty
*prop
;
1732 ObjectProperty
*target_prop
;
1734 Error
*local_err
= NULL
;
1736 target_prop
= object_property_find(target_obj
, target_name
, errp
);
1741 if (object_property_is_child(target_prop
)) {
1742 prop_type
= g_strdup_printf("link%s",
1743 target_prop
->type
+ strlen("child"));
1745 prop_type
= g_strdup(target_prop
->type
);
1748 prop
= g_malloc(sizeof(*prop
));
1749 prop
->target_obj
= target_obj
;
1750 prop
->target_name
= target_name
;
1752 op
= object_property_add(obj
, name
, prop_type
,
1755 property_release_alias
,
1758 error_propagate(errp
, local_err
);
1762 op
->resolve
= property_resolve_alias
;
1764 object_property_set_description(obj
, op
->name
,
1765 target_prop
->description
,
1772 void object_property_set_description(Object
*obj
, const char *name
,
1773 const char *description
, Error
**errp
)
1777 op
= object_property_find(obj
, name
, errp
);
1782 g_free(op
->description
);
1783 op
->description
= g_strdup(description
);
1786 static void object_instance_init(Object
*obj
)
1788 object_property_add_str(obj
, "type", qdev_get_type
, NULL
, NULL
);
1791 static void register_types(void)
1793 static TypeInfo interface_info
= {
1794 .name
= TYPE_INTERFACE
,
1795 .class_size
= sizeof(InterfaceClass
),
1799 static TypeInfo object_info
= {
1800 .name
= TYPE_OBJECT
,
1801 .instance_size
= sizeof(Object
),
1802 .instance_init
= object_instance_init
,
1806 type_interface
= type_register_internal(&interface_info
);
1807 type_register_internal(&object_info
);
1810 type_init(register_types
)