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/sysbus.h"
22#include "monitor/hmp.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/dispatch.h"
29#include "qapi/qmp/qdict.h"
30#include "qapi/qmp/qerror.h"
31#include "qapi/qmp/qstring.h"
32#include "qapi/qobject-input-visitor.h"
33#include "qemu/config-file.h"
34#include "qemu/error-report.h"
35#include "qemu/help_option.h"
36#include "qemu/option.h"
37#include "qemu/qemu-print.h"
38#include "qemu/option_int.h"
39#include "sysemu/block-backend.h"
40#include "migration/misc.h"
41#include "migration/migration.h"
42#include "qemu/cutils.h"
43#include "hw/qdev-properties.h"
44#include "hw/clock.h"
45#include "hw/boards.h"
46
47
48
49
50
51typedef struct QDevAlias
52{
53 const char *typename;
54 const char *alias;
55 uint32_t arch_mask;
56} QDevAlias;
57
58
59#define QEMU_ARCH_VIRTIO_PCI (QEMU_ARCH_ALPHA | QEMU_ARCH_ARM | \
60 QEMU_ARCH_HPPA | QEMU_ARCH_I386 | \
61 QEMU_ARCH_MIPS | QEMU_ARCH_PPC | \
62 QEMU_ARCH_RISCV | QEMU_ARCH_SH4 | \
63 QEMU_ARCH_SPARC | QEMU_ARCH_XTENSA)
64#define QEMU_ARCH_VIRTIO_CCW (QEMU_ARCH_S390X)
65#define QEMU_ARCH_VIRTIO_MMIO (QEMU_ARCH_M68K)
66
67
68static const QDevAlias qdev_alias_table[] = {
69 { "AC97", "ac97" },
70 { "e1000", "e1000-82540em" },
71 { "ES1370", "es1370" },
72 { "ich9-ahci", "ahci" },
73 { "lsi53c895a", "lsi" },
74 { "virtio-9p-device", "virtio-9p", QEMU_ARCH_VIRTIO_MMIO },
75 { "virtio-9p-ccw", "virtio-9p", QEMU_ARCH_VIRTIO_CCW },
76 { "virtio-9p-pci", "virtio-9p", QEMU_ARCH_VIRTIO_PCI },
77 { "virtio-balloon-device", "virtio-balloon", QEMU_ARCH_VIRTIO_MMIO },
78 { "virtio-balloon-ccw", "virtio-balloon", QEMU_ARCH_VIRTIO_CCW },
79 { "virtio-balloon-pci", "virtio-balloon", QEMU_ARCH_VIRTIO_PCI },
80 { "virtio-blk-device", "virtio-blk", QEMU_ARCH_VIRTIO_MMIO },
81 { "virtio-blk-ccw", "virtio-blk", QEMU_ARCH_VIRTIO_CCW },
82 { "virtio-blk-pci", "virtio-blk", QEMU_ARCH_VIRTIO_PCI },
83 { "virtio-gpu-device", "virtio-gpu", QEMU_ARCH_VIRTIO_MMIO },
84 { "virtio-gpu-ccw", "virtio-gpu", QEMU_ARCH_VIRTIO_CCW },
85 { "virtio-gpu-pci", "virtio-gpu", QEMU_ARCH_VIRTIO_PCI },
86 { "virtio-gpu-gl-device", "virtio-gpu-gl", QEMU_ARCH_VIRTIO_MMIO },
87 { "virtio-gpu-gl-pci", "virtio-gpu-gl", QEMU_ARCH_VIRTIO_PCI },
88 { "virtio-input-host-device", "virtio-input-host", QEMU_ARCH_VIRTIO_MMIO },
89 { "virtio-input-host-ccw", "virtio-input-host", QEMU_ARCH_VIRTIO_CCW },
90 { "virtio-input-host-pci", "virtio-input-host", QEMU_ARCH_VIRTIO_PCI },
91 { "virtio-iommu-pci", "virtio-iommu", QEMU_ARCH_VIRTIO_PCI },
92 { "virtio-keyboard-device", "virtio-keyboard", QEMU_ARCH_VIRTIO_MMIO },
93 { "virtio-keyboard-ccw", "virtio-keyboard", QEMU_ARCH_VIRTIO_CCW },
94 { "virtio-keyboard-pci", "virtio-keyboard", QEMU_ARCH_VIRTIO_PCI },
95 { "virtio-mouse-device", "virtio-mouse", QEMU_ARCH_VIRTIO_MMIO },
96 { "virtio-mouse-ccw", "virtio-mouse", QEMU_ARCH_VIRTIO_CCW },
97 { "virtio-mouse-pci", "virtio-mouse", QEMU_ARCH_VIRTIO_PCI },
98 { "virtio-net-device", "virtio-net", QEMU_ARCH_VIRTIO_MMIO },
99 { "virtio-net-ccw", "virtio-net", QEMU_ARCH_VIRTIO_CCW },
100 { "virtio-net-pci", "virtio-net", QEMU_ARCH_VIRTIO_PCI },
101 { "virtio-rng-device", "virtio-rng", QEMU_ARCH_VIRTIO_MMIO },
102 { "virtio-rng-ccw", "virtio-rng", QEMU_ARCH_VIRTIO_CCW },
103 { "virtio-rng-pci", "virtio-rng", QEMU_ARCH_VIRTIO_PCI },
104 { "virtio-scsi-device", "virtio-scsi", QEMU_ARCH_VIRTIO_MMIO },
105 { "virtio-scsi-ccw", "virtio-scsi", QEMU_ARCH_VIRTIO_CCW },
106 { "virtio-scsi-pci", "virtio-scsi", QEMU_ARCH_VIRTIO_PCI },
107 { "virtio-serial-device", "virtio-serial", QEMU_ARCH_VIRTIO_MMIO },
108 { "virtio-serial-ccw", "virtio-serial", QEMU_ARCH_VIRTIO_CCW },
109 { "virtio-serial-pci", "virtio-serial", QEMU_ARCH_VIRTIO_PCI},
110 { "virtio-tablet-device", "virtio-tablet", QEMU_ARCH_VIRTIO_MMIO },
111 { "virtio-tablet-ccw", "virtio-tablet", QEMU_ARCH_VIRTIO_CCW },
112 { "virtio-tablet-pci", "virtio-tablet", QEMU_ARCH_VIRTIO_PCI },
113 { }
114};
115
116static const char *qdev_class_get_alias(DeviceClass *dc)
117{
118 const char *typename = object_class_get_name(OBJECT_CLASS(dc));
119 int i;
120
121 for (i = 0; qdev_alias_table[i].typename; i++) {
122 if (qdev_alias_table[i].arch_mask &&
123 !(qdev_alias_table[i].arch_mask & arch_type)) {
124 continue;
125 }
126
127 if (strcmp(qdev_alias_table[i].typename, typename) == 0) {
128 return qdev_alias_table[i].alias;
129 }
130 }
131
132 return NULL;
133}
134
135static bool qdev_class_has_alias(DeviceClass *dc)
136{
137 return (qdev_class_get_alias(dc) != NULL);
138}
139
140static void qdev_print_devinfo(DeviceClass *dc)
141{
142 qemu_printf("name \"%s\"", object_class_get_name(OBJECT_CLASS(dc)));
143 if (dc->bus_type) {
144 qemu_printf(", bus %s", dc->bus_type);
145 }
146 if (qdev_class_has_alias(dc)) {
147 qemu_printf(", alias \"%s\"", qdev_class_get_alias(dc));
148 }
149 if (dc->desc) {
150 qemu_printf(", desc \"%s\"", dc->desc);
151 }
152 if (!dc->user_creatable) {
153 qemu_printf(", no-user");
154 }
155 qemu_printf("\n");
156}
157
158static void qdev_print_devinfos(bool show_no_user)
159{
160 static const char *cat_name[DEVICE_CATEGORY_MAX + 1] = {
161 [DEVICE_CATEGORY_BRIDGE] = "Controller/Bridge/Hub",
162 [DEVICE_CATEGORY_USB] = "USB",
163 [DEVICE_CATEGORY_STORAGE] = "Storage",
164 [DEVICE_CATEGORY_NETWORK] = "Network",
165 [DEVICE_CATEGORY_INPUT] = "Input",
166 [DEVICE_CATEGORY_DISPLAY] = "Display",
167 [DEVICE_CATEGORY_SOUND] = "Sound",
168 [DEVICE_CATEGORY_MISC] = "Misc",
169 [DEVICE_CATEGORY_CPU] = "CPU",
170 [DEVICE_CATEGORY_WATCHDOG]= "Watchdog",
171 [DEVICE_CATEGORY_MAX] = "Uncategorized",
172 };
173 GSList *list, *elt;
174 int i;
175 bool cat_printed;
176
177 module_load_qom_all();
178 list = object_class_get_list_sorted(TYPE_DEVICE, false);
179
180 for (i = 0; i <= DEVICE_CATEGORY_MAX; i++) {
181 cat_printed = false;
182 for (elt = list; elt; elt = elt->next) {
183 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
184 TYPE_DEVICE);
185 if ((i < DEVICE_CATEGORY_MAX
186 ? !test_bit(i, dc->categories)
187 : !bitmap_empty(dc->categories, DEVICE_CATEGORY_MAX))
188 || (!show_no_user
189 && !dc->user_creatable)) {
190 continue;
191 }
192 if (!cat_printed) {
193 qemu_printf("%s%s devices:\n", i ? "\n" : "", cat_name[i]);
194 cat_printed = true;
195 }
196 qdev_print_devinfo(dc);
197 }
198 }
199
200 g_slist_free(list);
201}
202
203static const char *find_typename_by_alias(const char *alias)
204{
205 int i;
206
207 for (i = 0; qdev_alias_table[i].alias; i++) {
208 if (qdev_alias_table[i].arch_mask &&
209 !(qdev_alias_table[i].arch_mask & arch_type)) {
210 continue;
211 }
212
213 if (strcmp(qdev_alias_table[i].alias, alias) == 0) {
214 return qdev_alias_table[i].typename;
215 }
216 }
217
218 return NULL;
219}
220
221static DeviceClass *qdev_get_device_class(const char **driver, Error **errp)
222{
223 ObjectClass *oc;
224 DeviceClass *dc;
225 const char *original_name = *driver;
226
227 oc = module_object_class_by_name(*driver);
228 if (!oc) {
229 const char *typename = find_typename_by_alias(*driver);
230
231 if (typename) {
232 *driver = typename;
233 oc = module_object_class_by_name(*driver);
234 }
235 }
236
237 if (!object_class_dynamic_cast(oc, TYPE_DEVICE)) {
238 if (*driver != original_name) {
239 error_setg(errp, "'%s' (alias '%s') is not a valid device model"
240 " name", original_name, *driver);
241 } else {
242 error_setg(errp, "'%s' is not a valid device model name", *driver);
243 }
244 return NULL;
245 }
246
247 if (object_class_is_abstract(oc)) {
248 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
249 "a non-abstract device type");
250 return NULL;
251 }
252
253 dc = DEVICE_CLASS(oc);
254 if (!dc->user_creatable ||
255 (phase_check(PHASE_MACHINE_READY) && !dc->hotpluggable)) {
256 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
257 "a pluggable device type");
258 return NULL;
259 }
260
261 if (object_class_dynamic_cast(oc, TYPE_SYS_BUS_DEVICE)) {
262
263 MachineClass *mc = MACHINE_CLASS(object_get_class(qdev_get_machine()));
264 if (!device_type_is_dynamic_sysbus(mc, *driver)) {
265 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
266 "a dynamic sysbus device type for the machine");
267 return NULL;
268 }
269 }
270
271 return dc;
272}
273
274
275int qdev_device_help(QemuOpts *opts)
276{
277 Error *local_err = NULL;
278 const char *driver;
279 ObjectPropertyInfoList *prop_list;
280 ObjectPropertyInfoList *prop;
281 GPtrArray *array;
282 int i;
283
284 driver = qemu_opt_get(opts, "driver");
285 if (driver && is_help_option(driver)) {
286 qdev_print_devinfos(false);
287 return 1;
288 }
289
290 if (!driver || !qemu_opt_has_help_opt(opts)) {
291 return 0;
292 }
293
294 if (!object_class_by_name(driver)) {
295 const char *typename = find_typename_by_alias(driver);
296
297 if (typename) {
298 driver = typename;
299 }
300 }
301
302 prop_list = qmp_device_list_properties(driver, &local_err);
303 if (local_err) {
304 goto error;
305 }
306
307 if (prop_list) {
308 qemu_printf("%s options:\n", driver);
309 } else {
310 qemu_printf("There are no options for %s.\n", driver);
311 }
312 array = g_ptr_array_new();
313 for (prop = prop_list; prop; prop = prop->next) {
314 g_ptr_array_add(array,
315 object_property_help(prop->value->name,
316 prop->value->type,
317 prop->value->default_value,
318 prop->value->description));
319 }
320 g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
321 for (i = 0; i < array->len; i++) {
322 qemu_printf("%s\n", (char *)array->pdata[i]);
323 }
324 g_ptr_array_set_free_func(array, g_free);
325 g_ptr_array_free(array, true);
326 qapi_free_ObjectPropertyInfoList(prop_list);
327 return 1;
328
329error:
330 error_report_err(local_err);
331 return 1;
332}
333
334static Object *qdev_get_peripheral(void)
335{
336 static Object *dev;
337
338 if (dev == NULL) {
339 dev = container_get(qdev_get_machine(), "/peripheral");
340 }
341
342 return dev;
343}
344
345static Object *qdev_get_peripheral_anon(void)
346{
347 static Object *dev;
348
349 if (dev == NULL) {
350 dev = container_get(qdev_get_machine(), "/peripheral-anon");
351 }
352
353 return dev;
354}
355
356static void qbus_error_append_bus_list_hint(DeviceState *dev,
357 Error *const *errp)
358{
359 BusState *child;
360 const char *sep = " ";
361
362 error_append_hint(errp, "child buses at \"%s\":",
363 dev->id ? dev->id : object_get_typename(OBJECT(dev)));
364 QLIST_FOREACH(child, &dev->child_bus, sibling) {
365 error_append_hint(errp, "%s\"%s\"", sep, child->name);
366 sep = ", ";
367 }
368 error_append_hint(errp, "\n");
369}
370
371static void qbus_error_append_dev_list_hint(BusState *bus,
372 Error *const *errp)
373{
374 BusChild *kid;
375 const char *sep = " ";
376
377 error_append_hint(errp, "devices at \"%s\":", bus->name);
378 QTAILQ_FOREACH(kid, &bus->children, sibling) {
379 DeviceState *dev = kid->child;
380 error_append_hint(errp, "%s\"%s\"", sep,
381 object_get_typename(OBJECT(dev)));
382 if (dev->id) {
383 error_append_hint(errp, "/\"%s\"", dev->id);
384 }
385 sep = ", ";
386 }
387 error_append_hint(errp, "\n");
388}
389
390static BusState *qbus_find_bus(DeviceState *dev, char *elem)
391{
392 BusState *child;
393
394 QLIST_FOREACH(child, &dev->child_bus, sibling) {
395 if (strcmp(child->name, elem) == 0) {
396 return child;
397 }
398 }
399 return NULL;
400}
401
402static DeviceState *qbus_find_dev(BusState *bus, char *elem)
403{
404 BusChild *kid;
405
406
407
408
409
410
411
412 QTAILQ_FOREACH(kid, &bus->children, sibling) {
413 DeviceState *dev = kid->child;
414 if (dev->id && strcmp(dev->id, elem) == 0) {
415 return dev;
416 }
417 }
418 QTAILQ_FOREACH(kid, &bus->children, sibling) {
419 DeviceState *dev = kid->child;
420 if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) {
421 return dev;
422 }
423 }
424 QTAILQ_FOREACH(kid, &bus->children, sibling) {
425 DeviceState *dev = kid->child;
426 DeviceClass *dc = DEVICE_GET_CLASS(dev);
427
428 if (qdev_class_has_alias(dc) &&
429 strcmp(qdev_class_get_alias(dc), elem) == 0) {
430 return dev;
431 }
432 }
433 return NULL;
434}
435
436static inline bool qbus_is_full(BusState *bus)
437{
438 BusClass *bus_class;
439
440 if (bus->full) {
441 return true;
442 }
443 bus_class = BUS_GET_CLASS(bus);
444 return bus_class->max_dev && bus->num_children >= bus_class->max_dev;
445}
446
447
448
449
450
451
452
453
454
455static BusState *qbus_find_recursive(BusState *bus, const char *name,
456 const char *bus_typename)
457{
458 BusChild *kid;
459 BusState *pick, *child, *ret;
460 bool match;
461
462 assert(name || bus_typename);
463 if (name) {
464 match = !strcmp(bus->name, name);
465 } else {
466 match = !!object_dynamic_cast(OBJECT(bus), bus_typename);
467 }
468
469 if (match && !qbus_is_full(bus)) {
470 return bus;
471 }
472
473 pick = match ? bus : NULL;
474
475 QTAILQ_FOREACH(kid, &bus->children, sibling) {
476 DeviceState *dev = kid->child;
477 QLIST_FOREACH(child, &dev->child_bus, sibling) {
478 ret = qbus_find_recursive(child, name, bus_typename);
479 if (ret && !qbus_is_full(ret)) {
480 return ret;
481 }
482 if (ret && !pick) {
483 pick = ret;
484 }
485 }
486 }
487
488
489 return pick;
490}
491
492static BusState *qbus_find(const char *path, Error **errp)
493{
494 DeviceState *dev;
495 BusState *bus;
496 char elem[128];
497 int pos, len;
498
499
500 if (path[0] == '/') {
501 bus = sysbus_get_default();
502 pos = 0;
503 } else {
504 if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
505 assert(!path[0]);
506 elem[0] = len = 0;
507 }
508 bus = qbus_find_recursive(sysbus_get_default(), elem, NULL);
509 if (!bus) {
510 error_setg(errp, "Bus '%s' not found", elem);
511 return NULL;
512 }
513 pos = len;
514 }
515
516 for (;;) {
517 assert(path[pos] == '/' || !path[pos]);
518 while (path[pos] == '/') {
519 pos++;
520 }
521 if (path[pos] == '\0') {
522 break;
523 }
524
525
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 dev = qbus_find_dev(bus, elem);
532 if (!dev) {
533 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
534 "Device '%s' not found", elem);
535 qbus_error_append_dev_list_hint(bus, errp);
536 return NULL;
537 }
538
539 assert(path[pos] == '/' || !path[pos]);
540 while (path[pos] == '/') {
541 pos++;
542 }
543 if (path[pos] == '\0') {
544
545
546 if (dev->num_child_bus == 1) {
547 bus = QLIST_FIRST(&dev->child_bus);
548 break;
549 }
550 if (dev->num_child_bus) {
551 error_setg(errp, "Device '%s' has multiple child buses",
552 elem);
553 qbus_error_append_bus_list_hint(dev, errp);
554 } else {
555 error_setg(errp, "Device '%s' has no child bus", elem);
556 }
557 return NULL;
558 }
559
560
561 if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
562 g_assert_not_reached();
563 elem[0] = len = 0;
564 }
565 pos += len;
566 bus = qbus_find_bus(dev, elem);
567 if (!bus) {
568 error_setg(errp, "Bus '%s' not found", elem);
569 qbus_error_append_bus_list_hint(dev, errp);
570 return NULL;
571 }
572 }
573
574 if (qbus_is_full(bus)) {
575 error_setg(errp, "Bus '%s' is full", path);
576 return NULL;
577 }
578 return bus;
579}
580
581
582const char *qdev_set_id(DeviceState *dev, char *id, Error **errp)
583{
584 ObjectProperty *prop;
585
586 assert(!dev->id && !dev->realized);
587
588
589
590
591
592 if (id) {
593 prop = object_property_try_add_child(qdev_get_peripheral(), id,
594 OBJECT(dev), NULL);
595 if (prop) {
596 dev->id = id;
597 } else {
598 error_setg(errp, "Duplicate device ID '%s'", id);
599 g_free(id);
600 return NULL;
601 }
602 } else {
603 static int anon_count;
604 gchar *name = g_strdup_printf("device[%d]", anon_count++);
605 prop = object_property_add_child(qdev_get_peripheral_anon(), name,
606 OBJECT(dev));
607 g_free(name);
608 }
609
610 return prop->name;
611}
612
613DeviceState *qdev_device_add_from_qdict(const QDict *opts,
614 bool from_json, Error **errp)
615{
616 ERRP_GUARD();
617 DeviceClass *dc;
618 const char *driver, *path;
619 char *id;
620 DeviceState *dev = NULL;
621 BusState *bus = NULL;
622
623 driver = qdict_get_try_str(opts, "driver");
624 if (!driver) {
625 error_setg(errp, QERR_MISSING_PARAMETER, "driver");
626 return NULL;
627 }
628
629
630 dc = qdev_get_device_class(&driver, errp);
631 if (!dc) {
632 return NULL;
633 }
634
635
636 path = qdict_get_try_str(opts, "bus");
637 if (path != NULL) {
638 bus = qbus_find(path, errp);
639 if (!bus) {
640 return NULL;
641 }
642 if (!object_dynamic_cast(OBJECT(bus), dc->bus_type)) {
643 error_setg(errp, "Device '%s' can't go on %s bus",
644 driver, object_get_typename(OBJECT(bus)));
645 return NULL;
646 }
647 } else if (dc->bus_type != NULL) {
648 bus = qbus_find_recursive(sysbus_get_default(), NULL, dc->bus_type);
649 if (!bus || qbus_is_full(bus)) {
650 error_setg(errp, "No '%s' bus found for device '%s'",
651 dc->bus_type, driver);
652 return NULL;
653 }
654 }
655
656 if (qdev_should_hide_device(opts, from_json, errp)) {
657 if (bus && !qbus_is_hotpluggable(bus)) {
658 error_setg(errp, QERR_BUS_NO_HOTPLUG, bus->name);
659 }
660 return NULL;
661 } else if (*errp) {
662 return NULL;
663 }
664
665 if (phase_check(PHASE_MACHINE_READY) && bus && !qbus_is_hotpluggable(bus)) {
666 error_setg(errp, QERR_BUS_NO_HOTPLUG, bus->name);
667 return NULL;
668 }
669
670 if (!migration_is_idle()) {
671 error_setg(errp, "device_add not allowed while migrating");
672 return NULL;
673 }
674
675
676 dev = qdev_new(driver);
677
678
679 if (phase_check(PHASE_MACHINE_READY)) {
680 if (!qdev_hotplug_allowed(dev, errp)) {
681 goto err_del_dev;
682 }
683
684 if (!bus && !qdev_get_machine_hotplug_handler(dev)) {
685
686 error_setg(errp, "Device '%s' can not be hotplugged on this machine",
687 driver);
688 goto err_del_dev;
689 }
690 }
691
692
693
694
695
696 id = g_strdup(qdict_get_try_str(opts, "id"));
697 if (!qdev_set_id(dev, id, errp)) {
698 goto err_del_dev;
699 }
700
701
702 dev->opts = qdict_clone_shallow(opts);
703 qdict_del(dev->opts, "driver");
704 qdict_del(dev->opts, "bus");
705 qdict_del(dev->opts, "id");
706
707 object_set_properties_from_keyval(&dev->parent_obj, dev->opts, from_json,
708 errp);
709 if (*errp) {
710 goto err_del_dev;
711 }
712
713 if (!qdev_realize(DEVICE(dev), bus, errp)) {
714 goto err_del_dev;
715 }
716 return dev;
717
718err_del_dev:
719 if (dev) {
720 object_unparent(OBJECT(dev));
721 object_unref(OBJECT(dev));
722 }
723 return NULL;
724}
725
726
727DeviceState *qdev_device_add(QemuOpts *opts, Error **errp)
728{
729 QDict *qdict = qemu_opts_to_qdict(opts, NULL);
730 DeviceState *ret;
731
732 ret = qdev_device_add_from_qdict(qdict, false, errp);
733 if (ret) {
734 qemu_opts_del(opts);
735 }
736 qobject_unref(qdict);
737 return ret;
738}
739
740#define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
741static void qbus_print(Monitor *mon, BusState *bus, int indent);
742
743static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
744 int indent)
745{
746 if (!props)
747 return;
748 for (; props->name; props++) {
749 char *value;
750 char *legacy_name = g_strdup_printf("legacy-%s", props->name);
751
752 if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
753 value = object_property_get_str(OBJECT(dev), legacy_name, NULL);
754 } else {
755 value = object_property_print(OBJECT(dev), props->name, true,
756 NULL);
757 }
758 g_free(legacy_name);
759
760 if (!value) {
761 continue;
762 }
763 qdev_printf("%s = %s\n", props->name,
764 *value ? value : "<null>");
765 g_free(value);
766 }
767}
768
769static void bus_print_dev(BusState *bus, Monitor *mon, DeviceState *dev, int indent)
770{
771 BusClass *bc = BUS_GET_CLASS(bus);
772
773 if (bc->print_dev) {
774 bc->print_dev(mon, dev, indent);
775 }
776}
777
778static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
779{
780 ObjectClass *class;
781 BusState *child;
782 NamedGPIOList *ngl;
783 NamedClockList *ncl;
784
785 qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)),
786 dev->id ? dev->id : "");
787 indent += 2;
788 QLIST_FOREACH(ngl, &dev->gpios, node) {
789 if (ngl->num_in) {
790 qdev_printf("gpio-in \"%s\" %d\n", ngl->name ? ngl->name : "",
791 ngl->num_in);
792 }
793 if (ngl->num_out) {
794 qdev_printf("gpio-out \"%s\" %d\n", ngl->name ? ngl->name : "",
795 ngl->num_out);
796 }
797 }
798 QLIST_FOREACH(ncl, &dev->clocks, node) {
799 g_autofree char *freq_str = clock_display_freq(ncl->clock);
800 qdev_printf("clock-%s%s \"%s\" freq_hz=%s\n",
801 ncl->output ? "out" : "in",
802 ncl->alias ? " (alias)" : "",
803 ncl->name, freq_str);
804 }
805 class = object_get_class(OBJECT(dev));
806 do {
807 qdev_print_props(mon, dev, DEVICE_CLASS(class)->props_, indent);
808 class = object_class_get_parent(class);
809 } while (class != object_class_by_name(TYPE_DEVICE));
810 bus_print_dev(dev->parent_bus, mon, dev, indent);
811 QLIST_FOREACH(child, &dev->child_bus, sibling) {
812 qbus_print(mon, child, indent);
813 }
814}
815
816static void qbus_print(Monitor *mon, BusState *bus, int indent)
817{
818 BusChild *kid;
819
820 qdev_printf("bus: %s\n", bus->name);
821 indent += 2;
822 qdev_printf("type %s\n", object_get_typename(OBJECT(bus)));
823 QTAILQ_FOREACH(kid, &bus->children, sibling) {
824 DeviceState *dev = kid->child;
825 qdev_print(mon, dev, indent);
826 }
827}
828#undef qdev_printf
829
830void hmp_info_qtree(Monitor *mon, const QDict *qdict)
831{
832 if (sysbus_get_default())
833 qbus_print(mon, sysbus_get_default(), 0);
834}
835
836void hmp_info_qdm(Monitor *mon, const QDict *qdict)
837{
838 qdev_print_devinfos(true);
839}
840
841void qmp_device_add(QDict *qdict, QObject **ret_data, Error **errp)
842{
843 QemuOpts *opts;
844 DeviceState *dev;
845
846 opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, errp);
847 if (!opts) {
848 return;
849 }
850 if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
851 qemu_opts_del(opts);
852 return;
853 }
854 dev = qdev_device_add(opts, errp);
855
856
857
858
859
860
861
862
863
864
865 drain_call_rcu();
866
867 if (!dev) {
868 qemu_opts_del(opts);
869 return;
870 }
871 object_unref(OBJECT(dev));
872}
873
874static DeviceState *find_device_state(const char *id, Error **errp)
875{
876 Object *obj = object_resolve_path_at(qdev_get_peripheral(), id);
877 DeviceState *dev;
878
879 if (!obj) {
880 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
881 "Device '%s' not found", id);
882 return NULL;
883 }
884
885 dev = (DeviceState *)object_dynamic_cast(obj, TYPE_DEVICE);
886 if (!dev) {
887 error_setg(errp, "%s is not a hotpluggable device", id);
888 return NULL;
889 }
890
891 return dev;
892}
893
894void qdev_unplug(DeviceState *dev, Error **errp)
895{
896 DeviceClass *dc = DEVICE_GET_CLASS(dev);
897 HotplugHandler *hotplug_ctrl;
898 HotplugHandlerClass *hdc;
899 Error *local_err = NULL;
900
901 if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) {
902 error_setg(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
903 return;
904 }
905
906 if (!dc->hotpluggable) {
907 error_setg(errp, QERR_DEVICE_NO_HOTPLUG,
908 object_get_typename(OBJECT(dev)));
909 return;
910 }
911
912 if (!migration_is_idle() && !dev->allow_unplug_during_migration) {
913 error_setg(errp, "device_del not allowed while migrating");
914 return;
915 }
916
917 qdev_hot_removed = true;
918
919 hotplug_ctrl = qdev_get_hotplug_handler(dev);
920
921
922 g_assert(hotplug_ctrl);
923
924
925
926 hdc = HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl);
927 if (hdc->unplug_request) {
928 hotplug_handler_unplug_request(hotplug_ctrl, dev, &local_err);
929 } else {
930 hotplug_handler_unplug(hotplug_ctrl, dev, &local_err);
931 if (!local_err) {
932 object_unparent(OBJECT(dev));
933 }
934 }
935 error_propagate(errp, local_err);
936}
937
938void qmp_device_del(const char *id, Error **errp)
939{
940 DeviceState *dev = find_device_state(id, errp);
941 if (dev != NULL) {
942 if (dev->pending_deleted_event &&
943 (dev->pending_deleted_expires_ms == 0 ||
944 dev->pending_deleted_expires_ms > qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL))) {
945 error_setg(errp, "Device %s is already in the "
946 "process of unplug", id);
947 return;
948 }
949
950 qdev_unplug(dev, errp);
951 }
952}
953
954void hmp_device_add(Monitor *mon, const QDict *qdict)
955{
956 Error *err = NULL;
957
958 qmp_device_add((QDict *)qdict, NULL, &err);
959 hmp_handle_error(mon, err);
960}
961
962void hmp_device_del(Monitor *mon, const QDict *qdict)
963{
964 const char *id = qdict_get_str(qdict, "id");
965 Error *err = NULL;
966
967 qmp_device_del(id, &err);
968 hmp_handle_error(mon, err);
969}
970
971BlockBackend *blk_by_qdev_id(const char *id, Error **errp)
972{
973 DeviceState *dev;
974 BlockBackend *blk;
975
976 GLOBAL_STATE_CODE();
977
978 dev = find_device_state(id, errp);
979 if (dev == NULL) {
980 return NULL;
981 }
982
983 blk = blk_by_dev(dev);
984 if (!blk) {
985 error_setg(errp, "Device does not have a block device backend");
986 }
987 return blk;
988}
989
990QemuOptsList qemu_device_opts = {
991 .name = "device",
992 .implied_opt_name = "driver",
993 .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
994 .desc = {
995
996
997
998
999
1000 { }
1001 },
1002};
1003
1004QemuOptsList qemu_global_opts = {
1005 .name = "global",
1006 .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head),
1007 .desc = {
1008 {
1009 .name = "driver",
1010 .type = QEMU_OPT_STRING,
1011 },{
1012 .name = "property",
1013 .type = QEMU_OPT_STRING,
1014 },{
1015 .name = "value",
1016 .type = QEMU_OPT_STRING,
1017 },
1018 { }
1019 },
1020};
1021
1022int qemu_global_option(const char *str)
1023{
1024 char driver[64], property[64];
1025 QemuOpts *opts;
1026 int rc, offset;
1027
1028 rc = sscanf(str, "%63[^.=].%63[^=]%n", driver, property, &offset);
1029 if (rc == 2 && str[offset] == '=') {
1030 opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort);
1031 qemu_opt_set(opts, "driver", driver, &error_abort);
1032 qemu_opt_set(opts, "property", property, &error_abort);
1033 qemu_opt_set(opts, "value", str + offset + 1, &error_abort);
1034 return 0;
1035 }
1036
1037 opts = qemu_opts_parse_noisily(&qemu_global_opts, str, false);
1038 if (!opts) {
1039 return -1;
1040 }
1041 if (!qemu_opt_get(opts, "driver")
1042 || !qemu_opt_get(opts, "property")
1043 || !qemu_opt_get(opts, "value")) {
1044 error_report("options 'driver', 'property', and 'value'"
1045 " are required");
1046 return -1;
1047 }
1048
1049 return 0;
1050}
1051
1052bool qmp_command_available(const QmpCommand *cmd, Error **errp)
1053{
1054 if (!phase_check(PHASE_MACHINE_READY) &&
1055 !(cmd->options & QCO_ALLOW_PRECONFIG)) {
1056 error_setg(errp, "The command '%s' is permitted only after machine initialization has completed",
1057 cmd->name);
1058 return false;
1059 }
1060 return true;
1061}
1062