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 "sysemu/sysemu.h"
31 #include "qapi/error.h"
32 #include "qapi/qapi-events-misc.h"
33 #include "qapi/qmp/qerror.h"
34 #include "qapi/visitor.h"
35 #include "qemu/error-report.h"
36 #include "qemu/option.h"
37 #include "hw/hotplug.h"
38 #include "hw/boards.h"
39 #include "hw/sysbus.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 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
55 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
56 if (kid
->child
== child
) {
59 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
60 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
62 /* This gives back ownership of kid->child back to us. */
63 object_property_del(OBJECT(bus
), name
, NULL
);
64 object_unref(OBJECT(kid
->child
));
71 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
74 BusChild
*kid
= g_malloc0(sizeof(*kid
));
76 kid
->index
= bus
->max_index
++;
78 object_ref(OBJECT(kid
->child
));
80 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
82 /* This transfers ownership of kid->child to the property. */
83 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
84 object_property_add_link(OBJECT(bus
), name
,
85 object_get_typename(OBJECT(child
)),
86 (Object
**)&kid
->child
,
87 NULL
, /* read-only property */
88 0, /* return ownership on prop deletion */
92 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
94 bool replugging
= dev
->parent_bus
!= NULL
;
97 /* Keep a reference to the device while it's not plugged into
98 * any bus, to avoid it potentially evaporating when it is
99 * dereffed in bus_remove_child().
101 object_ref(OBJECT(dev
));
102 bus_remove_child(dev
->parent_bus
, dev
);
103 object_unref(OBJECT(dev
->parent_bus
));
105 dev
->parent_bus
= bus
;
106 object_ref(OBJECT(bus
));
107 bus_add_child(bus
, dev
);
109 object_unref(OBJECT(dev
));
113 /* Create a new device. This only initializes the device state
114 structure and allows properties to be set. The device still needs
115 to be realized. See qdev-core.h. */
116 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
120 dev
= qdev_try_create(bus
, name
);
123 error_report("Unknown device '%s' for bus '%s'", name
,
124 object_get_typename(OBJECT(bus
)));
126 error_report("Unknown device '%s' for default sysbus", name
);
134 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
138 if (object_class_by_name(type
) == NULL
) {
141 dev
= DEVICE(object_new(type
));
147 /* Assert that the device really is a SysBusDevice before
148 * we put it onto the sysbus. Non-sysbus devices which aren't
149 * being put onto a bus should be created with object_new(TYPE_FOO),
150 * not qdev_create(NULL, TYPE_FOO).
152 g_assert(object_dynamic_cast(OBJECT(dev
), TYPE_SYS_BUS_DEVICE
));
153 bus
= sysbus_get_default();
156 qdev_set_parent_bus(dev
, bus
);
157 object_unref(OBJECT(dev
));
161 static QTAILQ_HEAD(device_listeners
, DeviceListener
) device_listeners
162 = QTAILQ_HEAD_INITIALIZER(device_listeners
);
164 enum ListenerDirection
{ Forward
, Reverse
};
166 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
168 DeviceListener *_listener; \
170 switch (_direction) { \
172 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
173 if (_listener->_callback) { \
174 _listener->_callback(_listener, ##_args); \
179 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
180 device_listeners, link) { \
181 if (_listener->_callback) { \
182 _listener->_callback(_listener, ##_args); \
191 static int device_listener_add(DeviceState
*dev
, void *opaque
)
193 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
198 void device_listener_register(DeviceListener
*listener
)
200 QTAILQ_INSERT_TAIL(&device_listeners
, listener
, link
);
202 qbus_walk_children(sysbus_get_default(), NULL
, NULL
, device_listener_add
,
206 void device_listener_unregister(DeviceListener
*listener
)
208 QTAILQ_REMOVE(&device_listeners
, listener
, link
);
211 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
212 int required_for_version
)
214 assert(!dev
->realized
);
215 dev
->instance_id_alias
= alias_id
;
216 dev
->alias_required_for_version
= required_for_version
;
219 HotplugHandler
*qdev_get_machine_hotplug_handler(DeviceState
*dev
)
221 MachineState
*machine
;
223 Object
*m_obj
= qdev_get_machine();
225 if (object_dynamic_cast(m_obj
, TYPE_MACHINE
)) {
226 machine
= MACHINE(m_obj
);
227 mc
= MACHINE_GET_CLASS(machine
);
228 if (mc
->get_hotplug_handler
) {
229 return mc
->get_hotplug_handler(machine
, dev
);
236 HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
238 HotplugHandler
*hotplug_ctrl
;
240 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
241 hotplug_ctrl
= dev
->parent_bus
->hotplug_handler
;
243 hotplug_ctrl
= qdev_get_machine_hotplug_handler(dev
);
248 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
255 static int qbus_reset_one(BusState
*bus
, void *opaque
)
257 BusClass
*bc
= BUS_GET_CLASS(bus
);
264 void qdev_reset_all(DeviceState
*dev
)
266 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
269 void qdev_reset_all_fn(void *opaque
)
271 qdev_reset_all(DEVICE(opaque
));
274 void qbus_reset_all(BusState
*bus
)
276 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
279 void qbus_reset_all_fn(void *opaque
)
281 BusState
*bus
= opaque
;
285 /* can be used as ->unplug() callback for the simple cases */
286 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
287 DeviceState
*dev
, Error
**errp
)
290 object_unparent(OBJECT(dev
));
295 * Device properties should be set before calling this function. IRQs
296 * and MMIO regions should be connected/mapped after calling this
298 * On failure, report an error with error_report() and terminate the
299 * program. This is okay during machine creation. Don't use for
300 * hotplug, because there callers need to recover from failure.
301 * Exception: if you know the device's init() callback can't fail,
302 * then qdev_init_nofail() can't fail either, and is therefore usable
303 * even then. But relying on the device implementation that way is
304 * somewhat unclean, and best avoided.
306 void qdev_init_nofail(DeviceState
*dev
)
310 assert(!dev
->realized
);
312 object_ref(OBJECT(dev
));
313 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
315 error_reportf_err(err
, "Initialization of device %s failed: ",
316 object_get_typename(OBJECT(dev
)));
319 object_unref(OBJECT(dev
));
322 void qdev_machine_creation_done(void)
325 * ok, initial machine setup is done, starting from now we can
326 * only create hotpluggable devices
331 bool qdev_machine_modified(void)
333 return qdev_hot_added
|| qdev_hot_removed
;
336 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
338 return dev
->parent_bus
;
341 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
346 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
347 /* NULL is a valid and matchable name, otherwise do a normal
350 if ((!ngl
->name
&& !name
) ||
351 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
356 ngl
= g_malloc0(sizeof(*ngl
));
357 ngl
->name
= g_strdup(name
);
358 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
362 void qdev_init_gpio_in_named_with_opaque(DeviceState
*dev
,
363 qemu_irq_handler handler
,
365 const char *name
, int n
)
368 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
370 assert(gpio_list
->num_out
== 0 || !name
);
371 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
375 name
= "unnamed-gpio-in";
377 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
378 gchar
*propname
= g_strdup_printf("%s[%u]", name
, i
);
380 object_property_add_child(OBJECT(dev
), propname
,
381 OBJECT(gpio_list
->in
[i
]), &error_abort
);
385 gpio_list
->num_in
+= n
;
388 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
390 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
393 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
394 const char *name
, int n
)
397 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
399 assert(gpio_list
->num_in
== 0 || !name
);
402 name
= "unnamed-gpio-out";
404 memset(pins
, 0, sizeof(*pins
) * n
);
405 for (i
= 0; i
< n
; ++i
) {
406 gchar
*propname
= g_strdup_printf("%s[%u]", name
,
407 gpio_list
->num_out
+ i
);
409 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
411 object_property_allow_set_link
,
412 OBJ_PROP_LINK_STRONG
,
416 gpio_list
->num_out
+= n
;
419 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
421 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
424 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
426 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
428 assert(n
>= 0 && n
< gpio_list
->num_in
);
429 return gpio_list
->in
[n
];
432 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
434 return qdev_get_gpio_in_named(dev
, NULL
, n
);
437 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
440 char *propname
= g_strdup_printf("%s[%d]",
441 name
? name
: "unnamed-gpio-out", n
);
443 /* We need a name for object_property_set_link to work. If the
444 * object has a parent, object_property_add_child will come back
445 * with an error without doing anything. If it has none, it will
446 * never fail. So we can just call it with a NULL Error pointer.
448 object_property_add_child(container_get(qdev_get_machine(),
450 "non-qdev-gpio[*]", OBJECT(pin
), NULL
);
452 object_property_set_link(OBJECT(dev
), OBJECT(pin
), propname
, &error_abort
);
456 qemu_irq
qdev_get_gpio_out_connector(DeviceState
*dev
, const char *name
, int n
)
458 char *propname
= g_strdup_printf("%s[%d]",
459 name
? name
: "unnamed-gpio-out", n
);
461 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
467 /* disconnect a GPIO output, returning the disconnected input (if any) */
469 static qemu_irq
qdev_disconnect_gpio_out_named(DeviceState
*dev
,
470 const char *name
, int n
)
472 char *propname
= g_strdup_printf("%s[%d]",
473 name
? name
: "unnamed-gpio-out", n
);
475 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
478 object_property_set_link(OBJECT(dev
), NULL
, propname
, NULL
);
484 qemu_irq
qdev_intercept_gpio_out(DeviceState
*dev
, qemu_irq icpt
,
485 const char *name
, int n
)
487 qemu_irq disconnected
= qdev_disconnect_gpio_out_named(dev
, name
, n
);
488 qdev_connect_gpio_out_named(dev
, name
, n
, icpt
);
492 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
494 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
497 void qdev_pass_gpios(DeviceState
*dev
, DeviceState
*container
,
501 NamedGPIOList
*ngl
= qdev_get_named_gpio_list(dev
, name
);
503 for (i
= 0; i
< ngl
->num_in
; i
++) {
504 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-in";
505 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
507 object_property_add_alias(OBJECT(container
), propname
,
508 OBJECT(dev
), propname
,
512 for (i
= 0; i
< ngl
->num_out
; i
++) {
513 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-out";
514 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
516 object_property_add_alias(OBJECT(container
), propname
,
517 OBJECT(dev
), propname
,
521 QLIST_REMOVE(ngl
, node
);
522 QLIST_INSERT_HEAD(&container
->gpios
, ngl
, node
);
525 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
528 Object
*child
= object_resolve_path_component(OBJECT(dev
), name
);
530 bus
= (BusState
*)object_dynamic_cast(child
, TYPE_BUS
);
535 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
536 if (strcmp(name
, bus
->name
) == 0) {
543 int qdev_walk_children(DeviceState
*dev
,
544 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
545 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
552 err
= pre_devfn(dev
, opaque
);
558 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
559 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
560 post_devfn
, post_busfn
, opaque
);
567 err
= post_devfn(dev
, opaque
);
576 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
582 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
583 DeviceState
*dev
= kid
->child
;
585 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
589 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
590 ret
= qdev_find_recursive(child
, id
);
599 char *qdev_get_dev_path(DeviceState
*dev
)
603 if (!dev
|| !dev
->parent_bus
) {
607 bc
= BUS_GET_CLASS(dev
->parent_bus
);
608 if (bc
->get_dev_path
) {
609 return bc
->get_dev_path(dev
);
616 * Legacy property handling
619 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
,
620 const char *name
, void *opaque
,
623 DeviceState
*dev
= DEVICE(obj
);
624 Property
*prop
= opaque
;
629 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
630 visit_type_str(v
, name
, &ptr
, errp
);
634 * qdev_property_add_legacy:
635 * @dev: Device to add the property to.
636 * @prop: The qdev property definition.
637 * @errp: location to store error information.
639 * Add a legacy QOM property to @dev for qdev property @prop.
640 * On error, store error in @errp.
642 * Legacy properties are string versions of QOM properties. The format of
643 * the string depends on the property type. Legacy properties are only
644 * needed for "info qtree".
646 * Do not use this is new code! QOM Properties added through this interface
647 * will be given names in the "legacy" namespace.
649 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
654 /* Register pointer properties as legacy properties */
655 if (!prop
->info
->print
&& prop
->info
->get
) {
659 if (prop
->info
->create
) {
663 name
= g_strdup_printf("legacy-%s", prop
->name
);
664 object_property_add(OBJECT(dev
), name
, "str",
665 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
674 * qdev_property_add_static:
675 * @dev: Device to add the property to.
676 * @prop: The qdev property definition.
677 * @errp: location to store error information.
679 * Add a static QOM property to @dev for qdev property @prop.
680 * On error, store error in @errp. Static properties access data in a struct.
681 * The type of the QOM property is derived from prop->info.
683 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
686 Error
*local_err
= NULL
;
687 Object
*obj
= OBJECT(dev
);
689 if (prop
->info
->create
) {
690 prop
->info
->create(obj
, prop
, &local_err
);
693 * TODO qdev_prop_ptr does not have getters or setters. It must
694 * go now that it can be replaced with links. The test should be
695 * removed along with it: all static properties are read/write.
697 if (!prop
->info
->get
&& !prop
->info
->set
) {
700 object_property_add(obj
, prop
->name
, prop
->info
->name
,
701 prop
->info
->get
, prop
->info
->set
,
707 error_propagate(errp
, local_err
);
711 object_property_set_description(obj
, prop
->name
,
712 prop
->info
->description
,
715 if (prop
->set_default
) {
716 prop
->info
->set_default_value(obj
, prop
);
720 /* @qdev_alias_all_properties - Add alias properties to the source object for
721 * all qdev properties on the target DeviceState.
723 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
728 class = object_get_class(OBJECT(target
));
730 DeviceClass
*dc
= DEVICE_CLASS(class);
732 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
733 object_property_add_alias(source
, prop
->name
,
734 OBJECT(target
), prop
->name
,
737 class = object_class_get_parent(class);
738 } while (class != object_class_by_name(TYPE_DEVICE
));
741 static int qdev_add_hotpluggable_device(Object
*obj
, void *opaque
)
743 GSList
**list
= opaque
;
744 DeviceState
*dev
= (DeviceState
*)object_dynamic_cast(OBJECT(obj
),
751 if (dev
->realized
&& object_property_get_bool(obj
, "hotpluggable", NULL
)) {
752 *list
= g_slist_append(*list
, dev
);
758 GSList
*qdev_build_hotpluggable_device_list(Object
*peripheral
)
762 object_child_foreach(peripheral
, qdev_add_hotpluggable_device
, &list
);
767 static bool device_get_realized(Object
*obj
, Error
**errp
)
769 DeviceState
*dev
= DEVICE(obj
);
770 return dev
->realized
;
773 static bool check_only_migratable(Object
*obj
, Error
**err
)
775 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
777 if (!vmstate_check_only_migratable(dc
->vmsd
)) {
778 error_setg(err
, "Device %s is not migratable, but "
779 "--only-migratable was specified",
780 object_get_typename(obj
));
787 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
789 DeviceState
*dev
= DEVICE(obj
);
790 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
791 HotplugHandler
*hotplug_ctrl
;
793 Error
*local_err
= NULL
;
794 bool unattached_parent
= false;
795 static int unattached_count
;
797 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
798 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
802 if (value
&& !dev
->realized
) {
803 if (!check_only_migratable(obj
, &local_err
)) {
808 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
810 object_property_add_child(container_get(qdev_get_machine(),
812 name
, obj
, &error_abort
);
813 unattached_parent
= true;
817 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
819 hotplug_handler_pre_plug(hotplug_ctrl
, dev
, &local_err
);
820 if (local_err
!= NULL
) {
826 dc
->realize(dev
, &local_err
);
829 if (local_err
!= NULL
) {
833 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
836 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
839 if (local_err
!= NULL
) {
840 goto post_realize_fail
;
844 * always free/re-initialize here since the value cannot be cleaned up
845 * in device_unrealize due to its usage later on in the unplug path
847 g_free(dev
->canonical_path
);
848 dev
->canonical_path
= object_get_canonical_path(OBJECT(dev
));
850 if (qdev_get_vmsd(dev
)) {
851 if (vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
852 dev
->instance_id_alias
,
853 dev
->alias_required_for_version
,
855 goto post_realize_fail
;
859 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
860 object_property_set_bool(OBJECT(bus
), true, "realized",
862 if (local_err
!= NULL
) {
863 goto child_realize_fail
;
866 if (dev
->hotplugged
) {
869 dev
->pending_deleted_event
= false;
872 hotplug_handler_post_plug(hotplug_ctrl
, dev
);
874 } else if (!value
&& dev
->realized
) {
875 Error
**local_errp
= NULL
;
876 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
877 local_errp
= local_err
? NULL
: &local_err
;
878 object_property_set_bool(OBJECT(bus
), false, "realized",
881 if (qdev_get_vmsd(dev
)) {
882 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
885 local_errp
= local_err
? NULL
: &local_err
;
886 dc
->unrealize(dev
, local_errp
);
888 dev
->pending_deleted_event
= true;
889 DEVICE_LISTENER_CALL(unrealize
, Reverse
, dev
);
892 if (local_err
!= NULL
) {
896 dev
->realized
= value
;
900 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
901 object_property_set_bool(OBJECT(bus
), false, "realized",
905 if (qdev_get_vmsd(dev
)) {
906 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
910 g_free(dev
->canonical_path
);
911 dev
->canonical_path
= NULL
;
913 dc
->unrealize(dev
, NULL
);
917 error_propagate(errp
, local_err
);
918 if (unattached_parent
) {
919 object_unparent(OBJECT(dev
));
924 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
926 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
927 DeviceState
*dev
= DEVICE(obj
);
929 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
930 qbus_is_hotpluggable(dev
->parent_bus
));
933 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
935 DeviceState
*dev
= DEVICE(obj
);
937 return dev
->hotplugged
;
940 static void device_initfn(Object
*obj
)
942 DeviceState
*dev
= DEVICE(obj
);
948 qdev_hot_added
= true;
951 dev
->instance_id_alias
= -1;
952 dev
->realized
= false;
954 object_property_add_bool(obj
, "realized",
955 device_get_realized
, device_set_realized
, NULL
);
956 object_property_add_bool(obj
, "hotpluggable",
957 device_get_hotpluggable
, NULL
, NULL
);
958 object_property_add_bool(obj
, "hotplugged",
959 device_get_hotplugged
, NULL
,
962 class = object_get_class(OBJECT(dev
));
964 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
965 qdev_property_add_legacy(dev
, prop
, &error_abort
);
966 qdev_property_add_static(dev
, prop
, &error_abort
);
968 class = object_class_get_parent(class);
969 } while (class != object_class_by_name(TYPE_DEVICE
));
971 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
972 (Object
**)&dev
->parent_bus
, NULL
, 0,
974 QLIST_INIT(&dev
->gpios
);
977 static void device_post_init(Object
*obj
)
979 qdev_prop_set_globals(DEVICE(obj
));
982 /* Unlink device from bus and free the structure. */
983 static void device_finalize(Object
*obj
)
985 NamedGPIOList
*ngl
, *next
;
987 DeviceState
*dev
= DEVICE(obj
);
989 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
990 QLIST_REMOVE(ngl
, node
);
991 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
994 /* ngl->out irqs are owned by the other end and should not be freed
999 /* Only send event if the device had been completely realized */
1000 if (dev
->pending_deleted_event
) {
1001 g_assert(dev
->canonical_path
);
1003 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, dev
->canonical_path
,
1005 g_free(dev
->canonical_path
);
1006 dev
->canonical_path
= NULL
;
1009 qemu_opts_del(dev
->opts
);
1012 static void device_class_base_init(ObjectClass
*class, void *data
)
1014 DeviceClass
*klass
= DEVICE_CLASS(class);
1016 /* We explicitly look up properties in the superclasses,
1017 * so do not propagate them to the subclasses.
1019 klass
->props
= NULL
;
1022 static void device_unparent(Object
*obj
)
1024 DeviceState
*dev
= DEVICE(obj
);
1027 if (dev
->realized
) {
1028 object_property_set_bool(obj
, false, "realized", NULL
);
1030 while (dev
->num_child_bus
) {
1031 bus
= QLIST_FIRST(&dev
->child_bus
);
1032 object_unparent(OBJECT(bus
));
1034 if (dev
->parent_bus
) {
1035 bus_remove_child(dev
->parent_bus
, dev
);
1036 object_unref(OBJECT(dev
->parent_bus
));
1037 dev
->parent_bus
= NULL
;
1041 static void device_class_init(ObjectClass
*class, void *data
)
1043 DeviceClass
*dc
= DEVICE_CLASS(class);
1045 class->unparent
= device_unparent
;
1047 /* by default all devices were considered as hotpluggable,
1048 * so with intent to check it in generic qdev_unplug() /
1049 * device_set_realized() functions make every device
1050 * hotpluggable. Devices that shouldn't be hotpluggable,
1051 * should override it in their class_init()
1053 dc
->hotpluggable
= true;
1054 dc
->user_creatable
= true;
1057 void device_class_set_parent_reset(DeviceClass
*dc
,
1058 DeviceReset dev_reset
,
1059 DeviceReset
*parent_reset
)
1061 *parent_reset
= dc
->reset
;
1062 dc
->reset
= dev_reset
;
1065 void device_class_set_parent_realize(DeviceClass
*dc
,
1066 DeviceRealize dev_realize
,
1067 DeviceRealize
*parent_realize
)
1069 *parent_realize
= dc
->realize
;
1070 dc
->realize
= dev_realize
;
1073 void device_class_set_parent_unrealize(DeviceClass
*dc
,
1074 DeviceUnrealize dev_unrealize
,
1075 DeviceUnrealize
*parent_unrealize
)
1077 *parent_unrealize
= dc
->unrealize
;
1078 dc
->unrealize
= dev_unrealize
;
1081 void device_reset(DeviceState
*dev
)
1083 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1090 Object
*qdev_get_machine(void)
1095 dev
= container_get(object_get_root(), "/machine");
1101 static const TypeInfo device_type_info
= {
1102 .name
= TYPE_DEVICE
,
1103 .parent
= TYPE_OBJECT
,
1104 .instance_size
= sizeof(DeviceState
),
1105 .instance_init
= device_initfn
,
1106 .instance_post_init
= device_post_init
,
1107 .instance_finalize
= device_finalize
,
1108 .class_base_init
= device_class_base_init
,
1109 .class_init
= device_class_init
,
1111 .class_size
= sizeof(DeviceClass
),
1114 static void qdev_register_types(void)
1116 type_register_static(&device_type_info
);
1119 type_init(qdev_register_types
)