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"
31 #include "qemu/error-report.h"
33 #define MAX_INTERFACES 32
35 typedef struct InterfaceImpl InterfaceImpl
;
36 typedef struct TypeImpl TypeImpl
;
51 void (*class_init
)(ObjectClass
*klass
, void *data
);
52 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
56 void (*instance_init
)(Object
*obj
);
57 void (*instance_post_init
)(Object
*obj
);
58 void (*instance_finalize
)(Object
*obj
);
63 TypeImpl
*parent_type
;
68 InterfaceImpl interfaces
[MAX_INTERFACES
];
71 static Type type_interface
;
73 static GHashTable
*type_table_get(void)
75 static GHashTable
*type_table
;
77 if (type_table
== NULL
) {
78 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
84 static bool enumerating_types
;
86 static void type_table_add(TypeImpl
*ti
)
88 assert(!enumerating_types
);
89 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
92 static TypeImpl
*type_table_lookup(const char *name
)
94 return g_hash_table_lookup(type_table_get(), name
);
97 static TypeImpl
*type_new(const TypeInfo
*info
)
99 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
102 g_assert(info
->name
!= NULL
);
104 if (type_table_lookup(info
->name
) != NULL
) {
105 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
109 ti
->name
= g_strdup(info
->name
);
110 ti
->parent
= g_strdup(info
->parent
);
112 ti
->class_size
= info
->class_size
;
113 ti
->instance_size
= info
->instance_size
;
115 ti
->class_init
= info
->class_init
;
116 ti
->class_base_init
= info
->class_base_init
;
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 void type_register_static_array(const TypeInfo
*infos
, int nr_infos
)
157 for (i
= 0; i
< nr_infos
; i
++) {
158 type_register_static(&infos
[i
]);
162 static TypeImpl
*type_get_by_name(const char *name
)
168 return type_table_lookup(name
);
171 static TypeImpl
*type_get_parent(TypeImpl
*type
)
173 if (!type
->parent_type
&& type
->parent
) {
174 type
->parent_type
= type_get_by_name(type
->parent
);
175 g_assert(type
->parent_type
!= NULL
);
178 return type
->parent_type
;
181 static bool type_has_parent(TypeImpl
*type
)
183 return (type
->parent
!= NULL
);
186 static size_t type_class_get_size(TypeImpl
*ti
)
188 if (ti
->class_size
) {
189 return ti
->class_size
;
192 if (type_has_parent(ti
)) {
193 return type_class_get_size(type_get_parent(ti
));
196 return sizeof(ObjectClass
);
199 static size_t type_object_get_size(TypeImpl
*ti
)
201 if (ti
->instance_size
) {
202 return ti
->instance_size
;
205 if (type_has_parent(ti
)) {
206 return type_object_get_size(type_get_parent(ti
));
212 size_t object_type_get_instance_size(const char *typename
)
214 TypeImpl
*type
= type_get_by_name(typename
);
216 g_assert(type
!= NULL
);
217 return type_object_get_size(type
);
220 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
224 /* Check if target_type is a direct ancestor of type */
226 if (type
== target_type
) {
230 type
= type_get_parent(type
);
236 static void type_initialize(TypeImpl
*ti
);
238 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
239 TypeImpl
*parent_type
)
241 InterfaceClass
*new_iface
;
243 TypeImpl
*iface_impl
;
245 info
.parent
= parent_type
->name
;
246 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
247 info
.abstract
= true;
249 iface_impl
= type_new(&info
);
250 iface_impl
->parent_type
= parent_type
;
251 type_initialize(iface_impl
);
252 g_free((char *)info
.name
);
254 new_iface
= (InterfaceClass
*)iface_impl
->class;
255 new_iface
->concrete_class
= ti
->class;
256 new_iface
->interface_type
= interface_type
;
258 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
262 static void object_property_free(gpointer data
)
264 ObjectProperty
*prop
= data
;
268 g_free(prop
->description
);
272 static void type_initialize(TypeImpl
*ti
)
280 ti
->class_size
= type_class_get_size(ti
);
281 ti
->instance_size
= type_object_get_size(ti
);
282 /* Any type with zero instance_size is implicitly abstract.
283 * This means interface types are all abstract.
285 if (ti
->instance_size
== 0) {
288 if (type_is_ancestor(ti
, type_interface
)) {
289 assert(ti
->instance_size
== 0);
290 assert(ti
->abstract
);
291 assert(!ti
->instance_init
);
292 assert(!ti
->instance_post_init
);
293 assert(!ti
->instance_finalize
);
294 assert(!ti
->num_interfaces
);
296 ti
->class = g_malloc0(ti
->class_size
);
298 parent
= type_get_parent(ti
);
300 type_initialize(parent
);
304 g_assert(parent
->class_size
<= ti
->class_size
);
305 memcpy(ti
->class, parent
->class, parent
->class_size
);
306 ti
->class->interfaces
= NULL
;
307 ti
->class->properties
= g_hash_table_new_full(
308 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
310 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
311 InterfaceClass
*iface
= e
->data
;
312 ObjectClass
*klass
= OBJECT_CLASS(iface
);
314 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
317 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
318 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
319 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
320 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
322 if (type_is_ancestor(target_type
, t
)) {
331 type_initialize_interface(ti
, t
, t
);
334 ti
->class->properties
= g_hash_table_new_full(
335 g_str_hash
, g_str_equal
, g_free
, object_property_free
);
338 ti
->class->type
= ti
;
341 if (parent
->class_base_init
) {
342 parent
->class_base_init(ti
->class, ti
->class_data
);
344 parent
= type_get_parent(parent
);
347 if (ti
->class_init
) {
348 ti
->class_init(ti
->class, ti
->class_data
);
352 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
354 if (type_has_parent(ti
)) {
355 object_init_with_type(obj
, type_get_parent(ti
));
358 if (ti
->instance_init
) {
359 ti
->instance_init(obj
);
363 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
365 if (ti
->instance_post_init
) {
366 ti
->instance_post_init(obj
);
369 if (type_has_parent(ti
)) {
370 object_post_init_with_type(obj
, type_get_parent(ti
));
374 void object_apply_global_props(Object
*obj
, const GPtrArray
*props
, Error
**errp
)
382 for (i
= 0; i
< props
->len
; i
++) {
383 GlobalProperty
*p
= g_ptr_array_index(props
, i
);
386 if (object_dynamic_cast(obj
, p
->driver
) == NULL
) {
389 if (p
->optional
&& !object_property_find(obj
, p
->property
, NULL
)) {
393 object_property_parse(obj
, p
->value
, p
->property
, &err
);
395 error_prepend(&err
, "can't apply global %s.%s=%s: ",
396 p
->driver
, p
->property
, p
->value
);
398 * If errp != NULL, propagate error and return.
399 * If errp == NULL, report a warning, but keep going
400 * with the remaining globals.
403 error_propagate(errp
, err
);
406 warn_report_err(err
);
413 * Global property defaults
414 * Slot 0: accelerator's global property defaults
415 * Slot 1: machine's global property defaults
416 * Each is a GPtrArray of of GlobalProperty.
417 * Applied in order, later entries override earlier ones.
419 static GPtrArray
*object_compat_props
[2];
422 * Set machine's global property defaults to @compat_props.
423 * May be called at most once.
425 void object_set_machine_compat_props(GPtrArray
*compat_props
)
427 assert(!object_compat_props
[1]);
428 object_compat_props
[1] = compat_props
;
432 * Set accelerator's global property defaults to @compat_props.
433 * May be called at most once.
435 void object_set_accelerator_compat_props(GPtrArray
*compat_props
)
437 assert(!object_compat_props
[0]);
438 object_compat_props
[0] = compat_props
;
441 void object_apply_compat_props(Object
*obj
)
445 for (i
= 0; i
< ARRAY_SIZE(object_compat_props
); i
++) {
446 object_apply_global_props(obj
, object_compat_props
[i
],
451 static void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
455 type_initialize(type
);
457 g_assert(type
->instance_size
>= sizeof(Object
));
458 g_assert(type
->abstract
== false);
459 g_assert(size
>= type
->instance_size
);
461 memset(obj
, 0, type
->instance_size
);
462 obj
->class = type
->class;
464 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
465 NULL
, object_property_free
);
466 object_init_with_type(obj
, type
);
467 object_post_init_with_type(obj
, type
);
470 void object_initialize(void *data
, size_t size
, const char *typename
)
472 TypeImpl
*type
= type_get_by_name(typename
);
475 error_report("missing object type '%s'", typename
);
479 object_initialize_with_type(data
, size
, type
);
482 void object_initialize_child(Object
*parentobj
, const char *propname
,
483 void *childobj
, size_t size
, const char *type
,
488 va_start(vargs
, errp
);
489 object_initialize_childv(parentobj
, propname
, childobj
, size
, type
, errp
,
494 void object_initialize_childv(Object
*parentobj
, const char *propname
,
495 void *childobj
, size_t size
, const char *type
,
496 Error
**errp
, va_list vargs
)
498 Error
*local_err
= NULL
;
502 object_initialize(childobj
, size
, type
);
503 obj
= OBJECT(childobj
);
505 object_set_propv(obj
, &local_err
, vargs
);
510 object_property_add_child(parentobj
, propname
, obj
, &local_err
);
515 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
517 user_creatable_complete(uc
, &local_err
);
519 object_unparent(obj
);
525 * Since object_property_add_child added a reference to the child object,
526 * we can drop the reference added by object_initialize(), so the child
527 * property will own the only reference to the object.
533 error_propagate(errp
, local_err
);
538 static inline bool object_property_is_child(ObjectProperty
*prop
)
540 return strstart(prop
->type
, "child<", NULL
);
543 static void object_property_del_all(Object
*obj
)
545 ObjectProperty
*prop
;
552 g_hash_table_iter_init(&iter
, obj
->properties
);
553 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
556 prop
->release(obj
, prop
->name
, prop
->opaque
);
557 prop
->release
= NULL
;
561 g_hash_table_iter_remove(&iter
);
565 g_hash_table_unref(obj
->properties
);
568 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
570 ObjectProperty
*prop
;
574 g_hash_table_iter_init(&iter
, obj
->properties
);
575 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
577 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
579 prop
->release(obj
, prop
->name
, prop
->opaque
);
580 prop
->release
= NULL
;
585 g_hash_table_iter_init(&iter
, obj
->properties
);
586 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
588 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
589 g_hash_table_iter_remove(&iter
);
595 void object_unparent(Object
*obj
)
598 object_property_del_child(obj
->parent
, obj
, NULL
);
602 static void object_deinit(Object
*obj
, TypeImpl
*type
)
604 if (type
->instance_finalize
) {
605 type
->instance_finalize(obj
);
608 if (type_has_parent(type
)) {
609 object_deinit(obj
, type_get_parent(type
));
613 static void object_finalize(void *data
)
616 TypeImpl
*ti
= obj
->class->type
;
618 object_property_del_all(obj
);
619 object_deinit(obj
, ti
);
621 g_assert(obj
->ref
== 0);
627 static Object
*object_new_with_type(Type type
)
631 g_assert(type
!= NULL
);
632 type_initialize(type
);
634 obj
= g_malloc(type
->instance_size
);
635 object_initialize_with_type(obj
, type
->instance_size
, type
);
641 Object
*object_new(const char *typename
)
643 TypeImpl
*ti
= type_get_by_name(typename
);
645 return object_new_with_type(ti
);
649 Object
*object_new_with_props(const char *typename
,
658 va_start(vargs
, errp
);
659 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
666 Object
*object_new_with_propv(const char *typename
,
674 Error
*local_err
= NULL
;
677 klass
= object_class_by_name(typename
);
679 error_setg(errp
, "invalid object type: %s", typename
);
683 if (object_class_is_abstract(klass
)) {
684 error_setg(errp
, "object type '%s' is abstract", typename
);
687 obj
= object_new_with_type(klass
->type
);
689 if (object_set_propv(obj
, &local_err
, vargs
) < 0) {
694 object_property_add_child(parent
, id
, obj
, &local_err
);
700 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
702 user_creatable_complete(uc
, &local_err
);
705 object_unparent(obj
);
711 object_unref(OBJECT(obj
));
715 error_propagate(errp
, local_err
);
721 int object_set_props(Object
*obj
,
728 va_start(vargs
, errp
);
729 ret
= object_set_propv(obj
, errp
, vargs
);
736 int object_set_propv(Object
*obj
,
740 const char *propname
;
741 Error
*local_err
= NULL
;
743 propname
= va_arg(vargs
, char *);
744 while (propname
!= NULL
) {
745 const char *value
= va_arg(vargs
, char *);
747 g_assert(value
!= NULL
);
748 object_property_parse(obj
, value
, propname
, &local_err
);
750 error_propagate(errp
, local_err
);
753 propname
= va_arg(vargs
, char *);
760 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
762 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
769 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
770 const char *file
, int line
, const char *func
)
772 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
773 typename
, file
, line
, func
);
775 #ifdef CONFIG_QOM_CAST_DEBUG
779 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
780 if (atomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
785 inst
= object_dynamic_cast(obj
, typename
);
788 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
789 file
, line
, func
, obj
, typename
);
795 if (obj
&& obj
== inst
) {
796 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
797 atomic_set(&obj
->class->object_cast_cache
[i
- 1],
798 atomic_read(&obj
->class->object_cast_cache
[i
]));
800 atomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
808 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
809 const char *typename
)
811 ObjectClass
*ret
= NULL
;
812 TypeImpl
*target_type
;
819 /* A simple fast path that can trigger a lot for leaf classes. */
821 if (type
->name
== typename
) {
825 target_type
= type_get_by_name(typename
);
827 /* target class type unknown, so fail the cast */
831 if (type
->class->interfaces
&&
832 type_is_ancestor(target_type
, type_interface
)) {
836 for (i
= class->interfaces
; i
; i
= i
->next
) {
837 ObjectClass
*target_class
= i
->data
;
839 if (type_is_ancestor(target_class
->type
, target_type
)) {
845 /* The match was ambiguous, don't allow a cast */
849 } else if (type_is_ancestor(type
, target_type
)) {
856 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
857 const char *typename
,
858 const char *file
, int line
,
863 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
864 typename
, file
, line
, func
);
866 #ifdef CONFIG_QOM_CAST_DEBUG
869 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
870 if (atomic_read(&class->class_cast_cache
[i
]) == typename
) {
876 if (!class || !class->interfaces
) {
881 ret
= object_class_dynamic_cast(class, typename
);
883 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
884 file
, line
, func
, class, typename
);
888 #ifdef CONFIG_QOM_CAST_DEBUG
889 if (class && ret
== class) {
890 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
891 atomic_set(&class->class_cast_cache
[i
- 1],
892 atomic_read(&class->class_cast_cache
[i
]));
894 atomic_set(&class->class_cast_cache
[i
- 1], typename
);
901 const char *object_get_typename(const Object
*obj
)
903 return obj
->class->type
->name
;
906 ObjectClass
*object_get_class(Object
*obj
)
911 bool object_class_is_abstract(ObjectClass
*klass
)
913 return klass
->type
->abstract
;
916 const char *object_class_get_name(ObjectClass
*klass
)
918 return klass
->type
->name
;
921 ObjectClass
*object_class_by_name(const char *typename
)
923 TypeImpl
*type
= type_get_by_name(typename
);
929 type_initialize(type
);
934 ObjectClass
*object_class_get_parent(ObjectClass
*class)
936 TypeImpl
*type
= type_get_parent(class->type
);
942 type_initialize(type
);
947 typedef struct OCFData
949 void (*fn
)(ObjectClass
*klass
, void *opaque
);
950 const char *implements_type
;
951 bool include_abstract
;
955 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
958 OCFData
*data
= opaque
;
959 TypeImpl
*type
= value
;
962 type_initialize(type
);
965 if (!data
->include_abstract
&& type
->abstract
) {
969 if (data
->implements_type
&&
970 !object_class_dynamic_cast(k
, data
->implements_type
)) {
974 data
->fn(k
, data
->opaque
);
977 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
978 const char *implements_type
, bool include_abstract
,
981 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
983 enumerating_types
= true;
984 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
985 enumerating_types
= false;
988 static int do_object_child_foreach(Object
*obj
,
989 int (*fn
)(Object
*child
, void *opaque
),
990 void *opaque
, bool recurse
)
993 ObjectProperty
*prop
;
996 g_hash_table_iter_init(&iter
, obj
->properties
);
997 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
998 if (object_property_is_child(prop
)) {
999 Object
*child
= prop
->opaque
;
1001 ret
= fn(child
, opaque
);
1006 do_object_child_foreach(child
, fn
, opaque
, true);
1013 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
1016 return do_object_child_foreach(obj
, fn
, opaque
, false);
1019 int object_child_foreach_recursive(Object
*obj
,
1020 int (*fn
)(Object
*child
, void *opaque
),
1023 return do_object_child_foreach(obj
, fn
, opaque
, true);
1026 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
1028 GSList
**list
= opaque
;
1030 *list
= g_slist_prepend(*list
, klass
);
1033 GSList
*object_class_get_list(const char *implements_type
,
1034 bool include_abstract
)
1036 GSList
*list
= NULL
;
1038 object_class_foreach(object_class_get_list_tramp
,
1039 implements_type
, include_abstract
, &list
);
1043 static gint
object_class_cmp(gconstpointer a
, gconstpointer b
)
1045 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
1046 object_class_get_name((ObjectClass
*)b
));
1049 GSList
*object_class_get_list_sorted(const char *implements_type
,
1050 bool include_abstract
)
1052 return g_slist_sort(object_class_get_list(implements_type
, include_abstract
),
1056 void object_ref(Object
*obj
)
1061 atomic_inc(&obj
->ref
);
1064 void object_unref(Object
*obj
)
1069 g_assert(obj
->ref
> 0);
1071 /* parent always holds a reference to its children */
1072 if (atomic_fetch_dec(&obj
->ref
) == 1) {
1073 object_finalize(obj
);
1078 object_property_add(Object
*obj
, const char *name
, const char *type
,
1079 ObjectPropertyAccessor
*get
,
1080 ObjectPropertyAccessor
*set
,
1081 ObjectPropertyRelease
*release
,
1082 void *opaque
, Error
**errp
)
1084 ObjectProperty
*prop
;
1085 size_t name_len
= strlen(name
);
1087 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
1089 ObjectProperty
*ret
;
1090 char *name_no_array
= g_strdup(name
);
1092 name_no_array
[name_len
- 3] = '\0';
1093 for (i
= 0; ; ++i
) {
1094 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
1096 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
1097 release
, opaque
, NULL
);
1103 g_free(name_no_array
);
1107 if (object_property_find(obj
, name
, NULL
) != NULL
) {
1108 error_setg(errp
, "attempt to add duplicate property '%s'"
1109 " to object (type '%s')", name
,
1110 object_get_typename(obj
));
1114 prop
= g_malloc0(sizeof(*prop
));
1116 prop
->name
= g_strdup(name
);
1117 prop
->type
= g_strdup(type
);
1121 prop
->release
= release
;
1122 prop
->opaque
= opaque
;
1124 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
1129 object_class_property_add(ObjectClass
*klass
,
1132 ObjectPropertyAccessor
*get
,
1133 ObjectPropertyAccessor
*set
,
1134 ObjectPropertyRelease
*release
,
1138 ObjectProperty
*prop
;
1140 if (object_class_property_find(klass
, name
, NULL
) != NULL
) {
1141 error_setg(errp
, "attempt to add duplicate property '%s'"
1142 " to object (type '%s')", name
,
1143 object_class_get_name(klass
));
1147 prop
= g_malloc0(sizeof(*prop
));
1149 prop
->name
= g_strdup(name
);
1150 prop
->type
= g_strdup(type
);
1154 prop
->release
= release
;
1155 prop
->opaque
= opaque
;
1157 g_hash_table_insert(klass
->properties
, g_strdup(name
), prop
);
1162 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
1165 ObjectProperty
*prop
;
1166 ObjectClass
*klass
= object_get_class(obj
);
1168 prop
= object_class_property_find(klass
, name
, NULL
);
1173 prop
= g_hash_table_lookup(obj
->properties
, name
);
1178 error_setg(errp
, "Property '.%s' not found", name
);
1182 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1185 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1186 iter
->nextclass
= object_get_class(obj
);
1189 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1192 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1193 if (!iter
->nextclass
) {
1196 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1197 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1202 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1205 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1206 iter
->nextclass
= object_class_get_parent(klass
);
1209 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
,
1212 ObjectProperty
*prop
;
1213 ObjectClass
*parent_klass
;
1215 parent_klass
= object_class_get_parent(klass
);
1217 prop
= object_class_property_find(parent_klass
, name
, NULL
);
1223 prop
= g_hash_table_lookup(klass
->properties
, name
);
1225 error_setg(errp
, "Property '.%s' not found", name
);
1230 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
1232 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1235 error_setg(errp
, "Property '.%s' not found", name
);
1239 if (prop
->release
) {
1240 prop
->release(obj
, name
, prop
->opaque
);
1242 g_hash_table_remove(obj
->properties
, name
);
1245 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
1248 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1254 error_setg(errp
, QERR_PERMISSION_DENIED
);
1256 prop
->get(obj
, v
, name
, prop
->opaque
, errp
);
1260 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
1263 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1269 error_setg(errp
, QERR_PERMISSION_DENIED
);
1271 prop
->set(obj
, v
, name
, prop
->opaque
, errp
);
1275 void object_property_set_str(Object
*obj
, const char *value
,
1276 const char *name
, Error
**errp
)
1278 QString
*qstr
= qstring_from_str(value
);
1279 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
1281 qobject_unref(qstr
);
1284 char *object_property_get_str(Object
*obj
, const char *name
,
1287 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1294 retval
= g_strdup(qobject_get_try_str(ret
));
1296 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1303 void object_property_set_link(Object
*obj
, Object
*value
,
1304 const char *name
, Error
**errp
)
1307 gchar
*path
= object_get_canonical_path(value
);
1308 object_property_set_str(obj
, path
, name
, errp
);
1311 object_property_set_str(obj
, "", name
, errp
);
1315 Object
*object_property_get_link(Object
*obj
, const char *name
,
1318 char *str
= object_property_get_str(obj
, name
, errp
);
1319 Object
*target
= NULL
;
1322 target
= object_resolve_path(str
, NULL
);
1324 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1325 "Device '%s' not found", str
);
1333 void object_property_set_bool(Object
*obj
, bool value
,
1334 const char *name
, Error
**errp
)
1336 QBool
*qbool
= qbool_from_bool(value
);
1337 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
1339 qobject_unref(qbool
);
1342 bool object_property_get_bool(Object
*obj
, const char *name
,
1345 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1352 qbool
= qobject_to(QBool
, ret
);
1354 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1357 retval
= qbool_get_bool(qbool
);
1364 void object_property_set_int(Object
*obj
, int64_t value
,
1365 const char *name
, Error
**errp
)
1367 QNum
*qnum
= qnum_from_int(value
);
1368 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1370 qobject_unref(qnum
);
1373 int64_t object_property_get_int(Object
*obj
, const char *name
,
1376 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1384 qnum
= qobject_to(QNum
, ret
);
1385 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1386 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1394 void object_property_set_uint(Object
*obj
, uint64_t value
,
1395 const char *name
, Error
**errp
)
1397 QNum
*qnum
= qnum_from_uint(value
);
1399 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1400 qobject_unref(qnum
);
1403 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1406 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1413 qnum
= qobject_to(QNum
, ret
);
1414 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1415 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "uint");
1423 typedef struct EnumProperty
{
1424 const QEnumLookup
*lookup
;
1425 int (*get
)(Object
*, Error
**);
1426 void (*set
)(Object
*, int, Error
**);
1429 int object_property_get_enum(Object
*obj
, const char *name
,
1430 const char *typename
, Error
**errp
)
1436 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1437 EnumProperty
*enumprop
;
1443 if (!g_str_equal(prop
->type
, typename
)) {
1444 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1445 name
, object_class_get_name(
1446 object_get_class(obj
)), typename
);
1450 enumprop
= prop
->opaque
;
1452 v
= string_output_visitor_new(false, &str
);
1453 object_property_get(obj
, v
, name
, &err
);
1455 error_propagate(errp
, err
);
1459 visit_complete(v
, &str
);
1461 v
= string_input_visitor_new(str
);
1462 visit_type_enum(v
, name
, &ret
, enumprop
->lookup
, errp
);
1470 void object_property_get_uint16List(Object
*obj
, const char *name
,
1471 uint16List
**list
, Error
**errp
)
1477 v
= string_output_visitor_new(false, &str
);
1478 object_property_get(obj
, v
, name
, &err
);
1480 error_propagate(errp
, err
);
1483 visit_complete(v
, &str
);
1485 v
= string_input_visitor_new(str
);
1486 visit_type_uint16List(v
, NULL
, list
, errp
);
1493 void object_property_parse(Object
*obj
, const char *string
,
1494 const char *name
, Error
**errp
)
1496 Visitor
*v
= string_input_visitor_new(string
);
1497 object_property_set(obj
, v
, name
, errp
);
1501 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1505 char *string
= NULL
;
1506 Error
*local_err
= NULL
;
1508 v
= string_output_visitor_new(human
, &string
);
1509 object_property_get(obj
, v
, name
, &local_err
);
1511 error_propagate(errp
, local_err
);
1515 visit_complete(v
, &string
);
1522 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1524 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1532 Object
*object_get_root(void)
1534 static Object
*root
;
1537 root
= object_new("container");
1543 Object
*object_get_objects_root(void)
1545 return container_get(object_get_root(), "/objects");
1548 Object
*object_get_internal_root(void)
1550 static Object
*internal_root
;
1552 if (!internal_root
) {
1553 internal_root
= object_new("container");
1556 return internal_root
;
1559 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1560 const char *name
, void *opaque
,
1563 Object
*child
= opaque
;
1566 path
= object_get_canonical_path(child
);
1567 visit_type_str(v
, name
, &path
, errp
);
1571 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1576 static void object_finalize_child_property(Object
*obj
, const char *name
,
1579 Object
*child
= opaque
;
1581 if (child
->class->unparent
) {
1582 (child
->class->unparent
)(child
);
1584 child
->parent
= NULL
;
1585 object_unref(child
);
1588 void object_property_add_child(Object
*obj
, const char *name
,
1589 Object
*child
, Error
**errp
)
1591 Error
*local_err
= NULL
;
1595 if (child
->parent
!= NULL
) {
1596 error_setg(errp
, "child object is already parented");
1600 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1602 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1603 object_finalize_child_property
, child
, &local_err
);
1605 error_propagate(errp
, local_err
);
1609 op
->resolve
= object_resolve_child_property
;
1611 child
->parent
= obj
;
1617 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1618 Object
*val
, Error
**errp
)
1620 /* Allow the link to be set, always */
1625 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1626 ObjectPropertyLinkFlags flags
;
1629 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1630 const char *name
, void *opaque
,
1633 LinkProperty
*lprop
= opaque
;
1634 Object
**child
= lprop
->child
;
1638 path
= object_get_canonical_path(*child
);
1639 visit_type_str(v
, name
, &path
, errp
);
1643 visit_type_str(v
, name
, &path
, errp
);
1648 * object_resolve_link:
1650 * Lookup an object and ensure its type matches the link property type. This
1651 * is similar to object_resolve_path() except type verification against the
1652 * link property is performed.
1654 * Returns: The matched object or NULL on path lookup failures.
1656 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1657 const char *path
, Error
**errp
)
1661 bool ambiguous
= false;
1664 /* Go from link<FOO> to FOO. */
1665 type
= object_property_get_type(obj
, name
, NULL
);
1666 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1667 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1670 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1672 } else if (!target
) {
1673 target
= object_resolve_path(path
, &ambiguous
);
1674 if (target
|| ambiguous
) {
1675 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1677 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1678 "Device '%s' not found", path
);
1682 g_free(target_type
);
1687 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1688 const char *name
, void *opaque
,
1691 Error
*local_err
= NULL
;
1692 LinkProperty
*prop
= opaque
;
1693 Object
**child
= prop
->child
;
1694 Object
*old_target
= *child
;
1695 Object
*new_target
= NULL
;
1698 visit_type_str(v
, name
, &path
, &local_err
);
1700 if (!local_err
&& strcmp(path
, "") != 0) {
1701 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1706 error_propagate(errp
, local_err
);
1710 prop
->check(obj
, name
, new_target
, &local_err
);
1712 error_propagate(errp
, local_err
);
1716 *child
= new_target
;
1717 if (prop
->flags
== OBJ_PROP_LINK_STRONG
) {
1718 object_ref(new_target
);
1719 object_unref(old_target
);
1723 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1725 LinkProperty
*lprop
= opaque
;
1727 return *lprop
->child
;
1730 static void object_release_link_property(Object
*obj
, const char *name
,
1733 LinkProperty
*prop
= opaque
;
1735 if ((prop
->flags
& OBJ_PROP_LINK_STRONG
) && *prop
->child
) {
1736 object_unref(*prop
->child
);
1741 void object_property_add_link(Object
*obj
, const char *name
,
1742 const char *type
, Object
**child
,
1743 void (*check
)(const Object
*, const char *,
1744 Object
*, Error
**),
1745 ObjectPropertyLinkFlags flags
,
1748 Error
*local_err
= NULL
;
1749 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1753 prop
->child
= child
;
1754 prop
->check
= check
;
1755 prop
->flags
= flags
;
1757 full_type
= g_strdup_printf("link<%s>", type
);
1759 op
= object_property_add(obj
, name
, full_type
,
1760 object_get_link_property
,
1761 check
? object_set_link_property
: NULL
,
1762 object_release_link_property
,
1766 error_propagate(errp
, local_err
);
1771 op
->resolve
= object_resolve_link_property
;
1777 void object_property_add_const_link(Object
*obj
, const char *name
,
1778 Object
*target
, Error
**errp
)
1783 link_type
= g_strdup_printf("link<%s>", object_get_typename(target
));
1784 op
= object_property_add(obj
, name
, link_type
,
1785 object_get_child_property
, NULL
,
1786 NULL
, target
, errp
);
1788 op
->resolve
= object_resolve_child_property
;
1793 gchar
*object_get_canonical_path_component(Object
*obj
)
1795 ObjectProperty
*prop
= NULL
;
1796 GHashTableIter iter
;
1798 if (obj
->parent
== NULL
) {
1802 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
1803 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1804 if (!object_property_is_child(prop
)) {
1808 if (prop
->opaque
== obj
) {
1809 return g_strdup(prop
->name
);
1813 /* obj had a parent but was not a child, should never happen */
1814 g_assert_not_reached();
1818 gchar
*object_get_canonical_path(Object
*obj
)
1820 Object
*root
= object_get_root();
1821 char *newpath
, *path
= NULL
;
1824 return g_strdup("/");
1828 char *component
= object_get_canonical_path_component(obj
);
1831 /* A canonical path must be complete, so discard what was
1838 newpath
= g_strdup_printf("/%s%s", component
, path
? path
: "");
1843 } while (obj
!= root
);
1848 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
1850 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
1855 if (prop
->resolve
) {
1856 return prop
->resolve(parent
, prop
->opaque
, part
);
1862 static Object
*object_resolve_abs_path(Object
*parent
,
1864 const char *typename
,
1869 if (parts
[index
] == NULL
) {
1870 return object_dynamic_cast(parent
, typename
);
1873 if (strcmp(parts
[index
], "") == 0) {
1874 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
1877 child
= object_resolve_path_component(parent
, parts
[index
]);
1882 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
1885 static Object
*object_resolve_partial_path(Object
*parent
,
1887 const char *typename
,
1891 GHashTableIter iter
;
1892 ObjectProperty
*prop
;
1894 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
1896 g_hash_table_iter_init(&iter
, parent
->properties
);
1897 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1900 if (!object_property_is_child(prop
)) {
1904 found
= object_resolve_partial_path(prop
->opaque
, parts
,
1905 typename
, ambiguous
);
1922 Object
*object_resolve_path_type(const char *path
, const char *typename
,
1928 parts
= g_strsplit(path
, "/", 0);
1931 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
1932 bool ambiguous
= false;
1933 obj
= object_resolve_partial_path(object_get_root(), parts
,
1934 typename
, &ambiguous
);
1936 *ambiguousp
= ambiguous
;
1939 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
1947 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
1949 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
1952 typedef struct StringProperty
1954 char *(*get
)(Object
*, Error
**);
1955 void (*set
)(Object
*, const char *, Error
**);
1958 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
1959 void *opaque
, Error
**errp
)
1961 StringProperty
*prop
= opaque
;
1965 value
= prop
->get(obj
, &err
);
1967 error_propagate(errp
, err
);
1971 visit_type_str(v
, name
, &value
, errp
);
1975 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
1976 void *opaque
, Error
**errp
)
1978 StringProperty
*prop
= opaque
;
1980 Error
*local_err
= NULL
;
1982 visit_type_str(v
, name
, &value
, &local_err
);
1984 error_propagate(errp
, local_err
);
1988 prop
->set(obj
, value
, errp
);
1992 static void property_release_str(Object
*obj
, const char *name
,
1995 StringProperty
*prop
= opaque
;
1999 void object_property_add_str(Object
*obj
, const char *name
,
2000 char *(*get
)(Object
*, Error
**),
2001 void (*set
)(Object
*, const char *, Error
**),
2004 Error
*local_err
= NULL
;
2005 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2010 object_property_add(obj
, name
, "string",
2011 get
? property_get_str
: NULL
,
2012 set
? property_set_str
: NULL
,
2013 property_release_str
,
2016 error_propagate(errp
, local_err
);
2021 void object_class_property_add_str(ObjectClass
*klass
, const char *name
,
2022 char *(*get
)(Object
*, Error
**),
2023 void (*set
)(Object
*, const char *,
2027 Error
*local_err
= NULL
;
2028 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2033 object_class_property_add(klass
, name
, "string",
2034 get
? property_get_str
: NULL
,
2035 set
? property_set_str
: NULL
,
2036 property_release_str
,
2039 error_propagate(errp
, local_err
);
2044 typedef struct BoolProperty
2046 bool (*get
)(Object
*, Error
**);
2047 void (*set
)(Object
*, bool, Error
**);
2050 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
2051 void *opaque
, Error
**errp
)
2053 BoolProperty
*prop
= opaque
;
2057 value
= prop
->get(obj
, &err
);
2059 error_propagate(errp
, err
);
2063 visit_type_bool(v
, name
, &value
, errp
);
2066 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
2067 void *opaque
, Error
**errp
)
2069 BoolProperty
*prop
= opaque
;
2071 Error
*local_err
= NULL
;
2073 visit_type_bool(v
, name
, &value
, &local_err
);
2075 error_propagate(errp
, local_err
);
2079 prop
->set(obj
, value
, errp
);
2082 static void property_release_bool(Object
*obj
, const char *name
,
2085 BoolProperty
*prop
= opaque
;
2089 void object_property_add_bool(Object
*obj
, const char *name
,
2090 bool (*get
)(Object
*, Error
**),
2091 void (*set
)(Object
*, bool, Error
**),
2094 Error
*local_err
= NULL
;
2095 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2100 object_property_add(obj
, name
, "bool",
2101 get
? property_get_bool
: NULL
,
2102 set
? property_set_bool
: NULL
,
2103 property_release_bool
,
2106 error_propagate(errp
, local_err
);
2111 void object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
2112 bool (*get
)(Object
*, Error
**),
2113 void (*set
)(Object
*, bool, Error
**),
2116 Error
*local_err
= NULL
;
2117 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2122 object_class_property_add(klass
, name
, "bool",
2123 get
? property_get_bool
: NULL
,
2124 set
? property_set_bool
: NULL
,
2125 property_release_bool
,
2128 error_propagate(errp
, local_err
);
2133 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
2134 void *opaque
, Error
**errp
)
2136 EnumProperty
*prop
= opaque
;
2140 value
= prop
->get(obj
, &err
);
2142 error_propagate(errp
, err
);
2146 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
2149 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
2150 void *opaque
, Error
**errp
)
2152 EnumProperty
*prop
= opaque
;
2156 visit_type_enum(v
, name
, &value
, prop
->lookup
, &err
);
2158 error_propagate(errp
, err
);
2161 prop
->set(obj
, value
, errp
);
2164 static void property_release_enum(Object
*obj
, const char *name
,
2167 EnumProperty
*prop
= opaque
;
2171 void object_property_add_enum(Object
*obj
, const char *name
,
2172 const char *typename
,
2173 const QEnumLookup
*lookup
,
2174 int (*get
)(Object
*, Error
**),
2175 void (*set
)(Object
*, int, Error
**),
2178 Error
*local_err
= NULL
;
2179 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2181 prop
->lookup
= lookup
;
2185 object_property_add(obj
, name
, typename
,
2186 get
? property_get_enum
: NULL
,
2187 set
? property_set_enum
: NULL
,
2188 property_release_enum
,
2191 error_propagate(errp
, local_err
);
2196 void object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2197 const char *typename
,
2198 const QEnumLookup
*lookup
,
2199 int (*get
)(Object
*, Error
**),
2200 void (*set
)(Object
*, int, Error
**),
2203 Error
*local_err
= NULL
;
2204 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2206 prop
->lookup
= lookup
;
2210 object_class_property_add(klass
, name
, typename
,
2211 get
? property_get_enum
: NULL
,
2212 set
? property_set_enum
: NULL
,
2213 property_release_enum
,
2216 error_propagate(errp
, local_err
);
2221 typedef struct TMProperty
{
2222 void (*get
)(Object
*, struct tm
*, Error
**);
2225 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2226 void *opaque
, Error
**errp
)
2228 TMProperty
*prop
= opaque
;
2232 prop
->get(obj
, &value
, &err
);
2237 visit_start_struct(v
, name
, NULL
, 0, &err
);
2241 visit_type_int32(v
, "tm_year", &value
.tm_year
, &err
);
2245 visit_type_int32(v
, "tm_mon", &value
.tm_mon
, &err
);
2249 visit_type_int32(v
, "tm_mday", &value
.tm_mday
, &err
);
2253 visit_type_int32(v
, "tm_hour", &value
.tm_hour
, &err
);
2257 visit_type_int32(v
, "tm_min", &value
.tm_min
, &err
);
2261 visit_type_int32(v
, "tm_sec", &value
.tm_sec
, &err
);
2265 visit_check_struct(v
, &err
);
2267 visit_end_struct(v
, NULL
);
2269 error_propagate(errp
, err
);
2273 static void property_release_tm(Object
*obj
, const char *name
,
2276 TMProperty
*prop
= opaque
;
2280 void object_property_add_tm(Object
*obj
, const char *name
,
2281 void (*get
)(Object
*, struct tm
*, Error
**),
2284 Error
*local_err
= NULL
;
2285 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2289 object_property_add(obj
, name
, "struct tm",
2290 get
? property_get_tm
: NULL
, NULL
,
2291 property_release_tm
,
2294 error_propagate(errp
, local_err
);
2299 void object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2300 void (*get
)(Object
*, struct tm
*, Error
**),
2303 Error
*local_err
= NULL
;
2304 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2308 object_class_property_add(klass
, name
, "struct tm",
2309 get
? property_get_tm
: NULL
, NULL
,
2310 property_release_tm
,
2313 error_propagate(errp
, local_err
);
2318 static char *qdev_get_type(Object
*obj
, Error
**errp
)
2320 return g_strdup(object_get_typename(obj
));
2323 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2324 void *opaque
, Error
**errp
)
2326 uint8_t value
= *(uint8_t *)opaque
;
2327 visit_type_uint8(v
, name
, &value
, errp
);
2330 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2331 void *opaque
, Error
**errp
)
2333 uint16_t value
= *(uint16_t *)opaque
;
2334 visit_type_uint16(v
, name
, &value
, errp
);
2337 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2338 void *opaque
, Error
**errp
)
2340 uint32_t value
= *(uint32_t *)opaque
;
2341 visit_type_uint32(v
, name
, &value
, errp
);
2344 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2345 void *opaque
, Error
**errp
)
2347 uint64_t value
= *(uint64_t *)opaque
;
2348 visit_type_uint64(v
, name
, &value
, errp
);
2351 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2352 const uint8_t *v
, Error
**errp
)
2354 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
2355 NULL
, NULL
, (void *)v
, errp
);
2358 void object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2359 const uint8_t *v
, Error
**errp
)
2361 object_class_property_add(klass
, name
, "uint8", property_get_uint8_ptr
,
2362 NULL
, NULL
, (void *)v
, errp
);
2365 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2366 const uint16_t *v
, Error
**errp
)
2368 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
2369 NULL
, NULL
, (void *)v
, errp
);
2372 void object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2373 const uint16_t *v
, Error
**errp
)
2375 object_class_property_add(klass
, name
, "uint16", property_get_uint16_ptr
,
2376 NULL
, NULL
, (void *)v
, errp
);
2379 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2380 const uint32_t *v
, Error
**errp
)
2382 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
2383 NULL
, NULL
, (void *)v
, errp
);
2386 void object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2387 const uint32_t *v
, Error
**errp
)
2389 object_class_property_add(klass
, name
, "uint32", property_get_uint32_ptr
,
2390 NULL
, NULL
, (void *)v
, errp
);
2393 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2394 const uint64_t *v
, Error
**errp
)
2396 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
2397 NULL
, NULL
, (void *)v
, errp
);
2400 void object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2401 const uint64_t *v
, Error
**errp
)
2403 object_class_property_add(klass
, name
, "uint64", property_get_uint64_ptr
,
2404 NULL
, NULL
, (void *)v
, errp
);
2412 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2413 void *opaque
, Error
**errp
)
2415 AliasProperty
*prop
= opaque
;
2417 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
2420 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2421 void *opaque
, Error
**errp
)
2423 AliasProperty
*prop
= opaque
;
2425 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
2428 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2431 AliasProperty
*prop
= opaque
;
2433 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2436 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2438 AliasProperty
*prop
= opaque
;
2440 g_free(prop
->target_name
);
2444 void object_property_add_alias(Object
*obj
, const char *name
,
2445 Object
*target_obj
, const char *target_name
,
2448 AliasProperty
*prop
;
2450 ObjectProperty
*target_prop
;
2452 Error
*local_err
= NULL
;
2454 target_prop
= object_property_find(target_obj
, target_name
, errp
);
2459 if (object_property_is_child(target_prop
)) {
2460 prop_type
= g_strdup_printf("link%s",
2461 target_prop
->type
+ strlen("child"));
2463 prop_type
= g_strdup(target_prop
->type
);
2466 prop
= g_malloc(sizeof(*prop
));
2467 prop
->target_obj
= target_obj
;
2468 prop
->target_name
= g_strdup(target_name
);
2470 op
= object_property_add(obj
, name
, prop_type
,
2473 property_release_alias
,
2476 error_propagate(errp
, local_err
);
2480 op
->resolve
= property_resolve_alias
;
2482 object_property_set_description(obj
, op
->name
,
2483 target_prop
->description
,
2490 void object_property_set_description(Object
*obj
, const char *name
,
2491 const char *description
, Error
**errp
)
2495 op
= object_property_find(obj
, name
, errp
);
2500 g_free(op
->description
);
2501 op
->description
= g_strdup(description
);
2504 void object_class_property_set_description(ObjectClass
*klass
,
2506 const char *description
,
2511 op
= g_hash_table_lookup(klass
->properties
, name
);
2513 error_setg(errp
, "Property '.%s' not found", name
);
2517 g_free(op
->description
);
2518 op
->description
= g_strdup(description
);
2521 static void object_class_init(ObjectClass
*klass
, void *data
)
2523 object_class_property_add_str(klass
, "type", qdev_get_type
,
2524 NULL
, &error_abort
);
2527 static void register_types(void)
2529 static TypeInfo interface_info
= {
2530 .name
= TYPE_INTERFACE
,
2531 .class_size
= sizeof(InterfaceClass
),
2535 static TypeInfo object_info
= {
2536 .name
= TYPE_OBJECT
,
2537 .instance_size
= sizeof(Object
),
2538 .class_init
= object_class_init
,
2542 type_interface
= type_register_internal(&interface_info
);
2543 type_register_internal(&object_info
);
2546 type_init(register_types
)