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"
29 #include "sysemu/sysemu.h"
30 #include "qapi/error.h"
31 #include "qapi/qapi-events-qdev.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/visitor.h"
34 #include "qemu/error-report.h"
35 #include "qemu/option.h"
36 #include "hw/hotplug.h"
38 #include "hw/qdev-properties.h"
39 #include "hw/boards.h"
40 #include "hw/sysbus.h"
41 #include "migration/vmstate.h"
43 bool qdev_hotplug
= false;
44 static bool qdev_hot_added
= false;
45 bool qdev_hot_removed
= false;
47 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
49 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
53 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
57 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
58 if (kid
->child
== child
) {
61 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
62 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
66 /* This gives back ownership of kid->child back to us. */
67 object_property_del(OBJECT(bus
), name
, NULL
);
68 object_unref(OBJECT(kid
->child
));
75 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
78 BusChild
*kid
= g_malloc0(sizeof(*kid
));
81 kid
->index
= bus
->max_index
++;
83 object_ref(OBJECT(kid
->child
));
85 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
87 /* This transfers ownership of kid->child to the property. */
88 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
89 object_property_add_link(OBJECT(bus
), name
,
90 object_get_typename(OBJECT(child
)),
91 (Object
**)&kid
->child
,
92 NULL
, /* read-only property */
93 0, /* return ownership on prop deletion */
97 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
99 bool replugging
= dev
->parent_bus
!= NULL
;
102 /* Keep a reference to the device while it's not plugged into
103 * any bus, to avoid it potentially evaporating when it is
104 * dereffed in bus_remove_child().
106 object_ref(OBJECT(dev
));
107 bus_remove_child(dev
->parent_bus
, dev
);
108 object_unref(OBJECT(dev
->parent_bus
));
110 dev
->parent_bus
= bus
;
111 object_ref(OBJECT(bus
));
112 bus_add_child(bus
, dev
);
114 object_unref(OBJECT(dev
));
118 /* Create a new device. This only initializes the device state
119 structure and allows properties to be set. The device still needs
120 to be realized. See qdev-core.h. */
121 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
125 dev
= qdev_try_create(bus
, name
);
128 error_report("Unknown device '%s' for bus '%s'", name
,
129 object_get_typename(OBJECT(bus
)));
131 error_report("Unknown device '%s' for default sysbus", name
);
139 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
143 if (object_class_by_name(type
) == NULL
) {
146 dev
= DEVICE(object_new(type
));
152 /* Assert that the device really is a SysBusDevice before
153 * we put it onto the sysbus. Non-sysbus devices which aren't
154 * being put onto a bus should be created with object_new(TYPE_FOO),
155 * not qdev_create(NULL, TYPE_FOO).
157 g_assert(object_dynamic_cast(OBJECT(dev
), TYPE_SYS_BUS_DEVICE
));
158 bus
= sysbus_get_default();
161 qdev_set_parent_bus(dev
, bus
);
162 object_unref(OBJECT(dev
));
166 static QTAILQ_HEAD(, DeviceListener
) device_listeners
167 = QTAILQ_HEAD_INITIALIZER(device_listeners
);
169 enum ListenerDirection
{ Forward
, Reverse
};
171 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
173 DeviceListener *_listener; \
175 switch (_direction) { \
177 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
178 if (_listener->_callback) { \
179 _listener->_callback(_listener, ##_args); \
184 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
186 if (_listener->_callback) { \
187 _listener->_callback(_listener, ##_args); \
196 static int device_listener_add(DeviceState
*dev
, void *opaque
)
198 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
203 void device_listener_register(DeviceListener
*listener
)
205 QTAILQ_INSERT_TAIL(&device_listeners
, listener
, link
);
207 qbus_walk_children(sysbus_get_default(), NULL
, NULL
, device_listener_add
,
211 void device_listener_unregister(DeviceListener
*listener
)
213 QTAILQ_REMOVE(&device_listeners
, listener
, link
);
216 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
217 int required_for_version
)
219 assert(!dev
->realized
);
220 dev
->instance_id_alias
= alias_id
;
221 dev
->alias_required_for_version
= required_for_version
;
224 HotplugHandler
*qdev_get_machine_hotplug_handler(DeviceState
*dev
)
226 MachineState
*machine
;
228 Object
*m_obj
= qdev_get_machine();
230 if (object_dynamic_cast(m_obj
, TYPE_MACHINE
)) {
231 machine
= MACHINE(m_obj
);
232 mc
= MACHINE_GET_CLASS(machine
);
233 if (mc
->get_hotplug_handler
) {
234 return mc
->get_hotplug_handler(machine
, dev
);
241 HotplugHandler
*qdev_get_bus_hotplug_handler(DeviceState
*dev
)
243 if (dev
->parent_bus
) {
244 return dev
->parent_bus
->hotplug_handler
;
249 HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
251 HotplugHandler
*hotplug_ctrl
= qdev_get_machine_hotplug_handler(dev
);
253 if (hotplug_ctrl
== NULL
&& dev
->parent_bus
) {
254 hotplug_ctrl
= qdev_get_bus_hotplug_handler(dev
);
259 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
266 static int qbus_reset_one(BusState
*bus
, void *opaque
)
268 BusClass
*bc
= BUS_GET_CLASS(bus
);
275 void qdev_reset_all(DeviceState
*dev
)
277 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
280 void qdev_reset_all_fn(void *opaque
)
282 qdev_reset_all(DEVICE(opaque
));
285 void qbus_reset_all(BusState
*bus
)
287 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
290 void qbus_reset_all_fn(void *opaque
)
292 BusState
*bus
= opaque
;
296 /* can be used as ->unplug() callback for the simple cases */
297 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
298 DeviceState
*dev
, Error
**errp
)
300 object_property_set_bool(OBJECT(dev
), false, "realized", NULL
);
305 * Device properties should be set before calling this function. IRQs
306 * and MMIO regions should be connected/mapped after calling this
308 * On failure, report an error with error_report() and terminate the
309 * program. This is okay during machine creation. Don't use for
310 * hotplug, because there callers need to recover from failure.
311 * Exception: if you know the device's init() callback can't fail,
312 * then qdev_init_nofail() can't fail either, and is therefore usable
313 * even then. But relying on the device implementation that way is
314 * somewhat unclean, and best avoided.
316 void qdev_init_nofail(DeviceState
*dev
)
320 assert(!dev
->realized
);
322 object_ref(OBJECT(dev
));
323 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
325 error_reportf_err(err
, "Initialization of device %s failed: ",
326 object_get_typename(OBJECT(dev
)));
329 object_unref(OBJECT(dev
));
332 void qdev_machine_creation_done(void)
335 * ok, initial machine setup is done, starting from now we can
336 * only create hotpluggable devices
341 bool qdev_machine_modified(void)
343 return qdev_hot_added
|| qdev_hot_removed
;
346 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
348 return dev
->parent_bus
;
351 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
356 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
357 /* NULL is a valid and matchable name, otherwise do a normal
360 if ((!ngl
->name
&& !name
) ||
361 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
366 ngl
= g_malloc0(sizeof(*ngl
));
367 ngl
->name
= g_strdup(name
);
368 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
372 void qdev_init_gpio_in_named_with_opaque(DeviceState
*dev
,
373 qemu_irq_handler handler
,
375 const char *name
, int n
)
378 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
380 assert(gpio_list
->num_out
== 0 || !name
);
381 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
385 name
= "unnamed-gpio-in";
387 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
388 gchar
*propname
= g_strdup_printf("%s[%u]", name
, i
);
390 object_property_add_child(OBJECT(dev
), propname
,
391 OBJECT(gpio_list
->in
[i
]), &error_abort
);
395 gpio_list
->num_in
+= n
;
398 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
400 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
403 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
404 const char *name
, int n
)
407 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
409 assert(gpio_list
->num_in
== 0 || !name
);
412 name
= "unnamed-gpio-out";
414 memset(pins
, 0, sizeof(*pins
) * n
);
415 for (i
= 0; i
< n
; ++i
) {
416 gchar
*propname
= g_strdup_printf("%s[%u]", name
,
417 gpio_list
->num_out
+ i
);
419 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
421 object_property_allow_set_link
,
422 OBJ_PROP_LINK_STRONG
,
426 gpio_list
->num_out
+= n
;
429 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
431 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
434 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
436 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
438 assert(n
>= 0 && n
< gpio_list
->num_in
);
439 return gpio_list
->in
[n
];
442 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
444 return qdev_get_gpio_in_named(dev
, NULL
, n
);
447 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
450 char *propname
= g_strdup_printf("%s[%d]",
451 name
? name
: "unnamed-gpio-out", n
);
453 /* We need a name for object_property_set_link to work. If the
454 * object has a parent, object_property_add_child will come back
455 * with an error without doing anything. If it has none, it will
456 * never fail. So we can just call it with a NULL Error pointer.
458 object_property_add_child(container_get(qdev_get_machine(),
460 "non-qdev-gpio[*]", OBJECT(pin
), NULL
);
462 object_property_set_link(OBJECT(dev
), OBJECT(pin
), propname
, &error_abort
);
466 qemu_irq
qdev_get_gpio_out_connector(DeviceState
*dev
, const char *name
, int n
)
468 char *propname
= g_strdup_printf("%s[%d]",
469 name
? name
: "unnamed-gpio-out", n
);
471 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
477 /* disconnect a GPIO output, returning the disconnected input (if any) */
479 static qemu_irq
qdev_disconnect_gpio_out_named(DeviceState
*dev
,
480 const char *name
, int n
)
482 char *propname
= g_strdup_printf("%s[%d]",
483 name
? name
: "unnamed-gpio-out", n
);
485 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
488 object_property_set_link(OBJECT(dev
), NULL
, propname
, NULL
);
494 qemu_irq
qdev_intercept_gpio_out(DeviceState
*dev
, qemu_irq icpt
,
495 const char *name
, int n
)
497 qemu_irq disconnected
= qdev_disconnect_gpio_out_named(dev
, name
, n
);
498 qdev_connect_gpio_out_named(dev
, name
, n
, icpt
);
502 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
504 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
507 void qdev_pass_gpios(DeviceState
*dev
, DeviceState
*container
,
511 NamedGPIOList
*ngl
= qdev_get_named_gpio_list(dev
, name
);
513 for (i
= 0; i
< ngl
->num_in
; i
++) {
514 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-in";
515 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
517 object_property_add_alias(OBJECT(container
), propname
,
518 OBJECT(dev
), propname
,
522 for (i
= 0; i
< ngl
->num_out
; i
++) {
523 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-out";
524 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
526 object_property_add_alias(OBJECT(container
), propname
,
527 OBJECT(dev
), propname
,
531 QLIST_REMOVE(ngl
, node
);
532 QLIST_INSERT_HEAD(&container
->gpios
, ngl
, node
);
535 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
538 Object
*child
= object_resolve_path_component(OBJECT(dev
), name
);
540 bus
= (BusState
*)object_dynamic_cast(child
, TYPE_BUS
);
545 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
546 if (strcmp(name
, bus
->name
) == 0) {
553 int qdev_walk_children(DeviceState
*dev
,
554 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
555 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
562 err
= pre_devfn(dev
, opaque
);
568 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
569 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
570 post_devfn
, post_busfn
, opaque
);
577 err
= post_devfn(dev
, opaque
);
586 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
592 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
593 DeviceState
*dev
= kid
->child
;
595 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
599 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
600 ret
= qdev_find_recursive(child
, id
);
609 char *qdev_get_dev_path(DeviceState
*dev
)
613 if (!dev
|| !dev
->parent_bus
) {
617 bc
= BUS_GET_CLASS(dev
->parent_bus
);
618 if (bc
->get_dev_path
) {
619 return bc
->get_dev_path(dev
);
626 * Legacy property handling
629 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
,
630 const char *name
, void *opaque
,
633 DeviceState
*dev
= DEVICE(obj
);
634 Property
*prop
= opaque
;
639 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
640 visit_type_str(v
, name
, &ptr
, errp
);
644 * qdev_property_add_legacy:
645 * @dev: Device to add the property to.
646 * @prop: The qdev property definition.
647 * @errp: location to store error information.
649 * Add a legacy QOM property to @dev for qdev property @prop.
650 * On error, store error in @errp.
652 * Legacy properties are string versions of QOM properties. The format of
653 * the string depends on the property type. Legacy properties are only
654 * needed for "info qtree".
656 * Do not use this in new code! QOM Properties added through this interface
657 * will be given names in the "legacy" namespace.
659 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
664 /* Register pointer properties as legacy properties */
665 if (!prop
->info
->print
&& prop
->info
->get
) {
669 if (prop
->info
->create
) {
673 name
= g_strdup_printf("legacy-%s", prop
->name
);
674 object_property_add(OBJECT(dev
), name
, "str",
675 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
684 * qdev_property_add_static:
685 * @dev: Device to add the property to.
686 * @prop: The qdev property definition.
687 * @errp: location to store error information.
689 * Add a static QOM property to @dev for qdev property @prop.
690 * On error, store error in @errp. Static properties access data in a struct.
691 * The type of the QOM property is derived from prop->info.
693 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
696 Error
*local_err
= NULL
;
697 Object
*obj
= OBJECT(dev
);
699 if (prop
->info
->create
) {
700 prop
->info
->create(obj
, prop
, &local_err
);
703 * TODO qdev_prop_ptr does not have getters or setters. It must
704 * go now that it can be replaced with links. The test should be
705 * removed along with it: all static properties are read/write.
707 if (!prop
->info
->get
&& !prop
->info
->set
) {
710 object_property_add(obj
, prop
->name
, prop
->info
->name
,
711 prop
->info
->get
, prop
->info
->set
,
717 error_propagate(errp
, local_err
);
721 object_property_set_description(obj
, prop
->name
,
722 prop
->info
->description
,
725 if (prop
->set_default
) {
726 prop
->info
->set_default_value(obj
, prop
);
730 /* @qdev_alias_all_properties - Add alias properties to the source object for
731 * all qdev properties on the target DeviceState.
733 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
738 class = object_get_class(OBJECT(target
));
740 DeviceClass
*dc
= DEVICE_CLASS(class);
742 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
743 object_property_add_alias(source
, prop
->name
,
744 OBJECT(target
), prop
->name
,
747 class = object_class_get_parent(class);
748 } while (class != object_class_by_name(TYPE_DEVICE
));
751 static int qdev_add_hotpluggable_device(Object
*obj
, void *opaque
)
753 GSList
**list
= opaque
;
754 DeviceState
*dev
= (DeviceState
*)object_dynamic_cast(OBJECT(obj
),
761 if (dev
->realized
&& object_property_get_bool(obj
, "hotpluggable", NULL
)) {
762 *list
= g_slist_append(*list
, dev
);
768 GSList
*qdev_build_hotpluggable_device_list(Object
*peripheral
)
772 object_child_foreach(peripheral
, qdev_add_hotpluggable_device
, &list
);
777 static bool device_get_realized(Object
*obj
, Error
**errp
)
779 DeviceState
*dev
= DEVICE(obj
);
780 return dev
->realized
;
783 static bool check_only_migratable(Object
*obj
, Error
**err
)
785 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
787 if (!vmstate_check_only_migratable(dc
->vmsd
)) {
788 error_setg(err
, "Device %s is not migratable, but "
789 "--only-migratable was specified",
790 object_get_typename(obj
));
797 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
799 DeviceState
*dev
= DEVICE(obj
);
800 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
801 HotplugHandler
*hotplug_ctrl
;
803 Error
*local_err
= NULL
;
804 bool unattached_parent
= false;
805 static int unattached_count
;
807 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
808 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
812 if (value
&& !dev
->realized
) {
813 if (!check_only_migratable(obj
, &local_err
)) {
818 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
820 object_property_add_child(container_get(qdev_get_machine(),
822 name
, obj
, &error_abort
);
823 unattached_parent
= true;
827 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
829 hotplug_handler_pre_plug(hotplug_ctrl
, dev
, &local_err
);
830 if (local_err
!= NULL
) {
836 dc
->realize(dev
, &local_err
);
839 if (local_err
!= NULL
) {
843 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
846 * always free/re-initialize here since the value cannot be cleaned up
847 * in device_unrealize due to its usage later on in the unplug path
849 g_free(dev
->canonical_path
);
850 dev
->canonical_path
= object_get_canonical_path(OBJECT(dev
));
852 if (qdev_get_vmsd(dev
)) {
853 if (vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
854 dev
->instance_id_alias
,
855 dev
->alias_required_for_version
,
857 goto post_realize_fail
;
861 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
862 object_property_set_bool(OBJECT(bus
), true, "realized",
864 if (local_err
!= NULL
) {
865 goto child_realize_fail
;
868 if (dev
->hotplugged
) {
871 dev
->pending_deleted_event
= false;
874 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
875 if (local_err
!= NULL
) {
876 goto child_realize_fail
;
880 } else if (!value
&& dev
->realized
) {
881 Error
**local_errp
= NULL
;
882 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
883 local_errp
= local_err
? NULL
: &local_err
;
884 object_property_set_bool(OBJECT(bus
), false, "realized",
887 if (qdev_get_vmsd(dev
)) {
888 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
891 local_errp
= local_err
? NULL
: &local_err
;
892 dc
->unrealize(dev
, local_errp
);
894 dev
->pending_deleted_event
= true;
895 DEVICE_LISTENER_CALL(unrealize
, Reverse
, dev
);
898 if (local_err
!= NULL
) {
902 dev
->realized
= value
;
906 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
907 object_property_set_bool(OBJECT(bus
), false, "realized",
911 if (qdev_get_vmsd(dev
)) {
912 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
916 g_free(dev
->canonical_path
);
917 dev
->canonical_path
= NULL
;
919 dc
->unrealize(dev
, NULL
);
923 error_propagate(errp
, local_err
);
924 if (unattached_parent
) {
925 object_unparent(OBJECT(dev
));
930 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
932 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
933 DeviceState
*dev
= DEVICE(obj
);
935 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
936 qbus_is_hotpluggable(dev
->parent_bus
));
939 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
941 DeviceState
*dev
= DEVICE(obj
);
943 return dev
->hotplugged
;
946 static void device_initfn(Object
*obj
)
948 DeviceState
*dev
= DEVICE(obj
);
954 qdev_hot_added
= true;
957 dev
->instance_id_alias
= -1;
958 dev
->realized
= false;
960 object_property_add_bool(obj
, "realized",
961 device_get_realized
, device_set_realized
, NULL
);
962 object_property_add_bool(obj
, "hotpluggable",
963 device_get_hotpluggable
, NULL
, NULL
);
964 object_property_add_bool(obj
, "hotplugged",
965 device_get_hotplugged
, NULL
,
968 class = object_get_class(OBJECT(dev
));
970 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
971 qdev_property_add_legacy(dev
, prop
, &error_abort
);
972 qdev_property_add_static(dev
, prop
, &error_abort
);
974 class = object_class_get_parent(class);
975 } while (class != object_class_by_name(TYPE_DEVICE
));
977 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
978 (Object
**)&dev
->parent_bus
, NULL
, 0,
980 QLIST_INIT(&dev
->gpios
);
983 static void device_post_init(Object
*obj
)
986 * Note: ordered so that the user's global properties take
989 object_apply_compat_props(obj
);
990 qdev_prop_set_globals(DEVICE(obj
));
993 /* Unlink device from bus and free the structure. */
994 static void device_finalize(Object
*obj
)
996 NamedGPIOList
*ngl
, *next
;
998 DeviceState
*dev
= DEVICE(obj
);
1000 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1001 QLIST_REMOVE(ngl
, node
);
1002 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1005 /* ngl->out irqs are owned by the other end and should not be freed
1010 /* Only send event if the device had been completely realized */
1011 if (dev
->pending_deleted_event
) {
1012 g_assert(dev
->canonical_path
);
1014 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, dev
->canonical_path
);
1015 g_free(dev
->canonical_path
);
1016 dev
->canonical_path
= NULL
;
1019 qemu_opts_del(dev
->opts
);
1022 static void device_class_base_init(ObjectClass
*class, void *data
)
1024 DeviceClass
*klass
= DEVICE_CLASS(class);
1026 /* We explicitly look up properties in the superclasses,
1027 * so do not propagate them to the subclasses.
1029 klass
->props
= NULL
;
1032 static void device_unparent(Object
*obj
)
1034 DeviceState
*dev
= DEVICE(obj
);
1037 if (dev
->realized
) {
1038 object_property_set_bool(obj
, false, "realized", NULL
);
1040 while (dev
->num_child_bus
) {
1041 bus
= QLIST_FIRST(&dev
->child_bus
);
1042 object_unparent(OBJECT(bus
));
1044 if (dev
->parent_bus
) {
1045 bus_remove_child(dev
->parent_bus
, dev
);
1046 object_unref(OBJECT(dev
->parent_bus
));
1047 dev
->parent_bus
= NULL
;
1051 static void device_class_init(ObjectClass
*class, void *data
)
1053 DeviceClass
*dc
= DEVICE_CLASS(class);
1055 class->unparent
= device_unparent
;
1057 /* by default all devices were considered as hotpluggable,
1058 * so with intent to check it in generic qdev_unplug() /
1059 * device_set_realized() functions make every device
1060 * hotpluggable. Devices that shouldn't be hotpluggable,
1061 * should override it in their class_init()
1063 dc
->hotpluggable
= true;
1064 dc
->user_creatable
= true;
1067 void device_class_set_parent_reset(DeviceClass
*dc
,
1068 DeviceReset dev_reset
,
1069 DeviceReset
*parent_reset
)
1071 *parent_reset
= dc
->reset
;
1072 dc
->reset
= dev_reset
;
1075 void device_class_set_parent_realize(DeviceClass
*dc
,
1076 DeviceRealize dev_realize
,
1077 DeviceRealize
*parent_realize
)
1079 *parent_realize
= dc
->realize
;
1080 dc
->realize
= dev_realize
;
1083 void device_class_set_parent_unrealize(DeviceClass
*dc
,
1084 DeviceUnrealize dev_unrealize
,
1085 DeviceUnrealize
*parent_unrealize
)
1087 *parent_unrealize
= dc
->unrealize
;
1088 dc
->unrealize
= dev_unrealize
;
1091 void device_reset(DeviceState
*dev
)
1093 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1100 Object
*qdev_get_machine(void)
1105 dev
= container_get(object_get_root(), "/machine");
1111 static const TypeInfo device_type_info
= {
1112 .name
= TYPE_DEVICE
,
1113 .parent
= TYPE_OBJECT
,
1114 .instance_size
= sizeof(DeviceState
),
1115 .instance_init
= device_initfn
,
1116 .instance_post_init
= device_post_init
,
1117 .instance_finalize
= device_finalize
,
1118 .class_base_init
= device_class_base_init
,
1119 .class_init
= device_class_init
,
1121 .class_size
= sizeof(DeviceClass
),
1124 static void qdev_register_types(void)
1126 type_register_static(&device_type_info
);
1129 type_init(qdev_register_types
)