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