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