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
);
119 void qbus_set_hotplug_handler(BusState
*bus
, DeviceState
*handler
, Error
**errp
)
121 qbus_set_hotplug_handler_internal(bus
, OBJECT(handler
), errp
);
124 void qbus_set_bus_hotplug_handler(BusState
*bus
, Error
**errp
)
126 qbus_set_hotplug_handler_internal(bus
, OBJECT(bus
), errp
);
129 /* Create a new device. This only initializes the device state structure
130 and allows properties to be set. qdev_init should be called to
131 initialize the actual device emulation. */
132 DeviceState
*qdev_create(BusState
*bus
, const char *name
)
136 dev
= qdev_try_create(bus
, name
);
139 error_report("Unknown device '%s' for bus '%s'", name
,
140 object_get_typename(OBJECT(bus
)));
142 error_report("Unknown device '%s' for default sysbus", name
);
150 DeviceState
*qdev_try_create(BusState
*bus
, const char *type
)
154 if (object_class_by_name(type
) == NULL
) {
157 dev
= DEVICE(object_new(type
));
163 bus
= sysbus_get_default();
166 qdev_set_parent_bus(dev
, bus
);
167 object_unref(OBJECT(dev
));
171 /* Initialize a device. Device properties should be set before calling
172 this function. IRQs and MMIO regions should be connected/mapped after
173 calling this function.
174 On failure, destroy the device and return negative value.
175 Return 0 on success. */
176 int qdev_init(DeviceState
*dev
)
178 Error
*local_err
= NULL
;
180 assert(!dev
->realized
);
182 object_property_set_bool(OBJECT(dev
), true, "realized", &local_err
);
183 if (local_err
!= NULL
) {
184 qerror_report_err(local_err
);
185 error_free(local_err
);
186 object_unparent(OBJECT(dev
));
192 static void device_realize(DeviceState
*dev
, Error
**errp
)
194 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
197 int rc
= dc
->init(dev
);
199 error_setg(errp
, "Device initialization failed.");
205 static void device_unrealize(DeviceState
*dev
, Error
**errp
)
207 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
210 int rc
= dc
->exit(dev
);
212 error_setg(errp
, "Device exit failed.");
218 void qdev_set_legacy_instance_id(DeviceState
*dev
, int alias_id
,
219 int required_for_version
)
221 assert(!dev
->realized
);
222 dev
->instance_id_alias
= alias_id
;
223 dev
->alias_required_for_version
= required_for_version
;
226 static HotplugHandler
*qdev_get_hotplug_handler(DeviceState
*dev
)
228 HotplugHandler
*hotplug_ctrl
= NULL
;
230 if (dev
->parent_bus
&& dev
->parent_bus
->hotplug_handler
) {
231 hotplug_ctrl
= dev
->parent_bus
->hotplug_handler
;
232 } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE
)) {
233 MachineState
*machine
= MACHINE(qdev_get_machine());
234 MachineClass
*mc
= MACHINE_GET_CLASS(machine
);
236 if (mc
->get_hotplug_handler
) {
237 hotplug_ctrl
= mc
->get_hotplug_handler(machine
, dev
);
243 void qdev_unplug(DeviceState
*dev
, Error
**errp
)
245 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
246 HotplugHandler
*hotplug_ctrl
;
247 HotplugHandlerClass
*hdc
;
249 if (dev
->parent_bus
&& !qbus_is_hotpluggable(dev
->parent_bus
)) {
250 error_set(errp
, QERR_BUS_NO_HOTPLUG
, dev
->parent_bus
->name
);
254 if (!dc
->hotpluggable
) {
255 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
,
256 object_get_typename(OBJECT(dev
)));
260 qdev_hot_removed
= true;
262 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
263 /* hotpluggable device MUST have HotplugHandler, if it doesn't
264 * then something is very wrong with it */
265 g_assert(hotplug_ctrl
);
267 /* If device supports async unplug just request it to be done,
268 * otherwise just remove it synchronously */
269 hdc
= HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl
);
270 if (hdc
->unplug_request
) {
271 hotplug_handler_unplug_request(hotplug_ctrl
, dev
, errp
);
273 hotplug_handler_unplug(hotplug_ctrl
, dev
, errp
);
277 static int qdev_reset_one(DeviceState
*dev
, void *opaque
)
284 static int qbus_reset_one(BusState
*bus
, void *opaque
)
286 BusClass
*bc
= BUS_GET_CLASS(bus
);
293 void qdev_reset_all(DeviceState
*dev
)
295 qdev_walk_children(dev
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
298 void qbus_reset_all(BusState
*bus
)
300 qbus_walk_children(bus
, NULL
, NULL
, qdev_reset_one
, qbus_reset_one
, NULL
);
303 void qbus_reset_all_fn(void *opaque
)
305 BusState
*bus
= opaque
;
309 /* can be used as ->unplug() callback for the simple cases */
310 void qdev_simple_device_unplug_cb(HotplugHandler
*hotplug_dev
,
311 DeviceState
*dev
, Error
**errp
)
314 object_unparent(OBJECT(dev
));
317 /* Like qdev_init(), but terminate program via error_report() instead of
318 returning an error value. This is okay during machine creation.
319 Don't use for hotplug, because there callers need to recover from
320 failure. Exception: if you know the device's init() callback can't
321 fail, then qdev_init_nofail() can't fail either, and is therefore
322 usable even then. But relying on the device implementation that
323 way is somewhat unclean, and best avoided. */
324 void qdev_init_nofail(DeviceState
*dev
)
326 const char *typename
= object_get_typename(OBJECT(dev
));
328 if (qdev_init(dev
) < 0) {
329 error_report("Initialization of device %s failed", typename
);
334 void qdev_machine_creation_done(void)
337 * ok, initial machine setup is done, starting from now we can
338 * only create hotpluggable devices
343 bool qdev_machine_modified(void)
345 return qdev_hot_added
|| qdev_hot_removed
;
348 BusState
*qdev_get_parent_bus(DeviceState
*dev
)
350 return dev
->parent_bus
;
353 static NamedGPIOList
*qdev_get_named_gpio_list(DeviceState
*dev
,
358 QLIST_FOREACH(ngl
, &dev
->gpios
, node
) {
359 /* NULL is a valid and matchable name, otherwise do a normal
362 if ((!ngl
->name
&& !name
) ||
363 (name
&& ngl
->name
&& strcmp(name
, ngl
->name
) == 0)) {
368 ngl
= g_malloc0(sizeof(*ngl
));
369 ngl
->name
= g_strdup(name
);
370 QLIST_INSERT_HEAD(&dev
->gpios
, ngl
, node
);
374 void qdev_init_gpio_in_named(DeviceState
*dev
, qemu_irq_handler handler
,
375 const char *name
, int n
)
378 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
379 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-in");
381 assert(gpio_list
->num_out
== 0 || !name
);
382 gpio_list
->in
= qemu_extend_irqs(gpio_list
->in
, gpio_list
->num_in
, handler
,
385 for (i
= gpio_list
->num_in
; i
< gpio_list
->num_in
+ n
; i
++) {
386 object_property_add_child(OBJECT(dev
), propname
,
387 OBJECT(gpio_list
->in
[i
]), &error_abort
);
391 gpio_list
->num_in
+= n
;
394 void qdev_init_gpio_in(DeviceState
*dev
, qemu_irq_handler handler
, int n
)
396 qdev_init_gpio_in_named(dev
, handler
, NULL
, n
);
399 void qdev_init_gpio_out_named(DeviceState
*dev
, qemu_irq
*pins
,
400 const char *name
, int n
)
403 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
404 char *propname
= g_strdup_printf("%s[*]", name
? name
: "unnamed-gpio-out");
406 assert(gpio_list
->num_in
== 0 || !name
);
407 assert(gpio_list
->num_out
== 0);
408 gpio_list
->num_out
= n
;
409 gpio_list
->out
= pins
;
411 for (i
= 0; i
< n
; ++i
) {
412 memset(&pins
[i
], 0, sizeof(*pins
));
413 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
415 object_property_allow_set_link
,
416 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
422 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
424 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
427 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
429 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
431 assert(n
>= 0 && n
< gpio_list
->num_in
);
432 return gpio_list
->in
[n
];
435 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
437 return qdev_get_gpio_in_named(dev
, NULL
, n
);
440 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
443 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
445 assert(n
>= 0 && n
< gpio_list
->num_out
);
446 gpio_list
->out
[n
] = pin
;
449 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
451 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
454 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
458 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
459 if (strcmp(name
, bus
->name
) == 0) {
466 int qbus_walk_children(BusState
*bus
,
467 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
468 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
475 err
= pre_busfn(bus
, opaque
);
481 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
482 err
= qdev_walk_children(kid
->child
,
483 pre_devfn
, pre_busfn
,
484 post_devfn
, post_busfn
, opaque
);
491 err
= post_busfn(bus
, opaque
);
500 int qdev_walk_children(DeviceState
*dev
,
501 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
502 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
509 err
= pre_devfn(dev
, opaque
);
515 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
516 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
517 post_devfn
, post_busfn
, opaque
);
524 err
= post_devfn(dev
, opaque
);
533 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
539 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
540 DeviceState
*dev
= kid
->child
;
542 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
546 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
547 ret
= qdev_find_recursive(child
, id
);
556 static void qbus_realize(BusState
*bus
, DeviceState
*parent
, const char *name
)
558 const char *typename
= object_get_typename(OBJECT(bus
));
563 bus
->parent
= parent
;
566 bus
->name
= g_strdup(name
);
567 } else if (bus
->parent
&& bus
->parent
->id
) {
568 /* parent device has id -> use it plus parent-bus-id for bus name */
569 bus_id
= bus
->parent
->num_child_bus
;
571 len
= strlen(bus
->parent
->id
) + 16;
573 snprintf(buf
, len
, "%s.%d", bus
->parent
->id
, bus_id
);
576 /* no id -> use lowercase bus type plus global bus-id for bus name */
577 bc
= BUS_GET_CLASS(bus
);
578 bus_id
= bc
->automatic_ids
++;
580 len
= strlen(typename
) + 16;
582 len
= snprintf(buf
, len
, "%s.%d", typename
, bus_id
);
583 for (i
= 0; i
< len
; i
++) {
584 buf
[i
] = qemu_tolower(buf
[i
]);
590 QLIST_INSERT_HEAD(&bus
->parent
->child_bus
, bus
, sibling
);
591 bus
->parent
->num_child_bus
++;
592 object_property_add_child(OBJECT(bus
->parent
), bus
->name
, OBJECT(bus
), NULL
);
593 object_unref(OBJECT(bus
));
594 } else if (bus
!= sysbus_get_default()) {
595 /* TODO: once all bus devices are qdevified,
596 only reset handler for main_system_bus should be registered here. */
597 qemu_register_reset(qbus_reset_all_fn
, bus
);
601 static void bus_unparent(Object
*obj
)
603 BusState
*bus
= BUS(obj
);
606 while ((kid
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
607 DeviceState
*dev
= kid
->child
;
608 object_unparent(OBJECT(dev
));
611 QLIST_REMOVE(bus
, sibling
);
612 bus
->parent
->num_child_bus
--;
615 assert(bus
!= sysbus_get_default()); /* main_system_bus is never freed */
616 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
620 static bool bus_get_realized(Object
*obj
, Error
**errp
)
622 BusState
*bus
= BUS(obj
);
624 return bus
->realized
;
627 static void bus_set_realized(Object
*obj
, bool value
, Error
**errp
)
629 BusState
*bus
= BUS(obj
);
630 BusClass
*bc
= BUS_GET_CLASS(bus
);
632 Error
*local_err
= NULL
;
634 if (value
&& !bus
->realized
) {
636 bc
->realize(bus
, &local_err
);
639 /* TODO: recursive realization */
640 } else if (!value
&& bus
->realized
) {
641 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
642 DeviceState
*dev
= kid
->child
;
643 object_property_set_bool(OBJECT(dev
), false, "realized",
645 if (local_err
!= NULL
) {
649 if (bc
->unrealize
&& local_err
== NULL
) {
650 bc
->unrealize(bus
, &local_err
);
654 if (local_err
!= NULL
) {
655 error_propagate(errp
, local_err
);
659 bus
->realized
= value
;
662 void qbus_create_inplace(void *bus
, size_t size
, const char *typename
,
663 DeviceState
*parent
, const char *name
)
665 object_initialize(bus
, size
, typename
);
666 qbus_realize(bus
, parent
, name
);
669 BusState
*qbus_create(const char *typename
, DeviceState
*parent
, const char *name
)
673 bus
= BUS(object_new(typename
));
674 qbus_realize(bus
, parent
, name
);
679 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
681 BusClass
*bc
= BUS_GET_CLASS(bus
);
683 if (bc
->get_fw_dev_path
) {
684 return bc
->get_fw_dev_path(dev
);
690 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
692 Object
*obj
= OBJECT(dev
);
695 while (!d
&& obj
->parent
) {
697 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
702 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
706 if (dev
&& dev
->parent_bus
) {
708 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
709 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
711 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
714 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
720 l
+= snprintf(p
+ l
, size
- l
, "/");
725 char* qdev_get_fw_dev_path(DeviceState
*dev
)
730 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
734 return g_strdup(path
);
737 char *qdev_get_dev_path(DeviceState
*dev
)
741 if (!dev
|| !dev
->parent_bus
) {
745 bc
= BUS_GET_CLASS(dev
->parent_bus
);
746 if (bc
->get_dev_path
) {
747 return bc
->get_dev_path(dev
);
754 * Legacy property handling
757 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
, void *opaque
,
758 const char *name
, Error
**errp
)
760 DeviceState
*dev
= DEVICE(obj
);
761 Property
*prop
= opaque
;
766 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
767 visit_type_str(v
, &ptr
, name
, errp
);
771 * @qdev_add_legacy_property - adds a legacy property
773 * Do not use this is new code! Properties added through this interface will
774 * be given names and types in the "legacy" namespace.
776 * Legacy properties are string versions of other OOM properties. The format
777 * of the string depends on the property type.
779 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
784 /* Register pointer properties as legacy properties */
785 if (!prop
->info
->print
&& prop
->info
->get
) {
789 name
= g_strdup_printf("legacy-%s", prop
->name
);
790 object_property_add(OBJECT(dev
), name
, "str",
791 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
800 * @qdev_property_add_static - add a @Property to a device.
802 * Static properties access data in a struct. The actual type of the
803 * property and the field depends on the property type.
805 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
808 Error
*local_err
= NULL
;
809 Object
*obj
= OBJECT(dev
);
812 * TODO qdev_prop_ptr does not have getters or setters. It must
813 * go now that it can be replaced with links. The test should be
814 * removed along with it: all static properties are read/write.
816 if (!prop
->info
->get
&& !prop
->info
->set
) {
820 object_property_add(obj
, prop
->name
, prop
->info
->name
,
821 prop
->info
->get
, prop
->info
->set
,
826 error_propagate(errp
, local_err
);
830 object_property_set_description(obj
, prop
->name
,
831 prop
->info
->description
,
834 if (prop
->qtype
== QTYPE_NONE
) {
838 if (prop
->qtype
== QTYPE_QBOOL
) {
839 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
840 } else if (prop
->info
->enum_table
) {
841 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
842 prop
->name
, &error_abort
);
843 } else if (prop
->qtype
== QTYPE_QINT
) {
844 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
848 /* @qdev_alias_all_properties - Add alias properties to the source object for
849 * all qdev properties on the target DeviceState.
851 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
856 class = object_get_class(OBJECT(target
));
858 DeviceClass
*dc
= DEVICE_CLASS(class);
860 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
861 object_property_add_alias(source
, prop
->name
,
862 OBJECT(target
), prop
->name
,
865 class = object_class_get_parent(class);
866 } while (class != object_class_by_name(TYPE_DEVICE
));
869 static bool device_get_realized(Object
*obj
, Error
**errp
)
871 DeviceState
*dev
= DEVICE(obj
);
872 return dev
->realized
;
875 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
877 DeviceState
*dev
= DEVICE(obj
);
878 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
879 HotplugHandler
*hotplug_ctrl
;
881 Error
*local_err
= NULL
;
883 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
884 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
888 if (value
&& !dev
->realized
) {
890 static int unattached_count
;
891 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
893 object_property_add_child(container_get(qdev_get_machine(),
895 name
, obj
, &error_abort
);
900 dc
->realize(dev
, &local_err
);
903 if (local_err
!= NULL
) {
907 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
909 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
912 if (local_err
!= NULL
) {
913 goto post_realize_fail
;
916 if (qdev_get_vmsd(dev
)) {
917 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
918 dev
->instance_id_alias
,
919 dev
->alias_required_for_version
);
922 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
923 object_property_set_bool(OBJECT(bus
), true, "realized",
925 if (local_err
!= NULL
) {
926 goto child_realize_fail
;
929 if (dev
->hotplugged
) {
932 dev
->pending_deleted_event
= false;
933 } else if (!value
&& dev
->realized
) {
934 Error
**local_errp
= NULL
;
935 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
936 local_errp
= local_err
? NULL
: &local_err
;
937 object_property_set_bool(OBJECT(bus
), false, "realized",
940 if (qdev_get_vmsd(dev
)) {
941 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
944 local_errp
= local_err
? NULL
: &local_err
;
945 dc
->unrealize(dev
, local_errp
);
947 dev
->pending_deleted_event
= true;
950 if (local_err
!= NULL
) {
954 dev
->realized
= value
;
958 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
959 object_property_set_bool(OBJECT(bus
), false, "realized",
963 if (qdev_get_vmsd(dev
)) {
964 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
969 dc
->unrealize(dev
, NULL
);
973 error_propagate(errp
, local_err
);
977 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
979 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
980 DeviceState
*dev
= DEVICE(obj
);
982 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
983 qbus_is_hotpluggable(dev
->parent_bus
));
986 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
988 DeviceState
*dev
= DEVICE(obj
);
990 return dev
->hotplugged
;
993 static void device_set_hotplugged(Object
*obj
, bool value
, Error
**err
)
995 DeviceState
*dev
= DEVICE(obj
);
997 dev
->hotplugged
= value
;
1000 static void device_initfn(Object
*obj
)
1002 DeviceState
*dev
= DEVICE(obj
);
1007 dev
->hotplugged
= 1;
1008 qdev_hot_added
= true;
1011 dev
->instance_id_alias
= -1;
1012 dev
->realized
= false;
1014 object_property_add_bool(obj
, "realized",
1015 device_get_realized
, device_set_realized
, NULL
);
1016 object_property_add_bool(obj
, "hotpluggable",
1017 device_get_hotpluggable
, NULL
, NULL
);
1018 object_property_add_bool(obj
, "hotplugged",
1019 device_get_hotplugged
, device_set_hotplugged
,
1022 class = object_get_class(OBJECT(dev
));
1024 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
1025 qdev_property_add_legacy(dev
, prop
, &error_abort
);
1026 qdev_property_add_static(dev
, prop
, &error_abort
);
1028 class = object_class_get_parent(class);
1029 } while (class != object_class_by_name(TYPE_DEVICE
));
1031 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1032 (Object
**)&dev
->parent_bus
, NULL
, 0,
1034 QLIST_INIT(&dev
->gpios
);
1037 static void device_post_init(Object
*obj
)
1040 qdev_prop_set_globals(DEVICE(obj
), &err
);
1042 qerror_report_err(err
);
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 qemu_opts_del(dev
->opts
);
1058 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1059 QLIST_REMOVE(ngl
, node
);
1060 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1063 /* ngl->out irqs are owned by the other end and should not be freed
1069 static void device_class_base_init(ObjectClass
*class, void *data
)
1071 DeviceClass
*klass
= DEVICE_CLASS(class);
1073 /* We explicitly look up properties in the superclasses,
1074 * so do not propagate them to the subclasses.
1076 klass
->props
= NULL
;
1079 static void device_unparent(Object
*obj
)
1081 DeviceState
*dev
= DEVICE(obj
);
1084 if (dev
->realized
) {
1085 object_property_set_bool(obj
, false, "realized", NULL
);
1087 while (dev
->num_child_bus
) {
1088 bus
= QLIST_FIRST(&dev
->child_bus
);
1089 object_unparent(OBJECT(bus
));
1091 if (dev
->parent_bus
) {
1092 bus_remove_child(dev
->parent_bus
, dev
);
1093 object_unref(OBJECT(dev
->parent_bus
));
1094 dev
->parent_bus
= NULL
;
1097 /* Only send event if the device had been completely realized */
1098 if (dev
->pending_deleted_event
) {
1099 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
1101 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, path
, &error_abort
);
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;
1123 void device_reset(DeviceState
*dev
)
1125 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1132 Object
*qdev_get_machine(void)
1137 dev
= container_get(object_get_root(), "/machine");
1143 static const TypeInfo device_type_info
= {
1144 .name
= TYPE_DEVICE
,
1145 .parent
= TYPE_OBJECT
,
1146 .instance_size
= sizeof(DeviceState
),
1147 .instance_init
= device_initfn
,
1148 .instance_post_init
= device_post_init
,
1149 .instance_finalize
= device_finalize
,
1150 .class_base_init
= device_class_base_init
,
1151 .class_init
= device_class_init
,
1153 .class_size
= sizeof(DeviceClass
),
1156 static void qbus_initfn(Object
*obj
)
1158 BusState
*bus
= BUS(obj
);
1160 QTAILQ_INIT(&bus
->children
);
1161 object_property_add_link(obj
, QDEV_HOTPLUG_HANDLER_PROPERTY
,
1162 TYPE_HOTPLUG_HANDLER
,
1163 (Object
**)&bus
->hotplug_handler
,
1164 object_property_allow_set_link
,
1165 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1167 object_property_add_bool(obj
, "realized",
1168 bus_get_realized
, bus_set_realized
, NULL
);
1171 static char *default_bus_get_fw_dev_path(DeviceState
*dev
)
1173 return g_strdup(object_get_typename(OBJECT(dev
)));
1176 static void bus_class_init(ObjectClass
*class, void *data
)
1178 BusClass
*bc
= BUS_CLASS(class);
1180 class->unparent
= bus_unparent
;
1181 bc
->get_fw_dev_path
= default_bus_get_fw_dev_path
;
1184 static void qbus_finalize(Object
*obj
)
1186 BusState
*bus
= BUS(obj
);
1188 g_free((char *)bus
->name
);
1191 static const TypeInfo bus_info
= {
1193 .parent
= TYPE_OBJECT
,
1194 .instance_size
= sizeof(BusState
),
1196 .class_size
= sizeof(BusClass
),
1197 .instance_init
= qbus_initfn
,
1198 .instance_finalize
= qbus_finalize
,
1199 .class_init
= bus_class_init
,
1202 static void qdev_register_types(void)
1204 type_register_static(&bus_info
);
1205 type_register_static(&device_type_info
);
1208 type_init(qdev_register_types
)