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