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