]> Git Repo - qemu.git/blob - qdev-monitor.c
check-qjson: Simplify around compare_litqobj_to_qobj()
[qemu.git] / qdev-monitor.c
1 /*
2  *  Dynamic device configuration and creation.
3  *
4  *  Copyright (c) 2009 CodeSourcery
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include "qemu/osdep.h"
21 #include "hw/qdev.h"
22 #include "hw/sysbus.h"
23 #include "monitor/monitor.h"
24 #include "monitor/qdev.h"
25 #include "qmp-commands.h"
26 #include "sysemu/arch_init.h"
27 #include "qapi/qmp/qerror.h"
28 #include "qemu/config-file.h"
29 #include "qemu/error-report.h"
30 #include "qemu/help_option.h"
31 #include "sysemu/block-backend.h"
32 #include "migration/migration.h"
33
34 /*
35  * Aliases were a bad idea from the start.  Let's keep them
36  * from spreading further.
37  */
38 typedef struct QDevAlias
39 {
40     const char *typename;
41     const char *alias;
42     uint32_t arch_mask;
43 } QDevAlias;
44
45 /* Please keep this table sorted by typename. */
46 static const QDevAlias qdev_alias_table[] = {
47     { "e1000", "e1000-82540em" },
48     { "ich9-ahci", "ahci" },
49     { "kvm-pci-assign", "pci-assign" },
50     { "lsi53c895a", "lsi" },
51     { "virtio-9p-ccw", "virtio-9p", QEMU_ARCH_S390X },
52     { "virtio-9p-pci", "virtio-9p", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
53     { "virtio-balloon-ccw", "virtio-balloon", QEMU_ARCH_S390X },
54     { "virtio-balloon-pci", "virtio-balloon",
55             QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
56     { "virtio-blk-ccw", "virtio-blk", QEMU_ARCH_S390X },
57     { "virtio-blk-pci", "virtio-blk", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
58     { "virtio-gpu-ccw", "virtio-gpu", QEMU_ARCH_S390X },
59     { "virtio-gpu-pci", "virtio-gpu", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
60     { "virtio-input-host-ccw", "virtio-input-host", QEMU_ARCH_S390X },
61     { "virtio-input-host-pci", "virtio-input-host",
62             QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
63     { "virtio-keyboard-ccw", "virtio-keyboard", QEMU_ARCH_S390X },
64     { "virtio-keyboard-pci", "virtio-keyboard",
65             QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
66     { "virtio-mouse-ccw", "virtio-mouse", QEMU_ARCH_S390X },
67     { "virtio-mouse-pci", "virtio-mouse", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
68     { "virtio-net-ccw", "virtio-net", QEMU_ARCH_S390X },
69     { "virtio-net-pci", "virtio-net", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
70     { "virtio-rng-ccw", "virtio-rng", QEMU_ARCH_S390X },
71     { "virtio-rng-pci", "virtio-rng", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
72     { "virtio-scsi-ccw", "virtio-scsi", QEMU_ARCH_S390X },
73     { "virtio-scsi-pci", "virtio-scsi", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
74     { "virtio-serial-ccw", "virtio-serial", QEMU_ARCH_S390X },
75     { "virtio-serial-pci", "virtio-serial", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
76     { "virtio-tablet-ccw", "virtio-tablet", QEMU_ARCH_S390X },
77     { "virtio-tablet-pci", "virtio-tablet", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
78     { }
79 };
80
81 static const char *qdev_class_get_alias(DeviceClass *dc)
82 {
83     const char *typename = object_class_get_name(OBJECT_CLASS(dc));
84     int i;
85
86     for (i = 0; qdev_alias_table[i].typename; i++) {
87         if (qdev_alias_table[i].arch_mask &&
88             !(qdev_alias_table[i].arch_mask & arch_type)) {
89             continue;
90         }
91
92         if (strcmp(qdev_alias_table[i].typename, typename) == 0) {
93             return qdev_alias_table[i].alias;
94         }
95     }
96
97     return NULL;
98 }
99
100 static bool qdev_class_has_alias(DeviceClass *dc)
101 {
102     return (qdev_class_get_alias(dc) != NULL);
103 }
104
105 static void qdev_print_devinfo(DeviceClass *dc)
106 {
107     error_printf("name \"%s\"", object_class_get_name(OBJECT_CLASS(dc)));
108     if (dc->bus_type) {
109         error_printf(", bus %s", dc->bus_type);
110     }
111     if (qdev_class_has_alias(dc)) {
112         error_printf(", alias \"%s\"", qdev_class_get_alias(dc));
113     }
114     if (dc->desc) {
115         error_printf(", desc \"%s\"", dc->desc);
116     }
117     if (dc->cannot_instantiate_with_device_add_yet) {
118         error_printf(", no-user");
119     }
120     error_printf("\n");
121 }
122
123 static gint devinfo_cmp(gconstpointer a, gconstpointer b)
124 {
125     return strcasecmp(object_class_get_name((ObjectClass *)a),
126                       object_class_get_name((ObjectClass *)b));
127 }
128
129 static void qdev_print_devinfos(bool show_no_user)
130 {
131     static const char *cat_name[DEVICE_CATEGORY_MAX + 1] = {
132         [DEVICE_CATEGORY_BRIDGE]  = "Controller/Bridge/Hub",
133         [DEVICE_CATEGORY_USB]     = "USB",
134         [DEVICE_CATEGORY_STORAGE] = "Storage",
135         [DEVICE_CATEGORY_NETWORK] = "Network",
136         [DEVICE_CATEGORY_INPUT]   = "Input",
137         [DEVICE_CATEGORY_DISPLAY] = "Display",
138         [DEVICE_CATEGORY_SOUND]   = "Sound",
139         [DEVICE_CATEGORY_MISC]    = "Misc",
140         [DEVICE_CATEGORY_CPU]     = "CPU",
141         [DEVICE_CATEGORY_MAX]     = "Uncategorized",
142     };
143     GSList *list, *elt;
144     int i;
145     bool cat_printed;
146
147     list = g_slist_sort(object_class_get_list(TYPE_DEVICE, false),
148                         devinfo_cmp);
149
150     for (i = 0; i <= DEVICE_CATEGORY_MAX; i++) {
151         cat_printed = false;
152         for (elt = list; elt; elt = elt->next) {
153             DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
154                                                  TYPE_DEVICE);
155             if ((i < DEVICE_CATEGORY_MAX
156                  ? !test_bit(i, dc->categories)
157                  : !bitmap_empty(dc->categories, DEVICE_CATEGORY_MAX))
158                 || (!show_no_user
159                     && dc->cannot_instantiate_with_device_add_yet)) {
160                 continue;
161             }
162             if (!cat_printed) {
163                 error_printf("%s%s devices:\n", i ? "\n" : "",
164                              cat_name[i]);
165                 cat_printed = true;
166             }
167             qdev_print_devinfo(dc);
168         }
169     }
170
171     g_slist_free(list);
172 }
173
174 static int set_property(void *opaque, const char *name, const char *value,
175                         Error **errp)
176 {
177     Object *obj = opaque;
178     Error *err = NULL;
179
180     if (strcmp(name, "driver") == 0)
181         return 0;
182     if (strcmp(name, "bus") == 0)
183         return 0;
184
185     object_property_parse(obj, value, name, &err);
186     if (err != NULL) {
187         error_propagate(errp, err);
188         return -1;
189     }
190     return 0;
191 }
192
193 static const char *find_typename_by_alias(const char *alias)
194 {
195     int i;
196
197     for (i = 0; qdev_alias_table[i].alias; i++) {
198         if (qdev_alias_table[i].arch_mask &&
199             !(qdev_alias_table[i].arch_mask & arch_type)) {
200             continue;
201         }
202
203         if (strcmp(qdev_alias_table[i].alias, alias) == 0) {
204             return qdev_alias_table[i].typename;
205         }
206     }
207
208     return NULL;
209 }
210
211 static DeviceClass *qdev_get_device_class(const char **driver, Error **errp)
212 {
213     ObjectClass *oc;
214     DeviceClass *dc;
215     const char *original_name = *driver;
216
217     oc = object_class_by_name(*driver);
218     if (!oc) {
219         const char *typename = find_typename_by_alias(*driver);
220
221         if (typename) {
222             *driver = typename;
223             oc = object_class_by_name(*driver);
224         }
225     }
226
227     if (!object_class_dynamic_cast(oc, TYPE_DEVICE)) {
228         if (*driver != original_name) {
229             error_setg(errp, "'%s' (alias '%s') is not a valid device model"
230                        " name", original_name, *driver);
231         } else {
232             error_setg(errp, "'%s' is not a valid device model name", *driver);
233         }
234         return NULL;
235     }
236
237     if (object_class_is_abstract(oc)) {
238         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
239                    "non-abstract device type");
240         return NULL;
241     }
242
243     dc = DEVICE_CLASS(oc);
244     if (dc->cannot_instantiate_with_device_add_yet ||
245         (qdev_hotplug && !dc->hotpluggable)) {
246         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
247                    "pluggable device type");
248         return NULL;
249     }
250
251     return dc;
252 }
253
254
255 int qdev_device_help(QemuOpts *opts)
256 {
257     Error *local_err = NULL;
258     const char *driver;
259     DevicePropertyInfoList *prop_list;
260     DevicePropertyInfoList *prop;
261
262     driver = qemu_opt_get(opts, "driver");
263     if (driver && is_help_option(driver)) {
264         qdev_print_devinfos(false);
265         return 1;
266     }
267
268     if (!driver || !qemu_opt_has_help_opt(opts)) {
269         return 0;
270     }
271
272     if (!object_class_by_name(driver)) {
273         const char *typename = find_typename_by_alias(driver);
274
275         if (typename) {
276             driver = typename;
277         }
278     }
279
280     prop_list = qmp_device_list_properties(driver, &local_err);
281     if (local_err) {
282         goto error;
283     }
284
285     for (prop = prop_list; prop; prop = prop->next) {
286         error_printf("%s.%s=%s", driver,
287                      prop->value->name,
288                      prop->value->type);
289         if (prop->value->has_description) {
290             error_printf(" (%s)\n", prop->value->description);
291         } else {
292             error_printf("\n");
293         }
294     }
295
296     qapi_free_DevicePropertyInfoList(prop_list);
297     return 1;
298
299 error:
300     error_report_err(local_err);
301     return 1;
302 }
303
304 static Object *qdev_get_peripheral(void)
305 {
306     static Object *dev;
307
308     if (dev == NULL) {
309         dev = container_get(qdev_get_machine(), "/peripheral");
310     }
311
312     return dev;
313 }
314
315 static Object *qdev_get_peripheral_anon(void)
316 {
317     static Object *dev;
318
319     if (dev == NULL) {
320         dev = container_get(qdev_get_machine(), "/peripheral-anon");
321     }
322
323     return dev;
324 }
325
326 static void qbus_list_bus(DeviceState *dev, Error **errp)
327 {
328     BusState *child;
329     const char *sep = " ";
330
331     error_append_hint(errp, "child buses at \"%s\":",
332                       dev->id ? dev->id : object_get_typename(OBJECT(dev)));
333     QLIST_FOREACH(child, &dev->child_bus, sibling) {
334         error_append_hint(errp, "%s\"%s\"", sep, child->name);
335         sep = ", ";
336     }
337     error_append_hint(errp, "\n");
338 }
339
340 static void qbus_list_dev(BusState *bus, Error **errp)
341 {
342     BusChild *kid;
343     const char *sep = " ";
344
345     error_append_hint(errp, "devices at \"%s\":", bus->name);
346     QTAILQ_FOREACH(kid, &bus->children, sibling) {
347         DeviceState *dev = kid->child;
348         error_append_hint(errp, "%s\"%s\"", sep,
349                           object_get_typename(OBJECT(dev)));
350         if (dev->id) {
351             error_append_hint(errp, "/\"%s\"", dev->id);
352         }
353         sep = ", ";
354     }
355     error_append_hint(errp, "\n");
356 }
357
358 static BusState *qbus_find_bus(DeviceState *dev, char *elem)
359 {
360     BusState *child;
361
362     QLIST_FOREACH(child, &dev->child_bus, sibling) {
363         if (strcmp(child->name, elem) == 0) {
364             return child;
365         }
366     }
367     return NULL;
368 }
369
370 static DeviceState *qbus_find_dev(BusState *bus, char *elem)
371 {
372     BusChild *kid;
373
374     /*
375      * try to match in order:
376      *   (1) instance id, if present
377      *   (2) driver name
378      *   (3) driver alias, if present
379      */
380     QTAILQ_FOREACH(kid, &bus->children, sibling) {
381         DeviceState *dev = kid->child;
382         if (dev->id  &&  strcmp(dev->id, elem) == 0) {
383             return dev;
384         }
385     }
386     QTAILQ_FOREACH(kid, &bus->children, sibling) {
387         DeviceState *dev = kid->child;
388         if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) {
389             return dev;
390         }
391     }
392     QTAILQ_FOREACH(kid, &bus->children, sibling) {
393         DeviceState *dev = kid->child;
394         DeviceClass *dc = DEVICE_GET_CLASS(dev);
395
396         if (qdev_class_has_alias(dc) &&
397             strcmp(qdev_class_get_alias(dc), elem) == 0) {
398             return dev;
399         }
400     }
401     return NULL;
402 }
403
404 static inline bool qbus_is_full(BusState *bus)
405 {
406     BusClass *bus_class = BUS_GET_CLASS(bus);
407     return bus_class->max_dev && bus->max_index >= bus_class->max_dev;
408 }
409
410 /*
411  * Search the tree rooted at @bus for a bus.
412  * If @name, search for a bus with that name.  Note that bus names
413  * need not be unique.  Yes, that's screwed up.
414  * Else search for a bus that is a subtype of @bus_typename.
415  * If more than one exists, prefer one that can take another device.
416  * Return the bus if found, else %NULL.
417  */
418 static BusState *qbus_find_recursive(BusState *bus, const char *name,
419                                      const char *bus_typename)
420 {
421     BusChild *kid;
422     BusState *pick, *child, *ret;
423     bool match;
424
425     assert(name || bus_typename);
426     if (name) {
427         match = !strcmp(bus->name, name);
428     } else {
429         match = !!object_dynamic_cast(OBJECT(bus), bus_typename);
430     }
431
432     if (match && !qbus_is_full(bus)) {
433         return bus;             /* root matches and isn't full */
434     }
435
436     pick = match ? bus : NULL;
437
438     QTAILQ_FOREACH(kid, &bus->children, sibling) {
439         DeviceState *dev = kid->child;
440         QLIST_FOREACH(child, &dev->child_bus, sibling) {
441             ret = qbus_find_recursive(child, name, bus_typename);
442             if (ret && !qbus_is_full(ret)) {
443                 return ret;     /* a descendant matches and isn't full */
444             }
445             if (ret && !pick) {
446                 pick = ret;
447             }
448         }
449     }
450
451     /* root or a descendant matches, but is full */
452     return pick;
453 }
454
455 static BusState *qbus_find(const char *path, Error **errp)
456 {
457     DeviceState *dev;
458     BusState *bus;
459     char elem[128];
460     int pos, len;
461
462     /* find start element */
463     if (path[0] == '/') {
464         bus = sysbus_get_default();
465         pos = 0;
466     } else {
467         if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
468             assert(!path[0]);
469             elem[0] = len = 0;
470         }
471         bus = qbus_find_recursive(sysbus_get_default(), elem, NULL);
472         if (!bus) {
473             error_setg(errp, "Bus '%s' not found", elem);
474             return NULL;
475         }
476         pos = len;
477     }
478
479     for (;;) {
480         assert(path[pos] == '/' || !path[pos]);
481         while (path[pos] == '/') {
482             pos++;
483         }
484         if (path[pos] == '\0') {
485             break;
486         }
487
488         /* find device */
489         if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
490             g_assert_not_reached();
491             elem[0] = len = 0;
492         }
493         pos += len;
494         dev = qbus_find_dev(bus, elem);
495         if (!dev) {
496             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
497                       "Device '%s' not found", elem);
498             qbus_list_dev(bus, errp);
499             return NULL;
500         }
501
502         assert(path[pos] == '/' || !path[pos]);
503         while (path[pos] == '/') {
504             pos++;
505         }
506         if (path[pos] == '\0') {
507             /* last specified element is a device.  If it has exactly
508              * one child bus accept it nevertheless */
509             if (dev->num_child_bus == 1) {
510                 bus = QLIST_FIRST(&dev->child_bus);
511                 break;
512             }
513             if (dev->num_child_bus) {
514                 error_setg(errp, "Device '%s' has multiple child buses",
515                            elem);
516                 qbus_list_bus(dev, errp);
517             } else {
518                 error_setg(errp, "Device '%s' has no child bus", elem);
519             }
520             return NULL;
521         }
522
523         /* find bus */
524         if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
525             g_assert_not_reached();
526             elem[0] = len = 0;
527         }
528         pos += len;
529         bus = qbus_find_bus(dev, elem);
530         if (!bus) {
531             error_setg(errp, "Bus '%s' not found", elem);
532             qbus_list_bus(dev, errp);
533             return NULL;
534         }
535     }
536
537     if (qbus_is_full(bus)) {
538         error_setg(errp, "Bus '%s' is full", path);
539         return NULL;
540     }
541     return bus;
542 }
543
544 void qdev_set_id(DeviceState *dev, const char *id)
545 {
546     if (id) {
547         dev->id = id;
548     }
549
550     if (dev->id) {
551         object_property_add_child(qdev_get_peripheral(), dev->id,
552                                   OBJECT(dev), NULL);
553     } else {
554         static int anon_count;
555         gchar *name = g_strdup_printf("device[%d]", anon_count++);
556         object_property_add_child(qdev_get_peripheral_anon(), name,
557                                   OBJECT(dev), NULL);
558         g_free(name);
559     }
560 }
561
562 DeviceState *qdev_device_add(QemuOpts *opts, Error **errp)
563 {
564     DeviceClass *dc;
565     const char *driver, *path;
566     DeviceState *dev;
567     BusState *bus = NULL;
568     Error *err = NULL;
569
570     driver = qemu_opt_get(opts, "driver");
571     if (!driver) {
572         error_setg(errp, QERR_MISSING_PARAMETER, "driver");
573         return NULL;
574     }
575
576     /* find driver */
577     dc = qdev_get_device_class(&driver, errp);
578     if (!dc) {
579         return NULL;
580     }
581
582     if (only_migratable) {
583         if (dc->vmsd->unmigratable) {
584             error_setg(errp, "Device %s is not migratable, but "
585                        "--only-migratable was specified", driver);
586             return NULL;
587         }
588     }
589
590     /* find bus */
591     path = qemu_opt_get(opts, "bus");
592     if (path != NULL) {
593         bus = qbus_find(path, errp);
594         if (!bus) {
595             return NULL;
596         }
597         if (!object_dynamic_cast(OBJECT(bus), dc->bus_type)) {
598             error_setg(errp, "Device '%s' can't go on %s bus",
599                        driver, object_get_typename(OBJECT(bus)));
600             return NULL;
601         }
602     } else if (dc->bus_type != NULL) {
603         bus = qbus_find_recursive(sysbus_get_default(), NULL, dc->bus_type);
604         if (!bus || qbus_is_full(bus)) {
605             error_setg(errp, "No '%s' bus found for device '%s'",
606                        dc->bus_type, driver);
607             return NULL;
608         }
609     }
610     if (qdev_hotplug && bus && !qbus_is_hotpluggable(bus)) {
611         error_setg(errp, QERR_BUS_NO_HOTPLUG, bus->name);
612         return NULL;
613     }
614
615     /* create device */
616     dev = DEVICE(object_new(driver));
617
618     if (bus) {
619         qdev_set_parent_bus(dev, bus);
620     }
621
622     qdev_set_id(dev, qemu_opts_id(opts));
623
624     /* set properties */
625     if (qemu_opt_foreach(opts, set_property, dev, &err)) {
626         error_propagate(errp, err);
627         object_unparent(OBJECT(dev));
628         object_unref(OBJECT(dev));
629         return NULL;
630     }
631
632     dev->opts = opts;
633     object_property_set_bool(OBJECT(dev), true, "realized", &err);
634     if (err != NULL) {
635         error_propagate(errp, err);
636         dev->opts = NULL;
637         object_unparent(OBJECT(dev));
638         object_unref(OBJECT(dev));
639         return NULL;
640     }
641     return dev;
642 }
643
644
645 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
646 static void qbus_print(Monitor *mon, BusState *bus, int indent);
647
648 static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
649                              int indent)
650 {
651     if (!props)
652         return;
653     for (; props->name; props++) {
654         Error *err = NULL;
655         char *value;
656         char *legacy_name = g_strdup_printf("legacy-%s", props->name);
657         if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
658             value = object_property_get_str(OBJECT(dev), legacy_name, &err);
659         } else {
660             value = object_property_print(OBJECT(dev), props->name, true, &err);
661         }
662         g_free(legacy_name);
663
664         if (err) {
665             error_free(err);
666             continue;
667         }
668         qdev_printf("%s = %s\n", props->name,
669                     value && *value ? value : "<null>");
670         g_free(value);
671     }
672 }
673
674 static void bus_print_dev(BusState *bus, Monitor *mon, DeviceState *dev, int indent)
675 {
676     BusClass *bc = BUS_GET_CLASS(bus);
677
678     if (bc->print_dev) {
679         bc->print_dev(mon, dev, indent);
680     }
681 }
682
683 static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
684 {
685     ObjectClass *class;
686     BusState *child;
687     NamedGPIOList *ngl;
688
689     qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)),
690                 dev->id ? dev->id : "");
691     indent += 2;
692     QLIST_FOREACH(ngl, &dev->gpios, node) {
693         if (ngl->num_in) {
694             qdev_printf("gpio-in \"%s\" %d\n", ngl->name ? ngl->name : "",
695                         ngl->num_in);
696         }
697         if (ngl->num_out) {
698             qdev_printf("gpio-out \"%s\" %d\n", ngl->name ? ngl->name : "",
699                         ngl->num_out);
700         }
701     }
702     class = object_get_class(OBJECT(dev));
703     do {
704         qdev_print_props(mon, dev, DEVICE_CLASS(class)->props, indent);
705         class = object_class_get_parent(class);
706     } while (class != object_class_by_name(TYPE_DEVICE));
707     bus_print_dev(dev->parent_bus, mon, dev, indent);
708     QLIST_FOREACH(child, &dev->child_bus, sibling) {
709         qbus_print(mon, child, indent);
710     }
711 }
712
713 static void qbus_print(Monitor *mon, BusState *bus, int indent)
714 {
715     BusChild *kid;
716
717     qdev_printf("bus: %s\n", bus->name);
718     indent += 2;
719     qdev_printf("type %s\n", object_get_typename(OBJECT(bus)));
720     QTAILQ_FOREACH(kid, &bus->children, sibling) {
721         DeviceState *dev = kid->child;
722         qdev_print(mon, dev, indent);
723     }
724 }
725 #undef qdev_printf
726
727 void hmp_info_qtree(Monitor *mon, const QDict *qdict)
728 {
729     if (sysbus_get_default())
730         qbus_print(mon, sysbus_get_default(), 0);
731 }
732
733 void hmp_info_qdm(Monitor *mon, const QDict *qdict)
734 {
735     qdev_print_devinfos(true);
736 }
737
738 typedef struct QOMCompositionState {
739     Monitor *mon;
740     int indent;
741 } QOMCompositionState;
742
743 static void print_qom_composition(Monitor *mon, Object *obj, int indent);
744
745 static int print_qom_composition_child(Object *obj, void *opaque)
746 {
747     QOMCompositionState *s = opaque;
748
749     print_qom_composition(s->mon, obj, s->indent);
750
751     return 0;
752 }
753
754 static void print_qom_composition(Monitor *mon, Object *obj, int indent)
755 {
756     QOMCompositionState s = {
757         .mon = mon,
758         .indent = indent + 2,
759     };
760     char *name;
761
762     if (obj == object_get_root()) {
763         name = g_strdup("");
764     } else {
765         name = object_get_canonical_path_component(obj);
766     }
767     monitor_printf(mon, "%*s/%s (%s)\n", indent, "", name,
768                    object_get_typename(obj));
769     g_free(name);
770     object_child_foreach(obj, print_qom_composition_child, &s);
771 }
772
773 void hmp_info_qom_tree(Monitor *mon, const QDict *dict)
774 {
775     const char *path = qdict_get_try_str(dict, "path");
776     Object *obj;
777     bool ambiguous = false;
778
779     if (path) {
780         obj = object_resolve_path(path, &ambiguous);
781         if (!obj) {
782             monitor_printf(mon, "Path '%s' could not be resolved.\n", path);
783             return;
784         }
785         if (ambiguous) {
786             monitor_printf(mon, "Warning: Path '%s' is ambiguous.\n", path);
787             return;
788         }
789     } else {
790         obj = qdev_get_machine();
791     }
792     print_qom_composition(mon, obj, 0);
793 }
794
795 void qmp_device_add(QDict *qdict, QObject **ret_data, Error **errp)
796 {
797     Error *local_err = NULL;
798     QemuOpts *opts;
799     DeviceState *dev;
800
801     opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err);
802     if (local_err) {
803         error_propagate(errp, local_err);
804         return;
805     }
806     if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
807         qemu_opts_del(opts);
808         return;
809     }
810     dev = qdev_device_add(opts, &local_err);
811     if (!dev) {
812         error_propagate(errp, local_err);
813         qemu_opts_del(opts);
814         return;
815     }
816     object_unref(OBJECT(dev));
817 }
818
819 static DeviceState *find_device_state(const char *id, Error **errp)
820 {
821     Object *obj;
822
823     if (id[0] == '/') {
824         obj = object_resolve_path(id, NULL);
825     } else {
826         char *root_path = object_get_canonical_path(qdev_get_peripheral());
827         char *path = g_strdup_printf("%s/%s", root_path, id);
828
829         g_free(root_path);
830         obj = object_resolve_path_type(path, TYPE_DEVICE, NULL);
831         g_free(path);
832     }
833
834     if (!obj) {
835         error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
836                   "Device '%s' not found", id);
837         return NULL;
838     }
839
840     if (!object_dynamic_cast(obj, TYPE_DEVICE)) {
841         error_setg(errp, "%s is not a hotpluggable device", id);
842         return NULL;
843     }
844
845     return DEVICE(obj);
846 }
847
848 void qmp_device_del(const char *id, Error **errp)
849 {
850     DeviceState *dev = find_device_state(id, errp);
851     if (dev != NULL) {
852         qdev_unplug(dev, errp);
853     }
854 }
855
856 BlockBackend *blk_by_qdev_id(const char *id, Error **errp)
857 {
858     DeviceState *dev;
859     BlockBackend *blk;
860
861     dev = find_device_state(id, errp);
862     if (dev == NULL) {
863         return NULL;
864     }
865
866     blk = blk_by_dev(dev);
867     if (!blk) {
868         error_setg(errp, "Device does not have a block device backend");
869     }
870     return blk;
871 }
872
873 void qdev_machine_init(void)
874 {
875     qdev_get_peripheral_anon();
876     qdev_get_peripheral();
877 }
878
879 QemuOptsList qemu_device_opts = {
880     .name = "device",
881     .implied_opt_name = "driver",
882     .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
883     .desc = {
884         /*
885          * no elements => accept any
886          * sanity checking will happen later
887          * when setting device properties
888          */
889         { /* end of list */ }
890     },
891 };
892
893 QemuOptsList qemu_global_opts = {
894     .name = "global",
895     .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head),
896     .desc = {
897         {
898             .name = "driver",
899             .type = QEMU_OPT_STRING,
900         },{
901             .name = "property",
902             .type = QEMU_OPT_STRING,
903         },{
904             .name = "value",
905             .type = QEMU_OPT_STRING,
906         },
907         { /* end of list */ }
908     },
909 };
910
911 int qemu_global_option(const char *str)
912 {
913     char driver[64], property[64];
914     QemuOpts *opts;
915     int rc, offset;
916
917     rc = sscanf(str, "%63[^.=].%63[^=]%n", driver, property, &offset);
918     if (rc == 2 && str[offset] == '=') {
919         opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort);
920         qemu_opt_set(opts, "driver", driver, &error_abort);
921         qemu_opt_set(opts, "property", property, &error_abort);
922         qemu_opt_set(opts, "value", str + offset + 1, &error_abort);
923         return 0;
924     }
925
926     opts = qemu_opts_parse_noisily(&qemu_global_opts, str, false);
927     if (!opts) {
928         return -1;
929     }
930
931     return 0;
932 }
This page took 0.074092 seconds and 4 git commands to generate.