virtio-blk-s390: switch to the new API.

[qemu.git] / hw / qdev.c

diff --git a/hw/qdev.c b/hw/qdev.c
index af419b9c1318e1728824984698f1639faea46554..0b20280133ce28ea60edc5407f5b7d4acda12095 100644 (file)
--- a/hw/qdev.c
+++ b/hw/qdev.c
@@ -25,38 +25,22 @@
    inherit from a particular bus (e.g. PCI or I2C) rather than
    this API directly.  */
 
    inherit from a particular bus (e.g. PCI or I2C) rather than
    this API directly.  */
 

-#include "net.h"
-#include "qdev.h"
-#include "sysemu.h"
-#include "error.h"
+#include "hw/qdev.h"
+#include "sysemu/sysemu.h"
+#include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
+#include "qapi/visitor.h"

 
 int qdev_hotplug = 0;
 static bool qdev_hot_added = false;
 static bool qdev_hot_removed = false;
 
 
 int qdev_hotplug = 0;
 static bool qdev_hot_added = false;
 static bool qdev_hot_removed = false;
 

-/* This is a nasty hack to allow passing a NULL bus to qdev_create.  */
-static BusState *main_system_bus;
-static void main_system_bus_create(void);
-
-/* Register a new device type.  */

 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
 {
     DeviceClass *dc = DEVICE_GET_CLASS(dev);
     return dc->vmsd;
 }
 
 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
 {
     DeviceClass *dc = DEVICE_GET_CLASS(dev);
     return dc->vmsd;
 }
 

-BusInfo *qdev_get_bus_info(DeviceState *dev)
-{
-    DeviceClass *dc = DEVICE_GET_CLASS(dev);
-    return dc->bus_info;
-}
-
-Property *qdev_get_props(DeviceState *dev)
-{
-    DeviceClass *dc = DEVICE_GET_CLASS(dev);
-    return dc->props;
-}
-

 const char *qdev_fw_name(DeviceState *dev)
 {
     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 const char *qdev_fw_name(DeviceState *dev)
 {
     DeviceClass *dc = DEVICE_GET_CLASS(dev);


@@ -68,30 +52,57 @@ const char *qdev_fw_name(DeviceState *dev)
     return object_get_typename(OBJECT(dev));
 }
 
     return object_get_typename(OBJECT(dev));
 }
 

-bool qdev_exists(const char *name)
-{
-    return !!object_class_by_name(name);
-}
-

 static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
                                      Error **errp);
 
 static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
                                      Error **errp);
 

-void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
+static void bus_remove_child(BusState *bus, DeviceState *child)

 {
 {

-    Property *prop;
+    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));

 
     if (qdev_hotplug) {
         assert(bus->allow_hotplug);
     }
 
 
     if (qdev_hotplug) {
         assert(bus->allow_hotplug);
     }
 

-    dev->parent_bus = bus;
-    QTAILQ_INSERT_HEAD(&bus->children, dev, sibling);
+    kid->index = bus->max_index++;
+    kid->child = child;
+    object_ref(OBJECT(kid->child));

 
 

