1 /*
2  * Copyright (C) 2015 Red Hat, Inc.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library.  If not, see
16  * <http://www.gnu.org/licenses/>.
17  *
18  * Author: Daniel P. Berrange <berrange@redhat.com>
19  */
20 
21 #include "qemu/osdep.h"
22 
23 #include "qapi/error.h"
24 #include "qapi/qobject-input-visitor.h"
25 #include "qapi/qmp/qdict.h"
26 #include "qapi/qmp/qobject.h"
27 #include "qom/object.h"
28 #include "qemu/module.h"
29 #include "qemu/option.h"
30 #include "qemu/keyval.h"
31 #include "qemu/config-file.h"
32 #include "qom/object_interfaces.h"
33 
34 
35 #define TYPE_DUMMY "qemu-dummy"
36 
37 typedef struct DummyObject DummyObject;
38 typedef struct DummyObjectClass DummyObjectClass;
39 
40 DECLARE_INSTANCE_CHECKER(DummyObject, DUMMY_OBJECT,
41                          TYPE_DUMMY)
42 
43 typedef enum DummyAnimal DummyAnimal;
44 
45 enum DummyAnimal {
46     DUMMY_FROG,
47     DUMMY_ALLIGATOR,
48     DUMMY_PLATYPUS,
49 
50     DUMMY_LAST,
51 };
52 
53 const QEnumLookup dummy_animal_map = {
54     .array = (const char *const[]) {
55         [DUMMY_FROG] = "frog",
56         [DUMMY_ALLIGATOR] = "alligator",
57         [DUMMY_PLATYPUS] = "platypus",
58     },
59     .size = DUMMY_LAST
60 };
61 
62 struct DummyObject {
63     Object parent_obj;
64 
65     bool bv;
66     DummyAnimal av;
67     char *sv;
68 };
69 
70 struct DummyObjectClass {
71     ObjectClass parent_class;
72 };
73 
74 
75 static void dummy_set_bv(Object *obj,
76                          bool value,
77                          Error **errp)
78 {
79     DummyObject *dobj = DUMMY_OBJECT(obj);
80 
81     dobj->bv = value;
82 }
83 
84 static bool dummy_get_bv(Object *obj,
85                          Error **errp)
86 {
87     DummyObject *dobj = DUMMY_OBJECT(obj);
88 
89     return dobj->bv;
90 }
91 
92 
93 static void dummy_set_av(Object *obj,
94                          int value,
95                          Error **errp)
96 {
97     DummyObject *dobj = DUMMY_OBJECT(obj);
98 
99     dobj->av = value;
100 }
101 
102 static int dummy_get_av(Object *obj,
103                         Error **errp)
104 {
105     DummyObject *dobj = DUMMY_OBJECT(obj);
106 
107     return dobj->av;
108 }
109 
110 
111 static void dummy_set_sv(Object *obj,
112                          const char *value,
113                          Error **errp)
114 {
115     DummyObject *dobj = DUMMY_OBJECT(obj);
116 
117     g_free(dobj->sv);
118     dobj->sv = g_strdup(value);
119 }
120 
121 static char *dummy_get_sv(Object *obj,
122                           Error **errp)
123 {
124     DummyObject *dobj = DUMMY_OBJECT(obj);
125 
126     return g_strdup(dobj->sv);
127 }
128 
129 
130 static void dummy_init(Object *obj)
131 {
132     object_property_add_bool(obj, "bv",
133                              dummy_get_bv,
134                              dummy_set_bv);
135 }
136 
137 
138 static void dummy_class_init(ObjectClass *cls, void *data)
139 {
140     object_class_property_add_str(cls, "sv",
141                                   dummy_get_sv,
142                                   dummy_set_sv);
143     object_class_property_add_enum(cls, "av",
144                                    "DummyAnimal",
145                                    &dummy_animal_map,
146                                    dummy_get_av,
147                                    dummy_set_av);
148 }
149 
150 
151 static void dummy_finalize(Object *obj)
152 {
153     DummyObject *dobj = DUMMY_OBJECT(obj);
154 
155     g_free(dobj->sv);
156 }
157 
158 
159 static const TypeInfo dummy_info = {
160     .name          = TYPE_DUMMY,
161     .parent        = TYPE_OBJECT,
162     .instance_size = sizeof(DummyObject),
163     .instance_init = dummy_init,
164     .instance_finalize = dummy_finalize,
165     .class_size = sizeof(DummyObjectClass),
166     .class_init = dummy_class_init,
167     .interfaces = (InterfaceInfo[]) {
168         { TYPE_USER_CREATABLE },
169         { }
170     }
171 };
172 
173 
174 /*
175  * The following 3 object classes are used to
176  * simulate the kind of relationships seen in
177  * qdev, which result in complex object
178  * property destruction ordering.
179  *
180  * DummyDev has a 'bus' child to a DummyBus
181  * DummyBus has a 'backend' child to a DummyBackend
182  * DummyDev has a 'backend' link to DummyBackend
183  *
184  * When DummyDev is finalized, it unparents the
185  * DummyBackend, which unparents the DummyDev
186  * which deletes the 'backend' link from DummyDev
187  * to DummyBackend. This illustrates that the
188  * object_property_del_all() method needs to
189  * cope with the list of properties being changed
190  * while it iterates over them.
191  */
192 typedef struct DummyDev DummyDev;
193 typedef struct DummyDevClass DummyDevClass;
194 typedef struct DummyBus DummyBus;
195 typedef struct DummyBusClass DummyBusClass;
196 typedef struct DummyBackend DummyBackend;
197 typedef struct DummyBackendClass DummyBackendClass;
198 
199 #define TYPE_DUMMY_DEV "qemu-dummy-dev"
200 #define TYPE_DUMMY_BUS "qemu-dummy-bus"
201 #define TYPE_DUMMY_BACKEND "qemu-dummy-backend"
202 
203 DECLARE_INSTANCE_CHECKER(DummyDev, DUMMY_DEV,
204                          TYPE_DUMMY_DEV)
205 DECLARE_INSTANCE_CHECKER(DummyBus, DUMMY_BUS,
206                          TYPE_DUMMY_BUS)
207 DECLARE_INSTANCE_CHECKER(DummyBackend, DUMMY_BACKEND,
208                          TYPE_DUMMY_BACKEND)
209 
210 struct DummyDev {
211     Object parent_obj;
212 
213     DummyBus *bus;
214 };
215 
216 struct DummyDevClass {
217     ObjectClass parent_class;
218 };
219 
220 struct DummyBus {
221     Object parent_obj;
222 
223     DummyBackend *backend;
224 };
225 
226 struct DummyBusClass {
227     ObjectClass parent_class;
228 };
229 
230 struct DummyBackend {
231     Object parent_obj;
232 };
233 
234 struct DummyBackendClass {
235     ObjectClass parent_class;
236 };
237 
238 
239 static void dummy_dev_finalize(Object *obj)
240 {
241     DummyDev *dev = DUMMY_DEV(obj);
242 
243     object_unref(OBJECT(dev->bus));
244 }
245 
246 static void dummy_dev_init(Object *obj)
247 {
248     DummyDev *dev = DUMMY_DEV(obj);
249     DummyBus *bus = DUMMY_BUS(object_new(TYPE_DUMMY_BUS));
250     DummyBackend *backend = DUMMY_BACKEND(object_new(TYPE_DUMMY_BACKEND));
251 
252     object_property_add_child(obj, "bus", OBJECT(bus));
253     dev->bus = bus;
254     object_property_add_child(OBJECT(bus), "backend", OBJECT(backend));
255     bus->backend = backend;
256 
257     object_property_add_link(obj, "backend", TYPE_DUMMY_BACKEND,
258                              (Object **)&bus->backend, NULL, 0);
259 }
260 
261 static void dummy_dev_unparent(Object *obj)
262 {
263     DummyDev *dev = DUMMY_DEV(obj);
264     object_unparent(OBJECT(dev->bus));
265 }
266 
267 static void dummy_dev_class_init(ObjectClass *klass, void *opaque)
268 {
269     klass->unparent = dummy_dev_unparent;
270 }
271 
272 
273 static void dummy_bus_finalize(Object *obj)
274 {
275     DummyBus *bus = DUMMY_BUS(obj);
276 
277     object_unref(OBJECT(bus->backend));
278 }
279 
280 static void dummy_bus_init(Object *obj)
281 {
282 }
283 
284 static void dummy_bus_unparent(Object *obj)
285 {
286     DummyBus *bus = DUMMY_BUS(obj);
287     object_property_del(obj->parent, "backend");
288     object_unparent(OBJECT(bus->backend));
289 }
290 
291 static void dummy_bus_class_init(ObjectClass *klass, void *opaque)
292 {
293     klass->unparent = dummy_bus_unparent;
294 }
295 
296 static void dummy_backend_init(Object *obj)
297 {
298 }
299 
300 
301 static const TypeInfo dummy_dev_info = {
302     .name          = TYPE_DUMMY_DEV,
303     .parent        = TYPE_OBJECT,
304     .instance_size = sizeof(DummyDev),
305     .instance_init = dummy_dev_init,
306     .instance_finalize = dummy_dev_finalize,
307     .class_size = sizeof(DummyDevClass),
308     .class_init = dummy_dev_class_init,
309 };
310 
311 static const TypeInfo dummy_bus_info = {
312     .name          = TYPE_DUMMY_BUS,
313     .parent        = TYPE_OBJECT,
314     .instance_size = sizeof(DummyBus),
315     .instance_init = dummy_bus_init,
316     .instance_finalize = dummy_bus_finalize,
317     .class_size = sizeof(DummyBusClass),
318     .class_init = dummy_bus_class_init,
319 };
320 
321 static const TypeInfo dummy_backend_info = {
322     .name          = TYPE_DUMMY_BACKEND,
323     .parent        = TYPE_OBJECT,
324     .instance_size = sizeof(DummyBackend),
325     .instance_init = dummy_backend_init,
326     .class_size = sizeof(DummyBackendClass),
327 };
328 
329 static QemuOptsList qemu_object_opts = {
330     .name = "object",
331     .implied_opt_name = "qom-type",
332     .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
333     .desc = {
334         { }
335     },
336 };
337 
338 
339 static void test_dummy_createv(void)
340 {
341     Error *err = NULL;
342     Object *parent = object_get_objects_root();
343     DummyObject *dobj = DUMMY_OBJECT(
344         object_new_with_props(TYPE_DUMMY,
345                               parent,
346                               "dummy0",
347                               &err,
348                               "bv", "yes",
349                               "sv", "Hiss hiss hiss",
350                               "av", "platypus",
351                               NULL));
352 
353     g_assert(err == NULL);
354     g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
355     g_assert(dobj->bv == true);
356     g_assert(dobj->av == DUMMY_PLATYPUS);
357 
358     g_assert(object_resolve_path_component(parent, "dummy0")
359              == OBJECT(dobj));
360 
361     object_unparent(OBJECT(dobj));
362 }
363 
364 
365 static Object *new_helper(Error **errp,
366                           Object *parent,
367                           ...)
368 {
369     va_list vargs;
370     Object *obj;
371 
372     va_start(vargs, parent);
373     obj = object_new_with_propv(TYPE_DUMMY,
374                                 parent,
375                                 "dummy0",
376                                 errp,
377                                 vargs);
378     va_end(vargs);
379     return obj;
380 }
381 
382 static void test_dummy_createlist(void)
383 {
384     Error *err = NULL;
385     Object *parent = object_get_objects_root();
386     DummyObject *dobj = DUMMY_OBJECT(
387         new_helper(&err,
388                    parent,
389                    "bv", "yes",
390                    "sv", "Hiss hiss hiss",
391                    "av", "platypus",
392                    NULL));
393 
394     g_assert(err == NULL);
395     g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
396     g_assert(dobj->bv == true);
397     g_assert(dobj->av == DUMMY_PLATYPUS);
398 
399     g_assert(object_resolve_path_component(parent, "dummy0")
400              == OBJECT(dobj));
401 
402     object_unparent(OBJECT(dobj));
403 }
404 
405 static bool test_create_obj(QDict *qdict, Error **errp)
406 {
407     Visitor *v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
408     Object *obj = user_creatable_add_type(TYPE_DUMMY, "dev0", qdict, v, errp);
409 
410     visit_free(v);
411     object_unref(obj);
412     return !!obj;
413 }
414 
415 static void test_dummy_createcmdl(void)
416 {
417     QDict *qdict;
418     DummyObject *dobj;
419     Error *err = NULL;
420     bool created, help;
421     const char *params = "bv=yes,sv=Hiss hiss hiss,av=platypus";
422 
423     /* Needed for user_creatable_del.  */
424     qemu_add_opts(&qemu_object_opts);
425 
426     qdict = keyval_parse(params, "qom-type", &help, &err);
427     g_assert(err == NULL);
428     g_assert(qdict);
429     g_assert(!help);
430 
431     created = test_create_obj(qdict, &err);
432     g_assert(created);
433     g_assert(err == NULL);
434     qobject_unref(qdict);
435 
436     dobj = DUMMY_OBJECT(object_resolve_path_component(object_get_objects_root(),
437                                                       "dev0"));
438     g_assert(dobj);
439     g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
440     g_assert(dobj->bv == true);
441     g_assert(dobj->av == DUMMY_PLATYPUS);
442 
443     qdict = keyval_parse(params, "qom-type", &help, &err);
444     created = test_create_obj(qdict, &err);
445     g_assert(!created);
446     g_assert(err);
447     g_assert(object_resolve_path_component(object_get_objects_root(), "dev0")
448              == OBJECT(dobj));
449     qobject_unref(qdict);
450     error_free(err);
451     err = NULL;
452 
453     qdict = keyval_parse(params, "qom-type", &help, &err);
454     user_creatable_del("dev0", &error_abort);
455     g_assert(object_resolve_path_component(object_get_objects_root(), "dev0")
456              == NULL);
457 
458     created = test_create_obj(qdict, &err);
459     g_assert(created);
460     g_assert(err == NULL);
461     qobject_unref(qdict);
462 
463     dobj = DUMMY_OBJECT(object_resolve_path_component(object_get_objects_root(),
464                                                       "dev0"));
465     g_assert(dobj);
466     g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
467     g_assert(dobj->bv == true);
468     g_assert(dobj->av == DUMMY_PLATYPUS);
469     g_assert(object_resolve_path_component(object_get_objects_root(), "dev0")
470              == OBJECT(dobj));
471 
472     object_unparent(OBJECT(dobj));
473 }
474 
475 static void test_dummy_badenum(void)
476 {
477     Error *err = NULL;
478     Object *parent = object_get_objects_root();
479     Object *dobj =
480         object_new_with_props(TYPE_DUMMY,
481                               parent,
482                               "dummy0",
483                               &err,
484                               "bv", "yes",
485                               "sv", "Hiss hiss hiss",
486                               "av", "yeti",
487                               NULL);
488 
489     g_assert(dobj == NULL);
490     g_assert(err != NULL);
491     g_assert_cmpstr(error_get_pretty(err), ==,
492                     "Parameter 'av' does not accept value 'yeti'");
493 
494     g_assert(object_resolve_path_component(parent, "dummy0")
495              == NULL);
496 
497     error_free(err);
498 }
499 
500 
501 static void test_dummy_getenum(void)
502 {
503     Error *err = NULL;
504     int val;
505     Object *parent = object_get_objects_root();
506     DummyObject *dobj = DUMMY_OBJECT(
507         object_new_with_props(TYPE_DUMMY,
508                          parent,
509                          "dummy0",
510                          &err,
511                          "av", "platypus",
512                          NULL));
513 
514     g_assert(err == NULL);
515     g_assert(dobj->av == DUMMY_PLATYPUS);
516 
517     val = object_property_get_enum(OBJECT(dobj),
518                                    "av",
519                                    "DummyAnimal",
520                                    &error_abort);
521     g_assert(val == DUMMY_PLATYPUS);
522 
523     /* A bad enum type name */
524     val = object_property_get_enum(OBJECT(dobj),
525                                    "av",
526                                    "BadAnimal",
527                                    &err);
528     g_assert(val == -1);
529     error_free_or_abort(&err);
530 
531     /* A non-enum property name */
532     val = object_property_get_enum(OBJECT(dobj),
533                                    "iv",
534                                    "DummyAnimal",
535                                    &err);
536     g_assert(val == -1);
537     error_free_or_abort(&err);
538 
539     object_unparent(OBJECT(dobj));
540 }
541 
542 
543 static void test_dummy_prop_iterator(ObjectPropertyIterator *iter,
544                                      const char *expected[], int n)
545 {
546     ObjectProperty *prop;
547     int i;
548 
549     while ((prop = object_property_iter_next(iter))) {
550         for (i = 0; i < n; i++) {
551             if (!g_strcmp0(prop->name, expected[i])) {
552                 break;
553             }
554         }
555         g_assert(i < n);
556         expected[i] = NULL;
557     }
558 
559     for (i = 0; i < n; i++) {
560         g_assert(!expected[i]);
561     }
562 }
563 
564 static void test_dummy_iterator(void)
565 {
566     const char *expected[] = {
567         "type",                 /* inherited from TYPE_OBJECT */
568         "sv", "av",             /* class properties */
569         "bv"};                  /* instance property */
570     Object *parent = object_get_objects_root();
571     DummyObject *dobj = DUMMY_OBJECT(
572         object_new_with_props(TYPE_DUMMY,
573                               parent,
574                               "dummy0",
575                               &error_abort,
576                               "bv", "yes",
577                               "sv", "Hiss hiss hiss",
578                               "av", "platypus",
579                               NULL));
580     ObjectPropertyIterator iter;
581 
582     object_property_iter_init(&iter, OBJECT(dobj));
583     test_dummy_prop_iterator(&iter, expected, ARRAY_SIZE(expected));
584     object_unparent(OBJECT(dobj));
585 }
586 
587 static void test_dummy_class_iterator(void)
588 {
589     const char *expected[] = { "type", "av", "sv" };
590     ObjectPropertyIterator iter;
591     ObjectClass *klass = object_class_by_name(TYPE_DUMMY);
592 
593     object_class_property_iter_init(&iter, klass);
594     test_dummy_prop_iterator(&iter, expected, ARRAY_SIZE(expected));
595 }
596 
597 static void test_dummy_delchild(void)
598 {
599     Object *parent = object_get_objects_root();
600     DummyDev *dev = DUMMY_DEV(
601         object_new_with_props(TYPE_DUMMY_DEV,
602                               parent,
603                               "dev0",
604                               &error_abort,
605                               NULL));
606 
607     object_unparent(OBJECT(dev));
608 }
609 
610 static void test_qom_partial_path(void)
611 {
612     Object *root  = object_get_objects_root();
613     Object *cont1 = container_get(root, "/cont1");
614     Object *obj1  = object_new(TYPE_DUMMY);
615     Object *obj2a = object_new(TYPE_DUMMY);
616     Object *obj2b = object_new(TYPE_DUMMY);
617     bool ambiguous;
618 
619     /* Objects created:
620      * /cont1
621      * /cont1/obj1
622      * /cont1/obj2 (obj2a)
623      * /obj2 (obj2b)
624      */
625     object_property_add_child(cont1, "obj1", obj1);
626     object_unref(obj1);
627     object_property_add_child(cont1, "obj2", obj2a);
628     object_unref(obj2a);
629     object_property_add_child(root,  "obj2", obj2b);
630     object_unref(obj2b);
631 
632     ambiguous = false;
633     g_assert(!object_resolve_path_type("", TYPE_DUMMY, &ambiguous));
634     g_assert(ambiguous);
635     g_assert(!object_resolve_path_type("", TYPE_DUMMY, NULL));
636 
637     ambiguous = false;
638     g_assert(!object_resolve_path("obj2", &ambiguous));
639     g_assert(ambiguous);
640     g_assert(!object_resolve_path("obj2", NULL));
641 
642     ambiguous = false;
643     g_assert(object_resolve_path("obj1", &ambiguous) == obj1);
644     g_assert(!ambiguous);
645     g_assert(object_resolve_path("obj1", NULL) == obj1);
646 
647     object_unparent(obj2b);
648     object_unparent(cont1);
649 }
650 
651 int main(int argc, char **argv)
652 {
653     g_test_init(&argc, &argv, NULL);
654 
655     module_call_init(MODULE_INIT_QOM);
656     type_register_static(&dummy_info);
657     type_register_static(&dummy_dev_info);
658     type_register_static(&dummy_bus_info);
659     type_register_static(&dummy_backend_info);
660 
661     g_test_add_func("/qom/proplist/createlist", test_dummy_createlist);
662     g_test_add_func("/qom/proplist/createv", test_dummy_createv);
663     g_test_add_func("/qom/proplist/createcmdline", test_dummy_createcmdl);
664     g_test_add_func("/qom/proplist/badenum", test_dummy_badenum);
665     g_test_add_func("/qom/proplist/getenum", test_dummy_getenum);
666     g_test_add_func("/qom/proplist/iterator", test_dummy_iterator);
667     g_test_add_func("/qom/proplist/class_iterator", test_dummy_class_iterator);
668     g_test_add_func("/qom/proplist/delchild", test_dummy_delchild);
669     g_test_add_func("/qom/resolve/partial", test_qom_partial_path);
670 
671     return g_test_run();
672 }
673