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 "hw/qdev-clock.h"
41 #include "migration/vmstate.h"
44 bool qdev_hotplug
= false;
45 static bool qdev_hot_added
= false;
46 bool qdev_hot_removed
= false;
48 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
50 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
54 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
58 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
59 if (kid
->child
== child
) {
62 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
63 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
67 /* This gives back ownership of kid->child back to us. */
68 object_property_del(OBJECT(bus
), name
);
69 object_unref(OBJECT(kid
->child
));
76 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
79 BusChild
*kid
= g_malloc0(sizeof(*kid
));
82 kid
->index
= bus
->max_index
++;
84 object_ref(OBJECT(kid
->child
));
86 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
88 /* This transfers ownership of kid->child to the property. */
89 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
90 object_property_add_link(OBJECT(bus
), name
,
91 object_get_typename(OBJECT(child
)),
92 (Object
**)&kid
->child
,
93 NULL
, /* read-only property */
97 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
99 BusState
*old_parent_bus
= dev
->parent_bus
;
100 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
102 assert(dc
->bus_type
&& object_dynamic_cast(OBJECT(bus
), dc
->bus_type
));
104 if (old_parent_bus
) {
105 trace_qdev_update_parent_bus(dev
, object_get_typename(OBJECT(dev
)),
106 old_parent_bus
, object_get_typename(OBJECT(old_parent_bus
)),
107 OBJECT(bus
), object_get_typename(OBJECT(bus
)));
109 * Keep a reference to the device while it's not plugged into
110 * any bus, to avoid it potentially evaporating when it is
111 * dereffed in bus_remove_child().
112 * Also keep the ref of the parent bus until the end, so that
113 * we can safely call resettable_change_parent() below.
115 object_ref(OBJECT(dev
));
116 bus_remove_child(dev
->parent_bus
, dev
);
118 dev
->parent_bus
= bus
;
119 object_ref(OBJECT(bus
));
120 bus_add_child(bus
, dev
);
122 resettable_change_parent(OBJECT(dev
), OBJECT(bus
),
123 OBJECT(old_parent_bus
));
125 if (old_parent_bus
) {
126 object_unref(OBJECT(old_parent_bus
));
127 object_unref(OBJECT(dev
));
132 * Create a device on the heap.
133 * A type @name must exist.
134 * This only initializes the device state structure and allows
135 * properties to be set. The device still needs to be realized. See
138 DeviceState
*qdev_new(const char *name
)
140 if (!object_class_by_name(name
)) {
141 module_load_qom_one(name
);
143 return DEVICE(object_new(name
));
147 * Try to create a device on the heap.
148 * This is like qdev_new(), except it returns %NULL when type @name
151 DeviceState
*qdev_try_new(const char *name
)
153 if (!module_object_class_by_name(name
)) {
156 return DEVICE(object_new(name
));
159 static QTAILQ_HEAD(, DeviceListener
) device_listeners
160 = QTAILQ_HEAD_INITIALIZER(device_listeners
);
162 enum ListenerDirection
{ Forward
, Reverse
};
164 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
166 DeviceListener *_listener; \
168 switch (_direction) { \
170 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
171 if (_listener->_callback) { \
172 _listener->_callback(_listener, ##_args); \
177 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
179 if (_listener->_callback) { \
180 _listener->_callback(_listener, ##_args); \
189 static int device_listener_add(DeviceState
*dev
, void *opaque
)
191 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
196 void device_listener_register(DeviceListener
*listener
)
198 QTAILQ_INSERT_TAIL(&device_listeners
, listener
, link
);
200 qbus_walk_children(sysbus_get_default(), NULL
, NULL
, device_listener_add
,
204 void device_listener_unregister(DeviceListener
*listener
)
206 QTAILQ_REMOVE(&device_listeners
, listener
, link
);
209 bool qdev_should_hide_device(QemuOpts
*opts
)
212 DeviceListener
*listener
;
214 QTAILQ_FOREACH(listener
, &device_listeners
, link
) {
215 if (listener
->should_be_hidden
) {
217 * should_be_hidden_will return
218 * 1 if device matches opts and it should be hidden
219 * 0 if device matches opts and should not be hidden
220 * -1 if device doesn't match ops
222 rc
= listener
->should_be_hidden(listener
, opts
);
233 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
234 int required_for_version
)
236 assert(!dev
->realized
);
237 dev
->instance_id_alias
= alias_id
;
238 dev
->alias_required_for_version
= required_for_version
;
241 HotplugHandler
*qdev_get_machine_hotplug_handler(DeviceState
*dev
)
243 MachineState
*machine
;
245 Object
*m_obj
= qdev_get_machine();
247 if (object_dynamic_cast(m_obj
, TYPE_MACHINE
)) {
248 machine
= MACHINE(m_obj
);
249 mc
= MACHINE_GET_CLASS(machine
);
250 if (mc
->get_hotplug_handler
) {
251 return mc
->get_hotplug_handler(machine
, dev
);
258 bool qdev_hotplug_allowed(DeviceState
*dev
, Error
**errp
)
260 MachineState
*machine
;
262 Object
*m_obj
= qdev_get_machine();
264 if (object_dynamic_cast(m_obj
, TYPE_MACHINE
)) {
265 machine
= MACHINE(m_obj
);
266 mc
= MACHINE_GET_CLASS(machine
);
267 if (mc
->hotplug_allowed
) {
268 return mc
->hotplug_allowed(machine
, dev
, errp
);
275 HotplugHandler
*qdev_get_bus_hotplug_handler(DeviceState
*dev
)
277 if (dev
->parent_bus
) {
278 return dev
->parent_bus
->hotplug_handler
;
283 HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
285 HotplugHandler
*hotplug_ctrl
= qdev_get_machine_hotplug_handler(dev
);
287 if (hotplug_ctrl
== NULL
&& dev
->parent_bus
) {
288 hotplug_ctrl
= qdev_get_bus_hotplug_handler(dev
);
293 static int qdev_prereset(DeviceState
*dev
, void *opaque
)
295 trace_qdev_reset_tree(dev
, object_get_typename(OBJECT(dev
)));
299 static int qbus_prereset(BusState
*bus
, void *opaque
)
301 trace_qbus_reset_tree(bus
, object_get_typename(OBJECT(bus
)));
305 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
307 device_legacy_reset(dev
);
312 static int qbus_reset_one(BusState
*bus
, void *opaque
)
314 BusClass
*bc
= BUS_GET_CLASS(bus
);
315 trace_qbus_reset(bus
, object_get_typename(OBJECT(bus
)));
322 void qdev_reset_all(DeviceState
*dev
)
324 trace_qdev_reset_all(dev
, object_get_typename(OBJECT(dev
)));
325 qdev_walk_children(dev
, qdev_prereset
, qbus_prereset
,
326 qdev_reset_one
, qbus_reset_one
, NULL
);
329 void qdev_reset_all_fn(void *opaque
)
331 qdev_reset_all(DEVICE(opaque
));
334 void qbus_reset_all(BusState
*bus
)
336 trace_qbus_reset_all(bus
, object_get_typename(OBJECT(bus
)));
337 qbus_walk_children(bus
, qdev_prereset
, qbus_prereset
,
338 qdev_reset_one
, qbus_reset_one
, NULL
);
341 void qbus_reset_all_fn(void *opaque
)
343 BusState
*bus
= opaque
;
347 void device_cold_reset(DeviceState
*dev
)
349 resettable_reset(OBJECT(dev
), RESET_TYPE_COLD
);
352 bool device_is_in_reset(DeviceState
*dev
)
354 return resettable_is_in_reset(OBJECT(dev
));
357 static ResettableState
*device_get_reset_state(Object
*obj
)
359 DeviceState
*dev
= DEVICE(obj
);
363 static void device_reset_child_foreach(Object
*obj
, ResettableChildCallback cb
,
364 void *opaque
, ResetType type
)
366 DeviceState
*dev
= DEVICE(obj
);
369 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
370 cb(OBJECT(bus
), opaque
, type
);
374 /* can be used as ->unplug() callback for the simple cases */
375 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
376 DeviceState
*dev
, Error
**errp
)
383 * @dev must not be plugged into a bus.
384 * If @bus, plug @dev into @bus. This takes a reference to @dev.
385 * If @dev has no QOM parent, make one up, taking another reference.
386 * On success, return true.
387 * On failure, store an error through @errp and return false.
389 bool qdev_realize(DeviceState
*dev
, BusState
*bus
, Error
**errp
)
393 assert(!dev
->realized
&& !dev
->parent_bus
);
396 qdev_set_parent_bus(dev
, bus
);
398 assert(!DEVICE_GET_CLASS(dev
)->bus_type
);
401 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
403 error_propagate(errp
, err
);
409 * Realize @dev and drop a reference.
410 * This is like qdev_realize(), except the caller must hold a
411 * (private) reference, which is dropped on return regardless of
412 * success or failure. Intended use:
415 * qdev_realize_and_unref(dev, bus, errp);
416 * Now @dev can go away without further ado.
418 bool qdev_realize_and_unref(DeviceState
*dev
, BusState
*bus
, Error
**errp
)
422 ret
= qdev_realize(dev
, bus
, errp
);
423 object_unref(OBJECT(dev
));
427 void qdev_unrealize(DeviceState
*dev
)
429 object_property_set_bool(OBJECT(dev
), false, "realized", &error_abort
);
432 static int qdev_assert_realized_properly(Object
*obj
, void *opaque
)
434 DeviceState
*dev
= DEVICE(object_dynamic_cast(obj
, TYPE_DEVICE
));
438 dc
= DEVICE_GET_CLASS(dev
);
439 assert(dev
->realized
);
440 assert(dev
->parent_bus
|| !dc
->bus_type
);
445 void qdev_machine_creation_done(void)
448 * ok, initial machine setup is done, starting from now we can
449 * only create hotpluggable devices
453 object_child_foreach_recursive(object_get_root(),
454 qdev_assert_realized_properly
, NULL
);
457 bool qdev_machine_modified(void)
459 return qdev_hot_added
|| qdev_hot_removed
;
462 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
464 return dev
->parent_bus
;
467 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
472 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
473 /* NULL is a valid and matchable name. */
474 if (g_strcmp0(name
, ngl
->name
) == 0) {
479 ngl
= g_malloc0(sizeof(*ngl
));
480 ngl
->name
= g_strdup(name
);
481 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
485 void qdev_init_gpio_in_named_with_opaque(DeviceState
*dev
,
486 qemu_irq_handler handler
,
488 const char *name
, int n
)
491 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
493 assert(gpio_list
->num_out
== 0 || !name
);
494 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
498 name
= "unnamed-gpio-in";
500 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
501 gchar
*propname
= g_strdup_printf("%s[%u]", name
, i
);
503 object_property_add_child(OBJECT(dev
), propname
,
504 OBJECT(gpio_list
->in
[i
]));
508 gpio_list
->num_in
+= n
;
511 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
513 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
516 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
517 const char *name
, int n
)
520 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
522 assert(gpio_list
->num_in
== 0 || !name
);
525 name
= "unnamed-gpio-out";
527 memset(pins
, 0, sizeof(*pins
) * n
);
528 for (i
= 0; i
< n
; ++i
) {
529 gchar
*propname
= g_strdup_printf("%s[%u]", name
,
530 gpio_list
->num_out
+ i
);
532 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
534 object_property_allow_set_link
,
535 OBJ_PROP_LINK_STRONG
);
538 gpio_list
->num_out
+= n
;
541 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
543 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
546 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
548 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
550 assert(n
>= 0 && n
< gpio_list
->num_in
);
551 return gpio_list
->in
[n
];
554 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
556 return qdev_get_gpio_in_named(dev
, NULL
, n
);
559 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
562 char *propname
= g_strdup_printf("%s[%d]",
563 name
? name
: "unnamed-gpio-out", n
);
564 if (pin
&& !OBJECT(pin
)->parent
) {
565 /* We need a name for object_property_set_link to work */
566 object_property_add_child(container_get(qdev_get_machine(),
568 "non-qdev-gpio[*]", OBJECT(pin
));
570 object_property_set_link(OBJECT(dev
), OBJECT(pin
), propname
, &error_abort
);
574 qemu_irq
qdev_get_gpio_out_connector(DeviceState
*dev
, const char *name
, int n
)
576 g_autofree
char *propname
= g_strdup_printf("%s[%d]",
577 name
? name
: "unnamed-gpio-out", n
);
579 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
585 /* disconnect a GPIO output, returning the disconnected input (if any) */
587 static qemu_irq
qdev_disconnect_gpio_out_named(DeviceState
*dev
,
588 const char *name
, int n
)
590 char *propname
= g_strdup_printf("%s[%d]",
591 name
? name
: "unnamed-gpio-out", n
);
593 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
596 object_property_set_link(OBJECT(dev
), NULL
, propname
, NULL
);
602 qemu_irq
qdev_intercept_gpio_out(DeviceState
*dev
, qemu_irq icpt
,
603 const char *name
, int n
)
605 qemu_irq disconnected
= qdev_disconnect_gpio_out_named(dev
, name
, n
);
606 qdev_connect_gpio_out_named(dev
, name
, n
, icpt
);
610 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
612 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
615 void qdev_pass_gpios(DeviceState
*dev
, DeviceState
*container
,
619 NamedGPIOList
*ngl
= qdev_get_named_gpio_list(dev
, name
);
621 for (i
= 0; i
< ngl
->num_in
; i
++) {
622 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-in";
623 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
625 object_property_add_alias(OBJECT(container
), propname
,
626 OBJECT(dev
), propname
);
629 for (i
= 0; i
< ngl
->num_out
; i
++) {
630 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-out";
631 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
633 object_property_add_alias(OBJECT(container
), propname
,
634 OBJECT(dev
), propname
);
637 QLIST_REMOVE(ngl
, node
);
638 QLIST_INSERT_HEAD(&container
->gpios
, ngl
, node
);
641 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
644 Object
*child
= object_resolve_path_component(OBJECT(dev
), name
);
646 bus
= (BusState
*)object_dynamic_cast(child
, TYPE_BUS
);
651 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
652 if (strcmp(name
, bus
->name
) == 0) {
659 int qdev_walk_children(DeviceState
*dev
,
660 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
661 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
668 err
= pre_devfn(dev
, opaque
);
674 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
675 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
676 post_devfn
, post_busfn
, opaque
);
683 err
= post_devfn(dev
, opaque
);
692 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
698 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
699 DeviceState
*dev
= kid
->child
;
701 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
705 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
706 ret
= qdev_find_recursive(child
, id
);
715 char *qdev_get_dev_path(DeviceState
*dev
)
719 if (!dev
|| !dev
->parent_bus
) {
723 bc
= BUS_GET_CLASS(dev
->parent_bus
);
724 if (bc
->get_dev_path
) {
725 return bc
->get_dev_path(dev
);
732 * Legacy property handling
735 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
,
736 const char *name
, void *opaque
,
739 DeviceState
*dev
= DEVICE(obj
);
740 Property
*prop
= opaque
;
745 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
746 visit_type_str(v
, name
, &ptr
, errp
);
750 * qdev_class_add_legacy_property:
751 * @dev: Device to add the property to.
752 * @prop: The qdev property definition.
754 * Add a legacy QOM property to @dev for qdev property @prop.
756 * Legacy properties are string versions of QOM properties. The format of
757 * the string depends on the property type. Legacy properties are only
758 * needed for "info qtree".
760 * Do not use this in new code! QOM Properties added through this interface
761 * will be given names in the "legacy" namespace.
763 static void qdev_class_add_legacy_property(DeviceClass
*dc
, Property
*prop
)
765 g_autofree
char *name
= NULL
;
767 /* Register pointer properties as legacy properties */
768 if (!prop
->info
->print
&& prop
->info
->get
) {
772 name
= g_strdup_printf("legacy-%s", prop
->name
);
773 object_class_property_add(OBJECT_CLASS(dc
), name
, "str",
774 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
778 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
)
780 Object
*obj
= OBJECT(dev
);
783 assert(!prop
->info
->create
);
785 op
= object_property_add(obj
, prop
->name
, prop
->info
->name
,
786 prop
->info
->get
, prop
->info
->set
,
790 object_property_set_description(obj
, prop
->name
,
791 prop
->info
->description
);
793 if (prop
->set_default
) {
794 prop
->info
->set_default_value(op
, prop
);
801 static void qdev_class_add_property(DeviceClass
*klass
, Property
*prop
)
803 ObjectClass
*oc
= OBJECT_CLASS(klass
);
805 if (prop
->info
->create
) {
806 prop
->info
->create(oc
, prop
);
810 op
= object_class_property_add(oc
,
811 prop
->name
, prop
->info
->name
,
812 prop
->info
->get
, prop
->info
->set
,
815 if (prop
->set_default
) {
816 prop
->info
->set_default_value(op
, prop
);
819 object_class_property_set_description(oc
, prop
->name
,
820 prop
->info
->description
);
823 /* @qdev_alias_all_properties - Add alias properties to the source object for
824 * all qdev properties on the target DeviceState.
826 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
831 class = object_get_class(OBJECT(target
));
833 DeviceClass
*dc
= DEVICE_CLASS(class);
835 for (prop
= dc
->props_
; prop
&& prop
->name
; prop
++) {
836 object_property_add_alias(source
, prop
->name
,
837 OBJECT(target
), prop
->name
);
839 class = object_class_get_parent(class);
840 } while (class != object_class_by_name(TYPE_DEVICE
));
843 static bool device_get_realized(Object
*obj
, Error
**errp
)
845 DeviceState
*dev
= DEVICE(obj
);
846 return dev
->realized
;
849 static bool check_only_migratable(Object
*obj
, Error
**errp
)
851 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
853 if (!vmstate_check_only_migratable(dc
->vmsd
)) {
854 error_setg(errp
, "Device %s is not migratable, but "
855 "--only-migratable was specified",
856 object_get_typename(obj
));
863 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
865 DeviceState
*dev
= DEVICE(obj
);
866 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
867 HotplugHandler
*hotplug_ctrl
;
870 Error
*local_err
= NULL
;
871 bool unattached_parent
= false;
872 static int unattached_count
;
874 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
875 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
879 if (value
&& !dev
->realized
) {
880 if (!check_only_migratable(obj
, &local_err
)) {
885 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
887 object_property_add_child(container_get(qdev_get_machine(),
890 unattached_parent
= true;
894 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
896 hotplug_handler_pre_plug(hotplug_ctrl
, dev
, &local_err
);
897 if (local_err
!= NULL
) {
903 dc
->realize(dev
, &local_err
);
904 if (local_err
!= NULL
) {
909 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
912 * always free/re-initialize here since the value cannot be cleaned up
913 * in device_unrealize due to its usage later on in the unplug path
915 g_free(dev
->canonical_path
);
916 dev
->canonical_path
= object_get_canonical_path(OBJECT(dev
));
917 QLIST_FOREACH(ncl
, &dev
->clocks
, node
) {
921 clock_setup_canonical_path(ncl
->clock
);
925 if (qdev_get_vmsd(dev
)) {
926 if (vmstate_register_with_alias_id(VMSTATE_IF(dev
),
927 VMSTATE_INSTANCE_ID_ANY
,
928 qdev_get_vmsd(dev
), dev
,
929 dev
->instance_id_alias
,
930 dev
->alias_required_for_version
,
932 goto post_realize_fail
;
937 * Clear the reset state, in case the object was previously unrealized
938 * with a dirty state.
940 resettable_state_clear(&dev
->reset
);
942 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
943 if (!qbus_realize(bus
, errp
)) {
944 goto child_realize_fail
;
947 if (dev
->hotplugged
) {
949 * Reset the device, as well as its subtree which, at this point,
950 * should be realized too.
952 resettable_assert_reset(OBJECT(dev
), RESET_TYPE_COLD
);
953 resettable_change_parent(OBJECT(dev
), OBJECT(dev
->parent_bus
),
955 resettable_release_reset(OBJECT(dev
), RESET_TYPE_COLD
);
957 dev
->pending_deleted_event
= false;
960 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
961 if (local_err
!= NULL
) {
962 goto child_realize_fail
;
966 } else if (!value
&& dev
->realized
) {
967 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
970 if (qdev_get_vmsd(dev
)) {
971 vmstate_unregister(VMSTATE_IF(dev
), qdev_get_vmsd(dev
), dev
);
976 dev
->pending_deleted_event
= true;
977 DEVICE_LISTENER_CALL(unrealize
, Reverse
, dev
);
980 assert(local_err
== NULL
);
981 dev
->realized
= value
;
985 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
989 if (qdev_get_vmsd(dev
)) {
990 vmstate_unregister(VMSTATE_IF(dev
), qdev_get_vmsd(dev
), dev
);
994 g_free(dev
->canonical_path
);
995 dev
->canonical_path
= NULL
;
1001 error_propagate(errp
, local_err
);
1002 if (unattached_parent
) {
1004 * Beware, this doesn't just revert
1005 * object_property_add_child(), it also runs bus_remove()!
1007 object_unparent(OBJECT(dev
));
1012 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
1014 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
1015 DeviceState
*dev
= DEVICE(obj
);
1017 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
1018 qbus_is_hotpluggable(dev
->parent_bus
));
1021 static bool device_get_hotplugged(Object
*obj
, Error
**errp
)
1023 DeviceState
*dev
= DEVICE(obj
);
1025 return dev
->hotplugged
;
1028 static void device_initfn(Object
*obj
)
1030 DeviceState
*dev
= DEVICE(obj
);
1033 dev
->hotplugged
= 1;
1034 qdev_hot_added
= true;
1037 dev
->instance_id_alias
= -1;
1038 dev
->realized
= false;
1039 dev
->allow_unplug_during_migration
= false;
1041 QLIST_INIT(&dev
->gpios
);
1042 QLIST_INIT(&dev
->clocks
);
1045 static void device_post_init(Object
*obj
)
1048 * Note: ordered so that the user's global properties take
1051 object_apply_compat_props(obj
);
1052 qdev_prop_set_globals(DEVICE(obj
));
1055 /* Unlink device from bus and free the structure. */
1056 static void device_finalize(Object
*obj
)
1058 NamedGPIOList
*ngl
, *next
;
1060 DeviceState
*dev
= DEVICE(obj
);
1062 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1063 QLIST_REMOVE(ngl
, node
);
1064 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1067 /* ngl->out irqs are owned by the other end and should not be freed
1072 qdev_finalize_clocklist(dev
);
1074 /* Only send event if the device had been completely realized */
1075 if (dev
->pending_deleted_event
) {
1076 g_assert(dev
->canonical_path
);
1078 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, dev
->canonical_path
);
1079 g_free(dev
->canonical_path
);
1080 dev
->canonical_path
= NULL
;
1083 qemu_opts_del(dev
->opts
);
1086 static void device_class_base_init(ObjectClass
*class, void *data
)
1088 DeviceClass
*klass
= DEVICE_CLASS(class);
1090 /* We explicitly look up properties in the superclasses,
1091 * so do not propagate them to the subclasses.
1093 klass
->props_
= NULL
;
1096 static void device_unparent(Object
*obj
)
1098 DeviceState
*dev
= DEVICE(obj
);
1101 if (dev
->realized
) {
1102 qdev_unrealize(dev
);
1104 while (dev
->num_child_bus
) {
1105 bus
= QLIST_FIRST(&dev
->child_bus
);
1106 object_unparent(OBJECT(bus
));
1108 if (dev
->parent_bus
) {
1109 bus_remove_child(dev
->parent_bus
, dev
);
1110 object_unref(OBJECT(dev
->parent_bus
));
1111 dev
->parent_bus
= NULL
;
1116 device_vmstate_if_get_id(VMStateIf
*obj
)
1118 DeviceState
*dev
= DEVICE(obj
);
1120 return qdev_get_dev_path(dev
);
1124 * device_phases_reset:
1125 * Transition reset method for devices to allow moving
1126 * smoothly from legacy reset method to multi-phases
1128 static void device_phases_reset(DeviceState
*dev
)
1130 ResettableClass
*rc
= RESETTABLE_GET_CLASS(dev
);
1132 if (rc
->phases
.enter
) {
1133 rc
->phases
.enter(OBJECT(dev
), RESET_TYPE_COLD
);
1135 if (rc
->phases
.hold
) {
1136 rc
->phases
.hold(OBJECT(dev
));
1138 if (rc
->phases
.exit
) {
1139 rc
->phases
.exit(OBJECT(dev
));
1143 static void device_transitional_reset(Object
*obj
)
1145 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
1148 * This will call either @device_phases_reset (for multi-phases transitioned
1149 * devices) or a device's specific method for not-yet transitioned devices.
1150 * In both case, it does not reset children.
1153 dc
->reset(DEVICE(obj
));
1158 * device_get_transitional_reset:
1159 * check if the device's class is ready for multi-phase
1161 static ResettableTrFunction
device_get_transitional_reset(Object
*obj
)
1163 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
1164 if (dc
->reset
!= device_phases_reset
) {
1166 * dc->reset has been overridden by a subclass,
1167 * the device is not ready for multi phase yet.
1169 return device_transitional_reset
;
1174 static void device_class_init(ObjectClass
*class, void *data
)
1176 DeviceClass
*dc
= DEVICE_CLASS(class);
1177 VMStateIfClass
*vc
= VMSTATE_IF_CLASS(class);
1178 ResettableClass
*rc
= RESETTABLE_CLASS(class);
1180 class->unparent
= device_unparent
;
1182 /* by default all devices were considered as hotpluggable,
1183 * so with intent to check it in generic qdev_unplug() /
1184 * device_set_realized() functions make every device
1185 * hotpluggable. Devices that shouldn't be hotpluggable,
1186 * should override it in their class_init()
1188 dc
->hotpluggable
= true;
1189 dc
->user_creatable
= true;
1190 vc
->get_id
= device_vmstate_if_get_id
;
1191 rc
->get_state
= device_get_reset_state
;
1192 rc
->child_foreach
= device_reset_child_foreach
;
1195 * @device_phases_reset is put as the default reset method below, allowing
1196 * to do the multi-phase transition from base classes to leaf classes. It
1197 * allows a legacy-reset Device class to extend a multi-phases-reset
1198 * Device class for the following reason:
1199 * + If a base class B has been moved to multi-phase, then it does not
1200 * override this default reset method and may have defined phase methods.
1201 * + A child class C (extending class B) which uses
1202 * device_class_set_parent_reset() (or similar means) to override the
1203 * reset method will still work as expected. @device_phases_reset function
1204 * will be registered as the parent reset method and effectively call
1205 * parent reset phases.
1207 dc
->reset
= device_phases_reset
;
1208 rc
->get_transitional_function
= device_get_transitional_reset
;
1210 object_class_property_add_bool(class, "realized",
1211 device_get_realized
, device_set_realized
);
1212 object_class_property_add_bool(class, "hotpluggable",
1213 device_get_hotpluggable
, NULL
);
1214 object_class_property_add_bool(class, "hotplugged",
1215 device_get_hotplugged
, NULL
);
1216 object_class_property_add_link(class, "parent_bus", TYPE_BUS
,
1217 offsetof(DeviceState
, parent_bus
), NULL
, 0);
1220 void device_class_set_props(DeviceClass
*dc
, Property
*props
)
1225 for (prop
= props
; prop
&& prop
->name
; prop
++) {
1226 qdev_class_add_legacy_property(dc
, prop
);
1227 qdev_class_add_property(dc
, prop
);
1231 void device_class_set_parent_reset(DeviceClass
*dc
,
1232 DeviceReset dev_reset
,
1233 DeviceReset
*parent_reset
)
1235 *parent_reset
= dc
->reset
;
1236 dc
->reset
= dev_reset
;
1239 void device_class_set_parent_realize(DeviceClass
*dc
,
1240 DeviceRealize dev_realize
,
1241 DeviceRealize
*parent_realize
)
1243 *parent_realize
= dc
->realize
;
1244 dc
->realize
= dev_realize
;
1247 void device_class_set_parent_unrealize(DeviceClass
*dc
,
1248 DeviceUnrealize dev_unrealize
,
1249 DeviceUnrealize
*parent_unrealize
)
1251 *parent_unrealize
= dc
->unrealize
;
1252 dc
->unrealize
= dev_unrealize
;
1255 void device_legacy_reset(DeviceState
*dev
)
1257 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1259 trace_qdev_reset(dev
, object_get_typename(OBJECT(dev
)));
1265 Object
*qdev_get_machine(void)
1270 dev
= container_get(object_get_root(), "/machine");
1276 static const TypeInfo device_type_info
= {
1277 .name
= TYPE_DEVICE
,
1278 .parent
= TYPE_OBJECT
,
1279 .instance_size
= sizeof(DeviceState
),
1280 .instance_init
= device_initfn
,
1281 .instance_post_init
= device_post_init
,
1282 .instance_finalize
= device_finalize
,
1283 .class_base_init
= device_class_base_init
,
1284 .class_init
= device_class_init
,
1286 .class_size
= sizeof(DeviceClass
),
1287 .interfaces
= (InterfaceInfo
[]) {
1288 { TYPE_VMSTATE_IF
},
1289 { TYPE_RESETTABLE_INTERFACE
},
1294 static void qdev_register_types(void)
1296 type_register_static(&device_type_info
);
1299 type_init(qdev_register_types
)