qom: Split object_property_set_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 static void object_get_link_property(Object *obj, Visitor *v, void *opaque,
1027 const char *name, Error **errp)
1028 {
1029 Object **child = opaque;
1030 gchar *path;
1031
1032 if (*child) {
1033 path = object_get_canonical_path(*child);
1034 visit_type_str(v, &path, name, errp);
1035 g_free(path);
1036 } else {
1037 path = (gchar *)"";
1038 visit_type_str(v, &path, name, errp);
1039 }
1040 }
1041
1042 /*
1043 * object_resolve_link:
1044 *
1045 * Lookup an object and ensure its type matches the link property type. This
1046 * is similar to object_resolve_path() except type verification against the
1047 * link property is performed.
1048 *
1049 * Returns: The matched object or NULL on path lookup failures.
1050 */
1051 static Object *object_resolve_link(Object *obj, const char *name,
1052 const char *path, Error **errp)
1053 {
1054 const char *type;
1055 gchar *target_type;
1056 bool ambiguous = false;
1057 Object *target;
1058
1059 /* Go from link<FOO> to FOO. */
1060 type = object_property_get_type(obj, name, NULL);
1061 target_type = g_strndup(&type[5], strlen(type) - 6);
1062 target = object_resolve_path_type(path, target_type, &ambiguous);
1063
1064 if (ambiguous) {
1065 error_set(errp, QERR_AMBIGUOUS_PATH, path);
1066 } else if (!target) {
1067 target = object_resolve_path(path, &ambiguous);
1068 if (target || ambiguous) {
1069 error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, target_type);
1070 } else {
1071 error_set(errp, QERR_DEVICE_NOT_FOUND, path);
1072 }
1073 target = NULL;
1074 }
1075 g_free(target_type);
1076
1077 return target;
1078 }
1079
1080 static void object_set_link_property(Object *obj, Visitor *v, void *opaque,
1081 const char *name, Error **errp)
1082 {
1083 Object **child = opaque;
1084 Object *old_target;
1085 char *path;
1086
1087 visit_type_str(v, &path, name, errp);
1088
1089 old_target = *child;
1090 *child = NULL;
1091
1092 if (strcmp(path, "") != 0) {
1093 Object *target;
1094
1095 target = object_resolve_link(obj, name, path, errp);
1096 if (target) {
1097 object_ref(target);
1098 *child = target;
1099 }
1100 }
1101
1102 g_free(path);
1103
1104 if (old_target != NULL) {
1105 object_unref(old_target);
1106 }
1107 }
1108
1109 void object_property_add_link(Object *obj, const char *name,
1110 const char *type, Object **child,
1111 Error **errp)
1112 {
1113 gchar *full_type;
1114
1115 full_type = g_strdup_printf("link<%s>", type);
1116
1117 object_property_add(obj, name, full_type,
1118 object_get_link_property,
1119 object_set_link_property,
1120 NULL, child, errp);
1121
1122 g_free(full_type);
1123 }
1124
1125 gchar *object_get_canonical_path_component(Object *obj)
1126 {
1127 ObjectProperty *prop = NULL;
1128
1129 g_assert(obj);
1130 g_assert(obj->parent != NULL);
1131
1132 QTAILQ_FOREACH(prop, &obj->parent->properties, node) {
1133 if (!object_property_is_child(prop)) {
1134 continue;
1135 }
1136
1137 if (prop->opaque == obj) {
1138 return g_strdup(prop->name);
1139 }
1140 }
1141
1142 /* obj had a parent but was not a child, should never happen */
1143 g_assert_not_reached();
1144 return NULL;
1145 }
1146
1147 gchar *object_get_canonical_path(Object *obj)
1148 {
1149 Object *root = object_get_root();
1150 char *newpath, *path = NULL;
1151
1152 while (obj != root) {
1153 char *component = object_get_canonical_path_component(obj);
1154
1155 if (path) {
1156 newpath = g_strdup_printf("%s/%s", component, path);
1157 g_free(component);
1158 g_free(path);
1159 path = newpath;
1160 } else {
1161 path = component;
1162 }
1163
1164 obj = obj->parent;
1165 }
1166
1167 newpath = g_strdup_printf("/%s", path ? path : "");
1168 g_free(path);
1169
1170 return newpath;
1171 }
1172
1173 Object *object_resolve_path_component(Object *parent, const gchar *part)
1174 {
1175 ObjectProperty *prop = object_property_find(parent, part, NULL);
1176 if (prop == NULL) {
1177 return NULL;
1178 }
1179
1180 if (object_property_is_link(prop)) {
1181 return *(Object **)prop->opaque;
1182 } else if (object_property_is_child(prop)) {
1183 return prop->opaque;
1184 } else {
1185 return NULL;
1186 }
1187 }
1188
1189 static Object *object_resolve_abs_path(Object *parent,
1190 gchar **parts,
1191 const char *typename,
1192 int index)
1193 {
1194 Object *child;
1195
1196 if (parts[index] == NULL) {
1197 return object_dynamic_cast(parent, typename);
1198 }
1199
1200 if (strcmp(parts[index], "") == 0) {
1201 return object_resolve_abs_path(parent, parts, typename, index + 1);
1202 }
1203
1204 child = object_resolve_path_component(parent, parts[index]);
1205 if (!child) {
1206 return NULL;
1207 }
1208
1209 return object_resolve_abs_path(child, parts, typename, index + 1);
1210 }
1211
1212 static Object *object_resolve_partial_path(Object *parent,
1213 gchar **parts,
1214 const char *typename,
1215 bool *ambiguous)
1216 {
1217 Object *obj;
1218 ObjectProperty *prop;
1219
1220 obj = object_resolve_abs_path(parent, parts, typename, 0);
1221
1222 QTAILQ_FOREACH(prop, &parent->properties, node) {
1223 Object *found;
1224
1225 if (!object_property_is_child(prop)) {
1226 continue;
1227 }
1228
1229 found = object_resolve_partial_path(prop->opaque, parts,
1230 typename, ambiguous);
1231 if (found) {
1232 if (obj) {
1233 if (ambiguous) {
1234 *ambiguous = true;
1235 }
1236 return NULL;
1237 }
1238 obj = found;
1239 }
1240
1241 if (ambiguous && *ambiguous) {
1242 return NULL;
1243 }
1244 }
1245
1246 return obj;
1247 }
1248
1249 Object *object_resolve_path_type(const char *path, const char *typename,
1250 bool *ambiguous)
1251 {
1252 Object *obj;
1253 gchar **parts;
1254
1255 parts = g_strsplit(path, "/", 0);
1256 assert(parts);
1257
1258 if (parts[0] == NULL || strcmp(parts[0], "") != 0) {
1259 if (ambiguous) {
1260 *ambiguous = false;
1261 }
1262 obj = object_resolve_partial_path(object_get_root(), parts,
1263 typename, ambiguous);
1264 } else {
1265 obj = object_resolve_abs_path(object_get_root(), parts, typename, 1);
1266 }
1267
1268 g_strfreev(parts);
1269
1270 return obj;
1271 }
1272
1273 Object *object_resolve_path(const char *path, bool *ambiguous)
1274 {
1275 return object_resolve_path_type(path, TYPE_OBJECT, ambiguous);
1276 }
1277
1278 typedef struct StringProperty
1279 {
1280 char *(*get)(Object *, Error **);
1281 void (*set)(Object *, const char *, Error **);
1282 } StringProperty;
1283
1284 static void property_get_str(Object *obj, Visitor *v, void *opaque,
1285 const char *name, Error **errp)
1286 {
1287 StringProperty *prop = opaque;
1288 char *value;
1289
1290 value = prop->get(obj, errp);
1291 if (value) {
1292 visit_type_str(v, &value, name, errp);
1293 g_free(value);
1294 }
1295 }
1296
1297 static void property_set_str(Object *obj, Visitor *v, void *opaque,
1298 const char *name, Error **errp)
1299 {
1300 StringProperty *prop = opaque;
1301 char *value;
1302 Error *local_err = NULL;
1303
1304 visit_type_str(v, &value, name, &local_err);
1305 if (local_err) {
1306 error_propagate(errp, local_err);
1307 return;
1308 }
1309
1310 prop->set(obj, value, errp);
1311 g_free(value);
1312 }
1313
1314 static void property_release_str(Object *obj, const char *name,
1315 void *opaque)
1316 {
1317 StringProperty *prop = opaque;
1318 g_free(prop);
1319 }
1320
1321 void object_property_add_str(Object *obj, const char *name,
1322 char *(*get)(Object *, Error **),
1323 void (*set)(Object *, const char *, Error **),
1324 Error **errp)
1325 {
1326 Error *local_err = NULL;
1327 StringProperty *prop = g_malloc0(sizeof(*prop));
1328
1329 prop->get = get;
1330 prop->set = set;
1331
1332 object_property_add(obj, name, "string",
1333 get ? property_get_str : NULL,
1334 set ? property_set_str : NULL,
1335 property_release_str,
1336 prop, &local_err);
1337 if (local_err) {
1338 error_propagate(errp, local_err);
1339 g_free(prop);
1340 }
1341 }
1342
1343 typedef struct BoolProperty
1344 {
1345 bool (*get)(Object *, Error **);
1346 void (*set)(Object *, bool, Error **);
1347 } BoolProperty;
1348
1349 static void property_get_bool(Object *obj, Visitor *v, void *opaque,
1350 const char *name, Error **errp)
1351 {
1352 BoolProperty *prop = opaque;
1353 bool value;
1354
1355 value = prop->get(obj, errp);
1356 visit_type_bool(v, &value, name, errp);
1357 }
1358
1359 static void property_set_bool(Object *obj, Visitor *v, void *opaque,
1360 const char *name, Error **errp)
1361 {
1362 BoolProperty *prop = opaque;
1363 bool value;
1364 Error *local_err = NULL;
1365
1366 visit_type_bool(v, &value, name, &local_err);
1367 if (local_err) {
1368 error_propagate(errp, local_err);
1369 return;
1370 }
1371
1372 prop->set(obj, value, errp);
1373 }
1374
1375 static void property_release_bool(Object *obj, const char *name,
1376 void *opaque)
1377 {
1378 BoolProperty *prop = opaque;
1379 g_free(prop);
1380 }
1381
1382 void object_property_add_bool(Object *obj, const char *name,
1383 bool (*get)(Object *, Error **),
1384 void (*set)(Object *, bool, Error **),
1385 Error **errp)
1386 {
1387 Error *local_err = NULL;
1388 BoolProperty *prop = g_malloc0(sizeof(*prop));
1389
1390 prop->get = get;
1391 prop->set = set;
1392
1393 object_property_add(obj, name, "bool",
1394 get ? property_get_bool : NULL,
1395 set ? property_set_bool : NULL,
1396 property_release_bool,
1397 prop, &local_err);
1398 if (local_err) {
1399 error_propagate(errp, local_err);
1400 g_free(prop);
1401 }
1402 }
1403
1404 static char *qdev_get_type(Object *obj, Error **errp)
1405 {
1406 return g_strdup(object_get_typename(obj));
1407 }
1408
1409 static void property_get_uint8_ptr(Object *obj, Visitor *v,
1410 void *opaque, const char *name,
1411 Error **errp)
1412 {
1413 uint8_t value = *(uint8_t *)opaque;
1414 visit_type_uint8(v, &value, name, errp);
1415 }
1416
1417 static void property_get_uint16_ptr(Object *obj, Visitor *v,
1418 void *opaque, const char *name,
1419 Error **errp)
1420 {
1421 uint16_t value = *(uint16_t *)opaque;
1422 visit_type_uint16(v, &value, name, errp);
1423 }
1424
1425 static void property_get_uint32_ptr(Object *obj, Visitor *v,
1426 void *opaque, const char *name,
1427 Error **errp)
1428 {
1429 uint32_t value = *(uint32_t *)opaque;
1430 visit_type_uint32(v, &value, name, errp);
1431 }
1432
1433 static void property_get_uint64_ptr(Object *obj, Visitor *v,
1434 void *opaque, const char *name,
1435 Error **errp)
1436 {
1437 uint64_t value = *(uint64_t *)opaque;
1438 visit_type_uint64(v, &value, name, errp);
1439 }
1440
1441 void object_property_add_uint8_ptr(Object *obj, const char *name,
1442 const uint8_t *v, Error **errp)
1443 {
1444 object_property_add(obj, name, "uint8", property_get_uint8_ptr,
1445 NULL, NULL, (void *)v, errp);
1446 }
1447
1448 void object_property_add_uint16_ptr(Object *obj, const char *name,
1449 const uint16_t *v, Error **errp)
1450 {
1451 object_property_add(obj, name, "uint16", property_get_uint16_ptr,
1452 NULL, NULL, (void *)v, errp);
1453 }
1454
1455 void object_property_add_uint32_ptr(Object *obj, const char *name,
1456 const uint32_t *v, Error **errp)
1457 {
1458 object_property_add(obj, name, "uint32", property_get_uint32_ptr,
1459 NULL, NULL, (void *)v, errp);
1460 }
1461
1462 void object_property_add_uint64_ptr(Object *obj, const char *name,
1463 const uint64_t *v, Error **errp)
1464 {
1465 object_property_add(obj, name, "uint64", property_get_uint64_ptr,
1466 NULL, NULL, (void *)v, errp);
1467 }
1468
1469 static void object_instance_init(Object *obj)
1470 {
1471 object_property_add_str(obj, "type", qdev_get_type, NULL, NULL);
1472 }
1473
1474 static void register_types(void)
1475 {
1476 static TypeInfo interface_info = {
1477 .name = TYPE_INTERFACE,
1478 .class_size = sizeof(InterfaceClass),
1479 .abstract = true,
1480 };
1481
1482 static TypeInfo object_info = {
1483 .name = TYPE_OBJECT,
1484 .instance_size = sizeof(Object),
1485 .instance_init = object_instance_init,
1486 .abstract = true,
1487 };
1488
1489 type_interface = type_register_internal(&interface_info);
1490 type_register_internal(&object_info);
1491 }
1492
1493 type_init(register_types)