![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to object.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / qom|
Return to object.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / qom |
1.1 root 1: /*
2: * QEMU Object Model
3: *
4: * Copyright IBM, Corp. 2011
5: *
6: * Authors:
7: * Anthony Liguori <[email protected]>
8: *
9: * This work is licensed under the terms of the GNU GPL, version 2 or later.
10: * See the COPYING file in the top-level directory.
11: */
12:
13: #include "qemu/object.h"
14: #include "qemu-common.h"
15: #include "qapi/qapi-visit-core.h"
16: #include "qapi/string-input-visitor.h"
17: #include "qapi/string-output-visitor.h"
18:
19: /* TODO: replace QObject with a simpler visitor to avoid a dependency
20: * of the QOM core on QObject? */
21: #include "qemu/qom-qobject.h"
22: #include "qobject.h"
23: #include "qbool.h"
24: #include "qint.h"
25: #include "qstring.h"
26:
27: #define MAX_INTERFACES 32
28:
29: typedef struct InterfaceImpl InterfaceImpl;
30: typedef struct TypeImpl TypeImpl;
31:
32: struct InterfaceImpl
33: {
34: const char *parent;
35: void (*interface_initfn)(ObjectClass *class, void *data);
36: TypeImpl *type;
37: };
38:
39: struct TypeImpl
40: {
41: const char *name;
42:
43: size_t class_size;
44:
45: size_t instance_size;
46:
47: void (*class_init)(ObjectClass *klass, void *data);
48: void (*class_finalize)(ObjectClass *klass, void *data);
49:
50: void *class_data;
51:
52: void (*instance_init)(Object *obj);
53: void (*instance_finalize)(Object *obj);
54:
55: bool abstract;
56:
57: const char *parent;
58: TypeImpl *parent_type;
59:
60: ObjectClass *class;
61:
62: int num_interfaces;
63: InterfaceImpl interfaces[MAX_INTERFACES];
64: };
65:
66: typedef struct Interface
67: {
68: Object parent;
69: Object *obj;
70: } Interface;
71:
72: #define INTERFACE(obj) OBJECT_CHECK(Interface, obj, TYPE_INTERFACE)
73:
74: static Type type_interface;
75:
76: static GHashTable *type_table_get(void)
77: {
78: static GHashTable *type_table;
79:
80: if (type_table == NULL) {
81: type_table = g_hash_table_new(g_str_hash, g_str_equal);
82: }
83:
84: return type_table;
85: }
86:
87: static void type_table_add(TypeImpl *ti)
88: {
89: g_hash_table_insert(type_table_get(), (void *)ti->name, ti);
90: }
91:
92: static TypeImpl *type_table_lookup(const char *name)
93: {
94: return g_hash_table_lookup(type_table_get(), name);
95: }
96:
97: TypeImpl *type_register(const TypeInfo *info)
98: {
99: TypeImpl *ti = g_malloc0(sizeof(*ti));
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_finalize = info->class_finalize;
116: ti->class_data = info->class_data;
117:
118: ti->instance_init = info->instance_init;
119: ti->instance_finalize = info->instance_finalize;
120:
121: ti->abstract = info->abstract;
122:
123: if (info->interfaces) {
124: int i;
125:
126: for (i = 0; info->interfaces[i].type; i++) {
127: ti->interfaces[i].parent = info->interfaces[i].type;
128: ti->interfaces[i].interface_initfn = info->interfaces[i].interface_initfn;
129: ti->num_interfaces++;
130: }
131: }
132:
133: type_table_add(ti);
134:
135: return ti;
136: }
137:
138: TypeImpl *type_register_static(const TypeInfo *info)
139: {
140: return type_register(info);
141: }
142:
143: static TypeImpl *type_get_by_name(const char *name)
144: {
145: if (name == NULL) {
146: return NULL;
147: }
148:
149: return type_table_lookup(name);
150: }
151:
152: static TypeImpl *type_get_parent(TypeImpl *type)
153: {
154: if (!type->parent_type && type->parent) {
155: type->parent_type = type_get_by_name(type->parent);
156: g_assert(type->parent_type != NULL);
157: }
158:
159: return type->parent_type;
160: }
161:
162: static bool type_has_parent(TypeImpl *type)
163: {
164: return (type->parent != NULL);
165: }
166:
167: static size_t type_class_get_size(TypeImpl *ti)
168: {
169: if (ti->class_size) {
170: return ti->class_size;
171: }
172:
173: if (type_has_parent(ti)) {
174: return type_class_get_size(type_get_parent(ti));
175: }
176:
177: return sizeof(ObjectClass);
178: }
179:
180: static size_t type_object_get_size(TypeImpl *ti)
181: {
182: if (ti->instance_size) {
183: return ti->instance_size;
184: }
185:
186: if (type_has_parent(ti)) {
187: return type_object_get_size(type_get_parent(ti));
188: }
189:
190: return 0;
191: }
192:
193: static void type_class_interface_init(TypeImpl *ti, InterfaceImpl *iface)
194: {
195: TypeInfo info = {
196: .instance_size = sizeof(Interface),
197: .parent = iface->parent,
198: .class_size = sizeof(InterfaceClass),
199: .class_init = iface->interface_initfn,
200: .abstract = true,
201: };
202: char *name = g_strdup_printf("<%s::%s>", ti->name, iface->parent);
203:
204: info.name = name;
205: iface->type = type_register(&info);
206: g_free(name);
207: }
208:
209: static void type_initialize(TypeImpl *ti)
210: {
211: size_t class_size = sizeof(ObjectClass);
212: int i;
213:
214: if (ti->class) {
215: return;
216: }
217:
218: ti->class_size = type_class_get_size(ti);
219: ti->instance_size = type_object_get_size(ti);
220:
221: ti->class = g_malloc0(ti->class_size);
222: ti->class->type = ti;
223:
224: if (type_has_parent(ti)) {
225: TypeImpl *parent = type_get_parent(ti);
226:
227: type_initialize(parent);
228:
229: class_size = parent->class_size;
230: g_assert(parent->class_size <= ti->class_size);
231:
232: memcpy((void *)ti->class + sizeof(ObjectClass),
233: (void *)parent->class + sizeof(ObjectClass),
234: parent->class_size - sizeof(ObjectClass));
235: }
236:
237: memset((void *)ti->class + class_size, 0, ti->class_size - class_size);
238:
239: for (i = 0; i < ti->num_interfaces; i++) {
240: type_class_interface_init(ti, &ti->interfaces[i]);
241: }
242:
243: if (ti->class_init) {
244: ti->class_init(ti->class, ti->class_data);
245: }
246: }
247:
248: static void object_interface_init(Object *obj, InterfaceImpl *iface)
249: {
250: TypeImpl *ti = iface->type;
251: Interface *iface_obj;
252:
253: iface_obj = INTERFACE(object_new(ti->name));
254: iface_obj->obj = obj;
255:
256: obj->interfaces = g_slist_prepend(obj->interfaces, iface_obj);
257: }
258:
259: static void object_init_with_type(Object *obj, TypeImpl *ti)
260: {
261: int i;
262:
263: if (type_has_parent(ti)) {
264: object_init_with_type(obj, type_get_parent(ti));
265: }
266:
267: for (i = 0; i < ti->num_interfaces; i++) {
268: object_interface_init(obj, &ti->interfaces[i]);
269: }
270:
271: if (ti->instance_init) {
272: ti->instance_init(obj);
273: }
274: }
275:
276: void object_initialize_with_type(void *data, TypeImpl *type)
277: {
278: Object *obj = data;
279:
280: g_assert(type != NULL);
281: type_initialize(type);
282:
283: g_assert(type->instance_size >= sizeof(Object));
284: g_assert(type->abstract == false);
285:
286: memset(obj, 0, type->instance_size);
287: obj->class = type->class;
288: QTAILQ_INIT(&obj->properties);
289: object_init_with_type(obj, type);
290: }
291:
292: void object_initialize(void *data, const char *typename)
293: {
294: TypeImpl *type = type_get_by_name(typename);
295:
296: object_initialize_with_type(data, type);
297: }
298:
299: static void object_property_del_all(Object *obj)
300: {
301: while (!QTAILQ_EMPTY(&obj->properties)) {
302: ObjectProperty *prop = QTAILQ_FIRST(&obj->properties);
303:
304: QTAILQ_REMOVE(&obj->properties, prop, node);
305:
306: if (prop->release) {
307: prop->release(obj, prop->name, prop->opaque);
308: }
309:
310: g_free(prop->name);
311: g_free(prop->type);
312: g_free(prop);
313: }
314: }
315:
316: static void object_property_del_child(Object *obj, Object *child, Error **errp)
317: {
318: ObjectProperty *prop;
319:
320: QTAILQ_FOREACH(prop, &obj->properties, node) {
321: if (strstart(prop->type, "child<", NULL) && prop->opaque == child) {
322: object_property_del(obj, prop->name, errp);
323: break;
324: }
325: }
326: }
327:
328: void object_unparent(Object *obj)
329: {
330: if (obj->parent) {
331: object_property_del_child(obj->parent, obj, NULL);
332: }
333: }
334:
335: static void object_deinit(Object *obj, TypeImpl *type)
336: {
337: if (type->instance_finalize) {
338: type->instance_finalize(obj);
339: }
340:
341: while (obj->interfaces) {
342: Interface *iface_obj = obj->interfaces->data;
343: obj->interfaces = g_slist_delete_link(obj->interfaces, obj->interfaces);
344: object_delete(OBJECT(iface_obj));
345: }
346:
347: if (type_has_parent(type)) {
348: object_deinit(obj, type_get_parent(type));
349: }
350:
351: object_unparent(obj);
352: }
353:
354: void object_finalize(void *data)
355: {
356: Object *obj = data;
357: TypeImpl *ti = obj->class->type;
358:
359: object_deinit(obj, ti);
360: object_property_del_all(obj);
361:
362: g_assert(obj->ref == 0);
363: }
364:
365: Object *object_new_with_type(Type type)
366: {
367: Object *obj;
368:
369: g_assert(type != NULL);
370: type_initialize(type);
371:
372: obj = g_malloc(type->instance_size);
373: object_initialize_with_type(obj, type);
374: object_ref(obj);
375:
376: return obj;
377: }
378:
379: Object *object_new(const char *typename)
380: {
381: TypeImpl *ti = type_get_by_name(typename);
382:
383: return object_new_with_type(ti);
384: }
385:
386: void object_delete(Object *obj)
387: {
388: object_unref(obj);
389: g_assert(obj->ref == 0);
390: g_free(obj);
391: }
392:
393: static bool type_is_ancestor(TypeImpl *type, TypeImpl *target_type)
394: {
395: assert(target_type);
396:
397: /* Check if typename is a direct ancestor of type */
398: while (type) {
399: if (type == target_type) {
400: return true;
401: }
402:
403: type = type_get_parent(type);
404: }
405:
406: return false;
407: }
408:
409: static bool object_is_type(Object *obj, TypeImpl *target_type)
410: {
411: return !target_type || type_is_ancestor(obj->class->type, target_type);
412: }
413:
414: Object *object_dynamic_cast(Object *obj, const char *typename)
415: {
416: TypeImpl *target_type = type_get_by_name(typename);
417: GSList *i;
418:
419: /* Check if typename is a direct ancestor. Special-case TYPE_OBJECT,
420: * we want to go back from interfaces to the parent.
421: */
422: if (target_type && object_is_type(obj, target_type)) {
423: return obj;
424: }
425:
426: /* Check if obj is an interface and its containing object is a direct
427: * ancestor of typename. In principle we could do this test at the very
428: * beginning of object_dynamic_cast, avoiding a second call to
429: * object_is_type. However, casting between interfaces is relatively
430: * rare, and object_is_type(obj, type_interface) would fail almost always.
431: *
432: * Perhaps we could add a magic value to the object header for increased
433: * (run-time) type safety and to speed up tests like this one. If we ever
434: * do that we can revisit the order here.
435: */
436: if (object_is_type(obj, type_interface)) {
437: assert(!obj->interfaces);
438: obj = INTERFACE(obj)->obj;
439: if (object_is_type(obj, target_type)) {
440: return obj;
441: }
442: }
443:
444: if (!target_type) {
445: return obj;
446: }
447:
448: /* Check if obj has an interface of typename */
449: for (i = obj->interfaces; i; i = i->next) {
450: Interface *iface = i->data;
451:
452: if (object_is_type(OBJECT(iface), target_type)) {
453: return OBJECT(iface);
454: }
455: }
456:
457: return NULL;
458: }
459:
460:
461: static void register_types(void)
462: {
463: static TypeInfo interface_info = {
464: .name = TYPE_INTERFACE,
465: .instance_size = sizeof(Interface),
466: .abstract = true,
467: };
468:
469: type_interface = type_register_static(&interface_info);
470: }
471:
472: type_init(register_types)
473:
474: Object *object_dynamic_cast_assert(Object *obj, const char *typename)
475: {
476: Object *inst;
477:
478: inst = object_dynamic_cast(obj, typename);
479:
480: if (!inst) {
481: fprintf(stderr, "Object %p is not an instance of type %s\n",
482: obj, typename);
483: abort();
484: }
485:
486: return inst;
487: }
488:
489: ObjectClass *object_class_dynamic_cast(ObjectClass *class,
490: const char *typename)
491: {
492: TypeImpl *target_type = type_get_by_name(typename);
493: TypeImpl *type = class->type;
494:
495: while (type) {
496: if (type == target_type) {
497: return class;
498: }
499:
500: type = type_get_parent(type);
501: }
502:
503: return NULL;
504: }
505:
506: ObjectClass *object_class_dynamic_cast_assert(ObjectClass *class,
507: const char *typename)
508: {
509: ObjectClass *ret = object_class_dynamic_cast(class, typename);
510:
511: if (!ret) {
512: fprintf(stderr, "Object %p is not an instance of type %s\n",
513: class, typename);
514: abort();
515: }
516:
517: return ret;
518: }
519:
520: const char *object_get_typename(Object *obj)
521: {
522: return obj->class->type->name;
523: }
524:
525: ObjectClass *object_get_class(Object *obj)
526: {
527: return obj->class;
528: }
529:
530: const char *object_class_get_name(ObjectClass *klass)
531: {
532: return klass->type->name;
533: }
534:
535: ObjectClass *object_class_by_name(const char *typename)
536: {
537: TypeImpl *type = type_get_by_name(typename);
538:
539: if (!type) {
540: return NULL;
541: }
542:
543: type_initialize(type);
544:
545: return type->class;
546: }
547:
548: typedef struct OCFData
549: {
550: void (*fn)(ObjectClass *klass, void *opaque);
551: const char *implements_type;
552: bool include_abstract;
553: void *opaque;
554: } OCFData;
555:
556: static void object_class_foreach_tramp(gpointer key, gpointer value,
557: gpointer opaque)
558: {
559: OCFData *data = opaque;
560: TypeImpl *type = value;
561: ObjectClass *k;
562:
563: type_initialize(type);
564: k = type->class;
565:
566: if (!data->include_abstract && type->abstract) {
567: return;
568: }
569:
570: if (data->implements_type &&
571: !object_class_dynamic_cast(k, data->implements_type)) {
572: return;
573: }
574:
575: data->fn(k, data->opaque);
576: }
577:
578: void object_class_foreach(void (*fn)(ObjectClass *klass, void *opaque),
579: const char *implements_type, bool include_abstract,
580: void *opaque)
581: {
582: OCFData data = { fn, implements_type, include_abstract, opaque };
583:
584: g_hash_table_foreach(type_table_get(), object_class_foreach_tramp, &data);
585: }
586:
587: static void object_class_get_list_tramp(ObjectClass *klass, void *opaque)
588: {
589: GSList **list = opaque;
590:
591: *list = g_slist_prepend(*list, klass);
592: }
593:
594: GSList *object_class_get_list(const char *implements_type,
595: bool include_abstract)
596: {
597: GSList *list = NULL;
598:
599: object_class_foreach(object_class_get_list_tramp,
600: implements_type, include_abstract, &list);
601: return list;
602: }
603:
604: void object_ref(Object *obj)
605: {
606: obj->ref++;
607: }
608:
609: void object_unref(Object *obj)
610: {
611: g_assert(obj->ref > 0);
612: obj->ref--;
613:
614: /* parent always holds a reference to its children */
615: if (obj->ref == 0) {
616: object_finalize(obj);
617: }
618: }
619:
620: void object_property_add(Object *obj, const char *name, const char *type,
621: ObjectPropertyAccessor *get,
622: ObjectPropertyAccessor *set,
623: ObjectPropertyRelease *release,
624: void *opaque, Error **errp)
625: {
626: ObjectProperty *prop = g_malloc0(sizeof(*prop));
627:
628: prop->name = g_strdup(name);
629: prop->type = g_strdup(type);
630:
631: prop->get = get;
632: prop->set = set;
633: prop->release = release;
634: prop->opaque = opaque;
635:
636: QTAILQ_INSERT_TAIL(&obj->properties, prop, node);
637: }
638:
639: static ObjectProperty *object_property_find(Object *obj, const char *name)
640: {
641: ObjectProperty *prop;
642:
643: QTAILQ_FOREACH(prop, &obj->properties, node) {
644: if (strcmp(prop->name, name) == 0) {
645: return prop;
646: }
647: }
648:
649: return NULL;
650: }
651:
652: void object_property_del(Object *obj, const char *name, Error **errp)
653: {
654: ObjectProperty *prop = object_property_find(obj, name);
655:
656: QTAILQ_REMOVE(&obj->properties, prop, node);
657:
658: prop->release(obj, prop->name, prop->opaque);
659:
660: g_free(prop->name);
661: g_free(prop->type);
662: g_free(prop);
663: }
664:
665: void object_property_get(Object *obj, Visitor *v, const char *name,
666: Error **errp)
667: {
668: ObjectProperty *prop = object_property_find(obj, name);
669:
670: if (prop == NULL) {
671: error_set(errp, QERR_PROPERTY_NOT_FOUND, "", name);
672: return;
673: }
674:
675: if (!prop->get) {
676: error_set(errp, QERR_PERMISSION_DENIED);
677: } else {
678: prop->get(obj, v, prop->opaque, name, errp);
679: }
680: }
681:
682: void object_property_set(Object *obj, Visitor *v, const char *name,
683: Error **errp)
684: {
685: ObjectProperty *prop = object_property_find(obj, name);
686:
687: if (prop == NULL) {
688: error_set(errp, QERR_PROPERTY_NOT_FOUND, "", name);
689: return;
690: }
691:
692: if (!prop->set) {
693: error_set(errp, QERR_PERMISSION_DENIED);
694: } else {
695: prop->set(obj, v, prop->opaque, name, errp);
696: }
697: }
698:
699: void object_property_set_str(Object *obj, const char *value,
700: const char *name, Error **errp)
701: {
702: QString *qstr = qstring_from_str(value);
703: object_property_set_qobject(obj, QOBJECT(qstr), name, errp);
704:
705: QDECREF(qstr);
706: }
707:
708: char *object_property_get_str(Object *obj, const char *name,
709: Error **errp)
710: {
711: QObject *ret = object_property_get_qobject(obj, name, errp);
712: QString *qstring;
713: char *retval;
714:
715: if (!ret) {
716: return NULL;
717: }
718: qstring = qobject_to_qstring(ret);
719: if (!qstring) {
720: error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
721: retval = NULL;
722: } else {
723: retval = g_strdup(qstring_get_str(qstring));
724: }
725:
726: QDECREF(qstring);
727: return retval;
728: }
729:
730: void object_property_set_link(Object *obj, Object *value,
731: const char *name, Error **errp)
732: {
733: object_property_set_str(obj, object_get_canonical_path(value),
734: name, errp);
735: }
736:
737: Object *object_property_get_link(Object *obj, const char *name,
738: Error **errp)
739: {
740: char *str = object_property_get_str(obj, name, errp);
741: Object *target = NULL;
742:
743: if (str && *str) {
744: target = object_resolve_path(str, NULL);
745: if (!target) {
746: error_set(errp, QERR_DEVICE_NOT_FOUND, str);
747: }
748: }
749:
750: g_free(str);
751: return target;
752: }
753:
754: void object_property_set_bool(Object *obj, bool value,
755: const char *name, Error **errp)
756: {
757: QBool *qbool = qbool_from_int(value);
758: object_property_set_qobject(obj, QOBJECT(qbool), name, errp);
759:
760: QDECREF(qbool);
761: }
762:
763: bool object_property_get_bool(Object *obj, const char *name,
764: Error **errp)
765: {
766: QObject *ret = object_property_get_qobject(obj, name, errp);
767: QBool *qbool;
768: bool retval;
769:
770: if (!ret) {
771: return false;
772: }
773: qbool = qobject_to_qbool(ret);
774: if (!qbool) {
775: error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "boolean");
776: retval = false;
777: } else {
778: retval = qbool_get_int(qbool);
779: }
780:
781: QDECREF(qbool);
782: return retval;
783: }
784:
785: void object_property_set_int(Object *obj, int64_t value,
786: const char *name, Error **errp)
787: {
788: QInt *qint = qint_from_int(value);
789: object_property_set_qobject(obj, QOBJECT(qint), name, errp);
790:
791: QDECREF(qint);
792: }
793:
794: int64_t object_property_get_int(Object *obj, const char *name,
795: Error **errp)
796: {
797: QObject *ret = object_property_get_qobject(obj, name, errp);
798: QInt *qint;
799: int64_t retval;
800:
801: if (!ret) {
802: return -1;
803: }
804: qint = qobject_to_qint(ret);
805: if (!qint) {
806: error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, "int");
807: retval = -1;
808: } else {
809: retval = qint_get_int(qint);
810: }
811:
812: QDECREF(qint);
813: return retval;
814: }
815:
816: void object_property_parse(Object *obj, const char *string,
817: const char *name, Error **errp)
818: {
819: StringInputVisitor *mi;
820: mi = string_input_visitor_new(string);
821: object_property_set(obj, string_input_get_visitor(mi), name, errp);
822:
823: string_input_visitor_cleanup(mi);
824: }
825:
826: char *object_property_print(Object *obj, const char *name,
827: Error **errp)
828: {
829: StringOutputVisitor *mo;
830: char *string;
831:
832: mo = string_output_visitor_new();
833: object_property_get(obj, string_output_get_visitor(mo), name, errp);
834: string = string_output_get_string(mo);
835: string_output_visitor_cleanup(mo);
836: return string;
837: }
838:
839: const char *object_property_get_type(Object *obj, const char *name, Error **errp)
840: {
841: ObjectProperty *prop = object_property_find(obj, name);
842:
843: if (prop == NULL) {
844: error_set(errp, QERR_PROPERTY_NOT_FOUND, "", name);
845: return NULL;
846: }
847:
848: return prop->type;
849: }
850:
851: Object *object_get_root(void)
852: {
853: static Object *root;
854:
855: if (!root) {
856: root = object_new("container");
857: }
858:
859: return root;
860: }
861:
862: static void object_get_child_property(Object *obj, Visitor *v, void *opaque,
863: const char *name, Error **errp)
864: {
865: Object *child = opaque;
866: gchar *path;
867:
868: path = object_get_canonical_path(child);
869: visit_type_str(v, &path, name, errp);
870: g_free(path);
871: }
872:
873: static void object_finalize_child_property(Object *obj, const char *name,
874: void *opaque)
875: {
876: Object *child = opaque;
877:
878: object_unref(child);
879: }
880:
881: void object_property_add_child(Object *obj, const char *name,
882: Object *child, Error **errp)
883: {
884: gchar *type;
885:
886: /* Registering an interface object in the composition tree will mightily
887: * confuse object_get_canonical_path (which, on the other hand, knows how
888: * to get the canonical path of an interface object).
889: */
890: assert(!object_is_type(obj, type_interface));
891:
892: type = g_strdup_printf("child<%s>", object_get_typename(OBJECT(child)));
893:
894: object_property_add(obj, name, type, object_get_child_property,
895: NULL, object_finalize_child_property, child, errp);
896:
897: object_ref(child);
898: g_assert(child->parent == NULL);
899: child->parent = obj;
900:
901: g_free(type);
902: }
903:
904: static void object_get_link_property(Object *obj, Visitor *v, void *opaque,
905: const char *name, Error **errp)
906: {
907: Object **child = opaque;
908: gchar *path;
909:
910: if (*child) {
911: path = object_get_canonical_path(*child);
912: visit_type_str(v, &path, name, errp);
913: g_free(path);
914: } else {
915: path = (gchar *)"";
916: visit_type_str(v, &path, name, errp);
917: }
918: }
919:
920: static void object_set_link_property(Object *obj, Visitor *v, void *opaque,
921: const char *name, Error **errp)
922: {
923: Object **child = opaque;
924: Object *old_target;
925: bool ambiguous = false;
926: const char *type;
927: char *path;
928: gchar *target_type;
929:
930: type = object_property_get_type(obj, name, NULL);
931:
932: visit_type_str(v, &path, name, errp);
933:
934: old_target = *child;
935: *child = NULL;
936:
937: if (strcmp(path, "") != 0) {
938: Object *target;
939:
940: /* Go from link<FOO> to FOO. */
941: target_type = g_strndup(&type[5], strlen(type) - 6);
942: target = object_resolve_path_type(path, target_type, &ambiguous);
943:
944: if (ambiguous) {
945: error_set(errp, QERR_AMBIGUOUS_PATH, path);
946: } else if (target) {
947: object_ref(target);
948: *child = target;
949: } else {
950: target = object_resolve_path(path, &ambiguous);
951: if (target || ambiguous) {
952: error_set(errp, QERR_INVALID_PARAMETER_TYPE, name, target_type);
953: } else {
954: error_set(errp, QERR_DEVICE_NOT_FOUND, path);
955: }
956: }
957: g_free(target_type);
958: }
959:
960: g_free(path);
961:
962: if (old_target != NULL) {
963: object_unref(old_target);
964: }
965: }
966:
967: void object_property_add_link(Object *obj, const char *name,
968: const char *type, Object **child,
969: Error **errp)
970: {
971: gchar *full_type;
972:
973: full_type = g_strdup_printf("link<%s>", type);
974:
975: object_property_add(obj, name, full_type,
976: object_get_link_property,
977: object_set_link_property,
978: NULL, child, errp);
979:
980: g_free(full_type);
981: }
982:
983: gchar *object_get_canonical_path(Object *obj)
984: {
985: Object *root = object_get_root();
986: char *newpath = NULL, *path = NULL;
987:
988: if (object_is_type(obj, type_interface)) {
989: obj = INTERFACE(obj)->obj;
990: }
991:
992: while (obj != root) {
993: ObjectProperty *prop = NULL;
994:
995: g_assert(obj->parent != NULL);
996:
997: QTAILQ_FOREACH(prop, &obj->parent->properties, node) {
998: if (!strstart(prop->type, "child<", NULL)) {
999: continue;
1000: }
1001:
1002: if (prop->opaque == obj) {
1003: if (path) {
1004: newpath = g_strdup_printf("%s/%s", prop->name, path);
1005: g_free(path);
1006: path = newpath;
1007: } else {
1008: path = g_strdup(prop->name);
1009: }
1010: break;
1011: }
1012: }
1013:
1014: g_assert(prop != NULL);
1015:
1016: obj = obj->parent;
1017: }
1018:
1019: newpath = g_strdup_printf("/%s", path);
1020: g_free(path);
1021:
1022: return newpath;
1023: }
1024:
1025: Object *object_resolve_path_component(Object *parent, gchar *part)
1026: {
1027: ObjectProperty *prop = object_property_find(parent, part);
1028: if (prop == NULL) {
1029: return NULL;
1030: }
1031:
1032: if (strstart(prop->type, "link<", NULL)) {
1033: return *(Object **)prop->opaque;
1034: } else if (strstart(prop->type, "child<", NULL)) {
1035: return prop->opaque;
1036: } else {
1037: return NULL;
1038: }
1039: }
1040:
1041: static Object *object_resolve_abs_path(Object *parent,
1042: gchar **parts,
1043: const char *typename,
1044: int index)
1045: {
1046: Object *child;
1047:
1048: if (parts[index] == NULL) {
1049: return object_dynamic_cast(parent, typename);
1050: }
1051:
1052: if (strcmp(parts[index], "") == 0) {
1053: return object_resolve_abs_path(parent, parts, typename, index + 1);
1054: }
1055:
1056: child = object_resolve_path_component(parent, parts[index]);
1057: if (!child) {
1058: return NULL;
1059: }
1060:
1061: return object_resolve_abs_path(child, parts, typename, index + 1);
1062: }
1063:
1064: static Object *object_resolve_partial_path(Object *parent,
1065: gchar **parts,
1066: const char *typename,
1067: bool *ambiguous)
1068: {
1069: Object *obj;
1070: ObjectProperty *prop;
1071:
1072: obj = object_resolve_abs_path(parent, parts, typename, 0);
1073:
1074: QTAILQ_FOREACH(prop, &parent->properties, node) {
1075: Object *found;
1076:
1077: if (!strstart(prop->type, "child<", NULL)) {
1078: continue;
1079: }
1080:
1081: found = object_resolve_partial_path(prop->opaque, parts,
1082: typename, ambiguous);
1083: if (found) {
1084: if (obj) {
1085: if (ambiguous) {
1086: *ambiguous = true;
1087: }
1088: return NULL;
1089: }
1090: obj = found;
1091: }
1092:
1093: if (ambiguous && *ambiguous) {
1094: return NULL;
1095: }
1096: }
1097:
1098: return obj;
1099: }
1100:
1101: Object *object_resolve_path_type(const char *path, const char *typename,
1102: bool *ambiguous)
1103: {
1104: bool partial_path = true;
1105: Object *obj;
1106: gchar **parts;
1107:
1108: parts = g_strsplit(path, "/", 0);
1109: if (parts == NULL || parts[0] == NULL) {
1110: g_strfreev(parts);
1111: return object_get_root();
1112: }
1113:
1114: if (strcmp(parts[0], "") == 0) {
1115: partial_path = false;
1116: }
1117:
1118: if (partial_path) {
1119: if (ambiguous) {
1120: *ambiguous = false;
1121: }
1122: obj = object_resolve_partial_path(object_get_root(), parts,
1123: typename, ambiguous);
1124: } else {
1125: obj = object_resolve_abs_path(object_get_root(), parts, typename, 1);
1126: }
1127:
1128: g_strfreev(parts);
1129:
1130: return obj;
1131: }
1132:
1133: Object *object_resolve_path(const char *path, bool *ambiguous)
1134: {
1135: return object_resolve_path_type(path, TYPE_OBJECT, ambiguous);
1136: }
1137:
1138: typedef struct StringProperty
1139: {
1140: char *(*get)(Object *, Error **);
1141: void (*set)(Object *, const char *, Error **);
1142: } StringProperty;
1143:
1144: static void property_get_str(Object *obj, Visitor *v, void *opaque,
1145: const char *name, Error **errp)
1146: {
1147: StringProperty *prop = opaque;
1148: char *value;
1149:
1150: value = prop->get(obj, errp);
1151: if (value) {
1152: visit_type_str(v, &value, name, errp);
1153: g_free(value);
1154: }
1155: }
1156:
1157: static void property_set_str(Object *obj, Visitor *v, void *opaque,
1158: const char *name, Error **errp)
1159: {
1160: StringProperty *prop = opaque;
1161: char *value;
1162: Error *local_err = NULL;
1163:
1164: visit_type_str(v, &value, name, &local_err);
1165: if (local_err) {
1166: error_propagate(errp, local_err);
1167: return;
1168: }
1169:
1170: prop->set(obj, value, errp);
1171: g_free(value);
1172: }
1173:
1174: static void property_release_str(Object *obj, const char *name,
1175: void *opaque)
1176: {
1177: StringProperty *prop = opaque;
1178: g_free(prop);
1179: }
1180:
1181: void object_property_add_str(Object *obj, const char *name,
1182: char *(*get)(Object *, Error **),
1183: void (*set)(Object *, const char *, Error **),
1184: Error **errp)
1185: {
1186: StringProperty *prop = g_malloc0(sizeof(*prop));
1187:
1188: prop->get = get;
1189: prop->set = set;
1190:
1191: object_property_add(obj, name, "string",
1192: get ? property_get_str : NULL,
1193: set ? property_set_str : NULL,
1194: property_release_str,
1195: prop, errp);
1196: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.