-    for (prop = qdev_get_bus_info(dev)->props; prop && prop->name; prop++) {
-        qdev_property_add_legacy(dev, prop, NULL);
-        qdev_property_add_static(dev, prop, NULL);
-    }
-    qdev_prop_set_defaults(dev, dev->parent_bus->info->props);
+    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);
+}
+
+void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
+{
+    dev->parent_bus = bus;
+    object_ref(OBJECT(bus));
+    bus_add_child(bus, dev);

 }
 
 /* Create a new device.  This only initializes the device state structure
 }
 
 /* Create a new device.  This only initializes the device state structure


@@ -104,10 +115,12 @@ DeviceState *qdev_create(BusState *bus, const char *name)
     dev = qdev_try_create(bus, name);
     if (!dev) {
         if (bus) {
     dev = qdev_try_create(bus, name);
     if (!dev) {
         if (bus) {

-            hw_error("Unknown device '%s' for bus '%s'\n", name,
-                     bus->info->name);
+            error_report("Unknown device '%s' for bus '%s'", name,
+                         object_get_typename(OBJECT(bus)));
+            abort();

         } else {
         } else {

-            hw_error("Unknown device '%s' for default sysbus\n", name);
+            error_report("Unknown device '%s' for default sysbus", name);
+            abort();

         }
     }
 
         }
     }
 


@@ -131,8 +144,7 @@ DeviceState *qdev_try_create(BusState *bus, const char *type)
     }
 
     qdev_set_parent_bus(dev, bus);
     }
 
     qdev_set_parent_bus(dev, bus);

-    qdev_prop_set_globals(dev);
-
+    object_unref(OBJECT(dev));

     return dev;
 }
 
     return dev;
 }
 


@@ -143,44 +155,36 @@ DeviceState *qdev_try_create(BusState *bus, const char *type)
    Return 0 on success.  */
 int qdev_init(DeviceState *dev)
 {
    Return 0 on success.  */
 int qdev_init(DeviceState *dev)
 {

-    DeviceClass *dc = DEVICE_GET_CLASS(dev);
-    int rc;
+    Error *local_err = NULL;

 
 

-    assert(dev->state == DEV_STATE_CREATED);
+    assert(!dev->realized);

 
 

-    rc = dc->init(dev);
-    if (rc < 0) {
-        object_unparent(OBJECT(dev));
+    object_property_set_bool(OBJECT(dev), true, "realized", &local_err);
+    if (local_err != NULL) {
+        error_free(local_err);

         qdev_free(dev);
         qdev_free(dev);

-        return rc;
+        return -1;

     }
     }

+    return 0;
+}

 
 

-    if (!OBJECT(dev)->parent) {
-        static int unattached_count = 0;
-        gchar *name = g_strdup_printf("device[%d]", unattached_count++);
-
-        object_property_add_child(container_get(qdev_get_machine(),
-                                                "/unattached"),
-                                  name, OBJECT(dev), NULL);
-        g_free(name);
-    }
+static void device_realize(DeviceState *dev, Error **err)
+{
+    DeviceClass *dc = DEVICE_GET_CLASS(dev);

 
 

-    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);
-    }
-    dev->state = DEV_STATE_INITIALIZED;
-    if (dev->hotplugged) {
-        device_reset(dev);
+    if (dc->init) {
+        int rc = dc->init(dev);
+        if (rc < 0) {
+            error_setg(err, "Device initialization failed.");
+            return;
+        }

     }
     }

-    return 0;

 }
 
 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
                                  int required_for_version)
 {
 }
 
 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
                                  int required_for_version)
 {

-    assert(dev->state == DEV_STATE_CREATED);
+    assert(!dev->realized);

     dev->instance_id_alias = alias_id;
     dev->alias_required_for_version = required_for_version;
 }
     dev->instance_id_alias = alias_id;
     dev->alias_required_for_version = required_for_version;
 }


@@ -210,18 +214,11 @@ static int qdev_reset_one(DeviceState *dev, void *opaque)
     return 0;
 }
 
     return 0;
 }
 

-BusState *sysbus_get_default(void)
-{
-    if (!main_system_bus) {
-        main_system_bus_create();
-    }
-    return main_system_bus;
-}
-

 static int qbus_reset_one(BusState *bus, void *opaque)
 {
 static int qbus_reset_one(BusState *bus, void *opaque)
 {

-    if (bus->info->reset) {
-        return bus->info->reset(bus);
+    BusClass *bc = BUS_GET_CLASS(bus);
+    if (bc->reset) {
+        return bc->reset(bus);

     }
     return 0;
 }
     }
     return 0;
 }


@@ -231,17 +228,21 @@ void qdev_reset_all(DeviceState *dev)
     qdev_walk_children(dev, qdev_reset_one, qbus_reset_one, NULL);
 }
 
     qdev_walk_children(dev, qdev_reset_one, qbus_reset_one, NULL);
 }
 

+void qbus_reset_all(BusState *bus)
+{
+    qbus_walk_children(bus, qdev_reset_one, qbus_reset_one, NULL);
+}
+

 void qbus_reset_all_fn(void *opaque)
 {
     BusState *bus = opaque;
 void qbus_reset_all_fn(void *opaque)
 {
     BusState *bus = opaque;

-    qbus_walk_children(bus, qdev_reset_one, qbus_reset_one, NULL);
+    qbus_reset_all(bus);

 }
 
 /* can be used as ->unplug() callback for the simple cases */
 int qdev_simple_unplug_cb(DeviceState *dev)
 {
     /* just zap it */
 }
 
 /* can be used as ->unplug() callback for the simple cases */
 int qdev_simple_unplug_cb(DeviceState *dev)
 {
     /* just zap it */

-    object_unparent(OBJECT(dev));

     qdev_free(dev);
     return 0;
 }
     qdev_free(dev);
     return 0;
 }


