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