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.1 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/qdict.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/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 static bool qdev_hot_added = false;
  45 bool qdev_hot_removed = false;
  46
  47 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
  48 {
  49     DeviceClass *dc = DEVICE_GET_CLASS(dev);
  50     return dc->vmsd;
  51 }
  52
  53 static void bus_free_bus_child(BusChild *kid)
  54 {
  55     object_unref(OBJECT(kid->child));
  56     g_free(kid);
  57 }
  58
  59 static void bus_remove_child(BusState *bus, DeviceState *child)
  60 {
  61     BusChild *kid;
  62
  63     QTAILQ_FOREACH(kid, &bus->children, sibling) {
  64         if (kid->child == child) {
  65             char name[32];
  66
  67             snprintf(name, sizeof(name), "child[%d]", kid->index);
  68             QTAILQ_REMOVE_RCU(&bus->children, kid, sibling);
  69
  70             bus->num_children--;
  71
  72             /* This gives back ownership of kid->child back to us.  */
  73             object_property_del(OBJECT(bus), name);
  74
  75             /* free the bus kid, when it is safe to do so*/
  76             call_rcu(kid, bus_free_bus_child, rcu);
  77             break;
  78         }
  79     }
  80 }
  81
  82 static void bus_add_child(BusState *bus, DeviceState *child)
  83 {
  84     char name[32];
  85     BusChild *kid = g_malloc0(sizeof(*kid));
  86
  87     bus->num_children++;
  88     kid->index = bus->max_index++;
  89     kid->child = child;
  90     object_ref(OBJECT(kid->child));
  91
  92     QTAILQ_INSERT_HEAD_RCU(&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);
 101 }
 102
 103 static bool bus_check_address(BusState *bus, DeviceState *child, Error **errp)
 104 {
 105     BusClass *bc = BUS_GET_CLASS(bus);
 106     return !bc->check_address || bc->check_address(bus, child, errp);
 107 }
 108
 109 bool qdev_set_parent_bus(DeviceState *dev, BusState *bus, Error **errp)
 110 {
 111     BusState *old_parent_bus = dev->parent_bus;
 112     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 113
 114     assert(dc->bus_type && object_dynamic_cast(OBJECT(bus), dc->bus_type));
 115
 116     if (!bus_check_address(bus, dev, errp)) {
 117         return false;
 118     }
 119
 120     if (old_parent_bus) {
 121         trace_qdev_update_parent_bus(dev, object_get_typename(OBJECT(dev)),
 122             old_parent_bus, object_get_typename(OBJECT(old_parent_bus)),
 123             OBJECT(bus), object_get_typename(OBJECT(bus)));
 124         /*
 125          * Keep a reference to the device while it's not plugged into
 126          * any bus, to avoid it potentially evaporating when it is
 127          * dereffed in bus_remove_child().
 128          * Also keep the ref of the parent bus until the end, so that
 129          * we can safely call resettable_change_parent() below.
 130          */
 131         object_ref(OBJECT(dev));
 132         bus_remove_child(dev->parent_bus, dev);
 133     }
 134     dev->parent_bus = bus;
 135     object_ref(OBJECT(bus));
 136     bus_add_child(bus, dev);
 137     if (dev->realized) {
 138         resettable_change_parent(OBJECT(dev), OBJECT(bus),
 139                                  OBJECT(old_parent_bus));
 140     }
 141     if (old_parent_bus) {
 142         object_unref(OBJECT(old_parent_bus));
 143         object_unref(OBJECT(dev));
 144     }
 145     return true;
 146 }
 147
 148 DeviceState *qdev_new(const char *name)
 149 {
 150     ObjectClass *oc = object_class_by_name(name);
 151 #ifdef CONFIG_MODULES
 152     if (!oc) {
 153         int rv = module_load_qom(name, &error_fatal);
 154         if (rv > 0) {
 155             oc = object_class_by_name(name);
 156         } else {
 157             error_report("could not find a module for type '%s'", name);
 158             exit(1);
 159         }
 160     }
 161 #endif
 162     if (!oc) {
 163         error_report("unknown type '%s'", name);
 164         abort();
 165     }
 166     return DEVICE(object_new(name));
 167 }
 168
 169 DeviceState *qdev_try_new(const char *name)
 170 {
 171     if (!module_object_class_by_name(name)) {
 172         return NULL;
 173     }
 174     return DEVICE(object_new(name));
 175 }
 176
 177 static QTAILQ_HEAD(, DeviceListener) device_listeners
 178     = QTAILQ_HEAD_INITIALIZER(device_listeners);
 179
 180 enum ListenerDirection { Forward, Reverse };
 181
 182 #define DEVICE_LISTENER_CALL(_callback, _direction, _args...)     \
 183     do {                                                          \
 184         DeviceListener *_listener;                                \
 185                                                                   \
 186         switch (_direction) {                                     \
 187         case Forward:                                             \
 188             QTAILQ_FOREACH(_listener, &device_listeners, link) {  \
 189                 if (_listener->_callback) {                       \
 190                     _listener->_callback(_listener, ##_args);     \
 191                 }                                                 \
 192             }                                                     \
 193             break;                                                \
 194         case Reverse:                                             \
 195             QTAILQ_FOREACH_REVERSE(_listener, &device_listeners,  \
 196                                    link) {                        \
 197                 if (_listener->_callback) {                       \
 198                     _listener->_callback(_listener, ##_args);     \
 199                 }                                                 \
 200             }                                                     \
 201             break;                                                \
 202         default:                                                  \
 203             abort();                                              \
 204         }                                                         \
 205     } while (0)
 206
 207 static int device_listener_add(DeviceState *dev, void *opaque)
 208 {
 209     DEVICE_LISTENER_CALL(realize, Forward, dev);
 210
 211     return 0;
 212 }
 213
 214 void device_listener_register(DeviceListener *listener)
 215 {
 216     QTAILQ_INSERT_TAIL(&device_listeners, listener, link);
 217
 218     qbus_walk_children(sysbus_get_default(), NULL, NULL, device_listener_add,
 219                        NULL, NULL);
 220 }
 221
 222 void device_listener_unregister(DeviceListener *listener)
 223 {
 224     QTAILQ_REMOVE(&device_listeners, listener, link);
 225 }
 226
 227 bool qdev_should_hide_device(const QDict *opts, bool from_json, Error **errp)
 228 {
 229     ERRP_GUARD();
 230     DeviceListener *listener;
 231
 232     QTAILQ_FOREACH(listener, &device_listeners, link) {
 233         if (listener->hide_device) {
 234             if (listener->hide_device(listener, opts, from_json, errp)) {
 235                 return true;
 236             } else if (*errp) {
 237                 return false;
 238             }
 239         }
 240     }
 241
 242     return false;
 243 }
 244
 245 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
 246                                  int required_for_version)
 247 {
 248     assert(!dev->realized);
 249     dev->instance_id_alias = alias_id;
 250     dev->alias_required_for_version = required_for_version;
 251 }
 252
 253 void device_cold_reset(DeviceState *dev)
 254 {
 255     resettable_reset(OBJECT(dev), RESET_TYPE_COLD);
 256 }
 257
 258 bool device_is_in_reset(DeviceState *dev)
 259 {
 260     return resettable_is_in_reset(OBJECT(dev));
 261 }
 262
 263 static ResettableState *device_get_reset_state(Object *obj)
 264 {
 265     DeviceState *dev = DEVICE(obj);
 266     return &dev->reset;
 267 }
 268
 269 static void device_reset_child_foreach(Object *obj, ResettableChildCallback cb,
 270                                        void *opaque, ResetType type)
 271 {
 272     DeviceState *dev = DEVICE(obj);
 273     BusState *bus;
 274
 275     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 276         cb(OBJECT(bus), opaque, type);
 277     }
 278 }
 279
 280 bool qdev_realize(DeviceState *dev, BusState *bus, Error **errp)
 281 {
 282     assert(!dev->realized && !dev->parent_bus);
 283
 284     if (bus) {
 285         if (!qdev_set_parent_bus(dev, bus, errp)) {
 286             return false;
 287         }
 288     } else {
 289         assert(!DEVICE_GET_CLASS(dev)->bus_type);
 290     }
 291
 292     return object_property_set_bool(OBJECT(dev), "realized", true, errp);
 293 }
 294
 295 bool qdev_realize_and_unref(DeviceState *dev, BusState *bus, Error **errp)
 296 {
 297     bool ret;
 298
 299     ret = qdev_realize(dev, bus, errp);
 300     object_unref(OBJECT(dev));
 301     return ret;
 302 }
 303
 304 void qdev_unrealize(DeviceState *dev)
 305 {
 306     object_property_set_bool(OBJECT(dev), "realized", false, &error_abort);
 307 }
 308
 309 static int qdev_assert_realized_properly_cb(Object *obj, void *opaque)
 310 {
 311     DeviceState *dev = DEVICE(object_dynamic_cast(obj, TYPE_DEVICE));
 312     DeviceClass *dc;
 313
 314     if (dev) {
 315         dc = DEVICE_GET_CLASS(dev);
 316         assert(dev->realized);
 317         assert(dev->parent_bus || !dc->bus_type);
 318     }
 319     return 0;
 320 }
 321
 322 void qdev_assert_realized_properly(void)
 323 {
 324     object_child_foreach_recursive(object_get_root(),
 325                                    qdev_assert_realized_properly_cb, NULL);
 326 }
 327
 328 bool qdev_machine_modified(void)
 329 {
 330     return qdev_hot_added || qdev_hot_removed;
 331 }
 332
 333 BusState *qdev_get_parent_bus(const DeviceState *dev)
 334 {
 335     return dev->parent_bus;
 336 }
 337
 338 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 339 {
 340     BusState *bus;
 341     Object *child = object_resolve_path_component(OBJECT(dev), name);
 342
 343     bus = (BusState *)object_dynamic_cast(child, TYPE_BUS);
 344     if (bus) {
 345         return bus;
 346     }
 347
 348     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 349         if (strcmp(name, bus->name) == 0) {
 350             return bus;
 351         }
 352     }
 353     return NULL;
 354 }
 355
 356 int qdev_walk_children(DeviceState *dev,
 357                        qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn,
 358                        qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn,
 359                        void *opaque)
 360 {
 361     BusState *bus;
 362     int err;
 363
 364     if (pre_devfn) {
 365         err = pre_devfn(dev, opaque);
 366         if (err) {
 367             return err;
 368         }
 369     }
 370
 371     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 372         err = qbus_walk_children(bus, pre_devfn, pre_busfn,
 373                                  post_devfn, post_busfn, opaque);
 374         if (err < 0) {
 375             return err;
 376         }
 377     }
 378
 379     if (post_devfn) {
 380         err = post_devfn(dev, opaque);
 381         if (err) {
 382             return err;
 383         }
 384     }
 385
 386     return 0;
 387 }
 388
 389 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 390 {
 391     BusChild *kid;
 392     DeviceState *ret;
 393     BusState *child;
 394
 395     WITH_RCU_READ_LOCK_GUARD() {
 396         QTAILQ_FOREACH_RCU(kid, &bus->children, sibling) {
 397             DeviceState *dev = kid->child;
 398
 399             if (dev->id && strcmp(dev->id, id) == 0) {
 400                 return dev;
 401             }
 402
 403             QLIST_FOREACH(child, &dev->child_bus, sibling) {
 404                 ret = qdev_find_recursive(child, id);
 405                 if (ret) {
 406                     return ret;
 407                 }
 408             }
 409         }
 410     }
 411     return NULL;
 412 }
 413
 414 char *qdev_get_dev_path(DeviceState *dev)
 415 {
 416     BusClass *bc;
 417
 418     if (!dev || !dev->parent_bus) {
 419         return NULL;
 420     }
 421
 422     bc = BUS_GET_CLASS(dev->parent_bus);
 423     if (bc->get_dev_path) {
 424         return bc->get_dev_path(dev);
 425     }
 426
 427     return NULL;
 428 }
 429
 430 void qdev_add_unplug_blocker(DeviceState *dev, Error *reason)
 431 {
 432     dev->unplug_blockers = g_slist_prepend(dev->unplug_blockers, reason);
 433 }
 434
 435 void qdev_del_unplug_blocker(DeviceState *dev, Error *reason)
 436 {
 437     dev->unplug_blockers = g_slist_remove(dev->unplug_blockers, reason);
 438 }
 439
 440 bool qdev_unplug_blocked(DeviceState *dev, Error **errp)
 441 {
 442     if (dev->unplug_blockers) {
 443         error_propagate(errp, error_copy(dev->unplug_blockers->data));
 444         return true;
 445     }
 446
 447     return false;
 448 }
 449
 450 static bool device_get_realized(Object *obj, Error **errp)
 451 {
 452     DeviceState *dev = DEVICE(obj);
 453     return dev->realized;
 454 }
 455
 456 static bool check_only_migratable(Object *obj, Error **errp)
 457 {
 458     DeviceClass *dc = DEVICE_GET_CLASS(obj);
 459
 460     if (!vmstate_check_only_migratable(dc->vmsd)) {
 461         error_setg(errp, "Device %s is not migratable, but "
 462                    "--only-migratable was specified",
 463                    object_get_typename(obj));
 464         return false;
 465     }
 466
 467     return true;
 468 }
 469
 470 static void device_set_realized(Object *obj, bool value, Error **errp)
 471 {
 472     DeviceState *dev = DEVICE(obj);
 473     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 474     HotplugHandler *hotplug_ctrl;
 475     BusState *bus;
 476     NamedClockList *ncl;
 477     Error *local_err = NULL;
 478     bool unattached_parent = false;
 479     static int unattached_count;
 480
 481     if (dev->hotplugged && !dc->hotpluggable) {
 482         error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj));
 483         return;
 484     }
 485
 486     if (value && !dev->realized) {
 487         if (!check_only_migratable(obj, errp)) {
 488             goto fail;
 489         }
 490
 491         if (!obj->parent) {
 492             gchar *name = g_strdup_printf("device[%d]", unattached_count++);
 493
 494             object_property_add_child(container_get(qdev_get_machine(),
 495                                                     "/unattached"),
 496                                       name, obj);
 497             unattached_parent = true;
 498             g_free(name);
 499         }
 500
 501         hotplug_ctrl = qdev_get_hotplug_handler(dev);
 502         if (hotplug_ctrl) {
 503             hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err);
 504             if (local_err != NULL) {
 505                 goto fail;
 506             }
 507         }
 508
 509         if (dc->realize) {
 510             dc->realize(dev, &local_err);
 511             if (local_err != NULL) {
 512                 goto fail;
 513             }
 514         }
 515
 516         DEVICE_LISTENER_CALL(realize, Forward, dev);
 517
 518         /*
 519          * always free/re-initialize here since the value cannot be cleaned up
 520          * in device_unrealize due to its usage later on in the unplug path
 521          */
 522         g_free(dev->canonical_path);
 523         dev->canonical_path = object_get_canonical_path(OBJECT(dev));
 524         QLIST_FOREACH(ncl, &dev->clocks, node) {
 525             if (ncl->alias) {
 526                 continue;
 527             } else {
 528                 clock_setup_canonical_path(ncl->clock);
 529             }
 530         }
 531
 532         if (qdev_get_vmsd(dev)) {
 533             if (vmstate_register_with_alias_id(VMSTATE_IF(dev),
 534                                                VMSTATE_INSTANCE_ID_ANY,
 535                                                qdev_get_vmsd(dev), dev,
 536                                                dev->instance_id_alias,
 537                                                dev->alias_required_for_version,
 538                                                &local_err) < 0) {
 539                 goto post_realize_fail;
 540             }
 541         }
 542
 543         /*
 544          * Clear the reset state, in case the object was previously unrealized
 545          * with a dirty state.
 546          */
 547         resettable_state_clear(&dev->reset);
 548
 549         QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 550             if (!qbus_realize(bus, errp)) {
 551                 goto child_realize_fail;
 552             }
 553         }
 554         if (dev->hotplugged) {
 555             /*
 556              * Reset the device, as well as its subtree which, at this point,
 557              * should be realized too.
 558              */
 559             resettable_assert_reset(OBJECT(dev), RESET_TYPE_COLD);
 560             resettable_change_parent(OBJECT(dev), OBJECT(dev->parent_bus),
 561                                      NULL);
 562             resettable_release_reset(OBJECT(dev), RESET_TYPE_COLD);
 563         }
 564         dev->pending_deleted_event = false;
 565
 566         if (hotplug_ctrl) {
 567             hotplug_handler_plug(hotplug_ctrl, dev, &local_err);
 568             if (local_err != NULL) {
 569                 goto child_realize_fail;
 570             }
 571        }
 572
 573        qatomic_store_release(&dev->realized, value);
 574
 575     } else if (!value && dev->realized) {
 576
 577         /*
 578          * Change the value so that any concurrent users are aware
 579          * that the device is going to be unrealized
 580          *
 581          * TODO: change .realized property to enum that states
 582          * each phase of the device realization/unrealization
 583          */
 584
 585         qatomic_set(&dev->realized, value);
 586         /*
 587          * Ensure that concurrent users see this update prior to
 588          * any other changes done by unrealize.
 589          */
 590         smp_wmb();
 591
 592         QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 593             qbus_unrealize(bus);
 594         }
 595         if (qdev_get_vmsd(dev)) {
 596             vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
 597         }
 598         if (dc->unrealize) {
 599             dc->unrealize(dev);
 600         }
 601         dev->pending_deleted_event = true;
 602         DEVICE_LISTENER_CALL(unrealize, Reverse, dev);
 603     }
 604
 605     assert(local_err == NULL);
 606     return;
 607
 608 child_realize_fail:
 609     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 610         qbus_unrealize(bus);
 611     }
 612
 613     if (qdev_get_vmsd(dev)) {
 614         vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
 615     }
 616
 617 post_realize_fail:
 618     g_free(dev->canonical_path);
 619     dev->canonical_path = NULL;
 620     if (dc->unrealize) {
 621         dc->unrealize(dev);
 622     }
 623
 624 fail:
 625     error_propagate(errp, local_err);
 626     if (unattached_parent) {
 627         /*
 628          * Beware, this doesn't just revert
 629          * object_property_add_child(), it also runs bus_remove()!
 630          */
 631         object_unparent(OBJECT(dev));
 632         unattached_count--;
 633     }
 634 }
 635
 636 static bool device_get_hotpluggable(Object *obj, Error **errp)
 637 {
 638     DeviceClass *dc = DEVICE_GET_CLASS(obj);
 639     DeviceState *dev = DEVICE(obj);
 640
 641     return dc->hotpluggable && (dev->parent_bus == NULL ||
 642                                 qbus_is_hotpluggable(dev->parent_bus));
 643 }
 644
 645 static bool device_get_hotplugged(Object *obj, Error **errp)
 646 {
 647     DeviceState *dev = DEVICE(obj);
 648
 649     return dev->hotplugged;
 650 }
 651
 652 static void device_initfn(Object *obj)
 653 {
 654     DeviceState *dev = DEVICE(obj);
 655
 656     if (phase_check(PHASE_MACHINE_READY)) {
 657         dev->hotplugged = 1;
 658         qdev_hot_added = true;
 659     }
 660
 661     dev->instance_id_alias = -1;
 662     dev->realized = false;
 663     dev->allow_unplug_during_migration = false;
 664
 665     QLIST_INIT(&dev->gpios);
 666     QLIST_INIT(&dev->clocks);
 667 }
 668
 669 static void device_post_init(Object *obj)
 670 {
 671     /*
 672      * Note: ordered so that the user's global properties take
 673      * precedence.
 674      */
 675     object_apply_compat_props(obj);
 676     qdev_prop_set_globals(DEVICE(obj));
 677 }
 678
 679 /* Unlink device from bus and free the structure.  */
 680 static void device_finalize(Object *obj)
 681 {
 682     NamedGPIOList *ngl, *next;
 683
 684     DeviceState *dev = DEVICE(obj);
 685
 686     g_assert(!dev->unplug_blockers);
 687
 688     QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) {
 689         QLIST_REMOVE(ngl, node);
 690         qemu_free_irqs(ngl->in, ngl->num_in);
 691         g_free(ngl->name);
 692         g_free(ngl);
 693         /* ngl->out irqs are owned by the other end and should not be freed
 694          * here
 695          */
 696     }
 697
 698     qdev_finalize_clocklist(dev);
 699
 700     /* Only send event if the device had been completely realized */
 701     if (dev->pending_deleted_event) {
 702         g_assert(dev->canonical_path);
 703
 704         qapi_event_send_device_deleted(dev->id, dev->canonical_path);
 705         g_free(dev->canonical_path);
 706         dev->canonical_path = NULL;
 707     }
 708
 709     qobject_unref(dev->opts);
 710     g_free(dev->id);
 711 }
 712
 713 static void device_class_base_init(ObjectClass *class, void *data)
 714 {
 715     DeviceClass *klass = DEVICE_CLASS(class);
 716
 717     /* We explicitly look up properties in the superclasses,
 718      * so do not propagate them to the subclasses.
 719      */
 720     klass->props_ = NULL;
 721 }
 722
 723 static void device_unparent(Object *obj)
 724 {
 725     DeviceState *dev = DEVICE(obj);
 726     BusState *bus;
 727
 728     if (dev->realized) {
 729         qdev_unrealize(dev);
 730     }
 731     while (dev->num_child_bus) {
 732         bus = QLIST_FIRST(&dev->child_bus);
 733         object_unparent(OBJECT(bus));
 734     }
 735     if (dev->parent_bus) {
 736         bus_remove_child(dev->parent_bus, dev);
 737         object_unref(OBJECT(dev->parent_bus));
 738         dev->parent_bus = NULL;
 739     }
 740 }
 741
 742 static char *
 743 device_vmstate_if_get_id(VMStateIf *obj)
 744 {
 745     DeviceState *dev = DEVICE(obj);
 746
 747     return qdev_get_dev_path(dev);
 748 }
 749
 750 /**
 751  * device_phases_reset:
 752  * Transition reset method for devices to allow moving
 753  * smoothly from legacy reset method to multi-phases
 754  */
 755 static void device_phases_reset(DeviceState *dev)
 756 {
 757     ResettableClass *rc = RESETTABLE_GET_CLASS(dev);
 758
 759     if (rc->phases.enter) {
 760         rc->phases.enter(OBJECT(dev), RESET_TYPE_COLD);
 761     }
 762     if (rc->phases.hold) {
 763         rc->phases.hold(OBJECT(dev));
 764     }
 765     if (rc->phases.exit) {
 766         rc->phases.exit(OBJECT(dev));
 767     }
 768 }
 769
 770 static void device_transitional_reset(Object *obj)
 771 {
 772     DeviceClass *dc = DEVICE_GET_CLASS(obj);
 773
 774     /*
 775      * This will call either @device_phases_reset (for multi-phases transitioned
 776      * devices) or a device's specific method for not-yet transitioned devices.
 777      * In both case, it does not reset children.
 778      */
 779     if (dc->reset) {
 780         dc->reset(DEVICE(obj));
 781     }
 782 }
 783
 784 /**
 785  * device_get_transitional_reset:
 786  * check if the device's class is ready for multi-phase
 787  */
 788 static ResettableTrFunction device_get_transitional_reset(Object *obj)
 789 {
 790     DeviceClass *dc = DEVICE_GET_CLASS(obj);
 791     if (dc->reset != device_phases_reset) {
 792         /*
 793          * dc->reset has been overridden by a subclass,
 794          * the device is not ready for multi phase yet.
 795          */
 796         return device_transitional_reset;
 797     }
 798     return NULL;
 799 }
 800
 801 static void device_class_init(ObjectClass *class, void *data)
 802 {
 803     DeviceClass *dc = DEVICE_CLASS(class);
 804     VMStateIfClass *vc = VMSTATE_IF_CLASS(class);
 805     ResettableClass *rc = RESETTABLE_CLASS(class);
 806
 807     class->unparent = device_unparent;
 808
 809     /* by default all devices were considered as hotpluggable,
 810      * so with intent to check it in generic qdev_unplug() /
 811      * device_set_realized() functions make every device
 812      * hotpluggable. Devices that shouldn't be hotpluggable,
 813      * should override it in their class_init()
 814      */
 815     dc->hotpluggable = true;
 816     dc->user_creatable = true;
 817     vc->get_id = device_vmstate_if_get_id;
 818     rc->get_state = device_get_reset_state;
 819     rc->child_foreach = device_reset_child_foreach;
 820
 821     /*
 822      * @device_phases_reset is put as the default reset method below, allowing
 823      * to do the multi-phase transition from base classes to leaf classes. It
 824      * allows a legacy-reset Device class to extend a multi-phases-reset
 825      * Device class for the following reason:
 826      * + If a base class B has been moved to multi-phase, then it does not
 827      *   override this default reset method and may have defined phase methods.
 828      * + A child class C (extending class B) which uses
 829      *   device_class_set_parent_reset() (or similar means) to override the
 830      *   reset method will still work as expected. @device_phases_reset function
 831      *   will be registered as the parent reset method and effectively call
 832      *   parent reset phases.
 833      */
 834     dc->reset = device_phases_reset;
 835     rc->get_transitional_function = device_get_transitional_reset;
 836
 837     object_class_property_add_bool(class, "realized",
 838                                    device_get_realized, device_set_realized);
 839     object_class_property_add_bool(class, "hotpluggable",
 840                                    device_get_hotpluggable, NULL);
 841     object_class_property_add_bool(class, "hotplugged",
 842                                    device_get_hotplugged, NULL);
 843     object_class_property_add_link(class, "parent_bus", TYPE_BUS,
 844                                    offsetof(DeviceState, parent_bus), NULL, 0);
 845 }
 846
 847 void device_class_set_parent_reset(DeviceClass *dc,
 848                                    DeviceReset dev_reset,
 849                                    DeviceReset *parent_reset)
 850 {
 851     *parent_reset = dc->reset;
 852     dc->reset = dev_reset;
 853 }
 854
 855 void device_class_set_parent_realize(DeviceClass *dc,
 856                                      DeviceRealize dev_realize,
 857                                      DeviceRealize *parent_realize)
 858 {
 859     *parent_realize = dc->realize;
 860     dc->realize = dev_realize;
 861 }
 862
 863 void device_class_set_parent_unrealize(DeviceClass *dc,
 864                                        DeviceUnrealize dev_unrealize,
 865                                        DeviceUnrealize *parent_unrealize)
 866 {
 867     *parent_unrealize = dc->unrealize;
 868     dc->unrealize = dev_unrealize;
 869 }
 870
 871 Object *qdev_get_machine(void)
 872 {
 873     static Object *dev;
 874
 875     if (dev == NULL) {
 876         dev = container_get(object_get_root(), "/machine");
 877     }
 878
 879     return dev;
 880 }
 881
 882 static MachineInitPhase machine_phase;
 883
 884 bool phase_check(MachineInitPhase phase)
 885 {
 886     return machine_phase >= phase;
 887 }
 888
 889 void phase_advance(MachineInitPhase phase)
 890 {
 891     assert(machine_phase == phase - 1);
 892     machine_phase = phase;
 893 }
 894
 895 static const TypeInfo device_type_info = {
 896     .name = TYPE_DEVICE,
 897     .parent = TYPE_OBJECT,
 898     .instance_size = sizeof(DeviceState),
 899     .instance_init = device_initfn,
 900     .instance_post_init = device_post_init,
 901     .instance_finalize = device_finalize,
 902     .class_base_init = device_class_base_init,
 903     .class_init = device_class_init,
 904     .abstract = true,
 905     .class_size = sizeof(DeviceClass),
 906     .interfaces = (InterfaceInfo[]) {
 907         { TYPE_VMSTATE_IF },
 908         { TYPE_RESETTABLE_INTERFACE },
 909         { }
 910     }
 911 };
 912
 913 static void qdev_register_types(void)
 914 {
 915     type_register_static(&device_type_info);
 916 }
 917
 918 type_init(qdev_register_types)