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
28 #include "qemu/osdep.h"
30 #include "hw/fw-path-provider.h"
31 #include "sysemu/sysemu.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "qemu/error-report.h"
36 #include "hw/hotplug.h"
37 #include "hw/boards.h"
38 #include "hw/sysbus.h"
39 #include "qapi-event.h"
41 bool qdev_hotplug
= false;
42 static bool qdev_hot_added
= false;
43 bool qdev_hot_removed
= false;
45 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
47 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
51 const char *qdev_fw_name(DeviceState
*dev
)
53 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
59 return object_get_typename(OBJECT(dev
));
62 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
66 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
67 if (kid
->child
== child
) {
70 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
71 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
73 /* This gives back ownership of kid->child back to us. */
74 object_property_del(OBJECT(bus
), name
, NULL
);
75 object_unref(OBJECT(kid
->child
));
82 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
85 BusChild
*kid
= g_malloc0(sizeof(*kid
));
87 kid
->index
= bus
->max_index
++;
89 object_ref(OBJECT(kid
->child
));
91 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
93 /* This transfers ownership of kid->child to the property. */
94 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
95 object_property_add_link(OBJECT(bus
), name
,
96 object_get_typename(OBJECT(child
)),
97 (Object
**)&kid
->child
,
98 NULL
, /* read-only property */
99 0, /* return ownership on prop deletion */
103 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
105 bool replugging
= dev
->parent_bus
!= NULL
;
108 /* Keep a reference to the device while it's not plugged into
109 * any bus, to avoid it potentially evaporating when it is
110 * dereffed in bus_remove_child().
112 object_ref(OBJECT(dev
));
113 bus_remove_child(dev
->parent_bus
, dev
);
114 object_unref(OBJECT(dev
->parent_bus
));
116 dev
->parent_bus
= bus
;
117 object_ref(OBJECT(bus
));
118 bus_add_child(bus
, dev
);
120 object_unref(OBJECT(dev
));
124 /* Create a new device. This only initializes the device state
125 structure and allows properties to be set. The device still needs
126 to be realized. See qdev-core.h. */
127 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
131 dev
= qdev_try_create(bus
, name
);
134 error_report("Unknown device '%s' for bus '%s'", name
,
135 object_get_typename(OBJECT(bus
)));
137 error_report("Unknown device '%s' for default sysbus", name
);
145 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
149 if (object_class_by_name(type
) == NULL
) {
152 dev
= DEVICE(object_new(type
));
158 /* Assert that the device really is a SysBusDevice before
159 * we put it onto the sysbus. Non-sysbus devices which aren't
160 * being put onto a bus should be created with object_new(TYPE_FOO),
161 * not qdev_create(NULL, TYPE_FOO).
163 g_assert(object_dynamic_cast(OBJECT(dev
), TYPE_SYS_BUS_DEVICE
));
164 bus
= sysbus_get_default();
167 qdev_set_parent_bus(dev
, bus
);
168 object_unref(OBJECT(dev
));
172 static QTAILQ_HEAD(device_listeners
, DeviceListener
) device_listeners
173 = QTAILQ_HEAD_INITIALIZER(device_listeners
);
175 enum ListenerDirection
{ Forward
, Reverse
};
177 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
179 DeviceListener *_listener; \
181 switch (_direction) { \
183 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
184 if (_listener->_callback) { \
185 _listener->_callback(_listener, ##_args); \
190 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
191 device_listeners, link) { \
192 if (_listener->_callback) { \
193 _listener->_callback(_listener, ##_args); \
202 static int device_listener_add(DeviceState
*dev
, void *opaque
)
204 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
209 void device_listener_register(DeviceListener
*listener
)
211 QTAILQ_INSERT_TAIL(&device_listeners
, listener
, link
);
213 qbus_walk_children(sysbus_get_default(), NULL
, NULL
, device_listener_add
,
217 void device_listener_unregister(DeviceListener
*listener
)
219 QTAILQ_REMOVE(&device_listeners
, listener
, link
);
222 static void device_realize(DeviceState
*dev
, Error
**errp
)
224 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
227 int rc
= dc
->init(dev
);
229 error_setg(errp
, "Device initialization failed.");
235 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
237 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
240 int rc
= dc
->exit(dev
);
242 error_setg(errp
, "Device exit failed.");
248 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
249 int required_for_version
)
251 assert(!dev
->realized
);
252 dev
->instance_id_alias
= alias_id
;
253 dev
->alias_required_for_version
= required_for_version
;
256 HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
258 HotplugHandler
*hotplug_ctrl
= NULL
;
260 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
261 hotplug_ctrl
= dev
->parent_bus
->hotplug_handler
;
262 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE
)) {
263 MachineState
*machine
= MACHINE(qdev_get_machine());
264 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
266 if (mc
->get_hotplug_handler
) {
267 hotplug_ctrl
= mc
->get_hotplug_handler(machine
, dev
);
273 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
280 static int qbus_reset_one(BusState
*bus
, void *opaque
)
282 BusClass
*bc
= BUS_GET_CLASS(bus
);
289 void qdev_reset_all(DeviceState
*dev
)
291 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
294 void qdev_reset_all_fn(void *opaque
)
296 qdev_reset_all(DEVICE(opaque
));
299 void qbus_reset_all(BusState
*bus
)
301 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
304 void qbus_reset_all_fn(void *opaque
)
306 BusState
*bus
= opaque
;
310 /* can be used as ->unplug() callback for the simple cases */
311 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
312 DeviceState
*dev
, Error
**errp
)
315 object_unparent(OBJECT(dev
));
320 * Device properties should be set before calling this function. IRQs
321 * and MMIO regions should be connected/mapped after calling this
323 * On failure, report an error with error_report() and terminate the
324 * program. This is okay during machine creation. Don't use for
325 * hotplug, because there callers need to recover from failure.
326 * Exception: if you know the device's init() callback can't fail,
327 * then qdev_init_nofail() can't fail either, and is therefore usable
328 * even then. But relying on the device implementation that way is
329 * somewhat unclean, and best avoided.
331 void qdev_init_nofail(DeviceState
*dev
)
335 assert(!dev
->realized
);
337 object_ref(OBJECT(dev
));
338 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
340 error_reportf_err(err
, "Initialization of device %s failed: ",
341 object_get_typename(OBJECT(dev
)));
344 object_unref(OBJECT(dev
));
347 void qdev_machine_creation_done(void)
350 * ok, initial machine setup is done, starting from now we can
351 * only create hotpluggable devices
356 bool qdev_machine_modified(void)
358 return qdev_hot_added
|| qdev_hot_removed
;
361 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
363 return dev
->parent_bus
;
366 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
371 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
372 /* NULL is a valid and matchable name, otherwise do a normal
375 if ((!ngl
->name
&& !name
) ||
376 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
381 ngl
= g_malloc0(sizeof(*ngl
));
382 ngl
->name
= g_strdup(name
);
383 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
387 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
388 const char *name
, int n
)
391 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
393 assert(gpio_list
->num_out
== 0 || !name
);
394 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
398 name
= "unnamed-gpio-in";
400 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
401 gchar
*propname
= g_strdup_printf("%s[%u]", name
, i
);
403 object_property_add_child(OBJECT(dev
), propname
,
404 OBJECT(gpio_list
->in
[i
]), &error_abort
);
408 gpio_list
->num_in
+= n
;
411 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
413 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
416 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
417 const char *name
, int n
)
420 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
422 assert(gpio_list
->num_in
== 0 || !name
);
425 name
= "unnamed-gpio-out";
427 memset(pins
, 0, sizeof(*pins
) * n
);
428 for (i
= 0; i
< n
; ++i
) {
429 gchar
*propname
= g_strdup_printf("%s[%u]", name
,
430 gpio_list
->num_out
+ i
);
432 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
434 object_property_allow_set_link
,
435 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
439 gpio_list
->num_out
+= n
;
442 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
444 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
447 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
449 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
451 assert(n
>= 0 && n
< gpio_list
->num_in
);
452 return gpio_list
->in
[n
];
455 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
457 return qdev_get_gpio_in_named(dev
, NULL
, n
);
460 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
463 char *propname
= g_strdup_printf("%s[%d]",
464 name
? name
: "unnamed-gpio-out", n
);
466 /* We need a name for object_property_set_link to work. If the
467 * object has a parent, object_property_add_child will come back
468 * with an error without doing anything. If it has none, it will
469 * never fail. So we can just call it with a NULL Error pointer.
471 object_property_add_child(container_get(qdev_get_machine(),
473 "non-qdev-gpio[*]", OBJECT(pin
), NULL
);
475 object_property_set_link(OBJECT(dev
), OBJECT(pin
), propname
, &error_abort
);
479 qemu_irq
qdev_get_gpio_out_connector(DeviceState
*dev
, const char *name
, int n
)
481 char *propname
= g_strdup_printf("%s[%d]",
482 name
? name
: "unnamed-gpio-out", n
);
484 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
490 /* disconnect a GPIO output, returning the disconnected input (if any) */
492 static qemu_irq
qdev_disconnect_gpio_out_named(DeviceState
*dev
,
493 const char *name
, int n
)
495 char *propname
= g_strdup_printf("%s[%d]",
496 name
? name
: "unnamed-gpio-out", n
);
498 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
501 object_property_set_link(OBJECT(dev
), NULL
, propname
, NULL
);
507 qemu_irq
qdev_intercept_gpio_out(DeviceState
*dev
, qemu_irq icpt
,
508 const char *name
, int n
)
510 qemu_irq disconnected
= qdev_disconnect_gpio_out_named(dev
, name
, n
);
511 qdev_connect_gpio_out_named(dev
, name
, n
, icpt
);
515 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
517 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
520 void qdev_pass_gpios(DeviceState
*dev
, DeviceState
*container
,
524 NamedGPIOList
*ngl
= qdev_get_named_gpio_list(dev
, name
);
526 for (i
= 0; i
< ngl
->num_in
; i
++) {
527 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-in";
528 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
530 object_property_add_alias(OBJECT(container
), propname
,
531 OBJECT(dev
), propname
,
535 for (i
= 0; i
< ngl
->num_out
; i
++) {
536 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-out";
537 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
539 object_property_add_alias(OBJECT(container
), propname
,
540 OBJECT(dev
), propname
,
544 QLIST_REMOVE(ngl
, node
);
545 QLIST_INSERT_HEAD(&container
->gpios
, ngl
, node
);
548 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
551 Object
*child
= object_resolve_path_component(OBJECT(dev
), name
);
553 bus
= (BusState
*)object_dynamic_cast(child
, TYPE_BUS
);
558 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
559 if (strcmp(name
, bus
->name
) == 0) {
566 int qdev_walk_children(DeviceState
*dev
,
567 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
568 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
575 err
= pre_devfn(dev
, opaque
);
581 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
582 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
583 post_devfn
, post_busfn
, opaque
);
590 err
= post_devfn(dev
, opaque
);
599 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
605 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
606 DeviceState
*dev
= kid
->child
;
608 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
612 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
613 ret
= qdev_find_recursive(child
, id
);
622 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
624 BusClass
*bc
= BUS_GET_CLASS(bus
);
626 if (bc
->get_fw_dev_path
) {
627 return bc
->get_fw_dev_path(dev
);
633 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
635 Object
*obj
= OBJECT(dev
);
638 while (!d
&& obj
->parent
) {
640 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
645 char *qdev_get_own_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
647 Object
*obj
= OBJECT(dev
);
649 return fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
652 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
656 if (dev
&& dev
->parent_bus
) {
658 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
659 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
661 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
664 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
670 l
+= snprintf(p
+ l
, size
- l
, "/");
675 char* qdev_get_fw_dev_path(DeviceState
*dev
)
680 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
684 return g_strdup(path
);
687 char *qdev_get_dev_path(DeviceState
*dev
)
691 if (!dev
|| !dev
->parent_bus
) {
695 bc
= BUS_GET_CLASS(dev
->parent_bus
);
696 if (bc
->get_dev_path
) {
697 return bc
->get_dev_path(dev
);
704 * Legacy property handling
707 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
,
708 const char *name
, void *opaque
,
711 DeviceState
*dev
= DEVICE(obj
);
712 Property
*prop
= opaque
;
717 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
718 visit_type_str(v
, name
, &ptr
, errp
);
722 * qdev_property_add_legacy:
723 * @dev: Device to add the property to.
724 * @prop: The qdev property definition.
725 * @errp: location to store error information.
727 * Add a legacy QOM property to @dev for qdev property @prop.
728 * On error, store error in @errp.
730 * Legacy properties are string versions of QOM properties. The format of
731 * the string depends on the property type. Legacy properties are only
732 * needed for "info qtree".
734 * Do not use this is new code! QOM Properties added through this interface
735 * will be given names in the "legacy" namespace.
737 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
742 /* Register pointer properties as legacy properties */
743 if (!prop
->info
->print
&& prop
->info
->get
) {
747 name
= g_strdup_printf("legacy-%s", prop
->name
);
748 object_property_add(OBJECT(dev
), name
, "str",
749 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
758 * qdev_property_add_static:
759 * @dev: Device to add the property to.
760 * @prop: The qdev property definition.
761 * @errp: location to store error information.
763 * Add a static QOM property to @dev for qdev property @prop.
764 * On error, store error in @errp. Static properties access data in a struct.
765 * The type of the QOM property is derived from prop->info.
767 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
770 Error
*local_err
= NULL
;
771 Object
*obj
= OBJECT(dev
);
774 * TODO qdev_prop_ptr does not have getters or setters. It must
775 * go now that it can be replaced with links. The test should be
776 * removed along with it: all static properties are read/write.
778 if (!prop
->info
->get
&& !prop
->info
->set
) {
782 object_property_add(obj
, prop
->name
, prop
->info
->name
,
783 prop
->info
->get
, prop
->info
->set
,
788 error_propagate(errp
, local_err
);
792 object_property_set_description(obj
, prop
->name
,
793 prop
->info
->description
,
796 if (prop
->info
->set_default_value
) {
797 prop
->info
->set_default_value(obj
, prop
);
801 /* @qdev_alias_all_properties - Add alias properties to the source object for
802 * all qdev properties on the target DeviceState.
804 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
809 class = object_get_class(OBJECT(target
));
811 DeviceClass
*dc
= DEVICE_CLASS(class);
813 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
814 object_property_add_alias(source
, prop
->name
,
815 OBJECT(target
), prop
->name
,
818 class = object_class_get_parent(class);
819 } while (class != object_class_by_name(TYPE_DEVICE
));
822 static int qdev_add_hotpluggable_device(Object
*obj
, void *opaque
)
824 GSList
**list
= opaque
;
825 DeviceState
*dev
= (DeviceState
*)object_dynamic_cast(OBJECT(obj
),
832 if (dev
->realized
&& object_property_get_bool(obj
, "hotpluggable", NULL
)) {
833 *list
= g_slist_append(*list
, dev
);
839 GSList
*qdev_build_hotpluggable_device_list(Object
*peripheral
)
843 object_child_foreach(peripheral
, qdev_add_hotpluggable_device
, &list
);
848 static bool device_get_realized(Object
*obj
, Error
**errp
)
850 DeviceState
*dev
= DEVICE(obj
);
851 return dev
->realized
;
854 static bool check_only_migratable(Object
*obj
, Error
**err
)
856 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
858 if (!vmstate_check_only_migratable(dc
->vmsd
)) {
859 error_setg(err
, "Device %s is not migratable, but "
860 "--only-migratable was specified",
861 object_get_typename(obj
));
868 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
870 DeviceState
*dev
= DEVICE(obj
);
871 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
872 HotplugHandler
*hotplug_ctrl
;
874 Error
*local_err
= NULL
;
875 bool unattached_parent
= false;
876 static int unattached_count
;
878 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
879 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
883 if (value
&& !dev
->realized
) {
884 if (!check_only_migratable(obj
, &local_err
)) {
889 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
891 object_property_add_child(container_get(qdev_get_machine(),
893 name
, obj
, &error_abort
);
894 unattached_parent
= true;
898 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
900 hotplug_handler_pre_plug(hotplug_ctrl
, dev
, &local_err
);
901 if (local_err
!= NULL
) {
907 dc
->realize(dev
, &local_err
);
910 if (local_err
!= NULL
) {
914 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
917 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
920 if (local_err
!= NULL
) {
921 goto post_realize_fail
;
924 if (qdev_get_vmsd(dev
)) {
925 if (vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
926 dev
->instance_id_alias
,
927 dev
->alias_required_for_version
,
929 goto post_realize_fail
;
933 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
934 object_property_set_bool(OBJECT(bus
), true, "realized",
936 if (local_err
!= NULL
) {
937 goto child_realize_fail
;
940 if (dev
->hotplugged
) {
943 dev
->pending_deleted_event
= false;
944 } else if (!value
&& dev
->realized
) {
945 Error
**local_errp
= NULL
;
946 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
947 local_errp
= local_err
? NULL
: &local_err
;
948 object_property_set_bool(OBJECT(bus
), false, "realized",
951 if (qdev_get_vmsd(dev
)) {
952 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
955 local_errp
= local_err
? NULL
: &local_err
;
956 dc
->unrealize(dev
, local_errp
);
958 dev
->pending_deleted_event
= true;
959 DEVICE_LISTENER_CALL(unrealize
, Reverse
, dev
);
962 if (local_err
!= NULL
) {
966 dev
->realized
= value
;
970 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
971 object_property_set_bool(OBJECT(bus
), false, "realized",
975 if (qdev_get_vmsd(dev
)) {
976 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
981 dc
->unrealize(dev
, NULL
);
985 error_propagate(errp
, local_err
);
986 if (unattached_parent
) {
987 object_unparent(OBJECT(dev
));
992 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
994 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
995 DeviceState
*dev
= DEVICE(obj
);
997 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
998 qbus_is_hotpluggable(dev
->parent_bus
));
1001 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
1003 DeviceState
*dev
= DEVICE(obj
);
1005 return dev
->hotplugged
;
1008 static void device_initfn(Object
*obj
)
1010 DeviceState
*dev
= DEVICE(obj
);
1015 dev
->hotplugged
= 1;
1016 qdev_hot_added
= true;
1019 dev
->instance_id_alias
= -1;
1020 dev
->realized
= false;
1022 object_property_add_bool(obj
, "realized",
1023 device_get_realized
, device_set_realized
, NULL
);
1024 object_property_add_bool(obj
, "hotpluggable",
1025 device_get_hotpluggable
, NULL
, NULL
);
1026 object_property_add_bool(obj
, "hotplugged",
1027 device_get_hotplugged
, NULL
,
1030 class = object_get_class(OBJECT(dev
));
1032 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
1033 qdev_property_add_legacy(dev
, prop
, &error_abort
);
1034 qdev_property_add_static(dev
, prop
, &error_abort
);
1036 class = object_class_get_parent(class);
1037 } while (class != object_class_by_name(TYPE_DEVICE
));
1039 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1040 (Object
**)&dev
->parent_bus
, NULL
, 0,
1042 QLIST_INIT(&dev
->gpios
);
1045 static void device_post_init(Object
*obj
)
1047 qdev_prop_set_globals(DEVICE(obj
));
1050 /* Unlink device from bus and free the structure. */
1051 static void device_finalize(Object
*obj
)
1053 NamedGPIOList
*ngl
, *next
;
1055 DeviceState
*dev
= DEVICE(obj
);
1057 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1058 QLIST_REMOVE(ngl
, node
);
1059 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1062 /* ngl->out irqs are owned by the other end and should not be freed
1068 static void device_class_base_init(ObjectClass
*class, void *data
)
1070 DeviceClass
*klass
= DEVICE_CLASS(class);
1072 /* We explicitly look up properties in the superclasses,
1073 * so do not propagate them to the subclasses.
1075 klass
->props
= NULL
;
1078 static void device_unparent(Object
*obj
)
1080 DeviceState
*dev
= DEVICE(obj
);
1083 if (dev
->realized
) {
1084 object_property_set_bool(obj
, false, "realized", NULL
);
1086 while (dev
->num_child_bus
) {
1087 bus
= QLIST_FIRST(&dev
->child_bus
);
1088 object_unparent(OBJECT(bus
));
1090 if (dev
->parent_bus
) {
1091 bus_remove_child(dev
->parent_bus
, dev
);
1092 object_unref(OBJECT(dev
->parent_bus
));
1093 dev
->parent_bus
= NULL
;
1096 /* Only send event if the device had been completely realized */
1097 if (dev
->pending_deleted_event
) {
1098 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
1100 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, path
, &error_abort
);
1104 qemu_opts_del(dev
->opts
);
1108 static void device_class_init(ObjectClass
*class, void *data
)
1110 DeviceClass
*dc
= DEVICE_CLASS(class);
1112 class->unparent
= device_unparent
;
1113 dc
->realize
= device_realize
;
1114 dc
->unrealize
= device_unrealize
;
1116 /* by default all devices were considered as hotpluggable,
1117 * so with intent to check it in generic qdev_unplug() /
1118 * device_set_realized() functions make every device
1119 * hotpluggable. Devices that shouldn't be hotpluggable,
1120 * should override it in their class_init()
1122 dc
->hotpluggable
= true;
1123 dc
->user_creatable
= true;
1126 void device_reset(DeviceState
*dev
)
1128 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1135 Object
*qdev_get_machine(void)
1140 dev
= container_get(object_get_root(), "/machine");
1146 static const TypeInfo device_type_info
= {
1147 .name
= TYPE_DEVICE
,
1148 .parent
= TYPE_OBJECT
,
1149 .instance_size
= sizeof(DeviceState
),
1150 .instance_init
= device_initfn
,
1151 .instance_post_init
= device_post_init
,
1152 .instance_finalize
= device_finalize
,
1153 .class_base_init
= device_class_base_init
,
1154 .class_init
= device_class_init
,
1156 .class_size
= sizeof(DeviceClass
),
1159 static void qdev_register_types(void)
1161 type_register_static(&device_type_info
);
1164 type_init(qdev_register_types
)