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