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 "qapi/error.h"
  30 #include "qapi/qapi-events-qdev.h"
  31 #include "qapi/qmp/qerror.h"
  32 #include "qapi/visitor.h"
  33 #include "qemu/error-report.h"
  34 #include "qemu/option.h"
  35 #include "hw/hotplug.h"
  36 #include "hw/irq.h"
  37 #include "hw/qdev-properties.h"
  38 #include "hw/boards.h"
  39 #include "hw/sysbus.h"
  40 #include "hw/qdev-clock.h"
  41 #include "migration/vmstate.h"
  42 #include "trace.h"
  43
  44 bool qdev_hotplug = false;
  45 static bool qdev_hot_added = false;
  46 bool qdev_hot_removed = false;
  47
  48 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
  49 {
  50     DeviceClass *dc = DEVICE_GET_CLASS(dev);
  51     return dc->vmsd;
  52 }
  53
  54 static void bus_remove_child(BusState *bus, DeviceState *child)
  55 {
  56     BusChild *kid;
  57
  58     QTAILQ_FOREACH(kid, &bus->children, sibling) {
  59         if (kid->child == child) {
  60             char name[32];
  61
  62             snprintf(name, sizeof(name), "child[%d]", kid->index);
  63             QTAILQ_REMOVE(&bus->children, kid, sibling);
  64
  65             bus->num_children--;
  66
  67             /* This gives back ownership of kid->child back to us.  */
  68             object_property_del(OBJECT(bus), name);
  69             object_unref(OBJECT(kid->child));
  70             g_free(kid);
  71             return;
  72         }
  73     }
  74 }
  75
  76 static void bus_add_child(BusState *bus, DeviceState *child)
  77 {
  78     char name[32];
  79     BusChild *kid = g_malloc0(sizeof(*kid));
  80
  81     bus->num_children++;
  82     kid->index = bus->max_index++;
  83     kid->child = child;
  84     object_ref(OBJECT(kid->child));
  85
  86     QTAILQ_INSERT_HEAD(&bus->children, kid, sibling);
  87
  88     /* This transfers ownership of kid->child to the property.  */
  89     snprintf(name, sizeof(name), "child[%d]", kid->index);
  90     object_property_add_link(OBJECT(bus), name,
  91                              object_get_typename(OBJECT(child)),
  92                              (Object **)&kid->child,
  93                              NULL, /* read-only property */
  94                              0);
  95 }
  96
  97 void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
  98 {
  99     BusState *old_parent_bus = dev->parent_bus;
 100     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 101
 102     assert(dc->bus_type && object_dynamic_cast(OBJECT(bus), dc->bus_type));
 103
 104     if (old_parent_bus) {
 105         trace_qdev_update_parent_bus(dev, object_get_typename(OBJECT(dev)),
 106             old_parent_bus, object_get_typename(OBJECT(old_parent_bus)),
 107             OBJECT(bus), object_get_typename(OBJECT(bus)));
 108         /*
 109          * Keep a reference to the device while it's not plugged into
 110          * any bus, to avoid it potentially evaporating when it is
 111          * dereffed in bus_remove_child().
 112          * Also keep the ref of the parent bus until the end, so that
 113          * we can safely call resettable_change_parent() below.
 114          */
 115         object_ref(OBJECT(dev));
 116         bus_remove_child(dev->parent_bus, dev);
 117     }
 118     dev->parent_bus = bus;
 119     object_ref(OBJECT(bus));
 120     bus_add_child(bus, dev);
 121     if (dev->realized) {
 122         resettable_change_parent(OBJECT(dev), OBJECT(bus),
 123                                  OBJECT(old_parent_bus));
 124     }
 125     if (old_parent_bus) {
 126         object_unref(OBJECT(old_parent_bus));
 127         object_unref(OBJECT(dev));
 128     }
 129 }
 130
 131 /*
 132  * Create a device on the heap.
 133  * A type @name must exist.
 134  * This only initializes the device state structure and allows
 135  * properties to be set.  The device still needs to be realized.  See
 136  * qdev-core.h.
 137  */
 138 DeviceState *qdev_new(const char *name)
 139 {
 140     return DEVICE(object_new(name));
 141 }
 142
 143 /*
 144  * Try to create a device on the heap.
 145  * This is like qdev_new(), except it returns %NULL when type @name
 146  * does not exist.
 147  */
 148 DeviceState *qdev_try_new(const char *name)
 149 {
 150     if (!object_class_by_name(name)) {
 151         return NULL;
 152     }
 153
 154     return DEVICE(object_new(name));
 155 }
 156
 157 static QTAILQ_HEAD(, DeviceListener) device_listeners
 158     = QTAILQ_HEAD_INITIALIZER(device_listeners);
 159
 160 enum ListenerDirection { Forward, Reverse };
 161
 162 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...)     \
 163     do {                                                          \
 164         DeviceListener *_listener;                                \
 165                                                                   \
 166         switch (_direction) {                                     \
 167         case Forward:                                             \
 168             QTAILQ_FOREACH(_listener, &device_listeners, link) {  \
 169                 if (_listener->_callback) {                       \
 170                     _listener->_callback(_listener, ##_args);     \
 171                 }                                                 \
 172             }                                                     \
 173             break;                                                \
 174         case Reverse:                                             \
 175             QTAILQ_FOREACH_REVERSE(_listener, &device_listeners,  \
 176                                    link) {                        \
 177                 if (_listener->_callback) {                       \
 178                     _listener->_callback(_listener, ##_args);     \
 179                 }                                                 \
 180             }                                                     \
 181             break;                                                \
 182         default:                                                  \
 183             abort();                                              \
 184         }                                                         \
 185     } while (0)
 186
 187 static int device_listener_add(DeviceState *dev, void *opaque)
 188 {
 189     DEVICE_LISTENER_CALL(realize, Forward, dev);
 190
 191     return 0;
 192 }
 193
 194 void device_listener_register(DeviceListener *listener)
 195 {
 196     QTAILQ_INSERT_TAIL(&device_listeners, listener, link);
 197
 198     qbus_walk_children(sysbus_get_default(), NULL, NULL, device_listener_add,
 199                        NULL, NULL);
 200 }
 201
 202 void device_listener_unregister(DeviceListener *listener)
 203 {
 204     QTAILQ_REMOVE(&device_listeners, listener, link);
 205 }
 206
 207 bool qdev_should_hide_device(QemuOpts *opts)
 208 {
 209     int rc = -1;
 210     DeviceListener *listener;
 211
 212     QTAILQ_FOREACH(listener, &device_listeners, link) {
 213        if (listener->should_be_hidden) {
 214             /*
 215              * should_be_hidden_will return
 216              *  1 if device matches opts and it should be hidden
 217              *  0 if device matches opts and should not be hidden
 218              *  -1 if device doesn't match ops
 219              */
 220             rc = listener->should_be_hidden(listener, opts);
 221         }
 222
 223         if (rc > 0) {
 224             break;
 225         }
 226     }
 227
 228     return rc > 0;
 229 }
 230
 231 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
 232                                  int required_for_version)
 233 {
 234     assert(!dev->realized);
 235     dev->instance_id_alias = alias_id;
 236     dev->alias_required_for_version = required_for_version;
 237 }
 238
 239 HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev)
 240 {
 241     MachineState *machine;
 242     MachineClass *mc;
 243     Object *m_obj = qdev_get_machine();
 244
 245     if (object_dynamic_cast(m_obj, TYPE_MACHINE)) {
 246         machine = MACHINE(m_obj);
 247         mc = MACHINE_GET_CLASS(machine);
 248         if (mc->get_hotplug_handler) {
 249             return mc->get_hotplug_handler(machine, dev);
 250         }
 251     }
 252
 253     return NULL;
 254 }
 255
 256 bool qdev_hotplug_allowed(DeviceState *dev, Error **errp)
 257 {
 258     MachineState *machine;
 259     MachineClass *mc;
 260     Object *m_obj = qdev_get_machine();
 261
 262     if (object_dynamic_cast(m_obj, TYPE_MACHINE)) {
 263         machine = MACHINE(m_obj);
 264         mc = MACHINE_GET_CLASS(machine);
 265         if (mc->hotplug_allowed) {
 266             return mc->hotplug_allowed(machine, dev, errp);
 267         }
 268     }
 269
 270     return true;
 271 }
 272
 273 HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev)
 274 {
 275     if (dev->parent_bus) {
 276         return dev->parent_bus->hotplug_handler;
 277     }
 278     return NULL;
 279 }
 280
 281 HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev)
 282 {
 283     HotplugHandler *hotplug_ctrl = qdev_get_machine_hotplug_handler(dev);
 284
 285     if (hotplug_ctrl == NULL && dev->parent_bus) {
 286         hotplug_ctrl = qdev_get_bus_hotplug_handler(dev);
 287     }
 288     return hotplug_ctrl;
 289 }
 290
 291 static int qdev_prereset(DeviceState *dev, void *opaque)
 292 {
 293     trace_qdev_reset_tree(dev, object_get_typename(OBJECT(dev)));
 294     return 0;
 295 }
 296
 297 static int qbus_prereset(BusState *bus, void *opaque)
 298 {
 299     trace_qbus_reset_tree(bus, object_get_typename(OBJECT(bus)));
 300     return 0;
 301 }
 302
 303 static int qdev_reset_one(DeviceState *dev, void *opaque)
 304 {
 305     device_legacy_reset(dev);
 306
 307     return 0;
 308 }
 309
 310 static int qbus_reset_one(BusState *bus, void *opaque)
 311 {
 312     BusClass *bc = BUS_GET_CLASS(bus);
 313     trace_qbus_reset(bus, object_get_typename(OBJECT(bus)));
 314     if (bc->reset) {
 315         bc->reset(bus);
 316     }
 317     return 0;
 318 }
 319
 320 void qdev_reset_all(DeviceState *dev)
 321 {
 322     trace_qdev_reset_all(dev, object_get_typename(OBJECT(dev)));
 323     qdev_walk_children(dev, qdev_prereset, qbus_prereset,
 324                        qdev_reset_one, qbus_reset_one, NULL);
 325 }
 326
 327 void qdev_reset_all_fn(void *opaque)
 328 {
 329     qdev_reset_all(DEVICE(opaque));
 330 }
 331
 332 void qbus_reset_all(BusState *bus)
 333 {
 334     trace_qbus_reset_all(bus, object_get_typename(OBJECT(bus)));
 335     qbus_walk_children(bus, qdev_prereset, qbus_prereset,
 336                        qdev_reset_one, qbus_reset_one, NULL);
 337 }
 338
 339 void qbus_reset_all_fn(void *opaque)
 340 {
 341     BusState *bus = opaque;
 342     qbus_reset_all(bus);
 343 }
 344
 345 void device_cold_reset(DeviceState *dev)
 346 {
 347     resettable_reset(OBJECT(dev), RESET_TYPE_COLD);
 348 }
 349
 350 bool device_is_in_reset(DeviceState *dev)
 351 {
 352     return resettable_is_in_reset(OBJECT(dev));
 353 }
 354
 355 static ResettableState *device_get_reset_state(Object *obj)
 356 {
 357     DeviceState *dev = DEVICE(obj);
 358     return &dev->reset;
 359 }
 360
 361 static void device_reset_child_foreach(Object *obj, ResettableChildCallback cb,
 362                                        void *opaque, ResetType type)
 363 {
 364     DeviceState *dev = DEVICE(obj);
 365     BusState *bus;
 366
 367     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 368         cb(OBJECT(bus), opaque, type);
 369     }
 370 }
 371
 372 /* can be used as ->unplug() callback for the simple cases */
 373 void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev,
 374                                   DeviceState *dev, Error **errp)
 375 {
 376     qdev_unrealize(dev);
 377 }
 378
 379 /*
 380  * Realize @dev.
 381  * @dev must not be plugged into a bus.
 382  * If @bus, plug @dev into @bus.  This takes a reference to @dev.
 383  * If @dev has no QOM parent, make one up, taking another reference.
 384  * On success, return true.
 385  * On failure, store an error through @errp and return false.
 386  */
 387 bool qdev_realize(DeviceState *dev, BusState *bus, Error **errp)
 388 {
 389     Error *err = NULL;
 390
 391     assert(!dev->realized && !dev->parent_bus);
 392
 393     if (bus) {
 394         qdev_set_parent_bus(dev, bus);
 395     } else {
 396         assert(!DEVICE_GET_CLASS(dev)->bus_type);
 397     }
 398
 399     object_property_set_bool(OBJECT(dev), true, "realized", &err);
 400     if (err) {
 401         error_propagate(errp, err);
 402     }
 403     return !err;
 404 }
 405
 406 /*
 407  * Realize @dev and drop a reference.
 408  * This is like qdev_realize(), except the caller must hold a
 409  * (private) reference, which is dropped on return regardless of
 410  * success or failure.  Intended use:
 411  *     dev = qdev_new();
 412  *     [...]
 413  *     qdev_realize_and_unref(dev, bus, errp);
 414  * Now @dev can go away without further ado.
 415  */
 416 bool qdev_realize_and_unref(DeviceState *dev, BusState *bus, Error **errp)
 417 {
 418     bool ret;
 419
 420     ret = qdev_realize(dev, bus, errp);
 421     object_unref(OBJECT(dev));
 422     return ret;
 423 }
 424
 425 void qdev_unrealize(DeviceState *dev)
 426 {
 427     object_property_set_bool(OBJECT(dev), false, "realized", &error_abort);
 428 }
 429
 430 static int qdev_assert_realized_properly(Object *obj, void *opaque)
 431 {
 432     DeviceState *dev = DEVICE(object_dynamic_cast(obj, TYPE_DEVICE));
 433     DeviceClass *dc;
 434
 435     if (dev) {
 436         dc = DEVICE_GET_CLASS(dev);
 437         assert(dev->realized);
 438         assert(dev->parent_bus || !dc->bus_type);
 439     }
 440     return 0;
 441 }
 442
 443 void qdev_machine_creation_done(void)
 444 {
 445     /*
 446      * ok, initial machine setup is done, starting from now we can
 447      * only create hotpluggable devices
 448      */
 449     qdev_hotplug = true;
 450
 451     object_child_foreach_recursive(object_get_root(),
 452                                    qdev_assert_realized_properly, NULL);
 453 }
 454
 455 bool qdev_machine_modified(void)
 456 {
 457     return qdev_hot_added || qdev_hot_removed;
 458 }
 459
 460 BusState *qdev_get_parent_bus(DeviceState *dev)
 461 {
 462     return dev->parent_bus;
 463 }
 464
 465 static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev,
 466                                                const char *name)
 467 {
 468     NamedGPIOList *ngl;
 469
 470     QLIST_FOREACH(ngl, &dev->gpios, node) {
 471         /* NULL is a valid and matchable name. */
 472         if (g_strcmp0(name, ngl->name) == 0) {
 473             return ngl;
 474         }
 475     }
 476
 477     ngl = g_malloc0(sizeof(*ngl));
 478     ngl->name = g_strdup(name);
 479     QLIST_INSERT_HEAD(&dev->gpios, ngl, node);
 480     return ngl;
 481 }
 482
 483 void qdev_init_gpio_in_named_with_opaque(DeviceState *dev,
 484                                          qemu_irq_handler handler,
 485                                          void *opaque,
 486                                          const char *name, int n)
 487 {
 488     int i;
 489     NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
 490
 491     assert(gpio_list->num_out == 0 || !name);
 492     gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler,
 493                                      opaque, n);
 494
 495     if (!name) {
 496         name = "unnamed-gpio-in";
 497     }
 498     for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) {
 499         gchar *propname = g_strdup_printf("%s[%u]", name, i);
 500
 501         object_property_add_child(OBJECT(dev), propname,
 502                                   OBJECT(gpio_list->in[i]));
 503         g_free(propname);
 504     }
 505
 506     gpio_list->num_in += n;
 507 }
 508
 509 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
 510 {
 511     qdev_init_gpio_in_named(dev, handler, NULL, n);
 512 }
 513
 514 void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
 515                               const char *name, int n)
 516 {
 517     int i;
 518     NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
 519
 520     assert(gpio_list->num_in == 0 || !name);
 521
 522     if (!name) {
 523         name = "unnamed-gpio-out";
 524     }
 525     memset(pins, 0, sizeof(*pins) * n);
 526     for (i = 0; i < n; ++i) {
 527         gchar *propname = g_strdup_printf("%s[%u]", name,
 528                                           gpio_list->num_out + i);
 529
 530         object_property_add_link(OBJECT(dev), propname, TYPE_IRQ,
 531                                  (Object **)&pins[i],
 532                                  object_property_allow_set_link,
 533                                  OBJ_PROP_LINK_STRONG);
 534         g_free(propname);
 535     }
 536     gpio_list->num_out += n;
 537 }
 538
 539 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
 540 {
 541     qdev_init_gpio_out_named(dev, pins, NULL, n);
 542 }
 543
 544 qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n)
 545 {
 546     NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
 547
 548     assert(n >= 0 && n < gpio_list->num_in);
 549     return gpio_list->in[n];
 550 }
 551
 552 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
 553 {
 554     return qdev_get_gpio_in_named(dev, NULL, n);
 555 }
 556
 557 void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
 558                                  qemu_irq pin)
 559 {
 560     char *propname = g_strdup_printf("%s[%d]",
 561                                      name ? name : "unnamed-gpio-out", n);
 562     if (pin && !OBJECT(pin)->parent) {
 563         /* We need a name for object_property_set_link to work */
 564         object_property_add_child(container_get(qdev_get_machine(),
 565                                                 "/unattached"),
 566                                   "non-qdev-gpio[*]", OBJECT(pin));
 567     }
 568     object_property_set_link(OBJECT(dev), OBJECT(pin), propname, &error_abort);
 569     g_free(propname);
 570 }
 571
 572 qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n)
 573 {
 574     g_autofree char *propname = g_strdup_printf("%s[%d]",
 575                                      name ? name : "unnamed-gpio-out", n);
 576
 577     qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
 578                                                       NULL);
 579
 580     return ret;
 581 }
 582
 583 /* disconnect a GPIO output, returning the disconnected input (if any) */
 584
 585 static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev,
 586                                                const char *name, int n)
 587 {
 588     char *propname = g_strdup_printf("%s[%d]",
 589                                      name ? name : "unnamed-gpio-out", n);
 590
 591     qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
 592                                                       NULL);
 593     if (ret) {
 594         object_property_set_link(OBJECT(dev), NULL, propname, NULL);
 595     }
 596     g_free(propname);
 597     return ret;
 598 }
 599
 600 qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
 601                                  const char *name, int n)
 602 {
 603     qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n);
 604     qdev_connect_gpio_out_named(dev, name, n, icpt);
 605     return disconnected;
 606 }
 607
 608 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
 609 {
 610     qdev_connect_gpio_out_named(dev, NULL, n, pin);
 611 }
 612
 613 void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
 614                      const char *name)
 615 {
 616     int i;
 617     NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name);
 618
 619     for (i = 0; i < ngl->num_in; i++) {
 620         const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in";
 621         char *propname = g_strdup_printf("%s[%d]", nm, i);
 622
 623         object_property_add_alias(OBJECT(container), propname,
 624                                   OBJECT(dev), propname);
 625         g_free(propname);
 626     }
 627     for (i = 0; i < ngl->num_out; i++) {
 628         const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out";
 629         char *propname = g_strdup_printf("%s[%d]", nm, i);
 630
 631         object_property_add_alias(OBJECT(container), propname,
 632                                   OBJECT(dev), propname);
 633         g_free(propname);
 634     }
 635     QLIST_REMOVE(ngl, node);
 636     QLIST_INSERT_HEAD(&container->gpios, ngl, node);
 637 }
 638
 639 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 640 {
 641     BusState *bus;
 642     Object *child = object_resolve_path_component(OBJECT(dev), name);
 643
 644     bus = (BusState *)object_dynamic_cast(child, TYPE_BUS);
 645     if (bus) {
 646         return bus;
 647     }
 648
 649     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 650         if (strcmp(name, bus->name) == 0) {
 651             return bus;
 652         }
 653     }
 654     return NULL;
 655 }
 656
 657 int qdev_walk_children(DeviceState *dev,
 658                        qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
 659                        qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
 660                        void *opaque)
 661 {
 662     BusState *bus;
 663     int err;
 664
 665     if (pre_devfn) {
 666         err = pre_devfn(dev, opaque);
 667         if (err) {
 668             return err;
 669         }
 670     }
 671
 672     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 673         err = qbus_walk_children(bus, pre_devfn, pre_busfn,
 674                                  post_devfn, post_busfn, opaque);
 675         if (err < 0) {
 676             return err;
 677         }
 678     }
 679
 680     if (post_devfn) {
 681         err = post_devfn(dev, opaque);
 682         if (err) {
 683             return err;
 684         }
 685     }
 686
 687     return 0;
 688 }
 689
 690 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 691 {
 692     BusChild *kid;
 693     DeviceState *ret;
 694     BusState *child;
 695
 696     QTAILQ_FOREACH(kid, &bus->children, sibling) {
 697         DeviceState *dev = kid->child;
 698
 699         if (dev->id && strcmp(dev->id, id) == 0) {
 700             return dev;
 701         }
 702
 703         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 704             ret = qdev_find_recursive(child, id);
 705             if (ret) {
 706                 return ret;
 707             }
 708         }
 709     }
 710     return NULL;
 711 }
 712
 713 char *qdev_get_dev_path(DeviceState *dev)
 714 {
 715     BusClass *bc;
 716
 717     if (!dev || !dev->parent_bus) {
 718         return NULL;
 719     }
 720
 721     bc = BUS_GET_CLASS(dev->parent_bus);
 722     if (bc->get_dev_path) {
 723         return bc->get_dev_path(dev);
 724     }
 725
 726     return NULL;
 727 }
 728
 729 /**
 730  * Legacy property handling
 731  */
 732
 733 static void qdev_get_legacy_property(Object *obj, Visitor *v,
 734                                      const char *name, void *opaque,
 735                                      Error **errp)
 736 {
 737     DeviceState *dev = DEVICE(obj);
 738     Property *prop = opaque;
 739
 740     char buffer[1024];
 741     char *ptr = buffer;
 742
 743     prop->info->print(dev, prop, buffer, sizeof(buffer));
 744     visit_type_str(v, name, &ptr, errp);
 745 }
 746
 747 /**
 748  * qdev_class_add_legacy_property:
 749  * @dev: Device to add the property to.
 750  * @prop: The qdev property definition.
 751  *
 752  * Add a legacy QOM property to @dev for qdev property @prop.
 753  *
 754  * Legacy properties are string versions of QOM properties.  The format of
 755  * the string depends on the property type.  Legacy properties are only
 756  * needed for "info qtree".
 757  *
 758  * Do not use this in new code!  QOM Properties added through this interface
 759  * will be given names in the "legacy" namespace.
 760  */
 761 static void qdev_class_add_legacy_property(DeviceClass *dc, Property *prop)
 762 {
 763     g_autofree char *name = NULL;
 764
 765     /* Register pointer properties as legacy properties */
 766     if (!prop->info->print && prop->info->get) {
 767         return;
 768     }
 769
 770     name = g_strdup_printf("legacy-%s", prop->name);
 771     object_class_property_add(OBJECT_CLASS(dc), name, "str",
 772         prop->info->print ? qdev_get_legacy_property : prop->info->get,
 773         NULL, NULL, prop);
 774 }
 775
 776 void qdev_property_add_static(DeviceState *dev, Property *prop)
 777 {
 778     Object *obj = OBJECT(dev);
 779     ObjectProperty *op;
 780
 781     assert(!prop->info->create);
 782
 783     op = object_property_add(obj, prop->name, prop->info->name,
 784                              prop->info->get, prop->info->set,
 785                              prop->info->release,
 786                              prop);
 787
 788     object_property_set_description(obj, prop->name,
 789                                     prop->info->description);
 790
 791     if (prop->set_default) {
 792         prop->info->set_default_value(op, prop);
 793         if (op->init) {
 794             op->init(obj, op);
 795         }
 796     }
 797 }
 798
 799 static void qdev_class_add_property(DeviceClass *klass, Property *prop)
 800 {
 801     ObjectClass *oc = OBJECT_CLASS(klass);
 802
 803     if (prop->info->create) {
 804         prop->info->create(oc, prop);
 805     } else {
 806         ObjectProperty *op;
 807
 808         op = object_class_property_add(oc,
 809                                        prop->name, prop->info->name,
 810                                        prop->info->get, prop->info->set,
 811                                        prop->info->release,
 812                                        prop);
 813         if (prop->set_default) {
 814             prop->info->set_default_value(op, prop);
 815         }
 816     }
 817     object_class_property_set_description(oc, prop->name,
 818                                           prop->info->description);
 819 }
 820
 821 /* @qdev_alias_all_properties - Add alias properties to the source object for
 822  * all qdev properties on the target DeviceState.
 823  */
 824 void qdev_alias_all_properties(DeviceState *target, Object *source)
 825 {
 826     ObjectClass *class;
 827     Property *prop;
 828
 829     class = object_get_class(OBJECT(target));
 830     do {
 831         DeviceClass *dc = DEVICE_CLASS(class);
 832
 833         for (prop = dc->props_; prop && prop->name; prop++) {
 834             object_property_add_alias(source, prop->name,
 835                                       OBJECT(target), prop->name);
 836         }
 837         class = object_class_get_parent(class);
 838     } while (class != object_class_by_name(TYPE_DEVICE));
 839 }
 840
 841 static bool device_get_realized(Object *obj, Error **errp)
 842 {
 843     DeviceState *dev = DEVICE(obj);
 844     return dev->realized;
 845 }
 846
 847 static bool check_only_migratable(Object *obj, Error **errp)
 848 {
 849     DeviceClass *dc = DEVICE_GET_CLASS(obj);
 850
 851     if (!vmstate_check_only_migratable(dc->vmsd)) {
 852         error_setg(errp, "Device %s is not migratable, but "
 853                    "--only-migratable was specified",
 854                    object_get_typename(obj));
 855         return false;
 856     }
 857
 858     return true;
 859 }
 860
 861 static void device_set_realized(Object *obj, bool value, Error **errp)
 862 {
 863     DeviceState *dev = DEVICE(obj);
 864     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 865     HotplugHandler *hotplug_ctrl;
 866     BusState *bus;
 867     NamedClockList *ncl;
 868     Error *local_err = NULL;
 869     bool unattached_parent = false;
 870     static int unattached_count;
 871
 872     if (dev->hotplugged && !dc->hotpluggable) {
 873         error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
 874         return;
 875     }
 876
 877     if (value && !dev->realized) {
 878         if (!check_only_migratable(obj, &local_err)) {
 879             goto fail;
 880         }
 881
 882         if (!obj->parent) {
 883             gchar *name = g_strdup_printf("device[%d]", unattached_count++);
 884
 885             object_property_add_child(container_get(qdev_get_machine(),
 886                                                     "/unattached"),
 887                                       name, obj);
 888             unattached_parent = true;
 889             g_free(name);
 890         }
 891
 892         hotplug_ctrl = qdev_get_hotplug_handler(dev);
 893         if (hotplug_ctrl) {
 894             hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err);
 895             if (local_err != NULL) {
 896                 goto fail;
 897             }
 898         }
 899
 900         if (dc->realize) {
 901             dc->realize(dev, &local_err);
 902             if (local_err != NULL) {
 903                 goto fail;
 904             }
 905         }
 906
 907         DEVICE_LISTENER_CALL(realize, Forward, dev);
 908
 909         /*
 910          * always free/re-initialize here since the value cannot be cleaned up
 911          * in device_unrealize due to its usage later on in the unplug path
 912          */
 913         g_free(dev->canonical_path);
 914         dev->canonical_path = object_get_canonical_path(OBJECT(dev));
 915         QLIST_FOREACH(ncl, &dev->clocks, node) {
 916             if (ncl->alias) {
 917                 continue;
 918             } else {
 919                 clock_setup_canonical_path(ncl->clock);
 920             }
 921         }
 922
 923         if (qdev_get_vmsd(dev)) {
 924             if (vmstate_register_with_alias_id(VMSTATE_IF(dev),
 925                                                VMSTATE_INSTANCE_ID_ANY,
 926                                                qdev_get_vmsd(dev), dev,
 927                                                dev->instance_id_alias,
 928                                                dev->alias_required_for_version,
 929                                                &local_err) < 0) {
 930                 goto post_realize_fail;
 931             }
 932         }
 933
 934         /*
 935          * Clear the reset state, in case the object was previously unrealized
 936          * with a dirty state.
 937          */
 938         resettable_state_clear(&dev->reset);
 939
 940         QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 941             if (!qbus_realize(bus, errp)) {
 942                 goto child_realize_fail;
 943             }
 944         }
 945         if (dev->hotplugged) {
 946             /*
 947              * Reset the device, as well as its subtree which, at this point,
 948              * should be realized too.
 949              */
 950             resettable_assert_reset(OBJECT(dev), RESET_TYPE_COLD);
 951             resettable_change_parent(OBJECT(dev), OBJECT(dev->parent_bus),
 952                                      NULL);
 953             resettable_release_reset(OBJECT(dev), RESET_TYPE_COLD);
 954         }
 955         dev->pending_deleted_event = false;
 956
 957         if (hotplug_ctrl) {
 958             hotplug_handler_plug(hotplug_ctrl, dev, &local_err);
 959             if (local_err != NULL) {
 960                 goto child_realize_fail;
 961             }
 962        }
 963
 964     } else if (!value && dev->realized) {
 965         QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 966             qbus_unrealize(bus);
 967         }
 968         if (qdev_get_vmsd(dev)) {
 969             vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
 970         }
 971         if (dc->unrealize) {
 972             dc->unrealize(dev);
 973         }
 974         dev->pending_deleted_event = true;
 975         DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
 976     }
 977
 978     assert(local_err == NULL);
 979     dev->realized = value;
 980     return;
 981
 982 child_realize_fail:
 983     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 984         qbus_unrealize(bus);
 985     }
 986
 987     if (qdev_get_vmsd(dev)) {
 988         vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
 989     }
 990
 991 post_realize_fail:
 992     g_free(dev->canonical_path);
 993     dev->canonical_path = NULL;
 994     if (dc->unrealize) {
 995         dc->unrealize(dev);
 996     }
 997
 998 fail:
 999     error_propagate(errp, local_err);
