2 * Dynamic device configuration and creation.
4 * Copyright (c) 2009 CodeSourcery
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 /* The theory here is that it should be possible to create a machine without
21 knowledge of specific devices. Historically board init routines have
22 passed a bunch of arguments to each device, requiring the board know
23 exactly which device it is dealing with. This file provides an abstract
24 API for device configuration and initialization. Devices will generally
25 inherit from a particular bus (e.g. PCI or I2C) rather than
28 #include "qemu/osdep.h"
30 #include "hw/fw-path-provider.h"
31 #include "sysemu/sysemu.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "qemu/error-report.h"
36 #include "hw/hotplug.h"
37 #include "hw/boards.h"
38 #include "hw/sysbus.h"
39 #include "qapi-event.h"
40 #include "migration/migration.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 const char *qdev_fw_name(DeviceState
*dev
)
54 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
60 return object_get_typename(OBJECT(dev
));
63 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
67 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
68 if (kid
->child
== child
) {
71 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
72 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
74 /* This gives back ownership of kid->child back to us. */
75 object_property_del(OBJECT(bus
), name
, NULL
);
76 object_unref(OBJECT(kid
->child
));
83 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
86 BusChild
*kid
= g_malloc0(sizeof(*kid
));
88 kid
->index
= bus
->max_index
++;
90 object_ref(OBJECT(kid
->child
));
92 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
94 /* This transfers ownership of kid->child to the property. */
95 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
96 object_property_add_link(OBJECT(bus
), name
,
97 object_get_typename(OBJECT(child
)),
98 (Object
**)&kid
->child
,
99 NULL
, /* read-only property */
100 0, /* return ownership on prop deletion */
104 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
106 bool replugging
= dev
->parent_bus
!= NULL
;
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().
113 object_ref(OBJECT(dev
));
114 bus_remove_child(dev
->parent_bus
, dev
);
115 object_unref(OBJECT(dev
->parent_bus
));
117 dev
->parent_bus
= bus
;
118 object_ref(OBJECT(bus
));
119 bus_add_child(bus
, dev
);
121 object_unref(OBJECT(dev
));
125 /* Create a new device. This only initializes the device state
126 structure and allows properties to be set. The device still needs
127 to be realized. See qdev-core.h. */
128 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
132 dev
= qdev_try_create(bus
, name
);
135 error_report("Unknown device '%s' for bus '%s'", name
,
136 object_get_typename(OBJECT(bus
)));
138 error_report("Unknown device '%s' for default sysbus", name
);
146 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
150 if (object_class_by_name(type
) == NULL
) {
153 dev
= DEVICE(object_new(type
));
159 /* Assert that the device really is a SysBusDevice before
160 * we put it onto the sysbus. Non-sysbus devices which aren't
161 * being put onto a bus should be created with object_new(TYPE_FOO),
162 * not qdev_create(NULL, TYPE_FOO).
164 g_assert(object_dynamic_cast(OBJECT(dev
), TYPE_SYS_BUS_DEVICE
));
165 bus
= sysbus_get_default();
168 qdev_set_parent_bus(dev
, bus
);
169 object_unref(OBJECT(dev
));
173 static QTAILQ_HEAD(device_listeners
, DeviceListener
) device_listeners
174 = QTAILQ_HEAD_INITIALIZER(device_listeners
);
176 enum ListenerDirection
{ Forward
, Reverse
};
178 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
180 DeviceListener *_listener; \
182 switch (_direction) { \
184 QTAILQ_FOREACH(_listener, &device_listeners, link) { \
185 if (_listener->_callback) { \
186 _listener->_callback(_listener, ##_args); \
191 QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
192 device_listeners, link) { \
193 if (_listener->_callback) { \
194 _listener->_callback(_listener, ##_args); \
203 static int device_listener_add(DeviceState
*dev
, void *opaque
)
205 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
210 void device_listener_register(DeviceListener
*listener
)
212 QTAILQ_INSERT_TAIL(&device_listeners
, listener
, link
);
214 qbus_walk_children(sysbus_get_default(), NULL
, NULL
, device_listener_add
,
218 void device_listener_unregister(DeviceListener
*listener
)
220 QTAILQ_REMOVE(&device_listeners
, listener
, link
);
223 static void device_realize(DeviceState
*dev
, Error
**errp
)
225 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
228 int rc
= dc
->init(dev
);
230 error_setg(errp
, "Device initialization failed.");
236 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
238 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
241 int rc
= dc
->exit(dev
);
243 error_setg(errp
, "Device exit failed.");
249 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
250 int required_for_version
)
252 assert(!dev
->realized
);
253 dev
->instance_id_alias
= alias_id
;
254 dev
->alias_required_for_version
= required_for_version
;
257 HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
259 HotplugHandler
*hotplug_ctrl
= NULL
;
261 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
262 hotplug_ctrl
= dev
->parent_bus
->hotplug_handler
;
263 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE
)) {
264 MachineState
*machine
= MACHINE(qdev_get_machine());
265 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
267 if (mc
->get_hotplug_handler
) {
268 hotplug_ctrl
= mc
->get_hotplug_handler(machine
, dev
);
274 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
281 static int qbus_reset_one(BusState
*bus
, void *opaque
)
283 BusClass
*bc
= BUS_GET_CLASS(bus
);
290 void qdev_reset_all(DeviceState
*dev
)
292 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
295 void qdev_reset_all_fn(void *opaque
)
297 qdev_reset_all(DEVICE(opaque
));
300 void qbus_reset_all(BusState
*bus
)
302 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
305 void qbus_reset_all_fn(void *opaque
)
307 BusState
*bus
= opaque
;
311 /* can be used as ->unplug() callback for the simple cases */
312 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
313 DeviceState
*dev
, Error
**errp
)
316 object_unparent(OBJECT(dev
));
321 * Device properties should be set before calling this function. IRQs
322 * and MMIO regions should be connected/mapped after calling this
324 * On failure, report an error with error_report() and terminate the
325 * program. This is okay during machine creation. Don't use for
326 * hotplug, because there callers need to recover from failure.
327 * Exception: if you know the device's init() callback can't fail,
328 * then qdev_init_nofail() can't fail either, and is therefore usable
329 * even then. But relying on the device implementation that way is
330 * somewhat unclean, and best avoided.
332 void qdev_init_nofail(DeviceState
*dev
)
336 assert(!dev
->realized
);
338 object_ref(OBJECT(dev
));
339 object_property_set_bool(OBJECT(dev
), true, "realized", &err
);
341 error_reportf_err(err
, "Initialization of device %s failed: ",
342 object_get_typename(OBJECT(dev
)));
345 object_unref(OBJECT(dev
));
348 void qdev_machine_creation_done(void)
351 * ok, initial machine setup is done, starting from now we can
352 * only create hotpluggable devices
357 bool qdev_machine_modified(void)
359 return qdev_hot_added
|| qdev_hot_removed
;
362 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
364 return dev
->parent_bus
;
367 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
372 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
373 /* NULL is a valid and matchable name, otherwise do a normal
376 if ((!ngl
->name
&& !name
) ||
377 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
382 ngl
= g_malloc0(sizeof(*ngl
));
383 ngl
->name
= g_strdup(name
);
384 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
388 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
389 const char *name
, int n
)
392 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
394 assert(gpio_list
->num_out
== 0 || !name
);
395 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
399 name
= "unnamed-gpio-in";
401 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
402 gchar
*propname
= g_strdup_printf("%s[%u]", name
, i
);
404 object_property_add_child(OBJECT(dev
), propname
,
405 OBJECT(gpio_list
->in
[i
]), &error_abort
);
409 gpio_list
->num_in
+= n
;
412 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
414 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
417 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
418 const char *name
, int n
)
421 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
423 assert(gpio_list
->num_in
== 0 || !name
);
426 name
= "unnamed-gpio-out";
428 memset(pins
, 0, sizeof(*pins
) * n
);
429 for (i
= 0; i
< n
; ++i
) {
430 gchar
*propname
= g_strdup_printf("%s[%u]", name
,
431 gpio_list
->num_out
+ i
);
433 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
435 object_property_allow_set_link
,
436 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
440 gpio_list
->num_out
+= n
;
443 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
445 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
448 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
450 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
452 assert(n
>= 0 && n
< gpio_list
->num_in
);
453 return gpio_list
->in
[n
];
456 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
458 return qdev_get_gpio_in_named(dev
, NULL
, n
);
461 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
464 char *propname
= g_strdup_printf("%s[%d]",
465 name
? name
: "unnamed-gpio-out", n
);
467 /* We need a name for object_property_set_link to work. If the
468 * object has a parent, object_property_add_child will come back
469 * with an error without doing anything. If it has none, it will
470 * never fail. So we can just call it with a NULL Error pointer.
472 object_property_add_child(container_get(qdev_get_machine(),
474 "non-qdev-gpio[*]", OBJECT(pin
), NULL
);
476 object_property_set_link(OBJECT(dev
), OBJECT(pin
), propname
, &error_abort
);
480 qemu_irq
qdev_get_gpio_out_connector(DeviceState
*dev
, 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
,
491 /* disconnect a GPIO output, returning the disconnected input (if any) */
493 static qemu_irq
qdev_disconnect_gpio_out_named(DeviceState
*dev
,
494 const char *name
, int n
)
496 char *propname
= g_strdup_printf("%s[%d]",
497 name
? name
: "unnamed-gpio-out", n
);
499 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
502 object_property_set_link(OBJECT(dev
), NULL
, propname
, NULL
);
508 qemu_irq
qdev_intercept_gpio_out(DeviceState
*dev
, qemu_irq icpt
,
509 const char *name
, int n
)
511 qemu_irq disconnected
= qdev_disconnect_gpio_out_named(dev
, name
, n
);
512 qdev_connect_gpio_out_named(dev
, name
, n
, icpt
);
516 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
518 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
521 void qdev_pass_gpios(DeviceState
*dev
, DeviceState
*container
,
525 NamedGPIOList
*ngl
= qdev_get_named_gpio_list(dev
, name
);
527 for (i
= 0; i
< ngl
->num_in
; i
++) {
528 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-in";
529 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
531 object_property_add_alias(OBJECT(container
), propname
,
532 OBJECT(dev
), propname
,
536 for (i
= 0; i
< ngl
->num_out
; i
++) {
537 const char *nm
= ngl
->name
? ngl
->name
: "unnamed-gpio-out";
538 char *propname
= g_strdup_printf("%s[%d]", nm
, i
);
540 object_property_add_alias(OBJECT(container
), propname
,
541 OBJECT(dev
), propname
,
545 QLIST_REMOVE(ngl
, node
);
546 QLIST_INSERT_HEAD(&container
->gpios
, ngl
, node
);
549 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
552 Object
*child
= object_resolve_path_component(OBJECT(dev
), name
);
554 bus
= (BusState
*)object_dynamic_cast(child
, TYPE_BUS
);
559 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
560 if (strcmp(name
, bus
->name
) == 0) {
567 int qdev_walk_children(DeviceState
*dev
,
568 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
569 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
576 err
= pre_devfn(dev
, opaque
);
582 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
583 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
584 post_devfn
, post_busfn
, opaque
);
591 err
= post_devfn(dev
, opaque
);
600 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
606 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
607 DeviceState
*dev
= kid
->child
;
609 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
613 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
614 ret
= qdev_find_recursive(child
, id
);
623 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
625 BusClass
*bc
= BUS_GET_CLASS(bus
);
627 if (bc
->get_fw_dev_path
) {
628 return bc
->get_fw_dev_path(dev
);
634 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
636 Object
*obj
= OBJECT(dev
);
639 while (!d
&& obj
->parent
) {
641 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
646 char *qdev_get_own_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
648 Object
*obj
= OBJECT(dev
);
650 return fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
653 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
657 if (dev
&& dev
->parent_bus
) {
659 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
660 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
662 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
665 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
671 l
+= snprintf(p
+ l
, size
- l
, "/");
676 char* qdev_get_fw_dev_path(DeviceState
*dev
)
681 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
685 return g_strdup(path
);
688 char *qdev_get_dev_path(DeviceState
*dev
)
692 if (!dev
|| !dev
->parent_bus
) {
696 bc
= BUS_GET_CLASS(dev
->parent_bus
);
697 if (bc
->get_dev_path
) {
698 return bc
->get_dev_path(dev
);
705 * Legacy property handling
708 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
,
709 const char *name
, void *opaque
,
712 DeviceState
*dev
= DEVICE(obj
);
713 Property
*prop
= opaque
;
718 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
719 visit_type_str(v
, name
, &ptr
, errp
);
723 * qdev_property_add_legacy:
724 * @dev: Device to add the property to.
725 * @prop: The qdev property definition.
726 * @errp: location to store error information.
728 * Add a legacy QOM property to @dev for qdev property @prop.
729 * On error, store error in @errp.
731 * Legacy properties are string versions of QOM properties. The format of
732 * the string depends on the property type. Legacy properties are only
733 * needed for "info qtree".
735 * Do not use this is new code! QOM Properties added through this interface
736 * will be given names in the "legacy" namespace.
738 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
743 /* Register pointer properties as legacy properties */
744 if (!prop
->info
->print
&& prop
->info
->get
) {
748 name
= g_strdup_printf("legacy-%s", prop
->name
);
749 object_property_add(OBJECT(dev
), name
, "str",
750 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
759 * qdev_property_add_static:
760 * @dev: Device to add the property to.
761 * @prop: The qdev property definition.
762 * @errp: location to store error information.
764 * Add a static QOM property to @dev for qdev property @prop.
765 * On error, store error in @errp. Static properties access data in a struct.
766 * The type of the QOM property is derived from prop->info.
768 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
771 Error
*local_err
= NULL
;
772 Object
*obj
= OBJECT(dev
);
775 * TODO qdev_prop_ptr does not have getters or setters. It must
776 * go now that it can be replaced with links. The test should be
777 * removed along with it: all static properties are read/write.
779 if (!prop
->info
->get
&& !prop
->info
->set
) {
783 object_property_add(obj
, prop
->name
, prop
->info
->name
,
784 prop
->info
->get
, prop
->info
->set
,
789 error_propagate(errp
, local_err
);
793 object_property_set_description(obj
, prop
->name
,
794 prop
->info
->description
,
797 if (prop
->qtype
== QTYPE_NONE
) {
801 if (prop
->qtype
== QTYPE_QBOOL
) {
802 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
803 } else if (prop
->info
->enum_table
) {
804 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
805 prop
->name
, &error_abort
);
806 } else if (prop
->qtype
== QTYPE_QINT
) {
807 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
811 /* @qdev_alias_all_properties - Add alias properties to the source object for
812 * all qdev properties on the target DeviceState.
814 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
819 class = object_get_class(OBJECT(target
));
821 DeviceClass
*dc
= DEVICE_CLASS(class);
823 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
824 object_property_add_alias(source
, prop
->name
,
825 OBJECT(target
), prop
->name
,
828 class = object_class_get_parent(class);
829 } while (class != object_class_by_name(TYPE_DEVICE
));
832 static int qdev_add_hotpluggable_device(Object
*obj
, void *opaque
)
834 GSList
**list
= opaque
;
835 DeviceState
*dev
= (DeviceState
*)object_dynamic_cast(OBJECT(obj
),
842 if (dev
->realized
&& object_property_get_bool(obj
, "hotpluggable", NULL
)) {
843 *list
= g_slist_append(*list
, dev
);
849 GSList
*qdev_build_hotpluggable_device_list(Object
*peripheral
)
853 object_child_foreach(peripheral
, qdev_add_hotpluggable_device
, &list
);
858 static bool device_get_realized(Object
*obj
, Error
**errp
)
860 DeviceState
*dev
= DEVICE(obj
);
861 return dev
->realized
;
864 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
866 DeviceState
*dev
= DEVICE(obj
);
867 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
868 HotplugHandler
*hotplug_ctrl
;
870 Error
*local_err
= NULL
;
871 bool unattached_parent
= false;
872 static int unattached_count
;
875 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
876 error_setg(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
880 if (value
&& !dev
->realized
) {
881 ret
= check_migratable(obj
, &local_err
);
887 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
889 object_property_add_child(container_get(qdev_get_machine(),
891 name
, obj
, &error_abort
);
892 unattached_parent
= true;
896 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
898 hotplug_handler_pre_plug(hotplug_ctrl
, dev
, &local_err
);
899 if (local_err
!= NULL
) {
905 dc
->realize(dev
, &local_err
);
908 if (local_err
!= NULL
) {
912 DEVICE_LISTENER_CALL(realize
, Forward
, dev
);
915 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
918 if (local_err
!= NULL
) {
919 goto post_realize_fail
;
922 if (qdev_get_vmsd(dev
)) {
923 if (vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
924 dev
->instance_id_alias
,
925 dev
->alias_required_for_version
,
927 goto post_realize_fail
;
931 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
932 object_property_set_bool(OBJECT(bus
), true, "realized",
934 if (local_err
!= NULL
) {
935 goto child_realize_fail
;
938 if (dev
->hotplugged
) {
941 dev
->pending_deleted_event
= false;
942 } else if (!value
&& dev
->realized
) {
943 Error
**local_errp
= NULL
;
944 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
945 local_errp
= local_err
? NULL
: &local_err
;
946 object_property_set_bool(OBJECT(bus
), false, "realized",
949 if (qdev_get_vmsd(dev
)) {
950 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
953 local_errp
= local_err
? NULL
: &local_err
;
954 dc
->unrealize(dev
, local_errp
);
956 dev
->pending_deleted_event
= true;
957 DEVICE_LISTENER_CALL(unrealize
, Reverse
, dev
);
960 if (local_err
!= NULL
) {
964 dev
->realized
= value
;
968 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
969 object_property_set_bool(OBJECT(bus
), false, "realized",
973 if (qdev_get_vmsd(dev
)) {
974 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
979 dc
->unrealize(dev
, NULL
);
983 error_propagate(errp
, local_err
);
984 if (unattached_parent
) {
985 object_unparent(OBJECT(dev
));
990 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
992 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
993 DeviceState
*dev
= DEVICE(obj
);
995 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
996 qbus_is_hotpluggable(dev
->parent_bus
));
999 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
1001 DeviceState
*dev
= DEVICE(obj
);
1003 return dev
->hotplugged
;
1006 static void device_initfn(Object
*obj
)
1008 DeviceState
*dev
= DEVICE(obj
);
1013 dev
->hotplugged
= 1;
1014 qdev_hot_added
= true;
1017 dev
->instance_id_alias
= -1;
1018 dev
->realized
= false;
1020 object_property_add_bool(obj
, "realized",
1021 device_get_realized
, device_set_realized
, NULL
);
1022 object_property_add_bool(obj
, "hotpluggable",
1023 device_get_hotpluggable
, NULL
, NULL
);
1024 object_property_add_bool(obj
, "hotplugged",
1025 device_get_hotplugged
, NULL
,
1028 class = object_get_class(OBJECT(dev
));
1030 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
1031 qdev_property_add_legacy(dev
, prop
, &error_abort
);
1032 qdev_property_add_static(dev
, prop
, &error_abort
);
1034 class = object_class_get_parent(class);
1035 } while (class != object_class_by_name(TYPE_DEVICE
));
1037 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1038 (Object
**)&dev
->parent_bus
, NULL
, 0,
1040 QLIST_INIT(&dev
->gpios
);
1043 static void device_post_init(Object
*obj
)
1045 qdev_prop_set_globals(DEVICE(obj
));
1048 /* Unlink device from bus and free the structure. */
1049 static void device_finalize(Object
*obj
)
1051 NamedGPIOList
*ngl
, *next
;
1053 DeviceState
*dev
= DEVICE(obj
);
1055 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1056 QLIST_REMOVE(ngl
, node
);
1057 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1060 /* ngl->out irqs are owned by the other end and should not be freed
1066 static void device_class_base_init(ObjectClass
*class, void *data
)
1068 DeviceClass
*klass
= DEVICE_CLASS(class);
1070 /* We explicitly look up properties in the superclasses,
1071 * so do not propagate them to the subclasses.
1073 klass
->props
= NULL
;
1076 static void device_unparent(Object
*obj
)
1078 DeviceState
*dev
= DEVICE(obj
);
1081 if (dev
->realized
) {
1082 object_property_set_bool(obj
, false, "realized", NULL
);
1084 while (dev
->num_child_bus
) {
1085 bus
= QLIST_FIRST(&dev
->child_bus
);
1086 object_unparent(OBJECT(bus
));
1088 if (dev
->parent_bus
) {
1089 bus_remove_child(dev
->parent_bus
, dev
);
1090 object_unref(OBJECT(dev
->parent_bus
));
1091 dev
->parent_bus
= NULL
;
1094 /* Only send event if the device had been completely realized */
1095 if (dev
->pending_deleted_event
) {
1096 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
1098 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, path
, &error_abort
);
1102 qemu_opts_del(dev
->opts
);
1106 static void device_class_init(ObjectClass
*class, void *data
)
1108 DeviceClass
*dc
= DEVICE_CLASS(class);
1110 class->unparent
= device_unparent
;
1111 dc
->realize
= device_realize
;
1112 dc
->unrealize
= device_unrealize
;
1114 /* by default all devices were considered as hotpluggable,
1115 * so with intent to check it in generic qdev_unplug() /
1116 * device_set_realized() functions make every device
1117 * hotpluggable. Devices that shouldn't be hotpluggable,
1118 * should override it in their class_init()
1120 dc
->hotpluggable
= true;
1121 dc
->user_creatable
= true;
1124 void device_reset(DeviceState
*dev
)
1126 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1133 Object
*qdev_get_machine(void)
1138 dev
= container_get(object_get_root(), "/machine");
1144 static const TypeInfo device_type_info
= {
1145 .name
= TYPE_DEVICE
,
1146 .parent
= TYPE_OBJECT
,
1147 .instance_size
= sizeof(DeviceState
),
1148 .instance_init
= device_initfn
,
1149 .instance_post_init
= device_post_init
,
1150 .instance_finalize
= device_finalize
,
1151 .class_base_init
= device_class_base_init
,
1152 .class_init
= device_class_init
,
1154 .class_size
= sizeof(DeviceClass
),
1157 static void qdev_register_types(void)
1159 type_register_static(&device_type_info
);
1162 type_init(qdev_register_types
)