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 "hw/qdev-core.h"
15 #include "qapi/error.h"
16 #include "qom/object.h"
17 #include "qom/object_interfaces.h"
18 #include "qemu/cutils.h"
19 #include "qapi/visitor.h"
20 #include "qapi/string-input-visitor.h"
21 #include "qapi/string-output-visitor.h"
22 #include "qapi/qobject-input-visitor.h"
23 #include "qapi/qapi-builtin-visit.h"
24 #include "qapi/qmp/qerror.h"
25 #include "qapi/qmp/qjson.h"
28 /* TODO: replace QObject with a simpler visitor to avoid a dependency
29 * of the QOM core on QObject? */
30 #include "qom/qom-qobject.h"
31 #include "qapi/qmp/qbool.h"
32 #include "qapi/qmp/qnum.h"
33 #include "qapi/qmp/qstring.h"
34 #include "qemu/error-report.h"
36 #define MAX_INTERFACES 32
38 typedef struct InterfaceImpl InterfaceImpl
;
39 typedef struct TypeImpl TypeImpl
;
54 void (*class_init
)(ObjectClass
*klass
, void *data
);
55 void (*class_base_init
)(ObjectClass
*klass
, void *data
);
59 void (*instance_init
)(Object
*obj
);
60 void (*instance_post_init
)(Object
*obj
);
61 void (*instance_finalize
)(Object
*obj
);
66 TypeImpl
*parent_type
;
71 InterfaceImpl interfaces
[MAX_INTERFACES
];
74 static Type type_interface
;
76 static GHashTable
*type_table_get(void)
78 static GHashTable
*type_table
;
80 if (type_table
== NULL
) {
81 type_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
87 static bool enumerating_types
;
89 static void type_table_add(TypeImpl
*ti
)
91 assert(!enumerating_types
);
92 g_hash_table_insert(type_table_get(), (void *)ti
->name
, ti
);
95 static TypeImpl
*type_table_lookup(const char *name
)
97 return g_hash_table_lookup(type_table_get(), name
);
100 static TypeImpl
*type_new(const TypeInfo
*info
)
102 TypeImpl
*ti
= g_malloc0(sizeof(*ti
));
105 g_assert(info
->name
!= NULL
);
107 if (type_table_lookup(info
->name
) != NULL
) {
108 fprintf(stderr
, "Registering `%s' which already exists\n", info
->name
);
112 ti
->name
= g_strdup(info
->name
);
113 ti
->parent
= g_strdup(info
->parent
);
115 ti
->class_size
= info
->class_size
;
116 ti
->instance_size
= info
->instance_size
;
118 ti
->class_init
= info
->class_init
;
119 ti
->class_base_init
= info
->class_base_init
;
120 ti
->class_data
= info
->class_data
;
122 ti
->instance_init
= info
->instance_init
;
123 ti
->instance_post_init
= info
->instance_post_init
;
124 ti
->instance_finalize
= info
->instance_finalize
;
126 ti
->abstract
= info
->abstract
;
128 for (i
= 0; info
->interfaces
&& info
->interfaces
[i
].type
; i
++) {
129 ti
->interfaces
[i
].typename
= g_strdup(info
->interfaces
[i
].type
);
131 ti
->num_interfaces
= i
;
136 static TypeImpl
*type_register_internal(const TypeInfo
*info
)
145 TypeImpl
*type_register(const TypeInfo
*info
)
147 assert(info
->parent
);
148 return type_register_internal(info
);
151 TypeImpl
*type_register_static(const TypeInfo
*info
)
153 return type_register(info
);
156 void type_register_static_array(const TypeInfo
*infos
, int nr_infos
)
160 for (i
= 0; i
< nr_infos
; i
++) {
161 type_register_static(&infos
[i
]);
165 static TypeImpl
*type_get_by_name(const char *name
)
171 return type_table_lookup(name
);
174 static TypeImpl
*type_get_parent(TypeImpl
*type
)
176 if (!type
->parent_type
&& type
->parent
) {
177 type
->parent_type
= type_get_by_name(type
->parent
);
178 if (!type
->parent_type
) {
179 fprintf(stderr
, "Type '%s' is missing its parent '%s'\n",
180 type
->name
, type
->parent
);
185 return type
->parent_type
;
188 static bool type_has_parent(TypeImpl
*type
)
190 return (type
->parent
!= NULL
);
193 static size_t type_class_get_size(TypeImpl
*ti
)
195 if (ti
->class_size
) {
196 return ti
->class_size
;
199 if (type_has_parent(ti
)) {
200 return type_class_get_size(type_get_parent(ti
));
203 return sizeof(ObjectClass
);
206 static size_t type_object_get_size(TypeImpl
*ti
)
208 if (ti
->instance_size
) {
209 return ti
->instance_size
;
212 if (type_has_parent(ti
)) {
213 return type_object_get_size(type_get_parent(ti
));
219 size_t object_type_get_instance_size(const char *typename
)
221 TypeImpl
*type
= type_get_by_name(typename
);
223 g_assert(type
!= NULL
);
224 return type_object_get_size(type
);
227 static bool type_is_ancestor(TypeImpl
*type
, TypeImpl
*target_type
)
231 /* Check if target_type is a direct ancestor of type */
233 if (type
== target_type
) {
237 type
= type_get_parent(type
);
243 static void type_initialize(TypeImpl
*ti
);
245 static void type_initialize_interface(TypeImpl
*ti
, TypeImpl
*interface_type
,
246 TypeImpl
*parent_type
)
248 InterfaceClass
*new_iface
;
250 TypeImpl
*iface_impl
;
252 info
.parent
= parent_type
->name
;
253 info
.name
= g_strdup_printf("%s::%s", ti
->name
, interface_type
->name
);
254 info
.abstract
= true;
256 iface_impl
= type_new(&info
);
257 iface_impl
->parent_type
= parent_type
;
258 type_initialize(iface_impl
);
259 g_free((char *)info
.name
);
261 new_iface
= (InterfaceClass
*)iface_impl
->class;
262 new_iface
->concrete_class
= ti
->class;
263 new_iface
->interface_type
= interface_type
;
265 ti
->class->interfaces
= g_slist_append(ti
->class->interfaces
,
269 static void object_property_free(gpointer data
)
271 ObjectProperty
*prop
= data
;
274 qobject_unref(prop
->defval
);
279 g_free(prop
->description
);
283 static void type_initialize(TypeImpl
*ti
)
291 ti
->class_size
= type_class_get_size(ti
);
292 ti
->instance_size
= type_object_get_size(ti
);
293 /* Any type with zero instance_size is implicitly abstract.
294 * This means interface types are all abstract.
296 if (ti
->instance_size
== 0) {
299 if (type_is_ancestor(ti
, type_interface
)) {
300 assert(ti
->instance_size
== 0);
301 assert(ti
->abstract
);
302 assert(!ti
->instance_init
);
303 assert(!ti
->instance_post_init
);
304 assert(!ti
->instance_finalize
);
305 assert(!ti
->num_interfaces
);
307 ti
->class = g_malloc0(ti
->class_size
);
309 parent
= type_get_parent(ti
);
311 type_initialize(parent
);
315 g_assert(parent
->class_size
<= ti
->class_size
);
316 g_assert(parent
->instance_size
<= ti
->instance_size
);
317 memcpy(ti
->class, parent
->class, parent
->class_size
);
318 ti
->class->interfaces
= NULL
;
319 ti
->class->properties
= g_hash_table_new_full(
320 g_str_hash
, g_str_equal
, NULL
, object_property_free
);
322 for (e
= parent
->class->interfaces
; e
; e
= e
->next
) {
323 InterfaceClass
*iface
= e
->data
;
324 ObjectClass
*klass
= OBJECT_CLASS(iface
);
326 type_initialize_interface(ti
, iface
->interface_type
, klass
->type
);
329 for (i
= 0; i
< ti
->num_interfaces
; i
++) {
330 TypeImpl
*t
= type_get_by_name(ti
->interfaces
[i
].typename
);
332 error_report("missing interface '%s' for object '%s'",
333 ti
->interfaces
[i
].typename
, parent
->name
);
336 for (e
= ti
->class->interfaces
; e
; e
= e
->next
) {
337 TypeImpl
*target_type
= OBJECT_CLASS(e
->data
)->type
;
339 if (type_is_ancestor(target_type
, t
)) {
348 type_initialize_interface(ti
, t
, t
);
351 ti
->class->properties
= g_hash_table_new_full(
352 g_str_hash
, g_str_equal
, NULL
, object_property_free
);
355 ti
->class->type
= ti
;
358 if (parent
->class_base_init
) {
359 parent
->class_base_init(ti
->class, ti
->class_data
);
361 parent
= type_get_parent(parent
);
364 if (ti
->class_init
) {
365 ti
->class_init(ti
->class, ti
->class_data
);
369 static void object_init_with_type(Object
*obj
, TypeImpl
*ti
)
371 if (type_has_parent(ti
)) {
372 object_init_with_type(obj
, type_get_parent(ti
));
375 if (ti
->instance_init
) {
376 ti
->instance_init(obj
);
380 static void object_post_init_with_type(Object
*obj
, TypeImpl
*ti
)
382 if (ti
->instance_post_init
) {
383 ti
->instance_post_init(obj
);
386 if (type_has_parent(ti
)) {
387 object_post_init_with_type(obj
, type_get_parent(ti
));
391 void object_apply_global_props(Object
*obj
, const GPtrArray
*props
, Error
**errp
)
399 for (i
= 0; i
< props
->len
; i
++) {
400 GlobalProperty
*p
= g_ptr_array_index(props
, i
);
403 if (object_dynamic_cast(obj
, p
->driver
) == NULL
) {
406 if (p
->optional
&& !object_property_find(obj
, p
->property
, NULL
)) {
410 object_property_parse(obj
, p
->value
, p
->property
, &err
);
412 error_prepend(&err
, "can't apply global %s.%s=%s: ",
413 p
->driver
, p
->property
, p
->value
);
415 * If errp != NULL, propagate error and return.
416 * If errp == NULL, report a warning, but keep going
417 * with the remaining globals.
420 error_propagate(errp
, err
);
423 warn_report_err(err
);
430 * Global property defaults
431 * Slot 0: accelerator's global property defaults
432 * Slot 1: machine's global property defaults
433 * Slot 2: global properties from legacy command line option
434 * Each is a GPtrArray of of GlobalProperty.
435 * Applied in order, later entries override earlier ones.
437 static GPtrArray
*object_compat_props
[3];
440 * Retrieve @GPtrArray for global property defined with options
441 * other than "-global". These are generally used for syntactic
442 * sugar and legacy command line options.
444 void object_register_sugar_prop(const char *driver
, const char *prop
, const char *value
)
447 if (!object_compat_props
[2]) {
448 object_compat_props
[2] = g_ptr_array_new();
450 g
= g_new0(GlobalProperty
, 1);
451 g
->driver
= g_strdup(driver
);
452 g
->property
= g_strdup(prop
);
453 g
->value
= g_strdup(value
);
454 g_ptr_array_add(object_compat_props
[2], g
);
458 * Set machine's global property defaults to @compat_props.
459 * May be called at most once.
461 void object_set_machine_compat_props(GPtrArray
*compat_props
)
463 assert(!object_compat_props
[1]);
464 object_compat_props
[1] = compat_props
;
468 * Set accelerator's global property defaults to @compat_props.
469 * May be called at most once.
471 void object_set_accelerator_compat_props(GPtrArray
*compat_props
)
473 assert(!object_compat_props
[0]);
474 object_compat_props
[0] = compat_props
;
477 void object_apply_compat_props(Object
*obj
)
481 for (i
= 0; i
< ARRAY_SIZE(object_compat_props
); i
++) {
482 object_apply_global_props(obj
, object_compat_props
[i
],
483 i
== 2 ? &error_fatal
: &error_abort
);
487 static void object_class_property_init_all(Object
*obj
)
489 ObjectPropertyIterator iter
;
490 ObjectProperty
*prop
;
492 object_class_property_iter_init(&iter
, object_get_class(obj
));
493 while ((prop
= object_property_iter_next(&iter
))) {
495 prop
->init(obj
, prop
);
500 static void object_initialize_with_type(void *data
, size_t size
, TypeImpl
*type
)
504 type_initialize(type
);
506 g_assert(type
->instance_size
>= sizeof(Object
));
507 g_assert(type
->abstract
== false);
508 g_assert(size
>= type
->instance_size
);
510 memset(obj
, 0, type
->instance_size
);
511 obj
->class = type
->class;
513 object_class_property_init_all(obj
);
514 obj
->properties
= g_hash_table_new_full(g_str_hash
, g_str_equal
,
515 NULL
, object_property_free
);
516 object_init_with_type(obj
, type
);
517 object_post_init_with_type(obj
, type
);
520 void object_initialize(void *data
, size_t size
, const char *typename
)
522 TypeImpl
*type
= type_get_by_name(typename
);
525 error_report("missing object type '%s'", typename
);
529 object_initialize_with_type(data
, size
, type
);
532 void object_initialize_child(Object
*parentobj
, const char *propname
,
533 void *childobj
, size_t size
, const char *type
,
538 va_start(vargs
, errp
);
539 object_initialize_childv(parentobj
, propname
, childobj
, size
, type
, errp
,
544 void object_initialize_childv(Object
*parentobj
, const char *propname
,
545 void *childobj
, size_t size
, const char *type
,
546 Error
**errp
, va_list vargs
)
548 Error
*local_err
= NULL
;
552 object_initialize(childobj
, size
, type
);
553 obj
= OBJECT(childobj
);
555 object_set_propv(obj
, &local_err
, vargs
);
560 object_property_add_child(parentobj
, propname
, obj
, &local_err
);
565 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
567 user_creatable_complete(uc
, &local_err
);
569 object_unparent(obj
);
575 * Since object_property_add_child added a reference to the child object,
576 * we can drop the reference added by object_initialize(), so the child
577 * property will own the only reference to the object.
583 error_propagate(errp
, local_err
);
588 static inline bool object_property_is_child(ObjectProperty
*prop
)
590 return strstart(prop
->type
, "child<", NULL
);
593 static void object_property_del_all(Object
*obj
)
595 g_autoptr(GHashTable
) done
= g_hash_table_new(NULL
, NULL
);
596 ObjectProperty
*prop
;
597 ObjectPropertyIterator iter
;
602 object_property_iter_init(&iter
, obj
);
603 while ((prop
= object_property_iter_next(&iter
)) != NULL
) {
604 if (g_hash_table_add(done
, prop
)) {
606 prop
->release(obj
, prop
->name
, prop
->opaque
);
614 g_hash_table_unref(obj
->properties
);
617 static void object_property_del_child(Object
*obj
, Object
*child
, Error
**errp
)
619 ObjectProperty
*prop
;
623 g_hash_table_iter_init(&iter
, obj
->properties
);
624 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
626 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
628 prop
->release(obj
, prop
->name
, prop
->opaque
);
629 prop
->release
= NULL
;
634 g_hash_table_iter_init(&iter
, obj
->properties
);
635 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
637 if (object_property_is_child(prop
) && prop
->opaque
== child
) {
638 g_hash_table_iter_remove(&iter
);
644 void object_unparent(Object
*obj
)
647 object_property_del_child(obj
->parent
, obj
, NULL
);
651 static void object_deinit(Object
*obj
, TypeImpl
*type
)
653 if (type
->instance_finalize
) {
654 type
->instance_finalize(obj
);
657 if (type_has_parent(type
)) {
658 object_deinit(obj
, type_get_parent(type
));
662 static void object_finalize(void *data
)
665 TypeImpl
*ti
= obj
->class->type
;
667 object_property_del_all(obj
);
668 object_deinit(obj
, ti
);
670 g_assert(obj
->ref
== 0);
676 static Object
*object_new_with_type(Type type
)
680 g_assert(type
!= NULL
);
681 type_initialize(type
);
683 obj
= g_malloc(type
->instance_size
);
684 object_initialize_with_type(obj
, type
->instance_size
, type
);
690 Object
*object_new_with_class(ObjectClass
*klass
)
692 return object_new_with_type(klass
->type
);
695 Object
*object_new(const char *typename
)
697 TypeImpl
*ti
= type_get_by_name(typename
);
699 return object_new_with_type(ti
);
703 Object
*object_new_with_props(const char *typename
,
712 va_start(vargs
, errp
);
713 obj
= object_new_with_propv(typename
, parent
, id
, errp
, vargs
);
720 Object
*object_new_with_propv(const char *typename
,
728 Error
*local_err
= NULL
;
731 klass
= object_class_by_name(typename
);
733 error_setg(errp
, "invalid object type: %s", typename
);
737 if (object_class_is_abstract(klass
)) {
738 error_setg(errp
, "object type '%s' is abstract", typename
);
741 obj
= object_new_with_type(klass
->type
);
743 if (object_set_propv(obj
, &local_err
, vargs
) < 0) {
748 object_property_add_child(parent
, id
, obj
, &local_err
);
754 uc
= (UserCreatable
*)object_dynamic_cast(obj
, TYPE_USER_CREATABLE
);
756 user_creatable_complete(uc
, &local_err
);
759 object_unparent(obj
);
765 object_unref(OBJECT(obj
));
769 error_propagate(errp
, local_err
);
775 int object_set_props(Object
*obj
,
782 va_start(vargs
, errp
);
783 ret
= object_set_propv(obj
, errp
, vargs
);
790 int object_set_propv(Object
*obj
,
794 const char *propname
;
795 Error
*local_err
= NULL
;
797 propname
= va_arg(vargs
, char *);
798 while (propname
!= NULL
) {
799 const char *value
= va_arg(vargs
, char *);
801 g_assert(value
!= NULL
);
802 object_property_parse(obj
, value
, propname
, &local_err
);
804 error_propagate(errp
, local_err
);
807 propname
= va_arg(vargs
, char *);
814 Object
*object_dynamic_cast(Object
*obj
, const char *typename
)
816 if (obj
&& object_class_dynamic_cast(object_get_class(obj
), typename
)) {
823 Object
*object_dynamic_cast_assert(Object
*obj
, const char *typename
,
824 const char *file
, int line
, const char *func
)
826 trace_object_dynamic_cast_assert(obj
? obj
->class->type
->name
: "(null)",
827 typename
, file
, line
, func
);
829 #ifdef CONFIG_QOM_CAST_DEBUG
833 for (i
= 0; obj
&& i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
834 if (atomic_read(&obj
->class->object_cast_cache
[i
]) == typename
) {
839 inst
= object_dynamic_cast(obj
, typename
);
842 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
843 file
, line
, func
, obj
, typename
);
849 if (obj
&& obj
== inst
) {
850 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
851 atomic_set(&obj
->class->object_cast_cache
[i
- 1],
852 atomic_read(&obj
->class->object_cast_cache
[i
]));
854 atomic_set(&obj
->class->object_cast_cache
[i
- 1], typename
);
862 ObjectClass
*object_class_dynamic_cast(ObjectClass
*class,
863 const char *typename
)
865 ObjectClass
*ret
= NULL
;
866 TypeImpl
*target_type
;
873 /* A simple fast path that can trigger a lot for leaf classes. */
875 if (type
->name
== typename
) {
879 target_type
= type_get_by_name(typename
);
881 /* target class type unknown, so fail the cast */
885 if (type
->class->interfaces
&&
886 type_is_ancestor(target_type
, type_interface
)) {
890 for (i
= class->interfaces
; i
; i
= i
->next
) {
891 ObjectClass
*target_class
= i
->data
;
893 if (type_is_ancestor(target_class
->type
, target_type
)) {
899 /* The match was ambiguous, don't allow a cast */
903 } else if (type_is_ancestor(type
, target_type
)) {
910 ObjectClass
*object_class_dynamic_cast_assert(ObjectClass
*class,
911 const char *typename
,
912 const char *file
, int line
,
917 trace_object_class_dynamic_cast_assert(class ? class->type
->name
: "(null)",
918 typename
, file
, line
, func
);
920 #ifdef CONFIG_QOM_CAST_DEBUG
923 for (i
= 0; class && i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
924 if (atomic_read(&class->class_cast_cache
[i
]) == typename
) {
930 if (!class || !class->interfaces
) {
935 ret
= object_class_dynamic_cast(class, typename
);
937 fprintf(stderr
, "%s:%d:%s: Object %p is not an instance of type %s\n",
938 file
, line
, func
, class, typename
);
942 #ifdef CONFIG_QOM_CAST_DEBUG
943 if (class && ret
== class) {
944 for (i
= 1; i
< OBJECT_CLASS_CAST_CACHE
; i
++) {
945 atomic_set(&class->class_cast_cache
[i
- 1],
946 atomic_read(&class->class_cast_cache
[i
]));
948 atomic_set(&class->class_cast_cache
[i
- 1], typename
);
955 const char *object_get_typename(const Object
*obj
)
957 return obj
->class->type
->name
;
960 ObjectClass
*object_get_class(Object
*obj
)
965 bool object_class_is_abstract(ObjectClass
*klass
)
967 return klass
->type
->abstract
;
970 const char *object_class_get_name(ObjectClass
*klass
)
972 return klass
->type
->name
;
975 ObjectClass
*object_class_by_name(const char *typename
)
977 TypeImpl
*type
= type_get_by_name(typename
);
983 type_initialize(type
);
988 ObjectClass
*object_class_get_parent(ObjectClass
*class)
990 TypeImpl
*type
= type_get_parent(class->type
);
996 type_initialize(type
);
1001 typedef struct OCFData
1003 void (*fn
)(ObjectClass
*klass
, void *opaque
);
1004 const char *implements_type
;
1005 bool include_abstract
;
1009 static void object_class_foreach_tramp(gpointer key
, gpointer value
,
1012 OCFData
*data
= opaque
;
1013 TypeImpl
*type
= value
;
1016 type_initialize(type
);
1019 if (!data
->include_abstract
&& type
->abstract
) {
1023 if (data
->implements_type
&&
1024 !object_class_dynamic_cast(k
, data
->implements_type
)) {
1028 data
->fn(k
, data
->opaque
);
1031 void object_class_foreach(void (*fn
)(ObjectClass
*klass
, void *opaque
),
1032 const char *implements_type
, bool include_abstract
,
1035 OCFData data
= { fn
, implements_type
, include_abstract
, opaque
};
1037 enumerating_types
= true;
1038 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp
, &data
);
1039 enumerating_types
= false;
1042 static int do_object_child_foreach(Object
*obj
,
1043 int (*fn
)(Object
*child
, void *opaque
),
1044 void *opaque
, bool recurse
)
1046 GHashTableIter iter
;
1047 ObjectProperty
*prop
;
1050 g_hash_table_iter_init(&iter
, obj
->properties
);
1051 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1052 if (object_property_is_child(prop
)) {
1053 Object
*child
= prop
->opaque
;
1055 ret
= fn(child
, opaque
);
1060 do_object_child_foreach(child
, fn
, opaque
, true);
1067 int object_child_foreach(Object
*obj
, int (*fn
)(Object
*child
, void *opaque
),
1070 return do_object_child_foreach(obj
, fn
, opaque
, false);
1073 int object_child_foreach_recursive(Object
*obj
,
1074 int (*fn
)(Object
*child
, void *opaque
),
1077 return do_object_child_foreach(obj
, fn
, opaque
, true);
1080 static void object_class_get_list_tramp(ObjectClass
*klass
, void *opaque
)
1082 GSList
**list
= opaque
;
1084 *list
= g_slist_prepend(*list
, klass
);
1087 GSList
*object_class_get_list(const char *implements_type
,
1088 bool include_abstract
)
1090 GSList
*list
= NULL
;
1092 object_class_foreach(object_class_get_list_tramp
,
1093 implements_type
, include_abstract
, &list
);
1097 static gint
object_class_cmp(gconstpointer a
, gconstpointer b
)
1099 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
1100 object_class_get_name((ObjectClass
*)b
));
1103 GSList
*object_class_get_list_sorted(const char *implements_type
,
1104 bool include_abstract
)
1106 return g_slist_sort(object_class_get_list(implements_type
, include_abstract
),
1110 void object_ref(Object
*obj
)
1115 atomic_inc(&obj
->ref
);
1118 void object_unref(Object
*obj
)
1123 g_assert(obj
->ref
> 0);
1125 /* parent always holds a reference to its children */
1126 if (atomic_fetch_dec(&obj
->ref
) == 1) {
1127 object_finalize(obj
);
1132 object_property_add(Object
*obj
, const char *name
, const char *type
,
1133 ObjectPropertyAccessor
*get
,
1134 ObjectPropertyAccessor
*set
,
1135 ObjectPropertyRelease
*release
,
1136 void *opaque
, Error
**errp
)
1138 ObjectProperty
*prop
;
1139 size_t name_len
= strlen(name
);
1141 if (name_len
>= 3 && !memcmp(name
+ name_len
- 3, "[*]", 4)) {
1143 ObjectProperty
*ret
;
1144 char *name_no_array
= g_strdup(name
);
1146 name_no_array
[name_len
- 3] = '\0';
1147 for (i
= 0; ; ++i
) {
1148 char *full_name
= g_strdup_printf("%s[%d]", name_no_array
, i
);
1150 ret
= object_property_add(obj
, full_name
, type
, get
, set
,
1151 release
, opaque
, NULL
);
1157 g_free(name_no_array
);
1161 if (object_property_find(obj
, name
, NULL
) != NULL
) {
1162 error_setg(errp
, "attempt to add duplicate property '%s' to object (type '%s')",
1163 name
, object_get_typename(obj
));
1167 prop
= g_malloc0(sizeof(*prop
));
1169 prop
->name
= g_strdup(name
);
1170 prop
->type
= g_strdup(type
);
1174 prop
->release
= release
;
1175 prop
->opaque
= opaque
;
1177 g_hash_table_insert(obj
->properties
, prop
->name
, prop
);
1182 object_class_property_add(ObjectClass
*klass
,
1185 ObjectPropertyAccessor
*get
,
1186 ObjectPropertyAccessor
*set
,
1187 ObjectPropertyRelease
*release
,
1191 ObjectProperty
*prop
;
1193 if (object_class_property_find(klass
, name
, NULL
) != NULL
) {
1194 error_setg(errp
, "attempt to add duplicate property '%s' to class (type '%s')",
1195 name
, object_class_get_name(klass
));
1199 prop
= g_malloc0(sizeof(*prop
));
1201 prop
->name
= g_strdup(name
);
1202 prop
->type
= g_strdup(type
);
1206 prop
->release
= release
;
1207 prop
->opaque
= opaque
;
1209 g_hash_table_insert(klass
->properties
, prop
->name
, prop
);
1214 ObjectProperty
*object_property_find(Object
*obj
, const char *name
,
1217 ObjectProperty
*prop
;
1218 ObjectClass
*klass
= object_get_class(obj
);
1220 prop
= object_class_property_find(klass
, name
, NULL
);
1225 prop
= g_hash_table_lookup(obj
->properties
, name
);
1230 error_setg(errp
, "Property '.%s' not found", name
);
1234 void object_property_iter_init(ObjectPropertyIterator
*iter
,
1237 g_hash_table_iter_init(&iter
->iter
, obj
->properties
);
1238 iter
->nextclass
= object_get_class(obj
);
1241 ObjectProperty
*object_property_iter_next(ObjectPropertyIterator
*iter
)
1244 while (!g_hash_table_iter_next(&iter
->iter
, &key
, &val
)) {
1245 if (!iter
->nextclass
) {
1248 g_hash_table_iter_init(&iter
->iter
, iter
->nextclass
->properties
);
1249 iter
->nextclass
= object_class_get_parent(iter
->nextclass
);
1254 void object_class_property_iter_init(ObjectPropertyIterator
*iter
,
1257 g_hash_table_iter_init(&iter
->iter
, klass
->properties
);
1258 iter
->nextclass
= object_class_get_parent(klass
);
1261 ObjectProperty
*object_class_property_find(ObjectClass
*klass
, const char *name
,
1264 ObjectProperty
*prop
;
1265 ObjectClass
*parent_klass
;
1267 parent_klass
= object_class_get_parent(klass
);
1269 prop
= object_class_property_find(parent_klass
, name
, NULL
);
1275 prop
= g_hash_table_lookup(klass
->properties
, name
);
1277 error_setg(errp
, "Property '.%s' not found", name
);
1282 void object_property_del(Object
*obj
, const char *name
, Error
**errp
)
1284 ObjectProperty
*prop
= g_hash_table_lookup(obj
->properties
, name
);
1287 error_setg(errp
, "Property '.%s' not found", name
);
1291 if (prop
->release
) {
1292 prop
->release(obj
, name
, prop
->opaque
);
1294 g_hash_table_remove(obj
->properties
, name
);
1297 void object_property_get(Object
*obj
, Visitor
*v
, const char *name
,
1300 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1306 error_setg(errp
, QERR_PERMISSION_DENIED
);
1308 prop
->get(obj
, v
, name
, prop
->opaque
, errp
);
1312 void object_property_set(Object
*obj
, Visitor
*v
, const char *name
,
1315 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1321 error_setg(errp
, QERR_PERMISSION_DENIED
);
1323 prop
->set(obj
, v
, name
, prop
->opaque
, errp
);
1327 void object_property_set_str(Object
*obj
, const char *value
,
1328 const char *name
, Error
**errp
)
1330 QString
*qstr
= qstring_from_str(value
);
1331 object_property_set_qobject(obj
, QOBJECT(qstr
), name
, errp
);
1333 qobject_unref(qstr
);
1336 char *object_property_get_str(Object
*obj
, const char *name
,
1339 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1346 retval
= g_strdup(qobject_get_try_str(ret
));
1348 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "string");
1355 void object_property_set_link(Object
*obj
, Object
*value
,
1356 const char *name
, Error
**errp
)
1359 gchar
*path
= object_get_canonical_path(value
);
1360 object_property_set_str(obj
, path
, name
, errp
);
1363 object_property_set_str(obj
, "", name
, errp
);
1367 Object
*object_property_get_link(Object
*obj
, const char *name
,
1370 char *str
= object_property_get_str(obj
, name
, errp
);
1371 Object
*target
= NULL
;
1374 target
= object_resolve_path(str
, NULL
);
1376 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1377 "Device '%s' not found", str
);
1385 void object_property_set_bool(Object
*obj
, bool value
,
1386 const char *name
, Error
**errp
)
1388 QBool
*qbool
= qbool_from_bool(value
);
1389 object_property_set_qobject(obj
, QOBJECT(qbool
), name
, errp
);
1391 qobject_unref(qbool
);
1394 bool object_property_get_bool(Object
*obj
, const char *name
,
1397 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1404 qbool
= qobject_to(QBool
, ret
);
1406 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "boolean");
1409 retval
= qbool_get_bool(qbool
);
1416 void object_property_set_int(Object
*obj
, int64_t value
,
1417 const char *name
, Error
**errp
)
1419 QNum
*qnum
= qnum_from_int(value
);
1420 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1422 qobject_unref(qnum
);
1425 int64_t object_property_get_int(Object
*obj
, const char *name
,
1428 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1436 qnum
= qobject_to(QNum
, ret
);
1437 if (!qnum
|| !qnum_get_try_int(qnum
, &retval
)) {
1438 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "int");
1446 static void object_property_init_defval(Object
*obj
, ObjectProperty
*prop
)
1448 Visitor
*v
= qobject_input_visitor_new(prop
->defval
);
1450 assert(prop
->set
!= NULL
);
1451 prop
->set(obj
, v
, prop
->name
, prop
->opaque
, &error_abort
);
1456 static void object_property_set_default(ObjectProperty
*prop
, QObject
*defval
)
1458 assert(!prop
->defval
);
1459 assert(!prop
->init
);
1461 prop
->defval
= defval
;
1462 prop
->init
= object_property_init_defval
;
1465 void object_property_set_default_bool(ObjectProperty
*prop
, bool value
)
1467 object_property_set_default(prop
, QOBJECT(qbool_from_bool(value
)));
1470 void object_property_set_default_str(ObjectProperty
*prop
, const char *value
)
1472 object_property_set_default(prop
, QOBJECT(qstring_from_str(value
)));
1475 void object_property_set_default_int(ObjectProperty
*prop
, int64_t value
)
1477 object_property_set_default(prop
, QOBJECT(qnum_from_int(value
)));
1480 void object_property_set_default_uint(ObjectProperty
*prop
, uint64_t value
)
1482 object_property_set_default(prop
, QOBJECT(qnum_from_uint(value
)));
1485 void object_property_set_uint(Object
*obj
, uint64_t value
,
1486 const char *name
, Error
**errp
)
1488 QNum
*qnum
= qnum_from_uint(value
);
1490 object_property_set_qobject(obj
, QOBJECT(qnum
), name
, errp
);
1491 qobject_unref(qnum
);
1494 uint64_t object_property_get_uint(Object
*obj
, const char *name
,
1497 QObject
*ret
= object_property_get_qobject(obj
, name
, errp
);
1504 qnum
= qobject_to(QNum
, ret
);
1505 if (!qnum
|| !qnum_get_try_uint(qnum
, &retval
)) {
1506 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, "uint");
1514 typedef struct EnumProperty
{
1515 const QEnumLookup
*lookup
;
1516 int (*get
)(Object
*, Error
**);
1517 void (*set
)(Object
*, int, Error
**);
1520 int object_property_get_enum(Object
*obj
, const char *name
,
1521 const char *typename
, Error
**errp
)
1527 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1528 EnumProperty
*enumprop
;
1534 if (!g_str_equal(prop
->type
, typename
)) {
1535 error_setg(errp
, "Property %s on %s is not '%s' enum type",
1536 name
, object_class_get_name(
1537 object_get_class(obj
)), typename
);
1541 enumprop
= prop
->opaque
;
1543 v
= string_output_visitor_new(false, &str
);
1544 object_property_get(obj
, v
, name
, &err
);
1546 error_propagate(errp
, err
);
1550 visit_complete(v
, &str
);
1552 v
= string_input_visitor_new(str
);
1553 visit_type_enum(v
, name
, &ret
, enumprop
->lookup
, errp
);
1561 void object_property_get_uint16List(Object
*obj
, const char *name
,
1562 uint16List
**list
, Error
**errp
)
1568 v
= string_output_visitor_new(false, &str
);
1569 object_property_get(obj
, v
, name
, &err
);
1571 error_propagate(errp
, err
);
1574 visit_complete(v
, &str
);
1576 v
= string_input_visitor_new(str
);
1577 visit_type_uint16List(v
, NULL
, list
, errp
);
1584 void object_property_parse(Object
*obj
, const char *string
,
1585 const char *name
, Error
**errp
)
1587 Visitor
*v
= string_input_visitor_new(string
);
1588 object_property_set(obj
, v
, name
, errp
);
1592 char *object_property_print(Object
*obj
, const char *name
, bool human
,
1596 char *string
= NULL
;
1597 Error
*local_err
= NULL
;
1599 v
= string_output_visitor_new(human
, &string
);
1600 object_property_get(obj
, v
, name
, &local_err
);
1602 error_propagate(errp
, local_err
);
1606 visit_complete(v
, &string
);
1613 const char *object_property_get_type(Object
*obj
, const char *name
, Error
**errp
)
1615 ObjectProperty
*prop
= object_property_find(obj
, name
, errp
);
1623 Object
*object_get_root(void)
1625 static Object
*root
;
1628 root
= object_new("container");
1634 Object
*object_get_objects_root(void)
1636 return container_get(object_get_root(), "/objects");
1639 Object
*object_get_internal_root(void)
1641 static Object
*internal_root
;
1643 if (!internal_root
) {
1644 internal_root
= object_new("container");
1647 return internal_root
;
1650 static void object_get_child_property(Object
*obj
, Visitor
*v
,
1651 const char *name
, void *opaque
,
1654 Object
*child
= opaque
;
1657 path
= object_get_canonical_path(child
);
1658 visit_type_str(v
, name
, &path
, errp
);
1662 static Object
*object_resolve_child_property(Object
*parent
, void *opaque
, const gchar
*part
)
1667 static void object_finalize_child_property(Object
*obj
, const char *name
,
1670 Object
*child
= opaque
;
1672 if (child
->class->unparent
) {
1673 (child
->class->unparent
)(child
);
1675 child
->parent
= NULL
;
1676 object_unref(child
);
1679 void object_property_add_child(Object
*obj
, const char *name
,
1680 Object
*child
, Error
**errp
)
1682 Error
*local_err
= NULL
;
1686 if (child
->parent
!= NULL
) {
1687 error_setg(errp
, "child object is already parented");
1691 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1693 op
= object_property_add(obj
, name
, type
, object_get_child_property
, NULL
,
1694 object_finalize_child_property
, child
, &local_err
);
1696 error_propagate(errp
, local_err
);
1700 op
->resolve
= object_resolve_child_property
;
1702 child
->parent
= obj
;
1708 void object_property_allow_set_link(const Object
*obj
, const char *name
,
1709 Object
*val
, Error
**errp
)
1711 /* Allow the link to be set, always */
1717 Object
*target
; /* if OBJ_PROP_LINK_DIRECT, when holding the pointer */
1718 ptrdiff_t offset
; /* if OBJ_PROP_LINK_CLASS */
1720 void (*check
)(const Object
*, const char *, Object
*, Error
**);
1721 ObjectPropertyLinkFlags flags
;
1725 object_link_get_targetp(Object
*obj
, LinkProperty
*lprop
)
1727 if (lprop
->flags
& OBJ_PROP_LINK_DIRECT
) {
1728 return &lprop
->target
;
1729 } else if (lprop
->flags
& OBJ_PROP_LINK_CLASS
) {
1730 return (void *)obj
+ lprop
->offset
;
1732 return lprop
->targetp
;
1736 static void object_get_link_property(Object
*obj
, Visitor
*v
,
1737 const char *name
, void *opaque
,
1740 LinkProperty
*lprop
= opaque
;
1741 Object
**targetp
= object_link_get_targetp(obj
, lprop
);
1745 path
= object_get_canonical_path(*targetp
);
1746 visit_type_str(v
, name
, &path
, errp
);
1750 visit_type_str(v
, name
, &path
, errp
);
1755 * object_resolve_link:
1757 * Lookup an object and ensure its type matches the link property type. This
1758 * is similar to object_resolve_path() except type verification against the
1759 * link property is performed.
1761 * Returns: The matched object or NULL on path lookup failures.
1763 static Object
*object_resolve_link(Object
*obj
, const char *name
,
1764 const char *path
, Error
**errp
)
1768 bool ambiguous
= false;
1771 /* Go from link<FOO> to FOO. */
1772 type
= object_property_get_type(obj
, name
, NULL
);
1773 target_type
= g_strndup(&type
[5], strlen(type
) - 6);
1774 target
= object_resolve_path_type(path
, target_type
, &ambiguous
);
1777 error_setg(errp
, "Path '%s' does not uniquely identify an object",
1779 } else if (!target
) {
1780 target
= object_resolve_path(path
, &ambiguous
);
1781 if (target
|| ambiguous
) {
1782 error_setg(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, target_type
);
1784 error_set(errp
, ERROR_CLASS_DEVICE_NOT_FOUND
,
1785 "Device '%s' not found", path
);
1789 g_free(target_type
);
1794 static void object_set_link_property(Object
*obj
, Visitor
*v
,
1795 const char *name
, void *opaque
,
1798 Error
*local_err
= NULL
;
1799 LinkProperty
*prop
= opaque
;
1800 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1801 Object
*old_target
= *targetp
;
1802 Object
*new_target
= NULL
;
1805 visit_type_str(v
, name
, &path
, &local_err
);
1807 if (!local_err
&& strcmp(path
, "") != 0) {
1808 new_target
= object_resolve_link(obj
, name
, path
, &local_err
);
1813 error_propagate(errp
, local_err
);
1817 prop
->check(obj
, name
, new_target
, &local_err
);
1819 error_propagate(errp
, local_err
);
1823 *targetp
= new_target
;
1824 if (prop
->flags
& OBJ_PROP_LINK_STRONG
) {
1825 object_ref(new_target
);
1826 object_unref(old_target
);
1830 static Object
*object_resolve_link_property(Object
*parent
, void *opaque
, const gchar
*part
)
1832 LinkProperty
*lprop
= opaque
;
1834 return *object_link_get_targetp(parent
, lprop
);
1837 static void object_release_link_property(Object
*obj
, const char *name
,
1840 LinkProperty
*prop
= opaque
;
1841 Object
**targetp
= object_link_get_targetp(obj
, prop
);
1843 if ((prop
->flags
& OBJ_PROP_LINK_STRONG
) && *targetp
) {
1844 object_unref(*targetp
);
1846 if (!(prop
->flags
& OBJ_PROP_LINK_CLASS
)) {
1851 static void object_add_link_prop(Object
*obj
, const char *name
,
1852 const char *type
, void *ptr
,
1853 void (*check
)(const Object
*, const char *,
1854 Object
*, Error
**),
1855 ObjectPropertyLinkFlags flags
,
1858 Error
*local_err
= NULL
;
1859 LinkProperty
*prop
= g_malloc(sizeof(*prop
));
1863 if (flags
& OBJ_PROP_LINK_DIRECT
) {
1866 prop
->targetp
= ptr
;
1868 prop
->check
= check
;
1869 prop
->flags
= flags
;
1871 full_type
= g_strdup_printf("link<%s>", type
);
1873 op
= object_property_add(obj
, name
, full_type
,
1874 object_get_link_property
,
1875 check
? object_set_link_property
: NULL
,
1876 object_release_link_property
,
1880 error_propagate(errp
, local_err
);
1885 op
->resolve
= object_resolve_link_property
;
1891 void object_property_add_link(Object
*obj
, const char *name
,
1892 const char *type
, Object
**targetp
,
1893 void (*check
)(const Object
*, const char *,
1894 Object
*, Error
**),
1895 ObjectPropertyLinkFlags flags
,
1898 object_add_link_prop(obj
, name
, type
, targetp
, check
, flags
, errp
);
1902 object_class_property_add_link(ObjectClass
*oc
,
1904 const char *type
, ptrdiff_t offset
,
1905 void (*check
)(const Object
*obj
, const char *name
,
1906 Object
*val
, Error
**errp
),
1907 ObjectPropertyLinkFlags flags
,
1910 Error
*local_err
= NULL
;
1911 LinkProperty
*prop
= g_new0(LinkProperty
, 1);
1915 prop
->offset
= offset
;
1916 prop
->check
= check
;
1917 prop
->flags
= flags
| OBJ_PROP_LINK_CLASS
;
1919 full_type
= g_strdup_printf("link<%s>", type
);
1921 op
= object_class_property_add(oc
, name
, full_type
,
1922 object_get_link_property
,
1923 check
? object_set_link_property
: NULL
,
1924 object_release_link_property
,
1928 error_propagate(errp
, local_err
);
1933 op
->resolve
= object_resolve_link_property
;
1940 void object_property_add_const_link(Object
*obj
, const char *name
,
1941 Object
*target
, Error
**errp
)
1943 object_add_link_prop(obj
, name
, object_get_typename(target
), target
,
1944 NULL
, OBJ_PROP_LINK_DIRECT
, errp
);
1947 gchar
*object_get_canonical_path_component(Object
*obj
)
1949 ObjectProperty
*prop
= NULL
;
1950 GHashTableIter iter
;
1952 if (obj
->parent
== NULL
) {
1956 g_hash_table_iter_init(&iter
, obj
->parent
->properties
);
1957 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
1958 if (!object_property_is_child(prop
)) {
1962 if (prop
->opaque
== obj
) {
1963 return g_strdup(prop
->name
);
1967 /* obj had a parent but was not a child, should never happen */
1968 g_assert_not_reached();
1972 gchar
*object_get_canonical_path(Object
*obj
)
1974 Object
*root
= object_get_root();
1975 char *newpath
, *path
= NULL
;
1978 return g_strdup("/");
1982 char *component
= object_get_canonical_path_component(obj
);
1985 /* A canonical path must be complete, so discard what was
1992 newpath
= g_strdup_printf("/%s%s", component
, path
? path
: "");
1997 } while (obj
!= root
);
2002 Object
*object_resolve_path_component(Object
*parent
, const gchar
*part
)
2004 ObjectProperty
*prop
= object_property_find(parent
, part
, NULL
);
2009 if (prop
->resolve
) {
2010 return prop
->resolve(parent
, prop
->opaque
, part
);
2016 static Object
*object_resolve_abs_path(Object
*parent
,
2018 const char *typename
,
2023 if (parts
[index
] == NULL
) {
2024 return object_dynamic_cast(parent
, typename
);
2027 if (strcmp(parts
[index
], "") == 0) {
2028 return object_resolve_abs_path(parent
, parts
, typename
, index
+ 1);
2031 child
= object_resolve_path_component(parent
, parts
[index
]);
2036 return object_resolve_abs_path(child
, parts
, typename
, index
+ 1);
2039 static Object
*object_resolve_partial_path(Object
*parent
,
2041 const char *typename
,
2045 GHashTableIter iter
;
2046 ObjectProperty
*prop
;
2048 obj
= object_resolve_abs_path(parent
, parts
, typename
, 0);
2050 g_hash_table_iter_init(&iter
, parent
->properties
);
2051 while (g_hash_table_iter_next(&iter
, NULL
, (gpointer
*)&prop
)) {
2054 if (!object_property_is_child(prop
)) {
2058 found
= object_resolve_partial_path(prop
->opaque
, parts
,
2059 typename
, ambiguous
);
2076 Object
*object_resolve_path_type(const char *path
, const char *typename
,
2082 parts
= g_strsplit(path
, "/", 0);
2085 if (parts
[0] == NULL
|| strcmp(parts
[0], "") != 0) {
2086 bool ambiguous
= false;
2087 obj
= object_resolve_partial_path(object_get_root(), parts
,
2088 typename
, &ambiguous
);
2090 *ambiguousp
= ambiguous
;
2093 obj
= object_resolve_abs_path(object_get_root(), parts
, typename
, 1);
2101 Object
*object_resolve_path(const char *path
, bool *ambiguous
)
2103 return object_resolve_path_type(path
, TYPE_OBJECT
, ambiguous
);
2106 typedef struct StringProperty
2108 char *(*get
)(Object
*, Error
**);
2109 void (*set
)(Object
*, const char *, Error
**);
2112 static void property_get_str(Object
*obj
, Visitor
*v
, const char *name
,
2113 void *opaque
, Error
**errp
)
2115 StringProperty
*prop
= opaque
;
2119 value
= prop
->get(obj
, &err
);
2121 error_propagate(errp
, err
);
2125 visit_type_str(v
, name
, &value
, errp
);
2129 static void property_set_str(Object
*obj
, Visitor
*v
, const char *name
,
2130 void *opaque
, Error
**errp
)
2132 StringProperty
*prop
= opaque
;
2134 Error
*local_err
= NULL
;
2136 visit_type_str(v
, name
, &value
, &local_err
);
2138 error_propagate(errp
, local_err
);
2142 prop
->set(obj
, value
, errp
);
2146 static void property_release_str(Object
*obj
, const char *name
,
2149 StringProperty
*prop
= opaque
;
2153 void object_property_add_str(Object
*obj
, const char *name
,
2154 char *(*get
)(Object
*, Error
**),
2155 void (*set
)(Object
*, const char *, Error
**),
2158 Error
*local_err
= NULL
;
2159 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2164 object_property_add(obj
, name
, "string",
2165 get
? property_get_str
: NULL
,
2166 set
? property_set_str
: NULL
,
2167 property_release_str
,
2170 error_propagate(errp
, local_err
);
2176 object_class_property_add_str(ObjectClass
*klass
, const char *name
,
2177 char *(*get
)(Object
*, Error
**),
2178 void (*set
)(Object
*, const char *,
2182 Error
*local_err
= NULL
;
2183 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
2189 rv
= object_class_property_add(klass
, name
, "string",
2190 get
? property_get_str
: NULL
,
2191 set
? property_set_str
: NULL
,
2195 error_propagate(errp
, local_err
);
2202 typedef struct BoolProperty
2204 bool (*get
)(Object
*, Error
**);
2205 void (*set
)(Object
*, bool, Error
**);
2208 static void property_get_bool(Object
*obj
, Visitor
*v
, const char *name
,
2209 void *opaque
, Error
**errp
)
2211 BoolProperty
*prop
= opaque
;
2215 value
= prop
->get(obj
, &err
);
2217 error_propagate(errp
, err
);
2221 visit_type_bool(v
, name
, &value
, errp
);
2224 static void property_set_bool(Object
*obj
, Visitor
*v
, const char *name
,
2225 void *opaque
, Error
**errp
)
2227 BoolProperty
*prop
= opaque
;
2229 Error
*local_err
= NULL
;
2231 visit_type_bool(v
, name
, &value
, &local_err
);
2233 error_propagate(errp
, local_err
);
2237 prop
->set(obj
, value
, errp
);
2240 static void property_release_bool(Object
*obj
, const char *name
,
2243 BoolProperty
*prop
= opaque
;
2247 void object_property_add_bool(Object
*obj
, const char *name
,
2248 bool (*get
)(Object
*, Error
**),
2249 void (*set
)(Object
*, bool, Error
**),
2252 Error
*local_err
= NULL
;
2253 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2258 object_property_add(obj
, name
, "bool",
2259 get
? property_get_bool
: NULL
,
2260 set
? property_set_bool
: NULL
,
2261 property_release_bool
,
2264 error_propagate(errp
, local_err
);
2270 object_class_property_add_bool(ObjectClass
*klass
, const char *name
,
2271 bool (*get
)(Object
*, Error
**),
2272 void (*set
)(Object
*, bool, Error
**),
2275 Error
*local_err
= NULL
;
2276 BoolProperty
*prop
= g_malloc0(sizeof(*prop
));
2282 rv
= object_class_property_add(klass
, name
, "bool",
2283 get
? property_get_bool
: NULL
,
2284 set
? property_set_bool
: NULL
,
2288 error_propagate(errp
, local_err
);
2295 static void property_get_enum(Object
*obj
, Visitor
*v
, const char *name
,
2296 void *opaque
, Error
**errp
)
2298 EnumProperty
*prop
= opaque
;
2302 value
= prop
->get(obj
, &err
);
2304 error_propagate(errp
, err
);
2308 visit_type_enum(v
, name
, &value
, prop
->lookup
, errp
);
2311 static void property_set_enum(Object
*obj
, Visitor
*v
, const char *name
,
2312 void *opaque
, Error
**errp
)
2314 EnumProperty
*prop
= opaque
;
2318 visit_type_enum(v
, name
, &value
, prop
->lookup
, &err
);
2320 error_propagate(errp
, err
);
2323 prop
->set(obj
, value
, errp
);
2326 static void property_release_enum(Object
*obj
, const char *name
,
2329 EnumProperty
*prop
= opaque
;
2333 void object_property_add_enum(Object
*obj
, const char *name
,
2334 const char *typename
,
2335 const QEnumLookup
*lookup
,
2336 int (*get
)(Object
*, Error
**),
2337 void (*set
)(Object
*, int, Error
**),
2340 Error
*local_err
= NULL
;
2341 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2343 prop
->lookup
= lookup
;
2347 object_property_add(obj
, name
, typename
,
2348 get
? property_get_enum
: NULL
,
2349 set
? property_set_enum
: NULL
,
2350 property_release_enum
,
2353 error_propagate(errp
, local_err
);
2359 object_class_property_add_enum(ObjectClass
*klass
, const char *name
,
2360 const char *typename
,
2361 const QEnumLookup
*lookup
,
2362 int (*get
)(Object
*, Error
**),
2363 void (*set
)(Object
*, int, Error
**),
2366 Error
*local_err
= NULL
;
2367 EnumProperty
*prop
= g_malloc(sizeof(*prop
));
2370 prop
->lookup
= lookup
;
2374 rv
= object_class_property_add(klass
, name
, typename
,
2375 get
? property_get_enum
: NULL
,
2376 set
? property_set_enum
: NULL
,
2380 error_propagate(errp
, local_err
);
2387 typedef struct TMProperty
{
2388 void (*get
)(Object
*, struct tm
*, Error
**);
2391 static void property_get_tm(Object
*obj
, Visitor
*v
, const char *name
,
2392 void *opaque
, Error
**errp
)
2394 TMProperty
*prop
= opaque
;
2398 prop
->get(obj
, &value
, &err
);
2403 visit_start_struct(v
, name
, NULL
, 0, &err
);
2407 visit_type_int32(v
, "tm_year", &value
.tm_year
, &err
);
2411 visit_type_int32(v
, "tm_mon", &value
.tm_mon
, &err
);
2415 visit_type_int32(v
, "tm_mday", &value
.tm_mday
, &err
);
2419 visit_type_int32(v
, "tm_hour", &value
.tm_hour
, &err
);
2423 visit_type_int32(v
, "tm_min", &value
.tm_min
, &err
);
2427 visit_type_int32(v
, "tm_sec", &value
.tm_sec
, &err
);
2431 visit_check_struct(v
, &err
);
2433 visit_end_struct(v
, NULL
);
2435 error_propagate(errp
, err
);
2439 static void property_release_tm(Object
*obj
, const char *name
,
2442 TMProperty
*prop
= opaque
;
2446 void object_property_add_tm(Object
*obj
, const char *name
,
2447 void (*get
)(Object
*, struct tm
*, Error
**),
2450 Error
*local_err
= NULL
;
2451 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2455 object_property_add(obj
, name
, "struct tm",
2456 get
? property_get_tm
: NULL
, NULL
,
2457 property_release_tm
,
2460 error_propagate(errp
, local_err
);
2466 object_class_property_add_tm(ObjectClass
*klass
, const char *name
,
2467 void (*get
)(Object
*, struct tm
*, Error
**),
2470 Error
*local_err
= NULL
;
2471 TMProperty
*prop
= g_malloc0(sizeof(*prop
));
2476 rv
= object_class_property_add(klass
, name
, "struct tm",
2477 get
? property_get_tm
: NULL
, NULL
,
2481 error_propagate(errp
, local_err
);
2488 static char *qdev_get_type(Object
*obj
, Error
**errp
)
2490 return g_strdup(object_get_typename(obj
));
2493 static void property_get_uint8_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2494 void *opaque
, Error
**errp
)
2496 uint8_t value
= *(uint8_t *)opaque
;
2497 visit_type_uint8(v
, name
, &value
, errp
);
2500 static void property_get_uint16_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2501 void *opaque
, Error
**errp
)
2503 uint16_t value
= *(uint16_t *)opaque
;
2504 visit_type_uint16(v
, name
, &value
, errp
);
2507 static void property_get_uint32_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2508 void *opaque
, Error
**errp
)
2510 uint32_t value
= *(uint32_t *)opaque
;
2511 visit_type_uint32(v
, name
, &value
, errp
);
2514 static void property_get_uint64_ptr(Object
*obj
, Visitor
*v
, const char *name
,
2515 void *opaque
, Error
**errp
)
2517 uint64_t value
= *(uint64_t *)opaque
;
2518 visit_type_uint64(v
, name
, &value
, errp
);
2521 void object_property_add_uint8_ptr(Object
*obj
, const char *name
,
2522 const uint8_t *v
, Error
**errp
)
2524 object_property_add(obj
, name
, "uint8", property_get_uint8_ptr
,
2525 NULL
, NULL
, (void *)v
, errp
);
2529 object_class_property_add_uint8_ptr(ObjectClass
*klass
, const char *name
,
2530 const uint8_t *v
, Error
**errp
)
2532 return object_class_property_add(klass
, name
, "uint8",
2533 property_get_uint8_ptr
,
2534 NULL
, NULL
, (void *)v
, errp
);
2537 void object_property_add_uint16_ptr(Object
*obj
, const char *name
,
2538 const uint16_t *v
, Error
**errp
)
2540 object_property_add(obj
, name
, "uint16", property_get_uint16_ptr
,
2541 NULL
, NULL
, (void *)v
, errp
);
2545 object_class_property_add_uint16_ptr(ObjectClass
*klass
, const char *name
,
2546 const uint16_t *v
, Error
**errp
)
2548 return object_class_property_add(klass
, name
, "uint16",
2549 property_get_uint16_ptr
,
2550 NULL
, NULL
, (void *)v
, errp
);
2553 void object_property_add_uint32_ptr(Object
*obj
, const char *name
,
2554 const uint32_t *v
, Error
**errp
)
2556 object_property_add(obj
, name
, "uint32", property_get_uint32_ptr
,
2557 NULL
, NULL
, (void *)v
, errp
);
2561 object_class_property_add_uint32_ptr(ObjectClass
*klass
, const char *name
,
2562 const uint32_t *v
, Error
**errp
)
2564 return object_class_property_add(klass
, name
, "uint32",
2565 property_get_uint32_ptr
,
2566 NULL
, NULL
, (void *)v
, errp
);
2569 void object_property_add_uint64_ptr(Object
*obj
, const char *name
,
2570 const uint64_t *v
, Error
**errp
)
2572 object_property_add(obj
, name
, "uint64", property_get_uint64_ptr
,
2573 NULL
, NULL
, (void *)v
, errp
);
2577 object_class_property_add_uint64_ptr(ObjectClass
*klass
, const char *name
,
2578 const uint64_t *v
, Error
**errp
)
2580 return object_class_property_add(klass
, name
, "uint64",
2581 property_get_uint64_ptr
,
2582 NULL
, NULL
, (void *)v
, errp
);
2590 static void property_get_alias(Object
*obj
, Visitor
*v
, const char *name
,
2591 void *opaque
, Error
**errp
)
2593 AliasProperty
*prop
= opaque
;
2595 object_property_get(prop
->target_obj
, v
, prop
->target_name
, errp
);
2598 static void property_set_alias(Object
*obj
, Visitor
*v
, const char *name
,
2599 void *opaque
, Error
**errp
)
2601 AliasProperty
*prop
= opaque
;
2603 object_property_set(prop
->target_obj
, v
, prop
->target_name
, errp
);
2606 static Object
*property_resolve_alias(Object
*obj
, void *opaque
,
2609 AliasProperty
*prop
= opaque
;
2611 return object_resolve_path_component(prop
->target_obj
, prop
->target_name
);
2614 static void property_release_alias(Object
*obj
, const char *name
, void *opaque
)
2616 AliasProperty
*prop
= opaque
;
2618 g_free(prop
->target_name
);
2622 void object_property_add_alias(Object
*obj
, const char *name
,
2623 Object
*target_obj
, const char *target_name
,
2626 AliasProperty
*prop
;
2628 ObjectProperty
*target_prop
;
2630 Error
*local_err
= NULL
;
2632 target_prop
= object_property_find(target_obj
, target_name
, errp
);
2637 if (object_property_is_child(target_prop
)) {
2638 prop_type
= g_strdup_printf("link%s",
2639 target_prop
->type
+ strlen("child"));
2641 prop_type
= g_strdup(target_prop
->type
);
2644 prop
= g_malloc(sizeof(*prop
));
2645 prop
->target_obj
= target_obj
;
2646 prop
->target_name
= g_strdup(target_name
);
2648 op
= object_property_add(obj
, name
, prop_type
,
2651 property_release_alias
,
2654 error_propagate(errp
, local_err
);
2658 op
->resolve
= property_resolve_alias
;
2659 if (target_prop
->defval
) {
2660 op
->defval
= qobject_ref(target_prop
->defval
);
2663 object_property_set_description(obj
, op
->name
,
2664 target_prop
->description
,
2671 void object_property_set_description(Object
*obj
, const char *name
,
2672 const char *description
, Error
**errp
)
2676 op
= object_property_find(obj
, name
, errp
);
2681 g_free(op
->description
);
2682 op
->description
= g_strdup(description
);
2685 void object_class_property_set_description(ObjectClass
*klass
,
2687 const char *description
,
2692 op
= g_hash_table_lookup(klass
->properties
, name
);
2694 error_setg(errp
, "Property '.%s' not found", name
);
2698 g_free(op
->description
);
2699 op
->description
= g_strdup(description
);
2702 static void object_class_init(ObjectClass
*klass
, void *data
)
2704 object_class_property_add_str(klass
, "type", qdev_get_type
,
2705 NULL
, &error_abort
);
2708 static void register_types(void)
2710 static TypeInfo interface_info
= {
2711 .name
= TYPE_INTERFACE
,
2712 .class_size
= sizeof(InterfaceClass
),
2716 static TypeInfo object_info
= {
2717 .name
= TYPE_OBJECT
,
2718 .instance_size
= sizeof(Object
),
2719 .class_init
= object_class_init
,
2723 type_interface
= type_register_internal(&interface_info
);
2724 type_register_internal(&object_info
);
2727 type_init(register_types
)