2 * Dynamic device configuration and creation.
4 * Copyright (c) 2009 CodeSourcery
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.
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.
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/>.
21 #include "hw/sysbus.h"
22 #include "monitor/monitor.h"
23 #include "monitor/qdev.h"
24 #include "qmp-commands.h"
25 #include "sysemu/arch_init.h"
26 #include "qemu/config-file.h"
29 * Aliases were a bad idea from the start. Let's keep them
30 * from spreading further.
32 typedef struct QDevAlias
39 static const QDevAlias qdev_alias_table
[] = {
40 { "virtio-blk-pci", "virtio-blk", QEMU_ARCH_ALL
& ~QEMU_ARCH_S390X
},
41 { "virtio-net-pci", "virtio-net", QEMU_ARCH_ALL
& ~QEMU_ARCH_S390X
},
42 { "virtio-serial-pci", "virtio-serial", QEMU_ARCH_ALL
& ~QEMU_ARCH_S390X
},
43 { "virtio-balloon-pci", "virtio-balloon",
44 QEMU_ARCH_ALL
& ~QEMU_ARCH_S390X
},
45 { "virtio-blk-s390", "virtio-blk", QEMU_ARCH_S390X
},
46 { "virtio-net-s390", "virtio-net", QEMU_ARCH_S390X
},
47 { "virtio-serial-s390", "virtio-serial", QEMU_ARCH_S390X
},
48 { "lsi53c895a", "lsi" },
49 { "ich9-ahci", "ahci" },
50 { "kvm-pci-assign", "pci-assign" },
54 static const char *qdev_class_get_alias(DeviceClass
*dc
)
56 const char *typename
= object_class_get_name(OBJECT_CLASS(dc
));
59 for (i
= 0; qdev_alias_table
[i
].typename
; i
++) {
60 if (qdev_alias_table
[i
].arch_mask
&&
61 !(qdev_alias_table
[i
].arch_mask
& arch_type
)) {
65 if (strcmp(qdev_alias_table
[i
].typename
, typename
) == 0) {
66 return qdev_alias_table
[i
].alias
;
73 static bool qdev_class_has_alias(DeviceClass
*dc
)
75 return (qdev_class_get_alias(dc
) != NULL
);
78 static void qdev_print_devinfo(DeviceClass
*dc
)
80 error_printf("name \"%s\"", object_class_get_name(OBJECT_CLASS(dc
)));
82 error_printf(", bus %s", dc
->bus_type
);
84 if (qdev_class_has_alias(dc
)) {
85 error_printf(", alias \"%s\"", qdev_class_get_alias(dc
));
88 error_printf(", desc \"%s\"", dc
->desc
);
90 if (dc
->cannot_instantiate_with_device_add_yet
) {
91 error_printf(", no-user");
96 static gint
devinfo_cmp(gconstpointer a
, gconstpointer b
)
98 return strcasecmp(object_class_get_name((ObjectClass
*)a
),
99 object_class_get_name((ObjectClass
*)b
));
102 static void qdev_print_devinfos(bool show_no_user
)
104 static const char *cat_name
[DEVICE_CATEGORY_MAX
+ 1] = {
105 [DEVICE_CATEGORY_BRIDGE
] = "Controller/Bridge/Hub",
106 [DEVICE_CATEGORY_USB
] = "USB",
107 [DEVICE_CATEGORY_STORAGE
] = "Storage",
108 [DEVICE_CATEGORY_NETWORK
] = "Network",
109 [DEVICE_CATEGORY_INPUT
] = "Input",
110 [DEVICE_CATEGORY_DISPLAY
] = "Display",
111 [DEVICE_CATEGORY_SOUND
] = "Sound",
112 [DEVICE_CATEGORY_MISC
] = "Misc",
113 [DEVICE_CATEGORY_MAX
] = "Uncategorized",
119 list
= g_slist_sort(object_class_get_list(TYPE_DEVICE
, false),
122 for (i
= 0; i
<= DEVICE_CATEGORY_MAX
; i
++) {
124 for (elt
= list
; elt
; elt
= elt
->next
) {
125 DeviceClass
*dc
= OBJECT_CLASS_CHECK(DeviceClass
, elt
->data
,
127 if ((i
< DEVICE_CATEGORY_MAX
128 ? !test_bit(i
, dc
->categories
)
129 : !bitmap_empty(dc
->categories
, DEVICE_CATEGORY_MAX
))
131 && dc
->cannot_instantiate_with_device_add_yet
)) {
135 error_printf("%s%s devices:\n", i
? "\n" : "",
139 qdev_print_devinfo(dc
);
146 static int set_property(const char *name
, const char *value
, void *opaque
)
148 Object
*obj
= opaque
;
151 if (strcmp(name
, "driver") == 0)
153 if (strcmp(name
, "bus") == 0)
156 object_property_parse(obj
, value
, name
, &err
);
158 qerror_report_err(err
);
165 static const char *find_typename_by_alias(const char *alias
)
169 for (i
= 0; qdev_alias_table
[i
].alias
; i
++) {
170 if (qdev_alias_table
[i
].arch_mask
&&
171 !(qdev_alias_table
[i
].arch_mask
& arch_type
)) {
175 if (strcmp(qdev_alias_table
[i
].alias
, alias
) == 0) {
176 return qdev_alias_table
[i
].typename
;
183 static DeviceClass
*qdev_get_device_class(const char **driver
, Error
**errp
)
188 oc
= object_class_by_name(*driver
);
190 const char *typename
= find_typename_by_alias(*driver
);
194 oc
= object_class_by_name(*driver
);
198 if (!object_class_dynamic_cast(oc
, TYPE_DEVICE
)) {
199 error_setg(errp
, "'%s' is not a valid device model name", *driver
);
203 if (object_class_is_abstract(oc
)) {
204 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "driver",
205 "non-abstract device type");
209 dc
= DEVICE_CLASS(oc
);
210 if (dc
->cannot_instantiate_with_device_add_yet
||
211 (qdev_hotplug
&& !dc
->hotpluggable
)) {
212 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
, "driver",
213 "pluggable device type");
221 int qdev_device_help(QemuOpts
*opts
)
223 Error
*local_err
= NULL
;
225 DevicePropertyInfoList
*prop_list
;
226 DevicePropertyInfoList
*prop
;
228 driver
= qemu_opt_get(opts
, "driver");
229 if (driver
&& is_help_option(driver
)) {
230 qdev_print_devinfos(false);
234 if (!driver
|| !qemu_opt_has_help_opt(opts
)) {
238 if (!object_class_by_name(driver
)) {
239 const char *typename
= find_typename_by_alias(driver
);
246 prop_list
= qmp_device_list_properties(driver
, &local_err
);
251 for (prop
= prop_list
; prop
; prop
= prop
->next
) {
252 error_printf("%s.%s=%s", driver
,
255 if (prop
->value
->has_description
) {
256 error_printf(" (%s)\n", prop
->value
->description
);
262 qapi_free_DevicePropertyInfoList(prop_list
);
266 error_printf("%s\n", error_get_pretty(local_err
));
267 error_free(local_err
);
271 static Object
*qdev_get_peripheral(void)
276 dev
= container_get(qdev_get_machine(), "/peripheral");
282 static Object
*qdev_get_peripheral_anon(void)
287 dev
= container_get(qdev_get_machine(), "/peripheral-anon");
293 static void qbus_list_bus(DeviceState
*dev
)
296 const char *sep
= " ";
298 error_printf("child busses at \"%s\":",
299 dev
->id
? dev
->id
: object_get_typename(OBJECT(dev
)));
300 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
301 error_printf("%s\"%s\"", sep
, child
->name
);
307 static void qbus_list_dev(BusState
*bus
)
310 const char *sep
= " ";
312 error_printf("devices at \"%s\":", bus
->name
);
313 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
314 DeviceState
*dev
= kid
->child
;
315 error_printf("%s\"%s\"", sep
, object_get_typename(OBJECT(dev
)));
317 error_printf("/\"%s\"", dev
->id
);
323 static BusState
*qbus_find_bus(DeviceState
*dev
, char *elem
)
327 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
328 if (strcmp(child
->name
, elem
) == 0) {
335 static DeviceState
*qbus_find_dev(BusState
*bus
, char *elem
)
340 * try to match in order:
341 * (1) instance id, if present
343 * (3) driver alias, if present
345 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
346 DeviceState
*dev
= kid
->child
;
347 if (dev
->id
&& strcmp(dev
->id
, elem
) == 0) {
351 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
352 DeviceState
*dev
= kid
->child
;
353 if (strcmp(object_get_typename(OBJECT(dev
)), elem
) == 0) {
357 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
358 DeviceState
*dev
= kid
->child
;
359 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
361 if (qdev_class_has_alias(dc
) &&
362 strcmp(qdev_class_get_alias(dc
), elem
) == 0) {
369 static BusState
*qbus_find_recursive(BusState
*bus
, const char *name
,
370 const char *bus_typename
)
372 BusClass
*bus_class
= BUS_GET_CLASS(bus
);
374 BusState
*child
, *ret
;
377 if (name
&& (strcmp(bus
->name
, name
) != 0)) {
379 } else if (bus_typename
&& !object_dynamic_cast(OBJECT(bus
), bus_typename
)) {
381 } else if ((bus_class
->max_dev
!= 0) && (bus_class
->max_dev
<= bus
->max_index
)) {
383 /* bus was explicitly specified: return an error. */
384 qerror_report(ERROR_CLASS_GENERIC_ERROR
, "Bus '%s' is full",
388 /* bus was not specified: try to find another one. */
396 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
397 DeviceState
*dev
= kid
->child
;
398 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
399 ret
= qbus_find_recursive(child
, name
, bus_typename
);
408 static BusState
*qbus_find(const char *path
)
415 /* find start element */
416 if (path
[0] == '/') {
417 bus
= sysbus_get_default();
420 if (sscanf(path
, "%127[^/]%n", elem
, &len
) != 1) {
424 bus
= qbus_find_recursive(sysbus_get_default(), elem
, NULL
);
426 qerror_report(QERR_BUS_NOT_FOUND
, elem
);
433 assert(path
[pos
] == '/' || !path
[pos
]);
434 while (path
[pos
] == '/') {
437 if (path
[pos
] == '\0') {
442 if (sscanf(path
+pos
, "%127[^/]%n", elem
, &len
) != 1) {
443 g_assert_not_reached();
447 dev
= qbus_find_dev(bus
, elem
);
449 qerror_report(QERR_DEVICE_NOT_FOUND
, elem
);
450 if (!monitor_cur_is_qmp()) {
456 assert(path
[pos
] == '/' || !path
[pos
]);
457 while (path
[pos
] == '/') {
460 if (path
[pos
] == '\0') {
461 /* last specified element is a device. If it has exactly
462 * one child bus accept it nevertheless */
463 switch (dev
->num_child_bus
) {
465 qerror_report(ERROR_CLASS_GENERIC_ERROR
,
466 "Device '%s' has no child bus", elem
);
469 return QLIST_FIRST(&dev
->child_bus
);
471 qerror_report(ERROR_CLASS_GENERIC_ERROR
,
472 "Device '%s' has multiple child busses", elem
);
473 if (!monitor_cur_is_qmp()) {
481 if (sscanf(path
+pos
, "%127[^/]%n", elem
, &len
) != 1) {
482 g_assert_not_reached();
486 bus
= qbus_find_bus(dev
, elem
);
488 qerror_report(QERR_BUS_NOT_FOUND
, elem
);
489 if (!monitor_cur_is_qmp()) {
497 DeviceState
*qdev_device_add(QemuOpts
*opts
)
500 const char *driver
, *path
, *id
;
502 BusState
*bus
= NULL
;
505 driver
= qemu_opt_get(opts
, "driver");
507 qerror_report(QERR_MISSING_PARAMETER
, "driver");
512 dc
= qdev_get_device_class(&driver
, &err
);
514 qerror_report_err(err
);
520 path
= qemu_opt_get(opts
, "bus");
522 bus
= qbus_find(path
);
526 if (!object_dynamic_cast(OBJECT(bus
), dc
->bus_type
)) {
527 qerror_report(ERROR_CLASS_GENERIC_ERROR
,
528 "Device '%s' can't go on a %s bus",
529 driver
, object_get_typename(OBJECT(bus
)));
532 } else if (dc
->bus_type
!= NULL
) {
533 bus
= qbus_find_recursive(sysbus_get_default(), NULL
, dc
->bus_type
);
535 qerror_report(ERROR_CLASS_GENERIC_ERROR
,
536 "No '%s' bus found for device '%s'",
537 dc
->bus_type
, driver
);
541 if (qdev_hotplug
&& bus
&& !qbus_is_hotpluggable(bus
)) {
542 qerror_report(QERR_BUS_NO_HOTPLUG
, bus
->name
);
547 dev
= DEVICE(object_new(driver
));
550 qdev_set_parent_bus(dev
, bus
);
553 id
= qemu_opts_id(opts
);
559 object_property_add_child(qdev_get_peripheral(), dev
->id
,
562 static int anon_count
;
563 gchar
*name
= g_strdup_printf("device[%d]", anon_count
++);
564 object_property_add_child(qdev_get_peripheral_anon(), name
,
570 if (qemu_opt_foreach(opts
, set_property
, dev
, 1) != 0) {
571 object_unparent(OBJECT(dev
));
572 object_unref(OBJECT(dev
));
577 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
579 qerror_report_err(err
);
582 object_unparent(OBJECT(dev
));
583 object_unref(OBJECT(dev
));
584 qerror_report(QERR_DEVICE_INIT_FAILED
, driver
);
591 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
592 static void qbus_print(Monitor
*mon
, BusState
*bus
, int indent
);
594 static void qdev_print_props(Monitor
*mon
, DeviceState
*dev
, Property
*props
,
599 for (; props
->name
; props
++) {
602 char *legacy_name
= g_strdup_printf("legacy-%s", props
->name
);
603 if (object_property_get_type(OBJECT(dev
), legacy_name
, NULL
)) {
604 value
= object_property_get_str(OBJECT(dev
), legacy_name
, &err
);
606 value
= object_property_print(OBJECT(dev
), props
->name
, true, &err
);
614 qdev_printf("%s = %s\n", props
->name
,
615 value
&& *value
? value
: "<null>");
620 static void bus_print_dev(BusState
*bus
, Monitor
*mon
, DeviceState
*dev
, int indent
)
622 BusClass
*bc
= BUS_GET_CLASS(bus
);
625 bc
->print_dev(mon
, dev
, indent
);
629 static void qdev_print(Monitor
*mon
, DeviceState
*dev
, int indent
)
635 qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev
)),
636 dev
->id
? dev
->id
: "");
638 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
640 qdev_printf("gpio-in \"%s\" %d\n", ngl
->name
? ngl
->name
: "",
644 qdev_printf("gpio-out \"%s\" %d\n", ngl
->name
? ngl
->name
: "",
648 class = object_get_class(OBJECT(dev
));
650 qdev_print_props(mon
, dev
, DEVICE_CLASS(class)->props
, indent
);
651 class = object_class_get_parent(class);
652 } while (class != object_class_by_name(TYPE_DEVICE
));
653 bus_print_dev(dev
->parent_bus
, mon
, dev
, indent
);
654 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
655 qbus_print(mon
, child
, indent
);
659 static void qbus_print(Monitor
*mon
, BusState
*bus
, int indent
)
663 qdev_printf("bus: %s\n", bus
->name
);
665 qdev_printf("type %s\n", object_get_typename(OBJECT(bus
)));
666 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
667 DeviceState
*dev
= kid
->child
;
668 qdev_print(mon
, dev
, indent
);
673 void do_info_qtree(Monitor
*mon
, const QDict
*qdict
)
675 if (sysbus_get_default())
676 qbus_print(mon
, sysbus_get_default(), 0);
679 void do_info_qdm(Monitor
*mon
, const QDict
*qdict
)
681 qdev_print_devinfos(true);
684 int do_device_add(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
686 Error
*local_err
= NULL
;
690 opts
= qemu_opts_from_qdict(qemu_find_opts("device"), qdict
, &local_err
);
692 qerror_report_err(local_err
);
693 error_free(local_err
);
696 if (!monitor_cur_is_qmp() && qdev_device_help(opts
)) {
700 dev
= qdev_device_add(opts
);
705 object_unref(OBJECT(dev
));
709 void qmp_device_del(const char *id
, Error
**errp
)
712 char *root_path
= object_get_canonical_path(qdev_get_peripheral());
713 char *path
= g_strdup_printf("%s/%s", root_path
, id
);
716 obj
= object_resolve_path_type(path
, TYPE_DEVICE
, NULL
);
720 error_set(errp
, QERR_DEVICE_NOT_FOUND
, id
);
724 qdev_unplug(DEVICE(obj
), errp
);
727 void qdev_machine_init(void)
729 qdev_get_peripheral_anon();
730 qdev_get_peripheral();
733 QemuOptsList qemu_device_opts
= {
735 .implied_opt_name
= "driver",
736 .head
= QTAILQ_HEAD_INITIALIZER(qemu_device_opts
.head
),
739 * no elements => accept any
740 * sanity checking will happen later
741 * when setting device properties
743 { /* end of list */ }
747 QemuOptsList qemu_global_opts
= {
749 .head
= QTAILQ_HEAD_INITIALIZER(qemu_global_opts
.head
),
753 .type
= QEMU_OPT_STRING
,
756 .type
= QEMU_OPT_STRING
,
759 .type
= QEMU_OPT_STRING
,
761 { /* end of list */ }
765 int qemu_global_option(const char *str
)
767 char driver
[64], property
[64];
771 rc
= sscanf(str
, "%63[^.].%63[^=]%n", driver
, property
, &offset
);
772 if (rc
< 2 || str
[offset
] != '=') {
773 error_report("can't parse: \"%s\"", str
);
777 opts
= qemu_opts_create(&qemu_global_opts
, NULL
, 0, &error_abort
);
778 qemu_opt_set(opts
, "driver", driver
);
779 qemu_opt_set(opts
, "property", property
);
780 qemu_opt_set(opts
, "value", str
+offset
+1);