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 "hw/hotplug.h"
  36 #include "hw/boards.h"
  37 #include "qapi-event.h"
  38
  39 int qdev_hotplug = 0;
  40 static bool qdev_hot_added = false;
  41 static bool qdev_hot_removed = false;
  42
  43 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
  44 {
  45     DeviceClass *dc = DEVICE_GET_CLASS(dev);
  46     return dc->vmsd;
  47 }
  48
  49 const char *qdev_fw_name(DeviceState *dev)
  50 {
  51     DeviceClass *dc = DEVICE_GET_CLASS(dev);
  52
  53     if (dc->fw_name) {
  54         return dc->fw_name;
  55     }
  56
  57     return object_get_typename(OBJECT(dev));
  58 }
  59
  60 static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
  61                                      Error **errp);
  62
  63 static void bus_remove_child(BusState *bus, DeviceState *child)
  64 {
  65     BusChild *kid;
  66
  67     QTAILQ_FOREACH(kid, &bus->children, sibling) {
  68         if (kid->child == child) {
  69             char name[32];
  70
  71             snprintf(name, sizeof(name), "child[%d]", kid->index);
  72             QTAILQ_REMOVE(&bus->children, kid, sibling);
  73
  74             /* This gives back ownership of kid->child back to us.  */
  75             object_property_del(OBJECT(bus), name, NULL);
  76             object_unref(OBJECT(kid->child));
  77             g_free(kid);
  78             return;
  79         }
  80     }
  81 }
  82
  83 static void bus_add_child(BusState *bus, DeviceState *child)
  84 {
  85     char name[32];
  86     BusChild *kid = g_malloc0(sizeof(*kid));
  87
  88     kid->index = bus->max_index++;
  89     kid->child = child;
  90     object_ref(OBJECT(kid->child));
  91
  92     QTAILQ_INSERT_HEAD(&bus->children, kid, sibling);
  93
  94     /* This transfers ownership of kid->child to the property.  */
  95     snprintf(name, sizeof(name), "child[%d]", kid->index);
  96     object_property_add_link(OBJECT(bus), name,
  97                              object_get_typename(OBJECT(child)),
  98                              (Object **)&kid->child,
  99                              NULL, /* read-only property */
 100                              0, /* return ownership on prop deletion */
 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 static void qbus_set_hotplug_handler_internal(BusState *bus, Object *handler,
 112                                               Error **errp)
 113 {
 114
 115     object_property_set_link(OBJECT(bus), OBJECT(handler),
 116                              QDEV_HOTPLUG_HANDLER_PROPERTY, errp);
 117 }
 118
 119 void qbus_set_hotplug_handler(BusState *bus, DeviceState *handler, Error **errp)
 120 {
 121     qbus_set_hotplug_handler_internal(bus, OBJECT(handler), errp);
 122 }
 123
 124 void qbus_set_bus_hotplug_handler(BusState *bus, Error **errp)
 125 {
 126     qbus_set_hotplug_handler_internal(bus, OBJECT(bus), errp);
 127 }
 128
 129 /* Create a new device.  This only initializes the device state structure
 130    and allows properties to be set.  qdev_init should be called to
 131    initialize the actual device emulation.  */
 132 DeviceState *qdev_create(BusState *bus, const char *name)
 133 {
 134     DeviceState *dev;
 135
 136     dev = qdev_try_create(bus, name);
 137     if (!dev) {
 138         if (bus) {
 139             error_report("Unknown device '%s' for bus '%s'", name,
 140                          object_get_typename(OBJECT(bus)));
 141         } else {
 142             error_report("Unknown device '%s' for default sysbus", name);
 143         }
 144         abort();
 145     }
 146
 147     return dev;
 148 }
 149
 150 DeviceState *qdev_try_create(BusState *bus, const char *type)
 151 {
 152     DeviceState *dev;
 153
 154     if (object_class_by_name(type) == NULL) {
 155         return NULL;
 156     }
 157     dev = DEVICE(object_new(type));
 158     if (!dev) {
 159         return NULL;
 160     }
 161
 162     if (!bus) {
 163         bus = sysbus_get_default();
 164     }
 165
 166     qdev_set_parent_bus(dev, bus);
 167     object_unref(OBJECT(dev));
 168     return dev;
 169 }
 170
 171 /* Initialize a device.  Device properties should be set before calling
 172    this function.  IRQs and MMIO regions should be connected/mapped after
 173    calling this function.
 174    On failure, destroy the device and return negative value.
 175    Return 0 on success.  */
 176 int qdev_init(DeviceState *dev)
 177 {
 178     Error *local_err = NULL;
 179
 180     assert(!dev->realized);
 181
 182     object_property_set_bool(OBJECT(dev), true, "realized", &local_err);
 183     if (local_err != NULL) {
 184         qerror_report_err(local_err);
 185         error_free(local_err);
 186         object_unparent(OBJECT(dev));
 187         return -1;
 188     }
 189     return 0;
 190 }
 191
 192 static QTAILQ_HEAD(device_listeners, DeviceListener) device_listeners
 193     = QTAILQ_HEAD_INITIALIZER(device_listeners);
 194
 195 enum ListenerDirection { Forward, Reverse };
 196
 197 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...)     \
 198     do {                                                          \
 199         DeviceListener *_listener;                                \
 200                                                                   \
 201         switch (_direction) {                                     \
 202         case Forward:                                             \
 203             QTAILQ_FOREACH(_listener, &device_listeners, link) {  \
 204                 if (_listener->_callback) {                       \
 205                     _listener->_callback(_listener, ##_args);     \
 206                 }                                                 \
 207             }                                                     \
 208             break;                                                \
 209         case Reverse:                                             \
 210             QTAILQ_FOREACH_REVERSE(_listener, &device_listeners,  \
 211                                    device_listeners, link) {      \
 212                 if (_listener->_callback) {                       \
 213                     _listener->_callback(_listener, ##_args);     \
 214                 }                                                 \
 215             }                                                     \
 216             break;                                                \
 217         default:                                                  \
 218             abort();                                              \
 219         }                                                         \
 220     } while (0)
 221
 222 static int device_listener_add(DeviceState *dev, void *opaque)
 223 {
 224     DEVICE_LISTENER_CALL(realize, Forward, dev);
 225
 226     return 0;
 227 }
 228
 229 void device_listener_register(DeviceListener *listener)
 230 {
 231     QTAILQ_INSERT_TAIL(&device_listeners, listener, link);
 232
 233     qbus_walk_children(sysbus_get_default(), NULL, NULL, device_listener_add,
 234                        NULL, NULL);
 235 }
 236
 237 void device_listener_unregister(DeviceListener *listener)
 238 {
 239     QTAILQ_REMOVE(&device_listeners, listener, link);
 240 }
 241
 242 static void device_realize(DeviceState *dev, Error **errp)
 243 {
 244     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 245
 246     if (dc->init) {
 247         int rc = dc->init(dev);
 248         if (rc < 0) {
 249             error_setg(errp, "Device initialization failed.");
 250             return;
 251         }
 252     }
 253 }
 254
 255 static void device_unrealize(DeviceState *dev, Error **errp)
 256 {
 257     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 258
 259     if (dc->exit) {
 260         int rc = dc->exit(dev);
 261         if (rc < 0) {
 262             error_setg(errp, "Device exit failed.");
 263             return;
 264         }
 265     }
 266 }
 267
 268 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
 269                                  int required_for_version)
 270 {
 271     assert(!dev->realized);
 272     dev->instance_id_alias = alias_id;
 273     dev->alias_required_for_version = required_for_version;
 274 }
 275
 276 static HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev)
 277 {
 278     HotplugHandler *hotplug_ctrl = NULL;
 279
 280     if (dev->parent_bus && dev->parent_bus->hotplug_handler) {
 281         hotplug_ctrl = dev->parent_bus->hotplug_handler;
 282     } else if (object_dynamic_cast(qdev_get_machine(), TYPE_MACHINE)) {
 283         MachineState *machine = MACHINE(qdev_get_machine());
 284         MachineClass *mc = MACHINE_GET_CLASS(machine);
 285
 286         if (mc->get_hotplug_handler) {
 287             hotplug_ctrl = mc->get_hotplug_handler(machine, dev);
 288         }
 289     }
 290     return hotplug_ctrl;
 291 }
 292
 293 void qdev_unplug(DeviceState *dev, Error **errp)
 294 {
 295     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 296     HotplugHandler *hotplug_ctrl;
 297     HotplugHandlerClass *hdc;
 298
 299     if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) {
 300         error_set(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
 301         return;
 302     }
 303
 304     if (!dc->hotpluggable) {
 305         error_set(errp, QERR_DEVICE_NO_HOTPLUG,
 306                   object_get_typename(OBJECT(dev)));
 307         return;
 308     }
 309
 310     qdev_hot_removed = true;
 311
 312     hotplug_ctrl = qdev_get_hotplug_handler(dev);
 313     /* hotpluggable device MUST have HotplugHandler, if it doesn't
 314      * then something is very wrong with it */
 315     g_assert(hotplug_ctrl);
 316
 317     /* If device supports async unplug just request it to be done,
 318      * otherwise just remove it synchronously */
 319     hdc = HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl);
 320     if (hdc->unplug_request) {
 321         hotplug_handler_unplug_request(hotplug_ctrl, dev, errp);
 322     } else {
 323         hotplug_handler_unplug(hotplug_ctrl, dev, errp);
 324     }
 325 }
 326
 327 static int qdev_reset_one(DeviceState *dev, void *opaque)
 328 {
 329     device_reset(dev);
 330
 331     return 0;
 332 }
 333
 334 static int qbus_reset_one(BusState *bus, void *opaque)
 335 {
 336     BusClass *bc = BUS_GET_CLASS(bus);
 337     if (bc->reset) {
 338         bc->reset(bus);
 339     }
 340     return 0;
 341 }
 342
 343 void qdev_reset_all(DeviceState *dev)
 344 {
 345     qdev_walk_children(dev, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
 346 }
 347
 348 void qbus_reset_all(BusState *bus)
 349 {
 350     qbus_walk_children(bus, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL);
 351 }
 352
 353 void qbus_reset_all_fn(void *opaque)
 354 {
 355     BusState *bus = opaque;
 356     qbus_reset_all(bus);
 357 }
 358
 359 /* can be used as ->unplug() callback for the simple cases */
 360 void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
 361                                   DeviceState *dev, Error **errp)
 362 {
 363     /* just zap it */
 364     object_unparent(OBJECT(dev));
 365 }
 366
 367 /* Like qdev_init(), but terminate program via error_report() instead of
 368    returning an error value.  This is okay during machine creation.
 369    Don't use for hotplug, because there callers need to recover from
 370    failure.  Exception: if you know the device's init() callback can't
 371    fail, then qdev_init_nofail() can't fail either, and is therefore
 372    usable even then.  But relying on the device implementation that
 373    way is somewhat unclean, and best avoided.  */
 374 void qdev_init_nofail(DeviceState *dev)
 375 {
 376     Error *err = NULL;
 377
 378     assert(!dev->realized);
 379
 380     object_property_set_bool(OBJECT(dev), true, "realized", &err);
 381     if (err) {
 382         error_report("Initialization of device %s failed: %s",
 383                      object_get_typename(OBJECT(dev)),
 384                      error_get_pretty(err));
 385         exit(1);
 386     }
 387 }
 388
 389 void qdev_machine_creation_done(void)
 390 {
 391     /*
 392      * ok, initial machine setup is done, starting from now we can
 393      * only create hotpluggable devices
 394      */
 395     qdev_hotplug = 1;
 396 }
 397
 398 bool qdev_machine_modified(void)
 399 {
 400     return qdev_hot_added || qdev_hot_removed;
 401 }
 402
 403 BusState *qdev_get_parent_bus(DeviceState *dev)
 404 {
 405     return dev->parent_bus;
 406 }
 407
 408 static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev,
 409                                                const char *name)
 410 {
 411     NamedGPIOList *ngl;
 412
 413     QLIST_FOREACH(ngl, &dev->gpios, node) {
 414         /* NULL is a valid and matchable name, otherwise do a normal
 415          * strcmp match.
 416          */
 417         if ((!ngl->name && !name) ||
 418                 (name && ngl->name && strcmp(name, ngl->name) == 0)) {
 419             return ngl;
 420         }
 421     }
 422
 423     ngl = g_malloc0(sizeof(*ngl));
 424     ngl->name = g_strdup(name);
 425     QLIST_INSERT_HEAD(&dev->gpios, ngl, node);
 426     return ngl;
 427 }
 428
 429 void qdev_init_gpio_in_named(DeviceState *dev, qemu_irq_handler handler,
 430                              const char *name, int n)
 431 {
 432     int i;
 433     NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
 434     char *propname = g_strdup_printf("%s[*]", name ? name : "unnamed-gpio-in");
 435
 436     assert(gpio_list->num_out == 0 || !name);
 437     gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler,
 438                                      dev, n);
 439
 440     for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) {
 441         object_property_add_child(OBJECT(dev), propname,
 442                                   OBJECT(gpio_list->in[i]), &error_abort);
 443     }
 444     g_free(propname);
 445
 446     gpio_list->num_in += n;
 447 }
 448
 449 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
 450 {
 451     qdev_init_gpio_in_named(dev, handler, NULL, n);
 452 }
 453
 454 void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
 455                               const char *name, int n)
 456 {
 457     int i;
 458     NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
 459     char *propname = g_strdup_printf("%s[*]", name ? name : "unnamed-gpio-out");
 460
 461     assert(gpio_list->num_in == 0 || !name);
 462     gpio_list->num_out += n;
 463
 464     for (i = 0; i < n; ++i) {
 465         memset(&pins[i], 0, sizeof(*pins));
 466         object_property_add_link(OBJECT(dev), propname, TYPE_IRQ,
 467                                  (Object **)&pins[i],
 468                                  object_property_allow_set_link,
 469                                  OBJ_PROP_LINK_UNREF_ON_RELEASE,
 470                                  &error_abort);
 471     }
 472     g_free(propname);
 473 }
 474
 475 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
 476 {
 477     qdev_init_gpio_out_named(dev, pins, NULL, n);
 478 }
 479
 480 qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n)
 481 {
 482     NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
 483
 484     assert(n >= 0 && n < gpio_list->num_in);
 485     return gpio_list->in[n];
 486 }
 487
 488 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
 489 {
 490     return qdev_get_gpio_in_named(dev, NULL, n);
 491 }
 492
 493 void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
 494                                  qemu_irq pin)
 495 {
 496     char *propname = g_strdup_printf("%s[%d]",
 497                                      name ? name : "unnamed-gpio-out", n);
 498     if (pin) {
 499         /* We need a name for object_property_set_link to work.  If the
 500          * object has a parent, object_property_add_child will come back
 501          * with an error without doing anything.  If it has none, it will
 502          * never fail.  So we can just call it with a NULL Error pointer.
 503          */
 504         object_property_add_child(container_get(qdev_get_machine(),
 505                                                 "/unattached"),
 506                                   "non-qdev-gpio[*]", OBJECT(pin), NULL);
 507     }
 508     object_property_set_link(OBJECT(dev), OBJECT(pin), propname, &error_abort);
 509     g_free(propname);
 510 }
 511
 512 qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n)
 513 {
 514     char *propname = g_strdup_printf("%s[%d]",
 515                                      name ? name : "unnamed-gpio-out", n);
 516
 517     qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
 518                                                       NULL);
 519
 520     return ret;
 521 }
 522
 523 /* disconnect a GPIO ouput, returning the disconnected input (if any) */
 524
 525 static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev,
 526                                                const char *name, int n)
 527 {
 528     char *propname = g_strdup_printf("%s[%d]",
 529                                      name ? name : "unnamed-gpio-out", n);
 530
 531     qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
 532                                                       NULL);
 533     if (ret) {
 534         object_property_set_link(OBJECT(dev), NULL, propname, NULL);
 535     }
 536     g_free(propname);
 537     return ret;
 538 }
 539
 540 qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
 541                                  const char *name, int n)
 542 {
 543     qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n);
 544     qdev_connect_gpio_out_named(dev, name, n, icpt);
 545     return disconnected;
 546 }
 547
 548 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
 549 {
 550     qdev_connect_gpio_out_named(dev, NULL, n, pin);
 551 }
 552
 553 void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
 554                      const char *name)
 555 {
 556     int i;
 557     NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name);
 558
 559     for (i = 0; i < ngl->num_in; i++) {
 560         const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in";
 561         char *propname = g_strdup_printf("%s[%d]", nm, i);
 562
 563         object_property_add_alias(OBJECT(container), propname,
 564                                   OBJECT(dev), propname,
 565                                   &error_abort);
 566     }
 567     for (i = 0; i < ngl->num_out; i++) {
 568         const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out";
 569         char *propname = g_strdup_printf("%s[%d]", nm, i);
 570
 571         object_property_add_alias(OBJECT(container), propname,
 572                                   OBJECT(dev), propname,
 573                                   &error_abort);
 574     }
 575     QLIST_REMOVE(ngl, node);
 576     QLIST_INSERT_HEAD(&container->gpios, ngl, node);
 577 }
 578
 579 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 580 {
 581     BusState *bus;
 582
 583     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 584         if (strcmp(name, bus->name) == 0) {
 585             return bus;
 586         }
 587     }
 588     return NULL;
 589 }
 590
 591 int qbus_walk_children(BusState *bus,
 592                        qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
 593                        qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
 594                        void *opaque)
 595 {
 596     BusChild *kid;
 597     int err;
 598
 599     if (pre_busfn) {
 600         err = pre_busfn(bus, opaque);
 601         if (err) {
 602             return err;
 603         }
 604     }
 605
 606     QTAILQ_FOREACH(kid, &bus->children, sibling) {
 607         err = qdev_walk_children(kid->child,
 608                                  pre_devfn, pre_busfn,
 609                                  post_devfn, post_busfn, opaque);
 610         if (err < 0) {
 611             return err;
 612         }
 613     }
 614
 615     if (post_busfn) {
 616         err = post_busfn(bus, opaque);
 617         if (err) {
 618             return err;
 619         }
 620     }
 621
 622     return 0;
 623 }
 624
 625 int qdev_walk_children(DeviceState *dev,
 626                        qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
 627                        qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
 628                        void *opaque)
 629 {
 630     BusState *bus;
 631     int err;
 632
 633     if (pre_devfn) {
 634         err = pre_devfn(dev, opaque);
 635         if (err) {
 636             return err;
 637         }
 638     }
 639
 640     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 641         err = qbus_walk_children(bus, pre_devfn, pre_busfn,
 642                                  post_devfn, post_busfn, opaque);
 643         if (err < 0) {
 644             return err;
 645         }
 646     }
 647
 648     if (post_devfn) {
 649         err = post_devfn(dev, opaque);
 650         if (err) {
 651             return err;
 652         }
 653     }
 654
 655     return 0;
 656 }
 657
 658 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 659 {
 660     BusChild *kid;
 661     DeviceState *ret;
 662     BusState *child;
 663
 664     QTAILQ_FOREACH(kid, &bus->children, sibling) {
 665         DeviceState *dev = kid->child;
 666
 667         if (dev->id && strcmp(dev->id, id) == 0) {
 668             return dev;
 669         }
 670
 671         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 672             ret = qdev_find_recursive(child, id);
 673             if (ret) {
 674                 return ret;
 675             }
 676         }
 677     }
 678     return NULL;
 679 }
 680
 681 static void qbus_realize(BusState *bus, DeviceState *parent, const char *name)
 682 {
 683     const char *typename = object_get_typename(OBJECT(bus));
 684     BusClass *bc;
 685     char *buf;
 686     int i, len, bus_id;
 687
 688     bus->parent = parent;
 689
 690     if (name) {
 691         bus->name = g_strdup(name);
 692     } else if (bus->parent && bus->parent->id) {
 693         /* parent device has id -> use it plus parent-bus-id for bus name */
 694         bus_id = bus->parent->num_child_bus;
 695
 696         len = strlen(bus->parent->id) + 16;
 697         buf = g_malloc(len);
 698         snprintf(buf, len, "%s.%d", bus->parent->id, bus_id);
 699         bus->name = buf;
 700     } else {
 701         /* no id -> use lowercase bus type plus global bus-id for bus name */
 702         bc = BUS_GET_CLASS(bus);
 703         bus_id = bc->automatic_ids++;
 704
 705         len = strlen(typename) + 16;
 706         buf = g_malloc(len);
 707         len = snprintf(buf, len, "%s.%d", typename, bus_id);
 708         for (i = 0; i < len; i++) {
 709             buf[i] = qemu_tolower(buf[i]);
 710         }
 711         bus->name = buf;
 712     }
 713
 714     if (bus->parent) {
 715         QLIST_INSERT_HEAD(&bus->parent->child_bus, bus, sibling);
 716         bus->parent->num_child_bus++;
 717         object_property_add_child(OBJECT(bus->parent), bus->name, OBJECT(bus), NULL);
 718         object_unref(OBJECT(bus));
 719     } else if (bus != sysbus_get_default()) {
 720         /* TODO: once all bus devices are qdevified,
 721            only reset handler for main_system_bus should be registered here. */
 722         qemu_register_reset(qbus_reset_all_fn, bus);
 723     }
 724 }
 725
 726 static void bus_unparent(Object *obj)
 727 {
 728     BusState *bus = BUS(obj);
 729     BusChild *kid;
 730
 731     while ((kid = QTAILQ_FIRST(&bus->children)) != NULL) {
 732         DeviceState *dev = kid->child;
 733         object_unparent(OBJECT(dev));
 734     }
 735     if (bus->parent) {
 736         QLIST_REMOVE(bus, sibling);
 737         bus->parent->num_child_bus--;
 738         bus->parent = NULL;
 739     } else {
 740         assert(bus != sysbus_get_default()); /* main_system_bus is never freed */
 741         qemu_unregister_reset(qbus_reset_all_fn, bus);
 742     }
 743 }
 744
 745 static bool bus_get_realized(Object *obj, Error **errp)
 746 {
 747     BusState *bus = BUS(obj);
 748
 749     return bus->realized;
 750 }
 751
 752 static void bus_set_realized(Object *obj, bool value, Error **errp)
 753 {
 754     BusState *bus = BUS(obj);
 755     BusClass *bc = BUS_GET_CLASS(bus);
 756     BusChild *kid;
 757     Error *local_err = NULL;
 758
 759     if (value && !bus->realized) {
 760         if (bc->realize) {
 761             bc->realize(bus, &local_err);
 762         }
 763
 764         /* TODO: recursive realization */
 765     } else if (!value && bus->realized) {
 766         QTAILQ_FOREACH(kid, &bus->children, sibling) {
 767             DeviceState *dev = kid->child;
 768             object_property_set_bool(OBJECT(dev), false, "realized",
 769                                      &local_err);
 770             if (local_err != NULL) {
 771                 break;
 772             }
 773         }
 774         if (bc->unrealize && local_err == NULL) {
 775             bc->unrealize(bus, &local_err);
 776         }
 777     }
 778
 779     if (local_err != NULL) {
 780         error_propagate(errp, local_err);
 781         return;
 782     }
 783
 784     bus->realized = value;
 785 }
 786
 787 void qbus_create_inplace(void *bus, size_t size, const char *typename,
 788                          DeviceState *parent, const char *name)
 789 {
 790     object_initialize(bus, size, typename);
 791     qbus_realize(bus, parent, name);
 792 }
 793
 794 BusState *qbus_create(const char *typename, DeviceState *parent, const char *name)
 795 {
 796     BusState *bus;
 797
 798     bus = BUS(object_new(typename));
 799     qbus_realize(bus, parent, name);
 800
 801     return bus;
 802 }
 803
 804 static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev)
 805 {
 806     BusClass *bc = BUS_GET_CLASS(bus);
 807
 808     if (bc->get_fw_dev_path) {
 809         return bc->get_fw_dev_path(dev);
 810     }
 811
 812     return NULL;
 813 }
 814
 815 static char *qdev_get_fw_dev_path_from_handler(BusState *bus, DeviceState *dev)
 816 {
 817     Object *obj = OBJECT(dev);
 818     char *d = NULL;
 819
 820     while (!d && obj->parent) {
 821         obj = obj->parent;
 822         d = fw_path_provider_try_get_dev_path(obj, bus, dev);
 823     }
 824     return d;
 825 }
 826
 827 char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev)
 828 {
 829     Object *obj = OBJECT(dev);
 830
 831     return fw_path_provider_try_get_dev_path(obj, bus, dev);
 832 }
 833
 834 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
 835 {
 836     int l = 0;
 837
 838     if (dev && dev->parent_bus) {
 839         char *d;
 840         l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
 841         d = qdev_get_fw_dev_path_from_handler(dev->parent_bus, dev);
 842         if (!d) {
 843             d = bus_get_fw_dev_path(dev->parent_bus, dev);
 844         }
 845         if (d) {
 846             l += snprintf(p + l, size - l, "%s", d);
 847             g_free(d);
 848         } else {
 849             return l;
 850         }
 851     }
 852     l += snprintf(p + l , size - l, "/");
 853
 854     return l;
 855 }
 856
 857 char* qdev_get_fw_dev_path(DeviceState *dev)
 858 {
 859     char path[128];
 860     int l;
 861
 862     l = qdev_get_fw_dev_path_helper(dev, path, 128);
 863
 864     path[l-1] = '\0';
 865
 866     return g_strdup(path);
 867 }
 868
 869 char *qdev_get_dev_path(DeviceState *dev)
 870 {
 871     BusClass *bc;
 872
 873     if (!dev || !dev->parent_bus) {
 874         return NULL;
 875     }
 876
 877     bc = BUS_GET_CLASS(dev->parent_bus);
 878     if (bc->get_dev_path) {
 879         return bc->get_dev_path(dev);
 880     }
 881
 882     return NULL;
 883 }
 884
 885 /**
 886  * Legacy property handling
 887  */
 888
 889 static void qdev_get_legacy_property(Object *obj, Visitor *v, void *opaque,
 890                                      const char *name, Error **errp)
 891 {
 892     DeviceState *dev = DEVICE(obj);
 893     Property *prop = opaque;
 894
 895     char buffer[1024];
 896     char *ptr = buffer;
 897
 898     prop->info->print(dev, prop, buffer, sizeof(buffer));
 899     visit_type_str(v, &ptr, name, errp);
 900 }
 901
 902 /**
 903  * @qdev_add_legacy_property - adds a legacy property
 904  *
 905  * Do not use this is new code!  Properties added through this interface will
 906  * be given names and types in the "legacy" namespace.
 907  *
 908  * Legacy properties are string versions of other OOM properties.  The format
 909  * of the string depends on the property type.
 910  */
 911 static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
 912                                      Error **errp)
 913 {
 914     gchar *name;
 915
 916     /* Register pointer properties as legacy properties */
 917     if (!prop->info->print && prop->info->get) {
 918         return;
 919     }
 920
 921     name = g_strdup_printf("legacy-%s", prop->name);
 922     object_property_add(OBJECT(dev), name, "str",
 923                         prop->info->print ? qdev_get_legacy_property : prop->info->get,
 924                         NULL,
 925                         NULL,
 926                         prop, errp);
 927
 928     g_free(name);
 929 }
 930
 931 /**
 932  * @qdev_property_add_static - add a @Property to a device.
 933  *
 934  * Static properties access data in a struct.  The actual type of the
 935  * property and the field depends on the property type.
 936  */
 937 void qdev_property_add_static(DeviceState *dev, Property *prop,
 938                               Error **errp)
 939 {
 940     Error *local_err = NULL;
 941     Object *obj = OBJECT(dev);
 942
 943     /*
 944      * TODO qdev_prop_ptr does not have getters or setters.  It must
 945      * go now that it can be replaced with links.  The test should be
 946      * removed along with it: all static properties are read/write.
 947      */
 948     if (!prop->info->get && !prop->info->set) {
 949         return;
 950     }
 951
 952     object_property_add(obj, prop->name, prop->info->name,
 953                         prop->info->get, prop->info->set,
 954                         prop->info->release,
 955                         prop, &local_err);
 956
 957     if (local_err) {
 958         error_propagate(errp, local_err);
 959         return;
 960     }
 961
 962     object_property_set_description(obj, prop->name,
 963                                     prop->info->description,
 964                                     &error_abort);
 965
 966     if (prop->qtype == QTYPE_NONE) {
 967         return;
 968     }
 969
 970     if (prop->qtype == QTYPE_QBOOL) {
 971         object_property_set_bool(obj, prop->defval, prop->name, &error_abort);
 972     } else if (prop->info->enum_table) {
 973         object_property_set_str(obj, prop->info->enum_table[prop->defval],
 974                                 prop->name, &error_abort);
 975     } else if (prop->qtype == QTYPE_QINT) {
 976         object_property_set_int(obj, prop->defval, prop->name, &error_abort);
 977     }
 978 }
 979
 980 /* @qdev_alias_all_properties - Add alias properties to the source object for
 981  * all qdev properties on the target DeviceState.
 982  */
 983 void qdev_alias_all_properties(DeviceState *target, Object *source)
 984 {
 985     ObjectClass *class;
 986     Property *prop;
 987
 988     class = object_get_class(OBJECT(target));
 989     do {
 990         DeviceClass *dc = DEVICE_CLASS(class);
 991
 992         for (prop = dc->props; prop && prop->name; prop++) {
 993             object_property_add_alias(source, prop->name,
 994                                       OBJECT(target), prop->name,
 995                                       &error_abort);
 996         }
 997         class = object_class_get_parent(class);
 998     } while (class != object_class_by_name(TYPE_DEVICE));
 999 }
