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