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