1000     if (unattached_parent) {
1001         /*
1002          * Beware, this doesn't just revert
1003          * object_property_add_child(), it also runs bus_remove()!
1004          */
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 **errp)
1020 {
1021     DeviceState *dev = DEVICE(obj);
1022
1023     return dev->hotplugged;
1024 }
1025
1026 static void device_initfn(Object *obj)
1027 {
1028     DeviceState *dev = DEVICE(obj);
1029
1030     if (qdev_hotplug) {
1031         dev->hotplugged = 1;
1032         qdev_hot_added = true;
1033     }
1034
1035     dev->instance_id_alias = -1;
1036     dev->realized = false;
1037     dev->allow_unplug_during_migration = false;
1038
1039     QLIST_INIT(&dev->gpios);
1040     QLIST_INIT(&dev->clocks);
1041 }
1042
1043 static void device_post_init(Object *obj)
1044 {
1045     /*
1046      * Note: ordered so that the user's global properties take
1047      * precedence.
1048      */
1049     object_apply_compat_props(obj);
1050     qdev_prop_set_globals(DEVICE(obj));
1051 }
1052
1053 /* Unlink device from bus and free the structure.  */
1054 static void device_finalize(Object *obj)
1055 {
1056     NamedGPIOList *ngl, *next;
1057
1058     DeviceState *dev = DEVICE(obj);
1059
1060     QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
1061         QLIST_REMOVE(ngl, node);
1062         qemu_free_irqs(ngl->in, ngl->num_in);
1063         g_free(ngl->name);
1064         g_free(ngl);
1065         /* ngl->out irqs are owned by the other end and should not be freed
1066          * here
1067          */
1068     }
1069
1070     qdev_finalize_clocklist(dev);
1071
1072     /* Only send event if the device had been completely realized */
1073     if (dev->pending_deleted_event) {
1074         g_assert(dev->canonical_path);
1075
1076         qapi_event_send_device_deleted(!!dev->id, dev->id, dev->canonical_path);
1077         g_free(dev->canonical_path);
1078         dev->canonical_path = NULL;
1079     }
1080
1081     qemu_opts_del(dev->opts);
1082 }
1083
1084 static void device_class_base_init(ObjectClass *class, void *data)
1085 {
1086     DeviceClass *klass = DEVICE_CLASS(class);
1087
1088     /* We explicitly look up properties in the superclasses,
1089      * so do not propagate them to the subclasses.
1090      */
1091     klass->props_ = NULL;
1092 }
1093
1094 static void device_unparent(Object *obj)
1095 {
1096     DeviceState *dev = DEVICE(obj);
1097     BusState *bus;
1098
1099     if (dev->realized) {
1100         qdev_unrealize(dev);
1101     }
1102     while (dev->num_child_bus) {
1103         bus = QLIST_FIRST(&dev->child_bus);
1104         object_unparent(OBJECT(bus));
1105     }
1106     if (dev->parent_bus) {
1107         bus_remove_child(dev->parent_bus, dev);
1108         object_unref(OBJECT(dev->parent_bus));
1109         dev->parent_bus = NULL;
1110     }
1111 }
1112
1113 static char *
1114 device_vmstate_if_get_id(VMStateIf *obj)
1115 {
1116     DeviceState *dev = DEVICE(obj);
1117
1118     return qdev_get_dev_path(dev);
1119 }
1120
1121 /**
1122  * device_phases_reset:
1123  * Transition reset method for devices to allow moving
1124  * smoothly from legacy reset method to multi-phases
1125  */
1126 static void device_phases_reset(DeviceState *dev)
1127 {
1128     ResettableClass *rc = RESETTABLE_GET_CLASS(dev);
1129
1130     if (rc->phases.enter) {
1131         rc->phases.enter(OBJECT(dev), RESET_TYPE_COLD);
1132     }
1133     if (rc->phases.hold) {
1134         rc->phases.hold(OBJECT(dev));
1135     }
1136     if (rc->phases.exit) {
1137         rc->phases.exit(OBJECT(dev));
1138     }
1139 }
1140
1141 static void device_transitional_reset(Object *obj)
1142 {
1143     DeviceClass *dc = DEVICE_GET_CLASS(obj);
1144
1145     /*
1146      * This will call either @device_phases_reset (for multi-phases transitioned
1147      * devices) or a device's specific method for not-yet transitioned devices.
1148      * In both case, it does not reset children.
1149      */
1150     if (dc->reset) {
1151         dc->reset(DEVICE(obj));
1152     }
1153 }
1154
1155 /**
1156  * device_get_transitional_reset:
1157  * check if the device's class is ready for multi-phase
1158  */
1159 static ResettableTrFunction device_get_transitional_reset(Object *obj)
1160 {
1161     DeviceClass *dc = DEVICE_GET_CLASS(obj);
1162     if (dc->reset != device_phases_reset) {
1163         /*
1164          * dc->reset has been overridden by a subclass,
1165          * the device is not ready for multi phase yet.
1166          */
1167         return device_transitional_reset;
1168     }
1169     return NULL;
1170 }
1171
1172 static void device_class_init(ObjectClass *class, void *data)
1173 {
1174     DeviceClass *dc = DEVICE_CLASS(class);
1175     VMStateIfClass *vc = VMSTATE_IF_CLASS(class);
1176     ResettableClass *rc = RESETTABLE_CLASS(class);
1177
1178     class->unparent = device_unparent;
1179
1180     /* by default all devices were considered as hotpluggable,
1181      * so with intent to check it in generic qdev_unplug() /
1182      * device_set_realized() functions make every device
1183      * hotpluggable. Devices that shouldn't be hotpluggable,
1184      * should override it in their class_init()
1185      */
1186     dc->hotpluggable = true;
1187     dc->user_creatable = true;
1188     vc->get_id = device_vmstate_if_get_id;
1189     rc->get_state = device_get_reset_state;
1190     rc->child_foreach = device_reset_child_foreach;
1191
1192     /*
1193      * @device_phases_reset is put as the default reset method below, allowing
1194      * to do the multi-phase transition from base classes to leaf classes. It
1195      * allows a legacy-reset Device class to extend a multi-phases-reset
1196      * Device class for the following reason:
1197      * + If a base class B has been moved to multi-phase, then it does not
1198      *   override this default reset method and may have defined phase methods.
1199      * + A child class C (extending class B) which uses
1200      *   device_class_set_parent_reset() (or similar means) to override the
1201      *   reset method will still work as expected. @device_phases_reset function
1202      *   will be registered as the parent reset method and effectively call
1203      *   parent reset phases.
1204      */
1205     dc->reset = device_phases_reset;
1206     rc->get_transitional_function = device_get_transitional_reset;
1207
1208     object_class_property_add_bool(class, "realized",
1209                                    device_get_realized, device_set_realized);
1210     object_class_property_add_bool(class, "hotpluggable",
1211                                    device_get_hotpluggable, NULL);
1212     object_class_property_add_bool(class, "hotplugged",
1213                                    device_get_hotplugged, NULL);
1214     object_class_property_add_link(class, "parent_bus", TYPE_BUS,
1215                                    offsetof(DeviceState, parent_bus), NULL, 0);
1216 }
1217
1218 void device_class_set_props(DeviceClass *dc, Property *props)
1219 {
1220     Property *prop;
1221
1222     dc->props_ = props;
1223     for (prop = props; prop && prop->name; prop++) {
1224         qdev_class_add_legacy_property(dc, prop);
1225         qdev_class_add_property(dc, prop);
1226     }
1227 }
1228
1229 void device_class_set_parent_reset(DeviceClass *dc,
1230                                    DeviceReset dev_reset,
1231                                    DeviceReset *parent_reset)
1232 {
1233     *parent_reset = dc->reset;
1234     dc->reset = dev_reset;
1235 }
1236
1237 void device_class_set_parent_realize(DeviceClass *dc,
1238                                      DeviceRealize dev_realize,
1239                                      DeviceRealize *parent_realize)
1240 {
1241     *parent_realize = dc->realize;
1242     dc->realize = dev_realize;
1243 }
1244
1245 void device_class_set_parent_unrealize(DeviceClass *dc,
1246                                        DeviceUnrealize dev_unrealize,
1247                                        DeviceUnrealize *parent_unrealize)
1248 {
1249     *parent_unrealize = dc->unrealize;
1250     dc->unrealize = dev_unrealize;
1251 }
1252
1253 void device_legacy_reset(DeviceState *dev)
1254 {
1255     DeviceClass *klass = DEVICE_GET_CLASS(dev);
1256
1257     trace_qdev_reset(dev, object_get_typename(OBJECT(dev)));
1258     if (klass->reset) {
1259         klass->reset(dev);
1260     }
1261 }
1262
1263 Object *qdev_get_machine(void)
1264 {
1265     static Object *dev;
1266
1267     if (dev == NULL) {
1268         dev = container_get(object_get_root(), "/machine");
1269     }
1270
1271     return dev;
1272 }
1273
1274 static const TypeInfo device_type_info = {
1275     .name = TYPE_DEVICE,
1276     .parent = TYPE_OBJECT,
1277     .instance_size = sizeof(DeviceState),
1278     .instance_init = device_initfn,
1279     .instance_post_init = device_post_init,
1280     .instance_finalize = device_finalize,
1281     .class_base_init = device_class_base_init,
1282     .class_init = device_class_init,
1283     .abstract = true,
1284     .class_size = sizeof(DeviceClass),
1285     .interfaces = (InterfaceInfo[]) {
1286         { TYPE_VMSTATE_IF },
1287         { TYPE_RESETTABLE_INTERFACE },
1288         { }
1289     }
1290 };
1291
1292 static void qdev_register_types(void)
1293 {
1294     type_register_static(&device_type_info);
1295 }
1296
1297 type_init(qdev_register_types)