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
));
89 assert(qbus_is_hotpluggable(bus
));
92 kid
->index
= bus
->max_index
++;
94 object_ref(OBJECT(kid
->child
));
96 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
98 /* This transfers ownership of kid->child to the property. */
99 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
100 object_property_add_link(OBJECT(bus
), name
,
101 object_get_typename(OBJECT(child
)),
102 (Object
**)&kid
->child
,
103 NULL
, /* read-only property */
104 0, /* return ownership on prop deletion */
108 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
110 dev
->parent_bus
= bus
;
111 object_ref(OBJECT(bus
));
112 bus_add_child(bus
, dev
);
115 /* Create a new device. This only initializes the device state structure
116 and allows properties to be set. qdev_init should be called to
117 initialize the actual device emulation. */
118 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
122 dev
= qdev_try_create(bus
, name
);
125 error_report("Unknown device '%s' for bus '%s'", name
,
126 object_get_typename(OBJECT(bus
)));
128 error_report("Unknown device '%s' for default sysbus", name
);
136 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
140 if (object_class_by_name(type
) == NULL
) {
143 dev
= DEVICE(object_new(type
));
149 bus
= sysbus_get_default();
152 qdev_set_parent_bus(dev
, bus
);
153 object_unref(OBJECT(dev
));
157 /* Initialize a device. Device properties should be set before calling
158 this function. IRQs and MMIO regions should be connected/mapped after
159 calling this function.
160 On failure, destroy the device and return negative value.
161 Return 0 on success. */
162 int qdev_init(DeviceState
*dev
)
164 Error
*local_err
= NULL
;
166 assert(!dev
->realized
);
168 object_property_set_bool(OBJECT(dev
), true, "realized", &local_err
);
169 if (local_err
!= NULL
) {
170 qerror_report_err(local_err
);
171 error_free(local_err
);
172 object_unparent(OBJECT(dev
));
178 static void device_realize(DeviceState
*dev
, Error
**errp
)
180 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
183 int rc
= dc
->init(dev
);
185 error_setg(errp
, "Device initialization failed.");
191 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
193 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
196 int rc
= dc
->exit(dev
);
198 error_setg(errp
, "Device exit failed.");
204 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
205 int required_for_version
)
207 assert(!dev
->realized
);
208 dev
->instance_id_alias
= alias_id
;
209 dev
->alias_required_for_version
= required_for_version
;
212 void qdev_unplug(DeviceState
*dev
, Error
**errp
)
214 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
216 if (dev
->parent_bus
&& !qbus_is_hotpluggable(dev
->parent_bus
)) {
217 error_set(errp
, QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
221 if (!dc
->hotpluggable
) {
222 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
,
223 object_get_typename(OBJECT(dev
)));
227 qdev_hot_removed
= true;
229 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
230 hotplug_handler_unplug(dev
->parent_bus
->hotplug_handler
, dev
, errp
);
232 assert(dc
->unplug
!= NULL
);
233 if (dc
->unplug(dev
) < 0) { /* legacy handler */
234 error_set(errp
, QERR_UNDEFINED_ERROR
);
239 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
246 static int qbus_reset_one(BusState
*bus
, void *opaque
)
248 BusClass
*bc
= BUS_GET_CLASS(bus
);
255 void qdev_reset_all(DeviceState
*dev
)
257 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
260 void qbus_reset_all(BusState
*bus
)
262 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
265 void qbus_reset_all_fn(void *opaque
)
267 BusState
*bus
= opaque
;
271 /* can be used as ->unplug() callback for the simple cases */
272 int qdev_simple_unplug_cb(DeviceState
*dev
)
275 object_unparent(OBJECT(dev
));
280 /* Like qdev_init(), but terminate program via error_report() instead of
281 returning an error value. This is okay during machine creation.
282 Don't use for hotplug, because there callers need to recover from
283 failure. Exception: if you know the device's init() callback can't
284 fail, then qdev_init_nofail() can't fail either, and is therefore
285 usable even then. But relying on the device implementation that
286 way is somewhat unclean, and best avoided. */
287 void qdev_init_nofail(DeviceState
*dev
)
289 const char *typename
= object_get_typename(OBJECT(dev
));
291 if (qdev_init(dev
) < 0) {
292 error_report("Initialization of device %s failed", typename
);
297 void qdev_machine_creation_done(void)
300 * ok, initial machine setup is done, starting from now we can
301 * only create hotpluggable devices
306 bool qdev_machine_modified(void)
308 return qdev_hot_added
|| qdev_hot_removed
;
311 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
313 return dev
->parent_bus
;
316 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
321 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
322 /* NULL is a valid and matchable name, otherwise do a normal
325 if ((!ngl
->name
&& !name
) ||
326 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
331 ngl
= g_malloc0(sizeof(*ngl
));
332 ngl
->name
= g_strdup(name
);
333 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
337 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
338 const char *name
, int n
)
341 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
342 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-in");
344 assert(gpio_list
->num_out
== 0 || !name
);
345 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
348 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
349 object_property_add_child(OBJECT(dev
), propname
,
350 OBJECT(gpio_list
->in
[i
]), &error_abort
);
354 gpio_list
->num_in
+= n
;
357 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
359 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
362 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
363 const char *name
, int n
)
366 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
367 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-out");
369 assert(gpio_list
->num_in
== 0 || !name
);
370 assert(gpio_list
->num_out
== 0);
371 gpio_list
->num_out
= n
;
372 gpio_list
->out
= pins
;
374 for (i
= 0; i
< n
; ++i
) {
375 memset(&pins
[i
], 0, sizeof(*pins
));
376 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
378 object_property_allow_set_link
,
379 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
385 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
387 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
390 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
392 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
394 assert(n
>= 0 && n
< gpio_list
->num_in
);
395 return gpio_list
->in
[n
];
398 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
400 return qdev_get_gpio_in_named(dev
, NULL
, n
);
403 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
406 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
408 assert(n
>= 0 && n
< gpio_list
->num_out
);
409 gpio_list
->out
[n
] = pin
;
412 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
414 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
417 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
421 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
422 if (strcmp(name
, bus
->name
) == 0) {
429 int qbus_walk_children(BusState
*bus
,
430 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
431 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
438 err
= pre_busfn(bus
, opaque
);
444 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
445 err
= qdev_walk_children(kid
->child
,
446 pre_devfn
, pre_busfn
,
447 post_devfn
, post_busfn
, opaque
);
454 err
= post_busfn(bus
, opaque
);
463 int qdev_walk_children(DeviceState
*dev
,
464 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
465 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
472 err
= pre_devfn(dev
, opaque
);
478 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
479 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
480 post_devfn
, post_busfn
, opaque
);
487 err
= post_devfn(dev
, opaque
);
496 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
502 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
503 DeviceState
*dev
= kid
->child
;
505 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
509 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
510 ret
= qdev_find_recursive(child
, id
);
519 static void qbus_realize(BusState
*bus
, DeviceState
*parent
, const char *name
)
521 const char *typename
= object_get_typename(OBJECT(bus
));
526 bus
->parent
= parent
;
529 bus
->name
= g_strdup(name
);
530 } else if (bus
->parent
&& bus
->parent
->id
) {
531 /* parent device has id -> use it plus parent-bus-id for bus name */
532 bus_id
= bus
->parent
->num_child_bus
;
534 len
= strlen(bus
->parent
->id
) + 16;
536 snprintf(buf
, len
, "%s.%d", bus
->parent
->id
, bus_id
);
539 /* no id -> use lowercase bus type plus global bus-id for bus name */
540 bc
= BUS_GET_CLASS(bus
);
541 bus_id
= bc
->automatic_ids
++;
543 len
= strlen(typename
) + 16;
545 len
= snprintf(buf
, len
, "%s.%d", typename
, bus_id
);
546 for (i
= 0; i
< len
; i
++) {
547 buf
[i
] = qemu_tolower(buf
[i
]);
553 QLIST_INSERT_HEAD(&bus
->parent
->child_bus
, bus
, sibling
);
554 bus
->parent
->num_child_bus
++;
555 object_property_add_child(OBJECT(bus
->parent
), bus
->name
, OBJECT(bus
), NULL
);
556 object_unref(OBJECT(bus
));
557 } else if (bus
!= sysbus_get_default()) {
558 /* TODO: once all bus devices are qdevified,
559 only reset handler for main_system_bus should be registered here. */
560 qemu_register_reset(qbus_reset_all_fn
, bus
);
564 static void bus_unparent(Object
*obj
)
566 BusState
*bus
= BUS(obj
);
569 while ((kid
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
570 DeviceState
*dev
= kid
->child
;
571 object_unparent(OBJECT(dev
));
574 QLIST_REMOVE(bus
, sibling
);
575 bus
->parent
->num_child_bus
--;
578 assert(bus
!= sysbus_get_default()); /* main_system_bus is never freed */
579 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
583 static bool bus_get_realized(Object
*obj
, Error
**errp
)
585 BusState
*bus
= BUS(obj
);
587 return bus
->realized
;
590 static void bus_set_realized(Object
*obj
, bool value
, Error
**errp
)
592 BusState
*bus
= BUS(obj
);
593 BusClass
*bc
= BUS_GET_CLASS(bus
);
595 Error
*local_err
= NULL
;
597 if (value
&& !bus
->realized
) {
599 bc
->realize(bus
, &local_err
);
602 /* TODO: recursive realization */
603 } else if (!value
&& bus
->realized
) {
604 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
605 DeviceState
*dev
= kid
->child
;
606 object_property_set_bool(OBJECT(dev
), false, "realized",
608 if (local_err
!= NULL
) {
612 if (bc
->unrealize
&& local_err
== NULL
) {
613 bc
->unrealize(bus
, &local_err
);
617 if (local_err
!= NULL
) {
618 error_propagate(errp
, local_err
);
622 bus
->realized
= value
;
625 void qbus_create_inplace(void *bus
, size_t size
, const char *typename
,
626 DeviceState
*parent
, const char *name
)
628 object_initialize(bus
, size
, typename
);
629 qbus_realize(bus
, parent
, name
);
632 BusState
*qbus_create(const char *typename
, DeviceState
*parent
, const char *name
)
636 bus
= BUS(object_new(typename
));
637 qbus_realize(bus
, parent
, name
);
642 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
644 BusClass
*bc
= BUS_GET_CLASS(bus
);
646 if (bc
->get_fw_dev_path
) {
647 return bc
->get_fw_dev_path(dev
);
653 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
655 Object
*obj
= OBJECT(dev
);
658 while (!d
&& obj
->parent
) {
660 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
665 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
669 if (dev
&& dev
->parent_bus
) {
671 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
672 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
674 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
677 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
683 l
+= snprintf(p
+ l
, size
- l
, "/");
688 char* qdev_get_fw_dev_path(DeviceState
*dev
)
693 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
697 return g_strdup(path
);
700 char *qdev_get_dev_path(DeviceState
*dev
)
704 if (!dev
|| !dev
->parent_bus
) {
708 bc
= BUS_GET_CLASS(dev
->parent_bus
);
709 if (bc
->get_dev_path
) {
710 return bc
->get_dev_path(dev
);
717 * Legacy property handling
720 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
, void *opaque
,
721 const char *name
, Error
**errp
)
723 DeviceState
*dev
= DEVICE(obj
);
724 Property
*prop
= opaque
;
729 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
730 visit_type_str(v
, &ptr
, name
, errp
);
734 * @qdev_add_legacy_property - adds a legacy property
736 * Do not use this is new code! Properties added through this interface will
737 * be given names and types in the "legacy" namespace.
739 * Legacy properties are string versions of other OOM properties. The format
740 * of the string depends on the property type.
742 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
747 /* Register pointer properties as legacy properties */
748 if (!prop
->info
->print
&& prop
->info
->get
) {
752 name
= g_strdup_printf("legacy-%s", prop
->name
);
753 object_property_add(OBJECT(dev
), name
, "str",
754 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
763 * @qdev_property_add_static - add a @Property to a device.
765 * Static properties access data in a struct. The actual type of the
766 * property and the field depends on the property type.
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
);
792 if (prop
->qtype
== QTYPE_NONE
) {
796 if (prop
->qtype
== QTYPE_QBOOL
) {
797 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
798 } else if (prop
->info
->enum_table
) {
799 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
800 prop
->name
, &error_abort
);
801 } else if (prop
->qtype
== QTYPE_QINT
) {
802 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
806 /* @qdev_alias_all_properties - Add alias properties to the source object for
807 * all qdev properties on the target DeviceState.
809 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
814 class = object_get_class(OBJECT(target
));
816 DeviceClass
*dc
= DEVICE_CLASS(class);
818 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
819 object_property_add_alias(source
, prop
->name
,
820 OBJECT(target
), prop
->name
,
823 class = object_class_get_parent(class);
824 } while (class != object_class_by_name(TYPE_DEVICE
));
827 static bool device_get_realized(Object
*obj
, Error
**errp
)
829 DeviceState
*dev
= DEVICE(obj
);
830 return dev
->realized
;
833 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
835 DeviceState
*dev
= DEVICE(obj
);
836 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
838 Error
*local_err
= NULL
;
840 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
841 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
845 if (value
&& !dev
->realized
) {
847 static int unattached_count
;
848 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
850 object_property_add_child(container_get(qdev_get_machine(),
852 name
, obj
, &error_abort
);
857 dc
->realize(dev
, &local_err
);
860 if (local_err
!= NULL
) {
864 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
865 hotplug_handler_plug(dev
->parent_bus
->hotplug_handler
,
867 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE
)) {
868 HotplugHandler
*hotplug_ctrl
;
869 MachineState
*machine
= MACHINE(qdev_get_machine());
870 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
872 if (mc
->get_hotplug_handler
) {
873 hotplug_ctrl
= mc
->get_hotplug_handler(machine
, dev
);
875 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
880 if (local_err
!= NULL
) {
881 goto post_realize_fail
;
884 if (qdev_get_vmsd(dev
)) {
885 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
886 dev
->instance_id_alias
,
887 dev
->alias_required_for_version
);
890 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
891 object_property_set_bool(OBJECT(bus
), true, "realized",
893 if (local_err
!= NULL
) {
894 goto child_realize_fail
;
897 if (dev
->hotplugged
) {
900 dev
->pending_deleted_event
= false;
901 } else if (!value
&& dev
->realized
) {
902 Error
**local_errp
= NULL
;
903 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
904 local_errp
= local_err
? NULL
: &local_err
;
905 object_property_set_bool(OBJECT(bus
), false, "realized",
908 if (qdev_get_vmsd(dev
)) {
909 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
912 local_errp
= local_err
? NULL
: &local_err
;
913 dc
->unrealize(dev
, local_errp
);
915 dev
->pending_deleted_event
= true;
918 if (local_err
!= NULL
) {
922 dev
->realized
= value
;
926 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
927 object_property_set_bool(OBJECT(bus
), false, "realized",
931 if (qdev_get_vmsd(dev
)) {
932 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
937 dc
->unrealize(dev
, NULL
);
941 error_propagate(errp
, local_err
);
945 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
947 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
948 DeviceState
*dev
= DEVICE(obj
);
950 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
951 qbus_is_hotpluggable(dev
->parent_bus
));
954 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
956 DeviceState
*dev
= DEVICE(obj
);
958 return dev
->hotplugged
;
961 static void device_set_hotplugged(Object
*obj
, bool value
, Error
**err
)
963 DeviceState
*dev
= DEVICE(obj
);
965 dev
->hotplugged
= value
;
968 static void device_initfn(Object
*obj
)
970 DeviceState
*dev
= DEVICE(obj
);
976 qdev_hot_added
= true;
979 dev
->instance_id_alias
= -1;
980 dev
->realized
= false;
982 object_property_add_bool(obj
, "realized",
983 device_get_realized
, device_set_realized
, NULL
);
984 object_property_add_bool(obj
, "hotpluggable",
985 device_get_hotpluggable
, NULL
, NULL
);
986 object_property_add_bool(obj
, "hotplugged",
987 device_get_hotplugged
, device_set_hotplugged
,
990 class = object_get_class(OBJECT(dev
));
992 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
993 qdev_property_add_legacy(dev
, prop
, &error_abort
);
994 qdev_property_add_static(dev
, prop
, &error_abort
);
996 class = object_class_get_parent(class);
997 } while (class != object_class_by_name(TYPE_DEVICE
));
999 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1000 (Object
**)&dev
->parent_bus
, NULL
, 0,
1002 QLIST_INIT(&dev
->gpios
);
1005 static void device_post_init(Object
*obj
)
1008 qdev_prop_set_globals(DEVICE(obj
), &err
);
1010 qerror_report_err(err
);
1016 /* Unlink device from bus and free the structure. */
1017 static void device_finalize(Object
*obj
)
1019 NamedGPIOList
*ngl
, *next
;
1021 DeviceState
*dev
= DEVICE(obj
);
1023 qemu_opts_del(dev
->opts
);
1026 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1027 QLIST_REMOVE(ngl
, node
);
1028 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1031 /* ngl->out irqs are owned by the other end and should not be freed
1037 static void device_class_base_init(ObjectClass
*class, void *data
)
1039 DeviceClass
*klass
= DEVICE_CLASS(class);
1041 /* We explicitly look up properties in the superclasses,
1042 * so do not propagate them to the subclasses.
1044 klass
->props
= NULL
;
1047 static void device_unparent(Object
*obj
)
1049 DeviceState
*dev
= DEVICE(obj
);
1052 if (dev
->realized
) {
1053 object_property_set_bool(obj
, false, "realized", NULL
);
1055 while (dev
->num_child_bus
) {
1056 bus
= QLIST_FIRST(&dev
->child_bus
);
1057 object_unparent(OBJECT(bus
));
1059 if (dev
->parent_bus
) {
1060 bus_remove_child(dev
->parent_bus
, dev
);
1061 object_unref(OBJECT(dev
->parent_bus
));
1062 dev
->parent_bus
= NULL
;
1065 /* Only send event if the device had been completely realized */
1066 if (dev
->pending_deleted_event
) {
1067 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
1069 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, path
, &error_abort
);
1074 static void device_class_init(ObjectClass
*class, void *data
)
1076 DeviceClass
*dc
= DEVICE_CLASS(class);
1078 class->unparent
= device_unparent
;
1079 dc
->realize
= device_realize
;
1080 dc
->unrealize
= device_unrealize
;
1082 /* by default all devices were considered as hotpluggable,
1083 * so with intent to check it in generic qdev_unplug() /
1084 * device_set_realized() functions make every device
1085 * hotpluggable. Devices that shouldn't be hotpluggable,
1086 * should override it in their class_init()
1088 dc
->hotpluggable
= true;
1091 void device_reset(DeviceState
*dev
)
1093 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1100 Object
*qdev_get_machine(void)
1105 dev
= container_get(object_get_root(), "/machine");
1111 static const TypeInfo device_type_info
= {
1112 .name
= TYPE_DEVICE
,
1113 .parent
= TYPE_OBJECT
,
1114 .instance_size
= sizeof(DeviceState
),
1115 .instance_init
= device_initfn
,
1116 .instance_post_init
= device_post_init
,
1117 .instance_finalize
= device_finalize
,
1118 .class_base_init
= device_class_base_init
,
1119 .class_init
= device_class_init
,
1121 .class_size
= sizeof(DeviceClass
),
1124 static void qbus_initfn(Object
*obj
)
1126 BusState
*bus
= BUS(obj
);
1128 QTAILQ_INIT(&bus
->children
);
1129 object_property_add_link(obj
, QDEV_HOTPLUG_HANDLER_PROPERTY
,
1130 TYPE_HOTPLUG_HANDLER
,
1131 (Object
**)&bus
->hotplug_handler
,
1132 object_property_allow_set_link
,
1133 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1135 object_property_add_bool(obj
, "realized",
1136 bus_get_realized
, bus_set_realized
, NULL
);
1139 static char *default_bus_get_fw_dev_path(DeviceState
*dev
)
1141 return g_strdup(object_get_typename(OBJECT(dev
)));
1144 static void bus_class_init(ObjectClass
*class, void *data
)
1146 BusClass
*bc
= BUS_CLASS(class);
1148 class->unparent
= bus_unparent
;
1149 bc
->get_fw_dev_path
= default_bus_get_fw_dev_path
;
1152 static void qbus_finalize(Object
*obj
)
1154 BusState
*bus
= BUS(obj
);
1156 g_free((char *)bus
->name
);
1159 static const TypeInfo bus_info
= {
1161 .parent
= TYPE_OBJECT
,
1162 .instance_size
= sizeof(BusState
),
1164 .class_size
= sizeof(BusClass
),
1165 .instance_init
= qbus_initfn
,
1166 .instance_finalize
= qbus_finalize
,
1167 .class_init
= bus_class_init
,
1170 static void qdev_register_types(void)
1172 type_register_static(&bus_info
);
1173 type_register_static(&device_type_info
);
1176 type_init(qdev_register_types
)