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