1000
1001 static int qdev_add_hotpluggable_device(Object *obj, void *opaque)
1002 {
1003     GSList **list = opaque;
1004     DeviceState *dev = (DeviceState *)object_dynamic_cast(OBJECT(obj),
1005                                                           TYPE_DEVICE);
1006
1007     if (dev == NULL) {
1008         return 0;
1009     }
1010
1011     if (dev->realized && object_property_get_bool(obj, "hotpluggable", NULL)) {
1012         *list = g_slist_append(*list, dev);
1013     }
1014
1015     return 0;
1016 }
1017
1018 GSList *qdev_build_hotpluggable_device_list(Object *peripheral)
1019 {
1020     GSList *list = NULL;
1021
1022     object_child_foreach(peripheral, qdev_add_hotpluggable_device, &list);
1023
1024     return list;
1025 }
1026
1027 static bool device_get_realized(Object *obj, Error **errp)
1028 {
1029     DeviceState *dev = DEVICE(obj);
1030     return dev->realized;
1031 }
1032
1033 static void device_set_realized(Object *obj, bool value, Error **errp)
1034 {
1035     DeviceState *dev = DEVICE(obj);
1036     DeviceClass *dc = DEVICE_GET_CLASS(dev);
1037     HotplugHandler *hotplug_ctrl;
1038     BusState *bus;
1039     Error *local_err = NULL;
1040
1041     if (dev->hotplugged && !dc->hotpluggable) {
1042         error_set(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
1043         return;
1044     }
1045
1046     if (value && !dev->realized) {
1047         if (!obj->parent) {
1048             static int unattached_count;
1049             gchar *name = g_strdup_printf("device[%d]", unattached_count++);
1050
1051             object_property_add_child(container_get(qdev_get_machine(),
1052                                                     "/unattached"),
1053                                       name, obj, &error_abort);
1054             g_free(name);
1055         }
1056
1057         if (dc->realize) {
1058             dc->realize(dev, &local_err);
1059         }
1060
1061         if (local_err != NULL) {
1062             goto fail;
1063         }
1064
1065         DEVICE_LISTENER_CALL(realize, Forward, dev);
1066
1067         hotplug_ctrl = qdev_get_hotplug_handler(dev);
1068         if (hotplug_ctrl) {
1069             hotplug_handler_plug(hotplug_ctrl, dev, &local_err);
1070         }
1071
1072         if (local_err != NULL) {
1073             goto post_realize_fail;
1074         }
1075
1076         if (qdev_get_vmsd(dev)) {
1077             vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev,
1078                                            dev->instance_id_alias,
1079                                            dev->alias_required_for_version);
1080         }
1081
1082         QLIST_FOREACH(bus, &dev->child_bus, sibling) {
1083             object_property_set_bool(OBJECT(bus), true, "realized",
1084                                          &local_err);
1085             if (local_err != NULL) {
1086                 goto child_realize_fail;
1087             }
1088         }
1089         if (dev->hotplugged) {
1090             device_reset(dev);
1091         }
1092         dev->pending_deleted_event = false;
1093     } else if (!value && dev->realized) {
1094         Error **local_errp = NULL;
1095         QLIST_FOREACH(bus, &dev->child_bus, sibling) {
1096             local_errp = local_err ? NULL : &local_err;
1097             object_property_set_bool(OBJECT(bus), false, "realized",
1098                                      local_errp);
1099         }
1100         if (qdev_get_vmsd(dev)) {
1101             vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
1102         }
1103         if (dc->unrealize) {
1104             local_errp = local_err ? NULL : &local_err;
1105             dc->unrealize(dev, local_errp);
1106         }
1107         dev->pending_deleted_event = true;
1108         DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
1109     }
1110
1111     if (local_err != NULL) {
1112         goto fail;
1113     }
1114
1115     dev->realized = value;
1116     return;
1117
1118 child_realize_fail:
1119     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
1120         object_property_set_bool(OBJECT(bus), false, "realized",
1121                                  NULL);
1122     }
1123
1124     if (qdev_get_vmsd(dev)) {
1125         vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
1126     }
1127
1128 post_realize_fail:
1129     if (dc->unrealize) {
1130         dc->unrealize(dev, NULL);
1131     }
1132
1133 fail:
1134     error_propagate(errp, local_err);
1135     return;
1136 }
1137
1138 static bool device_get_hotpluggable(Object *obj, Error **errp)
1139 {
1140     DeviceClass *dc = DEVICE_GET_CLASS(obj);
1141     DeviceState *dev = DEVICE(obj);
1142
1143     return dc->hotpluggable && (dev->parent_bus == NULL ||
1144                                 qbus_is_hotpluggable(dev->parent_bus));
1145 }
1146
1147 static bool device_get_hotplugged(Object *obj, Error **err)
1148 {
1149     DeviceState *dev = DEVICE(obj);
1150
1151     return dev->hotplugged;
1152 }
1153
1154 static void device_set_hotplugged(Object *obj, bool value, Error **err)
1155 {
1156     DeviceState *dev = DEVICE(obj);
1157
1158     dev->hotplugged = value;
1159 }
1160
1161 static void device_initfn(Object *obj)
1162 {
1163     DeviceState *dev = DEVICE(obj);
1164     ObjectClass *class;
1165     Property *prop;
1166
1167     if (qdev_hotplug) {
1168         dev->hotplugged = 1;
1169         qdev_hot_added = true;
1170     }
1171
1172     dev->instance_id_alias = -1;
1173     dev->realized = false;
1174
1175     object_property_add_bool(obj, "realized",
1176                              device_get_realized, device_set_realized, NULL);
1177     object_property_add_bool(obj, "hotpluggable",
1178                              device_get_hotpluggable, NULL, NULL);
1179     object_property_add_bool(obj, "hotplugged",
1180                              device_get_hotplugged, device_set_hotplugged,
1181                              &error_abort);
1182
1183     class = object_get_class(OBJECT(dev));
1184     do {
1185         for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) {
1186             qdev_property_add_legacy(dev, prop, &error_abort);
1187             qdev_property_add_static(dev, prop, &error_abort);
1188         }
1189         class = object_class_get_parent(class);
1190     } while (class != object_class_by_name(TYPE_DEVICE));
1191
1192     object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS,
1193                              (Object **)&dev->parent_bus, NULL, 0,
1194                              &error_abort);
1195     QLIST_INIT(&dev->gpios);
1196 }
1197
1198 static void device_post_init(Object *obj)
1199 {
1200     qdev_prop_set_globals(DEVICE(obj));
1201 }
1202
1203 /* Unlink device from bus and free the structure.  */
1204 static void device_finalize(Object *obj)
1205 {
1206     NamedGPIOList *ngl, *next;
1207
1208     DeviceState *dev = DEVICE(obj);
1209     qemu_opts_del(dev->opts);
1210
1211     QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
1212         QLIST_REMOVE(ngl, node);
1213         qemu_free_irqs(ngl->in, ngl->num_in);
1214         g_free(ngl->name);
1215         g_free(ngl);
1216         /* ngl->out irqs are owned by the other end and should not be freed
1217          * here
1218          */
1219     }
1220 }
1221
1222 static void device_class_base_init(ObjectClass *class, void *data)
1223 {
1224     DeviceClass *klass = DEVICE_CLASS(class);
1225
1226     /* We explicitly look up properties in the superclasses,
1227      * so do not propagate them to the subclasses.
1228      */
1229     klass->props = NULL;
1230 }
1231
1232 static void device_unparent(Object *obj)
1233 {
1234     DeviceState *dev = DEVICE(obj);
1235     BusState *bus;
1236
1237     if (dev->realized) {
1238         object_property_set_bool(obj, false, "realized", NULL);
1239     }
1240     while (dev->num_child_bus) {
1241         bus = QLIST_FIRST(&dev->child_bus);
1242         object_unparent(OBJECT(bus));
1243     }
1244     if (dev->parent_bus) {
1245         bus_remove_child(dev->parent_bus, dev);
1246         object_unref(OBJECT(dev->parent_bus));
1247         dev->parent_bus = NULL;
1248     }
1249
1250     /* Only send event if the device had been completely realized */
1251     if (dev->pending_deleted_event) {
1252         gchar *path = object_get_canonical_path(OBJECT(dev));
1253
1254         qapi_event_send_device_deleted(!!dev->id, dev->id, path, &error_abort);
1255         g_free(path);
1256     }
1257 }
1258
1259 static void device_class_init(ObjectClass *class, void *data)
1260 {
1261     DeviceClass *dc = DEVICE_CLASS(class);
1262
1263     class->unparent = device_unparent;
1264     dc->realize = device_realize;
1265     dc->unrealize = device_unrealize;
1266
1267     /* by default all devices were considered as hotpluggable,
1268      * so with intent to check it in generic qdev_unplug() /
1269      * device_set_realized() functions make every device
1270      * hotpluggable. Devices that shouldn't be hotpluggable,
1271      * should override it in their class_init()
1272      */
1273     dc->hotpluggable = true;
1274 }
1275
1276 void device_reset(DeviceState *dev)
1277 {
1278     DeviceClass *klass = DEVICE_GET_CLASS(dev);
1279
1280     if (klass->reset) {
1281         klass->reset(dev);
1282     }
1283 }
1284
1285 Object *qdev_get_machine(void)
1286 {
1287     static Object *dev;
1288
1289     if (dev == NULL) {
1290         dev = container_get(object_get_root(), "/machine");
1291     }
1292
1293     return dev;
1294 }
1295
1296 static const TypeInfo device_type_info = {
1297     .name = TYPE_DEVICE,
1298     .parent = TYPE_OBJECT,
1299     .instance_size = sizeof(DeviceState),
1300     .instance_init = device_initfn,
1301     .instance_post_init = device_post_init,
1302     .instance_finalize = device_finalize,
1303     .class_base_init = device_class_base_init,
1304     .class_init = device_class_init,
1305     .abstract = true,
1306     .class_size = sizeof(DeviceClass),
1307 };
1308
1309 static void qbus_initfn(Object *obj)
1310 {
1311     BusState *bus = BUS(obj);
1312
1313     QTAILQ_INIT(&bus->children);
1314     object_property_add_link(obj, QDEV_HOTPLUG_HANDLER_PROPERTY,
1315                              TYPE_HOTPLUG_HANDLER,
1316                              (Object **)&bus->hotplug_handler,
1317                              object_property_allow_set_link,
1318                              OBJ_PROP_LINK_UNREF_ON_RELEASE,
1319                              NULL);
1320     object_property_add_bool(obj, "realized",
1321                              bus_get_realized, bus_set_realized, NULL);
1322 }
1323
1324 static char *default_bus_get_fw_dev_path(DeviceState *dev)
1325 {
1326     return g_strdup(object_get_typename(OBJECT(dev)));
1327 }
1328
1329 static void bus_class_init(ObjectClass *class, void *data)
1330 {
1331     BusClass *bc = BUS_CLASS(class);
1332
1333     class->unparent = bus_unparent;
1334     bc->get_fw_dev_path = default_bus_get_fw_dev_path;
1335 }
1336
1337 static void qbus_finalize(Object *obj)
1338 {
1339     BusState *bus = BUS(obj);
1340
1341     g_free((char *)bus->name);
1342 }
1343
1344 static const TypeInfo bus_info = {
1345     .name = TYPE_BUS,
1346     .parent = TYPE_OBJECT,
1347     .instance_size = sizeof(BusState),
1348     .abstract = true,
1349     .class_size = sizeof(BusClass),
1350     .instance_init = qbus_initfn,
1351     .instance_finalize = qbus_finalize,
1352     .class_init = bus_class_init,
1353 };
1354
1355 static void qdev_register_types(void)
1356 {
1357     type_register_static(&bus_info);
1358     type_register_static(&device_type_info);
1359 }
1360
1361 type_init(qdev_register_types)