commit 6b1566c
(qdev: Introduce FWPathProvider interface) did a
good job for supproting to get firmware path on some different
architectures.
Moreover further more, we can use the interface to get firmware
path name for a device which isn't attached a specific bus,
such as virtio-bus, scsi-bus etc.
When the device (such as vhost-scsi) realize the TYPE_FW_PATH_PROVIDER
interface, we should introduce a new function to get the correct firmware
path name for it.
Signed-off-by: Gonglei <arei.gonglei@huawei.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
1357 lines
38 KiB
C
1357 lines
38 KiB
C
/*
|
|
* Dynamic device configuration and creation.
|
|
*
|
|
* Copyright (c) 2009 CodeSourcery
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* The theory here is that it should be possible to create a machine without
|
|
knowledge of specific devices. Historically board init routines have
|
|
passed a bunch of arguments to each device, requiring the board know
|
|
exactly which device it is dealing with. This file provides an abstract
|
|
API for device configuration and initialization. Devices will generally
|
|
inherit from a particular bus (e.g. PCI or I2C) rather than
|
|
this API directly. */
|
|
|
|
#include "hw/qdev.h"
|
|
#include "hw/fw-path-provider.h"
|
|
#include "sysemu/sysemu.h"
|
|
#include "qapi/error.h"
|
|
#include "qapi/qmp/qerror.h"
|
|
#include "qapi/visitor.h"
|
|
#include "qapi/qmp/qjson.h"
|
|
#include "hw/hotplug.h"
|
|
#include "hw/boards.h"
|
|
#include "qapi-event.h"
|
|
|
|
int qdev_hotplug = 0;
|
|
static bool qdev_hot_added = false;
|
|
static bool qdev_hot_removed = false;
|
|
|
|
const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
|
|
{
|
|
DeviceClass *dc = DEVICE_GET_CLASS(dev);
|
|
return dc->vmsd;
|
|
}
|
|
|
|
const char *qdev_fw_name(DeviceState *dev)
|
|
{
|
|
DeviceClass *dc = DEVICE_GET_CLASS(dev);
|
|
|
|
if (dc->fw_name) {
|
|
return dc->fw_name;
|
|
}
|
|
|
|
return object_get_typename(OBJECT(dev));
|
|
}
|
|
|
|
static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
|
|
Error **errp);
|
|
|
|
static void bus_remove_child(BusState *bus, DeviceState *child)
|
|
{
|
|
BusChild *kid;
|
|
|
|
QTAILQ_FOREACH(kid, &bus->children, sibling) {
|
|
if (kid->child == child) {
|
|
char name[32];
|
|
|
|
snprintf(name, sizeof(name), "child[%d]", kid->index);
|
|
QTAILQ_REMOVE(&bus->children, kid, sibling);
|
|
|
|
/* This gives back ownership of kid->child back to us. */
|
|
object_property_del(OBJECT(bus), name, NULL);
|
|
object_unref(OBJECT(kid->child));
|
|
g_free(kid);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void bus_add_child(BusState *bus, DeviceState *child)
|
|
{
|
|
char name[32];
|
|
BusChild *kid = g_malloc0(sizeof(*kid));
|
|
|
|
kid->index = bus->max_index++;
|
|
kid->child = child;
|
|
object_ref(OBJECT(kid->child));
|
|
|
|
QTAILQ_INSERT_HEAD(&bus->children, kid, sibling);
|
|
|
|
/* This transfers ownership of kid->child to the property. */
|
|
snprintf(name, sizeof(name), "child[%d]", kid->index);
|
|
object_property_add_link(OBJECT(bus), name,
|
|
object_get_typename(OBJECT(child)),
|
|
(Object **)&kid->child,
|
|
NULL, /* read-only property */
|
|
0, /* return ownership on prop deletion */
|
|
NULL);
|
|
}
|
|
|
|
void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
|
|
{
|
|
dev->parent_bus = bus;
|
|
object_ref(OBJECT(bus));
|
|
bus_add_child(bus, dev);
|
|
}
|
|
|
|
static void qbus_set_hotplug_handler_internal(BusState *bus, Object *handler,
|
|
Error **errp)
|
|
{
|
|
|
|
object_property_set_link(OBJECT(bus), OBJECT(handler),
|
|
QDEV_HOTPLUG_HANDLER_PROPERTY, errp);
|
|
}
|
|
|
|
void qbus_set_hotplug_handler(BusState *bus, DeviceState *handler, Error **errp)
|
|
{
|
|
qbus_set_hotplug_handler_internal(bus, OBJECT(handler), errp);
|
|
}
|
|
|
|
void qbus_set_bus_hotplug_handler(BusState *bus, Error **errp)
|
|
{
|
|
qbus_set_hotplug_handler_internal(bus, OBJECT(bus), errp);
|
|
}
|
|
|
|
/* Create a new device. This only initializes the device state structure
|
|
and allows properties to be set. qdev_init should be called to
|
|
initialize the actual device emulation. */
|
|
DeviceState *qdev_create(BusState *bus, const char *name)
|
|
{
|
|
DeviceState *dev;
|
|
|
|
dev = qdev_try_create(bus, name);
|
|
if (!dev) {
|
|
if (bus) {
|
|
error_report("Unknown device '%s' for bus '%s'", name,
|
|
object_get_typename(OBJECT(bus)));
|
|
} else {
|
|
error_report("Unknown device '%s' for default sysbus", name);
|
|
}
|
|
abort();
|
|
}
|
|
|
|
return dev;
|
|
}
|
|
|
|
DeviceState *qdev_try_create(BusState *bus, const char *type)
|
|
{
|
|
DeviceState *dev;
|
|
|
|
if (object_class_by_name(type) == NULL) {
|
|
return NULL;
|
|
}
|
|
dev = DEVICE(object_new(type));
|
|
if (!dev) {
|
|
return NULL;
|
|
}
|
|
|
|
if (!bus) {
|
|
bus = sysbus_get_default();
|
|
}
|
|
|
|
qdev_set_parent_bus(dev, bus);
|
|
object_unref(OBJECT(dev));
|
|
return dev;
|
|
}
|
|
|
|
/* Initialize a device. Device properties should be set before calling
|
|
this function. IRQs and MMIO regions should be connected/mapped after
|
|
calling this function.
|
|
On failure, destroy the device and return negative value.
|
|
Return 0 on success. */
|
|
int qdev_init(DeviceState *dev)
|
|
{
|
|
Error *local_err = NULL;
|
|
|
|
assert(!dev->realized);
|
|
|
|
object_property_set_bool(OBJECT(dev), true, "realized", &local_err);
|
|
if (local_err != NULL) {
|
|
qerror_report_err(local_err);
|
|
error_free(local_err);
|
|
object_unparent(OBJECT(dev));
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static QTAILQ_HEAD(device_listeners, DeviceListener) device_listeners
|
|
= QTAILQ_HEAD_INITIALIZER(device_listeners);
|
|
|
|
enum ListenerDirection { Forward, Reverse };
|
|
|
|
#define DEVICE_LISTENER_CALL(_callback, _direction, _args...) \
|
|
do { \
|
|
DeviceListener *_listener; \
|
|
\
|
|
switch (_direction) { \
|
|
case Forward: \
|
|
QTAILQ_FOREACH(_listener, &device_listeners, link) { \
|
|
if (_listener->_callback) { \
|
|
_listener->_callback(_listener, ##_args); \
|
|
} \
|
|
} \
|
|
break; \
|
|
case Reverse: \
|
|
QTAILQ_FOREACH_REVERSE(_listener, &device_listeners, \
|
|
device_listeners, link) { \
|
|
if (_listener->_callback) { \
|
|
_listener->_callback(_listener, ##_args); \
|
|
} \
|
|
} \
|
|
break; \
|
|
default: \
|
|
abort(); \
|
|
} \
|
|
} while (0)
|
|
|
|
static int device_listener_add(DeviceState *dev, void *opaque)
|
|
{
|
|
DEVICE_LISTENER_CALL(realize, Forward, dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void device_listener_register(DeviceListener *listener)
|
|
{
|
|
QTAILQ_INSERT_TAIL(&device_listeners, listener, link);
|
|
|
|
qbus_walk_children(sysbus_get_default(), NULL, NULL, device_listener_add,
|
|
NULL, NULL);
|
|
}
|
|
|
|
void device_listener_unregister(DeviceListener *listener)
|
|
{
|
|
QTAILQ_REMOVE(&device_listeners, listener, link);
|
|
}
|
|
|
|
static void device_realize(DeviceState *dev, Error **errp)
|
|
{
|
|
DeviceClass *dc = DEVICE_GET_CLASS(dev);
|
|
|
|
if (dc->init) {
|
|
int rc = dc->init(dev);
|
|
if (rc < 0) {
|
|
error_setg(errp, "Device initialization failed.");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void device_unrealize(DeviceState *dev, Error **errp)
|
|
{
|
|
DeviceClass *dc = DEVICE_GET_CLASS(dev);
|
|
|
|
if (dc->exit) {
|
|
int rc = dc->exit(dev);
|
|
if (rc < 0) {
|
|
error_setg(errp, "Device exit failed.");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
|
|
int required_for_version)
|
|
{
|
|
assert(!dev->realized);
|
|
dev->instance_id_alias = alias_id;
|
|
dev->alias_required_for_version = required_for_version;
|
|
}
|
|
|
|
static HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev)
|
|
{
|
|
HotplugHandler *hotplug_ctrl = NULL;
|
|
|
|
if (dev->parent_bus && dev->parent_bus->hotplug_handler) {
|
|
hotplug_ctrl = dev->parent_bus->hotplug_handler;
|
|
} else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE)) {
|
|
MachineState *machine = MACHINE(qdev_get_machine());
|
|
MachineClass *mc = MACHINE_GET_CLASS(machine);
|
|
|
|
if (mc->get_hotplug_handler) {
|
|
hotplug_ctrl = mc->get_hotplug_handler(machine, dev);
|
|
}
|
|
}
|
|
return hotplug_ctrl;
|
|
}
|
|
|
|
void qdev_unplug(DeviceState *dev, Error **errp)
|
|
{
|
|
DeviceClass *dc = DEVICE_GET_CLASS(dev);
|
|
HotplugHandler *hotplug_ctrl;
|
|
HotplugHandlerClass *hdc;
|
|
|
|
if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) {
|
|
error_set(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
|
|
return;
|
|
}
|
|
|
|
if (!dc->hotpluggable) {
|
|
error_set(errp, QERR_DEVICE_NO_HOTPLUG,
|
|
object_get_typename(OBJECT(dev)));
|
|
return;
|
|
}
|
|
|
|
qdev_hot_removed = true;
|
|
|
|
hotplug_ctrl = qdev_get_hotplug_handler(dev);
|
|
/* hotpluggable device MUST have HotplugHandler, if it doesn't
|
|
* then something is very wrong with it */
|
|
g_assert(hotplug_ctrl);
|
|
|
|
/* If device supports async unplug just request it to be done,
|
|
* otherwise just remove it synchronously */
|
|
hdc = HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl);
|
|
if (hdc->unplug_request) {
|
|
hotplug_handler_unplug_request(hotplug_ctrl, dev, errp);
|
|
} else {
|
|
hotplug_handler_unplug(hotplug_ctrl, dev, errp);
|
|
}
|
|
}
|
|
|
|
static int qdev_reset_one(DeviceState *dev, void *opaque)
|
|
{
|
|
device_reset(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int qbus_reset_one(BusState *bus, void *opaque)
|
|
{
|
|
BusClass *bc = BUS_GET_CLASS(bus);
|
|
if (bc->reset) {
|
|
bc->reset(bus);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void qdev_reset_all(DeviceState *dev)
|
|
{
|
|
qdev_walk_children(dev, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
|
|
}
|
|
|
|
void qbus_reset_all(BusState *bus)
|
|
{
|
|
qbus_walk_children(bus, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
|
|
}
|
|
|
|
void qbus_reset_all_fn(void *opaque)
|
|
{
|
|
BusState *bus = opaque;
|
|
qbus_reset_all(bus);
|
|
}
|
|
|
|
/* can be used as ->unplug() callback for the simple cases */
|
|
void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
|
|
DeviceState *dev, Error **errp)
|
|
{
|
|
/* just zap it */
|
|
object_unparent(OBJECT(dev));
|
|
}
|
|
|
|
/* Like qdev_init(), but terminate program via error_report() instead of
|
|
returning an error value. This is okay during machine creation.
|
|
Don't use for hotplug, because there callers need to recover from
|
|
failure. Exception: if you know the device's init() callback can't
|
|
fail, then qdev_init_nofail() can't fail either, and is therefore
|
|
usable even then. But relying on the device implementation that
|
|
way is somewhat unclean, and best avoided. */
|
|
void qdev_init_nofail(DeviceState *dev)
|
|
{
|
|
const char *typename = object_get_typename(OBJECT(dev));
|
|
|
|
if (qdev_init(dev) < 0) {
|
|
error_report("Initialization of device %s failed", typename);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
void qdev_machine_creation_done(void)
|
|
{
|
|
/*
|
|
* ok, initial machine setup is done, starting from now we can
|
|
* only create hotpluggable devices
|
|
*/
|
|
qdev_hotplug = 1;
|
|
}
|
|
|
|
bool qdev_machine_modified(void)
|
|
{
|
|
return qdev_hot_added || qdev_hot_removed;
|
|
}
|
|
|
|
BusState *qdev_get_parent_bus(DeviceState *dev)
|
|
{
|
|
return dev->parent_bus;
|
|
}
|
|
|
|
static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev,
|
|
const char *name)
|
|
{
|
|
NamedGPIOList *ngl;
|
|
|
|
QLIST_FOREACH(ngl, &dev->gpios, node) {
|
|
/* NULL is a valid and matchable name, otherwise do a normal
|
|
* strcmp match.
|
|
*/
|
|
if ((!ngl->name && !name) ||
|
|
(name && ngl->name && strcmp(name, ngl->name) == 0)) {
|
|
return ngl;
|
|
}
|
|
}
|
|
|
|
ngl = g_malloc0(sizeof(*ngl));
|
|
ngl->name = g_strdup(name);
|
|
QLIST_INSERT_HEAD(&dev->gpios, ngl, node);
|
|
return ngl;
|
|
}
|
|
|
|
void qdev_init_gpio_in_named(DeviceState *dev, qemu_irq_handler handler,
|
|
const char *name, int n)
|
|
{
|
|
int i;
|
|
NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
|
|
char *propname = g_strdup_printf("%s[*]", name ? name : "unnamed-gpio-in");
|
|
|
|
assert(gpio_list->num_out == 0 || !name);
|
|
gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler,
|
|
dev, n);
|
|
|
|
for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) {
|
|
object_property_add_child(OBJECT(dev), propname,
|
|
OBJECT(gpio_list->in[i]), &error_abort);
|
|
}
|
|
g_free(propname);
|
|
|
|
gpio_list->num_in += n;
|
|
}
|
|
|
|
void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
|
|
{
|
|
qdev_init_gpio_in_named(dev, handler, NULL, n);
|
|
}
|
|
|
|
void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
|
|
const char *name, int n)
|
|
{
|
|
int i;
|
|
NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
|
|
char *propname = g_strdup_printf("%s[*]", name ? name : "unnamed-gpio-out");
|
|
|
|
assert(gpio_list->num_in == 0 || !name);
|
|
gpio_list->num_out += n;
|
|
|
|
for (i = 0; i < n; ++i) {
|
|
memset(&pins[i], 0, sizeof(*pins));
|
|
object_property_add_link(OBJECT(dev), propname, TYPE_IRQ,
|
|
(Object **)&pins[i],
|
|
object_property_allow_set_link,
|
|
OBJ_PROP_LINK_UNREF_ON_RELEASE,
|
|
&error_abort);
|
|
}
|
|
g_free(propname);
|
|
}
|
|
|
|
void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
|
|
{
|
|
qdev_init_gpio_out_named(dev, pins, NULL, n);
|
|
}
|
|
|
|
qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n)
|
|
{
|
|
NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
|
|
|
|
assert(n >= 0 && n < gpio_list->num_in);
|
|
return gpio_list->in[n];
|
|
}
|
|
|
|
qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
|
|
{
|
|
return qdev_get_gpio_in_named(dev, NULL, n);
|
|
}
|
|
|
|
void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
|
|
qemu_irq pin)
|
|
{
|
|
char *propname = g_strdup_printf("%s[%d]",
|
|
name ? name : "unnamed-gpio-out", n);
|
|
if (pin) {
|
|
/* We need a name for object_property_set_link to work. If the
|
|
* object has a parent, object_property_add_child will come back
|
|
* with an error without doing anything. If it has none, it will
|
|
* never fail. So we can just call it with a NULL Error pointer.
|
|
*/
|
|
object_property_add_child(qdev_get_machine(), "non-qdev-gpio[*]",
|
|
OBJECT(pin), NULL);
|
|
}
|
|
object_property_set_link(OBJECT(dev), OBJECT(pin), propname, &error_abort);
|
|
g_free(propname);
|
|
}
|
|
|
|
qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n)
|
|
{
|
|
char *propname = g_strdup_printf("%s[%d]",
|
|
name ? name : "unnamed-gpio-out", n);
|
|
|
|
qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
|
|
NULL);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* disconnect a GPIO ouput, returning the disconnected input (if any) */
|
|
|
|
static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev,
|
|
const char *name, int n)
|
|
{
|
|
char *propname = g_strdup_printf("%s[%d]",
|
|
name ? name : "unnamed-gpio-out", n);
|
|
|
|
qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
|
|
NULL);
|
|
if (ret) {
|
|
object_property_set_link(OBJECT(dev), NULL, propname, NULL);
|
|
}
|
|
g_free(propname);
|
|
return ret;
|
|
}
|
|
|
|
qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
|
|
const char *name, int n)
|
|
{
|
|
qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n);
|
|
qdev_connect_gpio_out_named(dev, name, n, icpt);
|
|
return disconnected;
|
|
}
|
|
|
|
void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
|
|
{
|
|
qdev_connect_gpio_out_named(dev, NULL, n, pin);
|
|
}
|
|
|
|
void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
|
|
const char *name)
|
|
{
|
|
int i;
|
|
NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name);
|
|
|
|
for (i = 0; i < ngl->num_in; i++) {
|
|
const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in";
|
|
char *propname = g_strdup_printf("%s[%d]", nm, i);
|
|
|
|
object_property_add_alias(OBJECT(container), propname,
|
|
OBJECT(dev), propname,
|
|
&error_abort);
|
|
}
|
|
for (i = 0; i < ngl->num_out; i++) {
|
|
const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out";
|
|
char *propname = g_strdup_printf("%s[%d]", nm, i);
|
|
|
|
object_property_add_alias(OBJECT(container), propname,
|
|
OBJECT(dev), propname,
|
|
&error_abort);
|
|
}
|
|
QLIST_REMOVE(ngl, node);
|
|
QLIST_INSERT_HEAD(&container->gpios, ngl, node);
|
|
}
|
|
|
|
BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
|
|
{
|
|
BusState *bus;
|
|
|
|
QLIST_FOREACH(bus, &dev->child_bus, sibling) {
|
|
if (strcmp(name, bus->name) == 0) {
|
|
return bus;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int qbus_walk_children(BusState *bus,
|
|
qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
|
|
qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
|
|
void *opaque)
|
|
{
|
|
BusChild *kid;
|
|
int err;
|
|
|
|
if (pre_busfn) {
|
|
err = pre_busfn(bus, opaque);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
}
|
|
|
|
QTAILQ_FOREACH(kid, &bus->children, sibling) {
|
|
err = qdev_walk_children(kid->child,
|
|
pre_devfn, pre_busfn,
|
|
post_devfn, post_busfn, opaque);
|
|
if (err < 0) {
|
|
return err;
|
|
}
|
|
}
|
|
|
|
if (post_busfn) {
|
|
err = post_busfn(bus, opaque);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int qdev_walk_children(DeviceState *dev,
|
|
qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
|
|
qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
|
|
void *opaque)
|
|
{
|
|
BusState *bus;
|
|
int err;
|
|
|
|
if (pre_devfn) {
|
|
err = pre_devfn(dev, opaque);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
}
|
|
|
|
QLIST_FOREACH(bus, &dev->child_bus, sibling) {
|
|
err = qbus_walk_children(bus, pre_devfn, pre_busfn,
|
|
post_devfn, post_busfn, opaque);
|
|
if (err < 0) {
|
|
return err;
|
|
}
|
|
}
|
|
|
|
if (post_devfn) {
|
|
err = post_devfn(dev, opaque);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
DeviceState *qdev_find_recursive(BusState *bus, const char *id)
|
|
{
|
|
BusChild *kid;
|
|
DeviceState *ret;
|
|
BusState *child;
|
|
|
|
QTAILQ_FOREACH(kid, &bus->children, sibling) {
|
|
DeviceState *dev = kid->child;
|
|
|
|
if (dev->id && strcmp(dev->id, id) == 0) {
|
|
return dev;
|
|
}
|
|
|
|
QLIST_FOREACH(child, &dev->child_bus, sibling) {
|
|
ret = qdev_find_recursive(child, id);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void qbus_realize(BusState *bus, DeviceState *parent, const char *name)
|
|
{
|
|
const char *typename = object_get_typename(OBJECT(bus));
|
|
BusClass *bc;
|
|
char *buf;
|
|
int i, len, bus_id;
|
|
|
|
bus->parent = parent;
|
|
|
|
if (name) {
|
|
bus->name = g_strdup(name);
|
|
} else if (bus->parent && bus->parent->id) {
|
|
/* parent device has id -> use it plus parent-bus-id for bus name */
|
|
bus_id = bus->parent->num_child_bus;
|
|
|
|
len = strlen(bus->parent->id) + 16;
|
|
buf = g_malloc(len);
|
|
snprintf(buf, len, "%s.%d", bus->parent->id, bus_id);
|
|
bus->name = buf;
|
|
} else {
|
|
/* no id -> use lowercase bus type plus global bus-id for bus name */
|
|
bc = BUS_GET_CLASS(bus);
|
|
bus_id = bc->automatic_ids++;
|
|
|
|
len = strlen(typename) + 16;
|
|
buf = g_malloc(len);
|
|
len = snprintf(buf, len, "%s.%d", typename, bus_id);
|
|
for (i = 0; i < len; i++) {
|
|
buf[i] = qemu_tolower(buf[i]);
|
|
}
|
|
bus->name = buf;
|
|
}
|
|
|
|
if (bus->parent) {
|
|
QLIST_INSERT_HEAD(&bus->parent->child_bus, bus, sibling);
|
|
bus->parent->num_child_bus++;
|
|
object_property_add_child(OBJECT(bus->parent), bus->name, OBJECT(bus), NULL);
|
|
object_unref(OBJECT(bus));
|
|
} else if (bus != sysbus_get_default()) {
|
|
/* TODO: once all bus devices are qdevified,
|
|
only reset handler for main_system_bus should be registered here. */
|
|
qemu_register_reset(qbus_reset_all_fn, bus);
|
|
}
|
|
}
|
|
|
|
static void bus_unparent(Object *obj)
|
|
{
|
|
BusState *bus = BUS(obj);
|
|
BusChild *kid;
|
|
|
|
while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
|
|
DeviceState *dev = kid->child;
|
|
object_unparent(OBJECT(dev));
|
|
}
|
|
if (bus->parent) {
|
|
QLIST_REMOVE(bus, sibling);
|
|
bus->parent->num_child_bus--;
|
|
bus->parent = NULL;
|
|
} else {
|
|
assert(bus != sysbus_get_default()); /* main_system_bus is never freed */
|
|
qemu_unregister_reset(qbus_reset_all_fn, bus);
|
|
}
|
|
}
|
|
|
|
static bool bus_get_realized(Object *obj, Error **errp)
|
|
{
|
|
BusState *bus = BUS(obj);
|
|
|
|
return bus->realized;
|
|
}
|
|
|
|
static void bus_set_realized(Object *obj, bool value, Error **errp)
|
|
{
|
|
BusState *bus = BUS(obj);
|
|
BusClass *bc = BUS_GET_CLASS(bus);
|
|
BusChild *kid;
|
|
Error *local_err = NULL;
|
|
|
|
if (value && !bus->realized) {
|
|
if (bc->realize) {
|
|
bc->realize(bus, &local_err);
|
|
}
|
|
|
|
/* TODO: recursive realization */
|
|
} else if (!value && bus->realized) {
|
|
QTAILQ_FOREACH(kid, &bus->children, sibling) {
|
|
DeviceState *dev = kid->child;
|
|
object_property_set_bool(OBJECT(dev), false, "realized",
|
|
&local_err);
|
|
if (local_err != NULL) {
|
|
break;
|
|
}
|
|
}
|
|
if (bc->unrealize && local_err == NULL) {
|
|
bc->unrealize(bus, &local_err);
|
|
}
|
|
}
|
|
|
|
if (local_err != NULL) {
|
|
error_propagate(errp, local_err);
|
|
return;
|
|
}
|
|
|
|
bus->realized = value;
|
|
}
|
|
|
|
void qbus_create_inplace(void *bus, size_t size, const char *typename,
|
|
DeviceState *parent, const char *name)
|
|
{
|
|
object_initialize(bus, size, typename);
|
|
qbus_realize(bus, parent, name);
|
|
}
|
|
|
|
BusState *qbus_create(const char *typename, DeviceState *parent, const char *name)
|
|
{
|
|
BusState *bus;
|
|
|
|
bus = BUS(object_new(typename));
|
|
qbus_realize(bus, parent, name);
|
|
|
|
return bus;
|
|
}
|
|
|
|
static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev)
|
|
{
|
|
BusClass *bc = BUS_GET_CLASS(bus);
|
|
|
|
if (bc->get_fw_dev_path) {
|
|
return bc->get_fw_dev_path(dev);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static char *qdev_get_fw_dev_path_from_handler(BusState *bus, DeviceState *dev)
|
|
{
|
|
Object *obj = OBJECT(dev);
|
|
char *d = NULL;
|
|
|
|
while (!d && obj->parent) {
|
|
obj = obj->parent;
|
|
d = fw_path_provider_try_get_dev_path(obj, bus, dev);
|
|
}
|
|
return d;
|
|
}
|
|
|
|
char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev)
|
|
{
|
|
Object *obj = OBJECT(dev);
|
|
|
|
return fw_path_provider_try_get_dev_path(obj, bus, dev);
|
|
}
|
|
|
|
static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
|
|
{
|
|
int l = 0;
|
|
|
|
if (dev && dev->parent_bus) {
|
|
char *d;
|
|
l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
|
|
d = qdev_get_fw_dev_path_from_handler(dev->parent_bus, dev);
|
|
if (!d) {
|
|
d = bus_get_fw_dev_path(dev->parent_bus, dev);
|
|
}
|
|
if (d) {
|
|
l += snprintf(p + l, size - l, "%s", d);
|
|
g_free(d);
|
|
} else {
|
|
return l;
|
|
}
|
|
}
|
|
l += snprintf(p + l , size - l, "/");
|
|
|
|
return l;
|
|
}
|
|
|
|
char* qdev_get_fw_dev_path(DeviceState *dev)
|
|
{
|
|
char path[128];
|
|
int l;
|
|
|
|
l = qdev_get_fw_dev_path_helper(dev, path, 128);
|
|
|
|
path[l-1] = '\0';
|
|
|
|
return g_strdup(path);
|
|
}
|
|
|
|
char *qdev_get_dev_path(DeviceState *dev)
|
|
{
|
|
BusClass *bc;
|
|
|
|
if (!dev || !dev->parent_bus) {
|
|
return NULL;
|
|
}
|
|
|
|
bc = BUS_GET_CLASS(dev->parent_bus);
|
|
if (bc->get_dev_path) {
|
|
return bc->get_dev_path(dev);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Legacy property handling
|
|
*/
|
|
|
|
static void qdev_get_legacy_property(Object *obj, Visitor *v, void *opaque,
|
|
const char *name, Error **errp)
|
|
{
|
|
DeviceState *dev = DEVICE(obj);
|
|
Property *prop = opaque;
|
|
|
|
char buffer[1024];
|
|
char *ptr = buffer;
|
|
|
|
prop->info->print(dev, prop, buffer, sizeof(buffer));
|
|
visit_type_str(v, &ptr, name, errp);
|
|
}
|
|
|
|
/**
|
|
* @qdev_add_legacy_property - adds a legacy property
|
|
*
|
|
* Do not use this is new code! Properties added through this interface will
|
|
* be given names and types in the "legacy" namespace.
|
|
*
|
|
* Legacy properties are string versions of other OOM properties. The format
|
|
* of the string depends on the property type.
|
|
*/
|
|
static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
|
|
Error **errp)
|
|
{
|
|
gchar *name;
|
|
|
|
/* Register pointer properties as legacy properties */
|
|
if (!prop->info->print && prop->info->get) {
|
|
return;
|
|
}
|
|
|
|
name = g_strdup_printf("legacy-%s", prop->name);
|
|
object_property_add(OBJECT(dev), name, "str",
|
|
prop->info->print ? qdev_get_legacy_property : prop->info->get,
|
|
NULL,
|
|
NULL,
|
|
prop, errp);
|
|
|
|
g_free(name);
|
|
}
|
|
|
|
/**
|
|
* @qdev_property_add_static - add a @Property to a device.
|
|
*
|
|
* Static properties access data in a struct. The actual type of the
|
|
* property and the field depends on the property type.
|
|
*/
|
|
void qdev_property_add_static(DeviceState *dev, Property *prop,
|
|
Error **errp)
|
|
{
|
|
Error *local_err = NULL;
|
|
Object *obj = OBJECT(dev);
|
|
|
|
/*
|
|
* TODO qdev_prop_ptr does not have getters or setters. It must
|
|
* go now that it can be replaced with links. The test should be
|
|
* removed along with it: all static properties are read/write.
|
|
*/
|
|
if (!prop->info->get && !prop->info->set) {
|
|
return;
|
|
}
|
|
|
|
object_property_add(obj, prop->name, prop->info->name,
|
|
prop->info->get, prop->info->set,
|
|
prop->info->release,
|
|
prop, &local_err);
|
|
|
|
if (local_err) {
|
|
error_propagate(errp, local_err);
|
|
return;
|
|
}
|
|
|
|
object_property_set_description(obj, prop->name,
|
|
prop->info->description,
|
|
&error_abort);
|
|
|
|
if (prop->qtype == QTYPE_NONE) {
|
|
return;
|
|
}
|
|
|
|
if (prop->qtype == QTYPE_QBOOL) {
|
|
object_property_set_bool(obj, prop->defval, prop->name, &error_abort);
|
|
} else if (prop->info->enum_table) {
|
|
object_property_set_str(obj, prop->info->enum_table[prop->defval],
|
|
prop->name, &error_abort);
|
|
} else if (prop->qtype == QTYPE_QINT) {
|
|
object_property_set_int(obj, prop->defval, prop->name, &error_abort);
|
|
}
|
|
}
|
|
|
|
/* @qdev_alias_all_properties - Add alias properties to the source object for
|
|
* all qdev properties on the target DeviceState.
|
|
*/
|
|
void qdev_alias_all_properties(DeviceState *target, Object *source)
|
|
{
|
|
ObjectClass *class;
|
|
Property *prop;
|
|
|
|
class = object_get_class(OBJECT(target));
|
|
do {
|
|
DeviceClass *dc = DEVICE_CLASS(class);
|
|
|
|
for (prop = dc->props; prop && prop->name; prop++) {
|
|
object_property_add_alias(source, prop->name,
|
|
OBJECT(target), prop->name,
|
|
&error_abort);
|
|
}
|
|
class = object_class_get_parent(class);
|
|
} while (class != object_class_by_name(TYPE_DEVICE));
|
|
}
|
|
|
|
static int qdev_add_hotpluggable_device(Object *obj, void *opaque)
|
|
{
|
|
GSList **list = opaque;
|
|
DeviceState *dev = DEVICE(obj);
|
|
|
|
if (dev->realized && object_property_get_bool(obj, "hotpluggable", NULL)) {
|
|
*list = g_slist_append(*list, dev);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
GSList *qdev_build_hotpluggable_device_list(Object *peripheral)
|
|
{
|
|
GSList *list = NULL;
|
|
|
|
object_child_foreach(peripheral, qdev_add_hotpluggable_device, &list);
|
|
|
|
return list;
|
|
}
|
|
|
|
static bool device_get_realized(Object *obj, Error **errp)
|
|
{
|
|
DeviceState *dev = DEVICE(obj);
|
|
return dev->realized;
|
|
}
|
|
|
|
static void device_set_realized(Object *obj, bool value, Error **errp)
|
|
{
|
|
DeviceState *dev = DEVICE(obj);
|
|
DeviceClass *dc = DEVICE_GET_CLASS(dev);
|
|
HotplugHandler *hotplug_ctrl;
|
|
BusState *bus;
|
|
Error *local_err = NULL;
|
|
|
|
if (dev->hotplugged && !dc->hotpluggable) {
|
|
error_set(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
|
|
return;
|
|
}
|
|
|
|
if (value && !dev->realized) {
|
|
if (!obj->parent) {
|
|
static int unattached_count;
|
|
gchar *name = g_strdup_printf("device[%d]", unattached_count++);
|
|
|
|
object_property_add_child(container_get(qdev_get_machine(),
|
|
"/unattached"),
|
|
name, obj, &error_abort);
|
|
g_free(name);
|
|
}
|
|
|
|
if (dc->realize) {
|
|
dc->realize(dev, &local_err);
|
|
}
|
|
|
|
if (local_err != NULL) {
|
|
goto fail;
|
|
}
|
|
|
|
DEVICE_LISTENER_CALL(realize, Forward, dev);
|
|
|
|
hotplug_ctrl = qdev_get_hotplug_handler(dev);
|
|
if (hotplug_ctrl) {
|
|
hotplug_handler_plug(hotplug_ctrl, dev, &local_err);
|
|
}
|
|
|
|
if (local_err != NULL) {
|
|
goto post_realize_fail;
|
|
}
|
|
|
|
if (qdev_get_vmsd(dev)) {
|
|
vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev,
|
|
dev->instance_id_alias,
|
|
dev->alias_required_for_version);
|
|
}
|
|
|
|
QLIST_FOREACH(bus, &dev->child_bus, sibling) {
|
|
object_property_set_bool(OBJECT(bus), true, "realized",
|
|
&local_err);
|
|
if (local_err != NULL) {
|
|
goto child_realize_fail;
|
|
}
|
|
}
|
|
if (dev->hotplugged) {
|
|
device_reset(dev);
|
|
}
|
|
dev->pending_deleted_event = false;
|
|
} else if (!value && dev->realized) {
|
|
Error **local_errp = NULL;
|
|
QLIST_FOREACH(bus, &dev->child_bus, sibling) {
|
|
local_errp = local_err ? NULL : &local_err;
|
|
object_property_set_bool(OBJECT(bus), false, "realized",
|
|
local_errp);
|
|
}
|
|
if (qdev_get_vmsd(dev)) {
|
|
vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
|
|
}
|
|
if (dc->unrealize) {
|
|
local_errp = local_err ? NULL : &local_err;
|
|
dc->unrealize(dev, local_errp);
|
|
}
|
|
dev->pending_deleted_event = true;
|
|
DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
|
|
}
|
|
|
|
if (local_err != NULL) {
|
|
goto fail;
|
|
}
|
|
|
|
dev->realized = value;
|
|
return;
|
|
|
|
child_realize_fail:
|
|
QLIST_FOREACH(bus, &dev->child_bus, sibling) {
|
|
object_property_set_bool(OBJECT(bus), false, "realized",
|
|
NULL);
|
|
}
|
|
|
|
if (qdev_get_vmsd(dev)) {
|
|
vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
|
|
}
|
|
|
|
post_realize_fail:
|
|
if (dc->unrealize) {
|
|
dc->unrealize(dev, NULL);
|
|
}
|
|
|
|
fail:
|
|
error_propagate(errp, local_err);
|
|
return;
|
|
}
|
|
|
|
static bool device_get_hotpluggable(Object *obj, Error **errp)
|
|
{
|
|
DeviceClass *dc = DEVICE_GET_CLASS(obj);
|
|
DeviceState *dev = DEVICE(obj);
|
|
|
|
return dc->hotpluggable && (dev->parent_bus == NULL ||
|
|
qbus_is_hotpluggable(dev->parent_bus));
|
|
}
|
|
|
|
static bool device_get_hotplugged(Object *obj, Error **err)
|
|
{
|
|
DeviceState *dev = DEVICE(obj);
|
|
|
|
return dev->hotplugged;
|
|
}
|
|
|
|
static void device_set_hotplugged(Object *obj, bool value, Error **err)
|
|
{
|
|
DeviceState *dev = DEVICE(obj);
|
|
|
|
dev->hotplugged = value;
|
|
}
|
|
|
|
static void device_initfn(Object *obj)
|
|
{
|
|
DeviceState *dev = DEVICE(obj);
|
|
ObjectClass *class;
|
|
Property *prop;
|
|
|
|
if (qdev_hotplug) {
|
|
dev->hotplugged = 1;
|
|
qdev_hot_added = true;
|
|
}
|
|
|
|
dev->instance_id_alias = -1;
|
|
dev->realized = false;
|
|
|
|
object_property_add_bool(obj, "realized",
|
|
device_get_realized, device_set_realized, NULL);
|
|
object_property_add_bool(obj, "hotpluggable",
|
|
device_get_hotpluggable, NULL, NULL);
|
|
object_property_add_bool(obj, "hotplugged",
|
|
device_get_hotplugged, device_set_hotplugged,
|
|
&error_abort);
|
|
|
|
class = object_get_class(OBJECT(dev));
|
|
do {
|
|
for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) {
|
|
qdev_property_add_legacy(dev, prop, &error_abort);
|
|
qdev_property_add_static(dev, prop, &error_abort);
|
|
}
|
|
class = object_class_get_parent(class);
|
|
} while (class != object_class_by_name(TYPE_DEVICE));
|
|
|
|
object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS,
|
|
(Object **)&dev->parent_bus, NULL, 0,
|
|
&error_abort);
|
|
QLIST_INIT(&dev->gpios);
|
|
}
|
|
|
|
static void device_post_init(Object *obj)
|
|
{
|
|
Error *err = NULL;
|
|
qdev_prop_set_globals(DEVICE(obj), &err);
|
|
if (err) {
|
|
qerror_report_err(err);
|
|
error_free(err);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
/* Unlink device from bus and free the structure. */
|
|
static void device_finalize(Object *obj)
|
|
{
|
|
NamedGPIOList *ngl, *next;
|
|
|
|
DeviceState *dev = DEVICE(obj);
|
|
qemu_opts_del(dev->opts);
|
|
|
|
QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
|
|
QLIST_REMOVE(ngl, node);
|
|
qemu_free_irqs(ngl->in, ngl->num_in);
|
|
g_free(ngl->name);
|
|
g_free(ngl);
|
|
/* ngl->out irqs are owned by the other end and should not be freed
|
|
* here
|
|
*/
|
|
}
|
|
}
|
|
|
|
static void device_class_base_init(ObjectClass *class, void *data)
|
|
{
|
|
DeviceClass *klass = DEVICE_CLASS(class);
|
|
|
|
/* We explicitly look up properties in the superclasses,
|
|
* so do not propagate them to the subclasses.
|
|
*/
|
|
klass->props = NULL;
|
|
}
|
|
|
|
static void device_unparent(Object *obj)
|
|
{
|
|
DeviceState *dev = DEVICE(obj);
|
|
BusState *bus;
|
|
|
|
if (dev->realized) {
|
|
object_property_set_bool(obj, false, "realized", NULL);
|
|
}
|
|
while (dev->num_child_bus) {
|
|
bus = QLIST_FIRST(&dev->child_bus);
|
|
object_unparent(OBJECT(bus));
|
|
}
|
|
if (dev->parent_bus) {
|
|
bus_remove_child(dev->parent_bus, dev);
|
|
object_unref(OBJECT(dev->parent_bus));
|
|
dev->parent_bus = NULL;
|
|
}
|
|
|
|
/* Only send event if the device had been completely realized */
|
|
if (dev->pending_deleted_event) {
|
|
gchar *path = object_get_canonical_path(OBJECT(dev));
|
|
|
|
qapi_event_send_device_deleted(!!dev->id, dev->id, path, &error_abort);
|
|
g_free(path);
|
|
}
|
|
}
|
|
|
|
static void device_class_init(ObjectClass *class, void *data)
|
|
{
|
|
DeviceClass *dc = DEVICE_CLASS(class);
|
|
|
|
class->unparent = device_unparent;
|
|
dc->realize = device_realize;
|
|
dc->unrealize = device_unrealize;
|
|
|
|
/* by default all devices were considered as hotpluggable,
|
|
* so with intent to check it in generic qdev_unplug() /
|
|
* device_set_realized() functions make every device
|
|
* hotpluggable. Devices that shouldn't be hotpluggable,
|
|
* should override it in their class_init()
|
|
*/
|
|
dc->hotpluggable = true;
|
|
}
|
|
|
|
void device_reset(DeviceState *dev)
|
|
{
|
|
DeviceClass *klass = DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->reset) {
|
|
klass->reset(dev);
|
|
}
|
|
}
|
|
|
|
Object *qdev_get_machine(void)
|
|
{
|
|
static Object *dev;
|
|
|
|
if (dev == NULL) {
|
|
dev = container_get(object_get_root(), "/machine");
|
|
}
|
|
|
|
return dev;
|
|
}
|
|
|
|
static const TypeInfo device_type_info = {
|
|
.name = TYPE_DEVICE,
|
|
.parent = TYPE_OBJECT,
|
|
.instance_size = sizeof(DeviceState),
|
|
.instance_init = device_initfn,
|
|
.instance_post_init = device_post_init,
|
|
.instance_finalize = device_finalize,
|
|
.class_base_init = device_class_base_init,
|
|
.class_init = device_class_init,
|
|
.abstract = true,
|
|
.class_size = sizeof(DeviceClass),
|
|
};
|
|
|
|
static void qbus_initfn(Object *obj)
|
|
{
|
|
BusState *bus = BUS(obj);
|
|
|
|
QTAILQ_INIT(&bus->children);
|
|
object_property_add_link(obj, QDEV_HOTPLUG_HANDLER_PROPERTY,
|
|
TYPE_HOTPLUG_HANDLER,
|
|
(Object **)&bus->hotplug_handler,
|
|
object_property_allow_set_link,
|
|
OBJ_PROP_LINK_UNREF_ON_RELEASE,
|
|
NULL);
|
|
object_property_add_bool(obj, "realized",
|
|
bus_get_realized, bus_set_realized, NULL);
|
|
}
|
|
|
|
static char *default_bus_get_fw_dev_path(DeviceState *dev)
|
|
{
|
|
return g_strdup(object_get_typename(OBJECT(dev)));
|
|
}
|
|
|
|
static void bus_class_init(ObjectClass *class, void *data)
|
|
{
|
|
BusClass *bc = BUS_CLASS(class);
|
|
|
|
class->unparent = bus_unparent;
|
|
bc->get_fw_dev_path = default_bus_get_fw_dev_path;
|
|
}
|
|
|
|
static void qbus_finalize(Object *obj)
|
|
{
|
|
BusState *bus = BUS(obj);
|
|
|
|
g_free((char *)bus->name);
|
|
}
|
|
|
|
static const TypeInfo bus_info = {
|
|
.name = TYPE_BUS,
|
|
.parent = TYPE_OBJECT,
|
|
.instance_size = sizeof(BusState),
|
|
.abstract = true,
|
|
.class_size = sizeof(BusClass),
|
|
.instance_init = qbus_initfn,
|
|
.instance_finalize = qbus_finalize,
|
|
.class_init = bus_class_init,
|
|
};
|
|
|
|
static void qdev_register_types(void)
|
|
{
|
|
type_register_static(&bus_info);
|
|
type_register_static(&device_type_info);
|
|
}
|
|
|
|
type_init(qdev_register_types)
|