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