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