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