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
29 #include "hw/fw-path-provider.h"
30 #include "sysemu/sysemu.h"
31 #include "qapi/error.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qapi/visitor.h"
34 #include "qapi/qmp/qjson.h"
35 #include "hw/hotplug.h"
36 #include "hw/boards.h"
37 #include "qapi-event.h"
40 static bool qdev_hot_added
= false;
41 static bool qdev_hot_removed
= false;
43 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
45 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
49 const char *qdev_fw_name(DeviceState
*dev
)
51 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
57 return object_get_typename(OBJECT(dev
));
60 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
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 dev
->parent_bus
= bus
;
107 object_ref(OBJECT(bus
));
108 bus_add_child(bus
, dev
);
111 static void qbus_set_hotplug_handler_internal(BusState
*bus
, Object
*handler
,
115 object_property_set_link(OBJECT(bus
), OBJECT(handler
),
116 QDEV_HOTPLUG_HANDLER_PROPERTY
, errp
);
117 bus
->allow_hotplug
= 1;
120 void qbus_set_hotplug_handler(BusState
*bus
, DeviceState
*handler
, Error
**errp
)
122 qbus_set_hotplug_handler_internal(bus
, OBJECT(handler
), errp
);
125 void qbus_set_bus_hotplug_handler(BusState
*bus
, Error
**errp
)
127 qbus_set_hotplug_handler_internal(bus
, OBJECT(bus
), errp
);
130 /* Create a new device. This only initializes the device state structure
131 and allows properties to be set. qdev_init should be called to
132 initialize the actual device emulation. */
133 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
137 dev
= qdev_try_create(bus
, name
);
140 error_report("Unknown device '%s' for bus '%s'", name
,
141 object_get_typename(OBJECT(bus
)));
143 error_report("Unknown device '%s' for default sysbus", name
);
151 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
155 if (object_class_by_name(type
) == NULL
) {
158 dev
= DEVICE(object_new(type
));
164 bus
= sysbus_get_default();
167 qdev_set_parent_bus(dev
, bus
);
168 object_unref(OBJECT(dev
));
172 /* Initialize a device. Device properties should be set before calling
173 this function. IRQs and MMIO regions should be connected/mapped after
174 calling this function.
175 On failure, destroy the device and return negative value.
176 Return 0 on success. */
177 int qdev_init(DeviceState
*dev
)
179 Error
*local_err
= NULL
;
181 assert(!dev
->realized
);
183 object_property_set_bool(OBJECT(dev
), true, "realized", &local_err
);
184 if (local_err
!= NULL
) {
185 qerror_report_err(local_err
);
186 error_free(local_err
);
187 object_unparent(OBJECT(dev
));
193 static void device_realize(DeviceState
*dev
, Error
**errp
)
195 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
198 int rc
= dc
->init(dev
);
200 error_setg(errp
, "Device initialization failed.");
206 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
208 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
211 int rc
= dc
->exit(dev
);
213 error_setg(errp
, "Device exit failed.");
219 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
220 int required_for_version
)
222 assert(!dev
->realized
);
223 dev
->instance_id_alias
= alias_id
;
224 dev
->alias_required_for_version
= required_for_version
;
227 void qdev_unplug(DeviceState
*dev
, Error
**errp
)
229 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
231 if (dev
->parent_bus
&& !qbus_is_hotpluggable(dev
->parent_bus
)) {
232 error_set(errp
, QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
236 if (!dc
->hotpluggable
) {
237 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
,
238 object_get_typename(OBJECT(dev
)));
242 qdev_hot_removed
= true;
244 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
245 HotplugHandlerClass
*hdc
;
247 /* If device supports async unplug just request it to be done,
248 * otherwise just remove it synchronously */
249 hdc
= HOTPLUG_HANDLER_GET_CLASS(dev
->parent_bus
->hotplug_handler
);
250 if (hdc
->unplug_request
) {
251 hotplug_handler_unplug_request(dev
->parent_bus
->hotplug_handler
,
254 hotplug_handler_unplug(dev
->parent_bus
->hotplug_handler
, dev
, errp
);
257 assert(dc
->unplug
!= NULL
);
258 if (dc
->unplug(dev
) < 0) { /* legacy handler */
259 error_set(errp
, QERR_UNDEFINED_ERROR
);
264 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
271 static int qbus_reset_one(BusState
*bus
, void *opaque
)
273 BusClass
*bc
= BUS_GET_CLASS(bus
);
280 void qdev_reset_all(DeviceState
*dev
)
282 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
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 int qdev_simple_unplug_cb(DeviceState
*dev
)
300 object_unparent(OBJECT(dev
));
304 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
305 DeviceState
*dev
, Error
**errp
)
307 qdev_simple_unplug_cb(dev
);
310 /* Like qdev_init(), but terminate program via error_report() instead of
311 returning an error value. This is okay during machine creation.
312 Don't use for hotplug, because there callers need to recover from
313 failure. Exception: if you know the device's init() callback can't
314 fail, then qdev_init_nofail() can't fail either, and is therefore
315 usable even then. But relying on the device implementation that
316 way is somewhat unclean, and best avoided. */
317 void qdev_init_nofail(DeviceState
*dev
)
319 const char *typename
= object_get_typename(OBJECT(dev
));
321 if (qdev_init(dev
) < 0) {
322 error_report("Initialization of device %s failed", typename
);
327 void qdev_machine_creation_done(void)
330 * ok, initial machine setup is done, starting from now we can
331 * only create hotpluggable devices
336 bool qdev_machine_modified(void)
338 return qdev_hot_added
|| qdev_hot_removed
;
341 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
343 return dev
->parent_bus
;
346 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
351 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
352 /* NULL is a valid and matchable name, otherwise do a normal
355 if ((!ngl
->name
&& !name
) ||
356 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
361 ngl
= g_malloc0(sizeof(*ngl
));
362 ngl
->name
= g_strdup(name
);
363 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
367 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
368 const char *name
, int n
)
371 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
372 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-in");
374 assert(gpio_list
->num_out
== 0 || !name
);
375 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
378 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
379 object_property_add_child(OBJECT(dev
), propname
,
380 OBJECT(gpio_list
->in
[i
]), &error_abort
);
384 gpio_list
->num_in
+= n
;
387 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
389 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
392 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
393 const char *name
, int n
)
396 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
397 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-out");
399 assert(gpio_list
->num_in
== 0 || !name
);
400 assert(gpio_list
->num_out
== 0);
401 gpio_list
->num_out
= n
;
402 gpio_list
->out
= pins
;
404 for (i
= 0; i
< n
; ++i
) {
405 memset(&pins
[i
], 0, sizeof(*pins
));
406 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
408 object_property_allow_set_link
,
409 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
415 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
417 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
420 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
422 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
424 assert(n
>= 0 && n
< gpio_list
->num_in
);
425 return gpio_list
->in
[n
];
428 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
430 return qdev_get_gpio_in_named(dev
, NULL
, n
);
433 void qdev_connect_gpio_out_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_out
);
439 gpio_list
->out
[n
] = pin
;
442 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
444 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
447 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
451 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
452 if (strcmp(name
, bus
->name
) == 0) {
459 int qbus_walk_children(BusState
*bus
,
460 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
461 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
468 err
= pre_busfn(bus
, opaque
);
474 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
475 err
= qdev_walk_children(kid
->child
,
476 pre_devfn
, pre_busfn
,
477 post_devfn
, post_busfn
, opaque
);
484 err
= post_busfn(bus
, opaque
);
493 int qdev_walk_children(DeviceState
*dev
,
494 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
495 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
502 err
= pre_devfn(dev
, opaque
);
508 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
509 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
510 post_devfn
, post_busfn
, opaque
);
517 err
= post_devfn(dev
, opaque
);
526 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
532 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
533 DeviceState
*dev
= kid
->child
;
535 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
539 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
540 ret
= qdev_find_recursive(child
, id
);
549 static void qbus_realize(BusState
*bus
, DeviceState
*parent
, const char *name
)
551 const char *typename
= object_get_typename(OBJECT(bus
));
556 bus
->parent
= parent
;
559 bus
->name
= g_strdup(name
);
560 } else if (bus
->parent
&& bus
->parent
->id
) {
561 /* parent device has id -> use it plus parent-bus-id for bus name */
562 bus_id
= bus
->parent
->num_child_bus
;
564 len
= strlen(bus
->parent
->id
) + 16;
566 snprintf(buf
, len
, "%s.%d", bus
->parent
->id
, bus_id
);
569 /* no id -> use lowercase bus type plus global bus-id for bus name */
570 bc
= BUS_GET_CLASS(bus
);
571 bus_id
= bc
->automatic_ids
++;
573 len
= strlen(typename
) + 16;
575 len
= snprintf(buf
, len
, "%s.%d", typename
, bus_id
);
576 for (i
= 0; i
< len
; i
++) {
577 buf
[i
] = qemu_tolower(buf
[i
]);
583 QLIST_INSERT_HEAD(&bus
->parent
->child_bus
, bus
, sibling
);
584 bus
->parent
->num_child_bus
++;
585 object_property_add_child(OBJECT(bus
->parent
), bus
->name
, OBJECT(bus
), NULL
);
586 object_unref(OBJECT(bus
));
587 } else if (bus
!= sysbus_get_default()) {
588 /* TODO: once all bus devices are qdevified,
589 only reset handler for main_system_bus should be registered here. */
590 qemu_register_reset(qbus_reset_all_fn
, bus
);
594 static void bus_unparent(Object
*obj
)
596 BusState
*bus
= BUS(obj
);
599 while ((kid
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
600 DeviceState
*dev
= kid
->child
;
601 object_unparent(OBJECT(dev
));
604 QLIST_REMOVE(bus
, sibling
);
605 bus
->parent
->num_child_bus
--;
608 assert(bus
!= sysbus_get_default()); /* main_system_bus is never freed */
609 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
613 static bool bus_get_realized(Object
*obj
, Error
**errp
)
615 BusState
*bus
= BUS(obj
);
617 return bus
->realized
;
620 static void bus_set_realized(Object
*obj
, bool value
, Error
**errp
)
622 BusState
*bus
= BUS(obj
);
623 BusClass
*bc
= BUS_GET_CLASS(bus
);
625 Error
*local_err
= NULL
;
627 if (value
&& !bus
->realized
) {
629 bc
->realize(bus
, &local_err
);
632 /* TODO: recursive realization */
633 } else if (!value
&& bus
->realized
) {
634 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
635 DeviceState
*dev
= kid
->child
;
636 object_property_set_bool(OBJECT(dev
), false, "realized",
638 if (local_err
!= NULL
) {
642 if (bc
->unrealize
&& local_err
== NULL
) {
643 bc
->unrealize(bus
, &local_err
);
647 if (local_err
!= NULL
) {
648 error_propagate(errp
, local_err
);
652 bus
->realized
= value
;
655 void qbus_create_inplace(void *bus
, size_t size
, const char *typename
,
656 DeviceState
*parent
, const char *name
)
658 object_initialize(bus
, size
, typename
);
659 qbus_realize(bus
, parent
, name
);
662 BusState
*qbus_create(const char *typename
, DeviceState
*parent
, const char *name
)
666 bus
= BUS(object_new(typename
));
667 qbus_realize(bus
, parent
, name
);
672 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
674 BusClass
*bc
= BUS_GET_CLASS(bus
);
676 if (bc
->get_fw_dev_path
) {
677 return bc
->get_fw_dev_path(dev
);
683 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
685 Object
*obj
= OBJECT(dev
);
688 while (!d
&& obj
->parent
) {
690 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
695 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
699 if (dev
&& dev
->parent_bus
) {
701 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
702 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
704 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
707 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
713 l
+= snprintf(p
+ l
, size
- l
, "/");
718 char* qdev_get_fw_dev_path(DeviceState
*dev
)
723 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
727 return g_strdup(path
);
730 char *qdev_get_dev_path(DeviceState
*dev
)
734 if (!dev
|| !dev
->parent_bus
) {
738 bc
= BUS_GET_CLASS(dev
->parent_bus
);
739 if (bc
->get_dev_path
) {
740 return bc
->get_dev_path(dev
);
747 * Legacy property handling
750 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
, void *opaque
,
751 const char *name
, Error
**errp
)
753 DeviceState
*dev
= DEVICE(obj
);
754 Property
*prop
= opaque
;
759 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
760 visit_type_str(v
, &ptr
, name
, errp
);
764 * @qdev_add_legacy_property - adds a legacy property
766 * Do not use this is new code! Properties added through this interface will
767 * be given names and types in the "legacy" namespace.
769 * Legacy properties are string versions of other OOM properties. The format
770 * of the string depends on the property type.
772 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
777 /* Register pointer properties as legacy properties */
778 if (!prop
->info
->print
&& prop
->info
->get
) {
782 name
= g_strdup_printf("legacy-%s", prop
->name
);
783 object_property_add(OBJECT(dev
), name
, "str",
784 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
793 * @qdev_property_add_static - add a @Property to a device.
795 * Static properties access data in a struct. The actual type of the
796 * property and the field depends on the property type.
798 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
801 Error
*local_err
= NULL
;
802 Object
*obj
= OBJECT(dev
);
805 * TODO qdev_prop_ptr does not have getters or setters. It must
806 * go now that it can be replaced with links. The test should be
807 * removed along with it: all static properties are read/write.
809 if (!prop
->info
->get
&& !prop
->info
->set
) {
813 object_property_add(obj
, prop
->name
, prop
->info
->name
,
814 prop
->info
->get
, prop
->info
->set
,
819 error_propagate(errp
, local_err
);
822 if (prop
->qtype
== QTYPE_NONE
) {
826 if (prop
->qtype
== QTYPE_QBOOL
) {
827 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
828 } else if (prop
->info
->enum_table
) {
829 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
830 prop
->name
, &error_abort
);
831 } else if (prop
->qtype
== QTYPE_QINT
) {
832 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
836 /* @qdev_alias_all_properties - Add alias properties to the source object for
837 * all qdev properties on the target DeviceState.
839 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
844 class = object_get_class(OBJECT(target
));
846 DeviceClass
*dc
= DEVICE_CLASS(class);
848 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
849 object_property_add_alias(source
, prop
->name
,
850 OBJECT(target
), prop
->name
,
853 class = object_class_get_parent(class);
854 } while (class != object_class_by_name(TYPE_DEVICE
));
857 static bool device_get_realized(Object
*obj
, Error
**errp
)
859 DeviceState
*dev
= DEVICE(obj
);
860 return dev
->realized
;
863 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
865 DeviceState
*dev
= DEVICE(obj
);
866 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
868 Error
*local_err
= NULL
;
870 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
871 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
875 if (value
&& !dev
->realized
) {
877 static int unattached_count
;
878 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
880 object_property_add_child(container_get(qdev_get_machine(),
882 name
, obj
, &error_abort
);
887 dc
->realize(dev
, &local_err
);
890 if (local_err
!= NULL
) {
894 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
895 hotplug_handler_plug(dev
->parent_bus
->hotplug_handler
,
897 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE
)) {
898 HotplugHandler
*hotplug_ctrl
;
899 MachineState
*machine
= MACHINE(qdev_get_machine());
900 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
902 if (mc
->get_hotplug_handler
) {
903 hotplug_ctrl
= mc
->get_hotplug_handler(machine
, dev
);
905 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
910 if (local_err
!= NULL
) {
911 goto post_realize_fail
;
914 if (qdev_get_vmsd(dev
)) {
915 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
916 dev
->instance_id_alias
,
917 dev
->alias_required_for_version
);
920 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
921 object_property_set_bool(OBJECT(bus
), true, "realized",
923 if (local_err
!= NULL
) {
924 goto child_realize_fail
;
927 if (dev
->hotplugged
) {
930 dev
->pending_deleted_event
= false;
931 } else if (!value
&& dev
->realized
) {
932 Error
**local_errp
= NULL
;
933 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
934 local_errp
= local_err
? NULL
: &local_err
;
935 object_property_set_bool(OBJECT(bus
), false, "realized",
938 if (qdev_get_vmsd(dev
)) {
939 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
942 local_errp
= local_err
? NULL
: &local_err
;
943 dc
->unrealize(dev
, local_errp
);
945 dev
->pending_deleted_event
= true;
948 if (local_err
!= NULL
) {
952 dev
->realized
= value
;
956 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
957 object_property_set_bool(OBJECT(bus
), false, "realized",
961 if (qdev_get_vmsd(dev
)) {
962 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
967 dc
->unrealize(dev
, NULL
);
971 error_propagate(errp
, local_err
);
975 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
977 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
978 DeviceState
*dev
= DEVICE(obj
);
980 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
981 qbus_is_hotpluggable(dev
->parent_bus
));
984 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
986 DeviceState
*dev
= DEVICE(obj
);
988 return dev
->hotplugged
;
991 static void device_set_hotplugged(Object
*obj
, bool value
, Error
**err
)
993 DeviceState
*dev
= DEVICE(obj
);
995 dev
->hotplugged
= value
;
998 static void device_initfn(Object
*obj
)
1000 DeviceState
*dev
= DEVICE(obj
);
1005 dev
->hotplugged
= 1;
1006 qdev_hot_added
= true;
1009 dev
->instance_id_alias
= -1;
1010 dev
->realized
= false;
1012 object_property_add_bool(obj
, "realized",
1013 device_get_realized
, device_set_realized
, NULL
);
1014 object_property_add_bool(obj
, "hotpluggable",
1015 device_get_hotpluggable
, NULL
, NULL
);
1016 object_property_add_bool(obj
, "hotplugged",
1017 device_get_hotplugged
, device_set_hotplugged
,
1020 class = object_get_class(OBJECT(dev
));
1022 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
1023 qdev_property_add_legacy(dev
, prop
, &error_abort
);
1024 qdev_property_add_static(dev
, prop
, &error_abort
);
1026 class = object_class_get_parent(class);
1027 } while (class != object_class_by_name(TYPE_DEVICE
));
1029 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1030 (Object
**)&dev
->parent_bus
, NULL
, 0,
1032 QLIST_INIT(&dev
->gpios
);
1035 static void device_post_init(Object
*obj
)
1038 qdev_prop_set_globals(DEVICE(obj
), &err
);
1040 qerror_report_err(err
);
1046 /* Unlink device from bus and free the structure. */
1047 static void device_finalize(Object
*obj
)
1049 NamedGPIOList
*ngl
, *next
;
1051 DeviceState
*dev
= DEVICE(obj
);
1053 qemu_opts_del(dev
->opts
);
1056 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1057 QLIST_REMOVE(ngl
, node
);
1058 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1061 /* ngl->out irqs are owned by the other end and should not be freed
1067 static void device_class_base_init(ObjectClass
*class, void *data
)
1069 DeviceClass
*klass
= DEVICE_CLASS(class);
1071 /* We explicitly look up properties in the superclasses,
1072 * so do not propagate them to the subclasses.
1074 klass
->props
= NULL
;
1077 static void device_unparent(Object
*obj
)
1079 DeviceState
*dev
= DEVICE(obj
);
1082 if (dev
->realized
) {
1083 object_property_set_bool(obj
, false, "realized", NULL
);
1085 while (dev
->num_child_bus
) {
1086 bus
= QLIST_FIRST(&dev
->child_bus
);
1087 object_unparent(OBJECT(bus
));
1089 if (dev
->parent_bus
) {
1090 bus_remove_child(dev
->parent_bus
, dev
);
1091 object_unref(OBJECT(dev
->parent_bus
));
1092 dev
->parent_bus
= NULL
;
1095 /* Only send event if the device had been completely realized */
1096 if (dev
->pending_deleted_event
) {
1097 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
1099 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, path
, &error_abort
);
1104 static void device_class_init(ObjectClass
*class, void *data
)
1106 DeviceClass
*dc
= DEVICE_CLASS(class);
1108 class->unparent
= device_unparent
;
1109 dc
->realize
= device_realize
;
1110 dc
->unrealize
= device_unrealize
;
1112 /* by default all devices were considered as hotpluggable,
1113 * so with intent to check it in generic qdev_unplug() /
1114 * device_set_realized() functions make every device
1115 * hotpluggable. Devices that shouldn't be hotpluggable,
1116 * should override it in their class_init()
1118 dc
->hotpluggable
= true;
1121 void device_reset(DeviceState
*dev
)
1123 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1130 Object
*qdev_get_machine(void)
1135 dev
= container_get(object_get_root(), "/machine");
1141 static const TypeInfo device_type_info
= {
1142 .name
= TYPE_DEVICE
,
1143 .parent
= TYPE_OBJECT
,
1144 .instance_size
= sizeof(DeviceState
),
1145 .instance_init
= device_initfn
,
1146 .instance_post_init
= device_post_init
,
1147 .instance_finalize
= device_finalize
,
1148 .class_base_init
= device_class_base_init
,
1149 .class_init
= device_class_init
,
1151 .class_size
= sizeof(DeviceClass
),
1154 static void qbus_initfn(Object
*obj
)
1156 BusState
*bus
= BUS(obj
);
1158 QTAILQ_INIT(&bus
->children
);
1159 object_property_add_link(obj
, QDEV_HOTPLUG_HANDLER_PROPERTY
,
1160 TYPE_HOTPLUG_HANDLER
,
1161 (Object
**)&bus
->hotplug_handler
,
1162 object_property_allow_set_link
,
1163 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1165 object_property_add_bool(obj
, "realized",
1166 bus_get_realized
, bus_set_realized
, NULL
);
1169 static char *default_bus_get_fw_dev_path(DeviceState
*dev
)
1171 return g_strdup(object_get_typename(OBJECT(dev
)));
1174 static void bus_class_init(ObjectClass
*class, void *data
)
1176 BusClass
*bc
= BUS_CLASS(class);
1178 class->unparent
= bus_unparent
;
1179 bc
->get_fw_dev_path
= default_bus_get_fw_dev_path
;
1182 static void qbus_finalize(Object
*obj
)
1184 BusState
*bus
= BUS(obj
);
1186 g_free((char *)bus
->name
);
1189 static const TypeInfo bus_info
= {
1191 .parent
= TYPE_OBJECT
,
1192 .instance_size
= sizeof(BusState
),
1194 .class_size
= sizeof(BusClass
),
1195 .instance_init
= qbus_initfn
,
1196 .instance_finalize
= qbus_finalize
,
1197 .class_init
= bus_class_init
,
1200 static void qdev_register_types(void)
1202 type_register_static(&bus_info
);
1203 type_register_static(&device_type_info
);
1206 type_init(qdev_register_types
)