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