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 "qapi/error.h"
30 #include "qapi/qapi-events-qdev.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/visitor.h"
33 #include "qemu/error-report.h"
34 #include "qemu/option.h"
35 #include "hw/hotplug.h"
37 #include "hw/qdev-properties.h"
38 #include "hw/boards.h"
39 #include "hw/sysbus.h"
40 #include "migration/vmstate.h"
42 bool qdev_hotplug
= false;
43 static bool qdev_hot_added
= false;
44 bool qdev_hot_removed
= false;
46 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
48 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
52 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
56 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
57 if (kid
->child
== child
) {
60 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
61 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
65 /* This gives back ownership of kid->child back to us. */
66 object_property_del(OBJECT(bus
), name
, NULL
);
67 object_unref(OBJECT(kid
->child
));
74 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
77 BusChild
*kid
= g_malloc0(sizeof(*kid
));
80 kid
->index
= bus
->max_index
++;
82 object_ref(OBJECT(kid
->child
));
84 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
86 /* This transfers ownership of kid->child to the property. */
87 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
88 object_property_add_link(OBJECT(bus
), name
,
89 object_get_typename(OBJECT(child
)),
90 (Object
**)&kid
->child
,
91 NULL
, /* read-only property */
92 0, /* return ownership on prop deletion */
96 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
98 bool replugging
= dev
->parent_bus
!= NULL
;
101 /* Keep a reference to the device while it's not plugged into
102 * any bus, to avoid it potentially evaporating when it is
103 * dereffed in bus_remove_child().
105 object_ref(OBJECT(dev
));
106 bus_remove_child(dev
->parent_bus
, dev
);
107 object_unref(OBJECT(dev
->parent_bus
));
109 dev
->parent_bus
= bus
;
110 object_ref(OBJECT(bus
));
111 bus_add_child(bus
, dev
);
113 object_unref(OBJECT(dev
));
117 /* Create a new device. This only initializes the device state
118 structure and allows properties to be set. The device still needs
119 to be realized. See qdev-core.h. */
120 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
124 dev
= qdev_try_create(bus
, name
);
127 error_report("Unknown device '%s' for bus '%s'", name
,
128 object_get_typename(OBJECT(bus
)));
130 error_report("Unknown device '%s' for default sysbus", name
);
138 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
142 if (object_class_by_name(type
) == NULL
) {
145 dev
= DEVICE(object_new(type
));
151 /* Assert that the device really is a SysBusDevice before
152 * we put it onto the sysbus. Non-sysbus devices which aren't
153 * being put onto a bus should be created with object_new(TYPE_FOO),
154 * not qdev_create(NULL, TYPE_FOO).
156 g_assert(object_dynamic_cast(OBJECT(dev
), TYPE_SYS_BUS_DEVICE
));
157 bus
= sysbus_get_default();
160 qdev_set_parent_bus(dev
, bus
);
161 object_unref(OBJECT(dev
));
165 static QTAILQ_HEAD(, DeviceListener
) device_listeners
166 = QTAILQ_HEAD_INITIALIZER(device_listeners
);
168 enum ListenerDirection
{ Forward
, Reverse
};
170 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
172 DeviceListener *_listener; \
174 switch (_direction) { \
176 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
177 if (_listener->_callback) { \
178 _listener->_callback(_listener, ##_args); \
183 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
185 if (_listener->_callback) { \
186 _listener->_callback(_listener, ##_args); \
195 static int device_listener_add(DeviceState
*dev
, void *opaque
)
197 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
202 void device_listener_register(DeviceListener
*listener
)
204 QTAILQ_INSERT_TAIL(&device_listeners
, listener
, link
);
206 qbus_walk_children(sysbus_get_default(), NULL
, NULL
, device_listener_add
,
210 void device_listener_unregister(DeviceListener
*listener
)
212 QTAILQ_REMOVE(&device_listeners
, listener
, link
);
215 bool qdev_should_hide_device(QemuOpts
*opts
)
218 DeviceListener
*listener
;
220 QTAILQ_FOREACH(listener
, &device_listeners
, link
) {
221 if (listener
->should_be_hidden
) {
223 * should_be_hidden_will return
224 * 1 if device matches opts and it should be hidden
225 * 0 if device matches opts and should not be hidden
226 * -1 if device doesn't match ops
228 rc
= listener
->should_be_hidden(listener
, opts
);
239 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
240 int required_for_version
)
242 assert(!dev
->realized
);
243 dev
->instance_id_alias
= alias_id
;
244 dev
->alias_required_for_version
= required_for_version
;
247 HotplugHandler
*qdev_get_machine_hotplug_handler(DeviceState
*dev
)
249 MachineState
*machine
;
251 Object
*m_obj
= qdev_get_machine();
253 if (object_dynamic_cast(m_obj
, TYPE_MACHINE
)) {
254 machine
= MACHINE(m_obj
);
255 mc
= MACHINE_GET_CLASS(machine
);
256 if (mc
->get_hotplug_handler
) {
257 return mc
->get_hotplug_handler(machine
, dev
);
264 bool qdev_hotplug_allowed(DeviceState
*dev
, Error
**errp
)
266 MachineState
*machine
;
268 Object
*m_obj
= qdev_get_machine();
270 if (object_dynamic_cast(m_obj
, TYPE_MACHINE
)) {
271 machine
= MACHINE(m_obj
);
272 mc
= MACHINE_GET_CLASS(machine
);
273 if (mc
->hotplug_allowed
) {
274 return mc
->hotplug_allowed(machine
, dev
, errp
);
281 HotplugHandler
*qdev_get_bus_hotplug_handler(DeviceState
*dev
)
283 if (dev
->parent_bus
) {
284 return dev
->parent_bus
->hotplug_handler
;
289 HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
291 HotplugHandler
*hotplug_ctrl
= qdev_get_machine_hotplug_handler(dev
);
293 if (hotplug_ctrl
== NULL
&& dev
->parent_bus
) {
294 hotplug_ctrl
= qdev_get_bus_hotplug_handler(dev
);
299 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
306 static int qbus_reset_one(BusState
*bus
, void *opaque
)
308 BusClass
*bc
= BUS_GET_CLASS(bus
);
315 void qdev_reset_all(DeviceState
*dev
)
317 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
320 void qdev_reset_all_fn(void *opaque
)
322 qdev_reset_all(DEVICE(opaque
));
325 void qbus_reset_all(BusState
*bus
)
327 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
330 void qbus_reset_all_fn(void *opaque
)
332 BusState
*bus
= opaque
;
336 /* can be used as ->unplug() callback for the simple cases */
337 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
338 DeviceState
*dev
, Error
**errp
)
340 object_property_set_bool(OBJECT(dev
), false, "realized", NULL
);
345 * Device properties should be set before calling this function. IRQs
346 * and MMIO regions should be connected/mapped after calling this
348 * On failure, report an error with error_report() and terminate the
349 * program. This is okay during machine creation. Don't use for
350 * hotplug, because there callers need to recover from failure.
351 * Exception: if you know the device's init() callback can't fail,
352 * then qdev_init_nofail() can't fail either, and is therefore usable
353 * even then. But relying on the device implementation that way is
354 * somewhat unclean, and best avoided.
356 void qdev_init_nofail(DeviceState
*dev
)
360 assert(!dev
->realized
);
362 object_ref(OBJECT(dev
));
363 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
365 error_reportf_err(err
, "Initialization of device %s failed: ",
366 object_get_typename(OBJECT(dev
)));
369 object_unref(OBJECT(dev
));
372 void qdev_machine_creation_done(void)
375 * ok, initial machine setup is done, starting from now we can
376 * only create hotpluggable devices
381 bool qdev_machine_modified(void)
383 return qdev_hot_added
|| qdev_hot_removed
;
386 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
388 return dev
->parent_bus
;
391 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
396 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
397 /* NULL is a valid and matchable name. */
398 if (g_strcmp0(name
, ngl
->name
) == 0) {
403 ngl
= g_malloc0(sizeof(*ngl
));
404 ngl
->name
= g_strdup(name
);
405 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
409 void qdev_init_gpio_in_named_with_opaque(DeviceState
*dev
,
410 qemu_irq_handler handler
,
412 const char *name
, int n
)
415 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
417 assert(gpio_list
->num_out
== 0 || !name
);
418 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
422 name
= "unnamed-gpio-in";
424 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
425 gchar
*propname
= g_strdup_printf("%s[%u]", name
, i
);
427 object_property_add_child(OBJECT(dev
), propname
,
428 OBJECT(gpio_list
->in
[i
]), &error_abort
);
432 gpio_list
->num_in
+= n
;
435 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
437 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
440 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
441 const char *name
, int n
)
444 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
446 assert(gpio_list
->num_in
== 0 || !name
);
449 name
= "unnamed-gpio-out";
451 memset(pins
, 0, sizeof(*pins
) * n
);
452 for (i
= 0; i
< n
; ++i
) {
453 gchar
*propname
= g_strdup_printf("%s[%u]", name
,
454 gpio_list
->num_out
+ i
);
456 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
458 object_property_allow_set_link
,
459 OBJ_PROP_LINK_STRONG
,
463 gpio_list
->num_out
+= n
;
466 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
468 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
471 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
473 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
475 assert(n
>= 0 && n
< gpio_list
->num_in
);
476 return gpio_list
->in
[n
];
479 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
481 return qdev_get_gpio_in_named(dev
, NULL
, n
);
484 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
487 char *propname
= g_strdup_printf("%s[%d]",
488 name
? name
: "unnamed-gpio-out", n
);
490 /* We need a name for object_property_set_link to work. If the
491 * object has a parent, object_property_add_child will come back
492 * with an error without doing anything. If it has none, it will
493 * never fail. So we can just call it with a NULL Error pointer.
495 object_property_add_child(container_get(qdev_get_machine(),
497 "non-qdev-gpio[*]", OBJECT(pin
), NULL
);
499 object_property_set_link(OBJECT(dev
), OBJECT(pin
), propname
, &error_abort
);
503 qemu_irq
qdev_get_gpio_out_connector(DeviceState
*dev
, const char *name
, int n
)
505 char *propname
= g_strdup_printf("%s[%d]",
506 name
? name
: "unnamed-gpio-out", n
);
508 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
514 /* disconnect a GPIO output, returning the disconnected input (if any) */
516 static qemu_irq
qdev_disconnect_gpio_out_named(DeviceState
*dev
,
517 const char *name
, int n
)
519 char *propname
= g_strdup_printf("%s[%d]",
520 name
? name
: "unnamed-gpio-out", n
);
522 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
525 object_property_set_link(OBJECT(dev
), NULL
, propname
, NULL
);
531 qemu_irq
qdev_intercept_gpio_out(DeviceState
*dev
, qemu_irq icpt
,
532 const char *name
, int n
)
534 qemu_irq disconnected
= qdev_disconnect_gpio_out_named(dev
, name
, n
);
535 qdev_connect_gpio_out_named(dev
, name
, n
, icpt
);
539 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
541 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
544 void qdev_pass_gpios(DeviceState
*dev
, DeviceState
*container
,
548 NamedGPIOList
*ngl
= qdev_get_named_gpio_list(dev
, name
);
550 for (i
= 0; i
< ngl
->num_in
; i
++) {
551 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-in";
552 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
554 object_property_add_alias(OBJECT(container
), propname
,
555 OBJECT(dev
), propname
,
559 for (i
= 0; i
< ngl
->num_out
; i
++) {
560 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-out";
561 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
563 object_property_add_alias(OBJECT(container
), propname
,
564 OBJECT(dev
), propname
,
568 QLIST_REMOVE(ngl
, node
);
569 QLIST_INSERT_HEAD(&container
->gpios
, ngl
, node
);
572 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
575 Object
*child
= object_resolve_path_component(OBJECT(dev
), name
);
577 bus
= (BusState
*)object_dynamic_cast(child
, TYPE_BUS
);
582 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
583 if (strcmp(name
, bus
->name
) == 0) {
590 int qdev_walk_children(DeviceState
*dev
,
591 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
592 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
599 err
= pre_devfn(dev
, opaque
);
605 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
606 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
607 post_devfn
, post_busfn
, opaque
);
614 err
= post_devfn(dev
, opaque
);
623 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
629 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
630 DeviceState
*dev
= kid
->child
;
632 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
636 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
637 ret
= qdev_find_recursive(child
, id
);
646 char *qdev_get_dev_path(DeviceState
*dev
)
650 if (!dev
|| !dev
->parent_bus
) {
654 bc
= BUS_GET_CLASS(dev
->parent_bus
);
655 if (bc
->get_dev_path
) {
656 return bc
->get_dev_path(dev
);
663 * Legacy property handling
666 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
,
667 const char *name
, void *opaque
,
670 DeviceState
*dev
= DEVICE(obj
);
671 Property
*prop
= opaque
;
676 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
677 visit_type_str(v
, name
, &ptr
, errp
);
681 * qdev_property_add_legacy:
682 * @dev: Device to add the property to.
683 * @prop: The qdev property definition.
684 * @errp: location to store error information.
686 * Add a legacy QOM property to @dev for qdev property @prop.
687 * On error, store error in @errp.
689 * Legacy properties are string versions of QOM properties. The format of
690 * the string depends on the property type. Legacy properties are only
691 * needed for "info qtree".
693 * Do not use this in new code! QOM Properties added through this interface
694 * will be given names in the "legacy" namespace.
696 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
701 /* Register pointer properties as legacy properties */
702 if (!prop
->info
->print
&& prop
->info
->get
) {
706 if (prop
->info
->create
) {
710 name
= g_strdup_printf("legacy-%s", prop
->name
);
711 object_property_add(OBJECT(dev
), name
, "str",
712 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
721 * qdev_property_add_static:
722 * @dev: Device to add the property to.
723 * @prop: The qdev property definition.
724 * @errp: location to store error information.
726 * Add a static QOM property to @dev for qdev property @prop.
727 * On error, store error in @errp. Static properties access data in a struct.
728 * The type of the QOM property is derived from prop->info.
730 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
733 Error
*local_err
= NULL
;
734 Object
*obj
= OBJECT(dev
);
736 if (prop
->info
->create
) {
737 prop
->info
->create(obj
, prop
, &local_err
);
739 object_property_add(obj
, prop
->name
, prop
->info
->name
,
740 prop
->info
->get
, prop
->info
->set
,
746 error_propagate(errp
, local_err
);
750 object_property_set_description(obj
, prop
->name
,
751 prop
->info
->description
,
754 if (prop
->set_default
) {
755 prop
->info
->set_default_value(obj
, prop
);
759 /* @qdev_alias_all_properties - Add alias properties to the source object for
760 * all qdev properties on the target DeviceState.
762 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
767 class = object_get_class(OBJECT(target
));
769 DeviceClass
*dc
= DEVICE_CLASS(class);
771 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
772 object_property_add_alias(source
, prop
->name
,
773 OBJECT(target
), prop
->name
,
776 class = object_class_get_parent(class);
777 } while (class != object_class_by_name(TYPE_DEVICE
));
780 static int qdev_add_hotpluggable_device(Object
*obj
, void *opaque
)
782 GSList
**list
= opaque
;
783 DeviceState
*dev
= (DeviceState
*)object_dynamic_cast(OBJECT(obj
),
790 if (dev
->realized
&& object_property_get_bool(obj
, "hotpluggable", NULL
)) {
791 *list
= g_slist_append(*list
, dev
);
797 GSList
*qdev_build_hotpluggable_device_list(Object
*peripheral
)
801 object_child_foreach(peripheral
, qdev_add_hotpluggable_device
, &list
);
806 static bool device_get_realized(Object
*obj
, Error
**errp
)
808 DeviceState
*dev
= DEVICE(obj
);
809 return dev
->realized
;
812 static bool check_only_migratable(Object
*obj
, Error
**errp
)
814 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
816 if (!vmstate_check_only_migratable(dc
->vmsd
)) {
817 error_setg(errp
, "Device %s is not migratable, but "
818 "--only-migratable was specified",
819 object_get_typename(obj
));
826 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
828 DeviceState
*dev
= DEVICE(obj
);
829 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
830 HotplugHandler
*hotplug_ctrl
;
832 Error
*local_err
= NULL
;
833 bool unattached_parent
= false;
834 static int unattached_count
;
836 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
837 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
841 if (value
&& !dev
->realized
) {
842 if (!check_only_migratable(obj
, &local_err
)) {
847 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
849 object_property_add_child(container_get(qdev_get_machine(),
851 name
, obj
, &error_abort
);
852 unattached_parent
= true;
856 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
858 hotplug_handler_pre_plug(hotplug_ctrl
, dev
, &local_err
);
859 if (local_err
!= NULL
) {
865 dc
->realize(dev
, &local_err
);
866 if (local_err
!= NULL
) {
871 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
874 * always free/re-initialize here since the value cannot be cleaned up
875 * in device_unrealize due to its usage later on in the unplug path
877 g_free(dev
->canonical_path
);
878 dev
->canonical_path
= object_get_canonical_path(OBJECT(dev
));
880 if (qdev_get_vmsd(dev
)) {
881 if (vmstate_register_with_alias_id(VMSTATE_IF(dev
),
882 VMSTATE_INSTANCE_ID_ANY
,
883 qdev_get_vmsd(dev
), dev
,
884 dev
->instance_id_alias
,
885 dev
->alias_required_for_version
,
887 goto post_realize_fail
;
891 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
892 object_property_set_bool(OBJECT(bus
), true, "realized",
894 if (local_err
!= NULL
) {
895 goto child_realize_fail
;
898 if (dev
->hotplugged
) {
901 dev
->pending_deleted_event
= false;
904 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
905 if (local_err
!= NULL
) {
906 goto child_realize_fail
;
910 } else if (!value
&& dev
->realized
) {
911 /* We want local_err to track only the first error */
912 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
913 object_property_set_bool(OBJECT(bus
), false, "realized",
914 local_err
? NULL
: &local_err
);
916 if (qdev_get_vmsd(dev
)) {
917 vmstate_unregister(VMSTATE_IF(dev
), qdev_get_vmsd(dev
), dev
);
920 dc
->unrealize(dev
, local_err
? NULL
: &local_err
);
922 dev
->pending_deleted_event
= true;
923 DEVICE_LISTENER_CALL(unrealize
, Reverse
, dev
);
925 if (local_err
!= NULL
) {
930 assert(local_err
== NULL
);
931 dev
->realized
= value
;
935 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
936 object_property_set_bool(OBJECT(bus
), false, "realized",
940 if (qdev_get_vmsd(dev
)) {
941 vmstate_unregister(VMSTATE_IF(dev
), qdev_get_vmsd(dev
), dev
);
945 g_free(dev
->canonical_path
);
946 dev
->canonical_path
= NULL
;
948 dc
->unrealize(dev
, NULL
);
952 error_propagate(errp
, local_err
);
953 if (unattached_parent
) {
954 object_unparent(OBJECT(dev
));
959 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
961 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
962 DeviceState
*dev
= DEVICE(obj
);
964 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
965 qbus_is_hotpluggable(dev
->parent_bus
));
968 static bool device_get_hotplugged(Object
*obj
, Error
**errp
)
970 DeviceState
*dev
= DEVICE(obj
);
972 return dev
->hotplugged
;
975 static void device_initfn(Object
*obj
)
977 DeviceState
*dev
= DEVICE(obj
);
983 qdev_hot_added
= true;
986 dev
->instance_id_alias
= -1;
987 dev
->realized
= false;
988 dev
->allow_unplug_during_migration
= false;
990 object_property_add_bool(obj
, "realized",
991 device_get_realized
, device_set_realized
, NULL
);
992 object_property_add_bool(obj
, "hotpluggable",
993 device_get_hotpluggable
, NULL
, NULL
);
994 object_property_add_bool(obj
, "hotplugged",
995 device_get_hotplugged
, NULL
,
998 class = object_get_class(OBJECT(dev
));
1000 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
1001 qdev_property_add_legacy(dev
, prop
, &error_abort
);
1002 qdev_property_add_static(dev
, prop
, &error_abort
);
1004 class = object_class_get_parent(class);
1005 } while (class != object_class_by_name(TYPE_DEVICE
));
1007 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1008 (Object
**)&dev
->parent_bus
, NULL
, 0,
1010 QLIST_INIT(&dev
->gpios
);
1013 static void device_post_init(Object
*obj
)
1016 * Note: ordered so that the user's global properties take
1019 object_apply_compat_props(obj
);
1020 qdev_prop_set_globals(DEVICE(obj
));
1023 /* Unlink device from bus and free the structure. */
1024 static void device_finalize(Object
*obj
)
1026 NamedGPIOList
*ngl
, *next
;
1028 DeviceState
*dev
= DEVICE(obj
);
1030 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1031 QLIST_REMOVE(ngl
, node
);
1032 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1035 /* ngl->out irqs are owned by the other end and should not be freed
1040 /* Only send event if the device had been completely realized */
1041 if (dev
->pending_deleted_event
) {
1042 g_assert(dev
->canonical_path
);
1044 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, dev
->canonical_path
);
1045 g_free(dev
->canonical_path
);
1046 dev
->canonical_path
= NULL
;
1049 qemu_opts_del(dev
->opts
);
1052 static void device_class_base_init(ObjectClass
*class, void *data
)
1054 DeviceClass
*klass
= DEVICE_CLASS(class);
1056 /* We explicitly look up properties in the superclasses,
1057 * so do not propagate them to the subclasses.
1059 klass
->props
= NULL
;
1062 static void device_unparent(Object
*obj
)
1064 DeviceState
*dev
= DEVICE(obj
);
1067 if (dev
->realized
) {
1068 object_property_set_bool(obj
, false, "realized", NULL
);
1070 while (dev
->num_child_bus
) {
1071 bus
= QLIST_FIRST(&dev
->child_bus
);
1072 object_unparent(OBJECT(bus
));
1074 if (dev
->parent_bus
) {
1075 bus_remove_child(dev
->parent_bus
, dev
);
1076 object_unref(OBJECT(dev
->parent_bus
));
1077 dev
->parent_bus
= NULL
;
1082 device_vmstate_if_get_id(VMStateIf
*obj
)
1084 DeviceState
*dev
= DEVICE(obj
);
1086 return qdev_get_dev_path(dev
);
1089 static void device_class_init(ObjectClass
*class, void *data
)
1091 DeviceClass
*dc
= DEVICE_CLASS(class);
1092 VMStateIfClass
*vc
= VMSTATE_IF_CLASS(class);
1094 class->unparent
= device_unparent
;
1096 /* by default all devices were considered as hotpluggable,
1097 * so with intent to check it in generic qdev_unplug() /
1098 * device_set_realized() functions make every device
1099 * hotpluggable. Devices that shouldn't be hotpluggable,
1100 * should override it in their class_init()
1102 dc
->hotpluggable
= true;
1103 dc
->user_creatable
= true;
1104 vc
->get_id
= device_vmstate_if_get_id
;
1107 void device_class_set_parent_reset(DeviceClass
*dc
,
1108 DeviceReset dev_reset
,
1109 DeviceReset
*parent_reset
)
1111 *parent_reset
= dc
->reset
;
1112 dc
->reset
= dev_reset
;
1115 void device_class_set_parent_realize(DeviceClass
*dc
,
1116 DeviceRealize dev_realize
,
1117 DeviceRealize
*parent_realize
)
1119 *parent_realize
= dc
->realize
;
1120 dc
->realize
= dev_realize
;
1123 void device_class_set_parent_unrealize(DeviceClass
*dc
,
1124 DeviceUnrealize dev_unrealize
,
1125 DeviceUnrealize
*parent_unrealize
)
1127 *parent_unrealize
= dc
->unrealize
;
1128 dc
->unrealize
= dev_unrealize
;
1131 void device_reset(DeviceState
*dev
)
1133 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1140 Object
*qdev_get_machine(void)
1145 dev
= container_get(object_get_root(), "/machine");
1151 static const TypeInfo device_type_info
= {
1152 .name
= TYPE_DEVICE
,
1153 .parent
= TYPE_OBJECT
,
1154 .instance_size
= sizeof(DeviceState
),
1155 .instance_init
= device_initfn
,
1156 .instance_post_init
= device_post_init
,
1157 .instance_finalize
= device_finalize
,
1158 .class_base_init
= device_class_base_init
,
1159 .class_init
= device_class_init
,
1161 .class_size
= sizeof(DeviceClass
),
1162 .interfaces
= (InterfaceInfo
[]) {
1163 { TYPE_VMSTATE_IF
},
1168 static void qdev_register_types(void)
1170 type_register_static(&device_type_info
);
1173 type_init(qdev_register_types
)