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