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