hw/qdev.c

   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 "net.h"
  29 #include "qdev.h"
  30 #include "sysemu.h"
  31 #include "monitor.h"
  32
  33 static int qdev_hotplug = 0;
  34 static bool qdev_hot_added = false;
  35 static bool qdev_hot_removed = false;
  36
  37 /* This is a nasty hack to allow passing a NULL bus to qdev_create.  */
  38 static BusState *main_system_bus;
  39 static void main_system_bus_create(void);
  40
  41 DeviceInfo *device_info_list;
  42
  43 static BusState *qbus_find_recursive(BusState *bus, const char *name,
  44                                      const BusInfo *info);
  45 static BusState *qbus_find(const char *path);
  46
  47 /* Register a new device type.  */
  48 void qdev_register(DeviceInfo *info)
  49 {
  50     assert(info->size >= sizeof(DeviceState));
  51     assert(!info->next);
  52
  53     info->next = device_info_list;
  54     device_info_list = info;
  55 }
  56
  57 static DeviceInfo *qdev_find_info(BusInfo *bus_info, const char *name)
  58 {
  59     DeviceInfo *info;
  60
  61     /* first check device names */
  62     for (info = device_info_list; info != NULL; info = info->next) {
  63         if (bus_info && info->bus_info != bus_info)
  64             continue;
  65         if (strcmp(info->name, name) != 0)
  66             continue;
  67         return info;
  68     }
  69
  70     /* failing that check the aliases */
  71     for (info = device_info_list; info != NULL; info = info->next) {
  72         if (bus_info && info->bus_info != bus_info)
  73             continue;
  74         if (!info->alias)
  75             continue;
  76         if (strcmp(info->alias, name) != 0)
  77             continue;
  78         return info;
  79     }
  80     return NULL;
  81 }
  82
  83 static DeviceState *qdev_create_from_info(BusState *bus, DeviceInfo *info)
  84 {
  85     DeviceState *dev;
  86
  87     assert(bus->info == info->bus_info);
  88     dev = g_malloc0(info->size);
  89     dev->info = info;
  90     dev->parent_bus = bus;
  91     qdev_prop_set_defaults(dev, dev->info->props);
  92     qdev_prop_set_defaults(dev, dev->parent_bus->info->props);
  93     qdev_prop_set_globals(dev);
  94     QTAILQ_INSERT_HEAD(&bus->children, dev, sibling);
  95     if (qdev_hotplug) {
  96         assert(bus->allow_hotplug);
  97         dev->hotplugged = 1;
  98         qdev_hot_added = true;
  99     }
 100     dev->instance_id_alias = -1;
 101     dev->state = DEV_STATE_CREATED;
 102     return dev;
 103 }
 104
 105 /* Create a new device.  This only initializes the device state structure
 106    and allows properties to be set.  qdev_init should be called to
 107    initialize the actual device emulation.  */
 108 DeviceState *qdev_create(BusState *bus, const char *name)
 109 {
 110     DeviceState *dev;
 111
 112     dev = qdev_try_create(bus, name);
 113     if (!dev) {
 114         if (bus) {
 115             hw_error("Unknown device '%s' for bus '%s'\n", name,
 116                      bus->info->name);
 117         } else {
 118             hw_error("Unknown device '%s' for default sysbus\n", name);
 119         }
 120     }
 121
 122     return dev;
 123 }
 124
 125 DeviceState *qdev_try_create(BusState *bus, const char *name)
 126 {
 127     DeviceInfo *info;
 128
 129     if (!bus) {
 130         bus = sysbus_get_default();
 131     }
 132
 133     info = qdev_find_info(bus->info, name);
 134     if (!info) {
 135         return NULL;
 136     }
 137
 138     return qdev_create_from_info(bus, info);
 139 }
 140
 141 static void qdev_print_devinfo(DeviceInfo *info)
 142 {
 143     error_printf("name \"%s\", bus %s",
 144                  info->name, info->bus_info->name);
 145     if (info->alias) {
 146         error_printf(", alias \"%s\"", info->alias);
 147     }
 148     if (info->desc) {
 149         error_printf(", desc \"%s\"", info->desc);
 150     }
 151     if (info->no_user) {
 152         error_printf(", no-user");
 153     }
 154     error_printf("\n");
 155 }
 156
 157 static int set_property(const char *name, const char *value, void *opaque)
 158 {
 159     DeviceState *dev = opaque;
 160
 161     if (strcmp(name, "driver") == 0)
 162         return 0;
 163     if (strcmp(name, "bus") == 0)
 164         return 0;
 165
 166     if (qdev_prop_parse(dev, name, value) == -1) {
 167         return -1;
 168     }
 169     return 0;
 170 }
 171
 172 int qdev_device_help(QemuOpts *opts)
 173 {
 174     const char *driver;
 175     DeviceInfo *info;
 176     Property *prop;
 177
 178     driver = qemu_opt_get(opts, "driver");
 179     if (driver && !strcmp(driver, "?")) {
 180         for (info = device_info_list; info != NULL; info = info->next) {
 181             if (info->no_user) {
 182                 continue;       /* not available, don't show */
 183             }
 184             qdev_print_devinfo(info);
 185         }
 186         return 1;
 187     }
 188
 189     if (!driver || !qemu_opt_get(opts, "?")) {
 190         return 0;
 191     }
 192
 193     info = qdev_find_info(NULL, driver);
 194     if (!info) {
 195         return 0;
 196     }
 197
 198     for (prop = info->props; prop && prop->name; prop++) {
 199         /*
 200          * TODO Properties without a parser are just for dirty hacks.
 201          * qdev_prop_ptr is the only such PropertyInfo.  It's marked
 202          * for removal.  This conditional should be removed along with
 203          * it.
 204          */
 205         if (!prop->info->parse) {
 206             continue;           /* no way to set it, don't show */
 207         }
 208         error_printf("%s.%s=%s\n", info->name, prop->name, prop->info->name);
 209     }
 210     for (prop = info->bus_info->props; prop && prop->name; prop++) {
 211         if (!prop->info->parse) {
 212             continue;           /* no way to set it, don't show */
 213         }
 214         error_printf("%s.%s=%s\n", info->name, prop->name, prop->info->name);
 215     }
 216     return 1;
 217 }
 218
 219 DeviceState *qdev_device_add(QemuOpts *opts)
 220 {
 221     const char *driver, *path, *id;
 222     DeviceInfo *info;
 223     DeviceState *qdev;
 224     BusState *bus;
 225
 226     driver = qemu_opt_get(opts, "driver");
 227     if (!driver) {
 228         qerror_report(QERR_MISSING_PARAMETER, "driver");
 229         return NULL;
 230     }
 231
 232     /* find driver */
 233     info = qdev_find_info(NULL, driver);
 234     if (!info || info->no_user) {
 235         qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", "a driver name");
 236         error_printf_unless_qmp("Try with argument '?' for a list.\n");
 237         return NULL;
 238     }
 239
 240     /* find bus */
 241     path = qemu_opt_get(opts, "bus");
 242     if (path != NULL) {
 243         bus = qbus_find(path);
 244         if (!bus) {
 245             return NULL;
 246         }
 247         if (bus->info != info->bus_info) {
 248             qerror_report(QERR_BAD_BUS_FOR_DEVICE,
 249                            driver, bus->info->name);
 250             return NULL;
 251         }
 252     } else {
 253         bus = qbus_find_recursive(main_system_bus, NULL, info->bus_info);
 254         if (!bus) {
 255             qerror_report(QERR_NO_BUS_FOR_DEVICE,
 256                            info->name, info->bus_info->name);
 257             return NULL;
 258         }
 259     }
 260     if (qdev_hotplug && !bus->allow_hotplug) {
 261         qerror_report(QERR_BUS_NO_HOTPLUG, bus->name);
 262         return NULL;
 263     }
 264
 265     /* create device, set properties */
 266     qdev = qdev_create_from_info(bus, info);
 267     id = qemu_opts_id(opts);
 268     if (id) {
 269         qdev->id = id;
 270     }
 271     if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) {
 272         qdev_free(qdev);
 273         return NULL;
 274     }
 275     if (qdev_init(qdev) < 0) {
 276         qerror_report(QERR_DEVICE_INIT_FAILED, driver);
 277         return NULL;
 278     }
 279     qdev->opts = opts;
 280     return qdev;
 281 }
 282
 283 /* Initialize a device.  Device properties should be set before calling
 284    this function.  IRQs and MMIO regions should be connected/mapped after
 285    calling this function.
 286    On failure, destroy the device and return negative value.
 287    Return 0 on success.  */
 288 int qdev_init(DeviceState *dev)
 289 {
 290     int rc;
 291
 292     assert(dev->state == DEV_STATE_CREATED);
 293     rc = dev->info->init(dev, dev->info);
 294     if (rc < 0) {
 295         qdev_free(dev);
 296         return rc;
 297     }
 298     if (dev->info->vmsd) {
 299         vmstate_register_with_alias_id(dev, -1, dev->info->vmsd, dev,
 300                                        dev->instance_id_alias,
 301                                        dev->alias_required_for_version);
 302     }
 303     dev->state = DEV_STATE_INITIALIZED;
 304     if (dev->hotplugged && dev->info->reset) {
 305         dev->info->reset(dev);
 306     }
 307     return 0;
 308 }
 309
 310 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
 311                                  int required_for_version)
 312 {
 313     assert(dev->state == DEV_STATE_CREATED);
 314     dev->instance_id_alias = alias_id;
 315     dev->alias_required_for_version = required_for_version;
 316 }
 317
 318 int qdev_unplug(DeviceState *dev)
 319 {
 320     if (!dev->parent_bus->allow_hotplug) {
 321         qerror_report(QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
 322         return -1;
 323     }
 324     assert(dev->info->unplug != NULL);
 325
 326     qdev_hot_removed = true;
 327
 328     return dev->info->unplug(dev);
 329 }
 330
 331 static int qdev_reset_one(DeviceState *dev, void *opaque)
 332 {
 333     if (dev->info->reset) {
 334         dev->info->reset(dev);
 335     }
 336
 337     return 0;
 338 }
 339
 340 BusState *sysbus_get_default(void)
 341 {
 342     if (!main_system_bus) {
 343         main_system_bus_create();
 344     }
 345     return main_system_bus;
 346 }
 347
 348 static int qbus_reset_one(BusState *bus, void *opaque)
 349 {
 350     if (bus->info->reset) {
 351         return bus->info->reset(bus);
 352     }
 353     return 0;
 354 }
 355
 356 void qdev_reset_all(DeviceState *dev)
 357 {
 358     qdev_walk_children(dev, qdev_reset_one, qbus_reset_one, NULL);
 359 }
 360
 361 void qbus_reset_all_fn(void *opaque)
 362 {
 363     BusState *bus = opaque;
 364     qbus_walk_children(bus, qdev_reset_one, qbus_reset_one, NULL);
 365 }
 366
 367 /* can be used as ->unplug() callback for the simple cases */
 368 int qdev_simple_unplug_cb(DeviceState *dev)
 369 {
 370     /* just zap it */
 371     qdev_free(dev);
 372     return 0;
 373 }
 374
 375
 376 /* Like qdev_init(), but terminate program via error_report() instead of
 377    returning an error value.  This is okay during machine creation.
 378    Don't use for hotplug, because there callers need to recover from
 379    failure.  Exception: if you know the device's init() callback can't
 380    fail, then qdev_init_nofail() can't fail either, and is therefore
 381    usable even then.  But relying on the device implementation that
 382    way is somewhat unclean, and best avoided.  */
 383 void qdev_init_nofail(DeviceState *dev)
 384 {
 385     DeviceInfo *info = dev->info;
 386
 387     if (qdev_init(dev) < 0) {
 388         error_report("Initialization of device %s failed", info->name);
 389         exit(1);
 390     }
 391 }
 392
 393 /* Unlink device from bus and free the structure.  */
 394 void qdev_free(DeviceState *dev)
 395 {
 396     BusState *bus;
 397     Property *prop;
 398
 399     if (dev->state == DEV_STATE_INITIALIZED) {
 400         while (dev->num_child_bus) {
 401             bus = QLIST_FIRST(&dev->child_bus);
 402             qbus_free(bus);
 403         }
 404         if (dev->info->vmsd)
 405             vmstate_unregister(dev, dev->info->vmsd, dev);
 406         if (dev->info->exit)
 407             dev->info->exit(dev);
 408         if (dev->opts)
 409             qemu_opts_del(dev->opts);
 410     }
 411     QTAILQ_REMOVE(&dev->parent_bus->children, dev, sibling);
 412     for (prop = dev->info->props; prop && prop->name; prop++) {
 413         if (prop->info->free) {
 414             prop->info->free(dev, prop);
 415         }
 416     }
 417     g_free(dev);
 418 }
 419
 420 void qdev_machine_creation_done(void)
 421 {
 422     /*
 423      * ok, initial machine setup is done, starting from now we can
 424      * only create hotpluggable devices
 425      */
 426     qdev_hotplug = 1;
 427 }
 428
 429 bool qdev_machine_modified(void)
 430 {
 431     return qdev_hot_added || qdev_hot_removed;
 432 }
 433
 434 /* Get a character (serial) device interface.  */
 435 CharDriverState *qdev_init_chardev(DeviceState *dev)
 436 {
 437     static int next_serial;
 438
 439     /* FIXME: This function needs to go away: use chardev properties!  */
 440     return serial_hds[next_serial++];
 441 }
 442
 443 BusState *qdev_get_parent_bus(DeviceState *dev)
 444 {
 445     return dev->parent_bus;
 446 }
 447
 448 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
 449 {
 450     assert(dev->num_gpio_in == 0);
 451     dev->num_gpio_in = n;
 452     dev->gpio_in = qemu_allocate_irqs(handler, dev, n);
 453 }
 454
 455 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
 456 {
 457     assert(dev->num_gpio_out == 0);
 458     dev->num_gpio_out = n;
 459     dev->gpio_out = pins;
 460 }
 461
 462 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
 463 {
 464     assert(n >= 0 && n < dev->num_gpio_in);
 465     return dev->gpio_in[n];
 466 }
 467
 468 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
 469 {
 470     assert(n >= 0 && n < dev->num_gpio_out);
 471     dev->gpio_out[n] = pin;
 472 }
 473
 474 void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
 475 {
 476     qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
 477     if (nd->vlan)
 478         qdev_prop_set_vlan(dev, "vlan", nd->vlan);
 479     if (nd->netdev)
 480         qdev_prop_set_netdev(dev, "netdev", nd->netdev);
 481     if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
 482         qdev_prop_exists(dev, "vectors")) {
 483         qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
 484     }
 485     nd->instantiated = 1;
 486 }
 487
 488 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 489 {
 490     BusState *bus;
 491
 492     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 493         if (strcmp(name, bus->name) == 0) {
 494             return bus;
 495         }
 496     }
 497     return NULL;
 498 }
 499
 500 int qbus_walk_children(BusState *bus, qdev_walkerfn *devfn,
 501                        qbus_walkerfn *busfn, void *opaque)
 502 {
 503     DeviceState *dev;
 504     int err;
 505
 506     if (busfn) {
 507         err = busfn(bus, opaque);
 508         if (err) {
 509             return err;
 510         }
 511     }
 512
 513     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 514         err = qdev_walk_children(dev, devfn, busfn, opaque);
 515         if (err < 0) {
 516             return err;
 517         }
 518     }
 519
 520     return 0;
 521 }
 522
 523 int qdev_walk_children(DeviceState *dev, qdev_walkerfn *devfn,
 524                        qbus_walkerfn *busfn, void *opaque)
 525 {
 526     BusState *bus;
 527     int err;
 528
 529     if (devfn) {
 530         err = devfn(dev, opaque);
 531         if (err) {
 532             return err;
 533         }
 534     }
 535
 536     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 537         err = qbus_walk_children(bus, devfn, busfn, opaque);
 538         if (err < 0) {
 539             return err;
 540         }
 541     }
 542
 543     return 0;
 544 }
 545
 546 static BusState *qbus_find_recursive(BusState *bus, const char *name,
 547                                      const BusInfo *info)
 548 {
 549     DeviceState *dev;
 550     BusState *child, *ret;
 551     int match = 1;
 552
 553     if (name && (strcmp(bus->name, name) != 0)) {
 554         match = 0;
 555     }
 556     if (info && (bus->info != info)) {
 557         match = 0;
 558     }
 559     if (match) {
 560         return bus;
 561     }
 562
 563     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 564         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 565             ret = qbus_find_recursive(child, name, info);
 566             if (ret) {
 567                 return ret;
 568             }
 569         }
 570     }
 571     return NULL;
 572 }
 573
 574 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 575 {
 576     DeviceState *dev, *ret;
 577     BusState *child;
 578
 579     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 580         if (dev->id && strcmp(dev->id, id) == 0)
 581             return dev;
 582         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 583             ret = qdev_find_recursive(child, id);
 584             if (ret) {
 585                 return ret;
 586             }
 587         }
 588     }
 589     return NULL;
 590 }
 591
 592 static void qbus_list_bus(DeviceState *dev)
 593 {
 594     BusState *child;
 595     const char *sep = " ";
 596
 597     error_printf("child busses at \"%s\":",
 598                  dev->id ? dev->id : dev->info->name);
 599     QLIST_FOREACH(child, &dev->child_bus, sibling) {
 600         error_printf("%s\"%s\"", sep, child->name);
 601         sep = ", ";
 602     }
 603     error_printf("\n");
 604 }
 605
 606 static void qbus_list_dev(BusState *bus)
 607 {
 608     DeviceState *dev;
 609     const char *sep = " ";
 610
 611     error_printf("devices at \"%s\":", bus->name);
 612     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 613         error_printf("%s\"%s\"", sep, dev->info->name);
 614         if (dev->id)
 615             error_printf("/\"%s\"", dev->id);
 616         sep = ", ";
 617     }
 618     error_printf("\n");
 619 }
 620
 621 static BusState *qbus_find_bus(DeviceState *dev, char *elem)
 622 {
 623     BusState *child;
 624
 625     QLIST_FOREACH(child, &dev->child_bus, sibling) {
 626         if (strcmp(child->name, elem) == 0) {
 627             return child;
 628         }
 629     }
 630     return NULL;
 631 }
 632
 633 static DeviceState *qbus_find_dev(BusState *bus, char *elem)
 634 {
 635     DeviceState *dev;
 636
 637     /*
 638      * try to match in order:
 639      *   (1) instance id, if present
 640      *   (2) driver name
 641      *   (3) driver alias, if present
 642      */
 643     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 644         if (dev->id  &&  strcmp(dev->id, elem) == 0) {
 645             return dev;
 646         }
 647     }
 648     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 649         if (strcmp(dev->info->name, elem) == 0) {
 650             return dev;
 651         }
 652     }
 653     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 654         if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) {
 655             return dev;
 656         }
 657     }
 658     return NULL;
 659 }
 660
 661 static BusState *qbus_find(const char *path)
 662 {
 663     DeviceState *dev;
 664     BusState *bus;
 665     char elem[128];
 666     int pos, len;
 667
 668     /* find start element */
 669     if (path[0] == '/') {
 670         bus = main_system_bus;
 671         pos = 0;
 672     } else {
 673         if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
 674             assert(!path[0]);
 675             elem[0] = len = 0;
 676         }
 677         bus = qbus_find_recursive(main_system_bus, elem, NULL);
 678         if (!bus) {
 679             qerror_report(QERR_BUS_NOT_FOUND, elem);
 680             return NULL;
 681         }
 682         pos = len;
 683     }
 684
 685     for (;;) {
 686         assert(path[pos] == '/' || !path[pos]);
 687         while (path[pos] == '/') {
 688             pos++;
 689         }
 690         if (path[pos] == '\0') {
 691             return bus;
 692         }
 693
 694         /* find device */
 695         if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
 696             assert(0);
 697             elem[0] = len = 0;
 698         }
 699         pos += len;
 700         dev = qbus_find_dev(bus, elem);
 701         if (!dev) {
 702             qerror_report(QERR_DEVICE_NOT_FOUND, elem);
 703             if (!monitor_cur_is_qmp()) {
 704                 qbus_list_dev(bus);
 705             }
 706             return NULL;
 707         }
 708
 709         assert(path[pos] == '/' || !path[pos]);
 710         while (path[pos] == '/') {
 711             pos++;
 712         }
 713         if (path[pos] == '\0') {
 714             /* last specified element is a device.  If it has exactly
 715              * one child bus accept it nevertheless */
 716             switch (dev->num_child_bus) {
 717             case 0:
 718                 qerror_report(QERR_DEVICE_NO_BUS, elem);
 719                 return NULL;
 720             case 1:
 721                 return QLIST_FIRST(&dev->child_bus);
 722             default:
 723                 qerror_report(QERR_DEVICE_MULTIPLE_BUSSES, elem);
 724                 if (!monitor_cur_is_qmp()) {
 725                     qbus_list_bus(dev);
 726                 }
 727                 return NULL;
 728             }
 729         }
 730
 731         /* find bus */
 732         if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
 733             assert(0);
 734             elem[0] = len = 0;
 735         }
 736         pos += len;
 737         bus = qbus_find_bus(dev, elem);
 738         if (!bus) {
 739             qerror_report(QERR_BUS_NOT_FOUND, elem);
 740             if (!monitor_cur_is_qmp()) {
 741                 qbus_list_bus(dev);
 742             }
 743             return NULL;
 744         }
 745     }
 746 }
 747
 748 void qbus_create_inplace(BusState *bus, BusInfo *info,
 749                          DeviceState *parent, const char *name)
 750 {
 751     char *buf;
 752     int i,len;
 753
 754     bus->info = info;
 755     bus->parent = parent;
 756
 757     if (name) {
 758         /* use supplied name */
 759         bus->name = g_strdup(name);
 760     } else if (parent && parent->id) {
 761         /* parent device has id -> use it for bus name */
 762         len = strlen(parent->id) + 16;
 763         buf = g_malloc(len);
 764         snprintf(buf, len, "%s.%d", parent->id, parent->num_child_bus);
 765         bus->name = buf;
 766     } else {
 767         /* no id -> use lowercase bus type for bus name */
 768         len = strlen(info->name) + 16;
 769         buf = g_malloc(len);
 770         len = snprintf(buf, len, "%s.%d", info->name,
 771                        parent ? parent->num_child_bus : 0);
 772         for (i = 0; i < len; i++)
 773             buf[i] = qemu_tolower(buf[i]);
 774         bus->name = buf;
 775     }
 776
 777     QTAILQ_INIT(&bus->children);
 778     if (parent) {
 779         QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling);
 780         parent->num_child_bus++;
 781     } else if (bus != main_system_bus) {
 782         /* TODO: once all bus devices are qdevified,
 783            only reset handler for main_system_bus should be registered here. */
 784         qemu_register_reset(qbus_reset_all_fn, bus);
 785     }
 786 }
 787
 788 BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name)
 789 {
 790     BusState *bus;
 791
 792     bus = g_malloc0(info->size);
 793     bus->qdev_allocated = 1;
 794     qbus_create_inplace(bus, info, parent, name);
 795     return bus;
 796 }
 797
 798 static void main_system_bus_create(void)
 799 {
 800     /* assign main_system_bus before qbus_create_inplace()
 801      * in order to make "if (bus != main_system_bus)" work */
 802     main_system_bus = g_malloc0(system_bus_info.size);
 803     main_system_bus->qdev_allocated = 1;
 804     qbus_create_inplace(main_system_bus, &system_bus_info, NULL,
 805                         "main-system-bus");
 806 }
 807
 808 void qbus_free(BusState *bus)
 809 {
 810     DeviceState *dev;
 811
 812     while ((dev = QTAILQ_FIRST(&bus->children)) != NULL) {
 813         qdev_free(dev);
 814     }
 815     if (bus->parent) {
 816         QLIST_REMOVE(bus, sibling);
 817         bus->parent->num_child_bus--;
 818     } else {
 819         assert(bus != main_system_bus); /* main_system_bus is never freed */
 820         qemu_unregister_reset(qbus_reset_all_fn, bus);
 821     }
 822     g_free((void*)bus->name);
 823     if (bus->qdev_allocated) {
 824         g_free(bus);
 825     }
 826 }
 827
 828 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
 829 static void qbus_print(Monitor *mon, BusState *bus, int indent);
 830
 831 static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
 832                              const char *prefix, int indent)
 833 {
 834     char buf[64];
 835
 836     if (!props)
 837         return;
 838     while (props->name) {
 839         /*
 840          * TODO Properties without a print method are just for dirty
 841          * hacks.  qdev_prop_ptr is the only such PropertyInfo.  It's
 842          * marked for removal.  The test props->info->print should be
 843          * removed along with it.
 844          */
 845         if (props->info->print) {
 846             props->info->print(dev, props, buf, sizeof(buf));
 847             qdev_printf("%s-prop: %s = %s\n", prefix, props->name, buf);
 848         }
 849         props++;
 850     }
 851 }
 852
 853 static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
 854 {
 855     BusState *child;
 856     qdev_printf("dev: %s, id \"%s\"\n", dev->info->name,
 857                 dev->id ? dev->id : "");
 858     indent += 2;
 859     if (dev->num_gpio_in) {
 860         qdev_printf("gpio-in %d\n", dev->num_gpio_in);
 861     }
 862     if (dev->num_gpio_out) {
 863         qdev_printf("gpio-out %d\n", dev->num_gpio_out);
 864     }
 865     qdev_print_props(mon, dev, dev->info->props, "dev", indent);
 866     qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent);
 867     if (dev->parent_bus->info->print_dev)
 868         dev->parent_bus->info->print_dev(mon, dev, indent);
 869     QLIST_FOREACH(child, &dev->child_bus, sibling) {
 870         qbus_print(mon, child, indent);
 871     }
 872 }
 873
 874 static void qbus_print(Monitor *mon, BusState *bus, int indent)
 875 {
 876     struct DeviceState *dev;
 877
 878     qdev_printf("bus: %s\n", bus->name);
 879     indent += 2;
 880     qdev_printf("type %s\n", bus->info->name);
 881     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 882         qdev_print(mon, dev, indent);
 883     }
 884 }
 885 #undef qdev_printf
 886
 887 void do_info_qtree(Monitor *mon)
 888 {
 889     if (main_system_bus)
 890         qbus_print(mon, main_system_bus, 0);
 891 }
 892
 893 void do_info_qdm(Monitor *mon)
 894 {
 895     DeviceInfo *info;
 896
 897     for (info = device_info_list; info != NULL; info = info->next) {
 898         qdev_print_devinfo(info);
 899     }
 900 }
 901
 902 int do_device_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
 903 {
 904     QemuOpts *opts;
 905
 906     opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict);
 907     if (!opts) {
 908         return -1;
 909     }
 910     if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
 911         qemu_opts_del(opts);
 912         return 0;
 913     }
 914     if (!qdev_device_add(opts)) {
 915         qemu_opts_del(opts);
 916         return -1;
 917     }
 918     return 0;
 919 }
 920
 921 int do_device_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
 922 {
 923     const char *id = qdict_get_str(qdict, "id");
 924     DeviceState *dev;
 925
 926     dev = qdev_find_recursive(main_system_bus, id);
 927     if (NULL == dev) {
 928         qerror_report(QERR_DEVICE_NOT_FOUND, id);
 929         return -1;
 930     }
 931     return qdev_unplug(dev);
 932 }
 933
 934 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
 935 {
 936     int l = 0;
 937
 938     if (dev && dev->parent_bus) {
 939         char *d;
 940         l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
 941         if (dev->parent_bus->info->get_fw_dev_path) {
 942             d = dev->parent_bus->info->get_fw_dev_path(dev);
 943             l += snprintf(p + l, size - l, "%s", d);
 944             g_free(d);
 945         } else {
 946             l += snprintf(p + l, size - l, "%s", dev->info->name);
 947         }
 948     }
 949     l += snprintf(p + l , size - l, "/");
 950
 951     return l;
 952 }
 953
 954 char* qdev_get_fw_dev_path(DeviceState *dev)
 955 {
 956     char path[128];
 957     int l;
 958
 959     l = qdev_get_fw_dev_path_helper(dev, path, 128);
 960
 961     path[l-1] = '\0';
 962
 963     return strdup(path);
 964 }