qom: Add check() argument to object_property_add_link()
[qemu.git] / qom / object.c
1 /*
2 * QEMU Object Model
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
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.
11 */
12
13 #include "qom/object.h"
14 #include "qemu-common.h"
15 #include "qapi/visitor.h"
16 #include "qapi/string-input-visitor.h"
17 #include "qapi/string-output-visitor.h"
18 #include "qapi/qmp/qerror.h"
19 #include "trace.h"
20
21 /* TODO: replace QObject with a simpler visitor to avoid a dependency
22 * of the QOM core on QObject? */
23 #include "qom/qom-qobject.h"
24 #include "qapi/qmp/qobject.h"
25 #include "qapi/qmp/qbool.h"
26 #include "qapi/qmp/qint.h"
27 #include "qapi/qmp/qstring.h"
28
29 #define MAX_INTERFACES 32
30
31 typedef struct InterfaceImpl InterfaceImpl;
32 typedef struct TypeImpl TypeImpl;
33
34 struct InterfaceImpl
35 {
36 const char *typename;
37 };
38
39 struct TypeImpl
40 {
41 const char *name;
42
43 size_t class_size;
44
45 size_t instance_size;
46
47 void (*class_init)(ObjectClass *klass, void *data);
48 void (*class_base_init)(ObjectClass *klass, void *data);
49 void (*class_finalize)(ObjectClass *klass, void *data);
50
51 void *class_data;
52
53 void (*instance_init)(Object *obj);
54 void (*instance_post_init)(Object *obj);
55 void (*instance_finalize)(Object *obj);
56
57 bool abstract;
58
59 const char *parent;
60 TypeImpl *parent_type;
61
62 ObjectClass *class;
63
64 int num_interfaces;
65 InterfaceImpl interfaces[MAX_INTERFACES];
66 };
67
68 static Type type_interface;
69
70 static GHashTable *type_table_get(void)
71 {
72 static GHashTable *type_table;
73
74 if (type_table == NULL) {
75 type_table = g_hash_table_new(g_str_hash, g_str_equal);
76 }
77
78 return type_table;
79 }
80
81 static bool enumerating_types;
82
83 static void type_table_add(TypeImpl *ti)
84 {
85 assert(!enumerating_types);
86 g_hash_table_insert(type_table_get(), (void *)ti->name, ti);
87 }
88
89 static TypeImpl *type_table_lookup(const char *name)
90 {
91 return g_hash_table_lookup(type_table_get(), name);
92 }
93
94 static TypeImpl *type_new(const TypeInfo *info)
95 {
96 TypeImpl *ti = g_malloc0(sizeof(*ti));
97 int i;
98
99 g_assert(info->name != NULL);
100
101 if (type_table_lookup(info->name) != NULL) {
102 fprintf(stderr, "Registering `%s' which already exists\n", info->name);
103 abort();
104 }
105
106 ti->name = g_strdup(info->name);
107 ti->parent = g_strdup(info->parent);
108
109 ti->class_size = info->class_size;
110 ti->instance_size = info->instance_size;
111
112 ti->class_init = info->class_init;
113 ti->class_base_init = info->class_base_init;
114 ti->class_finalize = info->class_finalize;
115 ti->class_data = info->class_data;
116
117 ti->instance_init = info->instance_init;
118 ti->instance_post_init = info->instance_post_init;
119 ti->instance_finalize = info->instance_finalize;
120
121 ti->abstract = info->abstract;
122
123 for (i = 0; info->interfaces && info->interfaces[i].type; i++) {
124 ti->interfaces[i].typename = g_strdup(info->interfaces[i].type);
125 }
126 ti->num_interfaces = i;
127
128 return ti;
129 }
130
131 static TypeImpl *type_register_internal(const TypeInfo *info)
132 {
133 TypeImpl *ti;
134 ti = type_new(info);
135
136 type_table_add(ti);
137 return ti;
138 }
139
140 TypeImpl *type_register(const TypeInfo *info)
141 {
142 assert(info->parent);
143 return type_register_internal(info);
144 }
145
146 TypeImpl *type_register_static(const TypeInfo *info)
147 {
148 return type_register(info);
149 }
150
151 static TypeImpl *type_get_by_name(const char *name)
152 {
153 if (name == NULL) {
154 return NULL;
155 }
156
157 return type_table_lookup(name);
158 }
159
160 static TypeImpl *type_get_parent(TypeImpl *type)
161 {
162 if (!type->parent_type && type->parent) {
163 type->parent_type = type_get_by_name(type->parent);
164 g_assert(type->parent_type != NULL);
165 }
166
167 return type->parent_type;
168 }
169
170 static bool type_has_parent(TypeImpl *type)
171 {
172 return (type->parent != NULL);
173 }
174
175 static size_t type_class_get_size(TypeImpl *ti)
176 {
177 if (ti->class_size) {
178 return ti->class_size;
179 }
180
181 if (type_has_parent(ti)) {
182 return type_class_get_size(type_get_parent(ti));
183 }
184
185 return sizeof(ObjectClass);
186 }
187
188 static size_t type_object_get_size(TypeImpl *ti)
189 {
190 if (ti->instance_size) {
191 return ti->instance_size;
192 }
193
194 if (type_has_parent(ti)) {
195 return type_object_get_size(type_get_parent(ti));
196 }
197
198 return 0;
199 }
200
201 static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type)
202 {
203 assert(target_type);
204
205 /* Check if typename is a direct ancestor of type */
206 while (type) {
207 if (type == target_type) {
208 return true;
209 }
210
211 type = type_get_parent(type);
212 }
213
214 return false;
215 }
216
217 static void type_initialize(TypeImpl *ti);
218
219 static void type_initialize_interface(TypeImpl *ti, TypeImpl *interface_type,
220 TypeImpl *parent_type)
221 {
222 InterfaceClass *new_iface;
223 TypeInfo info = { };
224 TypeImpl *iface_impl;
225
226 info.parent = parent_type->name;
227 info.name = g_strdup_printf("%s::%s", ti->name, interface_type->name);
228 info.abstract = true;
229
230 iface_impl = type_new(&info);
231 iface_impl->parent_type = parent_type;
232 type_initialize(iface_impl);
233 g_free((char *)info.name);
234
235 new_iface = (InterfaceClass *)iface_impl->class;
236 new_iface->concrete_class = ti->class;
237 new_iface->interface_type = interface_type;
238
239 ti->class->interfaces = g_slist_append(ti->class->interfaces,
240 iface_impl->class);
241 }
242
243 static void type_initialize(TypeImpl *ti)
244 {
245 TypeImpl *parent;
246
247 if (ti->class) {
248 return;
249 }
250
251 ti->class_size = type_class_get_size(ti);
252 ti->instance_size = type_object_get_size(ti);
253
254 ti->class = g_malloc0(ti->class_size);
255
256 parent = type_get_parent(ti);
257 if (parent) {
258 type_initialize(parent);
259 GSList *e;
260 int i;
261
262 g_assert(parent->class_size <= ti->class_size);
263 memcpy(ti->class, parent->class, parent->class_size);
264 ti->class->interfaces = NULL;
265
266 for (e = parent->class->interfaces; e; e = e->next) {
267 InterfaceClass *iface = e->data;
268 ObjectClass *klass = OBJECT_CLASS(iface);
269
270 type_initialize_interface(ti, iface->interface_type, klass->type);
271 }
272
273 for (i = 0; i < ti->num_interfaces; i++) {
274 TypeImpl *t = type_get_by_name(ti->interfaces[i].typename);
275 for (e = ti->class->interfaces; e; e = e->next) {
276 TypeImpl *target_type = OBJECT_CLASS(e->data)->type;
277
278 if (type_is_ancestor(target_type, t)) {
279 break;
280 }
281 }
282
283 if (e) {
284 continue;
285 }
286
287 type_initialize_interface(ti, t, t);
288 }
289 }
290
291 ti->class->type = ti;
292
293 while (parent) {
294 if (parent->class_base_init) {
295 parent->class_base_init(ti->class, ti->class_data);
296 }
297 parent = type_get_parent(parent);
298 }
299
300 if (ti->class_init) {
301 ti->class_init(ti->class, ti->class_data);
302 }
303 }
304
305 static void object_init_with_type(Object *obj, TypeImpl *ti)
306 {
307 if (type_has_parent(ti)) {
308 object_init_with_type(obj, type_get_parent(ti));
309 }
310
311 if (ti->instance_init) {
312 ti->instance_init(obj);
313 }
314 }
315
316 static void object_post_init_with_type(Object *obj, TypeImpl *ti)
317 {
318 if (ti->instance_post_init) {
319 ti->instance_post_init(obj);
320 }
321
322 if (type_has_parent(ti)) {
323 object_post_init_with_type(obj, type_get_parent(ti));
324 }
325 }
326
327 void object_initialize_with_type(void *data, size_t size, TypeImpl *type)
328 {
329 Object *obj = data;
330
331 g_assert(type != NULL);
332 type_initialize(type);
333
334 g_assert(type->instance_size >= sizeof(Object));
335 g_assert(type->abstract == false);
336 g_assert(size >= type->instance_size);
337
338 memset(obj, 0, type->instance_size);
339 obj->class = type->class;
340 object_ref(obj);
341 QTAILQ_INIT(&obj->properties);
342 object_init_with_type(obj, type);
343 object_post_init_with_type(obj, type);
344 }
345
346 void object_initialize(void *data, size_t size, const char *typename)
347 {
348 TypeImpl *type = type_get_by_name(typename);
349
350 object_initialize_with_type(data, size, type);
351 }
352
353 static inline bool object_property_is_child(ObjectProperty *prop)
354 {
355 return strstart(prop->type, "child<", NULL);
356 }
357
358 static inline bool object_property_is_link(ObjectProperty *prop)
359 {
360 return strstart(prop->type, "link<", NULL);
361 }
362
363 static void object_property_del_all(Object *obj)
364 {
365 while (!QTAILQ_EMPTY(&obj->properties)) {
366 ObjectProperty *prop = QTAILQ_FIRST(&obj->properties);
367
368 QTAILQ_REMOVE(&obj->properties, prop, node);
369
370 if (prop->release) {
371 prop->release(obj, prop->name, prop->opaque);
372 }
373
374 g_free(prop->name);
375 g_free(prop->type);
376 g_free(prop);
377 }
378 }
379
380 static void object_property_del_child(Object *obj, Object *child, Error **errp)
381 {
382 ObjectProperty *prop;
383
384 QTAILQ_FOREACH(prop, &obj->properties, node) {
385 if (object_property_is_child(prop) && prop->opaque == child) {
386 object_property_del(obj, prop->name, errp);
387 break;
388 }
389 }
390 }
391
392 void object_unparent(Object *obj)
393 {
394 if (!obj->parent) {
395 return;
396 }
397
398 object_ref(obj);
399 if (obj->class->unparent) {
400 (obj->class->unparent)(obj);
401 }
402 if (obj->parent) {
403 object_property_del_child(obj->parent, obj, NULL);
404 }
405 object_unref(obj);
406 }
407
408 static void object_deinit(Object *obj, TypeImpl *type)
409 {
410 if (type->instance_finalize) {
411 type->instance_finalize(obj);
412 }
413
414 if (type_has_parent(type)) {
415 object_deinit(obj, type_get_parent(type));
416 }
417 }
418
419 static void object_finalize(void *data)
420 {
421 Object *obj = data;
422 TypeImpl *ti = obj->class->type;
423
424 object_deinit(obj, ti);
425 object_property_del_all(obj);
426
427 g_assert(obj->ref == 0);
428 if (obj->free) {
429 obj->free(obj);
430 }
431 }
432
433 Object *object_new_with_type(Type type)
434 {
435 Object *obj;
436
437 g_assert(type != NULL);
438 type_initialize(type);
439
440 obj = g_malloc(type->instance_size);
441 object_initialize_with_type(obj, type->instance_size, type);
442 obj->free = g_free;
443
444 return obj;
445 }
446
447 Object *object_new(const char *typename)
448 {
449 TypeImpl *ti = type_get_by_name(typename);
450
451 return object_new_with_type(ti);
452 }
453
454 Object *object_dynamic_cast(Object *obj, const char *typename)
455 {
456 if (obj && object_class_dynamic_cast(object_get_class(obj), typename)) {
457 return obj;
458 }
459
460 return NULL;
461 }
462
463 Object *object_dynamic_cast_assert(Object *obj, const char *typename,
464 const char *file, int line, const char *func)
465 {
466 trace_object_dynamic_cast_assert(obj ? obj->class->type->name : "(null)",
467 typename, file, line, func);
468
469 #ifdef CONFIG_QOM_CAST_DEBUG
470 int i;
471 Object *inst;
472
473 for (i = 0; obj && i < OBJECT_CLASS_CAST_CACHE; i++) {
474 if (obj->class->object_cast_cache[i] == typename) {
475 goto out;
476 }
477 }
478
479 inst = object_dynamic_cast(obj, typename);
480
481 if (!inst && obj) {
482 fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
483 file, line, func, obj, typename);
484 abort();
485 }
486
487 assert(obj == inst);
488
489 if (obj && obj == inst) {
490 for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
491 obj->class->object_cast_cache[i - 1] =
492 obj->class->object_cast_cache[i];
493 }
494 obj->class->object_cast_cache[i - 1] = typename;
495 }
496
497 out:
498 #endif
499 return obj;
500 }
501
502 ObjectClass *object_class_dynamic_cast(ObjectClass *class,
503 const char *typename)
504 {
505 ObjectClass *ret = NULL;
506 TypeImpl *target_type;
507 TypeImpl *type;
508
509 if (!class) {
510 return NULL;
511 }
512
513 /* A simple fast path that can trigger a lot for leaf classes. */
514 type = class->type;
515 if (type->name == typename) {
516 return class;
517 }
518
519 target_type = type_get_by_name(typename);
520 if (!target_type) {
521 /* target class type unknown, so fail the cast */
522 return NULL;
523 }
524
525 if (type->class->interfaces &&
526 type_is_ancestor(target_type, type_interface)) {
527 int found = 0;
528 GSList *i;
529
530 for (i = class->interfaces; i; i = i->next) {
531 ObjectClass *target_class = i->data;
532
533 if (type_is_ancestor(target_class->type, target_type)) {
534 ret = target_class;
535 found++;
536 }
537 }
538
539 /* The match was ambiguous, don't allow a cast */
540 if (found > 1) {
541 ret = NULL;
542 }
543 } else if (type_is_ancestor(type, target_type)) {
544 ret = class;
545 }
546
547 return ret;
548 }
549
550 ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class,
551 const char *typename,
552 const char *file, int line,
553 const char *func)
554 {
555 ObjectClass *ret;
556
557 trace_object_class_dynamic_cast_assert(class ? class->type->name : "(null)",
558 typename, file, line, func);
559
560 #ifdef CONFIG_QOM_CAST_DEBUG
561 int i;
562
563 for (i = 0; class && i < OBJECT_CLASS_CAST_CACHE; i++) {
564 if (class->class_cast_cache[i] == typename) {
565 ret = class;
566 goto out;
567 }
568 }
569 #else
570 if (!class || !class->interfaces) {
571 return class;
572 }
573 #endif
574
575 ret = object_class_dynamic_cast(class, typename);
576 if (!ret && class) {
577 fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
578 file, line, func, class, typename);
579 abort();
580 }
581
582 #ifdef CONFIG_QOM_CAST_DEBUG
583 if (class && ret == class) {
584 for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
585 class->class_cast_cache[i - 1] = class->class_cast_cache[i];
586 }
587 class->class_cast_cache[i - 1] = typename;
588 }
589 out:
590 #endif
591 return ret;
592 }
593
594 const char *object_get_typename(Object *obj)
595 {
596 return obj->class->type->name;
597 }
598
599 ObjectClass *object_get_class(Object *obj)
600 {
601 return obj->class;
602 }
603
604 bool object_class_is_abstract(ObjectClass *klass)
605 {
606 return klass->type->abstract;
607 }
608
609 const char *object_class_get_name(ObjectClass *klass)
610 {
611 return klass->type->name;
612 }
613
614 ObjectClass *object_class_by_name(const char *typename)
615 {
616 TypeImpl *type = type_get_by_name(typename);
617
618 if (!type) {
619 return NULL;
620 }
621
622 type_initialize(type);
623
624 return type->class;
625 }
626
627 ObjectClass *object_class_get_parent(ObjectClass *class)
628 {
629 TypeImpl *type = type_get_parent(class->type);
630
631 if (!type) {
632 return NULL;
633 }
634
635 type_initialize(type);
636
637 return type->class;
638 }
639
640 typedef struct OCFData
641 {
642 void (*fn)(ObjectClass *klass, void *opaque);
643 const char *implements_type;
644 bool include_abstract;
645 void *opaque;
646 } OCFData;
647
648 static void object_class_foreach_tramp(gpointer key, gpointer value,
649 gpointer opaque)
650 {
651 OCFData *data = opaque;
652 TypeImpl *type = value;
653 ObjectClass *k;
654
655 type_initialize(type);
656 k = type->class;
657
658 if (!data->include_abstract && type->abstract) {
659 return;
660 }
661
662 if (data->implements_type &&
663 !object_class_dynamic_cast(k, data->implements_type)) {
664 return;
665 }
666
667 data->fn(k, data->opaque);
668 }
669
670 void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque),
671 const char *implements_type, bool include_abstract,
672 void *opaque)
673 {
674 OCFData data = { fn, implements_type, include_abstract, opaque };
675
676 enumerating_types = true;
677 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data);
678 enumerating_types = false;
679 }
680
681 int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque),
682 void *opaque)
683 {
684 ObjectProperty *prop;
685 int ret = 0;
686
687 QTAILQ_FOREACH(prop, &obj->properties, node) {
688 if (object_property_is_child(prop)) {
689 ret = fn(prop->opaque, opaque);
690 if (ret != 0) {
691 break;
692 }
693 }
694 }
695 return ret;
696 }
697
698 static void object_class_get_list_tramp(ObjectClass *klass, void *opaque)
699 {
700 GSList **list = opaque;
701
702 *list = g_slist_prepend(*list, klass);
703 }
704
705 GSList *object_class_get_list(const char *implements_type,
706 bool include_abstract)
707 {
708 GSList *list = NULL;
709
710 object_class_foreach(object_class_get_list_tramp,
711 implements_type, include_abstract, &list);
712 return list;
713 }
714
715 void object_ref(Object *obj)
716 {
717 atomic_inc(&obj->ref);
718 }
719
720 void object_unref(Object *obj)
721 {
722 g_assert(obj->ref > 0);
723
724 /* parent always holds a reference to its children */
725 if (atomic_fetch_dec(&obj->ref) == 1) {
726 object_finalize(obj);
727 }
728 }
729
730 void object_property_add(Object *obj, const char *name, const char *type,
731 ObjectPropertyAccessor *get,
732 ObjectPropertyAccessor *set,
733 ObjectPropertyRelease *release,
734 void *opaque, Error **errp)
735 {
736 ObjectProperty *prop;
737
738 QTAILQ_FOREACH(prop, &obj->properties, node) {
739 if (strcmp(prop->name, name) == 0) {
740 error_setg(errp, "attempt to add duplicate property '%s'"
741 " to object (type '%s')", name,
742 object_get_typename(obj));
743 return;
744 }
745 }
746
747 prop = g_malloc0(sizeof(*prop));
748
749 prop->name = g_strdup(name);
750 prop->type = g_strdup(type);
751
752 prop->get = get;
753 prop->set = set;
754 prop->release = release;
755 prop->opaque = opaque;
756
757 QTAILQ_INSERT_TAIL(&obj->properties, prop, node);
758 }
759
760 ObjectProperty *object_property_find(Object *obj, const char *name,
761 Error **errp)
762 {
763 ObjectProperty *prop;
764
765 QTAILQ_FOREACH(prop, &obj->properties, node) {
766 if (strcmp(prop->name, name) == 0) {
767 return prop;
768 }
769 }
770
771 error_set(errp, QERR_PROPERTY_NOT_FOUND, "", name);
772 return NULL;
773 }
774
775 void object_property_del(Object *obj, const char *name, Error **errp)
776 {
777 ObjectProperty *prop = object_property_find(obj, name, errp);
778 if (prop == NULL) {
779 return;
780 }
781
782 if (prop->release) {
783 prop->release(obj, name, prop->opaque);
784 }
785
786 QTAILQ_REMOVE(&obj->properties, prop, node);
787
788 g_free(prop->name);
789 g_free(prop->type);
790 g_free(prop);
791 }
792
793 void object_property_get(Object *obj, Visitor *v, const char *name,
794 Error **errp)
795 {
796 ObjectProperty *prop = object_property_find(obj, name, errp);
797 if (prop == NULL) {
798 return;
799 }
800
801 if (!prop->get) {
802 error_set(errp, QERR_PERMISSION_DENIED);
803 } else {
804 prop->get(obj, v, prop->opaque, name, errp);
805 }
806 }
807
808 void object_property_set(Object *obj, Visitor *v, const char *name,
809 Error **errp)
810 {
811 ObjectProperty *prop = object_property_find(obj, name, errp);
812 if (prop == NULL) {
813 return;
814 }
815
816 if (!prop->set) {
817 error_set(errp, QERR_PERMISSION_DENIED);
818 } else {
819 prop->set(obj, v, prop->opaque, name, errp);
820 }
821 }
822
823 void object_property_set_str(Object *obj, const char *value,
824 const char *name, Error **errp)
825 {
826 QString *qstr = qstring_from_str(value);
827 object_property_set_qobject(obj, QOBJECT(qstr), name, errp);
828
829 QDECREF(qstr);
830 }
831
832 char *object_property_get_str(Object *obj, const char *name,
833 Error **errp)
834 {
835 QObject *ret = object_property_get_qobject(obj, name, errp);
836 QString *qstring;
837 char *retval;
838
839 if (!ret) {
840 return NULL;
841 }
842 qstring = qobject_to_qstring(ret);
843 if (!qstring) {
844 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
845 retval = NULL;
846 } else {
847 retval = g_strdup(qstring_get_str(qstring));
848 }
849
850 QDECREF(qstring);
851 return retval;
852 }
853
854 void object_property_set_link(Object *obj, Object *value,
855 const char *name, Error **errp)
856 {
857 gchar *path = object_get_canonical_path(value);
858 object_property_set_str(obj, path, name, errp);
859 g_free(path);
860 }
861
862 Object *object_property_get_link(Object *obj, const char *name,
863 Error **errp)
864 {
865 char *str = object_property_get_str(obj, name, errp);
866 Object *target = NULL;
867
868 if (str && *str) {
869 target = object_resolve_path(str, NULL);
870 if (!target) {
871 error_set(errp, QERR_DEVICE_NOT_FOUND, str);
872 }
873 }
874
875 g_free(str);
876 return target;
877 }
878
879 void object_property_set_bool(Object *obj, bool value,
880 const char *name, Error **errp)
881 {
882 QBool *qbool = qbool_from_int(value);
883 object_property_set_qobject(obj, QOBJECT(qbool), name, errp);
884
885 QDECREF(qbool);
886 }
887
888 bool object_property_get_bool(Object *obj, const char *name,
889 Error **errp)
890 {
891 QObject *ret = object_property_get_qobject(obj, name, errp);
892 QBool *qbool;
893 bool retval;
894
895 if (!ret) {
896 return false;
897 }
898 qbool = qobject_to_qbool(ret);
899 if (!qbool) {
900 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean");
901 retval = false;
902 } else {
903 retval = qbool_get_int(qbool);
904 }
905
906 QDECREF(qbool);
907 return retval;
908 }
909
910 void object_property_set_int(Object *obj, int64_t value,
911 const char *name, Error **errp)
912 {
913 QInt *qint = qint_from_int(value);
914 object_property_set_qobject(obj, QOBJECT(qint), name, errp);
915
916 QDECREF(qint);
917 }
918
919 int64_t object_property_get_int(Object *obj, const char *name,
920 Error **errp)
921 {
922 QObject *ret = object_property_get_qobject(obj, name, errp);
923 QInt *qint;
924 int64_t retval;
925
926 if (!ret) {
927 return -1;
928 }
929 qint = qobject_to_qint(ret);
930 if (!qint) {
931 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "int");
932 retval = -1;
933 } else {
934 retval = qint_get_int(qint);
935 }
936
937 QDECREF(qint);
938 return retval;
939 }
940
941 void object_property_parse(Object *obj, const char *string,
942 const char *name, Error **errp)
943 {
944 StringInputVisitor *mi;
945 mi = string_input_visitor_new(string);
946 object_property_set(obj, string_input_get_visitor(mi), name, errp);
947
948 string_input_visitor_cleanup(mi);
949 }
950
951 char *object_property_print(Object *obj, const char *name, bool human,
952 Error **errp)
953 {
954 StringOutputVisitor *mo;
955 char *string;
956
957 mo = string_output_visitor_new(human);
958 object_property_get(obj, string_output_get_visitor(mo), name, errp);
959 string = string_output_get_string(mo);
960 string_output_visitor_cleanup(mo);
961 return string;
962 }
963
964 const char *object_property_get_type(Object *obj, const char *name, Error **errp)
965 {
966 ObjectProperty *prop = object_property_find(obj, name, errp);
967 if (prop == NULL) {
968 return NULL;
969 }
970
971 return prop->type;
972 }
973
974 Object *object_get_root(void)
975 {
976 static Object *root;
977
978 if (!root) {
979 root = object_new("container");
980 }
981
982 return root;
983 }
984
985 static void object_get_child_property(Object *obj, Visitor *v, void *opaque,
986 const char *name, Error **errp)
987 {
988 Object *child = opaque;
989 gchar *path;
990
991 path = object_get_canonical_path(child);
992 visit_type_str(v, &path, name, errp);
993 g_free(path);
994 }
995
996 static void object_finalize_child_property(Object *obj, const char *name,
997 void *opaque)
998 {
999 Object *child = opaque;
1000
1001 object_unref(child);
1002 }
1003
1004 void object_property_add_child(Object *obj, const char *name,
1005 Object *child, Error **errp)
1006 {
1007 Error *local_err = NULL;
1008 gchar *type;
1009
1010 type = g_strdup_printf("child<%s>", object_get_typename(OBJECT(child)));
1011
1012 object_property_add(obj, name, type, object_get_child_property, NULL,
1013 object_finalize_child_property, child, &local_err);
1014 if (local_err) {
1015 error_propagate(errp, local_err);
1016 goto out;
1017 }
1018 object_ref(child);
1019 g_assert(child->parent == NULL);
1020 child->parent = obj;
1021
1022 out:
1023 g_free(type);
1024 }
1025
1026 void object_property_allow_set_link(Object *obj, const char *name,
1027 Object *val, Error **errp)
1028 {
1029 /* Allow the link to be set, always */
1030 }
1031
1032 typedef struct {
1033 Object **child;
1034 void (*check)(Object *, const char *, Object *, Error **);
1035 ObjectPropertyLinkFlags flags;
1036 } LinkProperty;
1037
1038 static void object_get_link_property(Object *obj, Visitor *v, void *opaque,
1039 const char *name, Error **errp)
1040 {
1041 LinkProperty *lprop = opaque;
1042 Object **child = lprop->child;
1043 gchar *path;
1044
1045 if (*child) {
1046 path = object_get_canonical_path(*child);
1047 visit_type_str(v, &path, name, errp);
1048 g_free(path);
1049 } else {
1050 path = (gchar *)"";
1051 visit_type_str(v, &path, name, errp);
1052 }
1053 }
1054
1055 /*
1056 * object_resolve_link:
1057 *
1058 * Lookup an object and ensure its type matches the link property type. This
1059 * is similar to object_resolve_path() except type verification against the
1060 * link property is performed.
1061 *
1062 * Returns: The matched object or NULL on path lookup failures.
1063 */
1064 static Object *object_resolve_link(Object *obj, const char *name,
1065 const char *path, Error **errp)
1066 {
1067 const char *type;
1068 gchar *target_type;
1069 bool ambiguous = false;
1070 Object *target;
1071
1072 /* Go from link<FOO> to FOO. */
1073 type = object_property_get_type(obj, name, NULL);
1074 target_type = g_strndup(&type[5], strlen(type) - 6);
1075 target = object_resolve_path_type(path, target_type, &ambiguous);
1076
1077 if (ambiguous) {
1078 error_set(errp, QERR_AMBIGUOUS_PATH, path);
1079 } else if (!target) {
1080 target = object_resolve_path(path, &ambiguous);
1081 if (target || ambiguous) {
1082 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, target_type);
1083 } else {
1084 error_set(errp, QERR_DEVICE_NOT_FOUND, path);
1085 }
1086 target = NULL;
1087 }
1088 g_free(target_type);
1089
1090 return target;
1091 }
1092
1093 static void object_set_link_property(Object *obj, Visitor *v, void *opaque,
1094 const char *name, Error **errp)
1095 {
1096 Error *local_err = NULL;
1097 LinkProperty *prop = opaque;
1098 Object **child = prop->child;
1099 Object *old_target = *child;
1100 Object *new_target = NULL;
1101 char *path = NULL;
1102
1103 visit_type_str(v, &path, name, &local_err);
1104
1105 if (!local_err && strcmp(path, "") != 0) {
1106 new_target = object_resolve_link(obj, name, path, &local_err);
1107 }
1108
1109 g_free(path);
1110 if (local_err) {
1111 error_propagate(errp, local_err);
1112 return;
1113 }
1114
1115 prop->check(obj, name, new_target, &local_err);
1116 if (local_err) {
1117 error_propagate(errp, local_err);
1118 return;
1119 }
1120
1121 if (new_target) {
1122 object_ref(new_target);
1123 }
1124 *child = new_target;
1125 if (old_target != NULL) {
1126 object_unref(old_target);
1127 }
1128 }
1129
1130 static void object_release_link_property(Object *obj, const char *name,
1131 void *opaque)
1132 {
1133 LinkProperty *prop = opaque;
1134
1135 if ((prop->flags & OBJ_PROP_LINK_UNREF_ON_RELEASE) && *prop->child) {
1136 object_unref(*prop->child);
1137 }
1138 g_free(prop);
1139 }
1140
1141 void object_property_add_link(Object *obj, const char *name,
1142 const char *type, Object **child,
1143 void (*check)(Object *, const char *,
1144 Object *, Error **),
1145 ObjectPropertyLinkFlags flags,
1146 Error **errp)
1147 {
1148 Error *local_err = NULL;
1149 LinkProperty *prop = g_malloc(sizeof(*prop));
1150 gchar *full_type;
1151
1152 prop->child = child;
1153 prop->check = check;
1154 prop->flags = flags;
1155
1156 full_type = g_strdup_printf("link<%s>", type);
1157
1158 object_property_add(obj, name, full_type,
1159 object_get_link_property,
1160 check ? object_set_link_property : NULL,
1161 object_release_link_property,
1162 prop,
1163 &local_err);
1164 if (local_err) {
1165 error_propagate(errp, local_err);
1166 g_free(prop);
1167 }
1168
1169 g_free(full_type);
1170 }
1171
1172 gchar *object_get_canonical_path_component(Object *obj)
1173 {
1174 ObjectProperty *prop = NULL;
1175
1176 g_assert(obj);
1177 g_assert(obj->parent != NULL);
1178
1179 QTAILQ_FOREACH(prop, &obj->parent->properties, node) {
1180 if (!object_property_is_child(prop)) {
1181 continue;
1182 }
1183
1184 if (prop->opaque == obj) {
1185 return g_strdup(prop->name);
1186 }
1187 }
1188
1189 /* obj had a parent but was not a child, should never happen */
1190 g_assert_not_reached();
1191 return NULL;
1192 }
1193
1194 gchar *object_get_canonical_path(Object *obj)
1195 {
1196 Object *root = object_get_root();
1197 char *newpath, *path = NULL;
1198
1199 while (obj != root) {
1200 char *component = object_get_canonical_path_component(obj);
1201
1202 if (path) {
1203 newpath = g_strdup_printf("%s/%s", component, path);
1204 g_free(component);
1205 g_free(path);
1206 path = newpath;
1207 } else {
1208 path = component;
1209 }
1210
1211 obj = obj->parent;
1212 }
1213
1214 newpath = g_strdup_printf("/%s", path ? path : "");
1215 g_free(path);
1216
1217 return newpath;
1218 }
1219
1220 Object *object_resolve_path_component(Object *parent, const gchar *part)
1221 {
1222 ObjectProperty *prop = object_property_find(parent, part, NULL);
1223 if (prop == NULL) {
1224 return NULL;
1225 }
1226
1227 if (object_property_is_link(prop)) {
1228 return *(Object **)prop->opaque;
1229 } else if (object_property_is_child(prop)) {
1230 return prop->opaque;
1231 } else {
1232 return NULL;
1233 }
1234 }
1235
1236 static Object *object_resolve_abs_path(Object *parent,
1237 gchar **parts,
1238 const char *typename,
1239 int index)
1240 {
1241 Object *child;
1242
1243 if (parts[index] == NULL) {
1244 return object_dynamic_cast(parent, typename);
1245 }
1246
1247 if (strcmp(parts[index], "") == 0) {
1248 return object_resolve_abs_path(parent, parts, typename, index + 1);
1249 }
1250
1251 child = object_resolve_path_component(parent, parts[index]);
1252 if (!child) {
1253 return NULL;
1254 }
1255
1256 return object_resolve_abs_path(child, parts, typename, index + 1);
1257 }
1258
1259 static Object *object_resolve_partial_path(Object *parent,
1260 gchar **parts,
1261 const char *typename,
1262 bool *ambiguous)
1263 {
1264 Object *obj;
1265 ObjectProperty *prop;
1266
1267 obj = object_resolve_abs_path(parent, parts, typename, 0);
1268
1269 QTAILQ_FOREACH(prop, &parent->properties, node) {
1270 Object *found;
1271
1272 if (!object_property_is_child(prop)) {
1273 continue;
1274 }
1275
1276 found = object_resolve_partial_path(prop->opaque, parts,
1277 typename, ambiguous);
1278 if (found) {
1279 if (obj) {
1280 if (ambiguous) {
1281 *ambiguous = true;
1282 }
1283 return NULL;
1284 }
1285 obj = found;
1286 }
1287
1288 if (ambiguous && *ambiguous) {
1289 return NULL;
1290 }
1291 }
1292
1293 return obj;
1294 }
1295
1296 Object *object_resolve_path_type(const char *path, const char *typename,
1297 bool *ambiguous)
1298 {
1299 Object *obj;
1300 gchar **parts;
1301
1302 parts = g_strsplit(path, "/", 0);
1303 assert(parts);
1304
1305 if (parts[0] == NULL || strcmp(parts[0], "") != 0) {
1306 if (ambiguous) {
1307 *ambiguous = false;
1308 }
1309 obj = object_resolve_partial_path(object_get_root(), parts,
1310 typename, ambiguous);
1311 } else {
1312 obj = object_resolve_abs_path(object_get_root(), parts, typename, 1);
1313 }
1314
1315 g_strfreev(parts);
1316
1317 return obj;
1318 }
1319
1320 Object *object_resolve_path(const char *path, bool *ambiguous)
1321 {
1322 return object_resolve_path_type(path, TYPE_OBJECT, ambiguous);
1323 }
1324
1325 typedef struct StringProperty
1326 {
1327 char *(*get)(Object *, Error **);
1328 void (*set)(Object *, const char *, Error **);
1329 } StringProperty;
1330
1331 static void property_get_str(Object *obj, Visitor *v, void *opaque,
1332 const char *name, Error **errp)
1333 {
1334 StringProperty *prop = opaque;
1335 char *value;
1336
1337 value = prop->get(obj, errp);
1338 if (value) {
1339 visit_type_str(v, &value, name, errp);
1340 g_free(value);
1341 }
1342 }
1343
1344 static void property_set_str(Object *obj, Visitor *v, void *opaque,
1345 const char *name, Error **errp)
1346 {
1347 StringProperty *prop = opaque;
1348 char *value;
1349 Error *local_err = NULL;
1350
1351 visit_type_str(v, &value, name, &local_err);
1352 if (local_err) {
1353 error_propagate(errp, local_err);
1354 return;
1355 }
1356
1357 prop->set(obj, value, errp);
1358 g_free(value);
1359 }
1360
1361 static void property_release_str(Object *obj, const char *name,
1362 void *opaque)
1363 {
1364 StringProperty *prop = opaque;
1365 g_free(prop);
1366 }
1367
1368 void object_property_add_str(Object *obj, const char *name,
1369 char *(*get)(Object *, Error **),
1370 void (*set)(Object *, const char *, Error **),
1371 Error **errp)
1372 {
1373 Error *local_err = NULL;
1374 StringProperty *prop = g_malloc0(sizeof(*prop));
1375
1376 prop->get = get;
1377 prop->set = set;
1378
1379 object_property_add(obj, name, "string",
1380 get ? property_get_str : NULL,
1381 set ? property_set_str : NULL,
1382 property_release_str,
1383 prop, &local_err);
1384 if (local_err) {
1385 error_propagate(errp, local_err);
1386 g_free(prop);
1387 }
1388 }
1389
1390 typedef struct BoolProperty
1391 {
1392 bool (*get)(Object *, Error **);
1393 void (*set)(Object *, bool, Error **);
1394 } BoolProperty;
1395
1396 static void property_get_bool(Object *obj, Visitor *v, void *opaque,
1397 const char *name, Error **errp)
1398 {
1399 BoolProperty *prop = opaque;
1400 bool value;
1401
1402 value = prop->get(obj, errp);
1403 visit_type_bool(v, &value, name, errp);
1404 }
1405
1406 static void property_set_bool(Object *obj, Visitor *v, void *opaque,
1407 const char *name, Error **errp)
1408 {
1409 BoolProperty *prop = opaque;
1410 bool value;
1411 Error *local_err = NULL;
1412
1413 visit_type_bool(v, &value, name, &local_err);
1414 if (local_err) {
1415 error_propagate(errp, local_err);
1416 return;
1417 }
1418
1419 prop->set(obj, value, errp);
1420 }
1421
1422 static void property_release_bool(Object *obj, const char *name,
1423 void *opaque)
1424 {
1425 BoolProperty *prop = opaque;
1426 g_free(prop);
1427 }
1428
1429 void object_property_add_bool(Object *obj, const char *name,
1430 bool (*get)(Object *, Error **),
1431 void (*set)(Object *, bool, Error **),
1432 Error **errp)
1433 {
1434 Error *local_err = NULL;
1435 BoolProperty *prop = g_malloc0(sizeof(*prop));
1436
1437 prop->get = get;
1438 prop->set = set;
1439
1440 object_property_add(obj, name, "bool",
1441 get ? property_get_bool : NULL,
1442 set ? property_set_bool : NULL,
1443 property_release_bool,
1444 prop, &local_err);
1445 if (local_err) {
1446 error_propagate(errp, local_err);
1447 g_free(prop);
1448 }
1449 }
1450
1451 static char *qdev_get_type(Object *obj, Error **errp)
1452 {
1453 return g_strdup(object_get_typename(obj));
1454 }
1455
1456 static void property_get_uint8_ptr(Object *obj, Visitor *v,
1457 void *opaque, const char *name,
1458 Error **errp)
1459 {
1460 uint8_t value = *(uint8_t *)opaque;
1461 visit_type_uint8(v, &value, name, errp);
1462 }
1463
1464 static void property_get_uint16_ptr(Object *obj, Visitor *v,
1465 void *opaque, const char *name,
1466 Error **errp)
1467 {
1468 uint16_t value = *(uint16_t *)opaque;
1469 visit_type_uint16(v, &value, name, errp);
1470 }
1471
1472 static void property_get_uint32_ptr(Object *obj, Visitor *v,
1473 void *opaque, const char *name,
1474 Error **errp)
1475 {
1476 uint32_t value = *(uint32_t *)opaque;
1477 visit_type_uint32(v, &value, name, errp);
1478 }
1479
1480 static void property_get_uint64_ptr(Object *obj, Visitor *v,
1481 void *opaque, const char *name,
1482 Error **errp)
1483 {
1484 uint64_t value = *(uint64_t *)opaque;
1485 visit_type_uint64(v, &value, name, errp);
1486 }
1487
1488 void object_property_add_uint8_ptr(Object *obj, const char *name,
1489 const uint8_t *v, Error **errp)
1490 {
1491 object_property_add(obj, name, "uint8", property_get_uint8_ptr,
1492 NULL, NULL, (void *)v, errp);
1493 }
1494
1495 void object_property_add_uint16_ptr(Object *obj, const char *name,
1496 const uint16_t *v, Error **errp)
1497 {
1498 object_property_add(obj, name, "uint16", property_get_uint16_ptr,
1499 NULL, NULL, (void *)v, errp);
1500 }
1501
1502 void object_property_add_uint32_ptr(Object *obj, const char *name,
1503 const uint32_t *v, Error **errp)
1504 {
1505 object_property_add(obj, name, "uint32", property_get_uint32_ptr,
1506 NULL, NULL, (void *)v, errp);
1507 }
1508
1509 void object_property_add_uint64_ptr(Object *obj, const char *name,
1510 const uint64_t *v, Error **errp)
1511 {
1512 object_property_add(obj, name, "uint64", property_get_uint64_ptr,
1513 NULL, NULL, (void *)v, errp);
1514 }
1515
1516 static void object_instance_init(Object *obj)
1517 {
1518 object_property_add_str(obj, "type", qdev_get_type, NULL, NULL);
1519 }
1520
1521 static void register_types(void)
1522 {
1523 static TypeInfo interface_info = {
1524 .name = TYPE_INTERFACE,
1525 .class_size = sizeof(InterfaceClass),
1526 .abstract = true,
1527 };
1528
1529 static TypeInfo object_info = {
1530 .name = TYPE_OBJECT,
1531 .instance_size = sizeof(Object),
1532 .instance_init = object_instance_init,
1533 .abstract = true,
1534 };
1535
1536 type_interface = type_register_internal(&interface_info);
1537 type_register_internal(&object_info);
1538 }
1539
1540 type_init(register_types)