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