]> git.proxmox.com Git - mirror_qemu.git/blame - qom/object.c
qom: Replace object property list with GHashTable
[mirror_qemu.git] / qom / object.c
CommitLineData
2f28d2ff
AL
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
14cccb61 13#include "qom/object.h"
a31bdae5 14#include "qom/object_interfaces.h"
2f28d2ff 15#include "qemu-common.h"
7b1b5d19 16#include "qapi/visitor.h"
1f21772d 17#include "qapi-visit.h"
b2cd7dee
PB
18#include "qapi/string-input-visitor.h"
19#include "qapi/string-output-visitor.h"
7b1b5d19 20#include "qapi/qmp/qerror.h"
fa131d94 21#include "trace.h"
2f28d2ff 22
7b7b7d18
PB
23/* TODO: replace QObject with a simpler visitor to avoid a dependency
24 * of the QOM core on QObject? */
14cccb61 25#include "qom/qom-qobject.h"
7b1b5d19
PB
26#include "qapi/qmp/qobject.h"
27#include "qapi/qmp/qbool.h"
28#include "qapi/qmp/qint.h"
29#include "qapi/qmp/qstring.h"
7b7b7d18 30
2f28d2ff
AL
31#define MAX_INTERFACES 32
32
33typedef struct InterfaceImpl InterfaceImpl;
34typedef struct TypeImpl TypeImpl;
35
36struct InterfaceImpl
37{
33e95c63 38 const char *typename;
2f28d2ff
AL
39};
40
41struct TypeImpl
42{
43 const char *name;
44
45 size_t class_size;
46
47 size_t instance_size;
48
49 void (*class_init)(ObjectClass *klass, void *data);
3b50e311 50 void (*class_base_init)(ObjectClass *klass, void *data);
2f28d2ff
AL
51 void (*class_finalize)(ObjectClass *klass, void *data);
52
53 void *class_data;
54
55 void (*instance_init)(Object *obj);
8231c2dd 56 void (*instance_post_init)(Object *obj);
2f28d2ff
AL
57 void (*instance_finalize)(Object *obj);
58
59 bool abstract;
60
61 const char *parent;
62 TypeImpl *parent_type;
63
64 ObjectClass *class;
65
66 int num_interfaces;
67 InterfaceImpl interfaces[MAX_INTERFACES];
68};
69
a00c9482 70struct ObjectPropertyIterator {
b604a854 71 GHashTableIter iter;
a00c9482
DB
72};
73
9970bd88
PB
74static Type type_interface;
75
2f28d2ff
AL
76static 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
f54c19ca
HP
87static bool enumerating_types;
88
2f28d2ff
AL
89static void type_table_add(TypeImpl *ti)
90{
f54c19ca 91 assert(!enumerating_types);
2f28d2ff
AL
92 g_hash_table_insert(type_table_get(), (void *)ti->name, ti);
93}
94
95static TypeImpl *type_table_lookup(const char *name)
96{
97 return g_hash_table_lookup(type_table_get(), name);
98}
99
b061dc41 100static TypeImpl *type_new(const TypeInfo *info)
2f28d2ff
AL
101{
102 TypeImpl *ti = g_malloc0(sizeof(*ti));
33e95c63 103 int i;
2f28d2ff
AL
104
105 g_assert(info->name != NULL);
106
73093354
AL
107 if (type_table_lookup(info->name) != NULL) {
108 fprintf(stderr, "Registering `%s' which already exists\n", info->name);
109 abort();
110 }
111
2f28d2ff
AL
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;
3b50e311 119 ti->class_base_init = info->class_base_init;
2f28d2ff
AL
120 ti->class_finalize = info->class_finalize;
121 ti->class_data = info->class_data;
122
123 ti->instance_init = info->instance_init;
8231c2dd 124 ti->instance_post_init = info->instance_post_init;
2f28d2ff
AL
125 ti->instance_finalize = info->instance_finalize;
126
127 ti->abstract = info->abstract;
128
33e95c63
AL
129 for (i = 0; info->interfaces && info->interfaces[i].type; i++) {
130 ti->interfaces[i].typename = g_strdup(info->interfaces[i].type);
2f28d2ff 131 }
33e95c63 132 ti->num_interfaces = i;
2f28d2ff 133
b061dc41
PB
134 return ti;
135}
2f28d2ff 136
b061dc41
PB
137static TypeImpl *type_register_internal(const TypeInfo *info)
138{
139 TypeImpl *ti;
140 ti = type_new(info);
141
142 type_table_add(ti);
2f28d2ff
AL
143 return ti;
144}
145
049cb3cf
PB
146TypeImpl *type_register(const TypeInfo *info)
147{
148 assert(info->parent);
149 return type_register_internal(info);
150}
151
2f28d2ff
AL
152TypeImpl *type_register_static(const TypeInfo *info)
153{
154 return type_register(info);
155}
156
157static TypeImpl *type_get_by_name(const char *name)
158{
159 if (name == NULL) {
160 return NULL;
161 }
162
163 return type_table_lookup(name);
164}
165
166static TypeImpl *type_get_parent(TypeImpl *type)
167{
168 if (!type->parent_type && type->parent) {
169 type->parent_type = type_get_by_name(type->parent);
170 g_assert(type->parent_type != NULL);
171 }
172
173 return type->parent_type;
174}
175
176static bool type_has_parent(TypeImpl *type)
177{
178 return (type->parent != NULL);
179}
180
181static size_t type_class_get_size(TypeImpl *ti)
182{
183 if (ti->class_size) {
184 return ti->class_size;
185 }
186
187 if (type_has_parent(ti)) {
188 return type_class_get_size(type_get_parent(ti));
189 }
190
191 return sizeof(ObjectClass);
192}
193
aca59af6
IM
194static size_t type_object_get_size(TypeImpl *ti)
195{
196 if (ti->instance_size) {
197 return ti->instance_size;
198 }
199
200 if (type_has_parent(ti)) {
201 return type_object_get_size(type_get_parent(ti));
202 }
203
204 return 0;
205}
206
33e95c63 207static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type)
2f28d2ff 208{
33e95c63
AL
209 assert(target_type);
210
b30d8054 211 /* Check if target_type is a direct ancestor of type */
33e95c63
AL
212 while (type) {
213 if (type == target_type) {
214 return true;
215 }
2f28d2ff 216
33e95c63
AL
217 type = type_get_parent(type);
218 }
219
220 return false;
221}
222
223static void type_initialize(TypeImpl *ti);
224
b061dc41
PB
225static void type_initialize_interface(TypeImpl *ti, TypeImpl *interface_type,
226 TypeImpl *parent_type)
33e95c63
AL
227{
228 InterfaceClass *new_iface;
229 TypeInfo info = { };
230 TypeImpl *iface_impl;
231
b061dc41
PB
232 info.parent = parent_type->name;
233 info.name = g_strdup_printf("%s::%s", ti->name, interface_type->name);
33e95c63
AL
234 info.abstract = true;
235
b061dc41
PB
236 iface_impl = type_new(&info);
237 iface_impl->parent_type = parent_type;
33e95c63
AL
238 type_initialize(iface_impl);
239 g_free((char *)info.name);
240
241 new_iface = (InterfaceClass *)iface_impl->class;
242 new_iface->concrete_class = ti->class;
b061dc41 243 new_iface->interface_type = interface_type;
33e95c63
AL
244
245 ti->class->interfaces = g_slist_append(ti->class->interfaces,
246 iface_impl->class);
2f28d2ff
AL
247}
248
ac451033 249static void type_initialize(TypeImpl *ti)
2f28d2ff 250{
745549c8 251 TypeImpl *parent;
2f28d2ff
AL
252
253 if (ti->class) {
254 return;
255 }
256
257 ti->class_size = type_class_get_size(ti);
aca59af6 258 ti->instance_size = type_object_get_size(ti);
2f28d2ff
AL
259
260 ti->class = g_malloc0(ti->class_size);
2f28d2ff 261
745549c8
PB
262 parent = type_get_parent(ti);
263 if (parent) {
ac451033 264 type_initialize(parent);
33e95c63
AL
265 GSList *e;
266 int i;
2f28d2ff 267
2f28d2ff 268 g_assert(parent->class_size <= ti->class_size);
745549c8 269 memcpy(ti->class, parent->class, parent->class_size);
3e407de4 270 ti->class->interfaces = NULL;
33e95c63
AL
271
272 for (e = parent->class->interfaces; e; e = e->next) {
b061dc41
PB
273 InterfaceClass *iface = e->data;
274 ObjectClass *klass = OBJECT_CLASS(iface);
275
276 type_initialize_interface(ti, iface->interface_type, klass->type);
33e95c63
AL
277 }
278
279 for (i = 0; i < ti->num_interfaces; i++) {
280 TypeImpl *t = type_get_by_name(ti->interfaces[i].typename);
281 for (e = ti->class->interfaces; e; e = e->next) {
282 TypeImpl *target_type = OBJECT_CLASS(e->data)->type;
283
284 if (type_is_ancestor(target_type, t)) {
285 break;
286 }
287 }
288
289 if (e) {
290 continue;
291 }
292
b061dc41 293 type_initialize_interface(ti, t, t);
33e95c63 294 }
745549c8 295 }
2f28d2ff 296
745549c8 297 ti->class->type = ti;
3b50e311 298
745549c8
PB
299 while (parent) {
300 if (parent->class_base_init) {
301 parent->class_base_init(ti->class, ti->class_data);
3b50e311 302 }
745549c8 303 parent = type_get_parent(parent);
2f28d2ff
AL
304 }
305
2f28d2ff
AL
306 if (ti->class_init) {
307 ti->class_init(ti->class, ti->class_data);
308 }
2f28d2ff
AL
309}
310
311static void object_init_with_type(Object *obj, TypeImpl *ti)
312{
2f28d2ff
AL
313 if (type_has_parent(ti)) {
314 object_init_with_type(obj, type_get_parent(ti));
315 }
316
2f28d2ff
AL
317 if (ti->instance_init) {
318 ti->instance_init(obj);
319 }
320}
321
8231c2dd
EH
322static void object_post_init_with_type(Object *obj, TypeImpl *ti)
323{
324 if (ti->instance_post_init) {
325 ti->instance_post_init(obj);
326 }
327
328 if (type_has_parent(ti)) {
329 object_post_init_with_type(obj, type_get_parent(ti));
330 }
331}
332
b604a854
PF
333static void object_property_free(gpointer data)
334{
335 ObjectProperty *prop = data;
336
337 g_free(prop->name);
338 g_free(prop->type);
339 g_free(prop->description);
340 g_free(prop);
341}
342
5b9237f6 343void object_initialize_with_type(void *data, size_t size, TypeImpl *type)
2f28d2ff
AL
344{
345 Object *obj = data;
346
347 g_assert(type != NULL);
ac451033 348 type_initialize(type);
aca59af6
IM
349
350 g_assert(type->instance_size >= sizeof(Object));
2f28d2ff 351 g_assert(type->abstract == false);
5b9237f6 352 g_assert(size >= type->instance_size);
2f28d2ff
AL
353
354 memset(obj, 0, type->instance_size);
355 obj->class = type->class;
764b6312 356 object_ref(obj);
b604a854
PF
357 obj->properties = g_hash_table_new_full(g_str_hash, g_str_equal,
358 NULL, object_property_free);
2f28d2ff 359 object_init_with_type(obj, type);
8231c2dd 360 object_post_init_with_type(obj, type);
2f28d2ff
AL
361}
362
213f0c4f 363void object_initialize(void *data, size_t size, const char *typename)
2f28d2ff
AL
364{
365 TypeImpl *type = type_get_by_name(typename);
366
5b9237f6 367 object_initialize_with_type(data, size, type);
2f28d2ff
AL
368}
369
5d9d3f47
AF
370static inline bool object_property_is_child(ObjectProperty *prop)
371{
372 return strstart(prop->type, "child<", NULL);
373}
374
57c9fafe
AL
375static void object_property_del_all(Object *obj)
376{
b604a854
PF
377 ObjectProperty *prop;
378 GHashTableIter iter;
379 gpointer key, value;
380 bool released;
381
382 do {
383 released = false;
384 g_hash_table_iter_init(&iter, obj->properties);
385 while (g_hash_table_iter_next(&iter, &key, &value)) {
386 prop = value;
387 if (prop->release) {
388 prop->release(obj, prop->name, prop->opaque);
389 prop->release = NULL;
390 released = true;
391 break;
392 }
393 g_hash_table_iter_remove(&iter);
57c9fafe 394 }
b604a854 395 } while (released);
57c9fafe 396
b604a854 397 g_hash_table_unref(obj->properties);
57c9fafe
AL
398}
399
400static void object_property_del_child(Object *obj, Object *child, Error **errp)
401{
402 ObjectProperty *prop;
b604a854
PF
403 GHashTableIter iter;
404 gpointer key, value;
57c9fafe 405
b604a854
PF
406 g_hash_table_iter_init(&iter, obj->properties);
407 while (g_hash_table_iter_next(&iter, &key, &value)) {
408 prop = value;
409 if (object_property_is_child(prop) && prop->opaque == child) {
410 if (prop->release) {
411 prop->release(obj, prop->name, prop->opaque);
412 prop->release = NULL;
413 }
414 break;
415 }
416 }
417 g_hash_table_iter_init(&iter, obj->properties);
418 while (g_hash_table_iter_next(&iter, &key, &value)) {
419 prop = value;
5d9d3f47 420 if (object_property_is_child(prop) && prop->opaque == child) {
b604a854 421 g_hash_table_iter_remove(&iter);
6c1fdcf9 422 break;
57c9fafe
AL
423 }
424 }
425}
426
427void object_unparent(Object *obj)
428{
e998fa8d
MT
429 if (obj->parent) {
430 object_property_del_child(obj->parent, obj, NULL);
431 }
57c9fafe
AL
432}
433
2f28d2ff
AL
434static void object_deinit(Object *obj, TypeImpl *type)
435{
436 if (type->instance_finalize) {
437 type->instance_finalize(obj);
438 }
439
2f28d2ff
AL
440 if (type_has_parent(type)) {
441 object_deinit(obj, type_get_parent(type));
442 }
443}
444
339c2708 445static void object_finalize(void *data)
2f28d2ff
AL
446{
447 Object *obj = data;
448 TypeImpl *ti = obj->class->type;
449
57c9fafe 450 object_property_del_all(obj);
76a6e1cc 451 object_deinit(obj, ti);
db85b575
AL
452
453 g_assert(obj->ref == 0);
fde9bf44
PB
454 if (obj->free) {
455 obj->free(obj);
456 }
2f28d2ff
AL
457}
458
459Object *object_new_with_type(Type type)
460{
461 Object *obj;
462
463 g_assert(type != NULL);
ac451033 464 type_initialize(type);
2f28d2ff
AL
465
466 obj = g_malloc(type->instance_size);
5b9237f6 467 object_initialize_with_type(obj, type->instance_size, type);
fde9bf44 468 obj->free = g_free;
2f28d2ff
AL
469
470 return obj;
471}
472
473Object *object_new(const char *typename)
474{
475 TypeImpl *ti = type_get_by_name(typename);
476
477 return object_new_with_type(ti);
478}
479
a31bdae5
DB
480
481Object *object_new_with_props(const char *typename,
482 Object *parent,
483 const char *id,
484 Error **errp,
485 ...)
486{
487 va_list vargs;
488 Object *obj;
489
490 va_start(vargs, errp);
491 obj = object_new_with_propv(typename, parent, id, errp, vargs);
492 va_end(vargs);
493
494 return obj;
495}
496
497
498Object *object_new_with_propv(const char *typename,
499 Object *parent,
500 const char *id,
501 Error **errp,
502 va_list vargs)
503{
504 Object *obj;
505 ObjectClass *klass;
506 Error *local_err = NULL;
507
508 klass = object_class_by_name(typename);
509 if (!klass) {
510 error_setg(errp, "invalid object type: %s", typename);
511 return NULL;
512 }
513
514 if (object_class_is_abstract(klass)) {
515 error_setg(errp, "object type '%s' is abstract", typename);
516 return NULL;
517 }
518 obj = object_new(typename);
519
520 if (object_set_propv(obj, &local_err, vargs) < 0) {
521 goto error;
522 }
523
524 object_property_add_child(parent, id, obj, &local_err);
525 if (local_err) {
526 goto error;
527 }
528
529 if (object_dynamic_cast(obj, TYPE_USER_CREATABLE)) {
530 user_creatable_complete(obj, &local_err);
531 if (local_err) {
532 object_unparent(obj);
533 goto error;
534 }
535 }
536
537 object_unref(OBJECT(obj));
538 return obj;
539
540 error:
541 if (local_err) {
542 error_propagate(errp, local_err);
543 }
544 object_unref(obj);
545 return NULL;
546}
547
548
549int object_set_props(Object *obj,
550 Error **errp,
551 ...)
552{
553 va_list vargs;
554 int ret;
555
556 va_start(vargs, errp);
557 ret = object_set_propv(obj, errp, vargs);
558 va_end(vargs);
559
560 return ret;
561}
562
563
564int object_set_propv(Object *obj,
565 Error **errp,
566 va_list vargs)
567{
568 const char *propname;
569 Error *local_err = NULL;
570
571 propname = va_arg(vargs, char *);
572 while (propname != NULL) {
573 const char *value = va_arg(vargs, char *);
574
575 g_assert(value != NULL);
576 object_property_parse(obj, value, propname, &local_err);
577 if (local_err) {
578 error_propagate(errp, local_err);
579 return -1;
580 }
581 propname = va_arg(vargs, char *);
582 }
583
584 return 0;
585}
586
587
2f28d2ff
AL
588Object *object_dynamic_cast(Object *obj, const char *typename)
589{
b7f43fe4 590 if (obj && object_class_dynamic_cast(object_get_class(obj), typename)) {
acc4af3f
PB
591 return obj;
592 }
593
2f28d2ff
AL
594 return NULL;
595}
596
be17f18b
PB
597Object *object_dynamic_cast_assert(Object *obj, const char *typename,
598 const char *file, int line, const char *func)
2f28d2ff 599{
fa131d94
PB
600 trace_object_dynamic_cast_assert(obj ? obj->class->type->name : "(null)",
601 typename, file, line, func);
602
3556c233 603#ifdef CONFIG_QOM_CAST_DEBUG
03587328
AL
604 int i;
605 Object *inst;
606
95916abc 607 for (i = 0; obj && i < OBJECT_CLASS_CAST_CACHE; i++) {
0ab4c94c 608 if (obj->class->object_cast_cache[i] == typename) {
03587328
AL
609 goto out;
610 }
611 }
612
613 inst = object_dynamic_cast(obj, typename);
2f28d2ff 614
b7f43fe4 615 if (!inst && obj) {
be17f18b
PB
616 fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
617 file, line, func, obj, typename);
2f28d2ff
AL
618 abort();
619 }
620
3556c233 621 assert(obj == inst);
03587328 622
95916abc 623 if (obj && obj == inst) {
03587328 624 for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
0ab4c94c
PC
625 obj->class->object_cast_cache[i - 1] =
626 obj->class->object_cast_cache[i];
03587328 627 }
0ab4c94c 628 obj->class->object_cast_cache[i - 1] = typename;
03587328
AL
629 }
630
631out:
3556c233
PB
632#endif
633 return obj;
2f28d2ff
AL
634}
635
636ObjectClass *object_class_dynamic_cast(ObjectClass *class,
637 const char *typename)
638{
33e95c63 639 ObjectClass *ret = NULL;
bf0fda34
PB
640 TypeImpl *target_type;
641 TypeImpl *type;
2f28d2ff 642
bf0fda34
PB
643 if (!class) {
644 return NULL;
645 }
646
793c96b5 647 /* A simple fast path that can trigger a lot for leaf classes. */
bf0fda34 648 type = class->type;
793c96b5
PB
649 if (type->name == typename) {
650 return class;
651 }
652
bf0fda34 653 target_type = type_get_by_name(typename);
9ab880b3
AG
654 if (!target_type) {
655 /* target class type unknown, so fail the cast */
656 return NULL;
657 }
658
00e2ceae
PC
659 if (type->class->interfaces &&
660 type_is_ancestor(target_type, type_interface)) {
33e95c63
AL
661 int found = 0;
662 GSList *i;
2f28d2ff 663
33e95c63
AL
664 for (i = class->interfaces; i; i = i->next) {
665 ObjectClass *target_class = i->data;
666
667 if (type_is_ancestor(target_class->type, target_type)) {
668 ret = target_class;
669 found++;
670 }
671 }
672
673 /* The match was ambiguous, don't allow a cast */
674 if (found > 1) {
675 ret = NULL;
676 }
677 } else if (type_is_ancestor(type, target_type)) {
678 ret = class;
2f28d2ff
AL
679 }
680
33e95c63 681 return ret;
2f28d2ff
AL
682}
683
684ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class,
be17f18b
PB
685 const char *typename,
686 const char *file, int line,
687 const char *func)
2f28d2ff 688{
fa131d94
PB
689 ObjectClass *ret;
690
691 trace_object_class_dynamic_cast_assert(class ? class->type->name : "(null)",
692 typename, file, line, func);
2f28d2ff 693
03587328
AL
694#ifdef CONFIG_QOM_CAST_DEBUG
695 int i;
696
9d6a3d58 697 for (i = 0; class && i < OBJECT_CLASS_CAST_CACHE; i++) {
0ab4c94c 698 if (class->class_cast_cache[i] == typename) {
03587328
AL
699 ret = class;
700 goto out;
701 }
702 }
703#else
9d6a3d58 704 if (!class || !class->interfaces) {
3556c233
PB
705 return class;
706 }
707#endif
708
fa131d94 709 ret = object_class_dynamic_cast(class, typename);
bf0fda34 710 if (!ret && class) {
be17f18b
PB
711 fprintf(stderr, "%s:%d:%s: Object %p is not an instance of type %s\n",
712 file, line, func, class, typename);
2f28d2ff
AL
713 abort();
714 }
715
03587328 716#ifdef CONFIG_QOM_CAST_DEBUG
9d6a3d58 717 if (class && ret == class) {
03587328 718 for (i = 1; i < OBJECT_CLASS_CAST_CACHE; i++) {
0ab4c94c 719 class->class_cast_cache[i - 1] = class->class_cast_cache[i];
03587328 720 }
0ab4c94c 721 class->class_cast_cache[i - 1] = typename;
03587328
AL
722 }
723out:
724#endif
2f28d2ff
AL
725 return ret;
726}
727
728const char *object_get_typename(Object *obj)
729{
730 return obj->class->type->name;
731}
732
733ObjectClass *object_get_class(Object *obj)
734{
735 return obj->class;
736}
737
17862378
AF
738bool object_class_is_abstract(ObjectClass *klass)
739{
740 return klass->type->abstract;
741}
742
2f28d2ff
AL
743const char *object_class_get_name(ObjectClass *klass)
744{
745 return klass->type->name;
746}
747
748ObjectClass *object_class_by_name(const char *typename)
749{
750 TypeImpl *type = type_get_by_name(typename);
751
752 if (!type) {
753 return NULL;
754 }
755
ac451033 756 type_initialize(type);
2f28d2ff
AL
757
758 return type->class;
759}
760
e7cce67f
PB
761ObjectClass *object_class_get_parent(ObjectClass *class)
762{
763 TypeImpl *type = type_get_parent(class->type);
764
765 if (!type) {
766 return NULL;
767 }
768
769 type_initialize(type);
770
771 return type->class;
772}
773
2f28d2ff
AL
774typedef struct OCFData
775{
776 void (*fn)(ObjectClass *klass, void *opaque);
93c511a1
AL
777 const char *implements_type;
778 bool include_abstract;
2f28d2ff
AL
779 void *opaque;
780} OCFData;
781
782static void object_class_foreach_tramp(gpointer key, gpointer value,
783 gpointer opaque)
784{
785 OCFData *data = opaque;
786 TypeImpl *type = value;
93c511a1 787 ObjectClass *k;
2f28d2ff 788
ac451033 789 type_initialize(type);
93c511a1 790 k = type->class;
2f28d2ff 791
93c511a1
AL
792 if (!data->include_abstract && type->abstract) {
793 return;
794 }
795
796 if (data->implements_type &&
797 !object_class_dynamic_cast(k, data->implements_type)) {
798 return;
799 }
800
801 data->fn(k, data->opaque);
2f28d2ff
AL
802}
803
804void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque),
93c511a1 805 const char *implements_type, bool include_abstract,
2f28d2ff
AL
806 void *opaque)
807{
93c511a1 808 OCFData data = { fn, implements_type, include_abstract, opaque };
2f28d2ff 809
f54c19ca 810 enumerating_types = true;
2f28d2ff 811 g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data);
f54c19ca 812 enumerating_types = false;
2f28d2ff 813}
57c9fafe 814
d714b8de
PC
815static int do_object_child_foreach(Object *obj,
816 int (*fn)(Object *child, void *opaque),
817 void *opaque, bool recurse)
32efc535 818{
b604a854
PF
819 GHashTableIter iter;
820 ObjectProperty *prop;
32efc535
PB
821 int ret = 0;
822
b604a854
PF
823 g_hash_table_iter_init(&iter, obj->properties);
824 while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
32efc535 825 if (object_property_is_child(prop)) {
d714b8de
PC
826 Object *child = prop->opaque;
827
828 ret = fn(child, opaque);
32efc535
PB
829 if (ret != 0) {
830 break;
831 }
d714b8de
PC
832 if (recurse) {
833 do_object_child_foreach(child, fn, opaque, true);
834 }
32efc535
PB
835 }
836 }
837 return ret;
838}
839
d714b8de
PC
840int object_child_foreach(Object *obj, int (*fn)(Object *child, void *opaque),
841 void *opaque)
842{
843 return do_object_child_foreach(obj, fn, opaque, false);
844}
845
846int object_child_foreach_recursive(Object *obj,
847 int (*fn)(Object *child, void *opaque),
848 void *opaque)
849{
850 return do_object_child_foreach(obj, fn, opaque, true);
851}
852
418ba9e5
AF
853static void object_class_get_list_tramp(ObjectClass *klass, void *opaque)
854{
855 GSList **list = opaque;
856
857 *list = g_slist_prepend(*list, klass);
858}
859
860GSList *object_class_get_list(const char *implements_type,
861 bool include_abstract)
862{
863 GSList *list = NULL;
864
865 object_class_foreach(object_class_get_list_tramp,
866 implements_type, include_abstract, &list);
867 return list;
868}
869
57c9fafe
AL
870void object_ref(Object *obj)
871{
8ffad850
PC
872 if (!obj) {
873 return;
874 }
f08c03f3 875 atomic_inc(&obj->ref);
57c9fafe
AL
876}
877
878void object_unref(Object *obj)
879{
8ffad850
PC
880 if (!obj) {
881 return;
882 }
57c9fafe 883 g_assert(obj->ref > 0);
57c9fafe
AL
884
885 /* parent always holds a reference to its children */
f08c03f3 886 if (atomic_fetch_dec(&obj->ref) == 1) {
57c9fafe
AL
887 object_finalize(obj);
888 }
889}
890
64607d08
PB
891ObjectProperty *
892object_property_add(Object *obj, const char *name, const char *type,
893 ObjectPropertyAccessor *get,
894 ObjectPropertyAccessor *set,
895 ObjectPropertyRelease *release,
896 void *opaque, Error **errp)
57c9fafe 897{
54852b03 898 ObjectProperty *prop;
33965904
PC
899 size_t name_len = strlen(name);
900
901 if (name_len >= 3 && !memcmp(name + name_len - 3, "[*]", 4)) {
902 int i;
903 ObjectProperty *ret;
904 char *name_no_array = g_strdup(name);
905
906 name_no_array[name_len - 3] = '\0';
907 for (i = 0; ; ++i) {
908 char *full_name = g_strdup_printf("%s[%d]", name_no_array, i);
909
910 ret = object_property_add(obj, full_name, type, get, set,
911 release, opaque, NULL);
912 g_free(full_name);
913 if (ret) {
914 break;
915 }
916 }
917 g_free(name_no_array);
918 return ret;
919 }
54852b03 920
b604a854
PF
921 if (g_hash_table_lookup(obj->properties, name) != NULL) {
922 error_setg(errp, "attempt to add duplicate property '%s'"
54852b03
PM
923 " to object (type '%s')", name,
924 object_get_typename(obj));
b604a854 925 return NULL;
54852b03
PM
926 }
927
928 prop = g_malloc0(sizeof(*prop));
57c9fafe
AL
929
930 prop->name = g_strdup(name);
931 prop->type = g_strdup(type);
932
933 prop->get = get;
934 prop->set = set;
935 prop->release = release;
936 prop->opaque = opaque;
937
b604a854 938 g_hash_table_insert(obj->properties, prop->name, prop);
64607d08 939 return prop;
57c9fafe
AL
940}
941
89bfe000
PB
942ObjectProperty *object_property_find(Object *obj, const char *name,
943 Error **errp)
57c9fafe
AL
944{
945 ObjectProperty *prop;
946
b604a854
PF
947 prop = g_hash_table_lookup(obj->properties, name);
948 if (prop) {
949 return prop;
57c9fafe
AL
950 }
951
f231b88d 952 error_setg(errp, "Property '.%s' not found", name);
57c9fafe
AL
953 return NULL;
954}
955
a00c9482
DB
956ObjectPropertyIterator *object_property_iter_init(Object *obj)
957{
958 ObjectPropertyIterator *ret = g_new0(ObjectPropertyIterator, 1);
b604a854 959 g_hash_table_iter_init(&ret->iter, obj->properties);
a00c9482
DB
960 return ret;
961}
962
963void object_property_iter_free(ObjectPropertyIterator *iter)
964{
965 if (!iter) {
966 return;
967 }
968 g_free(iter);
969}
970
971ObjectProperty *object_property_iter_next(ObjectPropertyIterator *iter)
972{
b604a854
PF
973 gpointer key, val;
974 if (!g_hash_table_iter_next(&iter->iter, &key, &val)) {
975 return NULL;
a00c9482 976 }
b604a854 977 return val;
a00c9482
DB
978}
979
57c9fafe
AL
980void object_property_del(Object *obj, const char *name, Error **errp)
981{
b604a854
PF
982 ObjectProperty *prop = g_hash_table_lookup(obj->properties, name);
983
984 if (!prop) {
985 error_setg(errp, "Property '.%s' not found", name);
0866aca1
AL
986 return;
987 }
57c9fafe 988
0866aca1
AL
989 if (prop->release) {
990 prop->release(obj, name, prop->opaque);
991 }
b604a854 992 g_hash_table_remove(obj->properties, name);
57c9fafe
AL
993}
994
995void object_property_get(Object *obj, Visitor *v, const char *name,
996 Error **errp)
997{
89bfe000 998 ObjectProperty *prop = object_property_find(obj, name, errp);
57c9fafe 999 if (prop == NULL) {
57c9fafe
AL
1000 return;
1001 }
1002
1003 if (!prop->get) {
c6bd8c70 1004 error_setg(errp, QERR_PERMISSION_DENIED);
57c9fafe
AL
1005 } else {
1006 prop->get(obj, v, prop->opaque, name, errp);
1007 }
1008}
1009
1010void object_property_set(Object *obj, Visitor *v, const char *name,
1011 Error **errp)
1012{
89bfe000 1013 ObjectProperty *prop = object_property_find(obj, name, errp);
57c9fafe 1014 if (prop == NULL) {
57c9fafe
AL
1015 return;
1016 }
1017
1018 if (!prop->set) {
c6bd8c70 1019 error_setg(errp, QERR_PERMISSION_DENIED);
57c9fafe
AL
1020 } else {
1021 prop->set(obj, v, prop->opaque, name, errp);
1022 }
1023}
1024
7b7b7d18
PB
1025void object_property_set_str(Object *obj, const char *value,
1026 const char *name, Error **errp)
1027{
1028 QString *qstr = qstring_from_str(value);
1029 object_property_set_qobject(obj, QOBJECT(qstr), name, errp);
1030
1031 QDECREF(qstr);
1032}
1033
1034char *object_property_get_str(Object *obj, const char *name,
1035 Error **errp)
1036{
1037 QObject *ret = object_property_get_qobject(obj, name, errp);
1038 QString *qstring;
1039 char *retval;
1040
1041 if (!ret) {
1042 return NULL;
1043 }
1044 qstring = qobject_to_qstring(ret);
1045 if (!qstring) {
c6bd8c70 1046 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
7b7b7d18
PB
1047 retval = NULL;
1048 } else {
1049 retval = g_strdup(qstring_get_str(qstring));
1050 }
1051
1052 QDECREF(qstring);
1053 return retval;
1054}
1055
1d9c5a12
PB
1056void object_property_set_link(Object *obj, Object *value,
1057 const char *name, Error **errp)
1058{
d3c49316
PC
1059 if (value) {
1060 gchar *path = object_get_canonical_path(value);
1061 object_property_set_str(obj, path, name, errp);
1062 g_free(path);
1063 } else {
1064 object_property_set_str(obj, "", name, errp);
1065 }
1d9c5a12
PB
1066}
1067
1068Object *object_property_get_link(Object *obj, const char *name,
1069 Error **errp)
1070{
1071 char *str = object_property_get_str(obj, name, errp);
1072 Object *target = NULL;
1073
1074 if (str && *str) {
1075 target = object_resolve_path(str, NULL);
1076 if (!target) {
75158ebb
MA
1077 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1078 "Device '%s' not found", str);
1d9c5a12
PB
1079 }
1080 }
1081
1082 g_free(str);
1083 return target;
1084}
1085
7b7b7d18
PB
1086void object_property_set_bool(Object *obj, bool value,
1087 const char *name, Error **errp)
1088{
fc48ffc3 1089 QBool *qbool = qbool_from_bool(value);
7b7b7d18
PB
1090 object_property_set_qobject(obj, QOBJECT(qbool), name, errp);
1091
1092 QDECREF(qbool);
1093}
1094
1095bool object_property_get_bool(Object *obj, const char *name,
1096 Error **errp)
1097{
1098 QObject *ret = object_property_get_qobject(obj, name, errp);
1099 QBool *qbool;
1100 bool retval;
1101
1102 if (!ret) {
1103 return false;
1104 }
1105 qbool = qobject_to_qbool(ret);
1106 if (!qbool) {
c6bd8c70 1107 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean");
7b7b7d18
PB
1108 retval = false;
1109 } else {
fc48ffc3 1110 retval = qbool_get_bool(qbool);
7b7b7d18
PB
1111 }
1112
1113 QDECREF(qbool);
1114 return retval;
1115}
1116
1117void object_property_set_int(Object *obj, int64_t value,
1118 const char *name, Error **errp)
1119{
1120 QInt *qint = qint_from_int(value);
1121 object_property_set_qobject(obj, QOBJECT(qint), name, errp);
1122
1123 QDECREF(qint);
1124}
1125
1126int64_t object_property_get_int(Object *obj, const char *name,
1127 Error **errp)
1128{
1129 QObject *ret = object_property_get_qobject(obj, name, errp);
1130 QInt *qint;
1131 int64_t retval;
1132
1133 if (!ret) {
1134 return -1;
1135 }
1136 qint = qobject_to_qint(ret);
1137 if (!qint) {
c6bd8c70 1138 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "int");
7b7b7d18
PB
1139 retval = -1;
1140 } else {
1141 retval = qint_get_int(qint);
1142 }
1143
1144 QDECREF(qint);
1145 return retval;
b2cd7dee
PB
1146}
1147
a8e3fbed
DB
1148typedef struct EnumProperty {
1149 const char * const *strings;
1150 int (*get)(Object *, Error **);
1151 void (*set)(Object *, int, Error **);
1152} EnumProperty;
1153
1f21772d 1154int object_property_get_enum(Object *obj, const char *name,
a3590dac 1155 const char *typename, Error **errp)
1f21772d 1156{
4715d42e 1157 Error *err = NULL;
1f21772d
HT
1158 StringOutputVisitor *sov;
1159 StringInputVisitor *siv;
976620ac 1160 char *str;
1f21772d 1161 int ret;
a3590dac
DB
1162 ObjectProperty *prop = object_property_find(obj, name, errp);
1163 EnumProperty *enumprop;
1164
1165 if (prop == NULL) {
1166 return 0;
1167 }
1168
1169 if (!g_str_equal(prop->type, typename)) {
1170 error_setg(errp, "Property %s on %s is not '%s' enum type",
1171 name, object_class_get_name(
1172 object_get_class(obj)), typename);
1173 return 0;
1174 }
1175
1176 enumprop = prop->opaque;
1f21772d
HT
1177
1178 sov = string_output_visitor_new(false);
4715d42e
MA
1179 object_property_get(obj, string_output_get_visitor(sov), name, &err);
1180 if (err) {
1181 error_propagate(errp, err);
1182 string_output_visitor_cleanup(sov);
1183 return 0;
1184 }
976620ac
CF
1185 str = string_output_get_string(sov);
1186 siv = string_input_visitor_new(str);
1f21772d
HT
1187 string_output_visitor_cleanup(sov);
1188 visit_type_enum(string_input_get_visitor(siv),
a3590dac 1189 &ret, enumprop->strings, NULL, name, errp);
976620ac
CF
1190
1191 g_free(str);
1f21772d
HT
1192 string_input_visitor_cleanup(siv);
1193
1194 return ret;
1195}
1196
1197void object_property_get_uint16List(Object *obj, const char *name,
1198 uint16List **list, Error **errp)
1199{
4715d42e 1200 Error *err = NULL;
1f21772d
HT
1201 StringOutputVisitor *ov;
1202 StringInputVisitor *iv;
976620ac 1203 char *str;
1f21772d
HT
1204
1205 ov = string_output_visitor_new(false);
1206 object_property_get(obj, string_output_get_visitor(ov),
4715d42e
MA
1207 name, &err);
1208 if (err) {
1209 error_propagate(errp, err);
1210 goto out;
1211 }
976620ac
CF
1212 str = string_output_get_string(ov);
1213 iv = string_input_visitor_new(str);
1f21772d
HT
1214 visit_type_uint16List(string_input_get_visitor(iv),
1215 list, NULL, errp);
976620ac
CF
1216
1217 g_free(str);
1f21772d 1218 string_input_visitor_cleanup(iv);
4715d42e
MA
1219out:
1220 string_output_visitor_cleanup(ov);
1f21772d
HT
1221}
1222
b2cd7dee
PB
1223void object_property_parse(Object *obj, const char *string,
1224 const char *name, Error **errp)
1225{
f8b7f1a8
EB
1226 StringInputVisitor *siv;
1227 siv = string_input_visitor_new(string);
1228 object_property_set(obj, string_input_get_visitor(siv), name, errp);
b2cd7dee 1229
f8b7f1a8 1230 string_input_visitor_cleanup(siv);
b2cd7dee
PB
1231}
1232
0b7593e0 1233char *object_property_print(Object *obj, const char *name, bool human,
b2cd7dee
PB
1234 Error **errp)
1235{
f8b7f1a8 1236 StringOutputVisitor *sov;
3a53009f
GA
1237 char *string = NULL;
1238 Error *local_err = NULL;
b2cd7dee 1239
f8b7f1a8
EB
1240 sov = string_output_visitor_new(human);
1241 object_property_get(obj, string_output_get_visitor(sov), name, &local_err);
3a53009f
GA
1242 if (local_err) {
1243 error_propagate(errp, local_err);
1244 goto out;
1245 }
1246
f8b7f1a8 1247 string = string_output_get_string(sov);
3a53009f
GA
1248
1249out:
f8b7f1a8 1250 string_output_visitor_cleanup(sov);
b2cd7dee 1251 return string;
7b7b7d18
PB
1252}
1253
57c9fafe
AL
1254const char *object_property_get_type(Object *obj, const char *name, Error **errp)
1255{
89bfe000 1256 ObjectProperty *prop = object_property_find(obj, name, errp);
57c9fafe 1257 if (prop == NULL) {
57c9fafe
AL
1258 return NULL;
1259 }
1260
1261 return prop->type;
1262}
1263
1264Object *object_get_root(void)
1265{
8b45d447 1266 static Object *root;
57c9fafe 1267
8b45d447
AL
1268 if (!root) {
1269 root = object_new("container");
57c9fafe
AL
1270 }
1271
8b45d447 1272 return root;
57c9fafe
AL
1273}
1274
bc2256c4
DB
1275Object *object_get_objects_root(void)
1276{
1277 return container_get(object_get_root(), "/objects");
1278}
1279
57c9fafe
AL
1280static void object_get_child_property(Object *obj, Visitor *v, void *opaque,
1281 const char *name, Error **errp)
1282{
1283 Object *child = opaque;
1284 gchar *path;
1285
1286 path = object_get_canonical_path(child);
1287 visit_type_str(v, &path, name, errp);
1288 g_free(path);
1289}
1290
64607d08
PB
1291static Object *object_resolve_child_property(Object *parent, void *opaque, const gchar *part)
1292{
1293 return opaque;
1294}
1295
db85b575
AL
1296static void object_finalize_child_property(Object *obj, const char *name,
1297 void *opaque)
1298{
1299 Object *child = opaque;
1300
bffc687d
PB
1301 if (child->class->unparent) {
1302 (child->class->unparent)(child);
1303 }
1304 child->parent = NULL;
db85b575
AL
1305 object_unref(child);
1306}
1307
57c9fafe
AL
1308void object_property_add_child(Object *obj, const char *name,
1309 Object *child, Error **errp)
1310{
b0ed5e9f 1311 Error *local_err = NULL;
57c9fafe 1312 gchar *type;
64607d08 1313 ObjectProperty *op;
57c9fafe 1314
8faa2f85
PC
1315 if (child->parent != NULL) {
1316 error_setg(errp, "child object is already parented");
1317 return;
1318 }
1319
57c9fafe
AL
1320 type = g_strdup_printf("child<%s>", object_get_typename(OBJECT(child)));
1321
64607d08
PB
1322 op = object_property_add(obj, name, type, object_get_child_property, NULL,
1323 object_finalize_child_property, child, &local_err);
b0ed5e9f
PB
1324 if (local_err) {
1325 error_propagate(errp, local_err);
1326 goto out;
1327 }
64607d08
PB
1328
1329 op->resolve = object_resolve_child_property;
57c9fafe 1330 object_ref(child);
57c9fafe
AL
1331 child->parent = obj;
1332
b0ed5e9f 1333out:
57c9fafe
AL
1334 g_free(type);
1335}
1336
39f72ef9
SH
1337void object_property_allow_set_link(Object *obj, const char *name,
1338 Object *val, Error **errp)
1339{
1340 /* Allow the link to be set, always */
1341}
1342
9561fda8
SH
1343typedef struct {
1344 Object **child;
39f72ef9 1345 void (*check)(Object *, const char *, Object *, Error **);
9561fda8
SH
1346 ObjectPropertyLinkFlags flags;
1347} LinkProperty;
1348
57c9fafe
AL
1349static void object_get_link_property(Object *obj, Visitor *v, void *opaque,
1350 const char *name, Error **errp)
1351{
9561fda8
SH
1352 LinkProperty *lprop = opaque;
1353 Object **child = lprop->child;
57c9fafe
AL
1354 gchar *path;
1355
1356 if (*child) {
1357 path = object_get_canonical_path(*child);
1358 visit_type_str(v, &path, name, errp);
1359 g_free(path);
1360 } else {
1361 path = (gchar *)"";
1362 visit_type_str(v, &path, name, errp);
1363 }
1364}
1365
f5ec6704
SH
1366/*
1367 * object_resolve_link:
1368 *
1369 * Lookup an object and ensure its type matches the link property type. This
1370 * is similar to object_resolve_path() except type verification against the
1371 * link property is performed.
1372 *
1373 * Returns: The matched object or NULL on path lookup failures.
1374 */
1375static Object *object_resolve_link(Object *obj, const char *name,
1376 const char *path, Error **errp)
1377{
1378 const char *type;
1379 gchar *target_type;
1380 bool ambiguous = false;
1381 Object *target;
1382
1383 /* Go from link<FOO> to FOO. */
1384 type = object_property_get_type(obj, name, NULL);
1385 target_type = g_strndup(&type[5], strlen(type) - 6);
1386 target = object_resolve_path_type(path, target_type, &ambiguous);
1387
1388 if (ambiguous) {
455b0fde
EB
1389 error_setg(errp, "Path '%s' does not uniquely identify an object",
1390 path);
f5ec6704
SH
1391 } else if (!target) {
1392 target = object_resolve_path(path, &ambiguous);
1393 if (target || ambiguous) {
c6bd8c70 1394 error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, target_type);
f5ec6704 1395 } else {
75158ebb
MA
1396 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
1397 "Device '%s' not found", path);
f5ec6704
SH
1398 }
1399 target = NULL;
1400 }
1401 g_free(target_type);
1402
1403 return target;
1404}
1405
57c9fafe
AL
1406static void object_set_link_property(Object *obj, Visitor *v, void *opaque,
1407 const char *name, Error **errp)
1408{
c6aed983 1409 Error *local_err = NULL;
9561fda8
SH
1410 LinkProperty *prop = opaque;
1411 Object **child = prop->child;
c6aed983
SH
1412 Object *old_target = *child;
1413 Object *new_target = NULL;
1414 char *path = NULL;
57c9fafe 1415
c6aed983 1416 visit_type_str(v, &path, name, &local_err);
57c9fafe 1417
c6aed983
SH
1418 if (!local_err && strcmp(path, "") != 0) {
1419 new_target = object_resolve_link(obj, name, path, &local_err);
57c9fafe
AL
1420 }
1421
1422 g_free(path);
c6aed983
SH
1423 if (local_err) {
1424 error_propagate(errp, local_err);
1425 return;
1426 }
f0cdc966 1427
39f72ef9
SH
1428 prop->check(obj, name, new_target, &local_err);
1429 if (local_err) {
1430 error_propagate(errp, local_err);
1431 return;
1432 }
1433
8ffad850 1434 object_ref(new_target);
c6aed983 1435 *child = new_target;
8ffad850 1436 object_unref(old_target);
57c9fafe
AL
1437}
1438
64607d08
PB
1439static Object *object_resolve_link_property(Object *parent, void *opaque, const gchar *part)
1440{
1441 LinkProperty *lprop = opaque;
1442
1443 return *lprop->child;
1444}
1445
9561fda8
SH
1446static void object_release_link_property(Object *obj, const char *name,
1447 void *opaque)
1448{
1449 LinkProperty *prop = opaque;
1450
1451 if ((prop->flags & OBJ_PROP_LINK_UNREF_ON_RELEASE) && *prop->child) {
1452 object_unref(*prop->child);
1453 }
1454 g_free(prop);
1455}
1456
57c9fafe
AL
1457void object_property_add_link(Object *obj, const char *name,
1458 const char *type, Object **child,
39f72ef9
SH
1459 void (*check)(Object *, const char *,
1460 Object *, Error **),
9561fda8 1461 ObjectPropertyLinkFlags flags,
57c9fafe
AL
1462 Error **errp)
1463{
9561fda8
SH
1464 Error *local_err = NULL;
1465 LinkProperty *prop = g_malloc(sizeof(*prop));
57c9fafe 1466 gchar *full_type;
64607d08 1467 ObjectProperty *op;
57c9fafe 1468
9561fda8 1469 prop->child = child;
39f72ef9 1470 prop->check = check;
9561fda8
SH
1471 prop->flags = flags;
1472
57c9fafe
AL
1473 full_type = g_strdup_printf("link<%s>", type);
1474
64607d08
PB
1475 op = object_property_add(obj, name, full_type,
1476 object_get_link_property,
1477 check ? object_set_link_property : NULL,
1478 object_release_link_property,
1479 prop,
1480 &local_err);
9561fda8
SH
1481 if (local_err) {
1482 error_propagate(errp, local_err);
1483 g_free(prop);
64607d08 1484 goto out;
9561fda8 1485 }
57c9fafe 1486
64607d08
PB
1487 op->resolve = object_resolve_link_property;
1488
1489out:
57c9fafe
AL
1490 g_free(full_type);
1491}
1492
fb9e7e33
PB
1493void object_property_add_const_link(Object *obj, const char *name,
1494 Object *target, Error **errp)
1495{
1496 char *link_type;
1497 ObjectProperty *op;
1498
1499 link_type = g_strdup_printf("link<%s>", object_get_typename(target));
1500 op = object_property_add(obj, name, link_type,
1501 object_get_child_property, NULL,
1502 NULL, target, errp);
1503 if (op != NULL) {
1504 op->resolve = object_resolve_child_property;
1505 }
1506 g_free(link_type);
1507}
1508
11f590b1
SH
1509gchar *object_get_canonical_path_component(Object *obj)
1510{
1511 ObjectProperty *prop = NULL;
b604a854 1512 GHashTableIter iter;
11f590b1
SH
1513
1514 g_assert(obj);
1515 g_assert(obj->parent != NULL);
1516
b604a854
PF
1517 g_hash_table_iter_init(&iter, obj->parent->properties);
1518 while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
11f590b1
SH
1519 if (!object_property_is_child(prop)) {
1520 continue;
1521 }
1522
1523 if (prop->opaque == obj) {
1524 return g_strdup(prop->name);
1525 }
1526 }
1527
1528 /* obj had a parent but was not a child, should never happen */
1529 g_assert_not_reached();
1530 return NULL;
1531}
1532
57c9fafe
AL
1533gchar *object_get_canonical_path(Object *obj)
1534{
1535 Object *root = object_get_root();
11f590b1 1536 char *newpath, *path = NULL;
57c9fafe
AL
1537
1538 while (obj != root) {
11f590b1 1539 char *component = object_get_canonical_path_component(obj);
57c9fafe 1540
11f590b1
SH
1541 if (path) {
1542 newpath = g_strdup_printf("%s/%s", component, path);
1543 g_free(component);
1544 g_free(path);
1545 path = newpath;
1546 } else {
1547 path = component;
57c9fafe
AL
1548 }
1549
57c9fafe
AL
1550 obj = obj->parent;
1551 }
1552
11f590b1 1553 newpath = g_strdup_printf("/%s", path ? path : "");
57c9fafe
AL
1554 g_free(path);
1555
1556 return newpath;
1557}
1558
3e84b483 1559Object *object_resolve_path_component(Object *parent, const gchar *part)
a612b2a6 1560{
89bfe000 1561 ObjectProperty *prop = object_property_find(parent, part, NULL);
a612b2a6
PB
1562 if (prop == NULL) {
1563 return NULL;
1564 }
1565
64607d08
PB
1566 if (prop->resolve) {
1567 return prop->resolve(parent, prop->opaque, part);
a612b2a6
PB
1568 } else {
1569 return NULL;
1570 }
1571}
1572
57c9fafe
AL
1573static Object *object_resolve_abs_path(Object *parent,
1574 gchar **parts,
02fe2db6 1575 const char *typename,
57c9fafe
AL
1576 int index)
1577{
57c9fafe
AL
1578 Object *child;
1579
1580 if (parts[index] == NULL) {
02fe2db6 1581 return object_dynamic_cast(parent, typename);
57c9fafe
AL
1582 }
1583
1584 if (strcmp(parts[index], "") == 0) {
02fe2db6 1585 return object_resolve_abs_path(parent, parts, typename, index + 1);
57c9fafe
AL
1586 }
1587
a612b2a6 1588 child = object_resolve_path_component(parent, parts[index]);
57c9fafe
AL
1589 if (!child) {
1590 return NULL;
1591 }
1592
02fe2db6 1593 return object_resolve_abs_path(child, parts, typename, index + 1);
57c9fafe
AL
1594}
1595
1596static Object *object_resolve_partial_path(Object *parent,
1597 gchar **parts,
02fe2db6 1598 const char *typename,
57c9fafe
AL
1599 bool *ambiguous)
1600{
1601 Object *obj;
b604a854 1602 GHashTableIter iter;
57c9fafe
AL
1603 ObjectProperty *prop;
1604
02fe2db6 1605 obj = object_resolve_abs_path(parent, parts, typename, 0);
57c9fafe 1606
b604a854
PF
1607 g_hash_table_iter_init(&iter, parent->properties);
1608 while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&prop)) {
57c9fafe
AL
1609 Object *found;
1610
5d9d3f47 1611 if (!object_property_is_child(prop)) {
57c9fafe
AL
1612 continue;
1613 }
1614
02fe2db6
PB
1615 found = object_resolve_partial_path(prop->opaque, parts,
1616 typename, ambiguous);
57c9fafe
AL
1617 if (found) {
1618 if (obj) {
1619 if (ambiguous) {
1620 *ambiguous = true;
1621 }
1622 return NULL;
1623 }
1624 obj = found;
1625 }
1626
1627 if (ambiguous && *ambiguous) {
1628 return NULL;
1629 }
1630 }
1631
1632 return obj;
1633}
1634
02fe2db6
PB
1635Object *object_resolve_path_type(const char *path, const char *typename,
1636 bool *ambiguous)
57c9fafe 1637{
57c9fafe
AL
1638 Object *obj;
1639 gchar **parts;
1640
1641 parts = g_strsplit(path, "/", 0);
2e1103f6 1642 assert(parts);
57c9fafe 1643
2e1103f6 1644 if (parts[0] == NULL || strcmp(parts[0], "") != 0) {
57c9fafe
AL
1645 if (ambiguous) {
1646 *ambiguous = false;
1647 }
02fe2db6
PB
1648 obj = object_resolve_partial_path(object_get_root(), parts,
1649 typename, ambiguous);
57c9fafe 1650 } else {
02fe2db6 1651 obj = object_resolve_abs_path(object_get_root(), parts, typename, 1);
57c9fafe
AL
1652 }
1653
1654 g_strfreev(parts);
1655
1656 return obj;
1657}
1658
02fe2db6
PB
1659Object *object_resolve_path(const char *path, bool *ambiguous)
1660{
1661 return object_resolve_path_type(path, TYPE_OBJECT, ambiguous);
1662}
1663
57c9fafe
AL
1664typedef struct StringProperty
1665{
1666 char *(*get)(Object *, Error **);
1667 void (*set)(Object *, const char *, Error **);
1668} StringProperty;
1669
7b7b7d18
PB
1670static void property_get_str(Object *obj, Visitor *v, void *opaque,
1671 const char *name, Error **errp)
57c9fafe
AL
1672{
1673 StringProperty *prop = opaque;
1674 char *value;
e1c8237d 1675 Error *err = NULL;
57c9fafe 1676
e1c8237d
MA
1677 value = prop->get(obj, &err);
1678 if (err) {
1679 error_propagate(errp, err);
1680 return;
57c9fafe 1681 }
e1c8237d
MA
1682
1683 visit_type_str(v, &value, name, errp);
1684 g_free(value);
57c9fafe
AL
1685}
1686
7b7b7d18
PB
1687static void property_set_str(Object *obj, Visitor *v, void *opaque,
1688 const char *name, Error **errp)
57c9fafe
AL
1689{
1690 StringProperty *prop = opaque;
1691 char *value;
1692 Error *local_err = NULL;
1693
1694 visit_type_str(v, &value, name, &local_err);
1695 if (local_err) {
1696 error_propagate(errp, local_err);
1697 return;
1698 }
1699
1700 prop->set(obj, value, errp);
1701 g_free(value);
1702}
1703
7b7b7d18
PB
1704static void property_release_str(Object *obj, const char *name,
1705 void *opaque)
57c9fafe
AL
1706{
1707 StringProperty *prop = opaque;
1708 g_free(prop);
1709}
1710
1711void object_property_add_str(Object *obj, const char *name,
1712 char *(*get)(Object *, Error **),
1713 void (*set)(Object *, const char *, Error **),
1714 Error **errp)
1715{
a01aedc8 1716 Error *local_err = NULL;
57c9fafe
AL
1717 StringProperty *prop = g_malloc0(sizeof(*prop));
1718
1719 prop->get = get;
1720 prop->set = set;
1721
1722 object_property_add(obj, name, "string",
7b7b7d18
PB
1723 get ? property_get_str : NULL,
1724 set ? property_set_str : NULL,
1725 property_release_str,
a01aedc8
SH
1726 prop, &local_err);
1727 if (local_err) {
1728 error_propagate(errp, local_err);
1729 g_free(prop);
1730 }
57c9fafe 1731}
745549c8 1732
0e558843
AL
1733typedef struct BoolProperty
1734{
1735 bool (*get)(Object *, Error **);
1736 void (*set)(Object *, bool, Error **);
1737} BoolProperty;
1738
1739static void property_get_bool(Object *obj, Visitor *v, void *opaque,
1740 const char *name, Error **errp)
1741{
1742 BoolProperty *prop = opaque;
1743 bool value;
4715d42e
MA
1744 Error *err = NULL;
1745
1746 value = prop->get(obj, &err);
1747 if (err) {
1748 error_propagate(errp, err);
1749 return;
1750 }
0e558843 1751
0e558843
AL
1752 visit_type_bool(v, &value, name, errp);
1753}
1754
1755static void property_set_bool(Object *obj, Visitor *v, void *opaque,
1756 const char *name, Error **errp)
1757{
1758 BoolProperty *prop = opaque;
1759 bool value;
1760 Error *local_err = NULL;
1761
1762 visit_type_bool(v, &value, name, &local_err);
1763 if (local_err) {
1764 error_propagate(errp, local_err);
1765 return;
1766 }
1767
1768 prop->set(obj, value, errp);
1769}
1770
1771static void property_release_bool(Object *obj, const char *name,
1772 void *opaque)
1773{
1774 BoolProperty *prop = opaque;
1775 g_free(prop);
1776}
1777
1778void object_property_add_bool(Object *obj, const char *name,
1779 bool (*get)(Object *, Error **),
1780 void (*set)(Object *, bool, Error **),
1781 Error **errp)
1782{
a01aedc8 1783 Error *local_err = NULL;
0e558843
AL
1784 BoolProperty *prop = g_malloc0(sizeof(*prop));
1785
1786 prop->get = get;
1787 prop->set = set;
1788
1789 object_property_add(obj, name, "bool",
1790 get ? property_get_bool : NULL,
1791 set ? property_set_bool : NULL,
1792 property_release_bool,
a01aedc8
SH
1793 prop, &local_err);
1794 if (local_err) {
1795 error_propagate(errp, local_err);
1796 g_free(prop);
1797 }
0e558843
AL
1798}
1799
a8e3fbed
DB
1800static void property_get_enum(Object *obj, Visitor *v, void *opaque,
1801 const char *name, Error **errp)
1802{
1803 EnumProperty *prop = opaque;
1804 int value;
4715d42e
MA
1805 Error *err = NULL;
1806
1807 value = prop->get(obj, &err);
1808 if (err) {
1809 error_propagate(errp, err);
1810 return;
1811 }
a8e3fbed 1812
a8e3fbed
DB
1813 visit_type_enum(v, &value, prop->strings, NULL, name, errp);
1814}
1815
1816static void property_set_enum(Object *obj, Visitor *v, void *opaque,
1817 const char *name, Error **errp)
1818{
1819 EnumProperty *prop = opaque;
1820 int value;
4715d42e 1821 Error *err = NULL;
a8e3fbed 1822
4715d42e
MA
1823 visit_type_enum(v, &value, prop->strings, NULL, name, &err);
1824 if (err) {
1825 error_propagate(errp, err);
1826 return;
1827 }
a8e3fbed
DB
1828 prop->set(obj, value, errp);
1829}
1830
1831static void property_release_enum(Object *obj, const char *name,
1832 void *opaque)
1833{
1834 EnumProperty *prop = opaque;
1835 g_free(prop);
1836}
1837
1838void object_property_add_enum(Object *obj, const char *name,
1839 const char *typename,
1840 const char * const *strings,
1841 int (*get)(Object *, Error **),
1842 void (*set)(Object *, int, Error **),
1843 Error **errp)
1844{
1845 Error *local_err = NULL;
1846 EnumProperty *prop = g_malloc(sizeof(*prop));
1847
1848 prop->strings = strings;
1849 prop->get = get;
1850 prop->set = set;
1851
1852 object_property_add(obj, name, typename,
1853 get ? property_get_enum : NULL,
1854 set ? property_set_enum : NULL,
1855 property_release_enum,
1856 prop, &local_err);
1857 if (local_err) {
1858 error_propagate(errp, local_err);
1859 g_free(prop);
1860 }
1861}
1862
8e099d14
DG
1863typedef struct TMProperty {
1864 void (*get)(Object *, struct tm *, Error **);
1865} TMProperty;
1866
1867static void property_get_tm(Object *obj, Visitor *v, void *opaque,
1868 const char *name, Error **errp)
1869{
1870 TMProperty *prop = opaque;
1871 Error *err = NULL;
1872 struct tm value;
1873
1874 prop->get(obj, &value, &err);
1875 if (err) {
1876 goto out;
1877 }
1878
1879 visit_start_struct(v, NULL, "struct tm", name, 0, &err);
1880 if (err) {
1881 goto out;
1882 }
1883 visit_type_int32(v, &value.tm_year, "tm_year", &err);
1884 if (err) {
1885 goto out_end;
1886 }
1887 visit_type_int32(v, &value.tm_mon, "tm_mon", &err);
1888 if (err) {
1889 goto out_end;
1890 }
1891 visit_type_int32(v, &value.tm_mday, "tm_mday", &err);
1892 if (err) {
1893 goto out_end;
1894 }
1895 visit_type_int32(v, &value.tm_hour, "tm_hour", &err);
1896 if (err) {
1897 goto out_end;
1898 }
1899 visit_type_int32(v, &value.tm_min, "tm_min", &err);
1900 if (err) {
1901 goto out_end;
1902 }
1903 visit_type_int32(v, &value.tm_sec, "tm_sec", &err);
1904 if (err) {
1905 goto out_end;
1906 }
1907out_end:
1908 error_propagate(errp, err);
1909 err = NULL;
1910 visit_end_struct(v, errp);
1911out:
1912 error_propagate(errp, err);
1913
1914}
1915
1916static void property_release_tm(Object *obj, const char *name,
1917 void *opaque)
1918{
1919 TMProperty *prop = opaque;
1920 g_free(prop);
1921}
1922
1923void object_property_add_tm(Object *obj, const char *name,
1924 void (*get)(Object *, struct tm *, Error **),
1925 Error **errp)
1926{
1927 Error *local_err = NULL;
1928 TMProperty *prop = g_malloc0(sizeof(*prop));
1929
1930 prop->get = get;
1931
1932 object_property_add(obj, name, "struct tm",
1933 get ? property_get_tm : NULL, NULL,
1934 property_release_tm,
1935 prop, &local_err);
1936 if (local_err) {
1937 error_propagate(errp, local_err);
1938 g_free(prop);
1939 }
1940}
1941
2f262e06
PB
1942static char *qdev_get_type(Object *obj, Error **errp)
1943{
1944 return g_strdup(object_get_typename(obj));
1945}
1946
e732ea63
MT
1947static void property_get_uint8_ptr(Object *obj, Visitor *v,
1948 void *opaque, const char *name,
1949 Error **errp)
1950{
1951 uint8_t value = *(uint8_t *)opaque;
1952 visit_type_uint8(v, &value, name, errp);
1953}
1954
1955static void property_get_uint16_ptr(Object *obj, Visitor *v,
1956 void *opaque, const char *name,
1957 Error **errp)
1958{
1959 uint16_t value = *(uint16_t *)opaque;
1960 visit_type_uint16(v, &value, name, errp);
1961}
1962
1963static void property_get_uint32_ptr(Object *obj, Visitor *v,
1964 void *opaque, const char *name,
1965 Error **errp)
1966{
1967 uint32_t value = *(uint32_t *)opaque;
1968 visit_type_uint32(v, &value, name, errp);
1969}
1970
1971static void property_get_uint64_ptr(Object *obj, Visitor *v,
1972 void *opaque, const char *name,
1973 Error **errp)
1974{
1975 uint64_t value = *(uint64_t *)opaque;
1976 visit_type_uint64(v, &value, name, errp);
1977}
1978
1979void object_property_add_uint8_ptr(Object *obj, const char *name,
1980 const uint8_t *v, Error **errp)
1981{
1982 object_property_add(obj, name, "uint8", property_get_uint8_ptr,
1983 NULL, NULL, (void *)v, errp);
1984}
1985
1986void object_property_add_uint16_ptr(Object *obj, const char *name,
1987 const uint16_t *v, Error **errp)
1988{
1989 object_property_add(obj, name, "uint16", property_get_uint16_ptr,
1990 NULL, NULL, (void *)v, errp);
1991}
1992
1993void object_property_add_uint32_ptr(Object *obj, const char *name,
1994 const uint32_t *v, Error **errp)
1995{
1996 object_property_add(obj, name, "uint32", property_get_uint32_ptr,
1997 NULL, NULL, (void *)v, errp);
1998}
1999
2000void object_property_add_uint64_ptr(Object *obj, const char *name,
2001 const uint64_t *v, Error **errp)
2002{
2003 object_property_add(obj, name, "uint64", property_get_uint64_ptr,
2004 NULL, NULL, (void *)v, errp);
2005}
2006
ef7c7ff6
SH
2007typedef struct {
2008 Object *target_obj;
1590d266 2009 char *target_name;
ef7c7ff6
SH
2010} AliasProperty;
2011
2012static void property_get_alias(Object *obj, struct Visitor *v, void *opaque,
2013 const char *name, Error **errp)
2014{
2015 AliasProperty *prop = opaque;
2016
2017 object_property_get(prop->target_obj, v, prop->target_name, errp);
2018}
2019
2020static void property_set_alias(Object *obj, struct Visitor *v, void *opaque,
2021 const char *name, Error **errp)
2022{
2023 AliasProperty *prop = opaque;
2024
2025 object_property_set(prop->target_obj, v, prop->target_name, errp);
2026}
2027
64607d08
PB
2028static Object *property_resolve_alias(Object *obj, void *opaque,
2029 const gchar *part)
2030{
2031 AliasProperty *prop = opaque;
2032
2033 return object_resolve_path_component(prop->target_obj, prop->target_name);
2034}
2035
ef7c7ff6
SH
2036static void property_release_alias(Object *obj, const char *name, void *opaque)
2037{
2038 AliasProperty *prop = opaque;
2039
1590d266 2040 g_free(prop->target_name);
ef7c7ff6
SH
2041 g_free(prop);
2042}
2043
2044void object_property_add_alias(Object *obj, const char *name,
2045 Object *target_obj, const char *target_name,
2046 Error **errp)
2047{
2048 AliasProperty *prop;
64607d08 2049 ObjectProperty *op;
ef7c7ff6 2050 ObjectProperty *target_prop;
d190698e 2051 gchar *prop_type;
8ae9a9ef 2052 Error *local_err = NULL;
ef7c7ff6
SH
2053
2054 target_prop = object_property_find(target_obj, target_name, errp);
2055 if (!target_prop) {
2056 return;
2057 }
2058
d190698e
PB
2059 if (object_property_is_child(target_prop)) {
2060 prop_type = g_strdup_printf("link%s",
2061 target_prop->type + strlen("child"));
2062 } else {
2063 prop_type = g_strdup(target_prop->type);
2064 }
2065
ef7c7ff6
SH
2066 prop = g_malloc(sizeof(*prop));
2067 prop->target_obj = target_obj;
1590d266 2068 prop->target_name = g_strdup(target_name);
ef7c7ff6 2069
d190698e 2070 op = object_property_add(obj, name, prop_type,
64607d08
PB
2071 property_get_alias,
2072 property_set_alias,
2073 property_release_alias,
8ae9a9ef
GA
2074 prop, &local_err);
2075 if (local_err) {
2076 error_propagate(errp, local_err);
2077 g_free(prop);
2078 goto out;
2079 }
64607d08 2080 op->resolve = property_resolve_alias;
d190698e 2081
a18bb417 2082 object_property_set_description(obj, op->name,
80742642
GA
2083 target_prop->description,
2084 &error_abort);
2085
8ae9a9ef 2086out:
d190698e 2087 g_free(prop_type);
ef7c7ff6
SH
2088}
2089
80742642
GA
2090void object_property_set_description(Object *obj, const char *name,
2091 const char *description, Error **errp)
2092{
2093 ObjectProperty *op;
2094
2095 op = object_property_find(obj, name, errp);
2096 if (!op) {
2097 return;
2098 }
2099
2100 g_free(op->description);
2101 op->description = g_strdup(description);
2102}
2103
2f262e06
PB
2104static void object_instance_init(Object *obj)
2105{
2106 object_property_add_str(obj, "type", qdev_get_type, NULL, NULL);
2107}
2108
745549c8
PB
2109static void register_types(void)
2110{
2111 static TypeInfo interface_info = {
2112 .name = TYPE_INTERFACE,
33e95c63 2113 .class_size = sizeof(InterfaceClass),
745549c8
PB
2114 .abstract = true,
2115 };
2116
2117 static TypeInfo object_info = {
2118 .name = TYPE_OBJECT,
2119 .instance_size = sizeof(Object),
2f262e06 2120 .instance_init = object_instance_init,
745549c8
PB
2121 .abstract = true,
2122 };
2123
049cb3cf
PB
2124 type_interface = type_register_internal(&interface_info);
2125 type_register_internal(&object_info);
745549c8
PB
2126}
2127
2128type_init(register_types)