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