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 "qom/object_interfaces.h"
15 #include "qemu-common.h"
16 #include "qapi/visitor.h"
17 #include "qapi-visit.h"
18 #include "qapi/string-input-visitor.h"
19 #include "qapi/string-output-visitor.h"
20 #include "qapi/qmp/qerror.h"
23 /* TODO: replace QObject with a simpler visitor to avoid a dependency
24 * of the QOM core on QObject? */
25 #include "qom/qom-qobject.h"
26 #include "qapi/qmp/qobject.h"
27 #include "qapi/qmp/qbool.h"
28 #include "qapi/qmp/qint.h"
29 #include "qapi/qmp/qstring.h"
31 #define MAX_INTERFACES 32
33 typedef struct InterfaceImpl InterfaceImpl
;
34 typedef struct TypeImpl TypeImpl
;
49 void (*class_init
)(ObjectClass
*klass
, void *data
);
50 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
51 void (*class_finalize
)(ObjectClass
*klass
, void *data
);
55 void (*instance_init
)(Object
*obj
);
56 void (*instance_post_init
)(Object
*obj
);
57 void (*instance_finalize
)(Object
*obj
);
62 TypeImpl
*parent_type
;
67 InterfaceImpl interfaces
[MAX_INTERFACES
];
70 static Type type_interface
;
72 static GHashTable
*type_table_get(void)
74 static GHashTable
*type_table
;
76 if (type_table
== NULL
) {
77 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
83 static bool enumerating_types
;
85 static void type_table_add(TypeImpl
*ti
)
87 assert(!enumerating_types
);
88 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
91 static TypeImpl
*type_table_lookup(const char *name
)
93 return g_hash_table_lookup(type_table_get(), name
);
96 static TypeImpl
*type_new(const TypeInfo
*info
)
98 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
101 g_assert(info
->name
!= NULL
);
103 if (type_table_lookup(info
->name
) != NULL
) {
104 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
108 ti
->name
= g_strdup(info
->name
);
109 ti
->parent
= g_strdup(info
->parent
);
111 ti
->class_size
= info
->class_size
;
112 ti
->instance_size
= info
->instance_size
;
114 ti
->class_init
= info
->class_init
;
115 ti
->class_base_init
= info
->class_base_init
;
116 ti
->class_finalize
= info
->class_finalize
;
117 ti
->class_data
= info
->class_data
;
119 ti
->instance_init
= info
->instance_init
;
120 ti
->instance_post_init
= info
->instance_post_init
;
121 ti
->instance_finalize
= info
->instance_finalize
;
123 ti
->abstract
= info
->abstract
;
125 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
126 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
128 ti
->num_interfaces
= i
;
133 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
142 TypeImpl
*type_register(const TypeInfo
*info
)
144 assert(info
->parent
);
145 return type_register_internal(info
);
148 TypeImpl
*type_register_static(const TypeInfo
*info
)
150 return type_register(info
);
153 static TypeImpl
*type_get_by_name(const char *name
)
159 return type_table_lookup(name
);
162 static TypeImpl
*type_get_parent(TypeImpl
*type
)
164 if (!type
->parent_type
&& type
->parent
) {
165 type
->parent_type
= type_get_by_name(type
->parent
);
166 g_assert(type
->parent_type
!= NULL
);
169 return type
->parent_type
;
172 static bool type_has_parent(TypeImpl
*type
)
174 return (type
->parent
!= NULL
);
177 static size_t type_class_get_size(TypeImpl
*ti
)
179 if (ti
->class_size
) {
180 return ti
->class_size
;
183 if (type_has_parent(ti
)) {
184 return type_class_get_size(type_get_parent(ti
));
187 return sizeof(ObjectClass
);
190 static size_t type_object_get_size(TypeImpl
*ti
)
192 if (ti
->instance_size
) {
193 return ti
->instance_size
;
196 if (type_has_parent(ti
)) {
197 return type_object_get_size(type_get_parent(ti
));
203 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
207 /* Check if typename is a direct ancestor of type */
209 if (type
== target_type
) {
213 type
= type_get_parent(type
);
219 static void type_initialize(TypeImpl
*ti
);
221 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
222 TypeImpl
*parent_type
)
224 InterfaceClass
*new_iface
;
226 TypeImpl
*iface_impl
;
228 info
.parent
= parent_type
->name
;
229 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
230 info
.abstract
= true;
232 iface_impl
= type_new(&info
);
233 iface_impl
->parent_type
= parent_type
;
234 type_initialize(iface_impl
);
235 g_free((char *)info
.name
);
237 new_iface
= (InterfaceClass
*)iface_impl
->class;
238 new_iface
->concrete_class
= ti
->class;
239 new_iface
->interface_type
= interface_type
;
241 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
245 static void type_initialize(TypeImpl
*ti
)
253 ti
->class_size
= type_class_get_size(ti
);
254 ti
->instance_size
= type_object_get_size(ti
);
256 ti
->class = g_malloc0(ti
->class_size
);
258 parent
= type_get_parent(ti
);
260 type_initialize(parent
);
264 g_assert(parent
->class_size
<= ti
->class_size
);
265 memcpy(ti
->class, parent
->class, parent
->class_size
);
266 ti
->class->interfaces
= NULL
;
268 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
269 InterfaceClass
*iface
= e
->data
;
270 ObjectClass
*klass
= OBJECT_CLASS(iface
);
272 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
275 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
276 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
277 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
278 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
280 if (type_is_ancestor(target_type
, t
)) {
289 type_initialize_interface(ti
, t
, t
);
293 ti
->class->type
= ti
;
296 if (parent
->class_base_init
) {
297 parent
->class_base_init(ti
->class, ti
->class_data
);
299 parent
= type_get_parent(parent
);
302 if (ti
->class_init
) {
303 ti
->class_init(ti
->class, ti
->class_data
);
307 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
309 if (type_has_parent(ti
)) {
310 object_init_with_type(obj
, type_get_parent(ti
));
313 if (ti
->instance_init
) {
314 ti
->instance_init(obj
);
318 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
320 if (ti
->instance_post_init
) {
321 ti
->instance_post_init(obj
);
324 if (type_has_parent(ti
)) {
325 object_post_init_with_type(obj
, type_get_parent(ti
));
329 void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
333 g_assert(type
!= NULL
);
334 type_initialize(type
);
336 g_assert(type
->instance_size
>= sizeof(Object
));
337 g_assert(type
->abstract
== false);
338 g_assert(size
>= type
->instance_size
);
340 memset(obj
, 0, type
->instance_size
);
341 obj
->class = type
->class;
343 QTAILQ_INIT(&obj
->properties
);
344 object_init_with_type(obj
, type
);
345 object_post_init_with_type(obj
, type
);
348 void object_initialize(void *data
, size_t size
, const char *typename
)
350 TypeImpl
*type
= type_get_by_name(typename
);
352 object_initialize_with_type(data
, size
, type
);
355 static inline bool object_property_is_child(ObjectProperty
*prop
)
357 return strstart(prop
->type
, "child<", NULL
);
360 static void object_property_del_all(Object
*obj
)
362 while (!QTAILQ_EMPTY(&obj
->properties
)) {
363 ObjectProperty
*prop
= QTAILQ_FIRST(&obj
->properties
);
365 QTAILQ_REMOVE(&obj
->properties
, prop
, node
);
368 prop
->release(obj
, prop
->name
, prop
->opaque
);
373 g_free(prop
->description
);
378 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
380 ObjectProperty
*prop
;
382 QTAILQ_FOREACH(prop
, &obj
->properties
, node
) {
383 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
384 object_property_del(obj
, prop
->name
, errp
);
390 void object_unparent(Object
*obj
)
393 object_property_del_child(obj
->parent
, obj
, NULL
);
397 static void object_deinit(Object
*obj
, TypeImpl
*type
)
399 if (type
->instance_finalize
) {
400 type
->instance_finalize(obj
);
403 if (type_has_parent(type
)) {
404 object_deinit(obj
, type_get_parent(type
));
408 static void object_finalize(void *data
)
411 TypeImpl
*ti
= obj
->class->type
;
413 object_property_del_all(obj
);
414 object_deinit(obj
, ti
);
416 g_assert(obj
->ref
== 0);
422 Object
*object_new_with_type(Type type
)
426 g_assert(type
!= NULL
);
427 type_initialize(type
);
429 obj
= g_malloc(type
->instance_size
);
430 object_initialize_with_type(obj
, type
->instance_size
, type
);
436 Object
*object_new(const char *typename
)
438 TypeImpl
*ti
= type_get_by_name(typename
);
440 return object_new_with_type(ti
);
444 Object
*object_new_with_props(const char *typename
,
453 va_start(vargs
, errp
);
454 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
461 Object
*object_new_with_propv(const char *typename
,
469 Error
*local_err
= NULL
;
471 klass
= object_class_by_name(typename
);
473 error_setg(errp
, "invalid object type: %s", typename
);
477 if (object_class_is_abstract(klass
)) {
478 error_setg(errp
, "object type '%s' is abstract", typename
);
481 obj
= object_new(typename
);
483 if (object_set_propv(obj
, &local_err
, vargs
) < 0) {
487 object_property_add_child(parent
, id
, obj
, &local_err
);
492 if (object_dynamic_cast(obj
, TYPE_USER_CREATABLE
)) {
493 user_creatable_complete(obj
, &local_err
);
495 object_unparent(obj
);
500 object_unref(OBJECT(obj
));
505 error_propagate(errp
, local_err
);
512 int object_set_props(Object
*obj
,
519 va_start(vargs
, errp
);
520 ret
= object_set_propv(obj
, errp
, vargs
);
527 int object_set_propv(Object
*obj
,
531 const char *propname
;
532 Error
*local_err
= NULL
;
534 propname
= va_arg(vargs
, char *);
535 while (propname
!= NULL
) {
536 const char *value
= va_arg(vargs
, char *);
538 g_assert(value
!= NULL
);
539 object_property_parse(obj
, value
, propname
, &local_err
);
541 error_propagate(errp
, local_err
);
544 propname
= va_arg(vargs
, char *);
551 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
553 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
560 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
561 const char *file
, int line
, const char *func
)
563 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
564 typename
, file
, line
, func
);
566 #ifdef CONFIG_QOM_CAST_DEBUG
570 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
571 if (obj
->class->object_cast_cache
[i
] == typename
) {
576 inst
= object_dynamic_cast(obj
, typename
);
579 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
580 file
, line
, func
, obj
, typename
);
586 if (obj
&& obj
== inst
) {
587 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
588 obj
->class->object_cast_cache
[i
- 1] =
589 obj
->class->object_cast_cache
[i
];
591 obj
->class->object_cast_cache
[i
- 1] = typename
;
599 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
600 const char *typename
)
602 ObjectClass
*ret
= NULL
;
603 TypeImpl
*target_type
;
610 /* A simple fast path that can trigger a lot for leaf classes. */
612 if (type
->name
== typename
) {
616 target_type
= type_get_by_name(typename
);
618 /* target class type unknown, so fail the cast */
622 if (type
->class->interfaces
&&
623 type_is_ancestor(target_type
, type_interface
)) {
627 for (i
= class->interfaces
; i
; i
= i
->next
) {
628 ObjectClass
*target_class
= i
->data
;
630 if (type_is_ancestor(target_class
->type
, target_type
)) {
636 /* The match was ambiguous, don't allow a cast */
640 } else if (type_is_ancestor(type
, target_type
)) {
647 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
648 const char *typename
,
649 const char *file
, int line
,
654 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
655 typename
, file
, line
, func
);
657 #ifdef CONFIG_QOM_CAST_DEBUG
660 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
661 if (class->class_cast_cache
[i
] == typename
) {
667 if (!class || !class->interfaces
) {
672 ret
= object_class_dynamic_cast(class, typename
);
674 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
675 file
, line
, func
, class, typename
);
679 #ifdef CONFIG_QOM_CAST_DEBUG
680 if (class && ret
== class) {
681 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
682 class->class_cast_cache
[i
- 1] = class->class_cast_cache
[i
];
684 class->class_cast_cache
[i
- 1] = typename
;
691 const char *object_get_typename(Object
*obj
)
693 return obj
->class->type
->name
;
696 ObjectClass
*object_get_class(Object
*obj
)
701 bool object_class_is_abstract(ObjectClass
*klass
)
703 return klass
->type
->abstract
;
706 const char *object_class_get_name(ObjectClass
*klass
)
708 return klass
->type
->name
;
711 ObjectClass
*object_class_by_name(const char *typename
)
713 TypeImpl
*type
= type_get_by_name(typename
);
719 type_initialize(type
);
724 ObjectClass
*object_class_get_parent(ObjectClass
*class)
726 TypeImpl
*type
= type_get_parent(class->type
);
732 type_initialize(type
);
737 typedef struct OCFData
739 void (*fn
)(ObjectClass
*klass
, void *opaque
);
740 const char *implements_type
;
741 bool include_abstract
;
745 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
748 OCFData
*data
= opaque
;
749 TypeImpl
*type
= value
;
752 type_initialize(type
);
755 if (!data
->include_abstract
&& type
->abstract
) {
759 if (data
->implements_type
&&
760 !object_class_dynamic_cast(k
, data
->implements_type
)) {
764 data
->fn(k
, data
->opaque
);
767 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
768 const char *implements_type
, bool include_abstract
,
771 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
773 enumerating_types
= true;
774 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
775 enumerating_types
= false;
778 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
781 ObjectProperty
*prop
, *next
;
784 QTAILQ_FOREACH_SAFE(prop
, &obj
->properties
, node
, next
) {
785 if (object_property_is_child(prop
)) {
786 ret
= fn(prop
->opaque
, opaque
);
795 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
797 GSList
**list
= opaque
;
799 *list
= g_slist_prepend(*list
, klass
);
802 GSList
*object_class_get_list(const char *implements_type
,
803 bool include_abstract
)
807 object_class_foreach(object_class_get_list_tramp
,
808 implements_type
, include_abstract
, &list
);
812 void object_ref(Object
*obj
)
817 atomic_inc(&obj
->ref
);
820 void object_unref(Object
*obj
)
825 g_assert(obj
->ref
> 0);
827 /* parent always holds a reference to its children */
828 if (atomic_fetch_dec(&obj
->ref
) == 1) {
829 object_finalize(obj
);
834 object_property_add(Object
*obj
, const char *name
, const char *type
,
835 ObjectPropertyAccessor
*get
,
836 ObjectPropertyAccessor
*set
,
837 ObjectPropertyRelease
*release
,
838 void *opaque
, Error
**errp
)
840 ObjectProperty
*prop
;
841 size_t name_len
= strlen(name
);
843 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
846 char *name_no_array
= g_strdup(name
);
848 name_no_array
[name_len
- 3] = '\0';
850 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
852 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
853 release
, opaque
, NULL
);
859 g_free(name_no_array
);
863 QTAILQ_FOREACH(prop
, &obj
->properties
, node
) {
864 if (strcmp(prop
->name
, name
) == 0) {
865 error_setg(errp
, "attempt to add duplicate property '%s'"
866 " to object (type '%s')", name
,
867 object_get_typename(obj
));
872 prop
= g_malloc0(sizeof(*prop
));
874 prop
->name
= g_strdup(name
);
875 prop
->type
= g_strdup(type
);
879 prop
->release
= release
;
880 prop
->opaque
= opaque
;
882 QTAILQ_INSERT_TAIL(&obj
->properties
, prop
, node
);
886 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
889 ObjectProperty
*prop
;
891 QTAILQ_FOREACH(prop
, &obj
->properties
, node
) {
892 if (strcmp(prop
->name
, name
) == 0) {
897 error_setg(errp
, "Property '.%s' not found", name
);
901 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
903 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
909 prop
->release(obj
, name
, prop
->opaque
);
912 QTAILQ_REMOVE(&obj
->properties
, prop
, node
);
916 g_free(prop
->description
);
920 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
923 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
929 error_set(errp
, QERR_PERMISSION_DENIED
);
931 prop
->get(obj
, v
, prop
->opaque
, name
, errp
);
935 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
938 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
944 error_set(errp
, QERR_PERMISSION_DENIED
);
946 prop
->set(obj
, v
, prop
->opaque
, name
, errp
);
950 void object_property_set_str(Object
*obj
, const char *value
,
951 const char *name
, Error
**errp
)
953 QString
*qstr
= qstring_from_str(value
);
954 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
959 char *object_property_get_str(Object
*obj
, const char *name
,
962 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
969 qstring
= qobject_to_qstring(ret
);
971 error_set(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
974 retval
= g_strdup(qstring_get_str(qstring
));
981 void object_property_set_link(Object
*obj
, Object
*value
,
982 const char *name
, Error
**errp
)
985 gchar
*path
= object_get_canonical_path(value
);
986 object_property_set_str(obj
, path
, name
, errp
);
989 object_property_set_str(obj
, "", name
, errp
);
993 Object
*object_property_get_link(Object
*obj
, const char *name
,
996 char *str
= object_property_get_str(obj
, name
, errp
);
997 Object
*target
= NULL
;
1000 target
= object_resolve_path(str
, NULL
);
1002 error_set(errp
, QERR_DEVICE_NOT_FOUND
, str
);
1010 void object_property_set_bool(Object
*obj
, bool value
,
1011 const char *name
, Error
**errp
)
1013 QBool
*qbool
= qbool_from_int(value
);
1014 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
1019 bool object_property_get_bool(Object
*obj
, const char *name
,
1022 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1029 qbool
= qobject_to_qbool(ret
);
1031 error_set(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1034 retval
= qbool_get_int(qbool
);
1041 void object_property_set_int(Object
*obj
, int64_t value
,
1042 const char *name
, Error
**errp
)
1044 QInt
*qint
= qint_from_int(value
);
1045 object_property_set_qobject(obj
, QOBJECT(qint
), name
, errp
);
1050 int64_t object_property_get_int(Object
*obj
, const char *name
,
1053 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1060 qint
= qobject_to_qint(ret
);
1062 error_set(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1065 retval
= qint_get_int(qint
);
1072 typedef struct EnumProperty
{
1073 const char * const *strings
;
1074 int (*get
)(Object
*, Error
**);
1075 void (*set
)(Object
*, int, Error
**);
1078 int object_property_get_enum(Object
*obj
, const char *name
,
1079 const char * const strings
[], Error
**errp
)
1081 StringOutputVisitor
*sov
;
1082 StringInputVisitor
*siv
;
1086 sov
= string_output_visitor_new(false);
1087 object_property_get(obj
, string_output_get_visitor(sov
), name
, errp
);
1088 str
= string_output_get_string(sov
);
1089 siv
= string_input_visitor_new(str
);
1090 string_output_visitor_cleanup(sov
);
1091 visit_type_enum(string_input_get_visitor(siv
),
1092 &ret
, strings
, NULL
, name
, errp
);
1095 string_input_visitor_cleanup(siv
);
1100 void object_property_get_uint16List(Object
*obj
, const char *name
,
1101 uint16List
**list
, Error
**errp
)
1103 StringOutputVisitor
*ov
;
1104 StringInputVisitor
*iv
;
1107 ov
= string_output_visitor_new(false);
1108 object_property_get(obj
, string_output_get_visitor(ov
),
1110 str
= string_output_get_string(ov
);
1111 iv
= string_input_visitor_new(str
);
1112 visit_type_uint16List(string_input_get_visitor(iv
),
1116 string_output_visitor_cleanup(ov
);
1117 string_input_visitor_cleanup(iv
);
1120 void object_property_parse(Object
*obj
, const char *string
,
1121 const char *name
, Error
**errp
)
1123 StringInputVisitor
*mi
;
1124 mi
= string_input_visitor_new(string
);
1125 object_property_set(obj
, string_input_get_visitor(mi
), name
, errp
);
1127 string_input_visitor_cleanup(mi
);
1130 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1133 StringOutputVisitor
*mo
;
1134 char *string
= NULL
;
1135 Error
*local_err
= NULL
;
1137 mo
= string_output_visitor_new(human
);
1138 object_property_get(obj
, string_output_get_visitor(mo
), name
, &local_err
);
1140 error_propagate(errp
, local_err
);
1144 string
= string_output_get_string(mo
);
1147 string_output_visitor_cleanup(mo
);
1151 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1153 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1161 Object
*object_get_root(void)
1163 static Object
*root
;
1166 root
= object_new("container");
1172 Object
*object_get_objects_root(void)
1174 return container_get(object_get_root(), "/objects");
1177 static void object_get_child_property(Object
*obj
, Visitor
*v
, void *opaque
,
1178 const char *name
, Error
**errp
)
1180 Object
*child
= opaque
;
1183 path
= object_get_canonical_path(child
);
1184 visit_type_str(v
, &path
, name
, errp
);
1188 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1193 static void object_finalize_child_property(Object
*obj
, const char *name
,
1196 Object
*child
= opaque
;
1198 if (child
->class->unparent
) {
1199 (child
->class->unparent
)(child
);
1201 child
->parent
= NULL
;
1202 object_unref(child
);
1205 void object_property_add_child(Object
*obj
, const char *name
,
1206 Object
*child
, Error
**errp
)
1208 Error
*local_err
= NULL
;
1212 if (child
->parent
!= NULL
) {
1213 error_setg(errp
, "child object is already parented");
1217 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1219 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1220 object_finalize_child_property
, child
, &local_err
);
1222 error_propagate(errp
, local_err
);
1226 op
->resolve
= object_resolve_child_property
;
1228 child
->parent
= obj
;
1234 void object_property_allow_set_link(Object
*obj
, const char *name
,
1235 Object
*val
, Error
**errp
)
1237 /* Allow the link to be set, always */
1242 void (*check
)(Object
*, const char *, Object
*, Error
**);
1243 ObjectPropertyLinkFlags flags
;
1246 static void object_get_link_property(Object
*obj
, Visitor
*v
, void *opaque
,
1247 const char *name
, Error
**errp
)
1249 LinkProperty
*lprop
= opaque
;
1250 Object
**child
= lprop
->child
;
1254 path
= object_get_canonical_path(*child
);
1255 visit_type_str(v
, &path
, name
, errp
);
1259 visit_type_str(v
, &path
, name
, errp
);
1264 * object_resolve_link:
1266 * Lookup an object and ensure its type matches the link property type. This
1267 * is similar to object_resolve_path() except type verification against the
1268 * link property is performed.
1270 * Returns: The matched object or NULL on path lookup failures.
1272 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1273 const char *path
, Error
**errp
)
1277 bool ambiguous
= false;
1280 /* Go from link<FOO> to FOO. */
1281 type
= object_property_get_type(obj
, name
, NULL
);
1282 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1283 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1286 error_set(errp
, ERROR_CLASS_GENERIC_ERROR
,
1287 "Path '%s' does not uniquely identify an object", path
);
1288 } else if (!target
) {
1289 target
= object_resolve_path(path
, &ambiguous
);
1290 if (target
|| ambiguous
) {
1291 error_set(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1293 error_set(errp
, QERR_DEVICE_NOT_FOUND
, path
);
1297 g_free(target_type
);
1302 static void object_set_link_property(Object
*obj
, Visitor
*v
, void *opaque
,
1303 const char *name
, Error
**errp
)
1305 Error
*local_err
= NULL
;
1306 LinkProperty
*prop
= opaque
;
1307 Object
**child
= prop
->child
;
1308 Object
*old_target
= *child
;
1309 Object
*new_target
= NULL
;
1312 visit_type_str(v
, &path
, name
, &local_err
);
1314 if (!local_err
&& strcmp(path
, "") != 0) {
1315 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1320 error_propagate(errp
, local_err
);
1324 prop
->check(obj
, name
, new_target
, &local_err
);
1326 error_propagate(errp
, local_err
);
1330 object_ref(new_target
);
1331 *child
= new_target
;
1332 object_unref(old_target
);
1335 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1337 LinkProperty
*lprop
= opaque
;
1339 return *lprop
->child
;
1342 static void object_release_link_property(Object
*obj
, const char *name
,
1345 LinkProperty
*prop
= opaque
;
1347 if ((prop
->flags
& OBJ_PROP_LINK_UNREF_ON_RELEASE
) && *prop
->child
) {
1348 object_unref(*prop
->child
);
1353 void object_property_add_link(Object
*obj
, const char *name
,
1354 const char *type
, Object
**child
,
1355 void (*check
)(Object
*, const char *,
1356 Object
*, Error
**),
1357 ObjectPropertyLinkFlags flags
,
1360 Error
*local_err
= NULL
;
1361 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1365 prop
->child
= child
;
1366 prop
->check
= check
;
1367 prop
->flags
= flags
;
1369 full_type
= g_strdup_printf("link<%s>", type
);
1371 op
= object_property_add(obj
, name
, full_type
,
1372 object_get_link_property
,
1373 check
? object_set_link_property
: NULL
,
1374 object_release_link_property
,
1378 error_propagate(errp
, local_err
);
1383 op
->resolve
= object_resolve_link_property
;
1389 void object_property_add_const_link(Object
*obj
, const char *name
,
1390 Object
*target
, Error
**errp
)
1395 link_type
= g_strdup_printf("link<%s>", object_get_typename(target
));
1396 op
= object_property_add(obj
, name
, link_type
,
1397 object_get_child_property
, NULL
,
1398 NULL
, target
, errp
);
1400 op
->resolve
= object_resolve_child_property
;
1405 gchar
*object_get_canonical_path_component(Object
*obj
)
1407 ObjectProperty
*prop
= NULL
;
1410 g_assert(obj
->parent
!= NULL
);
1412 QTAILQ_FOREACH(prop
, &obj
->parent
->properties
, node
) {
1413 if (!object_property_is_child(prop
)) {
1417 if (prop
->opaque
== obj
) {
1418 return g_strdup(prop
->name
);
1422 /* obj had a parent but was not a child, should never happen */
1423 g_assert_not_reached();
1427 gchar
*object_get_canonical_path(Object
*obj
)
1429 Object
*root
= object_get_root();
1430 char *newpath
, *path
= NULL
;
1432 while (obj
!= root
) {
1433 char *component
= object_get_canonical_path_component(obj
);
1436 newpath
= g_strdup_printf("%s/%s", component
, path
);
1447 newpath
= g_strdup_printf("/%s", path
? path
: "");
1453 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
1455 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1460 if (prop
->resolve
) {
1461 return prop
->resolve(parent
, prop
->opaque
, part
);
1467 static Object
*object_resolve_abs_path(Object
*parent
,
1469 const char *typename
,
1474 if (parts
[index
] == NULL
) {
1475 return object_dynamic_cast(parent
, typename
);
1478 if (strcmp(parts
[index
], "") == 0) {
1479 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
1482 child
= object_resolve_path_component(parent
, parts
[index
]);
1487 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
1490 static Object
*object_resolve_partial_path(Object
*parent
,
1492 const char *typename
,
1496 ObjectProperty
*prop
;
1498 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
1500 QTAILQ_FOREACH(prop
, &parent
->properties
, node
) {
1503 if (!object_property_is_child(prop
)) {
1507 found
= object_resolve_partial_path(prop
->opaque
, parts
,
1508 typename
, ambiguous
);
1519 if (ambiguous
&& *ambiguous
) {
1527 Object
*object_resolve_path_type(const char *path
, const char *typename
,
1533 parts
= g_strsplit(path
, "/", 0);
1536 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
1540 obj
= object_resolve_partial_path(object_get_root(), parts
,
1541 typename
, ambiguous
);
1543 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
1551 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
1553 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
1556 typedef struct StringProperty
1558 char *(*get
)(Object
*, Error
**);
1559 void (*set
)(Object
*, const char *, Error
**);
1562 static void property_get_str(Object
*obj
, Visitor
*v
, void *opaque
,
1563 const char *name
, Error
**errp
)
1565 StringProperty
*prop
= opaque
;
1568 value
= prop
->get(obj
, errp
);
1570 visit_type_str(v
, &value
, name
, errp
);
1575 static void property_set_str(Object
*obj
, Visitor
*v
, void *opaque
,
1576 const char *name
, Error
**errp
)
1578 StringProperty
*prop
= opaque
;
1580 Error
*local_err
= NULL
;
1582 visit_type_str(v
, &value
, name
, &local_err
);
1584 error_propagate(errp
, local_err
);
1588 prop
->set(obj
, value
, errp
);
1592 static void property_release_str(Object
*obj
, const char *name
,
1595 StringProperty
*prop
= opaque
;
1599 void object_property_add_str(Object
*obj
, const char *name
,
1600 char *(*get
)(Object
*, Error
**),
1601 void (*set
)(Object
*, const char *, Error
**),
1604 Error
*local_err
= NULL
;
1605 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1610 object_property_add(obj
, name
, "string",
1611 get
? property_get_str
: NULL
,
1612 set
? property_set_str
: NULL
,
1613 property_release_str
,
1616 error_propagate(errp
, local_err
);
1621 typedef struct BoolProperty
1623 bool (*get
)(Object
*, Error
**);
1624 void (*set
)(Object
*, bool, Error
**);
1627 static void property_get_bool(Object
*obj
, Visitor
*v
, void *opaque
,
1628 const char *name
, Error
**errp
)
1630 BoolProperty
*prop
= opaque
;
1633 value
= prop
->get(obj
, errp
);
1634 visit_type_bool(v
, &value
, name
, errp
);
1637 static void property_set_bool(Object
*obj
, Visitor
*v
, void *opaque
,
1638 const char *name
, Error
**errp
)
1640 BoolProperty
*prop
= opaque
;
1642 Error
*local_err
= NULL
;
1644 visit_type_bool(v
, &value
, name
, &local_err
);
1646 error_propagate(errp
, local_err
);
1650 prop
->set(obj
, value
, errp
);
1653 static void property_release_bool(Object
*obj
, const char *name
,
1656 BoolProperty
*prop
= opaque
;
1660 void object_property_add_bool(Object
*obj
, const char *name
,
1661 bool (*get
)(Object
*, Error
**),
1662 void (*set
)(Object
*, bool, Error
**),
1665 Error
*local_err
= NULL
;
1666 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
1671 object_property_add(obj
, name
, "bool",
1672 get
? property_get_bool
: NULL
,
1673 set
? property_set_bool
: NULL
,
1674 property_release_bool
,
1677 error_propagate(errp
, local_err
);
1682 static void property_get_enum(Object
*obj
, Visitor
*v
, void *opaque
,
1683 const char *name
, Error
**errp
)
1685 EnumProperty
*prop
= opaque
;
1688 value
= prop
->get(obj
, errp
);
1689 visit_type_enum(v
, &value
, prop
->strings
, NULL
, name
, errp
);
1692 static void property_set_enum(Object
*obj
, Visitor
*v
, void *opaque
,
1693 const char *name
, Error
**errp
)
1695 EnumProperty
*prop
= opaque
;
1698 visit_type_enum(v
, &value
, prop
->strings
, NULL
, name
, errp
);
1699 prop
->set(obj
, value
, errp
);
1702 static void property_release_enum(Object
*obj
, const char *name
,
1705 EnumProperty
*prop
= opaque
;
1709 void object_property_add_enum(Object
*obj
, const char *name
,
1710 const char *typename
,
1711 const char * const *strings
,
1712 int (*get
)(Object
*, Error
**),
1713 void (*set
)(Object
*, int, Error
**),
1716 Error
*local_err
= NULL
;
1717 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
1719 prop
->strings
= strings
;
1723 object_property_add(obj
, name
, typename
,
1724 get
? property_get_enum
: NULL
,
1725 set
? property_set_enum
: NULL
,
1726 property_release_enum
,
1729 error_propagate(errp
, local_err
);
1734 typedef struct TMProperty
{
1735 void (*get
)(Object
*, struct tm
*, Error
**);
1738 static void property_get_tm(Object
*obj
, Visitor
*v
, void *opaque
,
1739 const char *name
, Error
**errp
)
1741 TMProperty
*prop
= opaque
;
1745 prop
->get(obj
, &value
, &err
);
1750 visit_start_struct(v
, NULL
, "struct tm", name
, 0, &err
);
1754 visit_type_int32(v
, &value
.tm_year
, "tm_year", &err
);
1758 visit_type_int32(v
, &value
.tm_mon
, "tm_mon", &err
);
1762 visit_type_int32(v
, &value
.tm_mday
, "tm_mday", &err
);
1766 visit_type_int32(v
, &value
.tm_hour
, "tm_hour", &err
);
1770 visit_type_int32(v
, &value
.tm_min
, "tm_min", &err
);
1774 visit_type_int32(v
, &value
.tm_sec
, "tm_sec", &err
);
1779 error_propagate(errp
, err
);
1781 visit_end_struct(v
, errp
);
1783 error_propagate(errp
, err
);
1787 static void property_release_tm(Object
*obj
, const char *name
,
1790 TMProperty
*prop
= opaque
;
1794 void object_property_add_tm(Object
*obj
, const char *name
,
1795 void (*get
)(Object
*, struct tm
*, Error
**),
1798 Error
*local_err
= NULL
;
1799 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
1803 object_property_add(obj
, name
, "struct tm",
1804 get
? property_get_tm
: NULL
, NULL
,
1805 property_release_tm
,
1808 error_propagate(errp
, local_err
);
1813 static char *qdev_get_type(Object
*obj
, Error
**errp
)
1815 return g_strdup(object_get_typename(obj
));
1818 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
,
1819 void *opaque
, const char *name
,
1822 uint8_t value
= *(uint8_t *)opaque
;
1823 visit_type_uint8(v
, &value
, name
, errp
);
1826 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
,
1827 void *opaque
, const char *name
,
1830 uint16_t value
= *(uint16_t *)opaque
;
1831 visit_type_uint16(v
, &value
, name
, errp
);
1834 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
,
1835 void *opaque
, const char *name
,
1838 uint32_t value
= *(uint32_t *)opaque
;
1839 visit_type_uint32(v
, &value
, name
, errp
);
1842 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
,
1843 void *opaque
, const char *name
,
1846 uint64_t value
= *(uint64_t *)opaque
;
1847 visit_type_uint64(v
, &value
, name
, errp
);
1850 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
1851 const uint8_t *v
, Error
**errp
)
1853 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
1854 NULL
, NULL
, (void *)v
, errp
);
1857 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
1858 const uint16_t *v
, Error
**errp
)
1860 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
1861 NULL
, NULL
, (void *)v
, errp
);
1864 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
1865 const uint32_t *v
, Error
**errp
)
1867 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
1868 NULL
, NULL
, (void *)v
, errp
);
1871 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
1872 const uint64_t *v
, Error
**errp
)
1874 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
1875 NULL
, NULL
, (void *)v
, errp
);
1883 static void property_get_alias(Object
*obj
, struct Visitor
*v
, void *opaque
,
1884 const char *name
, Error
**errp
)
1886 AliasProperty
*prop
= opaque
;
1888 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
1891 static void property_set_alias(Object
*obj
, struct Visitor
*v
, void *opaque
,
1892 const char *name
, Error
**errp
)
1894 AliasProperty
*prop
= opaque
;
1896 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
1899 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
1902 AliasProperty
*prop
= opaque
;
1904 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
1907 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
1909 AliasProperty
*prop
= opaque
;
1911 g_free(prop
->target_name
);
1915 void object_property_add_alias(Object
*obj
, const char *name
,
1916 Object
*target_obj
, const char *target_name
,
1919 AliasProperty
*prop
;
1921 ObjectProperty
*target_prop
;
1923 Error
*local_err
= NULL
;
1925 target_prop
= object_property_find(target_obj
, target_name
, errp
);
1930 if (object_property_is_child(target_prop
)) {
1931 prop_type
= g_strdup_printf("link%s",
1932 target_prop
->type
+ strlen("child"));
1934 prop_type
= g_strdup(target_prop
->type
);
1937 prop
= g_malloc(sizeof(*prop
));
1938 prop
->target_obj
= target_obj
;
1939 prop
->target_name
= g_strdup(target_name
);
1941 op
= object_property_add(obj
, name
, prop_type
,
1944 property_release_alias
,
1947 error_propagate(errp
, local_err
);
1951 op
->resolve
= property_resolve_alias
;
1953 object_property_set_description(obj
, op
->name
,
1954 target_prop
->description
,
1961 void object_property_set_description(Object
*obj
, const char *name
,
1962 const char *description
, Error
**errp
)
1966 op
= object_property_find(obj
, name
, errp
);
1971 g_free(op
->description
);
1972 op
->description
= g_strdup(description
);
1975 static void object_instance_init(Object
*obj
)
1977 object_property_add_str(obj
, "type", qdev_get_type
, NULL
, NULL
);
1980 static void register_types(void)
1982 static TypeInfo interface_info
= {
1983 .name
= TYPE_INTERFACE
,
1984 .class_size
= sizeof(InterfaceClass
),
1988 static TypeInfo object_info
= {
1989 .name
= TYPE_OBJECT
,
1990 .instance_size
= sizeof(Object
),
1991 .instance_init
= object_instance_init
,
1995 type_interface
= type_register_internal(&interface_info
);
1996 type_register_internal(&object_info
);
1999 type_init(register_types
)