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 "monitor/monitor.h"
36 #include "hw/hotplug.h"
39 static bool qdev_hot_added
= false;
40 static bool qdev_hot_removed
= false;
42 const VMStateDescription
*qdev_get_vmsd(DeviceState
*dev
)
44 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
48 const char *qdev_fw_name(DeviceState
*dev
)
50 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
56 return object_get_typename(OBJECT(dev
));
59 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
62 static void bus_remove_child(BusState
*bus
, DeviceState
*child
)
66 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
67 if (kid
->child
== child
) {
70 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
71 QTAILQ_REMOVE(&bus
->children
, kid
, sibling
);
73 /* This gives back ownership of kid->child back to us. */
74 object_property_del(OBJECT(bus
), name
, NULL
);
75 object_unref(OBJECT(kid
->child
));
82 static void bus_add_child(BusState
*bus
, DeviceState
*child
)
85 BusChild
*kid
= g_malloc0(sizeof(*kid
));
88 assert(bus
->allow_hotplug
);
91 kid
->index
= bus
->max_index
++;
93 object_ref(OBJECT(kid
->child
));
95 QTAILQ_INSERT_HEAD(&bus
->children
, kid
, sibling
);
97 /* This transfers ownership of kid->child to the property. */
98 snprintf(name
, sizeof(name
), "child[%d]", kid
->index
);
99 object_property_add_link(OBJECT(bus
), name
,
100 object_get_typename(OBJECT(child
)),
101 (Object
**)&kid
->child
,
102 NULL
, /* read-only property */
103 0, /* return ownership on prop deletion */
107 void qdev_set_parent_bus(DeviceState
*dev
, BusState
*bus
)
109 dev
->parent_bus
= bus
;
110 object_ref(OBJECT(bus
));
111 bus_add_child(bus
, dev
);
114 /* Create a new device. This only initializes the device state structure
115 and allows properties to be set. qdev_init should be called to
116 initialize the actual device emulation. */
117 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
121 dev
= qdev_try_create(bus
, name
);
124 error_report("Unknown device '%s' for bus '%s'", name
,
125 object_get_typename(OBJECT(bus
)));
127 error_report("Unknown device '%s' for default sysbus", name
);
135 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
139 if (object_class_by_name(type
) == NULL
) {
142 dev
= DEVICE(object_new(type
));
148 bus
= sysbus_get_default();
151 qdev_set_parent_bus(dev
, bus
);
152 object_unref(OBJECT(dev
));
156 /* Initialize a device. Device properties should be set before calling
157 this function. IRQs and MMIO regions should be connected/mapped after
158 calling this function.
159 On failure, destroy the device and return negative value.
160 Return 0 on success. */
161 int qdev_init(DeviceState
*dev
)
163 Error
*local_err
= NULL
;
165 assert(!dev
->realized
);
167 object_property_set_bool(OBJECT(dev
), true, "realized", &local_err
);
168 if (local_err
!= NULL
) {
169 qerror_report_err(local_err
);
170 error_free(local_err
);
171 object_unparent(OBJECT(dev
));
177 static void device_realize(DeviceState
*dev
, Error
**errp
)
179 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
182 int rc
= dc
->init(dev
);
184 error_setg(errp
, "Device initialization failed.");
190 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
192 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
195 int rc
= dc
->exit(dev
);
197 error_setg(errp
, "Device exit failed.");
203 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
204 int required_for_version
)
206 assert(!dev
->realized
);
207 dev
->instance_id_alias
= alias_id
;
208 dev
->alias_required_for_version
= required_for_version
;
211 void qdev_unplug(DeviceState
*dev
, Error
**errp
)
213 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
215 if (dev
->parent_bus
&& !dev
->parent_bus
->allow_hotplug
) {
216 error_set(errp
, QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
220 if (!dc
->hotpluggable
) {
221 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
,
222 object_get_typename(OBJECT(dev
)));
226 qdev_hot_removed
= true;
228 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
229 hotplug_handler_unplug(dev
->parent_bus
->hotplug_handler
, dev
, errp
);
231 assert(dc
->unplug
!= NULL
);
232 if (dc
->unplug(dev
) < 0) { /* legacy handler */
233 error_set(errp
, QERR_UNDEFINED_ERROR
);
238 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
245 static int qbus_reset_one(BusState
*bus
, void *opaque
)
247 BusClass
*bc
= BUS_GET_CLASS(bus
);
254 void qdev_reset_all(DeviceState
*dev
)
256 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
259 void qbus_reset_all(BusState
*bus
)
261 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
264 void qbus_reset_all_fn(void *opaque
)
266 BusState
*bus
= opaque
;
270 /* can be used as ->unplug() callback for the simple cases */
271 int qdev_simple_unplug_cb(DeviceState
*dev
)
274 object_unparent(OBJECT(dev
));
279 /* Like qdev_init(), but terminate program via error_report() instead of
280 returning an error value. This is okay during machine creation.
281 Don't use for hotplug, because there callers need to recover from
282 failure. Exception: if you know the device's init() callback can't
283 fail, then qdev_init_nofail() can't fail either, and is therefore
284 usable even then. But relying on the device implementation that
285 way is somewhat unclean, and best avoided. */
286 void qdev_init_nofail(DeviceState
*dev
)
288 const char *typename
= object_get_typename(OBJECT(dev
));
290 if (qdev_init(dev
) < 0) {
291 error_report("Initialization of device %s failed", typename
);
296 void qdev_machine_creation_done(void)
299 * ok, initial machine setup is done, starting from now we can
300 * only create hotpluggable devices
305 bool qdev_machine_modified(void)
307 return qdev_hot_added
|| qdev_hot_removed
;
310 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
312 return dev
->parent_bus
;
315 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
320 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
321 /* NULL is a valid and matchable name, otherwise do a normal
324 if ((!ngl
->name
&& !name
) ||
325 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
330 ngl
= g_malloc0(sizeof(*ngl
));
331 ngl
->name
= g_strdup(name
);
332 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
336 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
337 const char *name
, int n
)
339 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
341 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
343 gpio_list
->num_in
+= n
;
346 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
348 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
351 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
352 const char *name
, int n
)
354 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
356 assert(gpio_list
->num_out
== 0);
357 gpio_list
->num_out
= n
;
358 gpio_list
->out
= pins
;
361 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
363 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
366 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
368 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
370 assert(n
>= 0 && n
< gpio_list
->num_in
);
371 return gpio_list
->in
[n
];
374 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
376 return qdev_get_gpio_in_named(dev
, NULL
, n
);
379 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
382 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
384 assert(n
>= 0 && n
< gpio_list
->num_out
);
385 gpio_list
->out
[n
] = pin
;
388 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
390 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
393 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
397 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
398 if (strcmp(name
, bus
->name
) == 0) {
405 int qbus_walk_children(BusState
*bus
,
406 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
407 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
414 err
= pre_busfn(bus
, opaque
);
420 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
421 err
= qdev_walk_children(kid
->child
,
422 pre_devfn
, pre_busfn
,
423 post_devfn
, post_busfn
, opaque
);
430 err
= post_busfn(bus
, opaque
);
439 int qdev_walk_children(DeviceState
*dev
,
440 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
441 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
448 err
= pre_devfn(dev
, opaque
);
454 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
455 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
456 post_devfn
, post_busfn
, opaque
);
463 err
= post_devfn(dev
, opaque
);
472 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
478 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
479 DeviceState
*dev
= kid
->child
;
481 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
485 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
486 ret
= qdev_find_recursive(child
, id
);
495 static void qbus_realize(BusState
*bus
, DeviceState
*parent
, const char *name
)
497 const char *typename
= object_get_typename(OBJECT(bus
));
502 bus
->parent
= parent
;
505 bus
->name
= g_strdup(name
);
506 } else if (bus
->parent
&& bus
->parent
->id
) {
507 /* parent device has id -> use it plus parent-bus-id for bus name */
508 bus_id
= bus
->parent
->num_child_bus
;
510 len
= strlen(bus
->parent
->id
) + 16;
512 snprintf(buf
, len
, "%s.%d", bus
->parent
->id
, bus_id
);
515 /* no id -> use lowercase bus type plus global bus-id for bus name */
516 bc
= BUS_GET_CLASS(bus
);
517 bus_id
= bc
->automatic_ids
++;
519 len
= strlen(typename
) + 16;
521 len
= snprintf(buf
, len
, "%s.%d", typename
, bus_id
);
522 for (i
= 0; i
< len
; i
++) {
523 buf
[i
] = qemu_tolower(buf
[i
]);
529 QLIST_INSERT_HEAD(&bus
->parent
->child_bus
, bus
, sibling
);
530 bus
->parent
->num_child_bus
++;
531 object_property_add_child(OBJECT(bus
->parent
), bus
->name
, OBJECT(bus
), NULL
);
532 object_unref(OBJECT(bus
));
533 } else if (bus
!= sysbus_get_default()) {
534 /* TODO: once all bus devices are qdevified,
535 only reset handler for main_system_bus should be registered here. */
536 qemu_register_reset(qbus_reset_all_fn
, bus
);
540 static void bus_unparent(Object
*obj
)
542 BusState
*bus
= BUS(obj
);
545 while ((kid
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
546 DeviceState
*dev
= kid
->child
;
547 object_unparent(OBJECT(dev
));
550 QLIST_REMOVE(bus
, sibling
);
551 bus
->parent
->num_child_bus
--;
554 assert(bus
!= sysbus_get_default()); /* main_system_bus is never freed */
555 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
559 static bool bus_get_realized(Object
*obj
, Error
**errp
)
561 BusState
*bus
= BUS(obj
);
563 return bus
->realized
;
566 static void bus_set_realized(Object
*obj
, bool value
, Error
**errp
)
568 BusState
*bus
= BUS(obj
);
569 BusClass
*bc
= BUS_GET_CLASS(bus
);
570 Error
*local_err
= NULL
;
572 if (value
&& !bus
->realized
) {
574 bc
->realize(bus
, &local_err
);
576 if (local_err
!= NULL
) {
581 } else if (!value
&& bus
->realized
) {
583 bc
->unrealize(bus
, &local_err
);
585 if (local_err
!= NULL
) {
591 bus
->realized
= value
;
595 error_propagate(errp
, local_err
);
598 void qbus_create_inplace(void *bus
, size_t size
, const char *typename
,
599 DeviceState
*parent
, const char *name
)
601 object_initialize(bus
, size
, typename
);
602 qbus_realize(bus
, parent
, name
);
605 BusState
*qbus_create(const char *typename
, DeviceState
*parent
, const char *name
)
609 bus
= BUS(object_new(typename
));
610 qbus_realize(bus
, parent
, name
);
615 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
617 BusClass
*bc
= BUS_GET_CLASS(bus
);
619 if (bc
->get_fw_dev_path
) {
620 return bc
->get_fw_dev_path(dev
);
626 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
628 Object
*obj
= OBJECT(dev
);
631 while (!d
&& obj
->parent
) {
633 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
638 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
642 if (dev
&& dev
->parent_bus
) {
644 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
645 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
647 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
650 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
656 l
+= snprintf(p
+ l
, size
- l
, "/");
661 char* qdev_get_fw_dev_path(DeviceState
*dev
)
666 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
670 return g_strdup(path
);
673 char *qdev_get_dev_path(DeviceState
*dev
)
677 if (!dev
|| !dev
->parent_bus
) {
681 bc
= BUS_GET_CLASS(dev
->parent_bus
);
682 if (bc
->get_dev_path
) {
683 return bc
->get_dev_path(dev
);
690 * Legacy property handling
693 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
, void *opaque
,
694 const char *name
, Error
**errp
)
696 DeviceState
*dev
= DEVICE(obj
);
697 Property
*prop
= opaque
;
702 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
703 visit_type_str(v
, &ptr
, name
, errp
);
707 * @qdev_add_legacy_property - adds a legacy property
709 * Do not use this is new code! Properties added through this interface will
710 * be given names and types in the "legacy" namespace.
712 * Legacy properties are string versions of other OOM properties. The format
713 * of the string depends on the property type.
715 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
720 /* Register pointer properties as legacy properties */
721 if (!prop
->info
->print
&& prop
->info
->get
) {
725 name
= g_strdup_printf("legacy-%s", prop
->name
);
726 object_property_add(OBJECT(dev
), name
, "str",
727 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
736 * @qdev_property_add_static - add a @Property to a device.
738 * Static properties access data in a struct. The actual type of the
739 * property and the field depends on the property type.
741 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
744 Error
*local_err
= NULL
;
745 Object
*obj
= OBJECT(dev
);
748 * TODO qdev_prop_ptr does not have getters or setters. It must
749 * go now that it can be replaced with links. The test should be
750 * removed along with it: all static properties are read/write.
752 if (!prop
->info
->get
&& !prop
->info
->set
) {
756 object_property_add(obj
, prop
->name
, prop
->info
->name
,
757 prop
->info
->get
, prop
->info
->set
,
762 error_propagate(errp
, local_err
);
765 if (prop
->qtype
== QTYPE_NONE
) {
769 if (prop
->qtype
== QTYPE_QBOOL
) {
770 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
771 } else if (prop
->info
->enum_table
) {
772 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
773 prop
->name
, &error_abort
);
774 } else if (prop
->qtype
== QTYPE_QINT
) {
775 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
779 static bool device_get_realized(Object
*obj
, Error
**errp
)
781 DeviceState
*dev
= DEVICE(obj
);
782 return dev
->realized
;
785 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
787 DeviceState
*dev
= DEVICE(obj
);
788 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
790 Error
*local_err
= NULL
;
792 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
793 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
797 if (value
&& !dev
->realized
) {
798 if (!obj
->parent
&& local_err
== NULL
) {
799 static int unattached_count
;
800 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
802 object_property_add_child(container_get(qdev_get_machine(),
804 name
, obj
, &local_err
);
809 dc
->realize(dev
, &local_err
);
812 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
&&
814 hotplug_handler_plug(dev
->parent_bus
->hotplug_handler
,
818 if (qdev_get_vmsd(dev
) && local_err
== NULL
) {
819 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
820 dev
->instance_id_alias
,
821 dev
->alias_required_for_version
);
823 if (local_err
== NULL
) {
824 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
825 object_property_set_bool(OBJECT(bus
), true, "realized",
827 if (local_err
!= NULL
) {
832 if (dev
->hotplugged
&& local_err
== NULL
) {
835 } else if (!value
&& dev
->realized
) {
836 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
837 object_property_set_bool(OBJECT(bus
), false, "realized",
839 if (local_err
!= NULL
) {
843 if (qdev_get_vmsd(dev
) && local_err
== NULL
) {
844 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
846 if (dc
->unrealize
&& local_err
== NULL
) {
847 dc
->unrealize(dev
, &local_err
);
851 if (local_err
!= NULL
) {
852 error_propagate(errp
, local_err
);
856 dev
->realized
= value
;
859 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
861 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
862 DeviceState
*dev
= DEVICE(obj
);
864 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
865 dev
->parent_bus
->allow_hotplug
);
868 static void device_initfn(Object
*obj
)
870 DeviceState
*dev
= DEVICE(obj
);
876 qdev_hot_added
= true;
879 dev
->instance_id_alias
= -1;
880 dev
->realized
= false;
882 object_property_add_bool(obj
, "realized",
883 device_get_realized
, device_set_realized
, NULL
);
884 object_property_add_bool(obj
, "hotpluggable",
885 device_get_hotpluggable
, NULL
, NULL
);
887 class = object_get_class(OBJECT(dev
));
889 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
890 qdev_property_add_legacy(dev
, prop
, &error_abort
);
891 qdev_property_add_static(dev
, prop
, &error_abort
);
893 class = object_class_get_parent(class);
894 } while (class != object_class_by_name(TYPE_DEVICE
));
896 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
897 (Object
**)&dev
->parent_bus
, NULL
, 0,
899 QLIST_INIT(&dev
->gpios
);
902 static void device_post_init(Object
*obj
)
904 qdev_prop_set_globals(DEVICE(obj
), &error_abort
);
907 /* Unlink device from bus and free the structure. */
908 static void device_finalize(Object
*obj
)
910 NamedGPIOList
*ngl
, *next
;
912 DeviceState
*dev
= DEVICE(obj
);
914 qemu_opts_del(dev
->opts
);
917 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
918 QLIST_REMOVE(ngl
, node
);
919 qemu_free_irqs(ngl
->in
);
922 /* ngl->out irqs are owned by the other end and should not be freed
928 static void device_class_base_init(ObjectClass
*class, void *data
)
930 DeviceClass
*klass
= DEVICE_CLASS(class);
932 /* We explicitly look up properties in the superclasses,
933 * so do not propagate them to the subclasses.
938 static void device_unparent(Object
*obj
)
940 DeviceState
*dev
= DEVICE(obj
);
943 bool have_realized
= dev
->realized
;
946 object_property_set_bool(obj
, false, "realized", NULL
);
948 while (dev
->num_child_bus
) {
949 bus
= QLIST_FIRST(&dev
->child_bus
);
950 object_unparent(OBJECT(bus
));
952 if (dev
->parent_bus
) {
953 bus_remove_child(dev
->parent_bus
, dev
);
954 object_unref(OBJECT(dev
->parent_bus
));
955 dev
->parent_bus
= NULL
;
958 /* Only send event if the device had been completely realized */
960 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
963 event_data
= qobject_from_jsonf("{ 'device': %s, 'path': %s }",
966 event_data
= qobject_from_jsonf("{ 'path': %s }", path
);
968 monitor_protocol_event(QEVENT_DEVICE_DELETED
, event_data
);
969 qobject_decref(event_data
);
974 static void device_class_init(ObjectClass
*class, void *data
)
976 DeviceClass
*dc
= DEVICE_CLASS(class);
978 class->unparent
= device_unparent
;
979 dc
->realize
= device_realize
;
980 dc
->unrealize
= device_unrealize
;
982 /* by default all devices were considered as hotpluggable,
983 * so with intent to check it in generic qdev_unplug() /
984 * device_set_realized() functions make every device
985 * hotpluggable. Devices that shouldn't be hotpluggable,
986 * should override it in their class_init()
988 dc
->hotpluggable
= true;
991 void device_reset(DeviceState
*dev
)
993 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1000 Object
*qdev_get_machine(void)
1005 dev
= container_get(object_get_root(), "/machine");
1011 static const TypeInfo device_type_info
= {
1012 .name
= TYPE_DEVICE
,
1013 .parent
= TYPE_OBJECT
,
1014 .instance_size
= sizeof(DeviceState
),
1015 .instance_init
= device_initfn
,
1016 .instance_post_init
= device_post_init
,
1017 .instance_finalize
= device_finalize
,
1018 .class_base_init
= device_class_base_init
,
1019 .class_init
= device_class_init
,
1021 .class_size
= sizeof(DeviceClass
),
1024 static void qbus_initfn(Object
*obj
)
1026 BusState
*bus
= BUS(obj
);
1028 QTAILQ_INIT(&bus
->children
);
1029 object_property_add_link(obj
, QDEV_HOTPLUG_HANDLER_PROPERTY
,
1030 TYPE_HOTPLUG_HANDLER
,
1031 (Object
**)&bus
->hotplug_handler
,
1032 object_property_allow_set_link
,
1033 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1035 object_property_add_bool(obj
, "realized",
1036 bus_get_realized
, bus_set_realized
, NULL
);
1039 static char *default_bus_get_fw_dev_path(DeviceState
*dev
)
1041 return g_strdup(object_get_typename(OBJECT(dev
)));
1044 static void bus_class_init(ObjectClass
*class, void *data
)
1046 BusClass
*bc
= BUS_CLASS(class);
1048 class->unparent
= bus_unparent
;
1049 bc
->get_fw_dev_path
= default_bus_get_fw_dev_path
;
1052 static void qbus_finalize(Object
*obj
)
1054 BusState
*bus
= BUS(obj
);
1056 g_free((char *)bus
->name
);
1059 static const TypeInfo bus_info
= {
1061 .parent
= TYPE_OBJECT
,
1062 .instance_size
= sizeof(BusState
),
1064 .class_size
= sizeof(BusClass
),
1065 .instance_init
= qbus_initfn
,
1066 .instance_finalize
= qbus_finalize
,
1067 .class_init
= bus_class_init
,
1070 static void qdev_register_types(void)
1072 type_register_static(&bus_info
);
1073 type_register_static(&device_type_info
);
1076 type_init(qdev_register_types
)