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