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/>.
20 /* The theory here is that it should be possible to create a machine without
21 knowledge of specific devices. Historically board init routines have
22 passed a bunch of arguments to each device, requiring the board know
23 exactly which device it is dealing with. This file provides an abstract
24 API for device configuration and initialization. Devices will generally
25 inherit from a particular bus (e.g. PCI or I2C) rather than
33 static int qdev_hotplug
= 0;
34 static bool qdev_hot_added
= false;
35 static bool qdev_hot_removed
= false;
37 /* This is a nasty hack to allow passing a NULL bus to qdev_create. */
38 static BusState
*main_system_bus
;
39 static void main_system_bus_create(void);
41 static BusState
*qbus_find_recursive(BusState
*bus
, const char *name
,
43 static BusState
*qbus_find(const char *path
);
45 /* Register a new device type. */
46 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
48 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
52 BusInfo
*qdev_get_bus_info(DeviceState
*dev
)
54 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
58 Property
*qdev_get_props(DeviceState
*dev
)
60 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
65 * Aliases were a bad idea from the start. Let's keep them
66 * from spreading further.
68 typedef struct QDevAlias
74 static const QDevAlias qdev_alias_table
[] = {
75 { "virtio-blk-pci", "virtio-blk" },
76 { "virtio-net-pci", "virtio-net" },
77 { "virtio-serial-pci", "virtio-serial" },
78 { "virtio-balloon-pci", "virtio-balloon" },
79 { "virtio-blk-s390", "virtio-blk" },
80 { "virtio-net-s390", "virtio-net" },
81 { "virtio-serial-s390", "virtio-serial" },
82 { "lsi53c895a", "lsi" },
83 { "ich9-ahci", "ahci" },
87 static const char *qdev_class_get_alias(DeviceClass
*dc
)
89 const char *typename
= object_class_get_name(OBJECT_CLASS(dc
));
92 for (i
= 0; qdev_alias_table
[i
].typename
; i
++) {
93 if (strcmp(qdev_alias_table
[i
].typename
, typename
) == 0) {
94 return qdev_alias_table
[i
].alias
;
101 static bool qdev_class_has_alias(DeviceClass
*dc
)
103 return (qdev_class_get_alias(dc
) != NULL
);
106 const char *qdev_fw_name(DeviceState
*dev
)
108 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
112 } else if (qdev_class_has_alias(dc
)) {
113 return qdev_class_get_alias(dc
);
116 return object_get_typename(OBJECT(dev
));
119 bool qdev_exists(const char *name
)
121 return !!object_class_by_name(name
);
124 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
127 static DeviceState
*qdev_create_from_info(BusState
*bus
, const char *typename
)
132 dev
= DEVICE(object_new(typename
));
134 dev
->parent_bus
= bus
;
135 qdev_prop_set_defaults(dev
, dev
->parent_bus
->info
->props
);
138 assert(bus
->allow_hotplug
);
141 QTAILQ_INSERT_HEAD(&bus
->children
, dev
, sibling
);
143 for (prop
= qdev_get_bus_info(dev
)->props
; prop
&& prop
->name
; prop
++) {
144 qdev_property_add_legacy(dev
, prop
, NULL
);
145 qdev_property_add_static(dev
, prop
, NULL
);
148 qdev_prop_set_globals(dev
);
153 /* Create a new device. This only initializes the device state structure
154 and allows properties to be set. qdev_init should be called to
155 initialize the actual device emulation. */
156 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
160 dev
= qdev_try_create(bus
, name
);
163 hw_error("Unknown device '%s' for bus '%s'\n", name
,
166 hw_error("Unknown device '%s' for default sysbus\n", name
);
173 DeviceState
*qdev_try_create(BusState
*bus
, const char *name
)
176 bus
= sysbus_get_default();
179 return qdev_create_from_info(bus
, name
);
182 static void qdev_print_devinfo(ObjectClass
*klass
, void *opaque
)
185 bool *show_no_user
= opaque
;
187 dc
= (DeviceClass
*)object_class_dynamic_cast(klass
, TYPE_DEVICE
);
189 if (!dc
|| (show_no_user
&& !*show_no_user
&& dc
->no_user
)) {
193 error_printf("name \"%s\"", object_class_get_name(klass
));
195 error_printf(", bus %s", dc
->bus_info
->name
);
197 if (qdev_class_has_alias(dc
)) {
198 error_printf(", alias \"%s\"", qdev_class_get_alias(dc
));
201 error_printf(", desc \"%s\"", dc
->desc
);
204 error_printf(", no-user");
209 static int set_property(const char *name
, const char *value
, void *opaque
)
211 DeviceState
*dev
= opaque
;
213 if (strcmp(name
, "driver") == 0)
215 if (strcmp(name
, "bus") == 0)
218 if (qdev_prop_parse(dev
, name
, value
) == -1) {
224 static const char *find_typename_by_alias(const char *alias
)
228 for (i
= 0; qdev_alias_table
[i
].alias
; i
++) {
229 if (strcmp(qdev_alias_table
[i
].alias
, alias
) == 0) {
230 return qdev_alias_table
[i
].typename
;
237 int qdev_device_help(QemuOpts
*opts
)
244 driver
= qemu_opt_get(opts
, "driver");
245 if (driver
&& !strcmp(driver
, "?")) {
246 bool show_no_user
= false;
247 object_class_foreach(qdev_print_devinfo
, TYPE_DEVICE
, false, &show_no_user
);
251 if (!driver
|| !qemu_opt_get(opts
, "?")) {
255 klass
= object_class_by_name(driver
);
257 const char *typename
= find_typename_by_alias(driver
);
261 klass
= object_class_by_name(driver
);
268 info
= DEVICE_CLASS(klass
);
270 for (prop
= info
->props
; prop
&& prop
->name
; prop
++) {
272 * TODO Properties without a parser are just for dirty hacks.
273 * qdev_prop_ptr is the only such PropertyInfo. It's marked
274 * for removal. This conditional should be removed along with
277 if (!prop
->info
->parse
) {
278 continue; /* no way to set it, don't show */
280 error_printf("%s.%s=%s\n", driver
, prop
->name
,
281 prop
->info
->legacy_name
?: prop
->info
->name
);
283 for (prop
= info
->bus_info
->props
; prop
&& prop
->name
; prop
++) {
284 if (!prop
->info
->parse
) {
285 continue; /* no way to set it, don't show */
287 error_printf("%s.%s=%s\n", driver
, prop
->name
,
288 prop
->info
->legacy_name
?: prop
->info
->name
);
293 static DeviceState
*qdev_get_peripheral(void)
295 static DeviceState
*dev
;
298 dev
= qdev_create(NULL
, "container");
299 qdev_property_add_child(qdev_get_root(), "peripheral", dev
, NULL
);
300 qdev_init_nofail(dev
);
306 static DeviceState
*qdev_get_peripheral_anon(void)
308 static DeviceState
*dev
;
311 dev
= qdev_create(NULL
, "container");
312 qdev_property_add_child(qdev_get_root(), "peripheral-anon", dev
, NULL
);
313 qdev_init_nofail(dev
);
319 DeviceState
*qdev_device_add(QemuOpts
*opts
)
323 const char *driver
, *path
, *id
;
327 driver
= qemu_opt_get(opts
, "driver");
329 qerror_report(QERR_MISSING_PARAMETER
, "driver");
334 obj
= object_class_by_name(driver
);
336 const char *typename
= find_typename_by_alias(driver
);
340 obj
= object_class_by_name(driver
);
345 qerror_report(QERR_INVALID_PARAMETER_VALUE
, "driver", "device type");
349 k
= DEVICE_CLASS(obj
);
352 path
= qemu_opt_get(opts
, "bus");
354 bus
= qbus_find(path
);
358 if (bus
->info
!= k
->bus_info
) {
359 qerror_report(QERR_BAD_BUS_FOR_DEVICE
,
360 driver
, bus
->info
->name
);
364 bus
= qbus_find_recursive(main_system_bus
, NULL
, k
->bus_info
);
366 qerror_report(QERR_NO_BUS_FOR_DEVICE
,
367 driver
, k
->bus_info
->name
);
371 if (qdev_hotplug
&& !bus
->allow_hotplug
) {
372 qerror_report(QERR_BUS_NO_HOTPLUG
, bus
->name
);
376 /* create device, set properties */
377 qdev
= qdev_create_from_info(bus
, driver
);
378 id
= qemu_opts_id(opts
);
381 qdev_property_add_child(qdev_get_peripheral(), qdev
->id
, qdev
, NULL
);
383 static int anon_count
;
384 gchar
*name
= g_strdup_printf("device[%d]", anon_count
++);
385 qdev_property_add_child(qdev_get_peripheral_anon(), name
,
389 if (qemu_opt_foreach(opts
, set_property
, qdev
, 1) != 0) {
393 if (qdev_init(qdev
) < 0) {
394 qerror_report(QERR_DEVICE_INIT_FAILED
, driver
);
401 /* Initialize a device. Device properties should be set before calling
402 this function. IRQs and MMIO regions should be connected/mapped after
403 calling this function.
404 On failure, destroy the device and return negative value.
405 Return 0 on success. */
406 int qdev_init(DeviceState
*dev
)
408 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
411 assert(dev
->state
== DEV_STATE_CREATED
);
418 if (qdev_get_vmsd(dev
)) {
419 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
420 dev
->instance_id_alias
,
421 dev
->alias_required_for_version
);
423 dev
->state
= DEV_STATE_INITIALIZED
;
424 if (dev
->hotplugged
) {
430 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
431 int required_for_version
)
433 assert(dev
->state
== DEV_STATE_CREATED
);
434 dev
->instance_id_alias
= alias_id
;
435 dev
->alias_required_for_version
= required_for_version
;
438 int qdev_unplug(DeviceState
*dev
)
440 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
442 if (!dev
->parent_bus
->allow_hotplug
) {
443 qerror_report(QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
446 assert(dc
->unplug
!= NULL
);
448 qdev_hot_removed
= true;
450 return dc
->unplug(dev
);
453 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
460 BusState
*sysbus_get_default(void)
462 if (!main_system_bus
) {
463 main_system_bus_create();
465 return main_system_bus
;
468 static int qbus_reset_one(BusState
*bus
, void *opaque
)
470 if (bus
->info
->reset
) {
471 return bus
->info
->reset(bus
);
476 void qdev_reset_all(DeviceState
*dev
)
478 qdev_walk_children(dev
, qdev_reset_one
, qbus_reset_one
, NULL
);
481 void qbus_reset_all_fn(void *opaque
)
483 BusState
*bus
= opaque
;
484 qbus_walk_children(bus
, qdev_reset_one
, qbus_reset_one
, NULL
);
487 /* can be used as ->unplug() callback for the simple cases */
488 int qdev_simple_unplug_cb(DeviceState
*dev
)
496 /* Like qdev_init(), but terminate program via error_report() instead of
497 returning an error value. This is okay during machine creation.
498 Don't use for hotplug, because there callers need to recover from
499 failure. Exception: if you know the device's init() callback can't
500 fail, then qdev_init_nofail() can't fail either, and is therefore
501 usable even then. But relying on the device implementation that
502 way is somewhat unclean, and best avoided. */
503 void qdev_init_nofail(DeviceState
*dev
)
505 if (qdev_init(dev
) < 0) {
506 error_report("Initialization of device %s failed",
507 object_get_typename(OBJECT(dev
)));
512 static void qdev_property_del_all(DeviceState
*dev
)
514 while (!QTAILQ_EMPTY(&dev
->properties
)) {
515 DeviceProperty
*prop
= QTAILQ_FIRST(&dev
->properties
);
517 QTAILQ_REMOVE(&dev
->properties
, prop
, node
);
520 prop
->release(dev
, prop
->name
, prop
->opaque
);
529 static void qdev_property_del_child(DeviceState
*dev
, DeviceState
*child
, Error
**errp
)
531 DeviceProperty
*prop
;
533 QTAILQ_FOREACH(prop
, &dev
->properties
, node
) {
534 if (strstart(prop
->type
, "child<", NULL
) && prop
->opaque
== child
) {
539 g_assert(prop
!= NULL
);
541 QTAILQ_REMOVE(&dev
->properties
, prop
, node
);
544 prop
->release(dev
, prop
->name
, prop
->opaque
);
552 /* Unlink device from bus and free the structure. */
553 void qdev_free(DeviceState
*dev
)
557 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
559 qdev_property_del_all(dev
);
561 if (dev
->state
== DEV_STATE_INITIALIZED
) {
562 while (dev
->num_child_bus
) {
563 bus
= QLIST_FIRST(&dev
->child_bus
);
566 if (qdev_get_vmsd(dev
)) {
567 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
573 qemu_opts_del(dev
->opts
);
576 QTAILQ_REMOVE(&dev
->parent_bus
->children
, dev
, sibling
);
577 for (prop
= qdev_get_props(dev
); prop
&& prop
->name
; prop
++) {
578 if (prop
->info
->free
) {
579 prop
->info
->free(dev
, prop
);
583 qdev_property_del_child(dev
->parent
, dev
, NULL
);
586 qerror_report(QERR_DEVICE_IN_USE
, dev
->id
?:"");
588 object_delete(OBJECT(dev
));
591 void qdev_machine_creation_done(void)
594 * ok, initial machine setup is done, starting from now we can
595 * only create hotpluggable devices
600 bool qdev_machine_modified(void)
602 return qdev_hot_added
|| qdev_hot_removed
;
605 /* Get a character (serial) device interface. */
606 CharDriverState
*qdev_init_chardev(DeviceState
*dev
)
608 static int next_serial
;
610 /* FIXME: This function needs to go away: use chardev properties! */
611 return serial_hds
[next_serial
++];
614 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
616 return dev
->parent_bus
;
619 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
621 assert(dev
->num_gpio_in
== 0);
622 dev
->num_gpio_in
= n
;
623 dev
->gpio_in
= qemu_allocate_irqs(handler
, dev
, n
);
626 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
628 assert(dev
->num_gpio_out
== 0);
629 dev
->num_gpio_out
= n
;
630 dev
->gpio_out
= pins
;
633 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
635 assert(n
>= 0 && n
< dev
->num_gpio_in
);
636 return dev
->gpio_in
[n
];
639 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
641 assert(n
>= 0 && n
< dev
->num_gpio_out
);
642 dev
->gpio_out
[n
] = pin
;
645 void qdev_set_nic_properties(DeviceState
*dev
, NICInfo
*nd
)
647 qdev_prop_set_macaddr(dev
, "mac", nd
->macaddr
.a
);
649 qdev_prop_set_vlan(dev
, "vlan", nd
->vlan
);
651 qdev_prop_set_netdev(dev
, "netdev", nd
->netdev
);
652 if (nd
->nvectors
!= DEV_NVECTORS_UNSPECIFIED
&&
653 qdev_prop_exists(dev
, "vectors")) {
654 qdev_prop_set_uint32(dev
, "vectors", nd
->nvectors
);
656 nd
->instantiated
= 1;
659 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
663 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
664 if (strcmp(name
, bus
->name
) == 0) {
671 int qbus_walk_children(BusState
*bus
, qdev_walkerfn
*devfn
,
672 qbus_walkerfn
*busfn
, void *opaque
)
678 err
= busfn(bus
, opaque
);
684 QTAILQ_FOREACH(dev
, &bus
->children
, sibling
) {
685 err
= qdev_walk_children(dev
, devfn
, busfn
, opaque
);
694 int qdev_walk_children(DeviceState
*dev
, qdev_walkerfn
*devfn
,
695 qbus_walkerfn
*busfn
, void *opaque
)
701 err
= devfn(dev
, opaque
);
707 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
708 err
= qbus_walk_children(bus
, devfn
, busfn
, opaque
);
717 static BusState
*qbus_find_recursive(BusState
*bus
, const char *name
,
721 BusState
*child
, *ret
;
724 if (name
&& (strcmp(bus
->name
, name
) != 0)) {
727 if (info
&& (bus
->info
!= info
)) {
734 QTAILQ_FOREACH(dev
, &bus
->children
, sibling
) {
735 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
736 ret
= qbus_find_recursive(child
, name
, info
);
745 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
747 DeviceState
*dev
, *ret
;
750 QTAILQ_FOREACH(dev
, &bus
->children
, sibling
) {
751 if (dev
->id
&& strcmp(dev
->id
, id
) == 0)
753 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
754 ret
= qdev_find_recursive(child
, id
);
763 static void qbus_list_bus(DeviceState
*dev
)
766 const char *sep
= " ";
768 error_printf("child busses at \"%s\":",
769 dev
->id
? dev
->id
: object_get_typename(OBJECT(dev
)));
770 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
771 error_printf("%s\"%s\"", sep
, child
->name
);
777 static void qbus_list_dev(BusState
*bus
)
780 const char *sep
= " ";
782 error_printf("devices at \"%s\":", bus
->name
);
783 QTAILQ_FOREACH(dev
, &bus
->children
, sibling
) {
784 error_printf("%s\"%s\"", sep
, object_get_typename(OBJECT(dev
)));
786 error_printf("/\"%s\"", dev
->id
);
792 static BusState
*qbus_find_bus(DeviceState
*dev
, char *elem
)
796 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
797 if (strcmp(child
->name
, elem
) == 0) {
804 static DeviceState
*qbus_find_dev(BusState
*bus
, char *elem
)
809 * try to match in order:
810 * (1) instance id, if present
812 * (3) driver alias, if present
814 QTAILQ_FOREACH(dev
, &bus
->children
, sibling
) {
815 if (dev
->id
&& strcmp(dev
->id
, elem
) == 0) {
819 QTAILQ_FOREACH(dev
, &bus
->children
, sibling
) {
820 if (strcmp(object_get_typename(OBJECT(dev
)), elem
) == 0) {
824 QTAILQ_FOREACH(dev
, &bus
->children
, sibling
) {
825 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
827 if (qdev_class_has_alias(dc
) &&
828 strcmp(qdev_class_get_alias(dc
), elem
) == 0) {
835 static BusState
*qbus_find(const char *path
)
842 /* find start element */
843 if (path
[0] == '/') {
844 bus
= main_system_bus
;
847 if (sscanf(path
, "%127[^/]%n", elem
, &len
) != 1) {
851 bus
= qbus_find_recursive(main_system_bus
, elem
, NULL
);
853 qerror_report(QERR_BUS_NOT_FOUND
, elem
);
860 assert(path
[pos
] == '/' || !path
[pos
]);
861 while (path
[pos
] == '/') {
864 if (path
[pos
] == '\0') {
869 if (sscanf(path
+pos
, "%127[^/]%n", elem
, &len
) != 1) {
874 dev
= qbus_find_dev(bus
, elem
);
876 qerror_report(QERR_DEVICE_NOT_FOUND
, elem
);
877 if (!monitor_cur_is_qmp()) {
883 assert(path
[pos
] == '/' || !path
[pos
]);
884 while (path
[pos
] == '/') {
887 if (path
[pos
] == '\0') {
888 /* last specified element is a device. If it has exactly
889 * one child bus accept it nevertheless */
890 switch (dev
->num_child_bus
) {
892 qerror_report(QERR_DEVICE_NO_BUS
, elem
);
895 return QLIST_FIRST(&dev
->child_bus
);
897 qerror_report(QERR_DEVICE_MULTIPLE_BUSSES
, elem
);
898 if (!monitor_cur_is_qmp()) {
906 if (sscanf(path
+pos
, "%127[^/]%n", elem
, &len
) != 1) {
911 bus
= qbus_find_bus(dev
, elem
);
913 qerror_report(QERR_BUS_NOT_FOUND
, elem
);
914 if (!monitor_cur_is_qmp()) {
922 void qbus_create_inplace(BusState
*bus
, BusInfo
*info
,
923 DeviceState
*parent
, const char *name
)
929 bus
->parent
= parent
;
932 /* use supplied name */
933 bus
->name
= g_strdup(name
);
934 } else if (parent
&& parent
->id
) {
935 /* parent device has id -> use it for bus name */
936 len
= strlen(parent
->id
) + 16;
938 snprintf(buf
, len
, "%s.%d", parent
->id
, parent
->num_child_bus
);
941 /* no id -> use lowercase bus type for bus name */
942 len
= strlen(info
->name
) + 16;
944 len
= snprintf(buf
, len
, "%s.%d", info
->name
,
945 parent
? parent
->num_child_bus
: 0);
946 for (i
= 0; i
< len
; i
++)
947 buf
[i
] = qemu_tolower(buf
[i
]);
951 QTAILQ_INIT(&bus
->children
);
953 QLIST_INSERT_HEAD(&parent
->child_bus
, bus
, sibling
);
954 parent
->num_child_bus
++;
955 } else if (bus
!= main_system_bus
) {
956 /* TODO: once all bus devices are qdevified,
957 only reset handler for main_system_bus should be registered here. */
958 qemu_register_reset(qbus_reset_all_fn
, bus
);
962 BusState
*qbus_create(BusInfo
*info
, DeviceState
*parent
, const char *name
)
966 bus
= g_malloc0(info
->size
);
967 bus
->qdev_allocated
= 1;
968 qbus_create_inplace(bus
, info
, parent
, name
);
972 static void main_system_bus_create(void)
974 /* assign main_system_bus before qbus_create_inplace()
975 * in order to make "if (bus != main_system_bus)" work */
976 main_system_bus
= g_malloc0(system_bus_info
.size
);
977 main_system_bus
->qdev_allocated
= 1;
978 qbus_create_inplace(main_system_bus
, &system_bus_info
, NULL
,
982 void qbus_free(BusState
*bus
)
986 while ((dev
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
990 QLIST_REMOVE(bus
, sibling
);
991 bus
->parent
->num_child_bus
--;
993 assert(bus
!= main_system_bus
); /* main_system_bus is never freed */
994 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
996 g_free((void*)bus
->name
);
997 if (bus
->qdev_allocated
) {
1002 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
1003 static void qbus_print(Monitor
*mon
, BusState
*bus
, int indent
);
1005 static void qdev_print_props(Monitor
*mon
, DeviceState
*dev
, Property
*props
,
1006 const char *prefix
, int indent
)
1012 while (props
->name
) {
1014 * TODO Properties without a print method are just for dirty
1015 * hacks. qdev_prop_ptr is the only such PropertyInfo. It's
1016 * marked for removal. The test props->info->print should be
1017 * removed along with it.
1019 if (props
->info
->print
) {
1020 props
->info
->print(dev
, props
, buf
, sizeof(buf
));
1021 qdev_printf("%s-prop: %s = %s\n", prefix
, props
->name
, buf
);
1027 static void qdev_print(Monitor
*mon
, DeviceState
*dev
, int indent
)
1030 qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev
)),
1031 dev
->id
? dev
->id
: "");
1033 if (dev
->num_gpio_in
) {
1034 qdev_printf("gpio-in %d\n", dev
->num_gpio_in
);
1036 if (dev
->num_gpio_out
) {
1037 qdev_printf("gpio-out %d\n", dev
->num_gpio_out
);
1039 qdev_print_props(mon
, dev
, qdev_get_props(dev
), "dev", indent
);
1040 qdev_print_props(mon
, dev
, dev
->parent_bus
->info
->props
, "bus", indent
);
1041 if (dev
->parent_bus
->info
->print_dev
)
1042 dev
->parent_bus
->info
->print_dev(mon
, dev
, indent
);
1043 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
1044 qbus_print(mon
, child
, indent
);
1048 static void qbus_print(Monitor
*mon
, BusState
*bus
, int indent
)
1050 struct DeviceState
*dev
;
1052 qdev_printf("bus: %s\n", bus
->name
);
1054 qdev_printf("type %s\n", bus
->info
->name
);
1055 QTAILQ_FOREACH(dev
, &bus
->children
, sibling
) {
1056 qdev_print(mon
, dev
, indent
);
1061 void do_info_qtree(Monitor
*mon
)
1063 if (main_system_bus
)
1064 qbus_print(mon
, main_system_bus
, 0);
1067 void do_info_qdm(Monitor
*mon
)
1069 object_class_foreach(qdev_print_devinfo
, TYPE_DEVICE
, false, NULL
);
1072 int do_device_add(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
1076 opts
= qemu_opts_from_qdict(qemu_find_opts("device"), qdict
);
1080 if (!monitor_cur_is_qmp() && qdev_device_help(opts
)) {
1081 qemu_opts_del(opts
);
1084 if (!qdev_device_add(opts
)) {
1085 qemu_opts_del(opts
);
1091 int do_device_del(Monitor
*mon
, const QDict
*qdict
, QObject
**ret_data
)
1093 const char *id
= qdict_get_str(qdict
, "id");
1096 dev
= qdev_find_recursive(main_system_bus
, id
);
1098 qerror_report(QERR_DEVICE_NOT_FOUND
, id
);
1101 return qdev_unplug(dev
);
1104 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
1108 if (dev
&& dev
->parent_bus
) {
1110 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
1111 if (dev
->parent_bus
->info
->get_fw_dev_path
) {
1112 d
= dev
->parent_bus
->info
->get_fw_dev_path(dev
);
1113 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
1116 l
+= snprintf(p
+ l
, size
- l
, "%s", object_get_typename(OBJECT(dev
)));
1119 l
+= snprintf(p
+ l
, size
- l
, "/");
1124 char* qdev_get_fw_dev_path(DeviceState
*dev
)
1129 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
1133 return strdup(path
);
1136 char *qdev_get_type(DeviceState
*dev
, Error
**errp
)
1138 return g_strdup(object_get_typename(OBJECT(dev
)));
1141 void qdev_ref(DeviceState
*dev
)
1146 void qdev_unref(DeviceState
*dev
)
1148 g_assert(dev
->ref
> 0);
1152 void qdev_property_add(DeviceState
*dev
, const char *name
, const char *type
,
1153 DevicePropertyAccessor
*get
, DevicePropertyAccessor
*set
,
1154 DevicePropertyRelease
*release
,
1155 void *opaque
, Error
**errp
)
1157 DeviceProperty
*prop
= g_malloc0(sizeof(*prop
));
1159 prop
->name
= g_strdup(name
);
1160 prop
->type
= g_strdup(type
);
1164 prop
->release
= release
;
1165 prop
->opaque
= opaque
;
1167 QTAILQ_INSERT_TAIL(&dev
->properties
, prop
, node
);
1170 static DeviceProperty
*qdev_property_find(DeviceState
*dev
, const char *name
)
1172 DeviceProperty
*prop
;
1174 QTAILQ_FOREACH(prop
, &dev
->properties
, node
) {
1175 if (strcmp(prop
->name
, name
) == 0) {
1183 void qdev_property_get(DeviceState
*dev
, Visitor
*v
, const char *name
,
1186 DeviceProperty
*prop
= qdev_property_find(dev
, name
);
1189 error_set(errp
, QERR_PROPERTY_NOT_FOUND
, dev
->id
?:"", name
);
1194 error_set(errp
, QERR_PERMISSION_DENIED
);
1196 prop
->get(dev
, v
, prop
->opaque
, name
, errp
);
1200 void qdev_property_set(DeviceState
*dev
, Visitor
*v
, const char *name
,
1203 DeviceProperty
*prop
= qdev_property_find(dev
, name
);
1206 error_set(errp
, QERR_PROPERTY_NOT_FOUND
, dev
->id
?:"", name
);
1211 error_set(errp
, QERR_PERMISSION_DENIED
);
1213 prop
->set(dev
, v
, prop
->opaque
, name
, errp
);
1217 const char *qdev_property_get_type(DeviceState
*dev
, const char *name
, Error
**errp
)
1219 DeviceProperty
*prop
= qdev_property_find(dev
, name
);
1222 error_set(errp
, QERR_PROPERTY_NOT_FOUND
, dev
->id
?:"", name
);
1230 * Legacy property handling
1233 static void qdev_get_legacy_property(DeviceState
*dev
, Visitor
*v
, void *opaque
,
1234 const char *name
, Error
**errp
)
1236 Property
*prop
= opaque
;
1241 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
1242 visit_type_str(v
, &ptr
, name
, errp
);
1245 static void qdev_set_legacy_property(DeviceState
*dev
, Visitor
*v
, void *opaque
,
1246 const char *name
, Error
**errp
)
1248 Property
*prop
= opaque
;
1249 Error
*local_err
= NULL
;
1253 if (dev
->state
!= DEV_STATE_CREATED
) {
1254 error_set(errp
, QERR_PERMISSION_DENIED
);
1258 visit_type_str(v
, &ptr
, name
, &local_err
);
1260 error_propagate(errp
, local_err
);
1264 ret
= prop
->info
->parse(dev
, prop
, ptr
);
1265 error_set_from_qdev_prop_error(errp
, ret
, dev
, prop
, ptr
);
1270 * @qdev_add_legacy_property - adds a legacy property
1272 * Do not use this is new code! Properties added through this interface will
1273 * be given names and types in the "legacy" namespace.
1275 * Legacy properties are always processed as strings. The format of the string
1276 * depends on the property type.
1278 void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
1283 name
= g_strdup_printf("legacy-%s", prop
->name
);
1284 type
= g_strdup_printf("legacy<%s>",
1285 prop
->info
->legacy_name
?: prop
->info
->name
);
1287 qdev_property_add(dev
, name
, type
,
1288 prop
->info
->print
? qdev_get_legacy_property
: NULL
,
1289 prop
->info
->parse
? qdev_set_legacy_property
: NULL
,
1298 * @qdev_property_add_static - add a @Property to a device.
1300 * Static properties access data in a struct. The actual type of the
1301 * property and the field depends on the property type.
1303 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
1306 qdev_property_add(dev
, prop
->name
, prop
->info
->name
,
1307 prop
->info
->get
, prop
->info
->set
,
1312 DeviceState
*qdev_get_root(void)
1314 static DeviceState
*qdev_root
;
1317 qdev_root
= qdev_create(NULL
, "container");
1318 qdev_init_nofail(qdev_root
);
1324 static void qdev_get_child_property(DeviceState
*dev
, Visitor
*v
, void *opaque
,
1325 const char *name
, Error
**errp
)
1327 DeviceState
*child
= opaque
;
1330 path
= qdev_get_canonical_path(child
);
1331 visit_type_str(v
, &path
, name
, errp
);
1335 static void qdev_release_child_property(DeviceState
*dev
, const char *name
,
1338 DeviceState
*child
= opaque
;
1343 void qdev_property_add_child(DeviceState
*dev
, const char *name
,
1344 DeviceState
*child
, Error
**errp
)
1348 type
= g_strdup_printf("child<%s>", object_get_typename(OBJECT(child
)));
1350 qdev_property_add(dev
, name
, type
, qdev_get_child_property
,
1351 NULL
, qdev_release_child_property
,
1355 g_assert(child
->parent
== NULL
);
1356 child
->parent
= dev
;
1361 static void qdev_get_link_property(DeviceState
*dev
, Visitor
*v
, void *opaque
,
1362 const char *name
, Error
**errp
)
1364 DeviceState
**child
= opaque
;
1368 path
= qdev_get_canonical_path(*child
);
1369 visit_type_str(v
, &path
, name
, errp
);
1373 visit_type_str(v
, &path
, name
, errp
);
1377 static void qdev_set_link_property(DeviceState
*dev
, Visitor
*v
, void *opaque
,
1378 const char *name
, Error
**errp
)
1380 DeviceState
**child
= opaque
;
1381 bool ambiguous
= false;
1385 type
= qdev_property_get_type(dev
, name
, NULL
);
1387 visit_type_str(v
, &path
, name
, errp
);
1393 if (strcmp(path
, "") != 0) {
1394 DeviceState
*target
;
1396 target
= qdev_resolve_path(path
, &ambiguous
);
1400 target_type
= g_strdup_printf("link<%s>", object_get_typename(OBJECT(target
)));
1401 if (strcmp(target_type
, type
) == 0) {
1405 error_set(errp
, QERR_INVALID_PARAMETER_TYPE
, name
, type
);
1408 g_free(target_type
);
1410 error_set(errp
, QERR_DEVICE_NOT_FOUND
, path
);
1419 void qdev_property_add_link(DeviceState
*dev
, const char *name
,
1420 const char *type
, DeviceState
**child
,
1425 full_type
= g_strdup_printf("link<%s>", type
);
1427 qdev_property_add(dev
, name
, full_type
,
1428 qdev_get_link_property
,
1429 qdev_set_link_property
,
1435 gchar
*qdev_get_canonical_path(DeviceState
*dev
)
1437 DeviceState
*root
= qdev_get_root();
1438 char *newpath
= NULL
, *path
= NULL
;
1440 while (dev
!= root
) {
1441 DeviceProperty
*prop
= NULL
;
1443 g_assert(dev
->parent
!= NULL
);
1445 QTAILQ_FOREACH(prop
, &dev
->parent
->properties
, node
) {
1446 if (!strstart(prop
->type
, "child<", NULL
)) {
1450 if (prop
->opaque
== dev
) {
1452 newpath
= g_strdup_printf("%s/%s", prop
->name
, path
);
1456 path
= g_strdup(prop
->name
);
1462 g_assert(prop
!= NULL
);
1467 newpath
= g_strdup_printf("/%s", path
);
1473 static DeviceState
*qdev_resolve_abs_path(DeviceState
*parent
,
1477 DeviceProperty
*prop
;
1480 if (parts
[index
] == NULL
) {
1484 if (strcmp(parts
[index
], "") == 0) {
1485 return qdev_resolve_abs_path(parent
, parts
, index
+ 1);
1488 prop
= qdev_property_find(parent
, parts
[index
]);
1494 if (strstart(prop
->type
, "link<", NULL
)) {
1495 DeviceState
**pchild
= prop
->opaque
;
1499 } else if (strstart(prop
->type
, "child<", NULL
)) {
1500 child
= prop
->opaque
;
1507 return qdev_resolve_abs_path(child
, parts
, index
+ 1);
1510 static DeviceState
*qdev_resolve_partial_path(DeviceState
*parent
,
1515 DeviceProperty
*prop
;
1517 dev
= qdev_resolve_abs_path(parent
, parts
, 0);
1519 QTAILQ_FOREACH(prop
, &parent
->properties
, node
) {
1522 if (!strstart(prop
->type
, "child<", NULL
)) {
1526 found
= qdev_resolve_partial_path(prop
->opaque
, parts
, ambiguous
);
1537 if (ambiguous
&& *ambiguous
) {
1545 DeviceState
*qdev_resolve_path(const char *path
, bool *ambiguous
)
1547 bool partial_path
= true;
1551 parts
= g_strsplit(path
, "/", 0);
1552 if (parts
== NULL
|| parts
[0] == NULL
) {
1554 return qdev_get_root();
1557 if (strcmp(parts
[0], "") == 0) {
1558 partial_path
= false;
1565 dev
= qdev_resolve_partial_path(qdev_get_root(), parts
, ambiguous
);
1567 dev
= qdev_resolve_abs_path(qdev_get_root(), parts
, 1);
1575 typedef struct StringProperty
1577 char *(*get
)(DeviceState
*, Error
**);
1578 void (*set
)(DeviceState
*, const char *, Error
**);
1581 static void qdev_property_get_str(DeviceState
*dev
, Visitor
*v
, void *opaque
,
1582 const char *name
, Error
**errp
)
1584 StringProperty
*prop
= opaque
;
1587 value
= prop
->get(dev
, errp
);
1589 visit_type_str(v
, &value
, name
, errp
);
1594 static void qdev_property_set_str(DeviceState
*dev
, Visitor
*v
, void *opaque
,
1595 const char *name
, Error
**errp
)
1597 StringProperty
*prop
= opaque
;
1599 Error
*local_err
= NULL
;
1601 visit_type_str(v
, &value
, name
, &local_err
);
1603 error_propagate(errp
, local_err
);
1607 prop
->set(dev
, value
, errp
);
1611 static void qdev_property_release_str(DeviceState
*dev
, const char *name
,
1614 StringProperty
*prop
= opaque
;
1618 void qdev_property_add_str(DeviceState
*dev
, const char *name
,
1619 char *(*get
)(DeviceState
*, Error
**),
1620 void (*set
)(DeviceState
*, const char *, Error
**),
1623 StringProperty
*prop
= g_malloc0(sizeof(*prop
));
1628 qdev_property_add(dev
, name
, "string",
1629 get
? qdev_property_get_str
: NULL
,
1630 set
? qdev_property_set_str
: NULL
,
1631 qdev_property_release_str
,
1635 void qdev_machine_init(void)
1637 qdev_get_peripheral_anon();
1638 qdev_get_peripheral();
1641 static void device_initfn(Object
*obj
)
1643 DeviceState
*dev
= DEVICE(obj
);
1647 dev
->hotplugged
= 1;
1648 qdev_hot_added
= true;
1651 dev
->instance_id_alias
= -1;
1652 QTAILQ_INIT(&dev
->properties
);
1653 dev
->state
= DEV_STATE_CREATED
;
1655 qdev_prop_set_defaults(dev
, qdev_get_props(dev
));
1656 for (prop
= qdev_get_props(dev
); prop
&& prop
->name
; prop
++) {
1657 qdev_property_add_legacy(dev
, prop
, NULL
);
1658 qdev_property_add_static(dev
, prop
, NULL
);
1661 qdev_property_add_str(dev
, "type", qdev_get_type
, NULL
, NULL
);
1664 void device_reset(DeviceState
*dev
)
1666 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1673 static TypeInfo device_type_info
= {
1674 .name
= TYPE_DEVICE
,
1675 .parent
= TYPE_OBJECT
,
1676 .instance_size
= sizeof(DeviceState
),
1677 .instance_init
= device_initfn
,
1679 .class_size
= sizeof(DeviceClass
),
1682 static void init_qdev(void)
1684 type_register_static(&device_type_info
);
1687 device_init(init_qdev
);