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 "hw/qdev.h" 30 #include "hw/fw-path-provider.h" 31 #include "sysemu/sysemu.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 "hw/sysbus.h" 39 #include "qapi-event.h" 40 41 bool qdev_hotplug = false; 42 static bool qdev_hot_added = false; 43 bool qdev_hot_removed = false; 44 45 const VMStateDescription *qdev_get_vmsd(DeviceState *dev) 46 { 47 DeviceClass *dc = DEVICE_GET_CLASS(dev); 48 return dc->vmsd; 49 } 50 51 const char *qdev_fw_name(DeviceState *dev) 52 { 53 DeviceClass *dc = DEVICE_GET_CLASS(dev); 54 55 if (dc->fw_name) { 56 return dc->fw_name; 57 } 58 59 return object_get_typename(OBJECT(dev)); 60 } 61 62 static void bus_remove_child(BusState *bus, DeviceState *child) 63 { 64 BusChild *kid; 65 66 QTAILQ_FOREACH(kid, &bus->children, sibling) { 67 if (kid->child == child) { 68 char name[32]; 69 70 snprintf(name, sizeof(name), "child[%d]", kid->index); 71 QTAILQ_REMOVE(&bus->children, kid, sibling); 72 73 /* This gives back ownership of kid->child back to us. */ 74 object_property_del(OBJECT(bus), name, NULL); 75 object_unref(OBJECT(kid->child)); 76 g_free(kid); 77 return; 78 } 79 } 80 } 81 82 static void bus_add_child(BusState *bus, DeviceState *child) 83 { 84 char name[32]; 85 BusChild *kid = g_malloc0(sizeof(*kid)); 86 87 kid->index = bus->max_index++; 88 kid->child = child; 89 object_ref(OBJECT(kid->child)); 90 91 QTAILQ_INSERT_HEAD(&bus->children, kid, sibling); 92 93 /* This transfers ownership of kid->child to the property. */ 94 snprintf(name, sizeof(name), "child[%d]", kid->index); 95 object_property_add_link(OBJECT(bus), name, 96 object_get_typename(OBJECT(child)), 97 (Object **)&kid->child, 98 NULL, /* read-only property */ 99 0, /* return ownership on prop deletion */ 100 NULL); 101 } 102 103 void qdev_set_parent_bus(DeviceState *dev, BusState *bus) 104 { 105 bool replugging = dev->parent_bus != NULL; 106 107 if (replugging) { 108 /* Keep a reference to the device while it's not plugged into 109 * any bus, to avoid it potentially evaporating when it is 110 * dereffed in bus_remove_child(). 111 */ 112 object_ref(OBJECT(dev)); 113 bus_remove_child(dev->parent_bus, dev); 114 object_unref(OBJECT(dev->parent_bus)); 115 } 116 dev->parent_bus = bus; 117 object_ref(OBJECT(bus)); 118 bus_add_child(bus, dev); 119 if (replugging) { 120 object_unref(OBJECT(dev)); 121 } 122 } 123 124 /* Create a new device. This only initializes the device state 125 structure and allows properties to be set. The device still needs 126 to be realized. See qdev-core.h. */ 127 DeviceState *qdev_create(BusState *bus, const char *name) 128 { 129 DeviceState *dev; 130 131 dev = qdev_try_create(bus, name); 132 if (!dev) { 133 if (bus) { 134 error_report("Unknown device '%s' for bus '%s'", name, 135 object_get_typename(OBJECT(bus))); 136 } else { 137 error_report("Unknown device '%s' for default sysbus", name); 138 } 139 abort(); 140 } 141 142 return dev; 143 } 144 145 DeviceState *qdev_try_create(BusState *bus, const char *type) 146 { 147 DeviceState *dev; 148 149 if (object_class_by_name(type) == NULL) { 150 return NULL; 151 } 152 dev = DEVICE(object_new(type)); 153 if (!dev) { 154 return NULL; 155 } 156 157 if (!bus) { 158 /* Assert that the device really is a SysBusDevice before 159 * we put it onto the sysbus. Non-sysbus devices which aren't 160 * being put onto a bus should be created with object_new(TYPE_FOO), 161 * not qdev_create(NULL, TYPE_FOO). 162 */ 163 g_assert(object_dynamic_cast(OBJECT(dev), TYPE_SYS_BUS_DEVICE)); 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 static int qdev_reset_one(DeviceState *dev, void *opaque) 274 { 275 device_reset(dev); 276 277 return 0; 278 } 279 280 static int qbus_reset_one(BusState *bus, void *opaque) 281 { 282 BusClass *bc = BUS_GET_CLASS(bus); 283 if (bc->reset) { 284 bc->reset(bus); 285 } 286 return 0; 287 } 288 289 void qdev_reset_all(DeviceState *dev) 290 { 291 qdev_walk_children(dev, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL); 292 } 293 294 void qdev_reset_all_fn(void *opaque) 295 { 296 qdev_reset_all(DEVICE(opaque)); 297 } 298 299 void qbus_reset_all(BusState *bus) 300 { 301 qbus_walk_children(bus, NULL, NULL, qdev_reset_one, qbus_reset_one, NULL); 302 } 303 304 void qbus_reset_all_fn(void *opaque) 305 { 306 BusState *bus = opaque; 307 qbus_reset_all(bus); 308 } 309 310 /* can be used as ->unplug() callback for the simple cases */ 311 void qdev_simple_device_unplug_cb(HotplugHandler *hotplug_dev, 312 DeviceState *dev, Error **errp) 313 { 314 /* just zap it */ 315 object_unparent(OBJECT(dev)); 316 } 317 318 /* 319 * Realize @dev. 320 * Device properties should be set before calling this function. IRQs 321 * and MMIO regions should be connected/mapped after calling this 322 * function. 323 * On failure, report an error with error_report() and terminate the 324 * program. This is okay during machine creation. Don't use for 325 * hotplug, because there callers need to recover from failure. 326 * Exception: if you know the device's init() callback can't fail, 327 * then qdev_init_nofail() can't fail either, and is therefore usable 328 * even then. But relying on the device implementation that way is 329 * somewhat unclean, and best avoided. 330 */ 331 void qdev_init_nofail(DeviceState *dev) 332 { 333 Error *err = NULL; 334 335 assert(!dev->realized); 336 337 object_ref(OBJECT(dev)); 338 object_property_set_bool(OBJECT(dev), true, "realized", &err); 339 if (err) { 340 error_reportf_err(err, "Initialization of device %s failed: ", 341 object_get_typename(OBJECT(dev))); 342 exit(1); 343 } 344 object_unref(OBJECT(dev)); 345 } 346 347 void qdev_machine_creation_done(void) 348 { 349 /* 350 * ok, initial machine setup is done, starting from now we can 351 * only create hotpluggable devices 352 */ 353 qdev_hotplug = true; 354 } 355 356 bool qdev_machine_modified(void) 357 { 358 return qdev_hot_added || qdev_hot_removed; 359 } 360 361 BusState *qdev_get_parent_bus(DeviceState *dev) 362 { 363 return dev->parent_bus; 364 } 365 366 static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev, 367 const char *name) 368 { 369 NamedGPIOList *ngl; 370 371 QLIST_FOREACH(ngl, &dev->gpios, node) { 372 /* NULL is a valid and matchable name, otherwise do a normal 373 * strcmp match. 374 */ 375 if ((!ngl->name && !name) || 376 (name && ngl->name && strcmp(name, ngl->name) == 0)) { 377 return ngl; 378 } 379 } 380 381 ngl = g_malloc0(sizeof(*ngl)); 382 ngl->name = g_strdup(name); 383 QLIST_INSERT_HEAD(&dev->gpios, ngl, node); 384 return ngl; 385 } 386 387 void qdev_init_gpio_in_named(DeviceState *dev, qemu_irq_handler handler, 388 const char *name, int n) 389 { 390 int i; 391 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); 392 393 assert(gpio_list->num_out == 0 || !name); 394 gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler, 395 dev, n); 396 397 if (!name) { 398 name = "unnamed-gpio-in"; 399 } 400 for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) { 401 gchar *propname = g_strdup_printf("%s[%u]", name, i); 402 403 object_property_add_child(OBJECT(dev), propname, 404 OBJECT(gpio_list->in[i]), &error_abort); 405 g_free(propname); 406 } 407 408 gpio_list->num_in += n; 409 } 410 411 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n) 412 { 413 qdev_init_gpio_in_named(dev, handler, NULL, n); 414 } 415 416 void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins, 417 const char *name, int n) 418 { 419 int i; 420 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); 421 422 assert(gpio_list->num_in == 0 || !name); 423 424 if (!name) { 425 name = "unnamed-gpio-out"; 426 } 427 memset(pins, 0, sizeof(*pins) * n); 428 for (i = 0; i < n; ++i) { 429 gchar *propname = g_strdup_printf("%s[%u]", name, 430 gpio_list->num_out + i); 431 432 object_property_add_link(OBJECT(dev), propname, TYPE_IRQ, 433 (Object **)&pins[i], 434 object_property_allow_set_link, 435 OBJ_PROP_LINK_UNREF_ON_RELEASE, 436 &error_abort); 437 g_free(propname); 438 } 439 gpio_list->num_out += n; 440 } 441 442 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n) 443 { 444 qdev_init_gpio_out_named(dev, pins, NULL, n); 445 } 446 447 qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n) 448 { 449 NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name); 450 451 assert(n >= 0 && n < gpio_list->num_in); 452 return gpio_list->in[n]; 453 } 454 455 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n) 456 { 457 return qdev_get_gpio_in_named(dev, NULL, n); 458 } 459 460 void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n, 461 qemu_irq pin) 462 { 463 char *propname = g_strdup_printf("%s[%d]", 464 name ? name : "unnamed-gpio-out", n); 465 if (pin) { 466 /* We need a name for object_property_set_link to work. If the 467 * object has a parent, object_property_add_child will come back 468 * with an error without doing anything. If it has none, it will 469 * never fail. So we can just call it with a NULL Error pointer. 470 */ 471 object_property_add_child(container_get(qdev_get_machine(), 472 "/unattached"), 473 "non-qdev-gpio[*]", OBJECT(pin), NULL); 474 } 475 object_property_set_link(OBJECT(dev), OBJECT(pin), propname, &error_abort); 476 g_free(propname); 477 } 478 479 qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n) 480 { 481 char *propname = g_strdup_printf("%s[%d]", 482 name ? name : "unnamed-gpio-out", n); 483 484 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname, 485 NULL); 486 487 return ret; 488 } 489 490 /* disconnect a GPIO output, returning the disconnected input (if any) */ 491 492 static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev, 493 const char *name, int n) 494 { 495 char *propname = g_strdup_printf("%s[%d]", 496 name ? name : "unnamed-gpio-out", n); 497 498 qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname, 499 NULL); 500 if (ret) { 501 object_property_set_link(OBJECT(dev), NULL, propname, NULL); 502 } 503 g_free(propname); 504 return ret; 505 } 506 507 qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt, 508 const char *name, int n) 509 { 510 qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n); 511 qdev_connect_gpio_out_named(dev, name, n, icpt); 512 return disconnected; 513 } 514 515 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin) 516 { 517 qdev_connect_gpio_out_named(dev, NULL, n, pin); 518 } 519 520 void qdev_pass_gpios(DeviceState *dev, DeviceState *container, 521 const char *name) 522 { 523 int i; 524 NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name); 525 526 for (i = 0; i < ngl->num_in; i++) { 527 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in"; 528 char *propname = g_strdup_printf("%s[%d]", nm, i); 529 530 object_property_add_alias(OBJECT(container), propname, 531 OBJECT(dev), propname, 532 &error_abort); 533 g_free(propname); 534 } 535 for (i = 0; i < ngl->num_out; i++) { 536 const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out"; 537 char *propname = g_strdup_printf("%s[%d]", nm, i); 538 539 object_property_add_alias(OBJECT(container), propname, 540 OBJECT(dev), propname, 541 &error_abort); 542 g_free(propname); 543 } 544 QLIST_REMOVE(ngl, node); 545 QLIST_INSERT_HEAD(&container->gpios, ngl, node); 546 } 547 548 BusState *qdev_get_child_bus(DeviceState *dev, const char *name) 549 { 550 BusState *bus; 551 Object *child = object_resolve_path_component(OBJECT(dev), name); 552 553 bus = (BusState *)object_dynamic_cast(child, TYPE_BUS); 554 if (bus) { 555 return bus; 556 } 557 558 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 559 if (strcmp(name, bus->name) == 0) { 560 return bus; 561 } 562 } 563 return NULL; 564 } 565 566 int qdev_walk_children(DeviceState *dev, 567 qdev_walkerfn *pre_devfn, qbus_walkerfn *pre_busfn, 568 qdev_walkerfn *post_devfn, qbus_walkerfn *post_busfn, 569 void *opaque) 570 { 571 BusState *bus; 572 int err; 573 574 if (pre_devfn) { 575 err = pre_devfn(dev, opaque); 576 if (err) { 577 return err; 578 } 579 } 580 581 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 582 err = qbus_walk_children(bus, pre_devfn, pre_busfn, 583 post_devfn, post_busfn, opaque); 584 if (err < 0) { 585 return err; 586 } 587 } 588 589 if (post_devfn) { 590 err = post_devfn(dev, opaque); 591 if (err) { 592 return err; 593 } 594 } 595 596 return 0; 597 } 598 599 DeviceState *qdev_find_recursive(BusState *bus, const char *id) 600 { 601 BusChild *kid; 602 DeviceState *ret; 603 BusState *child; 604 605 QTAILQ_FOREACH(kid, &bus->children, sibling) { 606 DeviceState *dev = kid->child; 607 608 if (dev->id && strcmp(dev->id, id) == 0) { 609 return dev; 610 } 611 612 QLIST_FOREACH(child, &dev->child_bus, sibling) { 613 ret = qdev_find_recursive(child, id); 614 if (ret) { 615 return ret; 616 } 617 } 618 } 619 return NULL; 620 } 621 622 static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev) 623 { 624 BusClass *bc = BUS_GET_CLASS(bus); 625 626 if (bc->get_fw_dev_path) { 627 return bc->get_fw_dev_path(dev); 628 } 629 630 return NULL; 631 } 632 633 static char *qdev_get_fw_dev_path_from_handler(BusState *bus, DeviceState *dev) 634 { 635 Object *obj = OBJECT(dev); 636 char *d = NULL; 637 638 while (!d && obj->parent) { 639 obj = obj->parent; 640 d = fw_path_provider_try_get_dev_path(obj, bus, dev); 641 } 642 return d; 643 } 644 645 char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev) 646 { 647 Object *obj = OBJECT(dev); 648 649 return fw_path_provider_try_get_dev_path(obj, bus, dev); 650 } 651 652 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size) 653 { 654 int l = 0; 655 656 if (dev && dev->parent_bus) { 657 char *d; 658 l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size); 659 d = qdev_get_fw_dev_path_from_handler(dev->parent_bus, dev); 660 if (!d) { 661 d = bus_get_fw_dev_path(dev->parent_bus, dev); 662 } 663 if (d) { 664 l += snprintf(p + l, size - l, "%s", d); 665 g_free(d); 666 } else { 667 return l; 668 } 669 } 670 l += snprintf(p + l , size - l, "/"); 671 672 return l; 673 } 674 675 char* qdev_get_fw_dev_path(DeviceState *dev) 676 { 677 char path[128]; 678 int l; 679 680 l = qdev_get_fw_dev_path_helper(dev, path, 128); 681 682 path[l-1] = '\0'; 683 684 return g_strdup(path); 685 } 686 687 char *qdev_get_dev_path(DeviceState *dev) 688 { 689 BusClass *bc; 690 691 if (!dev || !dev->parent_bus) { 692 return NULL; 693 } 694 695 bc = BUS_GET_CLASS(dev->parent_bus); 696 if (bc->get_dev_path) { 697 return bc->get_dev_path(dev); 698 } 699 700 return NULL; 701 } 702 703 /** 704 * Legacy property handling 705 */ 706 707 static void qdev_get_legacy_property(Object *obj, Visitor *v, 708 const char *name, void *opaque, 709 Error **errp) 710 { 711 DeviceState *dev = DEVICE(obj); 712 Property *prop = opaque; 713 714 char buffer[1024]; 715 char *ptr = buffer; 716 717 prop->info->print(dev, prop, buffer, sizeof(buffer)); 718 visit_type_str(v, name, &ptr, errp); 719 } 720 721 /** 722 * qdev_property_add_legacy: 723 * @dev: Device to add the property to. 724 * @prop: The qdev property definition. 725 * @errp: location to store error information. 726 * 727 * Add a legacy QOM property to @dev for qdev property @prop. 728 * On error, store error in @errp. 729 * 730 * Legacy properties are string versions of QOM properties. The format of 731 * the string depends on the property type. Legacy properties are only 732 * needed for "info qtree". 733 * 734 * Do not use this is new code! QOM Properties added through this interface 735 * will be given names in the "legacy" namespace. 736 */ 737 static void qdev_property_add_legacy(DeviceState *dev, Property *prop, 738 Error **errp) 739 { 740 gchar *name; 741 742 /* Register pointer properties as legacy properties */ 743 if (!prop->info->print && prop->info->get) { 744 return; 745 } 746 747 name = g_strdup_printf("legacy-%s", prop->name); 748 object_property_add(OBJECT(dev), name, "str", 749 prop->info->print ? qdev_get_legacy_property : prop->info->get, 750 NULL, 751 NULL, 752 prop, errp); 753 754 g_free(name); 755 } 756 757 /** 758 * qdev_property_add_static: 759 * @dev: Device to add the property to. 760 * @prop: The qdev property definition. 761 * @errp: location to store error information. 762 * 763 * Add a static QOM property to @dev for qdev property @prop. 764 * On error, store error in @errp. Static properties access data in a struct. 765 * The type of the QOM property is derived from prop->info. 766 */ 767 void qdev_property_add_static(DeviceState *dev, Property *prop, 768 Error **errp) 769 { 770 Error *local_err = NULL; 771 Object *obj = OBJECT(dev); 772 773 /* 774 * TODO qdev_prop_ptr does not have getters or setters. It must 775 * go now that it can be replaced with links. The test should be 776 * removed along with it: all static properties are read/write. 777 */ 778 if (!prop->info->get && !prop->info->set) { 779 return; 780 } 781 782 object_property_add(obj, prop->name, prop->info->name, 783 prop->info->get, prop->info->set, 784 prop->info->release, 785 prop, &local_err); 786 787 if (local_err) { 788 error_propagate(errp, local_err); 789 return; 790 } 791 792 object_property_set_description(obj, prop->name, 793 prop->info->description, 794 &error_abort); 795 796 if (prop->qtype == QTYPE_NONE) { 797 return; 798 } 799 800 if (prop->qtype == QTYPE_QBOOL) { 801 object_property_set_bool(obj, prop->defval, prop->name, &error_abort); 802 } else if (prop->info->enum_table) { 803 object_property_set_str(obj, prop->info->enum_table[prop->defval], 804 prop->name, &error_abort); 805 } else if (prop->qtype == QTYPE_QINT) { 806 object_property_set_int(obj, prop->defval, prop->name, &error_abort); 807 } 808 } 809 810 /* @qdev_alias_all_properties - Add alias properties to the source object for 811 * all qdev properties on the target DeviceState. 812 */ 813 void qdev_alias_all_properties(DeviceState *target, Object *source) 814 { 815 ObjectClass *class; 816 Property *prop; 817 818 class = object_get_class(OBJECT(target)); 819 do { 820 DeviceClass *dc = DEVICE_CLASS(class); 821 822 for (prop = dc->props; prop && prop->name; prop++) { 823 object_property_add_alias(source, prop->name, 824 OBJECT(target), prop->name, 825 &error_abort); 826 } 827 class = object_class_get_parent(class); 828 } while (class != object_class_by_name(TYPE_DEVICE)); 829 } 830 831 static int qdev_add_hotpluggable_device(Object *obj, void *opaque) 832 { 833 GSList **list = opaque; 834 DeviceState *dev = (DeviceState *)object_dynamic_cast(OBJECT(obj), 835 TYPE_DEVICE); 836 837 if (dev == NULL) { 838 return 0; 839 } 840 841 if (dev->realized && object_property_get_bool(obj, "hotpluggable", NULL)) { 842 *list = g_slist_append(*list, dev); 843 } 844 845 return 0; 846 } 847 848 GSList *qdev_build_hotpluggable_device_list(Object *peripheral) 849 { 850 GSList *list = NULL; 851 852 object_child_foreach(peripheral, qdev_add_hotpluggable_device, &list); 853 854 return list; 855 } 856 857 static bool device_get_realized(Object *obj, Error **errp) 858 { 859 DeviceState *dev = DEVICE(obj); 860 return dev->realized; 861 } 862 863 static bool check_only_migratable(Object *obj, Error **err) 864 { 865 DeviceClass *dc = DEVICE_GET_CLASS(obj); 866 867 if (!vmstate_check_only_migratable(dc->vmsd)) { 868 error_setg(err, "Device %s is not migratable, but " 869 "--only-migratable was specified", 870 object_get_typename(obj)); 871 return false; 872 } 873 874 return true; 875 } 876 877 static void device_set_realized(Object *obj, bool value, Error **errp) 878 { 879 DeviceState *dev = DEVICE(obj); 880 DeviceClass *dc = DEVICE_GET_CLASS(dev); 881 HotplugHandler *hotplug_ctrl; 882 BusState *bus; 883 Error *local_err = NULL; 884 bool unattached_parent = false; 885 static int unattached_count; 886 887 if (dev->hotplugged && !dc->hotpluggable) { 888 error_setg(errp, QERR_DEVICE_NO_HOTPLUG, object_get_typename(obj)); 889 return; 890 } 891 892 if (value && !dev->realized) { 893 if (!check_only_migratable(obj, &local_err)) { 894 goto fail; 895 } 896 897 if (!obj->parent) { 898 gchar *name = g_strdup_printf("device[%d]", unattached_count++); 899 900 object_property_add_child(container_get(qdev_get_machine(), 901 "/unattached"), 902 name, obj, &error_abort); 903 unattached_parent = true; 904 g_free(name); 905 } 906 907 hotplug_ctrl = qdev_get_hotplug_handler(dev); 908 if (hotplug_ctrl) { 909 hotplug_handler_pre_plug(hotplug_ctrl, dev, &local_err); 910 if (local_err != NULL) { 911 goto fail; 912 } 913 } 914 915 if (dc->realize) { 916 dc->realize(dev, &local_err); 917 } 918 919 if (local_err != NULL) { 920 goto fail; 921 } 922 923 DEVICE_LISTENER_CALL(realize, Forward, dev); 924 925 if (hotplug_ctrl) { 926 hotplug_handler_plug(hotplug_ctrl, dev, &local_err); 927 } 928 929 if (local_err != NULL) { 930 goto post_realize_fail; 931 } 932 933 if (qdev_get_vmsd(dev)) { 934 if (vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev, 935 dev->instance_id_alias, 936 dev->alias_required_for_version, 937 &local_err) < 0) { 938 goto post_realize_fail; 939 } 940 } 941 942 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 943 object_property_set_bool(OBJECT(bus), true, "realized", 944 &local_err); 945 if (local_err != NULL) { 946 goto child_realize_fail; 947 } 948 } 949 if (dev->hotplugged) { 950 device_reset(dev); 951 } 952 dev->pending_deleted_event = false; 953 } else if (!value && dev->realized) { 954 Error **local_errp = NULL; 955 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 956 local_errp = local_err ? NULL : &local_err; 957 object_property_set_bool(OBJECT(bus), false, "realized", 958 local_errp); 959 } 960 if (qdev_get_vmsd(dev)) { 961 vmstate_unregister(dev, qdev_get_vmsd(dev), dev); 962 } 963 if (dc->unrealize) { 964 local_errp = local_err ? NULL : &local_err; 965 dc->unrealize(dev, local_errp); 966 } 967 dev->pending_deleted_event = true; 968 DEVICE_LISTENER_CALL(unrealize, Reverse, dev); 969 } 970 971 if (local_err != NULL) { 972 goto fail; 973 } 974 975 dev->realized = value; 976 return; 977 978 child_realize_fail: 979 QLIST_FOREACH(bus, &dev->child_bus, sibling) { 980 object_property_set_bool(OBJECT(bus), false, "realized", 981 NULL); 982 } 983 984 if (qdev_get_vmsd(dev)) { 985 vmstate_unregister(dev, qdev_get_vmsd(dev), dev); 986 } 987 988 post_realize_fail: 989 if (dc->unrealize) { 990 dc->unrealize(dev, NULL); 991 } 992 993 fail: 994 error_propagate(errp, local_err); 995 if (unattached_parent) { 996 object_unparent(OBJECT(dev)); 997 unattached_count--; 998 } 999 } 1000 1001 static bool device_get_hotpluggable(Object *obj, Error **errp) 1002 { 1003 DeviceClass *dc = DEVICE_GET_CLASS(obj); 1004 DeviceState *dev = DEVICE(obj); 1005 1006 return dc->hotpluggable && (dev->parent_bus == NULL || 1007 qbus_is_hotpluggable(dev->parent_bus)); 1008 } 1009 1010 static bool device_get_hotplugged(Object *obj, Error **err) 1011 { 1012 DeviceState *dev = DEVICE(obj); 1013 1014 return dev->hotplugged; 1015 } 1016 1017 static void device_initfn(Object *obj) 1018 { 1019 DeviceState *dev = DEVICE(obj); 1020 ObjectClass *class; 1021 Property *prop; 1022 1023 if (qdev_hotplug) { 1024 dev->hotplugged = 1; 1025 qdev_hot_added = true; 1026 } 1027 1028 dev->instance_id_alias = -1; 1029 dev->realized = false; 1030 1031 object_property_add_bool(obj, "realized", 1032 device_get_realized, device_set_realized, NULL); 1033 object_property_add_bool(obj, "hotpluggable", 1034 device_get_hotpluggable, NULL, NULL); 1035 object_property_add_bool(obj, "hotplugged", 1036 device_get_hotplugged, NULL, 1037 &error_abort); 1038 1039 class = object_get_class(OBJECT(dev)); 1040 do { 1041 for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) { 1042 qdev_property_add_legacy(dev, prop, &error_abort); 1043 qdev_property_add_static(dev, prop, &error_abort); 1044 } 1045 class = object_class_get_parent(class); 1046 } while (class != object_class_by_name(TYPE_DEVICE)); 1047 1048 object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS, 1049 (Object **)&dev->parent_bus, NULL, 0, 1050 &error_abort); 1051 QLIST_INIT(&dev->gpios); 1052 } 1053 1054 static void device_post_init(Object *obj) 1055 { 1056 qdev_prop_set_globals(DEVICE(obj)); 1057 } 1058 1059 /* Unlink device from bus and free the structure. */ 1060 static void device_finalize(Object *obj) 1061 { 1062 NamedGPIOList *ngl, *next; 1063 1064 DeviceState *dev = DEVICE(obj); 1065 1066 QLIST_FOREACH_SAFE(ngl, &dev->gpios, node, next) { 1067 QLIST_REMOVE(ngl, node); 1068 qemu_free_irqs(ngl->in, ngl->num_in); 1069 g_free(ngl->name); 1070 g_free(ngl); 1071 /* ngl->out irqs are owned by the other end and should not be freed 1072 * here 1073 */ 1074 } 1075 } 1076 1077 static void device_class_base_init(ObjectClass *class, void *data) 1078 { 1079 DeviceClass *klass = DEVICE_CLASS(class); 1080 1081 /* We explicitly look up properties in the superclasses, 1082 * so do not propagate them to the subclasses. 1083 */ 1084 klass->props = NULL; 1085 } 1086 1087 static void device_unparent(Object *obj) 1088 { 1089 DeviceState *dev = DEVICE(obj); 1090 BusState *bus; 1091 1092 if (dev->realized) { 1093 object_property_set_bool(obj, false, "realized", NULL); 1094 } 1095 while (dev->num_child_bus) { 1096 bus = QLIST_FIRST(&dev->child_bus); 1097 object_unparent(OBJECT(bus)); 1098 } 1099 if (dev->parent_bus) { 1100 bus_remove_child(dev->parent_bus, dev); 1101 object_unref(OBJECT(dev->parent_bus)); 1102 dev->parent_bus = NULL; 1103 } 1104 1105 /* Only send event if the device had been completely realized */ 1106 if (dev->pending_deleted_event) { 1107 gchar *path = object_get_canonical_path(OBJECT(dev)); 1108 1109 qapi_event_send_device_deleted(!!dev->id, dev->id, path, &error_abort); 1110 g_free(path); 1111 } 1112 1113 qemu_opts_del(dev->opts); 1114 dev->opts = NULL; 1115 } 1116 1117 static void device_class_init(ObjectClass *class, void *data) 1118 { 1119 DeviceClass *dc = DEVICE_CLASS(class); 1120 1121 class->unparent = device_unparent; 1122 dc->realize = device_realize; 1123 dc->unrealize = device_unrealize; 1124 1125 /* by default all devices were considered as hotpluggable, 1126 * so with intent to check it in generic qdev_unplug() / 1127 * device_set_realized() functions make every device 1128 * hotpluggable. Devices that shouldn't be hotpluggable, 1129 * should override it in their class_init() 1130 */ 1131 dc->hotpluggable = true; 1132 dc->user_creatable = true; 1133 } 1134 1135 void device_reset(DeviceState *dev) 1136 { 1137 DeviceClass *klass = DEVICE_GET_CLASS(dev); 1138 1139 if (klass->reset) { 1140 klass->reset(dev); 1141 } 1142 } 1143 1144 Object *qdev_get_machine(void) 1145 { 1146 static Object *dev; 1147 1148 if (dev == NULL) { 1149 dev = container_get(object_get_root(), "/machine"); 1150 } 1151 1152 return dev; 1153 } 1154 1155 static const TypeInfo device_type_info = { 1156 .name = TYPE_DEVICE, 1157 .parent = TYPE_OBJECT, 1158 .instance_size = sizeof(DeviceState), 1159 .instance_init = device_initfn, 1160 .instance_post_init = device_post_init, 1161 .instance_finalize = device_finalize, 1162 .class_base_init = device_class_base_init, 1163 .class_init = device_class_init, 1164 .abstract = true, 1165 .class_size = sizeof(DeviceClass), 1166 }; 1167 1168 static void qdev_register_types(void) 1169 { 1170 type_register_static(&device_type_info); 1171 } 1172 1173 type_init(qdev_register_types) 1174