1
2
3
4
5
6
7
8
9
10
11
12
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"
23#include "trace.h"
24
25
26
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"
32
33#define MAX_INTERFACES 32
34
35typedef struct InterfaceImpl InterfaceImpl;
36typedef struct TypeImpl TypeImpl;
37
38struct InterfaceImpl
39{
40 const char *typename;
41};
42
43struct TypeImpl
44{
45 const char *name;
46
47 size_t class_size;
48
49 size_t instance_size;
50
51 void (*class_init)(ObjectClass *klass, void *data);
52 void (*class_base_init)(ObjectClass *klass, void *data);
53
54 void *class_data;
55
56 void (*instance_init)(Object *obj);
57 void (*instance_post_init)(Object *obj);
58 void (*instance_finalize)(Object *obj);
59
60 bool abstract;
61
62 const char *parent;
63 TypeImpl *parent_type;
64
65 ObjectClass *class;
66
67 int num_interfaces;
68 InterfaceImpl interfaces[MAX_INTERFACES];
69};
70
71static Type type_interface;
72
73static GHashTable *type_table_get(void)
74{
75 static GHashTable *type_table;
76
77 if (type_table == NULL) {
78 type_table = g_hash_table_new(g_str_hash, g_str_equal);
79 }
80
81 return type_table;
82}
83
84static bool enumerating_types;
85
86static void type_table_add(TypeImpl *ti)
87{
88 assert(!enumerating_types);
89 g_hash_table_insert(type_table_get(), (void *)ti->name, ti);
90}
91
92static TypeImpl *type_table_lookup(const char *name)
93{
94 return g_hash_table_lookup(type_table_get(), name);
95}
96
97static TypeImpl *type_new(const TypeInfo *info)
98{
99 TypeImpl *ti = g_malloc0(sizeof(*ti));
100 int i;
101
102 g_assert(info->name != NULL);
103
104 if (type_table_lookup(info->name) != NULL) {
105 fprintf(stderr, "Registering `%s' which already exists\n", info->name);
106 abort();
107 }
108
109 ti->name = g_strdup(info->name);
110 ti->parent = g_strdup(info->parent);
111
112 ti->class_size = info->class_size;
113 ti->instance_size = info->instance_size;
114
115 ti->class_init = info->class_init;
116 ti->class_base_init = info->class_base_init;
117 ti->class_data = info->class_data;
118
119 ti->instance_init = info->instance_init;
120 ti->instance_post_init = info->instance_post_init;
121 ti->instance_finalize = info->instance_finalize;
122
123 ti->abstract = info->abstract;
124
125 for (i = 0; info->interfaces && info->interfaces[i].type; i++) {
126 ti->interfaces[i].typename = g_strdup(info->interfaces[i].type);
127 }
128 ti->num_interfaces = i;
129
130 return ti;
131}
132
133static TypeImpl *type_register_internal(const TypeInfo *info)
134{
135 TypeImpl *ti;
136 ti = type_new(info);
137
138 type_table_add(ti);
139 return ti;
140}
141
142TypeImpl *type_register(const TypeInfo *info)
143{
144 assert(info->parent);
145 return type_register_internal(info);
146}
147
148TypeImpl *type_register_static(const TypeInfo *info)
149{
150 return type_register(info);
151}
152
153void type_register_static_array(const TypeInfo *infos, int nr_infos)
154{
155 int i;
156
157 for (i = 0; i < nr_infos; i++) {
158 type_register_static(&infos[i]);
159 }
160}
161
162static TypeImpl *type_get_by_name(const char *name)
163{
164 if (name == NULL) {
165 return NULL;
166 }
167
168 return type_table_lookup(name);
169}
170
171static TypeImpl *type_get_parent(TypeImpl *type)
172{
173 if (!type->parent_type && type->parent) {
174 type->parent_type = type_get_by_name(type->parent);
175 g_assert(type->parent_type != NULL);
176 }
177
178 return type->parent_type;
179}
180
181static bool type_has_parent(TypeImpl *type)
182{
183 return (type->parent != NULL);
184}
185
186static size_t type_class_get_size(TypeImpl *ti)
187{
188 if (ti->class_size) {
189 return ti->class_size;
190 }
191
192 if (type_has_parent(ti)) {
193 return type_class_get_size(type_get_parent(ti));
194 }
195
196 return sizeof(ObjectClass);
197}
198
199static size_t type_object_get_size(TypeImpl *ti)
200{
201 if (ti->instance_size) {
202 return ti->instance_size;
203 }
204
205 if (type_has_parent(ti)) {
206 return type_object_get_size(type_get_parent(ti));
207 }
208
209 return 0;
210}
211
212size_t object_type_get_instance_size(const char *typename)
213{
214 TypeImpl *type = type_get_by_name(typename);
215
216 g_assert(type != NULL);
217 return type_object_get_size(type);
218}
219
220static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type)
221{
222 assert(target_type);
223
224
225 while (type) {
226 if (type == target_type) {
227 return true;
228 }
229
230 type = type_get_parent(type);
231 }
232
233 return false;
234}
235
236static void type_initialize(TypeImpl *ti);
237
238static void type_initialize_interface(TypeImpl *ti, TypeImpl *interface_type,
239 TypeImpl *parent_type)
240{
241 InterfaceClass *new_iface;
242 TypeInfo info = { };
243 TypeImpl *iface_impl;
244
245 info.parent = parent_type->name;
246 info.name = g_strdup_printf("%s::%s", ti->name, interface_type->name);
247 info.abstract = true;
248
249 iface_impl = type_new(&info);
250 iface_impl->parent_type = parent_type;
251 type_initialize(iface_impl);
252 g_free((char *)info.name);
253
254 new_iface = (InterfaceClass *)iface_impl->class;
255 new_iface->concrete_class = ti->class;
256 new_iface->interface_type = interface_type;
257
258 ti->class->interfaces = g_slist_append(ti->class->interfaces,
259 iface_impl->class);
260}
261
262static void object_property_free(gpointer data)
263{
264 ObjectProperty *prop = data;
265
266 g_free(prop->name);
267 g_free(prop->type);
268 g_free(prop->description);
269 g_free(prop);
270}
271
272static void type_initialize(TypeImpl *ti)
273{
274 TypeImpl *parent;
275
276 if (ti->class) {
277 return;
278 }
279
280 ti->class_size = type_class_get_size(ti);
281 ti->instance_size = type_object_get_size(ti);
282
283
284
285 if (ti->instance_size == 0) {
286 ti->abstract = true;
287 }
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);
295 }
296 ti->class = g_malloc0(ti->class_size);
297
298 parent = type_get_parent(ti);
299 if (parent) {
300 type_initialize(parent);
301 GSList *e;
302 int i;
303
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);
309
310 for (e = parent->class->interfaces; e; e = e->next) {
311 InterfaceClass *iface = e->data;
312 ObjectClass *klass = OBJECT_CLASS(iface);
313
314 type_initialize_interface(ti, iface->interface_type, klass->type);
315 }
316
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;
321
322 if (type_is_ancestor(target_type, t)) {
323 break;
324 }
325 }
326
327 if (e) {
328 continue;
329 }
330
331 type_initialize_interface(ti, t, t);
332 }
333 } else {
334 ti->class->properties = g_hash_table_new_full(
335 g_str_hash, g_str_equal, g_free, object_property_free);
336 }
337
338 ti->class->type = ti;
339
340 while (parent) {
341 if (parent->class_base_init) {
342 parent->class_base_init(ti->class, ti->class_data);
343 }
344 parent = type_get_parent(parent);
345 }
346
347 if (ti->class_init) {
348 ti->class_init(ti->class, ti->class_data);
349 }
350}
351
352static void object_init_with_type(Object *obj, TypeImpl *ti)
353{
354 if (type_has_parent(ti)) {
355 object_init_with_type(obj, type_get_parent(ti));
356 }
357
358 if (ti->instance_init) {
359 ti->instance_init(obj);
360 }
361}
362
363static void object_post_init_with_type(Object *obj, TypeImpl *ti)
364{
365 if (ti->instance_post_init) {
366 ti->instance_post_init(obj);
367 }
368
369 if (type_has_parent(ti)) {
370 object_post_init_with_type(obj, type_get_parent(ti));
371 }
372}
373
374void object_apply_global_props(Object *obj, const GPtrArray *props, Error **errp)
375{
376 int i;
377
378 if (!props) {
379 return;
380 }
381
382 for (i = 0; i < props->len; i++) {
383 GlobalProperty *p = g_ptr_array_index(props, i);
384 Error *err = NULL;
385
386 if (object_dynamic_cast(obj, p->driver) == NULL) {
387 continue;
388 }
389 if (p->optional && !object_property_find(obj, p->property, NULL)) {
390 continue;
391 }
392 p->used = true;
393 object_property_parse(obj, p->value, p->property, &err);
394 if (err != NULL) {
395 error_prepend(&err, "can't apply global %s.%s=%s: ",
396 p->driver, p->property, p->value);
397
398
399
400
401
402 if (errp) {
403 error_propagate(errp, err);
404 return;
405 } else {
406 warn_report_err(err);
407 }
408 }
409 }
410}
411
412
413
414
415
416
417
418
419static GPtrArray *object_compat_props[2];
420
421
422
423
424
425void object_set_machine_compat_props(GPtrArray *compat_props)
426{
427 assert(!object_compat_props[1]);
428 object_compat_props[1] = compat_props;
429}
430
431
432
433
434
435void object_set_accelerator_compat_props(GPtrArray *compat_props)
436{
437 assert(!object_compat_props[0]);
438 object_compat_props[0] = compat_props;
439}
440
441void object_apply_compat_props(Object *obj)
442{
443 int i;
444
445 for (i = 0; i < ARRAY_SIZE(object_compat_props); i++) {
446 object_apply_global_props(obj, object_compat_props[i],
447 &error_abort);
448 }
449}
450
451static void object_initialize_with_type(void *data, size_t size, TypeImpl *type)
452{
453 Object *obj = data;
454
455 type_initialize(type);
456
457 g_assert(type->instance_size >= sizeof(Object));
458 g_assert(type->abstract == false);
459 g_assert(size >= type->instance_size);
460
461 memset(obj, 0, type->instance_size);
462 obj->class = type->class;
463 object_ref(obj);
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);
468}
469
470void object_initialize(void *data, size_t size, const char *typename)
471{
472 TypeImpl *type = type_get_by_name(typename);
473
474 if (!type) {
475 error_report("missing object type '%s'", typename);
476 abort();
477 }
478
479 object_initialize_with_type(data, size, type);
480}
481
482void object_initialize_child(Object *parentobj, const char *propname,
483 void *childobj, size_t size, const char *type,
484 Error **errp, ...)
485{
486 va_list vargs;
487
488 va_start(vargs, errp);
489 object_initialize_childv(parentobj, propname, childobj, size, type, errp,
490 vargs);
491 va_end(vargs);
492}
493
494void object_initialize_childv(Object *parentobj, const char *propname,
495 void *childobj, size_t size, const char *type,
496 Error **errp, va_list vargs)
497{
498 Error *local_err = NULL;
499 Object *obj;
500 UserCreatable *uc;
501
502 object_initialize(childobj, size, type);
503 obj = OBJECT(childobj);
504
505 object_set_propv(obj, &local_err, vargs);
506 if (local_err) {
507 goto out;
508 }
509
510 object_property_add_child(parentobj, propname, obj, &local_err);
511 if (local_err) {
512 goto out;
513 }
514
515 uc = (UserCreatable *)object_dynamic_cast(obj, TYPE_USER_CREATABLE);
516 if (uc) {
517 user_creatable_complete(uc, &local_err);
518 if (local_err) {
519 object_unparent(obj);
520 goto out;
521 }
522 }
523
524
525
526
527
528
529 object_unref(obj);
530
531out:
532 if (local_err) {
533 error_propagate(errp, local_err);
534 object_unref(obj);
535 }
536}
537
538static inline bool object_property_is_child(ObjectProperty *prop)
539{
540 return strstart(prop->type, "child<", NULL);
541}
542
543static void object_property_del_all(Object *obj)
544{
545 ObjectProperty *prop;
546 GHashTableIter iter;
547 gpointer key, value;
548 bool released;
549
550 do {
551 released = false;
552 g_hash_table_iter_init(&iter, obj->properties);
553 while (g_hash_table_iter_next(&iter, &key, &value)) {
554 prop = value;
555 if (prop->release) {
556 prop->release(obj, prop->name, prop->opaque);
557 prop->release = NULL;
558 released = true;
559 break;
560 }
561 g_hash_table_iter_remove(&iter);
562 }
563 } while (released);
564
565 g_hash_table_unref(obj->properties);
566}
567
568static void object_property_del_child(Object *obj, Object *child, Error **errp)
569{
570 ObjectProperty *prop;
571 GHashTableIter iter;
572 gpointer key, value;
573
574 g_hash_table_iter_init(&iter, obj->properties);
575 while (g_hash_table_iter_next(&iter, &key, &value)) {
576 prop = value;
577 if (object_property_is_child(prop) && prop->opaque == child) {
578 if (prop->release) {
579 prop->release(obj, prop->name, prop->opaque);
580 prop->release = NULL;
581 }
582 break;
583 }
584 }
585 g_hash_table_iter_init(&iter, obj->properties);
586 while (g_hash_table_iter_next(&iter, &key, &value)) {
587 prop = value;
588 if (object_property_is_child(prop) && prop->opaque == child) {
589 g_hash_table_iter_remove(&iter);
590 break;
591 }
592 }
593}
594
595void object_unparent(Object *obj)
596{
597 if (obj->parent) {
598 object_property_del_child(obj->parent, obj, NULL);
599 }
600}
601
602static void object_deinit(Object *obj, TypeImpl *type)
603{
604 if (type->instance_finalize) {
605 type->instance_finalize(obj);
606 }
607
608 if (type_has_parent(type)) {
609 object_deinit(obj, type_get_parent(type));
610 }
611}
612
613static void object_finalize(void *data)
614{
615 Object *obj = data;
616 TypeImpl *ti = obj->class->type;
617
618 object_property_del_all(obj);
619 object_deinit(obj, ti);
620
621 g_assert(obj->ref == 0);
622 if (obj->free) {
623 obj->free(obj);
624 }
625}
626
627static Object *object_new_with_type(Type type)
628{
629 Object *obj;
630
631 g_assert(type != NULL);
632 type_initialize(type);
633
634 obj = g_malloc(type->instance_size);
635 object_initialize_with_type(obj, type->instance_size, type);
636 obj->free = g_free;
637
638 return obj;
639}
640
641Object *object_new(const char *typename)
642{
643 TypeImpl *ti = type_get_by_name(typename);
644
645 return object_new_with_type(ti);
646}
647
648
649Object *object_new_with_props(const char *typename,
650 Object *parent,
651 const char *id,
652 Error **errp,
653 ...)
654{
655 va_list vargs;
656 Object *obj;
657
658 va_start(vargs, errp);
659 obj = object_new_with_propv(typename, parent, id, errp, vargs);
660 va_end(vargs);
661
662 return obj;
663}
664
665
666Object *object_new_with_propv(const char *typename,
667 Object *parent,
668 const char *id,
669 Error **errp,
670 va_list vargs)
671{
672 Object *obj;
673 ObjectClass *klass;
674 Error *local_err = NULL;
675 UserCreatable *uc;
676
677 klass = object_class_by_name(typename);
678 if (!klass) {
679 error_setg(errp, "invalid object type: %s", typename);
680 return NULL;
681 }
682
683 if (object_class_is_abstract(klass)) {
684 error_setg(errp, "object type '%s' is abstract", typename);
685 return NULL;
686 }
687 obj = object_new_with_type(klass->type);
688
689 if (object_set_propv(obj, &local_err, vargs) < 0) {
690 goto error;
691 }
692
693 if (id != NULL) {
694 object_property_add_child(parent, id, obj, &local_err);
695 if (local_err) {
696 goto error;
697 }
698 }
699
700 uc = (UserCreatable *)object_dynamic_cast(obj, TYPE_USER_CREATABLE);
701 if (uc) {
702 user_creatable_complete(uc, &local_err);
703 if (local_err) {
704 if (id != NULL) {
705 object_unparent(obj);
706 }
707 goto error;
708 }
709 }
710
711 object_unref(OBJECT(obj));
712 return obj;
713
714 error:
715 error_propagate(errp, local_err);
716 object_unref(obj);
717 return NULL;
718}
719
720
721int object_set_props(Object *obj,
722 Error **errp,
723 ...)
724{
725 va_list vargs;
726 int ret;
727
728 va_start(vargs, errp);
729 ret = object_set_propv(obj, errp, vargs);
730 va_end(vargs);
731
732 return ret;
733}
734
735
736int object_set_propv(Object *obj,
737 Error **errp,
738 va_list vargs)
739{
740 const char *propname;
741 Error *local_err = NULL;
742
743 propname = va_arg(vargs, char *);
744 while (propname != NULL) {
745 const char *value = va_arg(vargs, char *);
746
747 g_assert(value != NULL);
748 object_property_parse(obj, value, propname, &local_err);
749 if (local_err) {
750 error_propagate(errp, local_err);
751 return -1;
752 }
753 propname = va_arg(vargs, char *);
754 }
755
756 return 0;
757}
758
759
760Object *object_dynamic_cast(Object *obj, const char *typename)
761{
762 if (obj && object_class_dynamic_cast(object_get_class(obj), typename)) {
763 return obj;
764 }
765
766 return NULL;
767}
768
769Object *object_dynamic_cast_assert(Object *obj, const char *typename,
770 const char *file, int line, const char *func)
771{
772 trace_object_dynamic_cast_assert(obj ? obj->class->type->name : "(null)",
773 typename, file, line, func);
774
775#ifdef CONFIG_QOM_CAST_DEBUG
776 int i;
777 Object *inst;
778
779 for (i = 0; obj && i < OBJECT_CLASS_CAST_CACHE; i++) {
780 if (atomic_read(&obj->class->object_cast_cache[i]) == typename) {
781 goto out;
782 }
783 }
784
785 inst = object_dynamic_cast(obj, typename);
786
787 if (!inst && obj) {
788 fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
789 file, line, func, obj, typename);
790 abort();
791 }
792
793 assert(obj == inst);
794
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]));
799 }
800 atomic_set(&obj->class->object_cast_cache[i - 1], typename);
801 }
802
803out:
804#endif
805 return obj;
806}
807
808ObjectClass *object_class_dynamic_cast(ObjectClass *class,
809 const char *typename)
810{
811 ObjectClass *ret = NULL;
812 TypeImpl *target_type;
813 TypeImpl *type;
814
815 if (!class) {
816 return NULL;
817 }
818
819
820 type = class->type;
821 if (type->name == typename) {
822 return class;
823 }
824
825 target_type = type_get_by_name(typename);
826 if (!target_type) {
827
828 return NULL;
829 }
830
831 if (type->class->interfaces &&
832 type_is_ancestor(target_type, type_interface)) {
833 int found = 0;
834 GSList *i;
835
836 for (i = class->interfaces; i; i = i->next) {
837 ObjectClass *target_class = i->data;
838
839 if (type_is_ancestor(target_class->type, target_type)) {
840 ret = target_class;
841 found++;
842 }
843 }
844
845
846 if (found > 1) {
847 ret = NULL;
848 }
849 } else if (type_is_ancestor(type, target_type)) {
850 ret = class;
851 }
852
853 return ret;
854}
855
856ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class,
857 const char *typename,
858 const char *file, int line,
859 const char *func)
860{
861 ObjectClass *ret;
862
863 trace_object_class_dynamic_cast_assert(class ? class->type->name : "(null)",
864 typename, file, line, func);
865
866#ifdef CONFIG_QOM_CAST_DEBUG
867 int i;
868
869 for (i = 0; class && i < OBJECT_CLASS_CAST_CACHE; i++) {
870 if (atomic_read(&class->class_cast_cache[i]) == typename) {
871 ret = class;
872 goto out;
873 }
874 }
875#else
876 if (!class || !class->interfaces) {
877 return class;
878 }
879#endif
880
881 ret = object_class_dynamic_cast(class, typename);
882 if (!ret && class) {
883 fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
884 file, line, func, class, typename);
885 abort();
886 }
887
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]));
893 }
894 atomic_set(&class->class_cast_cache[i - 1], typename);
895 }
896out:
897#endif
898 return ret;
899}
900
901const char *object_get_typename(const Object *obj)
902{
903 return obj->class->type->name;
904}
905
906ObjectClass *object_get_class(Object *obj)
907{
908 return obj->class;
909}
910
911bool object_class_is_abstract(ObjectClass *klass)
912{
913 return klass->type->abstract;
914}
915
916const char *object_class_get_name(ObjectClass *klass)
917{
918 return klass->type->name;
919}
920
921ObjectClass *object_class_by_name(const char *typename)
922{
923 TypeImpl *type = type_get_by_name(typename);
924
925 if (!type) {
926 return NULL;
927 }
928
929 type_initialize(type);
930
931 return type->class;
932}
933
934ObjectClass *object_class_get_parent(ObjectClass *class)
935{
936 TypeImpl *type = type_get_parent(class->type);
937
938 if (!type) {
939 return NULL;
940 }
941
942 type_initialize(type);
943
944 return type->class;
945}
946
947typedef struct OCFData
948{
949 void (*fn)(ObjectClass *klass, void *opaque);
950 const char *implements_type;
951 bool include_abstract;
952 void *opaque;
953} OCFData;
954
955static void object_class_foreach_tramp(gpointer key, gpointer value,
956 gpointer opaque)
957{
958 OCFData *data = opaque;
959 TypeImpl *type = value;
960 ObjectClass *k;
961
962 type_initialize(type);
963 k = type->class;
964
965 if (!data->include_abstract && type->abstract) {
966 return;
967 }
968
969 if (data->implements_type &&
970 !object_class_dynamic_cast(k, data->implements_type)) {
971 return;
972 }
973
974 data->fn(k, data->opaque);
975}
976
977void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque),
978 const char *implements_type, bool include_abstract,
979 void *opaque)
980{
981 OCFData data = { fn, implements_type, include_abstract, opaque };
982
983 enumerating_types = true;
984 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data);
985 enumerating_types = false;
986}
987
988static int do_object_child_foreach(Object *obj,
989 int (*fn)(Object *child, void *opaque),
990 void *opaque, bool recurse)
991{
992 GHashTableIter iter;
993 ObjectProperty *prop;
994 int ret = 0;
995
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;
1000
1001 ret = fn(child, opaque);
1002 if (ret != 0) {
1003 break;
1004 }
1005 if (recurse) {
1006 do_object_child_foreach(child, fn, opaque, true);
1007 }
1008 }
1009 }
1010 return ret;
1011}
1012
1013int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque),
1014 void *opaque)
1015{
1016 return do_object_child_foreach(obj, fn, opaque, false);
1017}
1018
1019int object_child_foreach_recursive(Object *obj,
1020 int (*fn)(Object *child, void *opaque),
1021 void *opaque)
1022{
1023 return do_object_child_foreach(obj, fn, opaque, true);
1024}
1025
1026static void object_class_get_list_tramp(ObjectClass *klass, void *opaque)
1027{
1028 GSList **list = opaque;
1029
1030 *list = g_slist_prepend(*list, klass);
1031}
1032
1033GSList *object_class_get_list(const char *implements_type,
1034 bool include_abstract)
1035{
1036 GSList *list = NULL;
1037
1038 object_class_foreach(object_class_get_list_tramp,
1039 implements_type, include_abstract, &list);
1040 return list;
1041}
1042
1043static gint object_class_cmp(gconstpointer a, gconstpointer b)
1044{
1045 return strcasecmp(object_class_get_name((ObjectClass *)a),
1046 object_class_get_name((ObjectClass *)b));
1047}
1048
1049GSList *object_class_get_list_sorted(const char *implements_type,
1050 bool include_abstract)
1051{
1052 return g_slist_sort(object_class_get_list(implements_type, include_abstract),
1053 object_class_cmp);
1054}
1055
1056void object_ref(Object *obj)
1057{
1058 if (!obj) {
1059 return;
1060 }
1061 atomic_inc(&obj->ref);
1062}
1063
1064void object_unref(Object *obj)
1065{
1066 if (!obj) {
1067 return;
1068 }
1069 g_assert(obj->ref > 0);
1070
1071
1072 if (atomic_fetch_dec(&obj->ref) == 1) {
1073 object_finalize(obj);
1074 }
1075}
1076
1077ObjectProperty *
1078object_property_add(Object *obj, const char *name, const char *type,
1079 ObjectPropertyAccessor *get,
1080 ObjectPropertyAccessor *set,
1081 ObjectPropertyRelease *release,
1082 void *opaque, Error **errp)
1083{
1084 ObjectProperty *prop;
1085 size_t name_len = strlen(name);
1086
1087 if (name_len >= 3 && !memcmp(name + name_len - 3, "[*]", 4)) {
1088 int i;
1089 ObjectProperty *ret;
1090 char *name_no_array = g_strdup(name);
1091
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);
1095
1096 ret = object_property_add(obj, full_name, type, get, set,
1097 release, opaque, NULL);
1098 g_free(full_name);
1099 if (ret) {
1100 break;
1101 }
1102 }
1103 g_free(name_no_array);
1104 return ret;
1105 }
1106
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));
1111 return NULL;
1112 }
1113
1114 prop = g_malloc0(sizeof(*prop));
1115
1116 prop->name = g_strdup(name);
1117 prop->type = g_strdup(type);
1118
1119 prop->get = get;
1120 prop->set = set;
1121 prop->release = release;
1122 prop->opaque = opaque;
1123
1124 g_hash_table_insert(obj->properties, prop->name, prop);
1125 return prop;
1126}
1127
1128ObjectProperty *
1129object_class_property_add(ObjectClass *klass,
1130 const char *name,
1131 const char *type,
1132 ObjectPropertyAccessor *get,
1133 ObjectPropertyAccessor *set,
1134 ObjectPropertyRelease *release,
1135 void *opaque,
1136 Error **errp)
1137{
1138 ObjectProperty *prop;
1139
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));
1144 return NULL;
1145 }
1146
1147 prop = g_malloc0(sizeof(*prop));
1148
1149 prop->name = g_strdup(name);
1150 prop->type = g_strdup(type);
1151
1152 prop->get = get;
1153 prop->set = set;
1154 prop->release = release;
1155 prop->opaque = opaque;
1156
1157 g_hash_table_insert(klass->properties, g_strdup(name), prop);
1158
1159 return prop;
1160}
1161
1162ObjectProperty *object_property_find(Object *obj, const char *name,
1163 Error **errp)
1164{
1165 ObjectProperty *prop;
1166 ObjectClass *klass = object_get_class(obj);
1167
1168 prop = object_class_property_find(klass, name, NULL);
1169 if (prop) {
1170 return prop;
1171 }
1172
1173 prop = g_hash_table_lookup(obj->properties, name);
1174 if (prop) {
1175 return prop;
1176 }
1177
1178 error_setg(errp, "Property '.%s' not found", name);
1179 return NULL;
1180}
1181
1182void object_property_iter_init(ObjectPropertyIterator *iter,
1183 Object *obj)
1184{
1185 g_hash_table_iter_init(&iter->iter, obj->properties);
1186 iter->nextclass = object_get_class(obj);
1187}
1188
1189ObjectProperty *object_property_iter_next(ObjectPropertyIterator *iter)
1190{
1191 gpointer key, val;
1192 while (!g_hash_table_iter_next(&iter->iter, &key, &val)) {
1193 if (!iter->nextclass) {
1194 return NULL;
1195 }
1196 g_hash_table_iter_init(&iter->iter, iter->nextclass->properties);
1197 iter->nextclass = object_class_get_parent(iter->nextclass);
1198 }
1199 return val;
1200}
1201
1202void object_class_property_iter_init(ObjectPropertyIterator *iter,
1203 ObjectClass *klass)
1204{
1205 g_hash_table_iter_init(&iter->iter, klass->properties);
1206 iter->nextclass = object_class_get_parent(klass);
1207}
1208
1209ObjectProperty *object_class_property_find(ObjectClass *klass, const char *name,
1210 Error **errp)
1211{
1212 ObjectProperty *prop;
1213 ObjectClass *parent_klass;
1214
1215 parent_klass = object_class_get_parent(klass);
1216 if (parent_klass) {
1217 prop = object_class_property_find(parent_klass, name, NULL);
1218 if (prop) {
1219 return prop;
1220 }
1221 }
1222
1223 prop = g_hash_table_lookup(klass->properties, name);
1224 if (!prop) {
1225 error_setg(errp, "Property '.%s' not found", name);
1226 }
1227 return prop;
1228}
1229
1230void object_property_del(Object *obj, const char *name, Error **errp)
1231{
1232 ObjectProperty *prop = g_hash_table_lookup(obj->properties, name);
1233
1234 if (!prop) {
1235 error_setg(errp, "Property '.%s' not found", name);
1236 return;
1237 }
1238
1239 if (prop->release) {
1240 prop->release(obj, name, prop->opaque);
1241 }
1242 g_hash_table_remove(obj->properties, name);
1243}
1244
1245void object_property_get(Object *obj, Visitor *v, const char *name,
1246 Error **errp)
1247{
1248 ObjectProperty *prop = object_property_find(obj, name, errp);
1249 if (prop == NULL) {
1250 return;
1251 }
1252
1253 if (!prop->get) {
1254 error_setg(errp, QERR_PERMISSION_DENIED);
1255 } else {
1256 prop->get(obj, v, name, prop->opaque, errp);
1257 }
1258}
1259
1260void object_property_set(Object *obj, Visitor *v, const char *name,
1261 Error **errp)
1262{
1263 ObjectProperty *prop = object_property_find(obj, name, errp);
1264 if (prop == NULL) {
1265 return;
1266 }
1267
1268 if (!prop->set) {
1269 error_setg(errp, QERR_PERMISSION_DENIED);
1270 } else {
1271 prop->set(obj, v, name, prop->opaque, errp);
1272 }
1273}
1274
1275void object_property_set_str(Object *obj, const char *value,
1276 const char *name, Error **errp)
1277{
1278 QString *qstr = qstring_from_str(value);
1279 object_property_set_qobject(obj, QOBJECT(qstr), name, errp);
1280
1281 qobject_unref(qstr);
1282}
1283
1284char *object_property_get_str(Object *obj, const char *name,
1285 Error **errp)
1286{
1287 QObject *ret = object_property_get_qobject(obj, name, errp);
1288 char *retval;
1289
1290 if (!ret) {
1291 return NULL;
1292 }
1293
1294 retval = g_strdup(qobject_get_try_str(ret));
1295 if (!retval) {
1296 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
1297 }
1298
1299 qobject_unref(ret);
1300 return retval;
1301}
1302
1303void object_property_set_link(Object *obj, Object *value,
1304 const char *name, Error **errp)
1305{
1306 if (value) {
1307 gchar *path = object_get_canonical_path(value);
1308 object_property_set_str(obj, path, name, errp);
1309 g_free(path);
1310 } else {
1311 object_property_set_str(obj, "", name, errp);
1312 }
1313}
1314
1315Object *object_property_get_link(Object *obj, const char *name,
1316 Error **errp)
1317{
1318 char *str = object_property_get_str(obj, name, errp);
1319 Object *target = NULL;
1320
1321 if (str && *str) {
1322 target = object_resolve_path(str, NULL);
1323 if (!target) {
1324 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1325 "Device '%s' not found", str);
1326 }
1327 }
1328
1329 g_free(str);
1330 return target;
1331}
1332
1333void object_property_set_bool(Object *obj, bool value,
1334 const char *name, Error **errp)
1335{
1336 QBool *qbool = qbool_from_bool(value);
1337 object_property_set_qobject(obj, QOBJECT(qbool), name, errp);
1338
1339 qobject_unref(qbool);
1340}
1341
1342bool object_property_get_bool(Object *obj, const char *name,
1343 Error **errp)
1344{
1345 QObject *ret = object_property_get_qobject(obj, name, errp);
1346 QBool *qbool;
1347 bool retval;
1348
1349 if (!ret) {
1350 return false;
1351 }
1352 qbool = qobject_to(QBool, ret);
1353 if (!qbool) {
1354 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean");
1355 retval = false;
1356 } else {
1357 retval = qbool_get_bool(qbool);
1358 }
1359
1360 qobject_unref(ret);
1361 return retval;
1362}
1363
1364void object_property_set_int(Object *obj, int64_t value,
1365 const char *name, Error **errp)
1366{
1367 QNum *qnum = qnum_from_int(value);
1368 object_property_set_qobject(obj, QOBJECT(qnum), name, errp);
1369
1370 qobject_unref(qnum);
1371}
1372
1373int64_t object_property_get_int(Object *obj, const char *name,
1374 Error **errp)
1375{
1376 QObject *ret = object_property_get_qobject(obj, name, errp);
1377 QNum *qnum;
1378 int64_t retval;
1379
1380 if (!ret) {
1381 return -1;
1382 }
1383
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");
1387 retval = -1;
1388 }
1389
1390 qobject_unref(ret);
1391 return retval;
1392}
1393
1394void object_property_set_uint(Object *obj, uint64_t value,
1395 const char *name, Error **errp)
1396{
1397 QNum *qnum = qnum_from_uint(value);
1398
1399 object_property_set_qobject(obj, QOBJECT(qnum), name, errp);
1400 qobject_unref(qnum);
1401}
1402
1403uint64_t object_property_get_uint(Object *obj, const char *name,
1404 Error **errp)
1405{
1406 QObject *ret = object_property_get_qobject(obj, name, errp);
1407 QNum *qnum;
1408 uint64_t retval;
1409
1410 if (!ret) {
1411 return 0;
1412 }
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");
1416 retval = 0;
1417 }
1418
1419 qobject_unref(ret);
1420 return retval;
1421}
1422
1423typedef struct EnumProperty {
1424 const QEnumLookup *lookup;
1425 int (*get)(Object *, Error **);
1426 void (*set)(Object *, int, Error **);
1427} EnumProperty;
1428
1429int object_property_get_enum(Object *obj, const char *name,
1430 const char *typename, Error **errp)
1431{
1432 Error *err = NULL;
1433 Visitor *v;
1434 char *str;
1435 int ret;
1436 ObjectProperty *prop = object_property_find(obj, name, errp);
1437 EnumProperty *enumprop;
1438
1439 if (prop == NULL) {
1440 return 0;
1441 }
1442
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);
1447 return 0;
1448 }
1449
1450 enumprop = prop->opaque;
1451
1452 v = string_output_visitor_new(false, &str);
1453 object_property_get(obj, v, name, &err);
1454 if (err) {
1455 error_propagate(errp, err);
1456 visit_free(v);
1457 return 0;
1458 }
1459 visit_complete(v, &str);
1460 visit_free(v);
1461 v = string_input_visitor_new(str);
1462 visit_type_enum(v, name, &ret, enumprop->lookup, errp);
1463
1464 g_free(str);
1465 visit_free(v);
1466
1467 return ret;
1468}
1469
1470void object_property_get_uint16List(Object *obj, const char *name,
1471 uint16List **list, Error **errp)
1472{
1473 Error *err = NULL;
1474 Visitor *v;
1475 char *str;
1476
1477 v = string_output_visitor_new(false, &str);
1478 object_property_get(obj, v, name, &err);
1479 if (err) {
1480 error_propagate(errp, err);
1481 goto out;
1482 }
1483 visit_complete(v, &str);
1484 visit_free(v);
1485 v = string_input_visitor_new(str);
1486 visit_type_uint16List(v, NULL, list, errp);
1487
1488 g_free(str);
1489out:
1490 visit_free(v);
1491}
1492
1493void object_property_parse(Object *obj, const char *string,
1494 const char *name, Error **errp)
1495{
1496 Visitor *v = string_input_visitor_new(string);
1497 object_property_set(obj, v, name, errp);
1498 visit_free(v);
1499}
1500
1501char *object_property_print(Object *obj, const char *name, bool human,
1502 Error **errp)
1503{
1504 Visitor *v;
1505 char *string = NULL;
1506 Error *local_err = NULL;
1507
1508 v = string_output_visitor_new(human, &string);
1509 object_property_get(obj, v, name, &local_err);
1510 if (local_err) {
1511 error_propagate(errp, local_err);
1512 goto out;
1513 }
1514
1515 visit_complete(v, &string);
1516
1517out:
1518 visit_free(v);
1519 return string;
1520}
1521
1522const char *object_property_get_type(Object *obj, const char *name, Error **errp)
1523{
1524 ObjectProperty *prop = object_property_find(obj, name, errp);
1525 if (prop == NULL) {
1526 return NULL;
1527 }
1528
1529 return prop->type;
1530}
1531
1532Object *object_get_root(void)
1533{
1534 static Object *root;
1535
1536 if (!root) {
1537 root = object_new("container");
1538 }
1539
1540 return root;
1541}
1542
1543Object *object_get_objects_root(void)
1544{
1545 return container_get(object_get_root(), "/objects");
1546}
1547
1548Object *object_get_internal_root(void)
1549{
1550 static Object *internal_root;
1551
1552 if (!internal_root) {
1553 internal_root = object_new("container");
1554 }
1555
1556 return internal_root;
1557}
1558
1559static void object_get_child_property(Object *obj, Visitor *v,
1560 const char *name, void *opaque,
1561 Error **errp)
1562{
1563 Object *child = opaque;
1564 gchar *path;
1565
1566 path = object_get_canonical_path(child);
1567 visit_type_str(v, name, &path, errp);
1568 g_free(path);
1569}
1570
1571static Object *object_resolve_child_property(Object *parent, void *opaque, const gchar *part)
1572{
1573 return opaque;
1574}
1575
1576static void object_finalize_child_property(Object *obj, const char *name,
1577 void *opaque)
1578{
1579 Object *child = opaque;
1580
1581 if (child->class->unparent) {
1582 (child->class->unparent)(child);
1583 }
1584 child->parent = NULL;
1585 object_unref(child);
1586}
1587
1588void object_property_add_child(Object *obj, const char *name,
1589 Object *child, Error **errp)
1590{
1591 Error *local_err = NULL;
1592 gchar *type;
1593 ObjectProperty *op;
1594
1595 if (child->parent != NULL) {
1596 error_setg(errp, "child object is already parented");
1597 return;
1598 }
1599
1600 type = g_strdup_printf("child<%s>", object_get_typename(OBJECT(child)));
1601
1602 op = object_property_add(obj, name, type, object_get_child_property, NULL,
1603 object_finalize_child_property, child, &local_err);
1604 if (local_err) {
1605 error_propagate(errp, local_err);
1606 goto out;
1607 }
1608
1609 op->resolve = object_resolve_child_property;
1610 object_ref(child);
1611 child->parent = obj;
1612
1613out:
1614 g_free(type);
1615}
1616
1617void object_property_allow_set_link(const Object *obj, const char *name,
1618 Object *val, Error **errp)
1619{
1620
1621}
1622
1623typedef struct {
1624 Object **child;
1625 void (*check)(const Object *, const char *, Object *, Error **);
1626 ObjectPropertyLinkFlags flags;
1627} LinkProperty;
1628
1629static void object_get_link_property(Object *obj, Visitor *v,
1630 const char *name, void *opaque,
1631 Error **errp)
1632{
1633 LinkProperty *lprop = opaque;
1634 Object **child = lprop->child;
1635 gchar *path;
1636
1637 if (*child) {
1638 path = object_get_canonical_path(*child);
1639 visit_type_str(v, name, &path, errp);
1640 g_free(path);
1641 } else {
1642 path = (gchar *)"";
1643 visit_type_str(v, name, &path, errp);
1644 }
1645}
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656static Object *object_resolve_link(Object *obj, const char *name,
1657 const char *path, Error **errp)
1658{
1659 const char *type;
1660 gchar *target_type;
1661 bool ambiguous = false;
1662 Object *target;
1663
1664
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);
1668
1669 if (ambiguous) {
1670 error_setg(errp, "Path '%s' does not uniquely identify an object",
1671 path);
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);
1676 } else {
1677 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1678 "Device '%s' not found", path);
1679 }
1680 target = NULL;
1681 }
1682 g_free(target_type);
1683
1684 return target;
1685}
1686
1687static void object_set_link_property(Object *obj, Visitor *v,
1688 const char *name, void *opaque,
1689 Error **errp)
1690{
1691 Error *local_err = NULL;
1692 LinkProperty *prop = opaque;
1693 Object **child = prop->child;
1694 Object *old_target = *child;
1695 Object *new_target = NULL;
1696 char *path = NULL;
1697
1698 visit_type_str(v, name, &path, &local_err);
1699
1700 if (!local_err && strcmp(path, "") != 0) {
1701 new_target = object_resolve_link(obj, name, path, &local_err);
1702 }
1703
1704 g_free(path);
1705 if (local_err) {
1706 error_propagate(errp, local_err);
1707 return;
1708 }
1709
1710 prop->check(obj, name, new_target, &local_err);
1711 if (local_err) {
1712 error_propagate(errp, local_err);
1713 return;
1714 }
1715
1716 *child = new_target;
1717 if (prop->flags == OBJ_PROP_LINK_STRONG) {
1718 object_ref(new_target);
1719 object_unref(old_target);
1720 }
1721}
1722
1723static Object *object_resolve_link_property(Object *parent, void *opaque, const gchar *part)
1724{
1725 LinkProperty *lprop = opaque;
1726
1727 return *lprop->child;
1728}
1729
1730static void object_release_link_property(Object *obj, const char *name,
1731 void *opaque)
1732{
1733 LinkProperty *prop = opaque;
1734
1735 if ((prop->flags & OBJ_PROP_LINK_STRONG) && *prop->child) {
1736 object_unref(*prop->child);
1737 }
1738 g_free(prop);
1739}
1740
1741void 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,
1746 Error **errp)
1747{
1748 Error *local_err = NULL;
1749 LinkProperty *prop = g_malloc(sizeof(*prop));
1750 gchar *full_type;
1751 ObjectProperty *op;
1752
1753 prop->child = child;
1754 prop->check = check;
1755 prop->flags = flags;
1756
1757 full_type = g_strdup_printf("link<%s>", type);
1758
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,
1763 prop,
1764 &local_err);
1765 if (local_err) {
1766 error_propagate(errp, local_err);
1767 g_free(prop);
1768 goto out;
1769 }
1770
1771 op->resolve = object_resolve_link_property;
1772
1773out:
1774 g_free(full_type);
1775}
1776
1777void object_property_add_const_link(Object *obj, const char *name,
1778 Object *target, Error **errp)
1779{
1780 char *link_type;
1781 ObjectProperty *op;
1782
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);
1787 if (op != NULL) {
1788 op->resolve = object_resolve_child_property;
1789 }
1790 g_free(link_type);
1791}
1792
1793gchar *object_get_canonical_path_component(Object *obj)
1794{
1795 ObjectProperty *prop = NULL;
1796 GHashTableIter iter;
1797
1798 if (obj->parent == NULL) {
1799 return NULL;
1800 }
1801
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)) {
1805 continue;
1806 }
1807
1808 if (prop->opaque == obj) {
1809 return g_strdup(prop->name);
1810 }
1811 }
1812
1813
1814 g_assert_not_reached();
1815 return NULL;
1816}
1817
1818gchar *object_get_canonical_path(Object *obj)
1819{
1820 Object *root = object_get_root();
1821 char *newpath, *path = NULL;
1822
1823 if (obj == root) {
1824 return g_strdup("/");
1825 }
1826
1827 do {
1828 char *component = object_get_canonical_path_component(obj);
1829
1830 if (!component) {
1831
1832
1833
1834 g_free(path);
1835 return NULL;
1836 }
1837
1838 newpath = g_strdup_printf("/%s%s", component, path ? path : "");
1839 g_free(path);
1840 g_free(component);
1841 path = newpath;
1842 obj = obj->parent;
1843 } while (obj != root);
1844
1845 return path;
1846}
1847
1848Object *object_resolve_path_component(Object *parent, const gchar *part)
1849{
1850 ObjectProperty *prop = object_property_find(parent, part, NULL);
1851 if (prop == NULL) {
1852 return NULL;
1853 }
1854
1855 if (prop->resolve) {
1856 return prop->resolve(parent, prop->opaque, part);
1857 } else {
1858 return NULL;
1859 }
1860}
1861
1862static Object *object_resolve_abs_path(Object *parent,
1863 gchar **parts,
1864 const char *typename,
1865 int index)
1866{
1867 Object *child;
1868
1869 if (parts[index] == NULL) {
1870 return object_dynamic_cast(parent, typename);
1871 }
1872
1873 if (strcmp(parts[index], "") == 0) {
1874 return object_resolve_abs_path(parent, parts, typename, index + 1);
1875 }
1876
1877 child = object_resolve_path_component(parent, parts[index]);
1878 if (!child) {
1879 return NULL;
1880 }
1881
1882 return object_resolve_abs_path(child, parts, typename, index + 1);
1883}
1884
1885static Object *object_resolve_partial_path(Object *parent,
1886 gchar **parts,
1887 const char *typename,
1888 bool *ambiguous)
1889{
1890 Object *obj;
1891 GHashTableIter iter;
1892 ObjectProperty *prop;
1893
1894 obj = object_resolve_abs_path(parent, parts, typename, 0);
1895
1896 g_hash_table_iter_init(&iter, parent->properties);
1897 while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
1898 Object *found;
1899
1900 if (!object_property_is_child(prop)) {
1901 continue;
1902 }
1903
1904 found = object_resolve_partial_path(prop->opaque, parts,
1905 typename, ambiguous);
1906 if (found) {
1907 if (obj) {
1908 *ambiguous = true;
1909 return NULL;
1910 }
1911 obj = found;
1912 }
1913
1914 if (*ambiguous) {
1915 return NULL;
1916 }
1917 }
1918
1919 return obj;
1920}
1921
1922Object *object_resolve_path_type(const char *path, const char *typename,
1923 bool *ambiguousp)
1924{
1925 Object *obj;
1926 gchar **parts;
1927
1928 parts = g_strsplit(path, "/", 0);
1929 assert(parts);
1930
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);
1935 if (ambiguousp) {
1936 *ambiguousp = ambiguous;
1937 }
1938 } else {
1939 obj = object_resolve_abs_path(object_get_root(), parts, typename, 1);
1940 }
1941
1942 g_strfreev(parts);
1943
1944 return obj;
1945}
1946
1947Object *object_resolve_path(const char *path, bool *ambiguous)
1948{
1949 return object_resolve_path_type(path, TYPE_OBJECT, ambiguous);
1950}
1951
1952typedef struct StringProperty
1953{
1954 char *(*get)(Object *, Error **);
1955 void (*set)(Object *, const char *, Error **);
1956} StringProperty;
1957
1958static void property_get_str(Object *obj, Visitor *v, const char *name,
1959 void *opaque, Error **errp)
1960{
1961 StringProperty *prop = opaque;
1962 char *value;
1963 Error *err = NULL;
1964
1965 value = prop->get(obj, &err);
1966 if (err) {
1967 error_propagate(errp, err);
1968 return;
1969 }
1970
1971 visit_type_str(v, name, &value, errp);
1972 g_free(value);
1973}
1974
1975static void property_set_str(Object *obj, Visitor *v, const char *name,
1976 void *opaque, Error **errp)
1977{
1978 StringProperty *prop = opaque;
1979 char *value;
1980 Error *local_err = NULL;
1981
1982 visit_type_str(v, name, &value, &local_err);
1983 if (local_err) {
1984 error_propagate(errp, local_err);
1985 return;
1986 }
1987
1988 prop->set(obj, value, errp);
1989 g_free(value);
1990}
1991
1992static void property_release_str(Object *obj, const char *name,
1993 void *opaque)
1994{
1995 StringProperty *prop = opaque;
1996 g_free(prop);
1997}
1998
1999void object_property_add_str(Object *obj, const char *name,
2000 char *(*get)(Object *, Error **),
2001 void (*set)(Object *, const char *, Error **),
2002 Error **errp)
2003{
2004 Error *local_err = NULL;
2005 StringProperty *prop = g_malloc0(sizeof(*prop));
2006
2007 prop->get = get;
2008 prop->set = set;
2009
2010 object_property_add(obj, name, "string",
2011 get ? property_get_str : NULL,
2012 set ? property_set_str : NULL,
2013 property_release_str,
2014 prop, &local_err);
2015 if (local_err) {
2016 error_propagate(errp, local_err);
2017 g_free(prop);
2018 }
2019}
2020
2021void object_class_property_add_str(ObjectClass *klass, const char *name,
2022 char *(*get)(Object *, Error **),
2023 void (*set)(Object *, const char *,
2024 Error **),
2025 Error **errp)
2026{
2027 Error *local_err = NULL;
2028 StringProperty *prop = g_malloc0(sizeof(*prop));
2029
2030 prop->get = get;
2031 prop->set = set;
2032
2033 object_class_property_add(klass, name, "string",
2034 get ? property_get_str : NULL,
2035 set ? property_set_str : NULL,
2036 property_release_str,
2037 prop, &local_err);
2038 if (local_err) {
2039 error_propagate(errp, local_err);
2040 g_free(prop);
2041 }
2042}
2043
2044typedef struct BoolProperty
2045{
2046 bool (*get)(Object *, Error **);
2047 void (*set)(Object *, bool, Error **);
2048} BoolProperty;
2049
2050static void property_get_bool(Object *obj, Visitor *v, const char *name,
2051 void *opaque, Error **errp)
2052{
2053 BoolProperty *prop = opaque;
2054 bool value;
2055 Error *err = NULL;
2056
2057 value = prop->get(obj, &err);
2058 if (err) {
2059 error_propagate(errp, err);
2060 return;
2061 }
2062
2063 visit_type_bool(v, name, &value, errp);
2064}
2065
2066static void property_set_bool(Object *obj, Visitor *v, const char *name,
2067 void *opaque, Error **errp)
2068{
2069 BoolProperty *prop = opaque;
2070 bool value;
2071 Error *local_err = NULL;
2072
2073 visit_type_bool(v, name, &value, &local_err);
2074 if (local_err) {
2075 error_propagate(errp, local_err);
2076 return;
2077 }
2078
2079 prop->set(obj, value, errp);
2080}
2081
2082static void property_release_bool(Object *obj, const char *name,
2083 void *opaque)
2084{
2085 BoolProperty *prop = opaque;
2086 g_free(prop);
2087}
2088
2089void object_property_add_bool(Object *obj, const char *name,
2090 bool (*get)(Object *, Error **),
2091 void (*set)(Object *, bool, Error **),
2092 Error **errp)
2093{
2094 Error *local_err = NULL;
2095 BoolProperty *prop = g_malloc0(sizeof(*prop));
2096
2097 prop->get = get;
2098 prop->set = set;
2099
2100 object_property_add(obj, name, "bool",
2101 get ? property_get_bool : NULL,
2102 set ? property_set_bool : NULL,
2103 property_release_bool,
2104 prop, &local_err);
2105 if (local_err) {
2106 error_propagate(errp, local_err);
2107 g_free(prop);
2108 }
2109}
2110
2111void object_class_property_add_bool(ObjectClass *klass, const char *name,
2112 bool (*get)(Object *, Error **),
2113 void (*set)(Object *, bool, Error **),
2114 Error **errp)
2115{
2116 Error *local_err = NULL;
2117 BoolProperty *prop = g_malloc0(sizeof(*prop));
2118
2119 prop->get = get;
2120 prop->set = set;
2121
2122 object_class_property_add(klass, name, "bool",
2123 get ? property_get_bool : NULL,
2124 set ? property_set_bool : NULL,
2125 property_release_bool,
2126 prop, &local_err);
2127 if (local_err) {
2128 error_propagate(errp, local_err);
2129 g_free(prop);
2130 }
2131}
2132
2133static void property_get_enum(Object *obj, Visitor *v, const char *name,
2134 void *opaque, Error **errp)
2135{
2136 EnumProperty *prop = opaque;
2137 int value;
2138 Error *err = NULL;
2139
2140 value = prop->get(obj, &err);
2141 if (err) {
2142 error_propagate(errp, err);
2143 return;
2144 }
2145
2146 visit_type_enum(v, name, &value, prop->lookup, errp);
2147}
2148
2149static void property_set_enum(Object *obj, Visitor *v, const char *name,
2150 void *opaque, Error **errp)
2151{
2152 EnumProperty *prop = opaque;
2153 int value;
2154 Error *err = NULL;
2155
2156 visit_type_enum(v, name, &value, prop->lookup, &err);
2157 if (err) {
2158 error_propagate(errp, err);
2159 return;
2160 }
2161 prop->set(obj, value, errp);
2162}
2163
2164static void property_release_enum(Object *obj, const char *name,
2165 void *opaque)
2166{
2167 EnumProperty *prop = opaque;
2168 g_free(prop);
2169}
2170
2171void 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 **),
2176 Error **errp)
2177{
2178 Error *local_err = NULL;
2179 EnumProperty *prop = g_malloc(sizeof(*prop));
2180
2181 prop->lookup = lookup;
2182 prop->get = get;
2183 prop->set = set;
2184
2185 object_property_add(obj, name, typename,
2186 get ? property_get_enum : NULL,
2187 set ? property_set_enum : NULL,
2188 property_release_enum,
2189 prop, &local_err);
2190 if (local_err) {
2191 error_propagate(errp, local_err);
2192 g_free(prop);
2193 }
2194}
2195
2196void 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 **),
2201 Error **errp)
2202{
2203 Error *local_err = NULL;
2204 EnumProperty *prop = g_malloc(sizeof(*prop));
2205
2206 prop->lookup = lookup;
2207 prop->get = get;
2208 prop->set = set;
2209
2210 object_class_property_add(klass, name, typename,
2211 get ? property_get_enum : NULL,
2212 set ? property_set_enum : NULL,
2213 property_release_enum,
2214 prop, &local_err);
2215 if (local_err) {
2216 error_propagate(errp, local_err);
2217 g_free(prop);
2218 }
2219}
2220
2221typedef struct TMProperty {
2222 void (*get)(Object *, struct tm *, Error **);
2223} TMProperty;
2224
2225static void property_get_tm(Object *obj, Visitor *v, const char *name,
2226 void *opaque, Error **errp)
2227{
2228 TMProperty *prop = opaque;
2229 Error *err = NULL;
2230 struct tm value;
2231
2232 prop->get(obj, &value, &err);
2233 if (err) {
2234 goto out;
2235 }
2236
2237 visit_start_struct(v, name, NULL, 0, &err);
2238 if (err) {
2239 goto out;
2240 }
2241 visit_type_int32(v, "tm_year", &value.tm_year, &err);
2242 if (err) {
2243 goto out_end;
2244 }
2245 visit_type_int32(v, "tm_mon", &value.tm_mon, &err);
2246 if (err) {
2247 goto out_end;
2248 }
2249 visit_type_int32(v, "tm_mday", &value.tm_mday, &err);
2250 if (err) {
2251 goto out_end;
2252 }
2253 visit_type_int32(v, "tm_hour", &value.tm_hour, &err);
2254 if (err) {
2255 goto out_end;
2256 }
2257 visit_type_int32(v, "tm_min", &value.tm_min, &err);
2258 if (err) {
2259 goto out_end;
2260 }
2261 visit_type_int32(v, "tm_sec", &value.tm_sec, &err);
2262 if (err) {
2263 goto out_end;
2264 }
2265 visit_check_struct(v, &err);
2266out_end:
2267 visit_end_struct(v, NULL);
2268out:
2269 error_propagate(errp, err);
2270
2271}
2272
2273static void property_release_tm(Object *obj, const char *name,
2274 void *opaque)
2275{
2276 TMProperty *prop = opaque;
2277 g_free(prop);
2278}
2279
2280void object_property_add_tm(Object *obj, const char *name,
2281 void (*get)(Object *, struct tm *, Error **),
2282 Error **errp)
2283{
2284 Error *local_err = NULL;
2285 TMProperty *prop = g_malloc0(sizeof(*prop));
2286
2287 prop->get = get;
2288
2289 object_property_add(obj, name, "struct tm",
2290 get ? property_get_tm : NULL, NULL,
2291 property_release_tm,
2292 prop, &local_err);
2293 if (local_err) {
2294 error_propagate(errp, local_err);
2295 g_free(prop);
2296 }
2297}
2298
2299void object_class_property_add_tm(ObjectClass *klass, const char *name,
2300 void (*get)(Object *, struct tm *, Error **),
2301 Error **errp)
2302{
2303 Error *local_err = NULL;
2304 TMProperty *prop = g_malloc0(sizeof(*prop));
2305
2306 prop->get = get;
2307
2308 object_class_property_add(klass, name, "struct tm",
2309 get ? property_get_tm : NULL, NULL,
2310 property_release_tm,
2311 prop, &local_err);
2312 if (local_err) {
2313 error_propagate(errp, local_err);
2314 g_free(prop);
2315 }
2316}
2317
2318static char *qdev_get_type(Object *obj, Error **errp)
2319{
2320 return g_strdup(object_get_typename(obj));
2321}
2322
2323static void property_get_uint8_ptr(Object *obj, Visitor *v, const char *name,
2324 void *opaque, Error **errp)
2325{
2326 uint8_t value = *(uint8_t *)opaque;
2327 visit_type_uint8(v, name, &value, errp);
2328}
2329
2330static void property_get_uint16_ptr(Object *obj, Visitor *v, const char *name,
2331 void *opaque, Error **errp)
2332{
2333 uint16_t value = *(uint16_t *)opaque;
2334 visit_type_uint16(v, name, &value, errp);
2335}
2336
2337static void property_get_uint32_ptr(Object *obj, Visitor *v, const char *name,
2338 void *opaque, Error **errp)
2339{
2340 uint32_t value = *(uint32_t *)opaque;
2341 visit_type_uint32(v, name, &value, errp);
2342}
2343
2344static void property_get_uint64_ptr(Object *obj, Visitor *v, const char *name,
2345 void *opaque, Error **errp)
2346{
2347 uint64_t value = *(uint64_t *)opaque;
2348 visit_type_uint64(v, name, &value, errp);
2349}
2350
2351void object_property_add_uint8_ptr(Object *obj, const char *name,
2352 const uint8_t *v, Error **errp)
2353{
2354 object_property_add(obj, name, "uint8", property_get_uint8_ptr,
2355 NULL, NULL, (void *)v, errp);
2356}
2357
2358void object_class_property_add_uint8_ptr(ObjectClass *klass, const char *name,
2359 const uint8_t *v, Error **errp)
2360{
2361 object_class_property_add(klass, name, "uint8", property_get_uint8_ptr,
2362 NULL, NULL, (void *)v, errp);
2363}
2364
2365void object_property_add_uint16_ptr(Object *obj, const char *name,
2366 const uint16_t *v, Error **errp)
2367{
2368 object_property_add(obj, name, "uint16", property_get_uint16_ptr,
2369 NULL, NULL, (void *)v, errp);
2370}
2371
2372void object_class_property_add_uint16_ptr(ObjectClass *klass, const char *name,
2373 const uint16_t *v, Error **errp)
2374{
2375 object_class_property_add(klass, name, "uint16", property_get_uint16_ptr,
2376 NULL, NULL, (void *)v, errp);
2377}
2378
2379void object_property_add_uint32_ptr(Object *obj, const char *name,
2380 const uint32_t *v, Error **errp)
2381{
2382 object_property_add(obj, name, "uint32", property_get_uint32_ptr,
2383 NULL, NULL, (void *)v, errp);
2384}
2385
2386void object_class_property_add_uint32_ptr(ObjectClass *klass, const char *name,
2387 const uint32_t *v, Error **errp)
2388{
2389 object_class_property_add(klass, name, "uint32", property_get_uint32_ptr,
2390 NULL, NULL, (void *)v, errp);
2391}
2392
2393void object_property_add_uint64_ptr(Object *obj, const char *name,
2394 const uint64_t *v, Error **errp)
2395{
2396 object_property_add(obj, name, "uint64", property_get_uint64_ptr,
2397 NULL, NULL, (void *)v, errp);
2398}
2399
2400void object_class_property_add_uint64_ptr(ObjectClass *klass, const char *name,
2401 const uint64_t *v, Error **errp)
2402{
2403 object_class_property_add(klass, name, "uint64", property_get_uint64_ptr,
2404 NULL, NULL, (void *)v, errp);
2405}
2406
2407typedef struct {
2408 Object *target_obj;
2409 char *target_name;
2410} AliasProperty;
2411
2412static void property_get_alias(Object *obj, Visitor *v, const char *name,
2413 void *opaque, Error **errp)
2414{
2415 AliasProperty *prop = opaque;
2416
2417 object_property_get(prop->target_obj, v, prop->target_name, errp);
2418}
2419
2420static void property_set_alias(Object *obj, Visitor *v, const char *name,
2421 void *opaque, Error **errp)
2422{
2423 AliasProperty *prop = opaque;
2424
2425 object_property_set(prop->target_obj, v, prop->target_name, errp);
2426}
2427
2428static Object *property_resolve_alias(Object *obj, void *opaque,
2429 const gchar *part)
2430{
2431 AliasProperty *prop = opaque;
2432
2433 return object_resolve_path_component(prop->target_obj, prop->target_name);
2434}
2435
2436static void property_release_alias(Object *obj, const char *name, void *opaque)
2437{
2438 AliasProperty *prop = opaque;
2439
2440 g_free(prop->target_name);
2441 g_free(prop);
2442}
2443
2444void object_property_add_alias(Object *obj, const char *name,
2445 Object *target_obj, const char *target_name,
2446 Error **errp)
2447{
2448 AliasProperty *prop;
2449 ObjectProperty *op;
2450 ObjectProperty *target_prop;
2451 gchar *prop_type;
2452 Error *local_err = NULL;
2453
2454 target_prop = object_property_find(target_obj, target_name, errp);
2455 if (!target_prop) {
2456 return;
2457 }
2458
2459 if (object_property_is_child(target_prop)) {
2460 prop_type = g_strdup_printf("link%s",
2461 target_prop->type + strlen("child"));
2462 } else {
2463 prop_type = g_strdup(target_prop->type);
2464 }
2465
2466 prop = g_malloc(sizeof(*prop));
2467 prop->target_obj = target_obj;
2468 prop->target_name = g_strdup(target_name);
2469
2470 op = object_property_add(obj, name, prop_type,
2471 property_get_alias,
2472 property_set_alias,
2473 property_release_alias,
2474 prop, &local_err);
2475 if (local_err) {
2476 error_propagate(errp, local_err);
2477 g_free(prop);
2478 goto out;
2479 }
2480 op->resolve = property_resolve_alias;
2481
2482 object_property_set_description(obj, op->name,
2483 target_prop->description,
2484 &error_abort);
2485
2486out:
2487 g_free(prop_type);
2488}
2489
2490void object_property_set_description(Object *obj, const char *name,
2491 const char *description, Error **errp)
2492{
2493 ObjectProperty *op;
2494
2495 op = object_property_find(obj, name, errp);
2496 if (!op) {
2497 return;
2498 }
2499
2500 g_free(op->description);
2501 op->description = g_strdup(description);
2502}
2503
2504void object_class_property_set_description(ObjectClass *klass,
2505 const char *name,
2506 const char *description,
2507 Error **errp)
2508{
2509 ObjectProperty *op;
2510
2511 op = g_hash_table_lookup(klass->properties, name);
2512 if (!op) {
2513 error_setg(errp, "Property '.%s' not found", name);
2514 return;
2515 }
2516
2517 g_free(op->description);
2518 op->description = g_strdup(description);
2519}
2520
2521static void object_class_init(ObjectClass *klass, void *data)
2522{
2523 object_class_property_add_str(klass, "type", qdev_get_type,
2524 NULL, &error_abort);
2525}
2526
2527static void register_types(void)
2528{
2529 static TypeInfo interface_info = {
2530 .name = TYPE_INTERFACE,
2531 .class_size = sizeof(InterfaceClass),
2532 .abstract = true,
2533 };
2534
2535 static TypeInfo object_info = {
2536 .name = TYPE_OBJECT,
2537 .instance_size = sizeof(Object),
2538 .class_init = object_class_init,
2539 .abstract = true,
2540 };
2541
2542 type_interface = type_register_internal(&interface_info);
2543 type_register_internal(&object_info);
2544}
2545
2546type_init(register_types)
2547