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
;
410 for (i
= 0; i
< n
; ++i
) {
411 memset(&pins
[i
], 0, sizeof(*pins
));
412 object_property_add_link(OBJECT(dev
), propname
, TYPE_IRQ
,
414 object_property_allow_set_link
,
415 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
421 void qdev_init_gpio_out(DeviceState
*dev
, qemu_irq
*pins
, int n
)
423 qdev_init_gpio_out_named(dev
, pins
, NULL
, n
);
426 qemu_irq
qdev_get_gpio_in_named(DeviceState
*dev
, const char *name
, int n
)
428 NamedGPIOList
*gpio_list
= qdev_get_named_gpio_list(dev
, name
);
430 assert(n
>= 0 && n
< gpio_list
->num_in
);
431 return gpio_list
->in
[n
];
434 qemu_irq
qdev_get_gpio_in(DeviceState
*dev
, int n
)
436 return qdev_get_gpio_in_named(dev
, NULL
, n
);
439 void qdev_connect_gpio_out_named(DeviceState
*dev
, const char *name
, int n
,
442 char *propname
= g_strdup_printf("%s[%d]",
443 name
? name
: "unnamed-gpio-out", n
);
445 /* We need a name for object_property_set_link to work. If the
446 * object has a parent, object_property_add_child will come back
447 * with an error without doing anything. If it has none, it will
448 * never fail. So we can just call it with a NULL Error pointer.
450 object_property_add_child(qdev_get_machine(), "non-qdev-gpio[*]",
453 object_property_set_link(OBJECT(dev
), OBJECT(pin
), propname
, &error_abort
);
457 /* disconnect a GPIO ouput, returning the disconnected input (if any) */
459 static qemu_irq
qdev_disconnect_gpio_out_named(DeviceState
*dev
,
460 const char *name
, int n
)
462 char *propname
= g_strdup_printf("%s[%d]",
463 name
? name
: "unnamed-gpio-out", n
);
465 qemu_irq ret
= (qemu_irq
)object_property_get_link(OBJECT(dev
), propname
,
468 object_property_set_link(OBJECT(dev
), NULL
, propname
, NULL
);
474 qemu_irq
qdev_intercept_gpio_out(DeviceState
*dev
, qemu_irq icpt
,
475 const char *name
, int n
)
477 qemu_irq disconnected
= qdev_disconnect_gpio_out_named(dev
, name
, n
);
478 qdev_connect_gpio_out_named(dev
, name
, n
, icpt
);
482 void qdev_connect_gpio_out(DeviceState
* dev
, int n
, qemu_irq pin
)
484 qdev_connect_gpio_out_named(dev
, NULL
, n
, pin
);
487 BusState
*qdev_get_child_bus(DeviceState
*dev
, const char *name
)
491 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
492 if (strcmp(name
, bus
->name
) == 0) {
499 int qbus_walk_children(BusState
*bus
,
500 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
501 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
508 err
= pre_busfn(bus
, opaque
);
514 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
515 err
= qdev_walk_children(kid
->child
,
516 pre_devfn
, pre_busfn
,
517 post_devfn
, post_busfn
, opaque
);
524 err
= post_busfn(bus
, opaque
);
533 int qdev_walk_children(DeviceState
*dev
,
534 qdev_walkerfn
*pre_devfn
, qbus_walkerfn
*pre_busfn
,
535 qdev_walkerfn
*post_devfn
, qbus_walkerfn
*post_busfn
,
542 err
= pre_devfn(dev
, opaque
);
548 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
549 err
= qbus_walk_children(bus
, pre_devfn
, pre_busfn
,
550 post_devfn
, post_busfn
, opaque
);
557 err
= post_devfn(dev
, opaque
);
566 DeviceState
*qdev_find_recursive(BusState
*bus
, const char *id
)
572 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
573 DeviceState
*dev
= kid
->child
;
575 if (dev
->id
&& strcmp(dev
->id
, id
) == 0) {
579 QLIST_FOREACH(child
, &dev
->child_bus
, sibling
) {
580 ret
= qdev_find_recursive(child
, id
);
589 static void qbus_realize(BusState
*bus
, DeviceState
*parent
, const char *name
)
591 const char *typename
= object_get_typename(OBJECT(bus
));
596 bus
->parent
= parent
;
599 bus
->name
= g_strdup(name
);
600 } else if (bus
->parent
&& bus
->parent
->id
) {
601 /* parent device has id -> use it plus parent-bus-id for bus name */
602 bus_id
= bus
->parent
->num_child_bus
;
604 len
= strlen(bus
->parent
->id
) + 16;
606 snprintf(buf
, len
, "%s.%d", bus
->parent
->id
, bus_id
);
609 /* no id -> use lowercase bus type plus global bus-id for bus name */
610 bc
= BUS_GET_CLASS(bus
);
611 bus_id
= bc
->automatic_ids
++;
613 len
= strlen(typename
) + 16;
615 len
= snprintf(buf
, len
, "%s.%d", typename
, bus_id
);
616 for (i
= 0; i
< len
; i
++) {
617 buf
[i
] = qemu_tolower(buf
[i
]);
623 QLIST_INSERT_HEAD(&bus
->parent
->child_bus
, bus
, sibling
);
624 bus
->parent
->num_child_bus
++;
625 object_property_add_child(OBJECT(bus
->parent
), bus
->name
, OBJECT(bus
), NULL
);
626 object_unref(OBJECT(bus
));
627 } else if (bus
!= sysbus_get_default()) {
628 /* TODO: once all bus devices are qdevified,
629 only reset handler for main_system_bus should be registered here. */
630 qemu_register_reset(qbus_reset_all_fn
, bus
);
634 static void bus_unparent(Object
*obj
)
636 BusState
*bus
= BUS(obj
);
639 while ((kid
= QTAILQ_FIRST(&bus
->children
)) != NULL
) {
640 DeviceState
*dev
= kid
->child
;
641 object_unparent(OBJECT(dev
));
644 QLIST_REMOVE(bus
, sibling
);
645 bus
->parent
->num_child_bus
--;
648 assert(bus
!= sysbus_get_default()); /* main_system_bus is never freed */
649 qemu_unregister_reset(qbus_reset_all_fn
, bus
);
653 static bool bus_get_realized(Object
*obj
, Error
**errp
)
655 BusState
*bus
= BUS(obj
);
657 return bus
->realized
;
660 static void bus_set_realized(Object
*obj
, bool value
, Error
**errp
)
662 BusState
*bus
= BUS(obj
);
663 BusClass
*bc
= BUS_GET_CLASS(bus
);
665 Error
*local_err
= NULL
;
667 if (value
&& !bus
->realized
) {
669 bc
->realize(bus
, &local_err
);
672 /* TODO: recursive realization */
673 } else if (!value
&& bus
->realized
) {
674 QTAILQ_FOREACH(kid
, &bus
->children
, sibling
) {
675 DeviceState
*dev
= kid
->child
;
676 object_property_set_bool(OBJECT(dev
), false, "realized",
678 if (local_err
!= NULL
) {
682 if (bc
->unrealize
&& local_err
== NULL
) {
683 bc
->unrealize(bus
, &local_err
);
687 if (local_err
!= NULL
) {
688 error_propagate(errp
, local_err
);
692 bus
->realized
= value
;
695 void qbus_create_inplace(void *bus
, size_t size
, const char *typename
,
696 DeviceState
*parent
, const char *name
)
698 object_initialize(bus
, size
, typename
);
699 qbus_realize(bus
, parent
, name
);
702 BusState
*qbus_create(const char *typename
, DeviceState
*parent
, const char *name
)
706 bus
= BUS(object_new(typename
));
707 qbus_realize(bus
, parent
, name
);
712 static char *bus_get_fw_dev_path(BusState
*bus
, DeviceState
*dev
)
714 BusClass
*bc
= BUS_GET_CLASS(bus
);
716 if (bc
->get_fw_dev_path
) {
717 return bc
->get_fw_dev_path(dev
);
723 static char *qdev_get_fw_dev_path_from_handler(BusState
*bus
, DeviceState
*dev
)
725 Object
*obj
= OBJECT(dev
);
728 while (!d
&& obj
->parent
) {
730 d
= fw_path_provider_try_get_dev_path(obj
, bus
, dev
);
735 static int qdev_get_fw_dev_path_helper(DeviceState
*dev
, char *p
, int size
)
739 if (dev
&& dev
->parent_bus
) {
741 l
= qdev_get_fw_dev_path_helper(dev
->parent_bus
->parent
, p
, size
);
742 d
= qdev_get_fw_dev_path_from_handler(dev
->parent_bus
, dev
);
744 d
= bus_get_fw_dev_path(dev
->parent_bus
, dev
);
747 l
+= snprintf(p
+ l
, size
- l
, "%s", d
);
753 l
+= snprintf(p
+ l
, size
- l
, "/");
758 char* qdev_get_fw_dev_path(DeviceState
*dev
)
763 l
= qdev_get_fw_dev_path_helper(dev
, path
, 128);
767 return g_strdup(path
);
770 char *qdev_get_dev_path(DeviceState
*dev
)
774 if (!dev
|| !dev
->parent_bus
) {
778 bc
= BUS_GET_CLASS(dev
->parent_bus
);
779 if (bc
->get_dev_path
) {
780 return bc
->get_dev_path(dev
);
787 * Legacy property handling
790 static void qdev_get_legacy_property(Object
*obj
, Visitor
*v
, void *opaque
,
791 const char *name
, Error
**errp
)
793 DeviceState
*dev
= DEVICE(obj
);
794 Property
*prop
= opaque
;
799 prop
->info
->print(dev
, prop
, buffer
, sizeof(buffer
));
800 visit_type_str(v
, &ptr
, name
, errp
);
804 * @qdev_add_legacy_property - adds a legacy property
806 * Do not use this is new code! Properties added through this interface will
807 * be given names and types in the "legacy" namespace.
809 * Legacy properties are string versions of other OOM properties. The format
810 * of the string depends on the property type.
812 static void qdev_property_add_legacy(DeviceState
*dev
, Property
*prop
,
817 /* Register pointer properties as legacy properties */
818 if (!prop
->info
->print
&& prop
->info
->get
) {
822 name
= g_strdup_printf("legacy-%s", prop
->name
);
823 object_property_add(OBJECT(dev
), name
, "str",
824 prop
->info
->print
? qdev_get_legacy_property
: prop
->info
->get
,
833 * @qdev_property_add_static - add a @Property to a device.
835 * Static properties access data in a struct. The actual type of the
836 * property and the field depends on the property type.
838 void qdev_property_add_static(DeviceState
*dev
, Property
*prop
,
841 Error
*local_err
= NULL
;
842 Object
*obj
= OBJECT(dev
);
845 * TODO qdev_prop_ptr does not have getters or setters. It must
846 * go now that it can be replaced with links. The test should be
847 * removed along with it: all static properties are read/write.
849 if (!prop
->info
->get
&& !prop
->info
->set
) {
853 object_property_add(obj
, prop
->name
, prop
->info
->name
,
854 prop
->info
->get
, prop
->info
->set
,
859 error_propagate(errp
, local_err
);
863 object_property_set_description(obj
, prop
->name
,
864 prop
->info
->description
,
867 if (prop
->qtype
== QTYPE_NONE
) {
871 if (prop
->qtype
== QTYPE_QBOOL
) {
872 object_property_set_bool(obj
, prop
->defval
, prop
->name
, &error_abort
);
873 } else if (prop
->info
->enum_table
) {
874 object_property_set_str(obj
, prop
->info
->enum_table
[prop
->defval
],
875 prop
->name
, &error_abort
);
876 } else if (prop
->qtype
== QTYPE_QINT
) {
877 object_property_set_int(obj
, prop
->defval
, prop
->name
, &error_abort
);
881 /* @qdev_alias_all_properties - Add alias properties to the source object for
882 * all qdev properties on the target DeviceState.
884 void qdev_alias_all_properties(DeviceState
*target
, Object
*source
)
889 class = object_get_class(OBJECT(target
));
891 DeviceClass
*dc
= DEVICE_CLASS(class);
893 for (prop
= dc
->props
; prop
&& prop
->name
; prop
++) {
894 object_property_add_alias(source
, prop
->name
,
895 OBJECT(target
), prop
->name
,
898 class = object_class_get_parent(class);
899 } while (class != object_class_by_name(TYPE_DEVICE
));
902 static bool device_get_realized(Object
*obj
, Error
**errp
)
904 DeviceState
*dev
= DEVICE(obj
);
905 return dev
->realized
;
908 static void device_set_realized(Object
*obj
, bool value
, Error
**errp
)
910 DeviceState
*dev
= DEVICE(obj
);
911 DeviceClass
*dc
= DEVICE_GET_CLASS(dev
);
912 HotplugHandler
*hotplug_ctrl
;
914 Error
*local_err
= NULL
;
916 if (dev
->hotplugged
&& !dc
->hotpluggable
) {
917 error_set(errp
, QERR_DEVICE_NO_HOTPLUG
, object_get_typename(obj
));
921 if (value
&& !dev
->realized
) {
923 static int unattached_count
;
924 gchar
*name
= g_strdup_printf("device[%d]", unattached_count
++);
926 object_property_add_child(container_get(qdev_get_machine(),
928 name
, obj
, &error_abort
);
933 dc
->realize(dev
, &local_err
);
936 if (local_err
!= NULL
) {
940 hotplug_ctrl
= qdev_get_hotplug_handler(dev
);
942 hotplug_handler_plug(hotplug_ctrl
, dev
, &local_err
);
945 if (local_err
!= NULL
) {
946 goto post_realize_fail
;
949 if (qdev_get_vmsd(dev
)) {
950 vmstate_register_with_alias_id(dev
, -1, qdev_get_vmsd(dev
), dev
,
951 dev
->instance_id_alias
,
952 dev
->alias_required_for_version
);
955 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
956 object_property_set_bool(OBJECT(bus
), true, "realized",
958 if (local_err
!= NULL
) {
959 goto child_realize_fail
;
962 if (dev
->hotplugged
) {
965 dev
->pending_deleted_event
= false;
966 } else if (!value
&& dev
->realized
) {
967 Error
**local_errp
= NULL
;
968 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
969 local_errp
= local_err
? NULL
: &local_err
;
970 object_property_set_bool(OBJECT(bus
), false, "realized",
973 if (qdev_get_vmsd(dev
)) {
974 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
977 local_errp
= local_err
? NULL
: &local_err
;
978 dc
->unrealize(dev
, local_errp
);
980 dev
->pending_deleted_event
= true;
983 if (local_err
!= NULL
) {
987 dev
->realized
= value
;
991 QLIST_FOREACH(bus
, &dev
->child_bus
, sibling
) {
992 object_property_set_bool(OBJECT(bus
), false, "realized",
996 if (qdev_get_vmsd(dev
)) {
997 vmstate_unregister(dev
, qdev_get_vmsd(dev
), dev
);
1001 if (dc
->unrealize
) {
1002 dc
->unrealize(dev
, NULL
);
1006 error_propagate(errp
, local_err
);
1010 static bool device_get_hotpluggable(Object
*obj
, Error
**errp
)
1012 DeviceClass
*dc
= DEVICE_GET_CLASS(obj
);
1013 DeviceState
*dev
= DEVICE(obj
);
1015 return dc
->hotpluggable
&& (dev
->parent_bus
== NULL
||
1016 qbus_is_hotpluggable(dev
->parent_bus
));
1019 static bool device_get_hotplugged(Object
*obj
, Error
**err
)
1021 DeviceState
*dev
= DEVICE(obj
);
1023 return dev
->hotplugged
;
1026 static void device_set_hotplugged(Object
*obj
, bool value
, Error
**err
)
1028 DeviceState
*dev
= DEVICE(obj
);
1030 dev
->hotplugged
= value
;
1033 static void device_initfn(Object
*obj
)
1035 DeviceState
*dev
= DEVICE(obj
);
1040 dev
->hotplugged
= 1;
1041 qdev_hot_added
= true;
1044 dev
->instance_id_alias
= -1;
1045 dev
->realized
= false;
1047 object_property_add_bool(obj
, "realized",
1048 device_get_realized
, device_set_realized
, NULL
);
1049 object_property_add_bool(obj
, "hotpluggable",
1050 device_get_hotpluggable
, NULL
, NULL
);
1051 object_property_add_bool(obj
, "hotplugged",
1052 device_get_hotplugged
, device_set_hotplugged
,
1055 class = object_get_class(OBJECT(dev
));
1057 for (prop
= DEVICE_CLASS(class)->props
; prop
&& prop
->name
; prop
++) {
1058 qdev_property_add_legacy(dev
, prop
, &error_abort
);
1059 qdev_property_add_static(dev
, prop
, &error_abort
);
1061 class = object_class_get_parent(class);
1062 } while (class != object_class_by_name(TYPE_DEVICE
));
1064 object_property_add_link(OBJECT(dev
), "parent_bus", TYPE_BUS
,
1065 (Object
**)&dev
->parent_bus
, NULL
, 0,
1067 QLIST_INIT(&dev
->gpios
);
1070 static void device_post_init(Object
*obj
)
1073 qdev_prop_set_globals(DEVICE(obj
), &err
);
1075 qerror_report_err(err
);
1081 /* Unlink device from bus and free the structure. */
1082 static void device_finalize(Object
*obj
)
1084 NamedGPIOList
*ngl
, *next
;
1086 DeviceState
*dev
= DEVICE(obj
);
1088 qemu_opts_del(dev
->opts
);
1091 QLIST_FOREACH_SAFE(ngl
, &dev
->gpios
, node
, next
) {
1092 QLIST_REMOVE(ngl
, node
);
1093 qemu_free_irqs(ngl
->in
, ngl
->num_in
);
1096 /* ngl->out irqs are owned by the other end and should not be freed
1102 static void device_class_base_init(ObjectClass
*class, void *data
)
1104 DeviceClass
*klass
= DEVICE_CLASS(class);
1106 /* We explicitly look up properties in the superclasses,
1107 * so do not propagate them to the subclasses.
1109 klass
->props
= NULL
;
1112 static void device_unparent(Object
*obj
)
1114 DeviceState
*dev
= DEVICE(obj
);
1117 if (dev
->realized
) {
1118 object_property_set_bool(obj
, false, "realized", NULL
);
1120 while (dev
->num_child_bus
) {
1121 bus
= QLIST_FIRST(&dev
->child_bus
);
1122 object_unparent(OBJECT(bus
));
1124 if (dev
->parent_bus
) {
1125 bus_remove_child(dev
->parent_bus
, dev
);
1126 object_unref(OBJECT(dev
->parent_bus
));
1127 dev
->parent_bus
= NULL
;
1130 /* Only send event if the device had been completely realized */
1131 if (dev
->pending_deleted_event
) {
1132 gchar
*path
= object_get_canonical_path(OBJECT(dev
));
1134 qapi_event_send_device_deleted(!!dev
->id
, dev
->id
, path
, &error_abort
);
1139 static void device_class_init(ObjectClass
*class, void *data
)
1141 DeviceClass
*dc
= DEVICE_CLASS(class);
1143 class->unparent
= device_unparent
;
1144 dc
->realize
= device_realize
;
1145 dc
->unrealize
= device_unrealize
;
1147 /* by default all devices were considered as hotpluggable,
1148 * so with intent to check it in generic qdev_unplug() /
1149 * device_set_realized() functions make every device
1150 * hotpluggable. Devices that shouldn't be hotpluggable,
1151 * should override it in their class_init()
1153 dc
->hotpluggable
= true;
1156 void device_reset(DeviceState
*dev
)
1158 DeviceClass
*klass
= DEVICE_GET_CLASS(dev
);
1165 Object
*qdev_get_machine(void)
1170 dev
= container_get(object_get_root(), "/machine");
1176 static const TypeInfo device_type_info
= {
1177 .name
= TYPE_DEVICE
,
1178 .parent
= TYPE_OBJECT
,
1179 .instance_size
= sizeof(DeviceState
),
1180 .instance_init
= device_initfn
,
1181 .instance_post_init
= device_post_init
,
1182 .instance_finalize
= device_finalize
,
1183 .class_base_init
= device_class_base_init
,
1184 .class_init
= device_class_init
,
1186 .class_size
= sizeof(DeviceClass
),
1189 static void qbus_initfn(Object
*obj
)
1191 BusState
*bus
= BUS(obj
);
1193 QTAILQ_INIT(&bus
->children
);
1194 object_property_add_link(obj
, QDEV_HOTPLUG_HANDLER_PROPERTY
,
1195 TYPE_HOTPLUG_HANDLER
,
1196 (Object
**)&bus
->hotplug_handler
,
1197 object_property_allow_set_link
,
1198 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1200 object_property_add_bool(obj
, "realized",
1201 bus_get_realized
, bus_set_realized
, NULL
);
1204 static char *default_bus_get_fw_dev_path(DeviceState
*dev
)
1206 return g_strdup(object_get_typename(OBJECT(dev
)));
1209 static void bus_class_init(ObjectClass
*class, void *data
)
1211 BusClass
*bc
= BUS_CLASS(class);
1213 class->unparent
= bus_unparent
;
1214 bc
->get_fw_dev_path
= default_bus_get_fw_dev_path
;
1217 static void qbus_finalize(Object
*obj
)
1219 BusState
*bus
= BUS(obj
);
1221 g_free((char *)bus
->name
);
1224 static const TypeInfo bus_info
= {
1226 .parent
= TYPE_OBJECT
,
1227 .instance_size
= sizeof(BusState
),
1229 .class_size
= sizeof(BusClass
),
1230 .instance_init
= qbus_initfn
,
1231 .instance_finalize
= qbus_finalize
,
1232 .class_init
= bus_class_init
,
1235 static void qdev_register_types(void)
1237 type_register_static(&bus_info
);
1238 type_register_static(&device_type_info
);
1241 type_init(qdev_register_types
)