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/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_free_bus_child(BusChild *kid) 55 { 56 object_unref(OBJECT(kid->child)); 57 g_free(kid); 58 } 59 60 static void bus_remove_child(BusState *bus, DeviceState *child) 61 { 62 BusChild *kid; 63 64 QTAILQ_FOREACH(kid, &bus->children, sibling) { 65 if (kid->child == child) { 66 char name[32]; 67 68 snprintf(name, sizeof(name), "child[%d]", kid->index); 69 QTAILQ_REMOVE_RCU(&bus->children, kid, sibling); 70 71 bus->num_children--; 72 73 /* This gives back ownership of kid->child back to us. */ 74 object_property_del(OBJECT(bus), name); 75 76 /* free the bus kid, when it is safe to do so*/ 77 call_rcu(kid, bus_free_bus_child, rcu); 78 break; 79 } 80 } 81 } 82 83 static void bus_add_child(BusState *bus, DeviceState *child) 84 { 85 char name[32]; 86 BusChild *kid = g_malloc0(sizeof(*kid)); 87 88 bus->num_children++; 89 kid->index = bus->max_index++; 90 kid->child = child; 91 object_ref(OBJECT(kid->child)); 92 93 QTAILQ_INSERT_HEAD_RCU(&bus->children, kid, sibling); 94 95 /* This transfers ownership of kid->child to the property. */ 96 snprintf(name, sizeof(name), "child[%d]", kid->index); 97 object_property_add_link(OBJECT(bus), name, 98 object_get_typename(OBJECT(child)), 99 (Object **)&kid->child, 100 NULL, /* read-only property */ 101 0); 102 } 103 104 static bool bus_check_address(BusState *bus, DeviceState *child, Error **errp) 105 { 106 BusClass *bc = BUS_GET_CLASS(bus); 107 return !bc->check_address || bc->check_address(bus, child, errp); 108 } 109 110 bool qdev_set_parent_bus(DeviceState *dev, BusState *bus, Error **errp) 111 { 112 BusState *old_parent_bus = dev->parent_bus; 113 DeviceClass *dc = DEVICE_GET_CLASS(dev); 114 115 assert(dc->bus_type && object_dynamic_cast(OBJECT(bus), dc->bus_type)); 116 117 if (!bus_check_address(bus, dev, errp)) { 118 return false; 119 } 120 121 if (old_parent_bus) { 122 trace_qdev_update_parent_bus(dev, object_get_typename(OBJECT(dev)), 123 old_parent_bus, object_get_typename(OBJECT(old_parent_bus)), 124 OBJECT(bus), object_get_typename(OBJECT(bus))); 125 /* 126 * Keep a reference to the device while it's not plugged into 127 * any bus, to avoid it potentially evaporating when it is 128 * dereffed in bus_remove_child(). 129 * Also keep the ref of the parent bus until the end, so that 130 * we can safely call resettable_change_parent() below. 131 */ 132 object_ref(OBJECT(dev)); 133 bus_remove_child(dev->parent_bus, dev); 134 } 135 dev->parent_bus = bus; 136 object_ref(OBJECT(bus)); 137 bus_add_child(bus, dev); 138 if (dev->realized) { 139 resettable_change_parent(OBJECT(dev), OBJECT(bus), 140 OBJECT(old_parent_bus)); 141 } 142 if (old_parent_bus) { 143 object_unref(OBJECT(old_parent_bus)); 144 object_unref(OBJECT(dev)); 145 } 146 return true; 147 } 148 149 DeviceState *qdev_new(const char *name) 150 { 151 if (!object_class_by_name(name)) { 152 module_load_qom_one(name); 153 } 154 return DEVICE(object_new(name)); 155 } 156 157 DeviceState *qdev_try_new(const char *name) 158 { 159 if (!module_object_class_by_name(name)) { 160 return NULL; 161 } 162 return DEVICE(object_new(name)); 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 DeviceListener *listener; 218 219 QTAILQ_FOREACH(listener, &device_listeners, link) { 220 if (listener->hide_device) { 221 if (listener->hide_device(listener, opts)) { 222 return true; 223 } 224 } 225 } 226 227 return false; 228 } 229 230 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id, 231 int required_for_version) 232 { 233 assert(!dev->realized); 234 dev->instance_id_alias = alias_id; 235 dev->alias_required_for_version = required_for_version; 236 } 237 238 HotplugHandler *qdev_get_machine_hotplug_handler(DeviceState *dev) 239 { 240 MachineState *machine; 241 MachineClass *mc; 242 Object *m_obj = qdev_get_machine(); 243 244 if (object_dynamic_cast(m_obj, TYPE_MACHINE)) { 245 machine = MACHINE(m_obj); 246 mc = MACHINE_GET_CLASS(machine); 247 if (mc->get_hotplug_handler) { 248 return mc->get_hotplug_handler(machine, dev); 249 } 250 } 251 252 return NULL; 253 } 254 255 bool qdev_hotplug_allowed(DeviceState *dev, Error **errp) 256 { 257 MachineState *machine; 258 MachineClass *mc; 259 Object *m_obj = qdev_get_machine(); 260 261 if (object_dynamic_cast(m_obj, TYPE_MACHINE)) { 262 machine = MACHINE(m_obj); 263 mc = MACHINE_GET_CLASS(machine); 264 if (mc->hotplug_allowed) { 265 return mc->hotplug_allowed(machine, dev, errp); 266 } 267 } 268 269 return true; 270 } 271 272 HotplugHandler *qdev_get_bus_hotplug_handler(DeviceState *dev) 273 { 274 if (dev->parent_bus) { 275 return dev->parent_bus->hotplug_handler; 276 } 277 return NULL; 278 } 279 280 HotplugHandler *qdev_get_hotplug_handler(DeviceState *dev) 281 { 282 HotplugHandler *hotplug_ctrl = qdev_get_machine_hotplug_handler(dev); 283 284 if (hotplug_ctrl == NULL && dev->parent_bus) { 285 hotplug_ctrl = qdev_get_bus_hotplug_handler(dev); 286 } 287 return hotplug_ctrl; 288 } 289 290 static int qdev_prereset(DeviceState *dev, void *opaque) 291 { 292 trace_qdev_reset_tree(dev, object_get_typename(OBJECT(dev))); 293 return 0; 294 } 295 296 static int qbus_prereset(BusState *bus, void *opaque) 297 { 298 trace_qbus_reset_tree(bus, object_get_typename(OBJECT(bus))); 299 return 0; 300 } 301 302 static int qdev_reset_one(DeviceState *dev, void *opaque) 303 { 304 device_legacy_reset(dev); 305 306 return 0; 307 } 308 309 static int qbus_reset_one(BusState *bus, void *opaque) 310 { 311 BusClass *bc = BUS_GET_CLASS(bus); 312 trace_qbus_reset(bus, object_get_typename(OBJECT(bus))); 313 if (bc->reset) { 314 bc->reset(bus); 315 } 316 return 0; 317 } 318 319 void qdev_reset_all(DeviceState *dev) 320 { 321 trace_qdev_reset_all(dev, object_get_typename(OBJECT(dev))); 322 qdev_walk_children(dev, qdev_prereset, qbus_prereset, 323 qdev_reset_one, qbus_reset_one, NULL); 324 } 325 326 void qdev_reset_all_fn(void *opaque) 327 { 328 qdev_reset_all(DEVICE(opaque)); 329 } 330 331 void qbus_reset_all(BusState *bus) 332 { 333 trace_qbus_reset_all(bus, object_get_typename(OBJECT(bus))); 334 qbus_walk_children(bus, qdev_prereset, qbus_prereset, 335 qdev_reset_one, qbus_reset_one, NULL); 336 } 337 338 void qbus_reset_all_fn(void *opaque) 339 { 340 BusState *bus = opaque; 341 qbus_reset_all(bus); 342 } 343 344 void device_cold_reset(DeviceState *dev) 345 { 346 resettable_reset(OBJECT(dev), RESET_TYPE_COLD); 347 } 348 349 bool device_is_in_reset(DeviceState *dev) 350 { 351 return resettable_is_in_reset(OBJECT(dev)); 352 } 353 354 static ResettableState *device_get_reset_state(Object *obj) 355 { 356 DeviceState *dev = DEVICE(obj); 357 return &dev->reset; 358 } 359 360 static void device_reset_child_foreach(Object *obj, ResettableChildCallback cb, 361 void *opaque, ResetType type) 362 { 363 DeviceState *dev = DEVICE(obj); 364 BusState *bus; 365 366 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 367 cb(OBJECT(bus), opaque, type); 368 } 369 } 370 371 /* can be used as ->unplug() callback for the simple cases */ 372 void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev, 373 DeviceState *dev, Error **errp) 374 { 375 qdev_unrealize(dev); 376 } 377 378 bool qdev_realize(DeviceState *dev, BusState *bus, Error **errp) 379 { 380 assert(!dev->realized && !dev->parent_bus); 381 382 if (bus) { 383 if (!qdev_set_parent_bus(dev, bus, errp)) { 384 return false; 385 } 386 } else { 387 assert(!DEVICE_GET_CLASS(dev)->bus_type); 388 } 389 390 return object_property_set_bool(OBJECT(dev), "realized", true, errp); 391 } 392 393 bool qdev_realize_and_unref(DeviceState *dev, BusState *bus, Error **errp) 394 { 395 bool ret; 396 397 ret = qdev_realize(dev, bus, errp); 398 object_unref(OBJECT(dev)); 399 return ret; 400 } 401 402 void qdev_unrealize(DeviceState *dev) 403 { 404 object_property_set_bool(OBJECT(dev), "realized", false, &error_abort); 405 } 406 407 static int qdev_assert_realized_properly_cb(Object *obj, void *opaque) 408 { 409 DeviceState *dev = DEVICE(object_dynamic_cast(obj, TYPE_DEVICE)); 410 DeviceClass *dc; 411 412 if (dev) { 413 dc = DEVICE_GET_CLASS(dev); 414 assert(dev->realized); 415 assert(dev->parent_bus || !dc->bus_type); 416 } 417 return 0; 418 } 419 420 void qdev_assert_realized_properly(void) 421 { 422 object_child_foreach_recursive(object_get_root(), 423 qdev_assert_realized_properly_cb, NULL); 424 } 425 426 bool qdev_machine_modified(void) 427 { 428 return qdev_hot_added || qdev_hot_removed; 429 } 430 431 BusState *qdev_get_parent_bus(DeviceState *dev) 432 { 433 return dev->parent_bus; 434 } 435 436 static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev, 437 const char *name) 438 { 439 NamedGPIOList *ngl; 440 441 QLIST_FOREACH(ngl, &dev->gpios, node) { 442 /* NULL is a valid and matchable name. */ 443 if (g_strcmp0(name, ngl->name) == 0) { 444 return ngl; 445 } 446 } 447 448 ngl = g_malloc0(sizeof(*ngl)); 449 ngl->name = g_strdup(name); 450 QLIST_INSERT_HEAD(&dev->gpios, ngl, node); 451 return ngl; 452 } 453 454 void qdev_init_gpio_in_named_with_opaque(DeviceState *dev, 455 qemu_irq_handler handler, 456 void *opaque, 457 const char *name, int n) 458 { 459 int i; 460 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); 461 462 assert(gpio_list->num_out == 0 || !name); 463 gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler, 464 opaque, n); 465 466 if (!name) { 467 name = "unnamed-gpio-in"; 468 } 469 for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) { 470 gchar *propname = g_strdup_printf("%s[%u]", name, i); 471 472 object_property_add_child(OBJECT(dev), propname, 473 OBJECT(gpio_list->in[i])); 474 g_free(propname); 475 } 476 477 gpio_list->num_in += n; 478 } 479 480 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n) 481 { 482 qdev_init_gpio_in_named(dev, handler, NULL, n); 483 } 484 485 void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins, 486 const char *name, int n) 487 { 488 int i; 489 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); 490 491 assert(gpio_list->num_in == 0 || !name); 492 493 if (!name) { 494 name = "unnamed-gpio-out"; 495 } 496 memset(pins, 0, sizeof(*pins) * n); 497 for (i = 0; i < n; ++i) { 498 gchar *propname = g_strdup_printf("%s[%u]", name, 499 gpio_list->num_out + i); 500 501 object_property_add_link(OBJECT(dev), propname, TYPE_IRQ, 502 (Object **)&pins[i], 503 object_property_allow_set_link, 504 OBJ_PROP_LINK_STRONG); 505 g_free(propname); 506 } 507 gpio_list->num_out += n; 508 } 509 510 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n) 511 { 512 qdev_init_gpio_out_named(dev, pins, NULL, n); 513 } 514 515 qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n) 516 { 517 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); 518 519 assert(n >= 0 && n < gpio_list->num_in); 520 return gpio_list->in[n]; 521 } 522 523 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n) 524 { 525 return qdev_get_gpio_in_named(dev, NULL, n); 526 } 527 528 void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n, 529 qemu_irq pin) 530 { 531 char *propname = g_strdup_printf("%s[%d]", 532 name ? name : "unnamed-gpio-out", n); 533 if (pin && !OBJECT(pin)->parent) { 534 /* We need a name for object_property_set_link to work */ 535 object_property_add_child(container_get(qdev_get_machine(), 536 "/unattached"), 537 "non-qdev-gpio[*]", OBJECT(pin)); 538 } 539 object_property_set_link(OBJECT(dev), propname, OBJECT(pin), &error_abort); 540 g_free(propname); 541 } 542 543 qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n) 544 { 545 g_autofree char *propname = g_strdup_printf("%s[%d]", 546 name ? name : "unnamed-gpio-out", n); 547 548 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname, 549 NULL); 550 551 return ret; 552 } 553 554 /* disconnect a GPIO output, returning the disconnected input (if any) */ 555 556 static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev, 557 const char *name, int n) 558 { 559 char *propname = g_strdup_printf("%s[%d]", 560 name ? name : "unnamed-gpio-out", n); 561 562 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname, 563 NULL); 564 if (ret) { 565 object_property_set_link(OBJECT(dev), propname, NULL, NULL); 566 } 567 g_free(propname); 568 return ret; 569 } 570 571 qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt, 572 const char *name, int n) 573 { 574 qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n); 575 qdev_connect_gpio_out_named(dev, name, n, icpt); 576 return disconnected; 577 } 578 579 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin) 580 { 581 qdev_connect_gpio_out_named(dev, NULL, n, pin); 582 } 583 584 void qdev_pass_gpios(DeviceState *dev, DeviceState *container, 585 const char *name) 586 { 587 int i; 588 NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name); 589 590 for (i = 0; i < ngl->num_in; i++) { 591 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in"; 592 char *propname = g_strdup_printf("%s[%d]", nm, i); 593 594 object_property_add_alias(OBJECT(container), propname, 595 OBJECT(dev), propname); 596 g_free(propname); 597 } 598 for (i = 0; i < ngl->num_out; i++) { 599 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out"; 600 char *propname = g_strdup_printf("%s[%d]", nm, i); 601 602 object_property_add_alias(OBJECT(container), propname, 603 OBJECT(dev), propname); 604 g_free(propname); 605 } 606 QLIST_REMOVE(ngl, node); 607 QLIST_INSERT_HEAD(&container->gpios, ngl, node); 608 } 609 610 BusState *qdev_get_child_bus(DeviceState *dev, const char *name) 611 { 612 BusState *bus; 613 Object *child = object_resolve_path_component(OBJECT(dev), name); 614 615 bus = (BusState *)object_dynamic_cast(child, TYPE_BUS); 616 if (bus) { 617 return bus; 618 } 619 620 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 621 if (strcmp(name, bus->name) == 0) { 622 return bus; 623 } 624 } 625 return NULL; 626 } 627 628 int qdev_walk_children(DeviceState *dev, 629 qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, 630 qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, 631 void *opaque) 632 { 633 BusState *bus; 634 int err; 635 636 if (pre_devfn) { 637 err = pre_devfn(dev, opaque); 638 if (err) { 639 return err; 640 } 641 } 642 643 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 644 err = qbus_walk_children(bus, pre_devfn, pre_busfn, 645 post_devfn, post_busfn, opaque); 646 if (err < 0) { 647 return err; 648 } 649 } 650 651 if (post_devfn) { 652 err = post_devfn(dev, opaque); 653 if (err) { 654 return err; 655 } 656 } 657 658 return 0; 659 } 660 661 DeviceState *qdev_find_recursive(BusState *bus, const char *id) 662 { 663 BusChild *kid; 664 DeviceState *ret; 665 BusState *child; 666 667 WITH_RCU_READ_LOCK_GUARD() { 668 QTAILQ_FOREACH_RCU(kid, &bus->children, sibling) { 669 DeviceState *dev = kid->child; 670 671 if (dev->id && strcmp(dev->id, id) == 0) { 672 return dev; 673 } 674 675 QLIST_FOREACH(child, &dev->child_bus, sibling) { 676 ret = qdev_find_recursive(child, id); 677 if (ret) { 678 return ret; 679 } 680 } 681 } 682 } 683 return NULL; 684 } 685 686 char *qdev_get_dev_path(DeviceState *dev) 687 { 688 BusClass *bc; 689 690 if (!dev || !dev->parent_bus) { 691 return NULL; 692 } 693 694 bc = BUS_GET_CLASS(dev->parent_bus); 695 if (bc->get_dev_path) { 696 return bc->get_dev_path(dev); 697 } 698 699 return NULL; 700 } 701 702 static bool device_get_realized(Object *obj, Error **errp) 703 { 704 DeviceState *dev = DEVICE(obj); 705 return dev->realized; 706 } 707 708 static bool check_only_migratable(Object *obj, Error **errp) 709 { 710 DeviceClass *dc = DEVICE_GET_CLASS(obj); 711 712 if (!vmstate_check_only_migratable(dc->vmsd)) { 713 error_setg(errp, "Device %s is not migratable, but " 714 "--only-migratable was specified", 715 object_get_typename(obj)); 716 return false; 717 } 718 719 return true; 720 } 721 722 static void device_set_realized(Object *obj, bool value, Error **errp) 723 { 724 DeviceState *dev = DEVICE(obj); 725 DeviceClass *dc = DEVICE_GET_CLASS(dev); 726 HotplugHandler *hotplug_ctrl; 727 BusState *bus; 728 NamedClockList *ncl; 729 Error *local_err = NULL; 730 bool unattached_parent = false; 731 static int unattached_count; 732 733 if (dev->hotplugged && !dc->hotpluggable) { 734 error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj)); 735 return; 736 } 737 738 if (value && !dev->realized) { 739 if (!check_only_migratable(obj, errp)) { 740 goto fail; 741 } 742 743 if (!obj->parent) { 744 gchar *name = g_strdup_printf("device[%d]", unattached_count++); 745 746 object_property_add_child(container_get(qdev_get_machine(), 747 "/unattached"), 748 name, obj); 749 unattached_parent = true; 750 g_free(name); 751 } 752 753 hotplug_ctrl = qdev_get_hotplug_handler(dev); 754 if (hotplug_ctrl) { 755 hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err); 756 if (local_err != NULL) { 757 goto fail; 758 } 759 } 760 761 if (dc->realize) { 762 dc->realize(dev, &local_err); 763 if (local_err != NULL) { 764 goto fail; 765 } 766 } 767 768 DEVICE_LISTENER_CALL(realize, Forward, dev); 769 770 /* 771 * always free/re-initialize here since the value cannot be cleaned up 772 * in device_unrealize due to its usage later on in the unplug path 773 */ 774 g_free(dev->canonical_path); 775 dev->canonical_path = object_get_canonical_path(OBJECT(dev)); 776 QLIST_FOREACH(ncl, &dev->clocks, node) { 777 if (ncl->alias) { 778 continue; 779 } else { 780 clock_setup_canonical_path(ncl->clock); 781 } 782 } 783 784 if (qdev_get_vmsd(dev)) { 785 if (vmstate_register_with_alias_id(VMSTATE_IF(dev), 786 VMSTATE_INSTANCE_ID_ANY, 787 qdev_get_vmsd(dev), dev, 788 dev->instance_id_alias, 789 dev->alias_required_for_version, 790 &local_err) < 0) { 791 goto post_realize_fail; 792 } 793 } 794 795 /* 796 * Clear the reset state, in case the object was previously unrealized 797 * with a dirty state. 798 */ 799 resettable_state_clear(&dev->reset); 800 801 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 802 if (!qbus_realize(bus, errp)) { 803 goto child_realize_fail; 804 } 805 } 806 if (dev->hotplugged) { 807 /* 808 * Reset the device, as well as its subtree which, at this point, 809 * should be realized too. 810 */ 811 resettable_assert_reset(OBJECT(dev), RESET_TYPE_COLD); 812 resettable_change_parent(OBJECT(dev), OBJECT(dev->parent_bus), 813 NULL); 814 resettable_release_reset(OBJECT(dev), RESET_TYPE_COLD); 815 } 816 dev->pending_deleted_event = false; 817 818 if (hotplug_ctrl) { 819 hotplug_handler_plug(hotplug_ctrl, dev, &local_err); 820 if (local_err != NULL) { 821 goto child_realize_fail; 822 } 823 } 824 825 qatomic_store_release(&dev->realized, value); 826 827 } else if (!value && dev->realized) { 828 829 /* 830 * Change the value so that any concurrent users are aware 831 * that the device is going to be unrealized 832 * 833 * TODO: change .realized property to enum that states 834 * each phase of the device realization/unrealization 835 */ 836 837 qatomic_set(&dev->realized, value); 838 /* 839 * Ensure that concurrent users see this update prior to 840 * any other changes done by unrealize. 841 */ 842 smp_wmb(); 843 844 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 845 qbus_unrealize(bus); 846 } 847 if (qdev_get_vmsd(dev)) { 848 vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev); 849 } 850 if (dc->unrealize) { 851 dc->unrealize(dev); 852 } 853 dev->pending_deleted_event = true; 854 DEVICE_LISTENER_CALL(unrealize, Reverse, dev); 855 } 856 857 assert(local_err == NULL); 858 return; 859 860 child_realize_fail: 861 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 862 qbus_unrealize(bus); 863 } 864 865 if (qdev_get_vmsd(dev)) { 866 vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev); 867 } 868 869 post_realize_fail: 870 g_free(dev->canonical_path); 871 dev->canonical_path = NULL; 872 if (dc->unrealize) { 873 dc->unrealize(dev); 874 } 875 876 fail: 877 error_propagate(errp, local_err); 878 if (unattached_parent) { 879 /* 880 * Beware, this doesn't just revert 881 * object_property_add_child(), it also runs bus_remove()! 882 */ 883 object_unparent(OBJECT(dev)); 884 unattached_count--; 885 } 886 } 887 888 static bool device_get_hotpluggable(Object *obj, Error **errp) 889 { 890 DeviceClass *dc = DEVICE_GET_CLASS(obj); 891 DeviceState *dev = DEVICE(obj); 892 893 return dc->hotpluggable && (dev->parent_bus == NULL || 894 qbus_is_hotpluggable(dev->parent_bus)); 895 } 896 897 static bool device_get_hotplugged(Object *obj, Error **errp) 898 { 899 DeviceState *dev = DEVICE(obj); 900 901 return dev->hotplugged; 902 } 903 904 static void device_initfn(Object *obj) 905 { 906 DeviceState *dev = DEVICE(obj); 907 908 if (qdev_hotplug) { 909 dev->hotplugged = 1; 910 qdev_hot_added = true; 911 } 912 913 dev->instance_id_alias = -1; 914 dev->realized = false; 915 dev->allow_unplug_during_migration = false; 916 917 QLIST_INIT(&dev->gpios); 918 QLIST_INIT(&dev->clocks); 919 } 920 921 static void device_post_init(Object *obj) 922 { 923 /* 924 * Note: ordered so that the user's global properties take 925 * precedence. 926 */ 927 object_apply_compat_props(obj); 928 qdev_prop_set_globals(DEVICE(obj)); 929 } 930 931 /* Unlink device from bus and free the structure. */ 932 static void device_finalize(Object *obj) 933 { 934 NamedGPIOList *ngl, *next; 935 936 DeviceState *dev = DEVICE(obj); 937 938 QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) { 939 QLIST_REMOVE(ngl, node); 940 qemu_free_irqs(ngl->in, ngl->num_in); 941 g_free(ngl->name); 942 g_free(ngl); 943 /* ngl->out irqs are owned by the other end and should not be freed 944 * here 945 */ 946 } 947 948 qdev_finalize_clocklist(dev); 949 950 /* Only send event if the device had been completely realized */ 951 if (dev->pending_deleted_event) { 952 g_assert(dev->canonical_path); 953 954 qapi_event_send_device_deleted(!!dev->id, dev->id, dev->canonical_path); 955 g_free(dev->canonical_path); 956 dev->canonical_path = NULL; 957 } 958 959 qemu_opts_del(dev->opts); 960 } 961 962 static void device_class_base_init(ObjectClass *class, void *data) 963 { 964 DeviceClass *klass = DEVICE_CLASS(class); 965 966 /* We explicitly look up properties in the superclasses, 967 * so do not propagate them to the subclasses. 968 */ 969 klass->props_ = NULL; 970 } 971 972 static void device_unparent(Object *obj) 973 { 974 DeviceState *dev = DEVICE(obj); 975 BusState *bus; 976 977 if (dev->realized) { 978 qdev_unrealize(dev); 979 } 980 while (dev->num_child_bus) { 981 bus = QLIST_FIRST(&dev->child_bus); 982 object_unparent(OBJECT(bus)); 983 } 984 if (dev->parent_bus) { 985 bus_remove_child(dev->parent_bus, dev); 986 object_unref(OBJECT(dev->parent_bus)); 987 dev->parent_bus = NULL; 988 } 989 } 990 991 static char * 992 device_vmstate_if_get_id(VMStateIf *obj) 993 { 994 DeviceState *dev = DEVICE(obj); 995 996 return qdev_get_dev_path(dev); 997 } 998 999 /** 1000 * device_phases_reset: 1001 * Transition reset method for devices to allow moving 1002 * smoothly from legacy reset method to multi-phases 1003 */ 1004 static void device_phases_reset(DeviceState *dev) 1005 { 1006 ResettableClass *rc = RESETTABLE_GET_CLASS(dev); 1007 1008 if (rc->phases.enter) { 1009 rc->phases.enter(OBJECT(dev), RESET_TYPE_COLD); 1010 } 1011 if (rc->phases.hold) { 1012 rc->phases.hold(OBJECT(dev)); 1013 } 1014 if (rc->phases.exit) { 1015 rc->phases.exit(OBJECT(dev)); 1016 } 1017 } 1018 1019 static void device_transitional_reset(Object *obj) 1020 { 1021 DeviceClass *dc = DEVICE_GET_CLASS(obj); 1022 1023 /* 1024 * This will call either @device_phases_reset (for multi-phases transitioned 1025 * devices) or a device's specific method for not-yet transitioned devices. 1026 * In both case, it does not reset children. 1027 */ 1028 if (dc->reset) { 1029 dc->reset(DEVICE(obj)); 1030 } 1031 } 1032 1033 /** 1034 * device_get_transitional_reset: 1035 * check if the device's class is ready for multi-phase 1036 */ 1037 static ResettableTrFunction device_get_transitional_reset(Object *obj) 1038 { 1039 DeviceClass *dc = DEVICE_GET_CLASS(obj); 1040 if (dc->reset != device_phases_reset) { 1041 /* 1042 * dc->reset has been overridden by a subclass, 1043 * the device is not ready for multi phase yet. 1044 */ 1045 return device_transitional_reset; 1046 } 1047 return NULL; 1048 } 1049 1050 static void device_class_init(ObjectClass *class, void *data) 1051 { 1052 DeviceClass *dc = DEVICE_CLASS(class); 1053 VMStateIfClass *vc = VMSTATE_IF_CLASS(class); 1054 ResettableClass *rc = RESETTABLE_CLASS(class); 1055 1056 class->unparent = device_unparent; 1057 1058 /* by default all devices were considered as hotpluggable, 1059 * so with intent to check it in generic qdev_unplug() / 1060 * device_set_realized() functions make every device 1061 * hotpluggable. Devices that shouldn't be hotpluggable, 1062 * should override it in their class_init() 1063 */ 1064 dc->hotpluggable = true; 1065 dc->user_creatable = true; 1066 vc->get_id = device_vmstate_if_get_id; 1067 rc->get_state = device_get_reset_state; 1068 rc->child_foreach = device_reset_child_foreach; 1069 1070 /* 1071 * @device_phases_reset is put as the default reset method below, allowing 1072 * to do the multi-phase transition from base classes to leaf classes. It 1073 * allows a legacy-reset Device class to extend a multi-phases-reset 1074 * Device class for the following reason: 1075 * + If a base class B has been moved to multi-phase, then it does not 1076 * override this default reset method and may have defined phase methods. 1077 * + A child class C (extending class B) which uses 1078 * device_class_set_parent_reset() (or similar means) to override the 1079 * reset method will still work as expected. @device_phases_reset function 1080 * will be registered as the parent reset method and effectively call 1081 * parent reset phases. 1082 */ 1083 dc->reset = device_phases_reset; 1084 rc->get_transitional_function = device_get_transitional_reset; 1085 1086 object_class_property_add_bool(class, "realized", 1087 device_get_realized, device_set_realized); 1088 object_class_property_add_bool(class, "hotpluggable", 1089 device_get_hotpluggable, NULL); 1090 object_class_property_add_bool(class, "hotplugged", 1091 device_get_hotplugged, NULL); 1092 object_class_property_add_link(class, "parent_bus", TYPE_BUS, 1093 offsetof(DeviceState, parent_bus), NULL, 0); 1094 } 1095 1096 void device_class_set_parent_reset(DeviceClass *dc, 1097 DeviceReset dev_reset, 1098 DeviceReset *parent_reset) 1099 { 1100 *parent_reset = dc->reset; 1101 dc->reset = dev_reset; 1102 } 1103 1104 void device_class_set_parent_realize(DeviceClass *dc, 1105 DeviceRealize dev_realize, 1106 DeviceRealize *parent_realize) 1107 { 1108 *parent_realize = dc->realize; 1109 dc->realize = dev_realize; 1110 } 1111 1112 void device_class_set_parent_unrealize(DeviceClass *dc, 1113 DeviceUnrealize dev_unrealize, 1114 DeviceUnrealize *parent_unrealize) 1115 { 1116 *parent_unrealize = dc->unrealize; 1117 dc->unrealize = dev_unrealize; 1118 } 1119 1120 void device_legacy_reset(DeviceState *dev) 1121 { 1122 DeviceClass *klass = DEVICE_GET_CLASS(dev); 1123 1124 trace_qdev_reset(dev, object_get_typename(OBJECT(dev))); 1125 if (klass->reset) { 1126 klass->reset(dev); 1127 } 1128 } 1129 1130 Object *qdev_get_machine(void) 1131 { 1132 static Object *dev; 1133 1134 if (dev == NULL) { 1135 dev = container_get(object_get_root(), "/machine"); 1136 } 1137 1138 return dev; 1139 } 1140 1141 static const TypeInfo device_type_info = { 1142 .name = TYPE_DEVICE, 1143 .parent = TYPE_OBJECT, 1144 .instance_size = sizeof(DeviceState), 1145 .instance_init = device_initfn, 1146 .instance_post_init = device_post_init, 1147 .instance_finalize = device_finalize, 1148 .class_base_init = device_class_base_init, 1149 .class_init = device_class_init, 1150 .abstract = true, 1151 .class_size = sizeof(DeviceClass), 1152 .interfaces = (InterfaceInfo[]) { 1153 { TYPE_VMSTATE_IF }, 1154 { TYPE_RESETTABLE_INTERFACE }, 1155 { } 1156 } 1157 }; 1158 1159 static void qdev_register_types(void) 1160 { 1161 type_register_static(&device_type_info); 1162 } 1163 1164 type_init(qdev_register_types) 1165