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