Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging
[qemu/ar7.git] / qdev-monitor.c
blob58222c2211d2116fda1dd65a4fca3740e6144981
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  */
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 "sysemu/arch_init.h"
26 #include "qapi/error.h"
27 #include "qapi/qapi-commands-qdev.h"
28 #include "qapi/qmp/qdict.h"
29 #include "qapi/qmp/qerror.h"
30 #include "qemu/config-file.h"
31 #include "qemu/error-report.h"
32 #include "qemu/help_option.h"
33 #include "qemu/option.h"
34 #include "qemu/qemu-print.h"
35 #include "sysemu/block-backend.h"
36 #include "migration/misc.h"
39  * Aliases were a bad idea from the start.  Let's keep them
40  * from spreading further.
41  */
42 typedef struct QDevAlias
44     const char *typename;
45     const char *alias;
46     uint32_t arch_mask;
47 } QDevAlias;
49 /* Please keep this table sorted by typename. */
50 static const QDevAlias qdev_alias_table[] = {
51     { "e1000", "e1000-82540em" },
52     { "ich9-ahci", "ahci" },
53     { "lsi53c895a", "lsi" },
54     { "virtio-9p-ccw", "virtio-9p", QEMU_ARCH_S390X },
55     { "virtio-9p-pci", "virtio-9p", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
56     { "virtio-balloon-ccw", "virtio-balloon", QEMU_ARCH_S390X },
57     { "virtio-balloon-pci", "virtio-balloon",
58             QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
59     { "virtio-blk-ccw", "virtio-blk", QEMU_ARCH_S390X },
60     { "virtio-blk-pci", "virtio-blk", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
61     { "virtio-gpu-ccw", "virtio-gpu", QEMU_ARCH_S390X },
62     { "virtio-gpu-pci", "virtio-gpu", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
63     { "virtio-input-host-ccw", "virtio-input-host", QEMU_ARCH_S390X },
64     { "virtio-input-host-pci", "virtio-input-host",
65             QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
66     { "virtio-keyboard-ccw", "virtio-keyboard", QEMU_ARCH_S390X },
67     { "virtio-keyboard-pci", "virtio-keyboard",
68             QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
69     { "virtio-mouse-ccw", "virtio-mouse", QEMU_ARCH_S390X },
70     { "virtio-mouse-pci", "virtio-mouse", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
71     { "virtio-net-ccw", "virtio-net", QEMU_ARCH_S390X },
72     { "virtio-net-pci", "virtio-net", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
73     { "virtio-rng-ccw", "virtio-rng", QEMU_ARCH_S390X },
74     { "virtio-rng-pci", "virtio-rng", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
75     { "virtio-scsi-ccw", "virtio-scsi", QEMU_ARCH_S390X },
76     { "virtio-scsi-pci", "virtio-scsi", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
77     { "virtio-serial-ccw", "virtio-serial", QEMU_ARCH_S390X },
78     { "virtio-serial-pci", "virtio-serial", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
79     { "virtio-tablet-ccw", "virtio-tablet", QEMU_ARCH_S390X },
80     { "virtio-tablet-pci", "virtio-tablet", QEMU_ARCH_ALL & ~QEMU_ARCH_S390X },
81     { }
84 static const char *qdev_class_get_alias(DeviceClass *dc)
86     const char *typename = object_class_get_name(OBJECT_CLASS(dc));
87     int i;
89     for (i = 0; qdev_alias_table[i].typename; i++) {
90         if (qdev_alias_table[i].arch_mask &&
91             !(qdev_alias_table[i].arch_mask & arch_type)) {
92             continue;
93         }
95         if (strcmp(qdev_alias_table[i].typename, typename) == 0) {
96             return qdev_alias_table[i].alias;
97         }
98     }
100     return NULL;
103 static bool qdev_class_has_alias(DeviceClass *dc)
105     return (qdev_class_get_alias(dc) != NULL);
108 static void qdev_print_devinfo(DeviceClass *dc)
110     qemu_printf("name \"%s\"", object_class_get_name(OBJECT_CLASS(dc)));
111     if (dc->bus_type) {
112         qemu_printf(", bus %s", dc->bus_type);
113     }
114     if (qdev_class_has_alias(dc)) {
115         qemu_printf(", alias \"%s\"", qdev_class_get_alias(dc));
116     }
117     if (dc->desc) {
118         qemu_printf(", desc \"%s\"", dc->desc);
119     }
120     if (!dc->user_creatable) {
121         qemu_printf(", no-user");
122     }
123     qemu_printf("\n");
126 static void qdev_print_devinfos(bool show_no_user)
128     static const char *cat_name[DEVICE_CATEGORY_MAX + 1] = {
129         [DEVICE_CATEGORY_BRIDGE]  = "Controller/Bridge/Hub",
130         [DEVICE_CATEGORY_USB]     = "USB",
131         [DEVICE_CATEGORY_STORAGE] = "Storage",
132         [DEVICE_CATEGORY_NETWORK] = "Network",
133         [DEVICE_CATEGORY_INPUT]   = "Input",
134         [DEVICE_CATEGORY_DISPLAY] = "Display",
135         [DEVICE_CATEGORY_SOUND]   = "Sound",
136         [DEVICE_CATEGORY_MISC]    = "Misc",
137         [DEVICE_CATEGORY_CPU]     = "CPU",
138         [DEVICE_CATEGORY_MAX]     = "Uncategorized",
139     };
140     GSList *list, *elt;
141     int i;
142     bool cat_printed;
144     list = object_class_get_list_sorted(TYPE_DEVICE, false);
146     for (i = 0; i <= DEVICE_CATEGORY_MAX; i++) {
147         cat_printed = false;
148         for (elt = list; elt; elt = elt->next) {
149             DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
150                                                  TYPE_DEVICE);
151             if ((i < DEVICE_CATEGORY_MAX
152                  ? !test_bit(i, dc->categories)
153                  : !bitmap_empty(dc->categories, DEVICE_CATEGORY_MAX))
154                 || (!show_no_user
155                     && !dc->user_creatable)) {
156                 continue;
157             }
158             if (!cat_printed) {
159                 qemu_printf("%s%s devices:\n", i ? "\n" : "", cat_name[i]);
160                 cat_printed = true;
161             }
162             qdev_print_devinfo(dc);
163         }
164     }
166     g_slist_free(list);
169 static int set_property(void *opaque, const char *name, const char *value,
170                         Error **errp)
172     Object *obj = opaque;
173     Error *err = NULL;
175     if (strcmp(name, "driver") == 0)
176         return 0;
177     if (strcmp(name, "bus") == 0)
178         return 0;
180     object_property_parse(obj, value, name, &err);
181     if (err != NULL) {
182         error_propagate(errp, err);
183         return -1;
184     }
185     return 0;
188 static const char *find_typename_by_alias(const char *alias)
190     int i;
192     for (i = 0; qdev_alias_table[i].alias; i++) {
193         if (qdev_alias_table[i].arch_mask &&
194             !(qdev_alias_table[i].arch_mask & arch_type)) {
195             continue;
196         }
198         if (strcmp(qdev_alias_table[i].alias, alias) == 0) {
199             return qdev_alias_table[i].typename;
200         }
201     }
203     return NULL;
206 static DeviceClass *qdev_get_device_class(const char **driver, Error **errp)
208     ObjectClass *oc;
209     DeviceClass *dc;
210     const char *original_name = *driver;
212     oc = object_class_by_name(*driver);
213     if (!oc) {
214         const char *typename = find_typename_by_alias(*driver);
216         if (typename) {
217             *driver = typename;
218             oc = object_class_by_name(*driver);
219         }
220     }
222     if (!object_class_dynamic_cast(oc, TYPE_DEVICE)) {
223         if (*driver != original_name) {
224             error_setg(errp, "'%s' (alias '%s') is not a valid device model"
225                        " name", original_name, *driver);
226         } else {
227             error_setg(errp, "'%s' is not a valid device model name", *driver);
228         }
229         return NULL;
230     }
232     if (object_class_is_abstract(oc)) {
233         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
234                    "non-abstract device type");
235         return NULL;
236     }
238     dc = DEVICE_CLASS(oc);
239     if (!dc->user_creatable ||
240         (qdev_hotplug && !dc->hotpluggable)) {
241         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
242                    "pluggable device type");
243         return NULL;
244     }
246     return dc;
250 int qdev_device_help(QemuOpts *opts)
252     Error *local_err = NULL;
253     const char *driver;
254     ObjectPropertyInfoList *prop_list;
255     ObjectPropertyInfoList *prop;
257     driver = qemu_opt_get(opts, "driver");
258     if (driver && is_help_option(driver)) {
259         qdev_print_devinfos(false);
260         return 1;
261     }
263     if (!driver || !qemu_opt_has_help_opt(opts)) {
264         return 0;
265     }
267     if (!object_class_by_name(driver)) {
268         const char *typename = find_typename_by_alias(driver);
270         if (typename) {
271             driver = typename;
272         }
273     }
275     prop_list = qmp_device_list_properties(driver, &local_err);
276     if (local_err) {
277         goto error;
278     }
280     if (prop_list) {
281         qemu_printf("%s options:\n", driver);
282     } else {
283         qemu_printf("There are no options for %s.\n", driver);
284     }
285     for (prop = prop_list; prop; prop = prop->next) {
286         int len;
287         qemu_printf("  %s=<%s>%n", prop->value->name, prop->value->type, &len);
288         if (prop->value->has_description) {
289             if (len < 24) {
290                 qemu_printf("%*s", 24 - len, "");
291             }
292             qemu_printf(" - %s\n", prop->value->description);
293         } else {
294             qemu_printf("\n");
295         }
296     }
298     qapi_free_ObjectPropertyInfoList(prop_list);
299     return 1;
301 error:
302     error_report_err(local_err);
303     return 1;
306 static Object *qdev_get_peripheral(void)
308     static Object *dev;
310     if (dev == NULL) {
311         dev = container_get(qdev_get_machine(), "/peripheral");
312     }
314     return dev;
317 static Object *qdev_get_peripheral_anon(void)
319     static Object *dev;
321     if (dev == NULL) {
322         dev = container_get(qdev_get_machine(), "/peripheral-anon");
323     }
325     return dev;
328 static void qbus_list_bus(DeviceState *dev, Error **errp)
330     BusState *child;
331     const char *sep = " ";
333     error_append_hint(errp, "child buses at \"%s\":",
334                       dev->id ? dev->id : object_get_typename(OBJECT(dev)));
335     QLIST_FOREACH(child, &dev->child_bus, sibling) {
336         error_append_hint(errp, "%s\"%s\"", sep, child->name);
337         sep = ", ";
338     }
339     error_append_hint(errp, "\n");
342 static void qbus_list_dev(BusState *bus, Error **errp)
344     BusChild *kid;
345     const char *sep = " ";
347     error_append_hint(errp, "devices at \"%s\":", bus->name);
348     QTAILQ_FOREACH(kid, &bus->children, sibling) {
349         DeviceState *dev = kid->child;
350         error_append_hint(errp, "%s\"%s\"", sep,
351                           object_get_typename(OBJECT(dev)));
352         if (dev->id) {
353             error_append_hint(errp, "/\"%s\"", dev->id);
354         }
355         sep = ", ";
356     }
357     error_append_hint(errp, "\n");
360 static BusState *qbus_find_bus(DeviceState *dev, char *elem)
362     BusState *child;
364     QLIST_FOREACH(child, &dev->child_bus, sibling) {
365         if (strcmp(child->name, elem) == 0) {
366             return child;
367         }
368     }
369     return NULL;
372 static DeviceState *qbus_find_dev(BusState *bus, char *elem)
374     BusChild *kid;
376     /*
377      * try to match in order:
378      *   (1) instance id, if present
379      *   (2) driver name
380      *   (3) driver alias, if present
381      */
382     QTAILQ_FOREACH(kid, &bus->children, sibling) {
383         DeviceState *dev = kid->child;
384         if (dev->id  &&  strcmp(dev->id, elem) == 0) {
385             return dev;
386         }
387     }
388     QTAILQ_FOREACH(kid, &bus->children, sibling) {
389         DeviceState *dev = kid->child;
390         if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) {
391             return dev;
392         }
393     }
394     QTAILQ_FOREACH(kid, &bus->children, sibling) {
395         DeviceState *dev = kid->child;
396         DeviceClass *dc = DEVICE_GET_CLASS(dev);
398         if (qdev_class_has_alias(dc) &&
399             strcmp(qdev_class_get_alias(dc), elem) == 0) {
400             return dev;
401         }
402     }
403     return NULL;
406 static inline bool qbus_is_full(BusState *bus)
408     BusClass *bus_class = BUS_GET_CLASS(bus);
409     return bus_class->max_dev && bus->num_children >= bus_class->max_dev;
413  * Search the tree rooted at @bus for a bus.
414  * If @name, search for a bus with that name.  Note that bus names
415  * need not be unique.  Yes, that's screwed up.
416  * Else search for a bus that is a subtype of @bus_typename.
417  * If more than one exists, prefer one that can take another device.
418  * Return the bus if found, else %NULL.
419  */
420 static BusState *qbus_find_recursive(BusState *bus, const char *name,
421                                      const char *bus_typename)
423     BusChild *kid;
424     BusState *pick, *child, *ret;
425     bool match;
427     assert(name || bus_typename);
428     if (name) {
429         match = !strcmp(bus->name, name);
430     } else {
431         match = !!object_dynamic_cast(OBJECT(bus), bus_typename);
432     }
434     if (match && !qbus_is_full(bus)) {
435         return bus;             /* root matches and isn't full */
436     }
438     pick = match ? bus : NULL;
440     QTAILQ_FOREACH(kid, &bus->children, sibling) {
441         DeviceState *dev = kid->child;
442         QLIST_FOREACH(child, &dev->child_bus, sibling) {
443             ret = qbus_find_recursive(child, name, bus_typename);
444             if (ret && !qbus_is_full(ret)) {
445                 return ret;     /* a descendant matches and isn't full */
446             }
447             if (ret && !pick) {
448                 pick = ret;
449             }
450         }
451     }
453     /* root or a descendant matches, but is full */
454     return pick;
457 static BusState *qbus_find(const char *path, Error **errp)
459     DeviceState *dev;
460     BusState *bus;
461     char elem[128];
462     int pos, len;
464     /* find start element */
465     if (path[0] == '/') {
466         bus = sysbus_get_default();
467         pos = 0;
468     } else {
469         if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
470             assert(!path[0]);
471             elem[0] = len = 0;
472         }
473         bus = qbus_find_recursive(sysbus_get_default(), elem, NULL);
474         if (!bus) {
475             error_setg(errp, "Bus '%s' not found", elem);
476             return NULL;
477         }
478         pos = len;
479     }
481     for (;;) {
482         assert(path[pos] == '/' || !path[pos]);
483         while (path[pos] == '/') {
484             pos++;
485         }
486         if (path[pos] == '\0') {
487             break;
488         }
490         /* find device */
491         if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
492             g_assert_not_reached();
493             elem[0] = len = 0;
494         }
495         pos += len;
496         dev = qbus_find_dev(bus, elem);
497         if (!dev) {
498             error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
499                       "Device '%s' not found", elem);
500             qbus_list_dev(bus, errp);
501             return NULL;
502         }
504         assert(path[pos] == '/' || !path[pos]);
505         while (path[pos] == '/') {
506             pos++;
507         }
508         if (path[pos] == '\0') {
509             /* last specified element is a device.  If it has exactly
510              * one child bus accept it nevertheless */
511             if (dev->num_child_bus == 1) {
512                 bus = QLIST_FIRST(&dev->child_bus);
513                 break;
514             }
515             if (dev->num_child_bus) {
516                 error_setg(errp, "Device '%s' has multiple child buses",
517                            elem);
518                 qbus_list_bus(dev, errp);
519             } else {
520                 error_setg(errp, "Device '%s' has no child bus", elem);
521             }
522             return NULL;
523         }
525         /* find bus */
526         if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
527             g_assert_not_reached();
528             elem[0] = len = 0;
529         }
530         pos += len;
531         bus = qbus_find_bus(dev, elem);
532         if (!bus) {
533             error_setg(errp, "Bus '%s' not found", elem);
534             qbus_list_bus(dev, errp);
535             return NULL;
536         }
537     }
539     if (qbus_is_full(bus)) {
540         error_setg(errp, "Bus '%s' is full", path);
541         return NULL;
542     }
543     return bus;
546 void qdev_set_id(DeviceState *dev, const char *id)
548     if (id) {
549         dev->id = id;
550     }
552     if (dev->id) {
553         object_property_add_child(qdev_get_peripheral(), dev->id,
554                                   OBJECT(dev), NULL);
555     } else {
556         static int anon_count;
557         gchar *name = g_strdup_printf("device[%d]", anon_count++);
558         object_property_add_child(qdev_get_peripheral_anon(), name,
559                                   OBJECT(dev), NULL);
560         g_free(name);
561     }
564 DeviceState *qdev_device_add(QemuOpts *opts, Error **errp)
566     DeviceClass *dc;
567     const char *driver, *path;
568     DeviceState *dev;
569     BusState *bus = NULL;
570     Error *err = NULL;
572     driver = qemu_opt_get(opts, "driver");
573     if (!driver) {
574         error_setg(errp, QERR_MISSING_PARAMETER, "driver");
575         return NULL;
576     }
578     /* find driver */
579     dc = qdev_get_device_class(&driver, errp);
580     if (!dc) {
581         return NULL;
582     }
584     /* find bus */
585     path = qemu_opt_get(opts, "bus");
586     if (path != NULL) {
587         bus = qbus_find(path, errp);
588         if (!bus) {
589             return NULL;
590         }
591         if (!object_dynamic_cast(OBJECT(bus), dc->bus_type)) {
592             error_setg(errp, "Device '%s' can't go on %s bus",
593                        driver, object_get_typename(OBJECT(bus)));
594             return NULL;
595         }
596     } else if (dc->bus_type != NULL) {
597         bus = qbus_find_recursive(sysbus_get_default(), NULL, dc->bus_type);
598         if (!bus || qbus_is_full(bus)) {
599             error_setg(errp, "No '%s' bus found for device '%s'",
600                        dc->bus_type, driver);
601             return NULL;
602         }
603     }
604     if (qdev_hotplug && bus && !qbus_is_hotpluggable(bus)) {
605         error_setg(errp, QERR_BUS_NO_HOTPLUG, bus->name);
606         return NULL;
607     }
609     if (!migration_is_idle()) {
610         error_setg(errp, "device_add not allowed while migrating");
611         return NULL;
612     }
614     /* create device */
615     dev = DEVICE(object_new(driver));
617     if (bus) {
618         qdev_set_parent_bus(dev, bus);
619     } else if (qdev_hotplug && !qdev_get_machine_hotplug_handler(dev)) {
620         /* No bus, no machine hotplug handler --> device is not hotpluggable */
621         error_setg(&err, "Device '%s' can not be hotplugged on this machine",
622                    driver);
623         goto err_del_dev;
624     }
626     qdev_set_id(dev, qemu_opts_id(opts));
628     /* set properties */
629     if (qemu_opt_foreach(opts, set_property, dev, &err)) {
630         goto err_del_dev;
631     }
633     dev->opts = opts;
634     object_property_set_bool(OBJECT(dev), true, "realized", &err);
635     if (err != NULL) {
636         dev->opts = NULL;
637         goto err_del_dev;
638     }
639     return dev;
641 err_del_dev:
642     error_propagate(errp, err);
643     object_unparent(OBJECT(dev));
644     object_unref(OBJECT(dev));
645     return NULL;
649 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
650 static void qbus_print(Monitor *mon, BusState *bus, int indent);
652 static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
653                              int indent)
655     if (!props)
656         return;
657     for (; props->name; props++) {
658         Error *err = NULL;
659         char *value;
660         char *legacy_name = g_strdup_printf("legacy-%s", props->name);
661         if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
662             value = object_property_get_str(OBJECT(dev), legacy_name, &err);
663         } else {
664             value = object_property_print(OBJECT(dev), props->name, true, &err);
665         }
666         g_free(legacy_name);
668         if (err) {
669             error_free(err);
670             continue;
671         }
672         qdev_printf("%s = %s\n", props->name,
673                     value && *value ? value : "<null>");
674         g_free(value);
675     }
678 static void bus_print_dev(BusState *bus, Monitor *mon, DeviceState *dev, int indent)
680     BusClass *bc = BUS_GET_CLASS(bus);
682     if (bc->print_dev) {
683         bc->print_dev(mon, dev, indent);
684     }
687 static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
689     ObjectClass *class;
690     BusState *child;
691     NamedGPIOList *ngl;
693     qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)),
694                 dev->id ? dev->id : "");
695     indent += 2;
696     QLIST_FOREACH(ngl, &dev->gpios, node) {
697         if (ngl->num_in) {
698             qdev_printf("gpio-in \"%s\" %d\n", ngl->name ? ngl->name : "",
699                         ngl->num_in);
700         }
701         if (ngl->num_out) {
702             qdev_printf("gpio-out \"%s\" %d\n", ngl->name ? ngl->name : "",
703                         ngl->num_out);
704         }
705     }
706     class = object_get_class(OBJECT(dev));
707     do {
708         qdev_print_props(mon, dev, DEVICE_CLASS(class)->props, indent);
709         class = object_class_get_parent(class);
710     } while (class != object_class_by_name(TYPE_DEVICE));
711     bus_print_dev(dev->parent_bus, mon, dev, indent);
712     QLIST_FOREACH(child, &dev->child_bus, sibling) {
713         qbus_print(mon, child, indent);
714     }
717 static void qbus_print(Monitor *mon, BusState *bus, int indent)
719     BusChild *kid;
721     qdev_printf("bus: %s\n", bus->name);
722     indent += 2;
723     qdev_printf("type %s\n", object_get_typename(OBJECT(bus)));
724     QTAILQ_FOREACH(kid, &bus->children, sibling) {
725         DeviceState *dev = kid->child;
726         qdev_print(mon, dev, indent);
727     }
729 #undef qdev_printf
731 void hmp_info_qtree(Monitor *mon, const QDict *qdict)
733     if (sysbus_get_default())
734         qbus_print(mon, sysbus_get_default(), 0);
737 void hmp_info_qdm(Monitor *mon, const QDict *qdict)
739     qdev_print_devinfos(true);
742 void qmp_device_add(QDict *qdict, QObject **ret_data, Error **errp)
744     Error *local_err = NULL;
745     QemuOpts *opts;
746     DeviceState *dev;
748     opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err);
749     if (local_err) {
750         error_propagate(errp, local_err);
751         return;
752     }
753     if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
754         qemu_opts_del(opts);
755         return;
756     }
757     dev = qdev_device_add(opts, &local_err);
758     if (!dev) {
759         error_propagate(errp, local_err);
760         qemu_opts_del(opts);
761         return;
762     }
763     object_unref(OBJECT(dev));
766 static DeviceState *find_device_state(const char *id, Error **errp)
768     Object *obj;
770     if (id[0] == '/') {
771         obj = object_resolve_path(id, NULL);
772     } else {
773         char *root_path = object_get_canonical_path(qdev_get_peripheral());
774         char *path = g_strdup_printf("%s/%s", root_path, id);
776         g_free(root_path);
777         obj = object_resolve_path_type(path, TYPE_DEVICE, NULL);
778         g_free(path);
779     }
781     if (!obj) {
782         error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
783                   "Device '%s' not found", id);
784         return NULL;
785     }
787     if (!object_dynamic_cast(obj, TYPE_DEVICE)) {
788         error_setg(errp, "%s is not a hotpluggable device", id);
789         return NULL;
790     }
792     return DEVICE(obj);
795 void qdev_unplug(DeviceState *dev, Error **errp)
797     DeviceClass *dc = DEVICE_GET_CLASS(dev);
798     HotplugHandler *hotplug_ctrl;
799     HotplugHandlerClass *hdc;
800     Error *local_err = NULL;
802     if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) {
803         error_setg(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
804         return;
805     }
807     if (!dc->hotpluggable) {
808         error_setg(errp, QERR_DEVICE_NO_HOTPLUG,
809                    object_get_typename(OBJECT(dev)));
810         return;
811     }
813     if (!migration_is_idle()) {
814         error_setg(errp, "device_del not allowed while migrating");
815         return;
816     }
818     qdev_hot_removed = true;
820     hotplug_ctrl = qdev_get_hotplug_handler(dev);
821     /* hotpluggable device MUST have HotplugHandler, if it doesn't
822      * then something is very wrong with it */
823     g_assert(hotplug_ctrl);
825     /* If device supports async unplug just request it to be done,
826      * otherwise just remove it synchronously */
827     hdc = HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl);
828     if (hdc->unplug_request) {
829         hotplug_handler_unplug_request(hotplug_ctrl, dev, &local_err);
830     } else {
831         hotplug_handler_unplug(hotplug_ctrl, dev, &local_err);
832         if (!local_err) {
833             object_unparent(OBJECT(dev));
834         }
835     }
836     error_propagate(errp, local_err);
839 void qmp_device_del(const char *id, Error **errp)
841     DeviceState *dev = find_device_state(id, errp);
842     if (dev != NULL) {
843         qdev_unplug(dev, errp);
844     }
847 BlockBackend *blk_by_qdev_id(const char *id, Error **errp)
849     DeviceState *dev;
850     BlockBackend *blk;
852     dev = find_device_state(id, errp);
853     if (dev == NULL) {
854         return NULL;
855     }
857     blk = blk_by_dev(dev);
858     if (!blk) {
859         error_setg(errp, "Device does not have a block device backend");
860     }
861     return blk;
864 void qdev_machine_init(void)
866     qdev_get_peripheral_anon();
867     qdev_get_peripheral();
870 QemuOptsList qemu_device_opts = {
871     .name = "device",
872     .implied_opt_name = "driver",
873     .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
874     .desc = {
875         /*
876          * no elements => accept any
877          * sanity checking will happen later
878          * when setting device properties
879          */
880         { /* end of list */ }
881     },
884 QemuOptsList qemu_global_opts = {
885     .name = "global",
886     .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head),
887     .desc = {
888         {
889             .name = "driver",
890             .type = QEMU_OPT_STRING,
891         },{
892             .name = "property",
893             .type = QEMU_OPT_STRING,
894         },{
895             .name = "value",
896             .type = QEMU_OPT_STRING,
897         },
898         { /* end of list */ }
899     },
902 int qemu_global_option(const char *str)
904     char driver[64], property[64];
905     QemuOpts *opts;
906     int rc, offset;
908     rc = sscanf(str, "%63[^.=].%63[^=]%n", driver, property, &offset);
909     if (rc == 2 && str[offset] == '=') {
910         opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort);
911         qemu_opt_set(opts, "driver", driver, &error_abort);
912         qemu_opt_set(opts, "property", property, &error_abort);
913         qemu_opt_set(opts, "value", str + offset + 1, &error_abort);
914         return 0;
915     }
917     opts = qemu_opts_parse_noisily(&qemu_global_opts, str, false);
918     if (!opts) {
919         return -1;
920     }
922     return 0;