hw/qdev.c

   1 /*
   2  *  Dynamic device configuration and creation.
   3  *
   4  *  Copyright (c) 2009 CodeSourcery
   5  *
   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.
  10  *
  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.
  15  *
  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/>.
  18  */
  19
  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
  26    this API directly.  */
  27
  28 #include "net.h"
  29 #include "qdev.h"
  30 #include "sysemu.h"
  31 #include "error.h"
  32
  33 int qdev_hotplug = 0;
  34 static bool qdev_hot_added = false;
  35 static bool qdev_hot_removed = false;
  36
  37 /* Register a new device type.  */
  38 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
  39 {
  40     DeviceClass *dc = DEVICE_GET_CLASS(dev);
  41     return dc->vmsd;
  42 }
  43
  44 const char *qdev_fw_name(DeviceState *dev)
  45 {
  46     DeviceClass *dc = DEVICE_GET_CLASS(dev);
  47
  48     if (dc->fw_name) {
  49         return dc->fw_name;
  50     }
  51
  52     return object_get_typename(OBJECT(dev));
  53 }
  54
  55 bool qdev_exists(const char *name)
  56 {
  57     return !!object_class_by_name(name);
  58 }
  59
  60 static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
  61                                      Error **errp);
  62
  63 static void bus_remove_child(BusState *bus, DeviceState *child)
  64 {
  65     BusChild *kid;
  66
  67     QTAILQ_FOREACH(kid, &bus->children, sibling) {
  68         if (kid->child == child) {
  69             char name[32];
  70
  71             snprintf(name, sizeof(name), "child[%d]", kid->index);
  72             QTAILQ_REMOVE(&bus->children, kid, sibling);
  73             object_property_del(OBJECT(bus), name, NULL);
  74             g_free(kid);
  75             return;
  76         }
  77     }
  78 }
  79
  80 static void bus_add_child(BusState *bus, DeviceState *child)
  81 {
  82     char name[32];
  83     BusChild *kid = g_malloc0(sizeof(*kid));
  84
  85     if (qdev_hotplug) {
  86         assert(bus->allow_hotplug);
  87     }
  88
  89     kid->index = bus->max_index++;
  90     kid->child = child;
  91
  92     QTAILQ_INSERT_HEAD(&bus->children, kid, sibling);
  93
  94     snprintf(name, sizeof(name), "child[%d]", kid->index);
  95     object_property_add_link(OBJECT(bus), name,
  96                              object_get_typename(OBJECT(child)),
  97                              (Object **)&kid->child,
  98                              NULL);
  99 }
 100
 101 void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
 102 {
 103     dev->parent_bus = bus;
 104     bus_add_child(bus, dev);
 105 }
 106
 107 /* Create a new device.  This only initializes the device state structure
 108    and allows properties to be set.  qdev_init should be called to
 109    initialize the actual device emulation.  */
 110 DeviceState *qdev_create(BusState *bus, const char *name)
 111 {
 112     DeviceState *dev;
 113
 114     dev = qdev_try_create(bus, name);
 115     if (!dev) {
 116         if (bus) {
 117             hw_error("Unknown device '%s' for bus '%s'\n", name,
 118                      object_get_typename(OBJECT(bus)));
 119         } else {
 120             hw_error("Unknown device '%s' for default sysbus\n", name);
 121         }
 122     }
 123
 124     return dev;
 125 }
 126
 127 DeviceState *qdev_try_create(BusState *bus, const char *type)
 128 {
 129     DeviceState *dev;
 130
 131     if (object_class_by_name(type) == NULL) {
 132         return NULL;
 133     }
 134     dev = DEVICE(object_new(type));
 135     if (!dev) {
 136         return NULL;
 137     }
 138
 139     if (!bus) {
 140         bus = sysbus_get_default();
 141     }
 142
 143     qdev_set_parent_bus(dev, bus);
 144
 145     return dev;
 146 }
 147
 148 /* Initialize a device.  Device properties should be set before calling
 149    this function.  IRQs and MMIO regions should be connected/mapped after
 150    calling this function.
 151    On failure, destroy the device and return negative value.
 152    Return 0 on success.  */
 153 int qdev_init(DeviceState *dev)
 154 {
 155     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 156     int rc;
 157
 158     assert(dev->state == DEV_STATE_CREATED);
 159
 160     rc = dc->init(dev);
 161     if (rc < 0) {
 162         qdev_free(dev);
 163         return rc;
 164     }
 165
 166     if (!OBJECT(dev)->parent) {
 167         static int unattached_count = 0;
 168         gchar *name = g_strdup_printf("device[%d]", unattached_count++);
 169
 170         object_property_add_child(container_get(qdev_get_machine(),
 171                                                 "/unattached"),
 172                                   name, OBJECT(dev), NULL);
 173         g_free(name);
 174     }
 175
 176     if (qdev_get_vmsd(dev)) {
 177         vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev,
 178                                        dev->instance_id_alias,
 179                                        dev->alias_required_for_version);
 180     }
 181     dev->state = DEV_STATE_INITIALIZED;
 182     if (dev->hotplugged) {
 183         device_reset(dev);
 184     }
 185     return 0;
 186 }
 187
 188 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
 189                                  int required_for_version)
 190 {
 191     assert(dev->state == DEV_STATE_CREATED);
 192     dev->instance_id_alias = alias_id;
 193     dev->alias_required_for_version = required_for_version;
 194 }
 195
 196 void qdev_unplug(DeviceState *dev, Error **errp)
 197 {
 198     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 199
 200     if (!dev->parent_bus->allow_hotplug) {
 201         error_set(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
 202         return;
 203     }
 204     assert(dc->unplug != NULL);
 205
 206     qdev_hot_removed = true;
 207
 208     if (dc->unplug(dev) < 0) {
 209         error_set(errp, QERR_UNDEFINED_ERROR);
 210         return;
 211     }
 212 }
 213
 214 static int qdev_reset_one(DeviceState *dev, void *opaque)
 215 {
 216     device_reset(dev);
 217
 218     return 0;
 219 }
 220
 221 static int qbus_reset_one(BusState *bus, void *opaque)
 222 {
 223     BusClass *bc = BUS_GET_CLASS(bus);
 224     if (bc->reset) {
 225         return bc->reset(bus);
 226     }
 227     return 0;
 228 }
 229
 230 void qdev_reset_all(DeviceState *dev)
 231 {
 232     qdev_walk_children(dev, qdev_reset_one, qbus_reset_one, NULL);
 233 }
 234
 235 void qbus_reset_all_fn(void *opaque)
 236 {
 237     BusState *bus = opaque;
 238     qbus_walk_children(bus, qdev_reset_one, qbus_reset_one, NULL);
 239 }
 240
 241 /* can be used as ->unplug() callback for the simple cases */
 242 int qdev_simple_unplug_cb(DeviceState *dev)
 243 {
 244     /* just zap it */
 245     qdev_free(dev);
 246     return 0;
 247 }
 248
 249
 250 /* Like qdev_init(), but terminate program via error_report() instead of
 251    returning an error value.  This is okay during machine creation.
 252    Don't use for hotplug, because there callers need to recover from
 253    failure.  Exception: if you know the device's init() callback can't
 254    fail, then qdev_init_nofail() can't fail either, and is therefore
 255    usable even then.  But relying on the device implementation that
 256    way is somewhat unclean, and best avoided.  */
 257 void qdev_init_nofail(DeviceState *dev)
 258 {
 259     const char *typename = object_get_typename(OBJECT(dev));
 260
 261     if (qdev_init(dev) < 0) {
 262         error_report("Initialization of device %s failed", typename);
 263         exit(1);
 264     }
 265 }
 266
 267 /* Unlink device from bus and free the structure.  */
 268 void qdev_free(DeviceState *dev)
 269 {
 270     object_delete(OBJECT(dev));
 271 }
 272
 273 void qdev_machine_creation_done(void)
 274 {
 275     /*
 276      * ok, initial machine setup is done, starting from now we can
 277      * only create hotpluggable devices
 278      */
 279     qdev_hotplug = 1;
 280 }
 281
 282 bool qdev_machine_modified(void)
 283 {
 284     return qdev_hot_added || qdev_hot_removed;
 285 }
 286
 287 BusState *qdev_get_parent_bus(DeviceState *dev)
 288 {
 289     return dev->parent_bus;
 290 }
 291
 292 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
 293 {
 294     assert(dev->num_gpio_in == 0);
 295     dev->num_gpio_in = n;
 296     dev->gpio_in = qemu_allocate_irqs(handler, dev, n);
 297 }
 298
 299 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
 300 {
 301     assert(dev->num_gpio_out == 0);
 302     dev->num_gpio_out = n;
 303     dev->gpio_out = pins;
 304 }
 305
 306 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
 307 {
 308     assert(n >= 0 && n < dev->num_gpio_in);
 309     return dev->gpio_in[n];
 310 }
 311
 312 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
 313 {
 314     assert(n >= 0 && n < dev->num_gpio_out);
 315     dev->gpio_out[n] = pin;
 316 }
 317
 318 void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
 319 {
 320     qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
 321     if (nd->netdev)
 322         qdev_prop_set_netdev(dev, "netdev", nd->netdev);
 323     if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
 324         object_property_find(OBJECT(dev), "vectors", NULL)) {
 325         qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
 326     }
 327     nd->instantiated = 1;
 328 }
 329
 330 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 331 {
 332     BusState *bus;
 333
 334     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 335         if (strcmp(name, bus->name) == 0) {
 336             return bus;
 337         }
 338     }
 339     return NULL;
 340 }
 341
 342 int qbus_walk_children(BusState *bus, qdev_walkerfn *devfn,
 343                        qbus_walkerfn *busfn, void *opaque)
 344 {
 345     BusChild *kid;
 346     int err;
 347
 348     if (busfn) {
 349         err = busfn(bus, opaque);
 350         if (err) {
 351             return err;
 352         }
 353     }
 354
 355     QTAILQ_FOREACH(kid, &bus->children, sibling) {
 356         err = qdev_walk_children(kid->child, devfn, busfn, opaque);
 357         if (err < 0) {
 358             return err;
 359         }
 360     }
 361
 362     return 0;
 363 }
 364
 365 int qdev_walk_children(DeviceState *dev, qdev_walkerfn *devfn,
 366                        qbus_walkerfn *busfn, void *opaque)
 367 {
 368     BusState *bus;
 369     int err;
 370
 371     if (devfn) {
 372         err = devfn(dev, opaque);
 373         if (err) {
 374             return err;
 375         }
 376     }
 377
 378     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 379         err = qbus_walk_children(bus, devfn, busfn, opaque);
 380         if (err < 0) {
 381             return err;
 382         }
 383     }
 384
 385     return 0;
 386 }
 387
 388 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 389 {
 390     BusChild *kid;
 391     DeviceState *ret;
 392     BusState *child;
 393
 394     QTAILQ_FOREACH(kid, &bus->children, sibling) {
 395         DeviceState *dev = kid->child;
 396
 397         if (dev->id && strcmp(dev->id, id) == 0) {
 398             return dev;
 399         }
 400
 401         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 402             ret = qdev_find_recursive(child, id);
 403             if (ret) {
 404                 return ret;
 405             }
 406         }
 407     }
 408     return NULL;
 409 }
 410
 411 static void qbus_realize(BusState *bus)
 412 {
 413     const char *typename = object_get_typename(OBJECT(bus));
 414     char *buf;
 415     int i,len;
 416
 417     if (bus->name) {
 418         /* use supplied name */
 419     } else if (bus->parent && bus->parent->id) {
 420         /* parent device has id -> use it for bus name */
 421         len = strlen(bus->parent->id) + 16;
 422         buf = g_malloc(len);
 423         snprintf(buf, len, "%s.%d", bus->parent->id, bus->parent->num_child_bus);
 424         bus->name = buf;
 425     } else {
 426         /* no id -> use lowercase bus type for bus name */
 427         len = strlen(typename) + 16;
 428         buf = g_malloc(len);
 429         len = snprintf(buf, len, "%s.%d", typename,
 430                        bus->parent ? bus->parent->num_child_bus : 0);
 431         for (i = 0; i < len; i++)
 432             buf[i] = qemu_tolower(buf[i]);
 433         bus->name = buf;
 434     }
 435
 436     if (bus->parent) {
 437         QLIST_INSERT_HEAD(&bus->parent->child_bus, bus, sibling);
 438         bus->parent->num_child_bus++;
 439         object_property_add_child(OBJECT(bus->parent), bus->name, OBJECT(bus), NULL);
 440     } else if (bus != sysbus_get_default()) {
 441         /* TODO: once all bus devices are qdevified,
 442            only reset handler for main_system_bus should be registered here. */
 443         qemu_register_reset(qbus_reset_all_fn, bus);
 444     }
 445 }
 446
 447 void qbus_create_inplace(BusState *bus, const char *typename,
 448                          DeviceState *parent, const char *name)
 449 {
 450     object_initialize(bus, typename);
 451
 452     bus->parent = parent;
 453     bus->name = name ? g_strdup(name) : NULL;
 454     qbus_realize(bus);
 455 }
 456
 457 BusState *qbus_create(const char *typename, DeviceState *parent, const char *name)
 458 {
 459     BusState *bus;
 460
 461     bus = BUS(object_new(typename));
 462     bus->qom_allocated = true;
 463
 464     bus->parent = parent;
 465     bus->name = name ? g_strdup(name) : NULL;
 466     qbus_realize(bus);
 467
 468     return bus;
 469 }
 470
 471 void qbus_free(BusState *bus)
 472 {
 473     if (bus->qom_allocated) {
 474         object_delete(OBJECT(bus));
 475     } else {
 476         object_finalize(OBJECT(bus));
 477         if (bus->glib_allocated) {
 478             g_free(bus);
 479         }
 480     }
 481 }
 482
 483 static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev)
 484 {
 485     BusClass *bc = BUS_GET_CLASS(bus);
 486
 487     if (bc->get_fw_dev_path) {
 488         return bc->get_fw_dev_path(dev);
 489     }
 490
 491     return NULL;
 492 }
 493
 494 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
 495 {
 496     int l = 0;
 497
 498     if (dev && dev->parent_bus) {
 499         char *d;
 500         l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
 501         d = bus_get_fw_dev_path(dev->parent_bus, dev);
 502         if (d) {
 503             l += snprintf(p + l, size - l, "%s", d);
 504             g_free(d);
 505         } else {
 506             l += snprintf(p + l, size - l, "%s", object_get_typename(OBJECT(dev)));
 507         }
 508     }
 509     l += snprintf(p + l , size - l, "/");
 510
 511     return l;
 512 }
 513
 514 char* qdev_get_fw_dev_path(DeviceState *dev)
 515 {
 516     char path[128];
 517     int l;
 518
 519     l = qdev_get_fw_dev_path_helper(dev, path, 128);
 520
 521     path[l-1] = '\0';
 522
 523     return strdup(path);
 524 }
 525
 526 char *qdev_get_dev_path(DeviceState *dev)
 527 {
 528     BusClass *bc;
 529
 530     if (!dev || !dev->parent_bus) {
 531         return NULL;
 532     }
 533
 534     bc = BUS_GET_CLASS(dev->parent_bus);
 535     if (bc->get_dev_path) {
 536         return bc->get_dev_path(dev);
 537     }
 538
 539     return NULL;
 540 }
 541
 542 /**
 543  * Legacy property handling
 544  */
 545
 546 static void qdev_get_legacy_property(Object *obj, Visitor *v, void *opaque,
 547                                      const char *name, Error **errp)
 548 {
 549     DeviceState *dev = DEVICE(obj);
 550     Property *prop = opaque;
 551
 552     char buffer[1024];
 553     char *ptr = buffer;
 554
 555     prop->info->print(dev, prop, buffer, sizeof(buffer));
 556     visit_type_str(v, &ptr, name, errp);
 557 }
 558
 559 static void qdev_set_legacy_property(Object *obj, Visitor *v, void *opaque,
 560                                      const char *name, Error **errp)
 561 {
 562     DeviceState *dev = DEVICE(obj);
 563     Property *prop = opaque;
 564     Error *local_err = NULL;
 565     char *ptr = NULL;
 566     int ret;
 567
 568     if (dev->state != DEV_STATE_CREATED) {
 569         error_set(errp, QERR_PERMISSION_DENIED);
 570         return;
 571     }
 572
 573     visit_type_str(v, &ptr, name, &local_err);
 574     if (local_err) {
 575         error_propagate(errp, local_err);
 576         return;
 577     }
 578
 579     ret = prop->info->parse(dev, prop, ptr);
 580     error_set_from_qdev_prop_error(errp, ret, dev, prop, ptr);
 581     g_free(ptr);
 582 }
 583
 584 /**
 585  * @qdev_add_legacy_property - adds a legacy property
 586  *
 587  * Do not use this is new code!  Properties added through this interface will
 588  * be given names and types in the "legacy" namespace.
 589  *
 590  * Legacy properties are string versions of other OOM properties.  The format
 591  * of the string depends on the property type.
 592  */
 593 void qdev_property_add_legacy(DeviceState *dev, Property *prop,
 594                               Error **errp)
 595 {
 596     gchar *name, *type;
 597
 598     /* Register pointer properties as legacy properties */
 599     if (!prop->info->print && !prop->info->parse &&
 600         (prop->info->set || prop->info->get)) {
 601         return;
 602     }
 603
 604     name = g_strdup_printf("legacy-%s", prop->name);
 605     type = g_strdup_printf("legacy<%s>",
 606                            prop->info->legacy_name ?: prop->info->name);
 607
 608     object_property_add(OBJECT(dev), name, type,
 609                         prop->info->print ? qdev_get_legacy_property : prop->info->get,
 610                         prop->info->parse ? qdev_set_legacy_property : prop->info->set,
 611                         NULL,
 612                         prop, errp);
 613
 614     g_free(type);
 615     g_free(name);
 616 }
 617
 618 /**
 619  * @qdev_property_add_static - add a @Property to a device.
 620  *
 621  * Static properties access data in a struct.  The actual type of the
 622  * property and the field depends on the property type.
 623  */
 624 void qdev_property_add_static(DeviceState *dev, Property *prop,
 625                               Error **errp)
 626 {
 627     Error *local_err = NULL;
 628     Object *obj = OBJECT(dev);
 629
 630     /*
 631      * TODO qdev_prop_ptr does not have getters or setters.  It must
 632      * go now that it can be replaced with links.  The test should be
 633      * removed along with it: all static properties are read/write.
 634      */
 635     if (!prop->info->get && !prop->info->set) {
 636         return;
 637     }
 638
 639     object_property_add(obj, prop->name, prop->info->name,
 640                         prop->info->get, prop->info->set,
 641                         prop->info->release,
 642                         prop, &local_err);
 643
 644     if (local_err) {
 645         error_propagate(errp, local_err);
 646         return;
 647     }
 648     if (prop->qtype == QTYPE_NONE) {
 649         return;
 650     }
 651
 652     if (prop->qtype == QTYPE_QBOOL) {
 653         object_property_set_bool(obj, prop->defval, prop->name, &local_err);
 654     } else if (prop->info->enum_table) {
 655         object_property_set_str(obj, prop->info->enum_table[prop->defval],
 656                                 prop->name, &local_err);
 657     } else if (prop->qtype == QTYPE_QINT) {
 658         object_property_set_int(obj, prop->defval, prop->name, &local_err);
 659     }
 660     assert_no_error(local_err);
 661 }
 662
 663 static void device_initfn(Object *obj)
 664 {
 665     DeviceState *dev = DEVICE(obj);
 666     ObjectClass *class;
 667     Property *prop;
 668
 669     if (qdev_hotplug) {
 670         dev->hotplugged = 1;
 671         qdev_hot_added = true;
 672     }
 673
 674     dev->instance_id_alias = -1;
 675     dev->state = DEV_STATE_CREATED;
 676
 677     class = object_get_class(OBJECT(dev));
 678     do {
 679         for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) {
 680             qdev_property_add_legacy(dev, prop, NULL);
 681             qdev_property_add_static(dev, prop, NULL);
 682         }
 683         class = object_class_get_parent(class);
 684     } while (class != object_class_by_name(TYPE_DEVICE));
 685     qdev_prop_set_globals(dev);
 686
 687     object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS,
 688                              (Object **)&dev->parent_bus, NULL);
 689 }
 690
 691 /* Unlink device from bus and free the structure.  */
 692 static void device_finalize(Object *obj)
 693 {
 694     DeviceState *dev = DEVICE(obj);
 695     BusState *bus;
 696     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 697
 698     if (dev->state == DEV_STATE_INITIALIZED) {
 699         while (dev->num_child_bus) {
 700             bus = QLIST_FIRST(&dev->child_bus);
 701             qbus_free(bus);
 702         }
 703         if (qdev_get_vmsd(dev)) {
 704             vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
 705         }
 706         if (dc->exit) {
 707             dc->exit(dev);
 708         }
 709         if (dev->opts) {
 710             qemu_opts_del(dev->opts);
 711         }
 712     }
 713     if (dev->parent_bus) {
 714         bus_remove_child(dev->parent_bus, dev);
 715     }
 716 }
 717
 718 static void device_class_base_init(ObjectClass *class, void *data)
 719 {
 720     DeviceClass *klass = DEVICE_CLASS(class);
 721
 722     /* We explicitly look up properties in the superclasses,
 723      * so do not propagate them to the subclasses.
 724      */
 725     klass->props = NULL;
 726 }
 727
 728 void device_reset(DeviceState *dev)
 729 {
 730     DeviceClass *klass = DEVICE_GET_CLASS(dev);
 731
 732     if (klass->reset) {
 733         klass->reset(dev);
 734     }
 735 }
 736
 737 Object *qdev_get_machine(void)
 738 {
 739     static Object *dev;
 740
 741     if (dev == NULL) {
 742         dev = container_get(object_get_root(), "/machine");
 743     }
 744
 745     return dev;
 746 }
 747
 748 static TypeInfo device_type_info = {
 749     .name = TYPE_DEVICE,
 750     .parent = TYPE_OBJECT,
 751     .instance_size = sizeof(DeviceState),
 752     .instance_init = device_initfn,
 753     .instance_finalize = device_finalize,
 754     .class_base_init = device_class_base_init,
 755     .abstract = true,
 756     .class_size = sizeof(DeviceClass),
 757 };
 758
 759 static void qbus_initfn(Object *obj)
 760 {
 761     BusState *bus = BUS(obj);
 762
 763     QTAILQ_INIT(&bus->children);
 764 }
 765
 766 static void qbus_finalize(Object *obj)
 767 {
 768     BusState *bus = BUS(obj);
 769     BusChild *kid;
 770
 771     while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
 772         DeviceState *dev = kid->child;
 773         qdev_free(dev);
 774     }
 775     if (bus->parent) {
 776         QLIST_REMOVE(bus, sibling);
 777         bus->parent->num_child_bus--;
 778     } else {
 779         assert(bus != sysbus_get_default()); /* main_system_bus is never freed */
 780         qemu_unregister_reset(qbus_reset_all_fn, bus);
 781     }
 782     g_free((char *)bus->name);
 783 }
 784
 785 static const TypeInfo bus_info = {
 786     .name = TYPE_BUS,
 787     .parent = TYPE_OBJECT,
 788     .instance_size = sizeof(BusState),
 789     .abstract = true,
 790     .class_size = sizeof(BusClass),
 791     .instance_init = qbus_initfn,
 792     .instance_finalize = qbus_finalize,
 793 };
 794
 795 static void qdev_register_types(void)
 796 {
 797     type_register_static(&bus_info);
 798     type_register_static(&device_type_info);
 799 }
 800
 801 type_init(qdev_register_types)