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 struct ObjectPropertyIterator
{
74 static Type type_interface
;
76 static GHashTable
*type_table_get(void)
78 static GHashTable
*type_table
;
80 if (type_table
== NULL
) {
81 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
87 static bool enumerating_types
;
89 static void type_table_add(TypeImpl
*ti
)
91 assert(!enumerating_types
);
92 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
95 static TypeImpl
*type_table_lookup(const char *name
)
97 return g_hash_table_lookup(type_table_get(), name
);
100 static TypeImpl
*type_new(const TypeInfo
*info
)
102 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
105 g_assert(info
->name
!= NULL
);
107 if (type_table_lookup(info
->name
) != NULL
) {
108 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
112 ti
->name
= g_strdup(info
->name
);
113 ti
->parent
= g_strdup(info
->parent
);
115 ti
->class_size
= info
->class_size
;
116 ti
->instance_size
= info
->instance_size
;
118 ti
->class_init
= info
->class_init
;
119 ti
->class_base_init
= info
->class_base_init
;
120 ti
->class_finalize
= info
->class_finalize
;
121 ti
->class_data
= info
->class_data
;
123 ti
->instance_init
= info
->instance_init
;
124 ti
->instance_post_init
= info
->instance_post_init
;
125 ti
->instance_finalize
= info
->instance_finalize
;
127 ti
->abstract
= info
->abstract
;
129 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
130 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
132 ti
->num_interfaces
= i
;
137 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
146 TypeImpl
*type_register(const TypeInfo
*info
)
148 assert(info
->parent
);
149 return type_register_internal(info
);
152 TypeImpl
*type_register_static(const TypeInfo
*info
)
154 return type_register(info
);
157 static TypeImpl
*type_get_by_name(const char *name
)
163 return type_table_lookup(name
);
166 static TypeImpl
*type_get_parent(TypeImpl
*type
)
168 if (!type
->parent_type
&& type
->parent
) {
169 type
->parent_type
= type_get_by_name(type
->parent
);
170 g_assert(type
->parent_type
!= NULL
);
173 return type
->parent_type
;
176 static bool type_has_parent(TypeImpl
*type
)
178 return (type
->parent
!= NULL
);
181 static size_t type_class_get_size(TypeImpl
*ti
)
183 if (ti
->class_size
) {
184 return ti
->class_size
;
187 if (type_has_parent(ti
)) {
188 return type_class_get_size(type_get_parent(ti
));
191 return sizeof(ObjectClass
);
194 static size_t type_object_get_size(TypeImpl
*ti
)
196 if (ti
->instance_size
) {
197 return ti
->instance_size
;
200 if (type_has_parent(ti
)) {
201 return type_object_get_size(type_get_parent(ti
));
207 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
211 /* Check if target_type is a direct ancestor of type */
213 if (type
== target_type
) {
217 type
= type_get_parent(type
);
223 static void type_initialize(TypeImpl
*ti
);
225 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
226 TypeImpl
*parent_type
)
228 InterfaceClass
*new_iface
;
230 TypeImpl
*iface_impl
;
232 info
.parent
= parent_type
->name
;
233 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
234 info
.abstract
= true;
236 iface_impl
= type_new(&info
);
237 iface_impl
->parent_type
= parent_type
;
238 type_initialize(iface_impl
);
239 g_free((char *)info
.name
);
241 new_iface
= (InterfaceClass
*)iface_impl
->class;
242 new_iface
->concrete_class
= ti
->class;
243 new_iface
->interface_type
= interface_type
;
245 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
249 static void type_initialize(TypeImpl
*ti
)
257 ti
->class_size
= type_class_get_size(ti
);
258 ti
->instance_size
= type_object_get_size(ti
);
260 ti
->class = g_malloc0(ti
->class_size
);
262 parent
= type_get_parent(ti
);
264 type_initialize(parent
);
268 g_assert(parent
->class_size
<= ti
->class_size
);
269 memcpy(ti
->class, parent
->class, parent
->class_size
);
270 ti
->class->interfaces
= NULL
;
272 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
273 InterfaceClass
*iface
= e
->data
;
274 ObjectClass
*klass
= OBJECT_CLASS(iface
);
276 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
279 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
280 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
281 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
282 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
284 if (type_is_ancestor(target_type
, t
)) {
293 type_initialize_interface(ti
, t
, t
);
297 ti
->class->type
= ti
;
300 if (parent
->class_base_init
) {
301 parent
->class_base_init(ti
->class, ti
->class_data
);
303 parent
= type_get_parent(parent
);
306 if (ti
->class_init
) {
307 ti
->class_init(ti
->class, ti
->class_data
);
311 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
313 if (type_has_parent(ti
)) {
314 object_init_with_type(obj
, type_get_parent(ti
));
317 if (ti
->instance_init
) {
318 ti
->instance_init(obj
);
322 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
324 if (ti
->instance_post_init
) {
325 ti
->instance_post_init(obj
);
328 if (type_has_parent(ti
)) {
329 object_post_init_with_type(obj
, type_get_parent(ti
));
333 void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
337 g_assert(type
!= NULL
);
338 type_initialize(type
);
340 g_assert(type
->instance_size
>= sizeof(Object
));
341 g_assert(type
->abstract
== false);
342 g_assert(size
>= type
->instance_size
);
344 memset(obj
, 0, type
->instance_size
);
345 obj
->class = type
->class;
347 QTAILQ_INIT(&obj
->properties
);
348 object_init_with_type(obj
, type
);
349 object_post_init_with_type(obj
, type
);
352 void object_initialize(void *data
, size_t size
, const char *typename
)
354 TypeImpl
*type
= type_get_by_name(typename
);
356 object_initialize_with_type(data
, size
, type
);
359 static inline bool object_property_is_child(ObjectProperty
*prop
)
361 return strstart(prop
->type
, "child<", NULL
);
364 static void object_property_del_all(Object
*obj
)
366 while (!QTAILQ_EMPTY(&obj
->properties
)) {
367 ObjectProperty
*prop
= QTAILQ_FIRST(&obj
->properties
);
369 QTAILQ_REMOVE(&obj
->properties
, prop
, node
);
372 prop
->release(obj
, prop
->name
, prop
->opaque
);
377 g_free(prop
->description
);
382 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
384 ObjectProperty
*prop
;
386 QTAILQ_FOREACH(prop
, &obj
->properties
, node
) {
387 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
388 object_property_del(obj
, prop
->name
, errp
);
394 void object_unparent(Object
*obj
)
397 object_property_del_child(obj
->parent
, obj
, NULL
);
401 static void object_deinit(Object
*obj
, TypeImpl
*type
)
403 if (type
->instance_finalize
) {
404 type
->instance_finalize(obj
);
407 if (type_has_parent(type
)) {
408 object_deinit(obj
, type_get_parent(type
));
412 static void object_finalize(void *data
)
415 TypeImpl
*ti
= obj
->class->type
;
417 object_property_del_all(obj
);
418 object_deinit(obj
, ti
);
420 g_assert(obj
->ref
== 0);
426 Object
*object_new_with_type(Type type
)
430 g_assert(type
!= NULL
);
431 type_initialize(type
);
433 obj
= g_malloc(type
->instance_size
);
434 object_initialize_with_type(obj
, type
->instance_size
, type
);
440 Object
*object_new(const char *typename
)
442 TypeImpl
*ti
= type_get_by_name(typename
);
444 return object_new_with_type(ti
);
448 Object
*object_new_with_props(const char *typename
,
457 va_start(vargs
, errp
);
458 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
465 Object
*object_new_with_propv(const char *typename
,
473 Error
*local_err
= NULL
;
475 klass
= object_class_by_name(typename
);
477 error_setg(errp
, "invalid object type: %s", typename
);
481 if (object_class_is_abstract(klass
)) {
482 error_setg(errp
, "object type '%s' is abstract", typename
);
485 obj
= object_new(typename
);
487 if (object_set_propv(obj
, &local_err
, vargs
) < 0) {
491 object_property_add_child(parent
, id
, obj
, &local_err
);
496 if (object_dynamic_cast(obj
, TYPE_USER_CREATABLE
)) {
497 user_creatable_complete(obj
, &local_err
);
499 object_unparent(obj
);
504 object_unref(OBJECT(obj
));
509 error_propagate(errp
, local_err
);
516 int object_set_props(Object
*obj
,
523 va_start(vargs
, errp
);
524 ret
= object_set_propv(obj
, errp
, vargs
);
531 int object_set_propv(Object
*obj
,
535 const char *propname
;
536 Error
*local_err
= NULL
;
538 propname
= va_arg(vargs
, char *);
539 while (propname
!= NULL
) {
540 const char *value
= va_arg(vargs
, char *);
542 g_assert(value
!= NULL
);
543 object_property_parse(obj
, value
, propname
, &local_err
);
545 error_propagate(errp
, local_err
);
548 propname
= va_arg(vargs
, char *);
555 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
557 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
564 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
565 const char *file
, int line
, const char *func
)
567 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
568 typename
, file
, line
, func
);
570 #ifdef CONFIG_QOM_CAST_DEBUG
574 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
575 if (obj
->class->object_cast_cache
[i
] == typename
) {
580 inst
= object_dynamic_cast(obj
, typename
);
583 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
584 file
, line
, func
, obj
, typename
);
590 if (obj
&& obj
== inst
) {
591 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
592 obj
->class->object_cast_cache
[i
- 1] =
593 obj
->class->object_cast_cache
[i
];
595 obj
->class->object_cast_cache
[i
- 1] = typename
;
603 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
604 const char *typename
)
606 ObjectClass
*ret
= NULL
;
607 TypeImpl
*target_type
;
614 /* A simple fast path that can trigger a lot for leaf classes. */
616 if (type
->name
== typename
) {
620 target_type
= type_get_by_name(typename
);
622 /* target class type unknown, so fail the cast */
626 if (type
->class->interfaces
&&
627 type_is_ancestor(target_type
, type_interface
)) {
631 for (i
= class->interfaces
; i
; i
= i
->next
) {
632 ObjectClass
*target_class
= i
->data
;
634 if (type_is_ancestor(target_class
->type
, target_type
)) {
640 /* The match was ambiguous, don't allow a cast */
644 } else if (type_is_ancestor(type
, target_type
)) {
651 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
652 const char *typename
,
653 const char *file
, int line
,
658 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
659 typename
, file
, line
, func
);
661 #ifdef CONFIG_QOM_CAST_DEBUG
664 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
665 if (class->class_cast_cache
[i
] == typename
) {
671 if (!class || !class->interfaces
) {
676 ret
= object_class_dynamic_cast(class, typename
);
678 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
679 file
, line
, func
, class, typename
);
683 #ifdef CONFIG_QOM_CAST_DEBUG
684 if (class && ret
== class) {
685 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
686 class->class_cast_cache
[i
- 1] = class->class_cast_cache
[i
];
688 class->class_cast_cache
[i
- 1] = typename
;
695 const char *object_get_typename(Object
*obj
)
697 return obj
->class->type
->name
;
700 ObjectClass
*object_get_class(Object
*obj
)
705 bool object_class_is_abstract(ObjectClass
*klass
)
707 return klass
->type
->abstract
;
710 const char *object_class_get_name(ObjectClass
*klass
)
712 return klass
->type
->name
;
715 ObjectClass
*object_class_by_name(const char *typename
)
717 TypeImpl
*type
= type_get_by_name(typename
);
723 type_initialize(type
);
728 ObjectClass
*object_class_get_parent(ObjectClass
*class)
730 TypeImpl
*type
= type_get_parent(class->type
);
736 type_initialize(type
);
741 typedef struct OCFData
743 void (*fn
)(ObjectClass
*klass
, void *opaque
);
744 const char *implements_type
;
745 bool include_abstract
;
749 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
752 OCFData
*data
= opaque
;
753 TypeImpl
*type
= value
;
756 type_initialize(type
);
759 if (!data
->include_abstract
&& type
->abstract
) {
763 if (data
->implements_type
&&
764 !object_class_dynamic_cast(k
, data
->implements_type
)) {
768 data
->fn(k
, data
->opaque
);
771 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
772 const char *implements_type
, bool include_abstract
,
775 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
777 enumerating_types
= true;
778 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
779 enumerating_types
= false;
782 static int do_object_child_foreach(Object
*obj
,
783 int (*fn
)(Object
*child
, void *opaque
),
784 void *opaque
, bool recurse
)
786 ObjectProperty
*prop
, *next
;
789 QTAILQ_FOREACH_SAFE(prop
, &obj
->properties
, node
, next
) {
790 if (object_property_is_child(prop
)) {
791 Object
*child
= prop
->opaque
;
793 ret
= fn(child
, opaque
);
798 do_object_child_foreach(child
, fn
, opaque
, true);
805 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
808 return do_object_child_foreach(obj
, fn
, opaque
, false);
811 int object_child_foreach_recursive(Object
*obj
,
812 int (*fn
)(Object
*child
, void *opaque
),
815 return do_object_child_foreach(obj
, fn
, opaque
, true);
818 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
820 GSList
**list
= opaque
;
822 *list
= g_slist_prepend(*list
, klass
);
825 GSList
*object_class_get_list(const char *implements_type
,
826 bool include_abstract
)
830 object_class_foreach(object_class_get_list_tramp
,
831 implements_type
, include_abstract
, &list
);
835 void object_ref(Object
*obj
)
840 atomic_inc(&obj
->ref
);
843 void object_unref(Object
*obj
)
848 g_assert(obj
->ref
> 0);
850 /* parent always holds a reference to its children */
851 if (atomic_fetch_dec(&obj
->ref
) == 1) {
852 object_finalize(obj
);
857 object_property_add(Object
*obj
, const char *name
, const char *type
,
858 ObjectPropertyAccessor
*get
,
859 ObjectPropertyAccessor
*set
,
860 ObjectPropertyRelease
*release
,
861 void *opaque
, Error
**errp
)
863 ObjectProperty
*prop
;
864 size_t name_len
= strlen(name
);
866 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
869 char *name_no_array
= g_strdup(name
);
871 name_no_array
[name_len
- 3] = '\0';
873 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
875 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
876 release
, opaque
, NULL
);
882 g_free(name_no_array
);
886 QTAILQ_FOREACH(prop
, &obj
->properties
, node
) {
887 if (strcmp(prop
->name
, name
) == 0) {
888 error_setg(errp
, "attempt to add duplicate property '%s'"
889 " to object (type '%s')", name
,
890 object_get_typename(obj
));
895 prop
= g_malloc0(sizeof(*prop
));
897 prop
->name
= g_strdup(name
);
898 prop
->type
= g_strdup(type
);
902 prop
->release
= release
;
903 prop
->opaque
= opaque
;
905 QTAILQ_INSERT_TAIL(&obj
->properties
, prop
, node
);
909 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
912 ObjectProperty
*prop
;
914 QTAILQ_FOREACH(prop
, &obj
->properties
, node
) {
915 if (strcmp(prop
->name
, name
) == 0) {
920 error_setg(errp
, "Property '.%s' not found", name
);
924 ObjectPropertyIterator
*object_property_iter_init(Object
*obj
)
926 ObjectPropertyIterator
*ret
= g_new0(ObjectPropertyIterator
, 1);
927 ret
->next
= QTAILQ_FIRST(&obj
->properties
);
931 void object_property_iter_free(ObjectPropertyIterator
*iter
)
939 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
941 ObjectProperty
*ret
= iter
->next
;
943 iter
->next
= QTAILQ_NEXT(iter
->next
, node
);
948 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
950 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
956 prop
->release(obj
, name
, prop
->opaque
);
959 QTAILQ_REMOVE(&obj
->properties
, prop
, node
);
963 g_free(prop
->description
);
967 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
970 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
976 error_setg(errp
, QERR_PERMISSION_DENIED
);
978 prop
->get(obj
, v
, prop
->opaque
, name
, errp
);
982 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
985 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
991 error_setg(errp
, QERR_PERMISSION_DENIED
);
993 prop
->set(obj
, v
, prop
->opaque
, name
, errp
);
997 void object_property_set_str(Object
*obj
, const char *value
,
998 const char *name
, Error
**errp
)
1000 QString
*qstr
= qstring_from_str(value
);
1001 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
1006 char *object_property_get_str(Object
*obj
, const char *name
,
1009 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1016 qstring
= qobject_to_qstring(ret
);
1018 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1021 retval
= g_strdup(qstring_get_str(qstring
));
1028 void object_property_set_link(Object
*obj
, Object
*value
,
1029 const char *name
, Error
**errp
)
1032 gchar
*path
= object_get_canonical_path(value
);
1033 object_property_set_str(obj
, path
, name
, errp
);
1036 object_property_set_str(obj
, "", name
, errp
);
1040 Object
*object_property_get_link(Object
*obj
, const char *name
,
1043 char *str
= object_property_get_str(obj
, name
, errp
);
1044 Object
*target
= NULL
;
1047 target
= object_resolve_path(str
, NULL
);
1049 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1050 "Device '%s' not found", str
);
1058 void object_property_set_bool(Object
*obj
, bool value
,
1059 const char *name
, Error
**errp
)
1061 QBool
*qbool
= qbool_from_bool(value
);
1062 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
1067 bool object_property_get_bool(Object
*obj
, const char *name
,
1070 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1077 qbool
= qobject_to_qbool(ret
);
1079 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1082 retval
= qbool_get_bool(qbool
);
1089 void object_property_set_int(Object
*obj
, int64_t value
,
1090 const char *name
, Error
**errp
)
1092 QInt
*qint
= qint_from_int(value
);
1093 object_property_set_qobject(obj
, QOBJECT(qint
), name
, errp
);
1098 int64_t object_property_get_int(Object
*obj
, const char *name
,
1101 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1108 qint
= qobject_to_qint(ret
);
1110 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1113 retval
= qint_get_int(qint
);
1120 typedef struct EnumProperty
{
1121 const char * const *strings
;
1122 int (*get
)(Object
*, Error
**);
1123 void (*set
)(Object
*, int, Error
**);
1126 int object_property_get_enum(Object
*obj
, const char *name
,
1127 const char *typename
, Error
**errp
)
1130 StringOutputVisitor
*sov
;
1131 StringInputVisitor
*siv
;
1134 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1135 EnumProperty
*enumprop
;
1141 if (!g_str_equal(prop
->type
, typename
)) {
1142 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1143 name
, object_class_get_name(
1144 object_get_class(obj
)), typename
);
1148 enumprop
= prop
->opaque
;
1150 sov
= string_output_visitor_new(false);
1151 object_property_get(obj
, string_output_get_visitor(sov
), name
, &err
);
1153 error_propagate(errp
, err
);
1154 string_output_visitor_cleanup(sov
);
1157 str
= string_output_get_string(sov
);
1158 siv
= string_input_visitor_new(str
);
1159 string_output_visitor_cleanup(sov
);
1160 visit_type_enum(string_input_get_visitor(siv
),
1161 &ret
, enumprop
->strings
, NULL
, name
, errp
);
1164 string_input_visitor_cleanup(siv
);
1169 void object_property_get_uint16List(Object
*obj
, const char *name
,
1170 uint16List
**list
, Error
**errp
)
1173 StringOutputVisitor
*ov
;
1174 StringInputVisitor
*iv
;
1177 ov
= string_output_visitor_new(false);
1178 object_property_get(obj
, string_output_get_visitor(ov
),
1181 error_propagate(errp
, err
);
1184 str
= string_output_get_string(ov
);
1185 iv
= string_input_visitor_new(str
);
1186 visit_type_uint16List(string_input_get_visitor(iv
),
1190 string_input_visitor_cleanup(iv
);
1192 string_output_visitor_cleanup(ov
);
1195 void object_property_parse(Object
*obj
, const char *string
,
1196 const char *name
, Error
**errp
)
1198 StringInputVisitor
*siv
;
1199 siv
= string_input_visitor_new(string
);
1200 object_property_set(obj
, string_input_get_visitor(siv
), name
, errp
);
1202 string_input_visitor_cleanup(siv
);
1205 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1208 StringOutputVisitor
*sov
;
1209 char *string
= NULL
;
1210 Error
*local_err
= NULL
;
1212 sov
= string_output_visitor_new(human
);
1213 object_property_get(obj
, string_output_get_visitor(sov
), name
, &local_err
);
1215 error_propagate(errp
, local_err
);
1219 string
= string_output_get_string(sov
);
1222 string_output_visitor_cleanup(sov
);
1226 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1228 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1236 Object
*object_get_root(void)
1238 static Object
*root
;
1241 root
= object_new("container");
1247 Object
*object_get_objects_root(void)
1249 return container_get(object_get_root(), "/objects");
1252 static void object_get_child_property(Object
*obj
, Visitor
*v
, void *opaque
,
1253 const char *name
, Error
**errp
)
1255 Object
*child
= opaque
;
1258 path
= object_get_canonical_path(child
);
1259 visit_type_str(v
, &path
, name
, errp
);
1263 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1268 static void object_finalize_child_property(Object
*obj
, const char *name
,
1271 Object
*child
= opaque
;
1273 if (child
->class->unparent
) {
1274 (child
->class->unparent
)(child
);
1276 child
->parent
= NULL
;
1277 object_unref(child
);
1280 void object_property_add_child(Object
*obj
, const char *name
,
1281 Object
*child
, Error
**errp
)
1283 Error
*local_err
= NULL
;
1287 if (child
->parent
!= NULL
) {
1288 error_setg(errp
, "child object is already parented");
1292 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1294 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1295 object_finalize_child_property
, child
, &local_err
);
1297 error_propagate(errp
, local_err
);
1301 op
->resolve
= object_resolve_child_property
;
1303 child
->parent
= obj
;
1309 void object_property_allow_set_link(Object
*obj
, const char *name
,
1310 Object
*val
, Error
**errp
)
1312 /* Allow the link to be set, always */
1317 void (*check
)(Object
*, const char *, Object
*, Error
**);
1318 ObjectPropertyLinkFlags flags
;
1321 static void object_get_link_property(Object
*obj
, Visitor
*v
, void *opaque
,
1322 const char *name
, Error
**errp
)
1324 LinkProperty
*lprop
= opaque
;
1325 Object
**child
= lprop
->child
;
1329 path
= object_get_canonical_path(*child
);
1330 visit_type_str(v
, &path
, name
, errp
);
1334 visit_type_str(v
, &path
, name
, errp
);
1339 * object_resolve_link:
1341 * Lookup an object and ensure its type matches the link property type. This
1342 * is similar to object_resolve_path() except type verification against the
1343 * link property is performed.
1345 * Returns: The matched object or NULL on path lookup failures.
1347 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1348 const char *path
, Error
**errp
)
1352 bool ambiguous
= false;
1355 /* Go from link<FOO> to FOO. */
1356 type
= object_property_get_type(obj
, name
, NULL
);
1357 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1358 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1361 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1363 } else if (!target
) {
1364 target
= object_resolve_path(path
, &ambiguous
);
1365 if (target
|| ambiguous
) {
1366 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1368 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1369 "Device '%s' not found", path
);
1373 g_free(target_type
);
1378 static void object_set_link_property(Object
*obj
, Visitor
*v
, void *opaque
,
1379 const char *name
, Error
**errp
)
1381 Error
*local_err
= NULL
;
1382 LinkProperty
*prop
= opaque
;
1383 Object
**child
= prop
->child
;
1384 Object
*old_target
= *child
;
1385 Object
*new_target
= NULL
;
1388 visit_type_str(v
, &path
, name
, &local_err
);
1390 if (!local_err
&& strcmp(path
, "") != 0) {
1391 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1396 error_propagate(errp
, local_err
);
1400 prop
->check(obj
, name
, new_target
, &local_err
);
1402 error_propagate(errp
, local_err
);
1406 object_ref(new_target
);
1407 *child
= new_target
;
1408 object_unref(old_target
);
1411 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1413 LinkProperty
*lprop
= opaque
;
1415 return *lprop
->child
;
1418 static void object_release_link_property(Object
*obj
, const char *name
,
1421 LinkProperty
*prop
= opaque
;
1423 if ((prop
->flags
& OBJ_PROP_LINK_UNREF_ON_RELEASE
) && *prop
->child
) {
1424 object_unref(*prop
->child
);
1429 void object_property_add_link(Object
*obj
, const char *name
,
1430 const char *type
, Object
**child
,
1431 void (*check
)(Object
*, const char *,
1432 Object
*, Error
**),
1433 ObjectPropertyLinkFlags flags
,
1436 Error
*local_err
= NULL
;
1437 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1441 prop
->child
= child
;
1442 prop
->check
= check
;
1443 prop
->flags
= flags
;
1445 full_type
= g_strdup_printf("link<%s>", type
);
1447 op
= object_property_add(obj
, name
, full_type
,
1448 object_get_link_property
,
1449 check
? object_set_link_property
: NULL
,
1450 object_release_link_property
,
1454 error_propagate(errp
, local_err
);
1459 op
->resolve
= object_resolve_link_property
;
1465 void object_property_add_const_link(Object
*obj
, const char *name
,
1466 Object
*target
, Error
**errp
)
1471 link_type
= g_strdup_printf("link<%s>", object_get_typename(target
));
1472 op
= object_property_add(obj
, name
, link_type
,
1473 object_get_child_property
, NULL
,
1474 NULL
, target
, errp
);
1476 op
->resolve
= object_resolve_child_property
;
1481 gchar
*object_get_canonical_path_component(Object
*obj
)
1483 ObjectProperty
*prop
= NULL
;
1486 g_assert(obj
->parent
!= NULL
);
1488 QTAILQ_FOREACH(prop
, &obj
->parent
->properties
, node
) {
1489 if (!object_property_is_child(prop
)) {
1493 if (prop
->opaque
== obj
) {
1494 return g_strdup(prop
->name
);
1498 /* obj had a parent but was not a child, should never happen */
1499 g_assert_not_reached();
1503 gchar
*object_get_canonical_path(Object
*obj
)
1505 Object
*root
= object_get_root();
1506 char *newpath
, *path
= NULL
;
1508 while (obj
!= root
) {
1509 char *component
= object_get_canonical_path_component(obj
);
1512 newpath
= g_strdup_printf("%s/%s", component
, path
);
1523 newpath
= g_strdup_printf("/%s", path
? path
: "");
1529 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
1531 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1536 if (prop
->resolve
) {
1537 return prop
->resolve(parent
, prop
->opaque
, part
);
1543 static Object
*object_resolve_abs_path(Object
*parent
,
1545 const char *typename
,
1550 if (parts
[index
] == NULL
) {
1551 return object_dynamic_cast(parent
, typename
);
1554 if (strcmp(parts
[index
], "") == 0) {
1555 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
1558 child
= object_resolve_path_component(parent
, parts
[index
]);
1563 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
1566 static Object
*object_resolve_partial_path(Object
*parent
,
1568 const char *typename
,
1572 ObjectProperty
*prop
;
1574 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
1576 QTAILQ_FOREACH(prop
, &parent
->properties
, node
) {
1579 if (!object_property_is_child(prop
)) {
1583 found
= object_resolve_partial_path(prop
->opaque
, parts
,
1584 typename
, ambiguous
);
1595 if (ambiguous
&& *ambiguous
) {
1603 Object
*object_resolve_path_type(const char *path
, const char *typename
,
1609 parts
= g_strsplit(path
, "/", 0);
1612 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
1616 obj
= object_resolve_partial_path(object_get_root(), parts
,
1617 typename
, ambiguous
);
1619 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
1627 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
1629 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
1632 typedef struct StringProperty
1634 char *(*get
)(Object
*, Error
**);
1635 void (*set
)(Object
*, const char *, Error
**);
1638 static void property_get_str(Object
*obj
, Visitor
*v
, void *opaque
,
1639 const char *name
, Error
**errp
)
1641 StringProperty
*prop
= opaque
;
1645 value
= prop
->get(obj
, &err
);
1647 error_propagate(errp
, err
);
1651 visit_type_str(v
, &value
, name
, errp
);
1655 static void property_set_str(Object
*obj
, Visitor
*v
, void *opaque
,
1656 const char *name
, Error
**errp
)
1658 StringProperty
*prop
= opaque
;
1660 Error
*local_err
= NULL
;
1662 visit_type_str(v
, &value
, name
, &local_err
);
1664 error_propagate(errp
, local_err
);
1668 prop
->set(obj
, value
, errp
);
1672 static void property_release_str(Object
*obj
, const char *name
,
1675 StringProperty
*prop
= opaque
;
1679 void object_property_add_str(Object
*obj
, const char *name
,
1680 char *(*get
)(Object
*, Error
**),
1681 void (*set
)(Object
*, const char *, Error
**),
1684 Error
*local_err
= NULL
;
1685 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1690 object_property_add(obj
, name
, "string",
1691 get
? property_get_str
: NULL
,
1692 set
? property_set_str
: NULL
,
1693 property_release_str
,
1696 error_propagate(errp
, local_err
);
1701 typedef struct BoolProperty
1703 bool (*get
)(Object
*, Error
**);
1704 void (*set
)(Object
*, bool, Error
**);
1707 static void property_get_bool(Object
*obj
, Visitor
*v
, void *opaque
,
1708 const char *name
, Error
**errp
)
1710 BoolProperty
*prop
= opaque
;
1714 value
= prop
->get(obj
, &err
);
1716 error_propagate(errp
, err
);
1720 visit_type_bool(v
, &value
, name
, errp
);
1723 static void property_set_bool(Object
*obj
, Visitor
*v
, void *opaque
,
1724 const char *name
, Error
**errp
)
1726 BoolProperty
*prop
= opaque
;
1728 Error
*local_err
= NULL
;
1730 visit_type_bool(v
, &value
, name
, &local_err
);
1732 error_propagate(errp
, local_err
);
1736 prop
->set(obj
, value
, errp
);
1739 static void property_release_bool(Object
*obj
, const char *name
,
1742 BoolProperty
*prop
= opaque
;
1746 void object_property_add_bool(Object
*obj
, const char *name
,
1747 bool (*get
)(Object
*, Error
**),
1748 void (*set
)(Object
*, bool, Error
**),
1751 Error
*local_err
= NULL
;
1752 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
1757 object_property_add(obj
, name
, "bool",
1758 get
? property_get_bool
: NULL
,
1759 set
? property_set_bool
: NULL
,
1760 property_release_bool
,
1763 error_propagate(errp
, local_err
);
1768 static void property_get_enum(Object
*obj
, Visitor
*v
, void *opaque
,
1769 const char *name
, Error
**errp
)
1771 EnumProperty
*prop
= opaque
;
1775 value
= prop
->get(obj
, &err
);
1777 error_propagate(errp
, err
);
1781 visit_type_enum(v
, &value
, prop
->strings
, NULL
, name
, errp
);
1784 static void property_set_enum(Object
*obj
, Visitor
*v
, void *opaque
,
1785 const char *name
, Error
**errp
)
1787 EnumProperty
*prop
= opaque
;
1791 visit_type_enum(v
, &value
, prop
->strings
, NULL
, name
, &err
);
1793 error_propagate(errp
, err
);
1796 prop
->set(obj
, value
, errp
);
1799 static void property_release_enum(Object
*obj
, const char *name
,
1802 EnumProperty
*prop
= opaque
;
1806 void object_property_add_enum(Object
*obj
, const char *name
,
1807 const char *typename
,
1808 const char * const *strings
,
1809 int (*get
)(Object
*, Error
**),
1810 void (*set
)(Object
*, int, Error
**),
1813 Error
*local_err
= NULL
;
1814 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
1816 prop
->strings
= strings
;
1820 object_property_add(obj
, name
, typename
,
1821 get
? property_get_enum
: NULL
,
1822 set
? property_set_enum
: NULL
,
1823 property_release_enum
,
1826 error_propagate(errp
, local_err
);
1831 typedef struct TMProperty
{
1832 void (*get
)(Object
*, struct tm
*, Error
**);
1835 static void property_get_tm(Object
*obj
, Visitor
*v
, void *opaque
,
1836 const char *name
, Error
**errp
)
1838 TMProperty
*prop
= opaque
;
1842 prop
->get(obj
, &value
, &err
);
1847 visit_start_struct(v
, NULL
, "struct tm", name
, 0, &err
);
1851 visit_type_int32(v
, &value
.tm_year
, "tm_year", &err
);
1855 visit_type_int32(v
, &value
.tm_mon
, "tm_mon", &err
);
1859 visit_type_int32(v
, &value
.tm_mday
, "tm_mday", &err
);
1863 visit_type_int32(v
, &value
.tm_hour
, "tm_hour", &err
);
1867 visit_type_int32(v
, &value
.tm_min
, "tm_min", &err
);
1871 visit_type_int32(v
, &value
.tm_sec
, "tm_sec", &err
);
1876 error_propagate(errp
, err
);
1878 visit_end_struct(v
, errp
);
1880 error_propagate(errp
, err
);
1884 static void property_release_tm(Object
*obj
, const char *name
,
1887 TMProperty
*prop
= opaque
;
1891 void object_property_add_tm(Object
*obj
, const char *name
,
1892 void (*get
)(Object
*, struct tm
*, Error
**),
1895 Error
*local_err
= NULL
;
1896 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
1900 object_property_add(obj
, name
, "struct tm",
1901 get
? property_get_tm
: NULL
, NULL
,
1902 property_release_tm
,
1905 error_propagate(errp
, local_err
);
1910 static char *qdev_get_type(Object
*obj
, Error
**errp
)
1912 return g_strdup(object_get_typename(obj
));
1915 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
,
1916 void *opaque
, const char *name
,
1919 uint8_t value
= *(uint8_t *)opaque
;
1920 visit_type_uint8(v
, &value
, name
, errp
);
1923 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
,
1924 void *opaque
, const char *name
,
1927 uint16_t value
= *(uint16_t *)opaque
;
1928 visit_type_uint16(v
, &value
, name
, errp
);
1931 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
,
1932 void *opaque
, const char *name
,
1935 uint32_t value
= *(uint32_t *)opaque
;
1936 visit_type_uint32(v
, &value
, name
, errp
);
1939 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
,
1940 void *opaque
, const char *name
,
1943 uint64_t value
= *(uint64_t *)opaque
;
1944 visit_type_uint64(v
, &value
, name
, errp
);
1947 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
1948 const uint8_t *v
, Error
**errp
)
1950 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
1951 NULL
, NULL
, (void *)v
, errp
);
1954 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
1955 const uint16_t *v
, Error
**errp
)
1957 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
1958 NULL
, NULL
, (void *)v
, errp
);
1961 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
1962 const uint32_t *v
, Error
**errp
)
1964 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
1965 NULL
, NULL
, (void *)v
, errp
);
1968 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
1969 const uint64_t *v
, Error
**errp
)
1971 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
1972 NULL
, NULL
, (void *)v
, errp
);
1980 static void property_get_alias(Object
*obj
, struct Visitor
*v
, void *opaque
,
1981 const char *name
, Error
**errp
)
1983 AliasProperty
*prop
= opaque
;
1985 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
1988 static void property_set_alias(Object
*obj
, struct Visitor
*v
, void *opaque
,
1989 const char *name
, Error
**errp
)
1991 AliasProperty
*prop
= opaque
;
1993 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
1996 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
1999 AliasProperty
*prop
= opaque
;
2001 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2004 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2006 AliasProperty
*prop
= opaque
;
2008 g_free(prop
->target_name
);
2012 void object_property_add_alias(Object
*obj
, const char *name
,
2013 Object
*target_obj
, const char *target_name
,
2016 AliasProperty
*prop
;
2018 ObjectProperty
*target_prop
;
2020 Error
*local_err
= NULL
;
2022 target_prop
= object_property_find(target_obj
, target_name
, errp
);
2027 if (object_property_is_child(target_prop
)) {
2028 prop_type
= g_strdup_printf("link%s",
2029 target_prop
->type
+ strlen("child"));
2031 prop_type
= g_strdup(target_prop
->type
);
2034 prop
= g_malloc(sizeof(*prop
));
2035 prop
->target_obj
= target_obj
;
2036 prop
->target_name
= g_strdup(target_name
);
2038 op
= object_property_add(obj
, name
, prop_type
,
2041 property_release_alias
,
2044 error_propagate(errp
, local_err
);
2048 op
->resolve
= property_resolve_alias
;
2050 object_property_set_description(obj
, op
->name
,
2051 target_prop
->description
,
2058 void object_property_set_description(Object
*obj
, const char *name
,
2059 const char *description
, Error
**errp
)
2063 op
= object_property_find(obj
, name
, errp
);
2068 g_free(op
->description
);
2069 op
->description
= g_strdup(description
);
2072 static void object_instance_init(Object
*obj
)
2074 object_property_add_str(obj
, "type", qdev_get_type
, NULL
, NULL
);
2077 static void register_types(void)
2079 static TypeInfo interface_info
= {
2080 .name
= TYPE_INTERFACE
,
2081 .class_size
= sizeof(InterfaceClass
),
2085 static TypeInfo object_info
= {
2086 .name
= TYPE_OBJECT
,
2087 .instance_size
= sizeof(Object
),
2088 .instance_init
= object_instance_init
,
2092 type_interface
= type_register_internal(&interface_info
);
2093 type_register_internal(&object_info
);
2096 type_init(register_types
)