4 * Copyright IBM, Corp. 2011
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
15 #include "qom/object.h"
16 #include "qom/object_interfaces.h"
17 #include "qemu/cutils.h"
18 #include "qapi/visitor.h"
19 #include "qapi/string-input-visitor.h"
20 #include "qapi/string-output-visitor.h"
21 #include "qapi/qapi-builtin-visit.h"
22 #include "qapi/qmp/qerror.h"
25 /* TODO: replace QObject with a simpler visitor to avoid a dependency
26 * of the QOM core on QObject? */
27 #include "qom/qom-qobject.h"
28 #include "qapi/qmp/qbool.h"
29 #include "qapi/qmp/qnum.h"
30 #include "qapi/qmp/qstring.h"
32 #define MAX_INTERFACES 32
34 typedef struct InterfaceImpl InterfaceImpl
;
35 typedef struct TypeImpl TypeImpl
;
50 void (*class_init
)(ObjectClass
*klass
, void *data
);
51 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
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_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 void type_register_static_array(const TypeInfo
*infos
, int nr_infos
)
156 for (i
= 0; i
< nr_infos
; i
++) {
157 type_register_static(&infos
[i
]);
161 static TypeImpl
*type_get_by_name(const char *name
)
167 return type_table_lookup(name
);
170 static TypeImpl
*type_get_parent(TypeImpl
*type
)
172 if (!type
->parent_type
&& type
->parent
) {
173 type
->parent_type
= type_get_by_name(type
->parent
);
174 g_assert(type
->parent_type
!= NULL
);
177 return type
->parent_type
;
180 static bool type_has_parent(TypeImpl
*type
)
182 return (type
->parent
!= NULL
);
185 static size_t type_class_get_size(TypeImpl
*ti
)
187 if (ti
->class_size
) {
188 return ti
->class_size
;
191 if (type_has_parent(ti
)) {
192 return type_class_get_size(type_get_parent(ti
));
195 return sizeof(ObjectClass
);
198 static size_t type_object_get_size(TypeImpl
*ti
)
200 if (ti
->instance_size
) {
201 return ti
->instance_size
;
204 if (type_has_parent(ti
)) {
205 return type_object_get_size(type_get_parent(ti
));
211 size_t object_type_get_instance_size(const char *typename
)
213 TypeImpl
*type
= type_get_by_name(typename
);
215 g_assert(type
!= NULL
);
216 return type_object_get_size(type
);
219 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
223 /* Check if target_type is a direct ancestor of type */
225 if (type
== target_type
) {
229 type
= type_get_parent(type
);
235 static void type_initialize(TypeImpl
*ti
);
237 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
238 TypeImpl
*parent_type
)
240 InterfaceClass
*new_iface
;
242 TypeImpl
*iface_impl
;
244 info
.parent
= parent_type
->name
;
245 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
246 info
.abstract
= true;
248 iface_impl
= type_new(&info
);
249 iface_impl
->parent_type
= parent_type
;
250 type_initialize(iface_impl
);
251 g_free((char *)info
.name
);
253 new_iface
= (InterfaceClass
*)iface_impl
->class;
254 new_iface
->concrete_class
= ti
->class;
255 new_iface
->interface_type
= interface_type
;
257 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
261 static void object_property_free(gpointer data
)
263 ObjectProperty
*prop
= data
;
267 g_free(prop
->description
);
271 static void type_initialize(TypeImpl
*ti
)
279 ti
->class_size
= type_class_get_size(ti
);
280 ti
->instance_size
= type_object_get_size(ti
);
281 /* Any type with zero instance_size is implicitly abstract.
282 * This means interface types are all abstract.
284 if (ti
->instance_size
== 0) {
287 if (type_is_ancestor(ti
, type_interface
)) {
288 assert(ti
->instance_size
== 0);
289 assert(ti
->abstract
);
290 assert(!ti
->instance_init
);
291 assert(!ti
->instance_post_init
);
292 assert(!ti
->instance_finalize
);
293 assert(!ti
->num_interfaces
);
295 ti
->class = g_malloc0(ti
->class_size
);
297 parent
= type_get_parent(ti
);
299 type_initialize(parent
);
303 g_assert(parent
->class_size
<= ti
->class_size
);
304 memcpy(ti
->class, parent
->class, parent
->class_size
);
305 ti
->class->interfaces
= NULL
;
306 ti
->class->properties
= g_hash_table_new_full(
307 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
309 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
310 InterfaceClass
*iface
= e
->data
;
311 ObjectClass
*klass
= OBJECT_CLASS(iface
);
313 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
316 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
317 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
318 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
319 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
321 if (type_is_ancestor(target_type
, t
)) {
330 type_initialize_interface(ti
, t
, t
);
333 ti
->class->properties
= g_hash_table_new_full(
334 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
337 ti
->class->type
= ti
;
340 if (parent
->class_base_init
) {
341 parent
->class_base_init(ti
->class, ti
->class_data
);
343 parent
= type_get_parent(parent
);
346 if (ti
->class_init
) {
347 ti
->class_init(ti
->class, ti
->class_data
);
351 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
353 if (type_has_parent(ti
)) {
354 object_init_with_type(obj
, type_get_parent(ti
));
357 if (ti
->instance_init
) {
358 ti
->instance_init(obj
);
362 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
364 if (ti
->instance_post_init
) {
365 ti
->instance_post_init(obj
);
368 if (type_has_parent(ti
)) {
369 object_post_init_with_type(obj
, type_get_parent(ti
));
373 void object_apply_global_props(Object
*obj
, const GPtrArray
*props
, Error
**errp
)
381 for (i
= 0; i
< props
->len
; i
++) {
382 GlobalProperty
*p
= g_ptr_array_index(props
, i
);
385 if (object_dynamic_cast(obj
, p
->driver
) == NULL
) {
388 if (p
->optional
&& !object_property_find(obj
, p
->property
, NULL
)) {
392 object_property_parse(obj
, p
->value
, p
->property
, &err
);
394 error_prepend(&err
, "can't apply global %s.%s=%s: ",
395 p
->driver
, p
->property
, p
->value
);
397 * If errp != NULL, propagate error and return.
398 * If errp == NULL, report a warning, but keep going
399 * with the remaining globals.
402 error_propagate(errp
, err
);
405 warn_report_err(err
);
411 static void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
415 g_assert(type
!= NULL
);
416 type_initialize(type
);
418 g_assert(type
->instance_size
>= sizeof(Object
));
419 g_assert(type
->abstract
== false);
420 g_assert(size
>= type
->instance_size
);
422 memset(obj
, 0, type
->instance_size
);
423 obj
->class = type
->class;
425 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
426 NULL
, object_property_free
);
427 object_init_with_type(obj
, type
);
428 object_post_init_with_type(obj
, type
);
431 void object_initialize(void *data
, size_t size
, const char *typename
)
433 TypeImpl
*type
= type_get_by_name(typename
);
435 object_initialize_with_type(data
, size
, type
);
438 void object_initialize_child(Object
*parentobj
, const char *propname
,
439 void *childobj
, size_t size
, const char *type
,
444 va_start(vargs
, errp
);
445 object_initialize_childv(parentobj
, propname
, childobj
, size
, type
, errp
,
450 void object_initialize_childv(Object
*parentobj
, const char *propname
,
451 void *childobj
, size_t size
, const char *type
,
452 Error
**errp
, va_list vargs
)
454 Error
*local_err
= NULL
;
458 object_initialize(childobj
, size
, type
);
459 obj
= OBJECT(childobj
);
461 object_set_propv(obj
, &local_err
, vargs
);
466 object_property_add_child(parentobj
, propname
, obj
, &local_err
);
471 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
473 user_creatable_complete(uc
, &local_err
);
475 object_unparent(obj
);
481 * Since object_property_add_child added a reference to the child object,
482 * we can drop the reference added by object_initialize(), so the child
483 * property will own the only reference to the object.
489 error_propagate(errp
, local_err
);
494 static inline bool object_property_is_child(ObjectProperty
*prop
)
496 return strstart(prop
->type
, "child<", NULL
);
499 static void object_property_del_all(Object
*obj
)
501 ObjectProperty
*prop
;
508 g_hash_table_iter_init(&iter
, obj
->properties
);
509 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
512 prop
->release(obj
, prop
->name
, prop
->opaque
);
513 prop
->release
= NULL
;
517 g_hash_table_iter_remove(&iter
);
521 g_hash_table_unref(obj
->properties
);
524 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
526 ObjectProperty
*prop
;
530 g_hash_table_iter_init(&iter
, obj
->properties
);
531 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
533 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
535 prop
->release(obj
, prop
->name
, prop
->opaque
);
536 prop
->release
= NULL
;
541 g_hash_table_iter_init(&iter
, obj
->properties
);
542 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
544 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
545 g_hash_table_iter_remove(&iter
);
551 void object_unparent(Object
*obj
)
554 object_property_del_child(obj
->parent
, obj
, NULL
);
558 static void object_deinit(Object
*obj
, TypeImpl
*type
)
560 if (type
->instance_finalize
) {
561 type
->instance_finalize(obj
);
564 if (type_has_parent(type
)) {
565 object_deinit(obj
, type_get_parent(type
));
569 static void object_finalize(void *data
)
572 TypeImpl
*ti
= obj
->class->type
;
574 object_property_del_all(obj
);
575 object_deinit(obj
, ti
);
577 g_assert(obj
->ref
== 0);
583 static Object
*object_new_with_type(Type type
)
587 g_assert(type
!= NULL
);
588 type_initialize(type
);
590 obj
= g_malloc(type
->instance_size
);
591 object_initialize_with_type(obj
, type
->instance_size
, type
);
597 Object
*object_new(const char *typename
)
599 TypeImpl
*ti
= type_get_by_name(typename
);
601 return object_new_with_type(ti
);
605 Object
*object_new_with_props(const char *typename
,
614 va_start(vargs
, errp
);
615 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
622 Object
*object_new_with_propv(const char *typename
,
630 Error
*local_err
= NULL
;
633 klass
= object_class_by_name(typename
);
635 error_setg(errp
, "invalid object type: %s", typename
);
639 if (object_class_is_abstract(klass
)) {
640 error_setg(errp
, "object type '%s' is abstract", typename
);
643 obj
= object_new(typename
);
645 if (object_set_propv(obj
, &local_err
, vargs
) < 0) {
650 object_property_add_child(parent
, id
, obj
, &local_err
);
656 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
658 user_creatable_complete(uc
, &local_err
);
661 object_unparent(obj
);
667 object_unref(OBJECT(obj
));
671 error_propagate(errp
, local_err
);
677 int object_set_props(Object
*obj
,
684 va_start(vargs
, errp
);
685 ret
= object_set_propv(obj
, errp
, vargs
);
692 int object_set_propv(Object
*obj
,
696 const char *propname
;
697 Error
*local_err
= NULL
;
699 propname
= va_arg(vargs
, char *);
700 while (propname
!= NULL
) {
701 const char *value
= va_arg(vargs
, char *);
703 g_assert(value
!= NULL
);
704 object_property_parse(obj
, value
, propname
, &local_err
);
706 error_propagate(errp
, local_err
);
709 propname
= va_arg(vargs
, char *);
716 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
718 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
725 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
726 const char *file
, int line
, const char *func
)
728 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
729 typename
, file
, line
, func
);
731 #ifdef CONFIG_QOM_CAST_DEBUG
735 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
736 if (atomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
741 inst
= object_dynamic_cast(obj
, typename
);
744 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
745 file
, line
, func
, obj
, typename
);
751 if (obj
&& obj
== inst
) {
752 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
753 atomic_set(&obj
->class->object_cast_cache
[i
- 1],
754 atomic_read(&obj
->class->object_cast_cache
[i
]));
756 atomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
764 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
765 const char *typename
)
767 ObjectClass
*ret
= NULL
;
768 TypeImpl
*target_type
;
775 /* A simple fast path that can trigger a lot for leaf classes. */
777 if (type
->name
== typename
) {
781 target_type
= type_get_by_name(typename
);
783 /* target class type unknown, so fail the cast */
787 if (type
->class->interfaces
&&
788 type_is_ancestor(target_type
, type_interface
)) {
792 for (i
= class->interfaces
; i
; i
= i
->next
) {
793 ObjectClass
*target_class
= i
->data
;
795 if (type_is_ancestor(target_class
->type
, target_type
)) {
801 /* The match was ambiguous, don't allow a cast */
805 } else if (type_is_ancestor(type
, target_type
)) {
812 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
813 const char *typename
,
814 const char *file
, int line
,
819 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
820 typename
, file
, line
, func
);
822 #ifdef CONFIG_QOM_CAST_DEBUG
825 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
826 if (atomic_read(&class->class_cast_cache
[i
]) == typename
) {
832 if (!class || !class->interfaces
) {
837 ret
= object_class_dynamic_cast(class, typename
);
839 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
840 file
, line
, func
, class, typename
);
844 #ifdef CONFIG_QOM_CAST_DEBUG
845 if (class && ret
== class) {
846 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
847 atomic_set(&class->class_cast_cache
[i
- 1],
848 atomic_read(&class->class_cast_cache
[i
]));
850 atomic_set(&class->class_cast_cache
[i
- 1], typename
);
857 const char *object_get_typename(const Object
*obj
)
859 return obj
->class->type
->name
;
862 ObjectClass
*object_get_class(Object
*obj
)
867 bool object_class_is_abstract(ObjectClass
*klass
)
869 return klass
->type
->abstract
;
872 const char *object_class_get_name(ObjectClass
*klass
)
874 return klass
->type
->name
;
877 ObjectClass
*object_class_by_name(const char *typename
)
879 TypeImpl
*type
= type_get_by_name(typename
);
885 type_initialize(type
);
890 ObjectClass
*object_class_get_parent(ObjectClass
*class)
892 TypeImpl
*type
= type_get_parent(class->type
);
898 type_initialize(type
);
903 typedef struct OCFData
905 void (*fn
)(ObjectClass
*klass
, void *opaque
);
906 const char *implements_type
;
907 bool include_abstract
;
911 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
914 OCFData
*data
= opaque
;
915 TypeImpl
*type
= value
;
918 type_initialize(type
);
921 if (!data
->include_abstract
&& type
->abstract
) {
925 if (data
->implements_type
&&
926 !object_class_dynamic_cast(k
, data
->implements_type
)) {
930 data
->fn(k
, data
->opaque
);
933 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
934 const char *implements_type
, bool include_abstract
,
937 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
939 enumerating_types
= true;
940 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
941 enumerating_types
= false;
944 static int do_object_child_foreach(Object
*obj
,
945 int (*fn
)(Object
*child
, void *opaque
),
946 void *opaque
, bool recurse
)
949 ObjectProperty
*prop
;
952 g_hash_table_iter_init(&iter
, obj
->properties
);
953 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
954 if (object_property_is_child(prop
)) {
955 Object
*child
= prop
->opaque
;
957 ret
= fn(child
, opaque
);
962 do_object_child_foreach(child
, fn
, opaque
, true);
969 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
972 return do_object_child_foreach(obj
, fn
, opaque
, false);
975 int object_child_foreach_recursive(Object
*obj
,
976 int (*fn
)(Object
*child
, void *opaque
),
979 return do_object_child_foreach(obj
, fn
, opaque
, true);
982 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
984 GSList
**list
= opaque
;
986 *list
= g_slist_prepend(*list
, klass
);
989 GSList
*object_class_get_list(const char *implements_type
,
990 bool include_abstract
)
994 object_class_foreach(object_class_get_list_tramp
,
995 implements_type
, include_abstract
, &list
);
999 static gint
object_class_cmp(gconstpointer a
, gconstpointer b
)
1001 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
1002 object_class_get_name((ObjectClass
*)b
));
1005 GSList
*object_class_get_list_sorted(const char *implements_type
,
1006 bool include_abstract
)
1008 return g_slist_sort(object_class_get_list(implements_type
, include_abstract
),
1012 void object_ref(Object
*obj
)
1017 atomic_inc(&obj
->ref
);
1020 void object_unref(Object
*obj
)
1025 g_assert(obj
->ref
> 0);
1027 /* parent always holds a reference to its children */
1028 if (atomic_fetch_dec(&obj
->ref
) == 1) {
1029 object_finalize(obj
);
1034 object_property_add(Object
*obj
, const char *name
, const char *type
,
1035 ObjectPropertyAccessor
*get
,
1036 ObjectPropertyAccessor
*set
,
1037 ObjectPropertyRelease
*release
,
1038 void *opaque
, Error
**errp
)
1040 ObjectProperty
*prop
;
1041 size_t name_len
= strlen(name
);
1043 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
1045 ObjectProperty
*ret
;
1046 char *name_no_array
= g_strdup(name
);
1048 name_no_array
[name_len
- 3] = '\0';
1049 for (i
= 0; ; ++i
) {
1050 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
1052 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
1053 release
, opaque
, NULL
);
1059 g_free(name_no_array
);
1063 if (object_property_find(obj
, name
, NULL
) != NULL
) {
1064 error_setg(errp
, "attempt to add duplicate property '%s'"
1065 " to object (type '%s')", name
,
1066 object_get_typename(obj
));
1070 prop
= g_malloc0(sizeof(*prop
));
1072 prop
->name
= g_strdup(name
);
1073 prop
->type
= g_strdup(type
);
1077 prop
->release
= release
;
1078 prop
->opaque
= opaque
;
1080 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
1085 object_class_property_add(ObjectClass
*klass
,
1088 ObjectPropertyAccessor
*get
,
1089 ObjectPropertyAccessor
*set
,
1090 ObjectPropertyRelease
*release
,
1094 ObjectProperty
*prop
;
1096 if (object_class_property_find(klass
, name
, NULL
) != NULL
) {
1097 error_setg(errp
, "attempt to add duplicate property '%s'"
1098 " to object (type '%s')", name
,
1099 object_class_get_name(klass
));
1103 prop
= g_malloc0(sizeof(*prop
));
1105 prop
->name
= g_strdup(name
);
1106 prop
->type
= g_strdup(type
);
1110 prop
->release
= release
;
1111 prop
->opaque
= opaque
;
1113 g_hash_table_insert(klass
->properties
, g_strdup(name
), prop
);
1118 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
1121 ObjectProperty
*prop
;
1122 ObjectClass
*klass
= object_get_class(obj
);
1124 prop
= object_class_property_find(klass
, name
, NULL
);
1129 prop
= g_hash_table_lookup(obj
->properties
, name
);
1134 error_setg(errp
, "Property '.%s' not found", name
);
1138 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1141 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1142 iter
->nextclass
= object_get_class(obj
);
1145 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1148 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1149 if (!iter
->nextclass
) {
1152 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1153 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1158 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1161 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1162 iter
->nextclass
= object_class_get_parent(klass
);
1165 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
,
1168 ObjectProperty
*prop
;
1169 ObjectClass
*parent_klass
;
1171 parent_klass
= object_class_get_parent(klass
);
1173 prop
= object_class_property_find(parent_klass
, name
, NULL
);
1179 prop
= g_hash_table_lookup(klass
->properties
, name
);
1181 error_setg(errp
, "Property '.%s' not found", name
);
1186 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
1188 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1191 error_setg(errp
, "Property '.%s' not found", name
);
1195 if (prop
->release
) {
1196 prop
->release(obj
, name
, prop
->opaque
);
1198 g_hash_table_remove(obj
->properties
, name
);
1201 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
1204 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1210 error_setg(errp
, QERR_PERMISSION_DENIED
);
1212 prop
->get(obj
, v
, name
, prop
->opaque
, errp
);
1216 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
1219 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1225 error_setg(errp
, QERR_PERMISSION_DENIED
);
1227 prop
->set(obj
, v
, name
, prop
->opaque
, errp
);
1231 void object_property_set_str(Object
*obj
, const char *value
,
1232 const char *name
, Error
**errp
)
1234 QString
*qstr
= qstring_from_str(value
);
1235 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
1237 qobject_unref(qstr
);
1240 char *object_property_get_str(Object
*obj
, const char *name
,
1243 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1250 retval
= g_strdup(qobject_get_try_str(ret
));
1252 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1259 void object_property_set_link(Object
*obj
, Object
*value
,
1260 const char *name
, Error
**errp
)
1263 gchar
*path
= object_get_canonical_path(value
);
1264 object_property_set_str(obj
, path
, name
, errp
);
1267 object_property_set_str(obj
, "", name
, errp
);
1271 Object
*object_property_get_link(Object
*obj
, const char *name
,
1274 char *str
= object_property_get_str(obj
, name
, errp
);
1275 Object
*target
= NULL
;
1278 target
= object_resolve_path(str
, NULL
);
1280 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1281 "Device '%s' not found", str
);
1289 void object_property_set_bool(Object
*obj
, bool value
,
1290 const char *name
, Error
**errp
)
1292 QBool
*qbool
= qbool_from_bool(value
);
1293 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
1295 qobject_unref(qbool
);
1298 bool object_property_get_bool(Object
*obj
, const char *name
,
1301 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1308 qbool
= qobject_to(QBool
, ret
);
1310 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1313 retval
= qbool_get_bool(qbool
);
1320 void object_property_set_int(Object
*obj
, int64_t value
,
1321 const char *name
, Error
**errp
)
1323 QNum
*qnum
= qnum_from_int(value
);
1324 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1326 qobject_unref(qnum
);
1329 int64_t object_property_get_int(Object
*obj
, const char *name
,
1332 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1340 qnum
= qobject_to(QNum
, ret
);
1341 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1342 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1350 void object_property_set_uint(Object
*obj
, uint64_t value
,
1351 const char *name
, Error
**errp
)
1353 QNum
*qnum
= qnum_from_uint(value
);
1355 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1356 qobject_unref(qnum
);
1359 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1362 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1369 qnum
= qobject_to(QNum
, ret
);
1370 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1371 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "uint");
1379 typedef struct EnumProperty
{
1380 const QEnumLookup
*lookup
;
1381 int (*get
)(Object
*, Error
**);
1382 void (*set
)(Object
*, int, Error
**);
1385 int object_property_get_enum(Object
*obj
, const char *name
,
1386 const char *typename
, Error
**errp
)
1392 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1393 EnumProperty
*enumprop
;
1399 if (!g_str_equal(prop
->type
, typename
)) {
1400 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1401 name
, object_class_get_name(
1402 object_get_class(obj
)), typename
);
1406 enumprop
= prop
->opaque
;
1408 v
= string_output_visitor_new(false, &str
);
1409 object_property_get(obj
, v
, name
, &err
);
1411 error_propagate(errp
, err
);
1415 visit_complete(v
, &str
);
1417 v
= string_input_visitor_new(str
);
1418 visit_type_enum(v
, name
, &ret
, enumprop
->lookup
, errp
);
1426 void object_property_get_uint16List(Object
*obj
, const char *name
,
1427 uint16List
**list
, Error
**errp
)
1433 v
= string_output_visitor_new(false, &str
);
1434 object_property_get(obj
, v
, name
, &err
);
1436 error_propagate(errp
, err
);
1439 visit_complete(v
, &str
);
1441 v
= string_input_visitor_new(str
);
1442 visit_type_uint16List(v
, NULL
, list
, errp
);
1449 void object_property_parse(Object
*obj
, const char *string
,
1450 const char *name
, Error
**errp
)
1452 Visitor
*v
= string_input_visitor_new(string
);
1453 object_property_set(obj
, v
, name
, errp
);
1457 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1461 char *string
= NULL
;
1462 Error
*local_err
= NULL
;
1464 v
= string_output_visitor_new(human
, &string
);
1465 object_property_get(obj
, v
, name
, &local_err
);
1467 error_propagate(errp
, local_err
);
1471 visit_complete(v
, &string
);
1478 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1480 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1488 Object
*object_get_root(void)
1490 static Object
*root
;
1493 root
= object_new("container");
1499 Object
*object_get_objects_root(void)
1501 return container_get(object_get_root(), "/objects");
1504 Object
*object_get_internal_root(void)
1506 static Object
*internal_root
;
1508 if (!internal_root
) {
1509 internal_root
= object_new("container");
1512 return internal_root
;
1515 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1516 const char *name
, void *opaque
,
1519 Object
*child
= opaque
;
1522 path
= object_get_canonical_path(child
);
1523 visit_type_str(v
, name
, &path
, errp
);
1527 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1532 static void object_finalize_child_property(Object
*obj
, const char *name
,
1535 Object
*child
= opaque
;
1537 if (child
->class->unparent
) {
1538 (child
->class->unparent
)(child
);
1540 child
->parent
= NULL
;
1541 object_unref(child
);
1544 void object_property_add_child(Object
*obj
, const char *name
,
1545 Object
*child
, Error
**errp
)
1547 Error
*local_err
= NULL
;
1551 if (child
->parent
!= NULL
) {
1552 error_setg(errp
, "child object is already parented");
1556 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1558 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1559 object_finalize_child_property
, child
, &local_err
);
1561 error_propagate(errp
, local_err
);
1565 op
->resolve
= object_resolve_child_property
;
1567 child
->parent
= obj
;
1573 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1574 Object
*val
, Error
**errp
)
1576 /* Allow the link to be set, always */
1581 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1582 ObjectPropertyLinkFlags flags
;
1585 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1586 const char *name
, void *opaque
,
1589 LinkProperty
*lprop
= opaque
;
1590 Object
**child
= lprop
->child
;
1594 path
= object_get_canonical_path(*child
);
1595 visit_type_str(v
, name
, &path
, errp
);
1599 visit_type_str(v
, name
, &path
, errp
);
1604 * object_resolve_link:
1606 * Lookup an object and ensure its type matches the link property type. This
1607 * is similar to object_resolve_path() except type verification against the
1608 * link property is performed.
1610 * Returns: The matched object or NULL on path lookup failures.
1612 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1613 const char *path
, Error
**errp
)
1617 bool ambiguous
= false;
1620 /* Go from link<FOO> to FOO. */
1621 type
= object_property_get_type(obj
, name
, NULL
);
1622 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1623 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1626 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1628 } else if (!target
) {
1629 target
= object_resolve_path(path
, &ambiguous
);
1630 if (target
|| ambiguous
) {
1631 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1633 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1634 "Device '%s' not found", path
);
1638 g_free(target_type
);
1643 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1644 const char *name
, void *opaque
,
1647 Error
*local_err
= NULL
;
1648 LinkProperty
*prop
= opaque
;
1649 Object
**child
= prop
->child
;
1650 Object
*old_target
= *child
;
1651 Object
*new_target
= NULL
;
1654 visit_type_str(v
, name
, &path
, &local_err
);
1656 if (!local_err
&& strcmp(path
, "") != 0) {
1657 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1662 error_propagate(errp
, local_err
);
1666 prop
->check(obj
, name
, new_target
, &local_err
);
1668 error_propagate(errp
, local_err
);
1672 *child
= new_target
;
1673 if (prop
->flags
== OBJ_PROP_LINK_STRONG
) {
1674 object_ref(new_target
);
1675 object_unref(old_target
);
1679 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1681 LinkProperty
*lprop
= opaque
;
1683 return *lprop
->child
;
1686 static void object_release_link_property(Object
*obj
, const char *name
,
1689 LinkProperty
*prop
= opaque
;
1691 if ((prop
->flags
& OBJ_PROP_LINK_STRONG
) && *prop
->child
) {
1692 object_unref(*prop
->child
);
1697 void object_property_add_link(Object
*obj
, const char *name
,
1698 const char *type
, Object
**child
,
1699 void (*check
)(const Object
*, const char *,
1700 Object
*, Error
**),
1701 ObjectPropertyLinkFlags flags
,
1704 Error
*local_err
= NULL
;
1705 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1709 prop
->child
= child
;
1710 prop
->check
= check
;
1711 prop
->flags
= flags
;
1713 full_type
= g_strdup_printf("link<%s>", type
);
1715 op
= object_property_add(obj
, name
, full_type
,
1716 object_get_link_property
,
1717 check
? object_set_link_property
: NULL
,
1718 object_release_link_property
,
1722 error_propagate(errp
, local_err
);
1727 op
->resolve
= object_resolve_link_property
;
1733 void object_property_add_const_link(Object
*obj
, const char *name
,
1734 Object
*target
, Error
**errp
)
1739 link_type
= g_strdup_printf("link<%s>", object_get_typename(target
));
1740 op
= object_property_add(obj
, name
, link_type
,
1741 object_get_child_property
, NULL
,
1742 NULL
, target
, errp
);
1744 op
->resolve
= object_resolve_child_property
;
1749 gchar
*object_get_canonical_path_component(Object
*obj
)
1751 ObjectProperty
*prop
= NULL
;
1752 GHashTableIter iter
;
1754 if (obj
->parent
== NULL
) {
1758 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
1759 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1760 if (!object_property_is_child(prop
)) {
1764 if (prop
->opaque
== obj
) {
1765 return g_strdup(prop
->name
);
1769 /* obj had a parent but was not a child, should never happen */
1770 g_assert_not_reached();
1774 gchar
*object_get_canonical_path(Object
*obj
)
1776 Object
*root
= object_get_root();
1777 char *newpath
, *path
= NULL
;
1780 return g_strdup("/");
1784 char *component
= object_get_canonical_path_component(obj
);
1787 /* A canonical path must be complete, so discard what was
1794 newpath
= g_strdup_printf("/%s%s", component
, path
? path
: "");
1799 } while (obj
!= root
);
1804 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
1806 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1811 if (prop
->resolve
) {
1812 return prop
->resolve(parent
, prop
->opaque
, part
);
1818 static Object
*object_resolve_abs_path(Object
*parent
,
1820 const char *typename
,
1825 if (parts
[index
] == NULL
) {
1826 return object_dynamic_cast(parent
, typename
);
1829 if (strcmp(parts
[index
], "") == 0) {
1830 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
1833 child
= object_resolve_path_component(parent
, parts
[index
]);
1838 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
1841 static Object
*object_resolve_partial_path(Object
*parent
,
1843 const char *typename
,
1847 GHashTableIter iter
;
1848 ObjectProperty
*prop
;
1850 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
1852 g_hash_table_iter_init(&iter
, parent
->properties
);
1853 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1856 if (!object_property_is_child(prop
)) {
1860 found
= object_resolve_partial_path(prop
->opaque
, parts
,
1861 typename
, ambiguous
);
1878 Object
*object_resolve_path_type(const char *path
, const char *typename
,
1884 parts
= g_strsplit(path
, "/", 0);
1887 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
1888 bool ambiguous
= false;
1889 obj
= object_resolve_partial_path(object_get_root(), parts
,
1890 typename
, &ambiguous
);
1892 *ambiguousp
= ambiguous
;
1895 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
1903 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
1905 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
1908 typedef struct StringProperty
1910 char *(*get
)(Object
*, Error
**);
1911 void (*set
)(Object
*, const char *, Error
**);
1914 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
1915 void *opaque
, Error
**errp
)
1917 StringProperty
*prop
= opaque
;
1921 value
= prop
->get(obj
, &err
);
1923 error_propagate(errp
, err
);
1927 visit_type_str(v
, name
, &value
, errp
);
1931 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
1932 void *opaque
, Error
**errp
)
1934 StringProperty
*prop
= opaque
;
1936 Error
*local_err
= NULL
;
1938 visit_type_str(v
, name
, &value
, &local_err
);
1940 error_propagate(errp
, local_err
);
1944 prop
->set(obj
, value
, errp
);
1948 static void property_release_str(Object
*obj
, const char *name
,
1951 StringProperty
*prop
= opaque
;
1955 void object_property_add_str(Object
*obj
, const char *name
,
1956 char *(*get
)(Object
*, Error
**),
1957 void (*set
)(Object
*, const char *, Error
**),
1960 Error
*local_err
= NULL
;
1961 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1966 object_property_add(obj
, name
, "string",
1967 get
? property_get_str
: NULL
,
1968 set
? property_set_str
: NULL
,
1969 property_release_str
,
1972 error_propagate(errp
, local_err
);
1977 void object_class_property_add_str(ObjectClass
*klass
, const char *name
,
1978 char *(*get
)(Object
*, Error
**),
1979 void (*set
)(Object
*, const char *,
1983 Error
*local_err
= NULL
;
1984 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1989 object_class_property_add(klass
, name
, "string",
1990 get
? property_get_str
: NULL
,
1991 set
? property_set_str
: NULL
,
1992 property_release_str
,
1995 error_propagate(errp
, local_err
);
2000 typedef struct BoolProperty
2002 bool (*get
)(Object
*, Error
**);
2003 void (*set
)(Object
*, bool, Error
**);
2006 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
2007 void *opaque
, Error
**errp
)
2009 BoolProperty
*prop
= opaque
;
2013 value
= prop
->get(obj
, &err
);
2015 error_propagate(errp
, err
);
2019 visit_type_bool(v
, name
, &value
, errp
);
2022 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
2023 void *opaque
, Error
**errp
)
2025 BoolProperty
*prop
= opaque
;
2027 Error
*local_err
= NULL
;
2029 visit_type_bool(v
, name
, &value
, &local_err
);
2031 error_propagate(errp
, local_err
);
2035 prop
->set(obj
, value
, errp
);
2038 static void property_release_bool(Object
*obj
, const char *name
,
2041 BoolProperty
*prop
= opaque
;
2045 void object_property_add_bool(Object
*obj
, const char *name
,
2046 bool (*get
)(Object
*, Error
**),
2047 void (*set
)(Object
*, bool, Error
**),
2050 Error
*local_err
= NULL
;
2051 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2056 object_property_add(obj
, name
, "bool",
2057 get
? property_get_bool
: NULL
,
2058 set
? property_set_bool
: NULL
,
2059 property_release_bool
,
2062 error_propagate(errp
, local_err
);
2067 void object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
2068 bool (*get
)(Object
*, Error
**),
2069 void (*set
)(Object
*, bool, Error
**),
2072 Error
*local_err
= NULL
;
2073 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2078 object_class_property_add(klass
, name
, "bool",
2079 get
? property_get_bool
: NULL
,
2080 set
? property_set_bool
: NULL
,
2081 property_release_bool
,
2084 error_propagate(errp
, local_err
);
2089 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
2090 void *opaque
, Error
**errp
)
2092 EnumProperty
*prop
= opaque
;
2096 value
= prop
->get(obj
, &err
);
2098 error_propagate(errp
, err
);
2102 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
2105 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
2106 void *opaque
, Error
**errp
)
2108 EnumProperty
*prop
= opaque
;
2112 visit_type_enum(v
, name
, &value
, prop
->lookup
, &err
);
2114 error_propagate(errp
, err
);
2117 prop
->set(obj
, value
, errp
);
2120 static void property_release_enum(Object
*obj
, const char *name
,
2123 EnumProperty
*prop
= opaque
;
2127 void object_property_add_enum(Object
*obj
, const char *name
,
2128 const char *typename
,
2129 const QEnumLookup
*lookup
,
2130 int (*get
)(Object
*, Error
**),
2131 void (*set
)(Object
*, int, Error
**),
2134 Error
*local_err
= NULL
;
2135 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2137 prop
->lookup
= lookup
;
2141 object_property_add(obj
, name
, typename
,
2142 get
? property_get_enum
: NULL
,
2143 set
? property_set_enum
: NULL
,
2144 property_release_enum
,
2147 error_propagate(errp
, local_err
);
2152 void object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2153 const char *typename
,
2154 const QEnumLookup
*lookup
,
2155 int (*get
)(Object
*, Error
**),
2156 void (*set
)(Object
*, int, Error
**),
2159 Error
*local_err
= NULL
;
2160 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2162 prop
->lookup
= lookup
;
2166 object_class_property_add(klass
, name
, typename
,
2167 get
? property_get_enum
: NULL
,
2168 set
? property_set_enum
: NULL
,
2169 property_release_enum
,
2172 error_propagate(errp
, local_err
);
2177 typedef struct TMProperty
{
2178 void (*get
)(Object
*, struct tm
*, Error
**);
2181 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2182 void *opaque
, Error
**errp
)
2184 TMProperty
*prop
= opaque
;
2188 prop
->get(obj
, &value
, &err
);
2193 visit_start_struct(v
, name
, NULL
, 0, &err
);
2197 visit_type_int32(v
, "tm_year", &value
.tm_year
, &err
);
2201 visit_type_int32(v
, "tm_mon", &value
.tm_mon
, &err
);
2205 visit_type_int32(v
, "tm_mday", &value
.tm_mday
, &err
);
2209 visit_type_int32(v
, "tm_hour", &value
.tm_hour
, &err
);
2213 visit_type_int32(v
, "tm_min", &value
.tm_min
, &err
);
2217 visit_type_int32(v
, "tm_sec", &value
.tm_sec
, &err
);
2221 visit_check_struct(v
, &err
);
2223 visit_end_struct(v
, NULL
);
2225 error_propagate(errp
, err
);
2229 static void property_release_tm(Object
*obj
, const char *name
,
2232 TMProperty
*prop
= opaque
;
2236 void object_property_add_tm(Object
*obj
, const char *name
,
2237 void (*get
)(Object
*, struct tm
*, Error
**),
2240 Error
*local_err
= NULL
;
2241 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2245 object_property_add(obj
, name
, "struct tm",
2246 get
? property_get_tm
: NULL
, NULL
,
2247 property_release_tm
,
2250 error_propagate(errp
, local_err
);
2255 void object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2256 void (*get
)(Object
*, struct tm
*, Error
**),
2259 Error
*local_err
= NULL
;
2260 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2264 object_class_property_add(klass
, name
, "struct tm",
2265 get
? property_get_tm
: NULL
, NULL
,
2266 property_release_tm
,
2269 error_propagate(errp
, local_err
);
2274 static char *qdev_get_type(Object
*obj
, Error
**errp
)
2276 return g_strdup(object_get_typename(obj
));
2279 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2280 void *opaque
, Error
**errp
)
2282 uint8_t value
= *(uint8_t *)opaque
;
2283 visit_type_uint8(v
, name
, &value
, errp
);
2286 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2287 void *opaque
, Error
**errp
)
2289 uint16_t value
= *(uint16_t *)opaque
;
2290 visit_type_uint16(v
, name
, &value
, errp
);
2293 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2294 void *opaque
, Error
**errp
)
2296 uint32_t value
= *(uint32_t *)opaque
;
2297 visit_type_uint32(v
, name
, &value
, errp
);
2300 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2301 void *opaque
, Error
**errp
)
2303 uint64_t value
= *(uint64_t *)opaque
;
2304 visit_type_uint64(v
, name
, &value
, errp
);
2307 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2308 const uint8_t *v
, Error
**errp
)
2310 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
2311 NULL
, NULL
, (void *)v
, errp
);
2314 void object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2315 const uint8_t *v
, Error
**errp
)
2317 object_class_property_add(klass
, name
, "uint8", property_get_uint8_ptr
,
2318 NULL
, NULL
, (void *)v
, errp
);
2321 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2322 const uint16_t *v
, Error
**errp
)
2324 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
2325 NULL
, NULL
, (void *)v
, errp
);
2328 void object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2329 const uint16_t *v
, Error
**errp
)
2331 object_class_property_add(klass
, name
, "uint16", property_get_uint16_ptr
,
2332 NULL
, NULL
, (void *)v
, errp
);
2335 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2336 const uint32_t *v
, Error
**errp
)
2338 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
2339 NULL
, NULL
, (void *)v
, errp
);
2342 void object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2343 const uint32_t *v
, Error
**errp
)
2345 object_class_property_add(klass
, name
, "uint32", property_get_uint32_ptr
,
2346 NULL
, NULL
, (void *)v
, errp
);
2349 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2350 const uint64_t *v
, Error
**errp
)
2352 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
2353 NULL
, NULL
, (void *)v
, errp
);
2356 void object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2357 const uint64_t *v
, Error
**errp
)
2359 object_class_property_add(klass
, name
, "uint64", property_get_uint64_ptr
,
2360 NULL
, NULL
, (void *)v
, errp
);
2368 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2369 void *opaque
, Error
**errp
)
2371 AliasProperty
*prop
= opaque
;
2373 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
2376 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2377 void *opaque
, Error
**errp
)
2379 AliasProperty
*prop
= opaque
;
2381 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
2384 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2387 AliasProperty
*prop
= opaque
;
2389 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2392 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2394 AliasProperty
*prop
= opaque
;
2396 g_free(prop
->target_name
);
2400 void object_property_add_alias(Object
*obj
, const char *name
,
2401 Object
*target_obj
, const char *target_name
,
2404 AliasProperty
*prop
;
2406 ObjectProperty
*target_prop
;
2408 Error
*local_err
= NULL
;
2410 target_prop
= object_property_find(target_obj
, target_name
, errp
);
2415 if (object_property_is_child(target_prop
)) {
2416 prop_type
= g_strdup_printf("link%s",
2417 target_prop
->type
+ strlen("child"));
2419 prop_type
= g_strdup(target_prop
->type
);
2422 prop
= g_malloc(sizeof(*prop
));
2423 prop
->target_obj
= target_obj
;
2424 prop
->target_name
= g_strdup(target_name
);
2426 op
= object_property_add(obj
, name
, prop_type
,
2429 property_release_alias
,
2432 error_propagate(errp
, local_err
);
2436 op
->resolve
= property_resolve_alias
;
2438 object_property_set_description(obj
, op
->name
,
2439 target_prop
->description
,
2446 void object_property_set_description(Object
*obj
, const char *name
,
2447 const char *description
, Error
**errp
)
2451 op
= object_property_find(obj
, name
, errp
);
2456 g_free(op
->description
);
2457 op
->description
= g_strdup(description
);
2460 void object_class_property_set_description(ObjectClass
*klass
,
2462 const char *description
,
2467 op
= g_hash_table_lookup(klass
->properties
, name
);
2469 error_setg(errp
, "Property '.%s' not found", name
);
2473 g_free(op
->description
);
2474 op
->description
= g_strdup(description
);
2477 static void object_class_init(ObjectClass
*klass
, void *data
)
2479 object_class_property_add_str(klass
, "type", qdev_get_type
,
2480 NULL
, &error_abort
);
2483 static void register_types(void)
2485 static TypeInfo interface_info
= {
2486 .name
= TYPE_INTERFACE
,
2487 .class_size
= sizeof(InterfaceClass
),
2491 static TypeInfo object_info
= {
2492 .name
= TYPE_OBJECT
,
2493 .instance_size
= sizeof(Object
),
2494 .class_init
= object_class_init
,
2498 type_interface
= type_register_internal(&interface_info
);
2499 type_register_internal(&object_info
);
2502 type_init(register_types
)