@@ -256,9 +257,10 @@ int qdev_simple_unplug_cb(DeviceState *dev)
    way is somewhat unclean, and best avoided.  */
 void qdev_init_nofail(DeviceState *dev)
 {
    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) {
     if (qdev_init(dev) < 0) {

-        error_report("Initialization of device %s failed",
-                     object_get_typename(OBJECT(dev)));
+        error_report("Initialization of device %s failed", typename);

         exit(1);
     }
 }
         exit(1);
     }
 }


@@ -266,7 +268,7 @@ void qdev_init_nofail(DeviceState *dev)
 /* Unlink device from bus and free the structure.  */
 void qdev_free(DeviceState *dev)
 {
 /* Unlink device from bus and free the structure.  */
 void qdev_free(DeviceState *dev)
 {

-    object_delete(OBJECT(dev));
+    object_unparent(OBJECT(dev));

 }
 
 void qdev_machine_creation_done(void)
 }
 
 void qdev_machine_creation_done(void)


@@ -290,9 +292,9 @@ BusState *qdev_get_parent_bus(DeviceState *dev)
 
 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
 {
 
 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
 {

-    assert(dev->num_gpio_in == 0);
-    dev->num_gpio_in = n;
-    dev->gpio_in = qemu_allocate_irqs(handler, dev, n);
+    dev->gpio_in = qemu_extend_irqs(dev->gpio_in, dev->num_gpio_in, handler,
+                                        dev, n);
+    dev->num_gpio_in += n;

 }
 
 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
 }
 
 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)


@@ -314,20 +316,6 @@ void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
     dev->gpio_out[n] = pin;
 }
 
     dev->gpio_out[n] = pin;
 }
 

