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