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