-void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
-{
-    qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
-    if (nd->vlan)
-        qdev_prop_set_vlan(dev, "vlan", nd->vlan);
-    if (nd->netdev)
-        qdev_prop_set_netdev(dev, "netdev", nd->netdev);
-    if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
-        qdev_prop_exists(dev, "vectors")) {
-        qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
-    }
-    nd->instantiated = 1;
-}
-

 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 {
     BusState *bus;
 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 {
     BusState *bus;


@@ -343,7 +331,7 @@ BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 int qbus_walk_children(BusState *bus, qdev_walkerfn *devfn,
                        qbus_walkerfn *busfn, void *opaque)
 {
 int qbus_walk_children(BusState *bus, qdev_walkerfn *devfn,
                        qbus_walkerfn *busfn, void *opaque)
 {

-    DeviceState *dev;
+    BusChild *kid;

     int err;
 
     if (busfn) {
     int err;
 
     if (busfn) {


@@ -353,8 +341,8 @@ int qbus_walk_children(BusState *bus, qdev_walkerfn *devfn,
         }
     }
 
         }
     }
 

-    QTAILQ_FOREACH(dev, &bus->children, sibling) {
-        err = qdev_walk_children(dev, devfn, busfn, opaque);
+    QTAILQ_FOREACH(kid, &bus->children, sibling) {
+        err = qdev_walk_children(kid->child, devfn, busfn, opaque);

         if (err < 0) {
             return err;
         }
         if (err < 0) {
             return err;
         }


@@ -388,12 +376,17 @@ int qdev_walk_children(DeviceState *dev, qdev_walkerfn *devfn,
 
 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 {
 
 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 {

-    DeviceState *dev, *ret;
+    BusChild *kid;
+    DeviceState *ret;

     BusState *child;
 
     BusState *child;
 

-    QTAILQ_FOREACH(dev, &bus->children, sibling) {
-        if (dev->id && strcmp(dev->id, id) == 0)
+    QTAILQ_FOREACH(kid, &bus->children, sibling) {
+        DeviceState *dev = kid->child;
+
+        if (dev->id && strcmp(dev->id, id) == 0) {

             return dev;
             return dev;

+        }
+

         QLIST_FOREACH(child, &dev->child_bus, sibling) {
             ret = qdev_find_recursive(child, id);
             if (ret) {
         QLIST_FOREACH(child, &dev->child_bus, sibling) {
             ret = qdev_find_recursive(child, id);
             if (ret) {


@@ -404,84 +397,95 @@ DeviceState *qdev_find_recursive(BusState *bus, const char *id)
     return NULL;
 }
 
     return NULL;
 }
 

-void qbus_create_inplace(BusState *bus, BusInfo *info,
-                         DeviceState *parent, const char *name)
+static void qbus_realize(BusState *bus, DeviceState *parent, const char *name)

 {
 {

+    const char *typename = object_get_typename(OBJECT(bus));

     char *buf;
     int i,len;
 
     char *buf;
     int i,len;
 

-    bus->info = info;

     bus->parent = parent;
 
     if (name) {
     bus->parent = parent;
 
     if (name) {

-        /* use supplied name */

         bus->name = g_strdup(name);
         bus->name = g_strdup(name);

-    } else if (parent && parent->id) {
+    } else if (bus->parent && bus->parent->id) {

         /* parent device has id -> use it for bus name */
         /* parent device has id -> use it for bus name */

-        len = strlen(parent->id) + 16;
+        len = strlen(bus->parent->id) + 16;

         buf = g_malloc(len);
         buf = g_malloc(len);

-        snprintf(buf, len, "%s.%d", parent->id, parent->num_child_bus);
+        snprintf(buf, len, "%s.%d", bus->parent->id, bus->parent->num_child_bus);

         bus->name = buf;
     } else {
         /* no id -> use lowercase bus type for bus name */
         bus->name = buf;
     } else {
         /* no id -> use lowercase bus type for bus name */

-        len = strlen(info->name) + 16;
+        len = strlen(typename) + 16;

         buf = g_malloc(len);
         buf = g_malloc(len);

-        len = snprintf(buf, len, "%s.%d", info->name,
-                       parent ? parent->num_child_bus : 0);
+        len = snprintf(buf, len, "%s.%d", typename,
+                       bus->parent ? bus->parent->num_child_bus : 0);

         for (i = 0; i < len; i++)
             buf[i] = qemu_tolower(buf[i]);
         bus->name = buf;
     }
 
         for (i = 0; i < len; i++)
             buf[i] = qemu_tolower(buf[i]);
         bus->name = buf;
     }
 

-    QTAILQ_INIT(&bus->children);
-    if (parent) {
-        QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling);
-        parent->num_child_bus++;
-    } else if (bus != main_system_bus) {
+    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);
     }
 }
 
         /* 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);
     }
 }
 

-BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name)
+static void bus_unparent(Object *obj)
+{
+    BusState *bus = BUS(obj);
+    BusChild *kid;
+
+    while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
+        DeviceState *dev = kid->child;
+        qdev_free(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);
+    }
+}
+
+void qbus_create_inplace(void *bus, const char *typename,
+                         DeviceState *parent, const char *name)
+{
+    object_initialize(bus, typename);
+    qbus_realize(bus, parent, name);
+}
+
+BusState *qbus_create(const char *typename, DeviceState *parent, const char *name)

 {
     BusState *bus;
 
 {
     BusState *bus;
 

-    bus = g_malloc0(info->size);
-    bus->qdev_allocated = 1;
-    qbus_create_inplace(bus, info, parent, name);
+    bus = BUS(object_new(typename));
+    qbus_realize(bus, parent, name);
+

     return bus;
 }
 
     return bus;
 }
 

-static void main_system_bus_create(void)
+void qbus_free(BusState *bus)

 {
 {

-    /* assign main_system_bus before qbus_create_inplace()
-     * in order to make "if (bus != main_system_bus)" work */
-    main_system_bus = g_malloc0(system_bus_info.size);
-    main_system_bus->qdev_allocated = 1;
-    qbus_create_inplace(main_system_bus, &system_bus_info, NULL,
-                        "main-system-bus");
+    object_unparent(OBJECT(bus));

 }
 
 }
 

-void qbus_free(BusState *bus)
+static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev)

 {
 {

-    DeviceState *dev;
+    BusClass *bc = BUS_GET_CLASS(bus);

 
 

-    while ((dev = QTAILQ_FIRST(&bus->children)) != NULL) {
-        qdev_free(dev);
-    }
-    if (bus->parent) {
-        QLIST_REMOVE(bus, sibling);
-        bus->parent->num_child_bus--;
-    } else {
-        assert(bus != main_system_bus); /* main_system_bus is never freed */
-        qemu_unregister_reset(qbus_reset_all_fn, bus);
-    }
-    g_free((void*)bus->name);
-    if (bus->qdev_allocated) {
-        g_free(bus);
+    if (bc->get_fw_dev_path) {
+        return bc->get_fw_dev_path(dev);

     }
     }

+
+    return NULL;

 }
 
 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
 }
 
 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)


@@ -491,8 +495,8 @@ static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
     if (dev && dev->parent_bus) {
         char *d;
         l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
     if (dev && dev->parent_bus) {
         char *d;
         l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);

-        if (dev->parent_bus->info->get_fw_dev_path) {
-            d = dev->parent_bus->info->get_fw_dev_path(dev);
+        d = bus_get_fw_dev_path(dev->parent_bus, dev);
+        if (d) {

             l += snprintf(p + l, size - l, "%s", d);
             g_free(d);
         } else {
             l += snprintf(p + l, size - l, "%s", d);
             g_free(d);
         } else {


@@ -513,12 +517,23 @@ char* qdev_get_fw_dev_path(DeviceState *dev)
 
     path[l-1] = '\0';
 
 
     path[l-1] = '\0';
 

-    return strdup(path);
+    return g_strdup(path);

 }
 
 }
 

-static char *qdev_get_type(Object *obj, Error **errp)
+char *qdev_get_dev_path(DeviceState *dev)

 {
 {

-    return g_strdup(object_get_typename(obj));
+    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;

 }
 
 /**
 }
 
 /**


@@ -547,7 +562,7 @@ static void qdev_set_legacy_property(Object *obj, Visitor *v, void *opaque,
     char *ptr = NULL;
     int ret;
 
     char *ptr = NULL;
     int ret;
 

-    if (dev->state != DEV_STATE_CREATED) {
+    if (dev->realized) {

         error_set(errp, QERR_PERMISSION_DENIED);
         return;
     }
         error_set(errp, QERR_PERMISSION_DENIED);
         return;
     }


@@ -606,6 +621,9 @@ void qdev_property_add_legacy(DeviceState *dev, Property *prop,
 void qdev_property_add_static(DeviceState *dev, Property *prop,
                               Error **errp)
 {
 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
     /*
      * 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


@@ -615,15 +633,83 @@ void qdev_property_add_static(DeviceState *dev, Property *prop,
         return;
     }
 
         return;
     }
 

-    object_property_add(OBJECT(dev), prop->name, prop->info->name,
+    object_property_add(obj, prop->name, prop->info->name,

                         prop->info->get, prop->info->set,
                         prop->info->release,
                         prop->info->get, prop->info->set,
                         prop->info->release,

-                        prop, errp);
+                        prop, &local_err);
+
+    if (local_err) {
+        error_propagate(errp, local_err);
+        return;
+    }
+    if (prop->qtype == QTYPE_NONE) {
+        return;
+    }
+
+    if (prop->qtype == QTYPE_QBOOL) {
+        object_property_set_bool(obj, prop->defval, prop->name, &local_err);
+    } else if (prop->info->enum_table) {
+        object_property_set_str(obj, prop->info->enum_table[prop->defval],
+                                prop->name, &local_err);
+    } else if (prop->qtype == QTYPE_QINT) {
+        object_property_set_int(obj, prop->defval, prop->name, &local_err);
+    }
+    assert_no_error(local_err);
+}
+
+static bool device_get_realized(Object *obj, Error **err)
+{
+    DeviceState *dev = DEVICE(obj);
+    return dev->realized;
+}
+
+static void device_set_realized(Object *obj, bool value, Error **err)
+{
+    DeviceState *dev = DEVICE(obj);
+    DeviceClass *dc = DEVICE_GET_CLASS(dev);
+    Error *local_err = NULL;
+
+    if (value && !dev->realized) {
+        if (dc->realize) {
+            dc->realize(dev, &local_err);
+        }
+
+        if (!obj->parent && local_err == NULL) {
+            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, &local_err);
+            g_free(name);
+        }
+
+        if (qdev_get_vmsd(dev) && local_err == NULL) {
+            vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev,
+                                           dev->instance_id_alias,
+                                           dev->alias_required_for_version);
+        }
+        if (dev->hotplugged && local_err == NULL) {
+            device_reset(dev);
+        }
+    } else if (!value && dev->realized) {
+        if (dc->unrealize) {
+            dc->unrealize(dev, &local_err);
+        }
+    }
+
+    if (local_err != NULL) {
+        error_propagate(err, local_err);
+        return;
+    }
+
+    dev->realized = value;

 }
 
 static void device_initfn(Object *obj)
 {
     DeviceState *dev = DEVICE(obj);
 }
 
 static void device_initfn(Object *obj)
 {
     DeviceState *dev = DEVICE(obj);

+    ObjectClass *class;

     Property *prop;
 
     if (qdev_hotplug) {
     Property *prop;
 
     if (qdev_hotplug) {


@@ -632,40 +718,75 @@ static void device_initfn(Object *obj)
     }
 
     dev->instance_id_alias = -1;
     }
 
     dev->instance_id_alias = -1;

-    dev->state = DEV_STATE_CREATED;
+    dev->realized = false;

 
 

-    for (prop = qdev_get_props(dev); prop && prop->name; prop++) {
-        qdev_property_add_legacy(dev, prop, NULL);
-        qdev_property_add_static(dev, prop, NULL);
-    }
+    object_property_add_bool(obj, "realized",
+                             device_get_realized, device_set_realized, NULL);

 
 

-    object_property_add_str(OBJECT(dev), "type", qdev_get_type, NULL, NULL);
-    qdev_prop_set_defaults(dev, qdev_get_props(dev));
+    class = object_get_class(OBJECT(dev));
+    do {
+        for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) {
+            qdev_property_add_legacy(dev, prop, NULL);
+            qdev_property_add_static(dev, prop, NULL);
+        }
+        class = object_class_get_parent(class);
+    } while (class != object_class_by_name(TYPE_DEVICE));
+    qdev_prop_set_globals(dev);
+
+    object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS,
+                             (Object **)&dev->parent_bus, NULL);

 }
 
 /* Unlink device from bus and free the structure.  */
 static void device_finalize(Object *obj)
 {
     DeviceState *dev = DEVICE(obj);
 }
 
 /* Unlink device from bus and free the structure.  */
 static void device_finalize(Object *obj)
 {
     DeviceState *dev = DEVICE(obj);

-    BusState *bus;
+    if (dev->opts) {
+        qemu_opts_del(dev->opts);
+    }
+}
+
+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);

     DeviceClass *dc = DEVICE_GET_CLASS(dev);
     DeviceClass *dc = DEVICE_GET_CLASS(dev);

+    BusState *bus;

 
 

-    if (dev->state == DEV_STATE_INITIALIZED) {
-        while (dev->num_child_bus) {
-            bus = QLIST_FIRST(&dev->child_bus);
-            qbus_free(bus);
-        }
+    while (dev->num_child_bus) {
+        bus = QLIST_FIRST(&dev->child_bus);
+        qbus_free(bus);
+    }
+    if (dev->realized) {

         if (qdev_get_vmsd(dev)) {
             vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
         }
         if (dc->exit) {
             dc->exit(dev);
         }
         if (qdev_get_vmsd(dev)) {
             vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
         }
         if (dc->exit) {
             dc->exit(dev);
         }

-        if (dev->opts) {
-            qemu_opts_del(dev->opts);
-        }

     }
     }

-    QTAILQ_REMOVE(&dev->parent_bus->children, dev, sibling);
+    if (dev->parent_bus) {
+        bus_remove_child(dev->parent_bus, dev);
+        object_unref(OBJECT(dev->parent_bus));
+        dev->parent_bus = NULL;
+    }
+}
+
+static void device_class_init(ObjectClass *class, void *data)
+{
+    DeviceClass *dc = DEVICE_CLASS(class);
+
+    class->unparent = device_unparent;
+    dc->realize = device_realize;

 }
 
 void device_reset(DeviceState *dev)
 }
 
 void device_reset(DeviceState *dev)


@@ -688,18 +809,51 @@ Object *qdev_get_machine(void)
     return dev;
 }
 
     return dev;
 }
 

-static TypeInfo device_type_info = {
+static const TypeInfo device_type_info = {

     .name = TYPE_DEVICE,
     .parent = TYPE_OBJECT,
     .instance_size = sizeof(DeviceState),
     .instance_init = device_initfn,
     .instance_finalize = device_finalize,
     .name = TYPE_DEVICE,
     .parent = TYPE_OBJECT,
     .instance_size = sizeof(DeviceState),
     .instance_init = device_initfn,
     .instance_finalize = device_finalize,

+    .class_base_init = device_class_base_init,
+    .class_init = device_class_init,

     .abstract = true,
     .class_size = sizeof(DeviceClass),
 };
 
     .abstract = true,
     .class_size = sizeof(DeviceClass),
 };
 

+static void qbus_initfn(Object *obj)
+{
+    BusState *bus = BUS(obj);
+
+    QTAILQ_INIT(&bus->children);
+}
+
+static void bus_class_init(ObjectClass *class, void *data)
+{
+    class->unparent = bus_unparent;
+}
+
+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)
 {
 static void qdev_register_types(void)
 {

+    type_register_static(&bus_info);

     type_register_static(&device_type_info);
 }
 
     type_register_static(&device_type_info);
 }