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 "qerror.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 /* Create a new device.  This only initializes the device state structure
  82    and allows properties to be set.  qdev_init should be called to
  83    initialize the actual device emulation.  */
  84 DeviceState *qdev_create(BusState *bus, const char *name)
  85 {
  86     DeviceInfo *info;
  87     DeviceState *dev;
  88
  89     if (!bus) {
  90         if (!main_system_bus) {
  91             main_system_bus = qbus_create(&system_bus_info, NULL, "main-system-bus");
  92         }
  93         bus = main_system_bus;
  94     }
  95
  96     info = qdev_find_info(bus->info, name);
  97     if (!info) {
  98         hw_error("Unknown device '%s' for bus '%s'\n", name, bus->info->name);
  99     }
 100
 101     dev = qemu_mallocz(info->size);
 102     dev->info = info;
 103     dev->parent_bus = bus;
 104     qdev_prop_set_defaults(dev, dev->info->props);
 105     qdev_prop_set_defaults(dev, dev->parent_bus->info->props);
 106     qdev_prop_set_globals(dev);
 107     QLIST_INSERT_HEAD(&bus->children, dev, sibling);
 108     if (qdev_hotplug) {
 109         assert(bus->allow_hotplug);
 110         dev->hotplugged = 1;
 111     }
 112     dev->state = DEV_STATE_CREATED;
 113     return dev;
 114 }
 115
 116 static int qdev_print_devinfo(DeviceInfo *info, char *dest, int len)
 117 {
 118     int pos = 0;
 119     int ret;
 120
 121     ret = snprintf(dest+pos, len-pos, "name \"%s\", bus %s",
 122                    info->name, info->bus_info->name);
 123     pos += MIN(len-pos,ret);
 124     if (info->alias) {
 125         ret = snprintf(dest+pos, len-pos, ", alias \"%s\"", info->alias);
 126         pos += MIN(len-pos,ret);
 127     }
 128     if (info->desc) {
 129         ret = snprintf(dest+pos, len-pos, ", desc \"%s\"", info->desc);
 130         pos += MIN(len-pos,ret);
 131     }
 132     if (info->no_user) {
 133         ret = snprintf(dest+pos, len-pos, ", no-user");
 134         pos += MIN(len-pos,ret);
 135     }
 136     return pos;
 137 }
 138
 139 static int set_property(const char *name, const char *value, void *opaque)
 140 {
 141     DeviceState *dev = opaque;
 142
 143     if (strcmp(name, "driver") == 0)
 144         return 0;
 145     if (strcmp(name, "bus") == 0)
 146         return 0;
 147
 148     if (qdev_prop_parse(dev, name, value) == -1) {
 149         qemu_error("can't set property \"%s\" to \"%s\" for \"%s\"\n",
 150                    name, value, dev->info->name);
 151         return -1;
 152     }
 153     return 0;
 154 }
 155
 156 DeviceState *qdev_device_add(QemuOpts *opts)
 157 {
 158     const char *driver, *path, *id;
 159     DeviceInfo *info;
 160     DeviceState *qdev;
 161     BusState *bus;
 162
 163     driver = qemu_opt_get(opts, "driver");
 164     if (!driver) {
 165         qemu_error("-device: no driver specified\n");
 166         return NULL;
 167     }
 168     if (strcmp(driver, "?") == 0) {
 169         char msg[256];
 170         for (info = device_info_list; info != NULL; info = info->next) {
 171             qdev_print_devinfo(info, msg, sizeof(msg));
 172             qemu_error("%s\n", msg);
 173         }
 174         return NULL;
 175     }
 176
 177     /* find driver */
 178     info = qdev_find_info(NULL, driver);
 179     if (!info) {
 180         qemu_error_new(QERR_DEVICE_NOT_FOUND, driver);
 181         return NULL;
 182     }
 183     if (info->no_user) {
 184         qemu_error("device \"%s\" can't be added via command line\n",
 185                    info->name);
 186         return NULL;
 187     }
 188
 189     /* find bus */
 190     path = qemu_opt_get(opts, "bus");
 191     if (path != NULL) {
 192         bus = qbus_find(path);
 193     } else {
 194         bus = qbus_find_recursive(main_system_bus, NULL, info->bus_info);
 195     }
 196     if (!bus) {
 197         qemu_error("Did not find %s bus for %s\n",
 198                    path ? path : info->bus_info->name, info->name);
 199         return NULL;
 200     }
 201     if (qdev_hotplug && !bus->allow_hotplug) {
 202         qemu_error("Bus %s does not support hotplugging\n",
 203                    bus->name);
 204         return NULL;
 205     }
 206
 207     /* create device, set properties */
 208     qdev = qdev_create(bus, driver);
 209     id = qemu_opts_id(opts);
 210     if (id) {
 211         qdev->id = id;
 212     }
 213     if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) {
 214         qdev_free(qdev);
 215         return NULL;
 216     }
 217     if (qdev_init(qdev) < 0) {
 218         qemu_error("Error initializing device %s\n", driver);
 219         return NULL;
 220     }
 221     qdev->opts = opts;
 222     return qdev;
 223 }
 224
 225 static void qdev_reset(void *opaque)
 226 {
 227     DeviceState *dev = opaque;
 228     if (dev->info->reset)
 229         dev->info->reset(dev);
 230 }
 231
 232 /* Initialize a device.  Device properties should be set before calling
 233    this function.  IRQs and MMIO regions should be connected/mapped after
 234    calling this function.
 235    On failure, destroy the device and return negative value.
 236    Return 0 on success.  */
 237 int qdev_init(DeviceState *dev)
 238 {
 239     int rc;
 240
 241     assert(dev->state == DEV_STATE_CREATED);
 242     rc = dev->info->init(dev, dev->info);
 243     if (rc < 0) {
 244         qdev_free(dev);
 245         return rc;
 246     }
 247     qemu_register_reset(qdev_reset, dev);
 248     if (dev->info->vmsd)
 249         vmstate_register(-1, dev->info->vmsd, dev);
 250     dev->state = DEV_STATE_INITIALIZED;
 251     return 0;
 252 }
 253
 254 int qdev_unplug(DeviceState *dev)
 255 {
 256     if (!dev->parent_bus->allow_hotplug) {
 257         qemu_error("Bus %s does not support hotplugging\n",
 258                    dev->parent_bus->name);
 259         return -1;
 260     }
 261     assert(dev->info->unplug != NULL);
 262
 263     return dev->info->unplug(dev);
 264 }
 265
 266 /* can be used as ->unplug() callback for the simple cases */
 267 int qdev_simple_unplug_cb(DeviceState *dev)
 268 {
 269     /* just zap it */
 270     qdev_free(dev);
 271     return 0;
 272 }
 273
 274 /* Like qdev_init(), but terminate program via hw_error() instead of
 275    returning an error value.  This is okay during machine creation.
 276    Don't use for hotplug, because there callers need to recover from
 277    failure.  Exception: if you know the device's init() callback can't
 278    fail, then qdev_init_nofail() can't fail either, and is therefore
 279    usable even then.  But relying on the device implementation that
 280    way is somewhat unclean, and best avoided.  */
 281 void qdev_init_nofail(DeviceState *dev)
 282 {
 283     DeviceInfo *info = dev->info;
 284
 285     if (qdev_init(dev) < 0)
 286         hw_error("Initialization of device %s failed\n", info->name);
 287 }
 288
 289 /* Unlink device from bus and free the structure.  */
 290 void qdev_free(DeviceState *dev)
 291 {
 292     BusState *bus;
 293
 294     if (dev->state == DEV_STATE_INITIALIZED) {
 295         while (dev->num_child_bus) {
 296             bus = QLIST_FIRST(&dev->child_bus);
 297             qbus_free(bus);
 298         }
 299         if (dev->info->vmsd)
 300             vmstate_unregister(dev->info->vmsd, dev);
 301         if (dev->info->exit)
 302             dev->info->exit(dev);
 303         if (dev->opts)
 304             qemu_opts_del(dev->opts);
 305     }
 306     qemu_unregister_reset(qdev_reset, dev);
 307     QLIST_REMOVE(dev, sibling);
 308     qemu_free(dev);
 309 }
 310
 311 void qdev_machine_creation_done(void)
 312 {
 313     /*
 314      * ok, initial machine setup is done, starting from now we can
 315      * only create hotpluggable devices
 316      */
 317     qdev_hotplug = 1;
 318 }
 319
 320 /* Get a character (serial) device interface.  */
 321 CharDriverState *qdev_init_chardev(DeviceState *dev)
 322 {
 323     static int next_serial;
 324
 325     /* FIXME: This function needs to go away: use chardev properties!  */
 326     return serial_hds[next_serial++];
 327 }
 328
 329 BusState *qdev_get_parent_bus(DeviceState *dev)
 330 {
 331     return dev->parent_bus;
 332 }
 333
 334 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
 335 {
 336     assert(dev->num_gpio_in == 0);
 337     dev->num_gpio_in = n;
 338     dev->gpio_in = qemu_allocate_irqs(handler, dev, n);
 339 }
 340
 341 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
 342 {
 343     assert(dev->num_gpio_out == 0);
 344     dev->num_gpio_out = n;
 345     dev->gpio_out = pins;
 346 }
 347
 348 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
 349 {
 350     assert(n >= 0 && n < dev->num_gpio_in);
 351     return dev->gpio_in[n];
 352 }
 353
 354 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
 355 {
 356     assert(n >= 0 && n < dev->num_gpio_out);
 357     dev->gpio_out[n] = pin;
 358 }
 359
 360 void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
 361 {
 362     qdev_prop_set_macaddr(dev, "mac", nd->macaddr);
 363     if (nd->vlan)
 364         qdev_prop_set_vlan(dev, "vlan", nd->vlan);
 365     if (nd->netdev)
 366         qdev_prop_set_netdev(dev, "netdev", nd->netdev);
 367     if (nd->nvectors != NIC_NVECTORS_UNSPECIFIED &&
 368         qdev_prop_exists(dev, "vectors")) {
 369         qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
 370     }
 371 }
 372
 373 static int next_block_unit[IF_COUNT];
 374
 375 /* Get a block device.  This should only be used for single-drive devices
 376    (e.g. SD/Floppy/MTD).  Multi-disk devices (scsi/ide) should use the
 377    appropriate bus.  */
 378 BlockDriverState *qdev_init_bdrv(DeviceState *dev, BlockInterfaceType type)
 379 {
 380     int unit = next_block_unit[type]++;
 381     DriveInfo *dinfo;
 382
 383     dinfo = drive_get(type, 0, unit);
 384     return dinfo ? dinfo->bdrv : NULL;
 385 }
 386
 387 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 388 {
 389     BusState *bus;
 390
 391     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 392         if (strcmp(name, bus->name) == 0) {
 393             return bus;
 394         }
 395     }
 396     return NULL;
 397 }
 398
 399 static BusState *qbus_find_recursive(BusState *bus, const char *name,
 400                                      const BusInfo *info)
 401 {
 402     DeviceState *dev;
 403     BusState *child, *ret;
 404     int match = 1;
 405
 406     if (name && (strcmp(bus->name, name) != 0)) {
 407         match = 0;
 408     }
 409     if (info && (bus->info != info)) {
 410         match = 0;
 411     }
 412     if (match) {
 413         return bus;
 414     }
 415
 416     QLIST_FOREACH(dev, &bus->children, sibling) {
 417         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 418             ret = qbus_find_recursive(child, name, info);
 419             if (ret) {
 420                 return ret;
 421             }
 422         }
 423     }
 424     return NULL;
 425 }
 426
 427 static DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 428 {
 429     DeviceState *dev, *ret;
 430     BusState *child;
 431
 432     QLIST_FOREACH(dev, &bus->children, sibling) {
 433         if (dev->id && strcmp(dev->id, id) == 0)
 434             return dev;
 435         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 436             ret = qdev_find_recursive(child, id);
 437             if (ret) {
 438                 return ret;
 439             }
 440         }
 441     }
 442     return NULL;
 443 }
 444
 445 static void qbus_list_bus(DeviceState *dev, char *dest, int len)
 446 {
 447     BusState *child;
 448     const char *sep = " ";
 449     int pos = 0;
 450
 451     pos += snprintf(dest+pos, len-pos,"child busses at \"%s\":",
 452                     dev->id ? dev->id : dev->info->name);
 453     QLIST_FOREACH(child, &dev->child_bus, sibling) {
 454         pos += snprintf(dest+pos, len-pos, "%s\"%s\"", sep, child->name);
 455         sep = ", ";
 456     }
 457 }
 458
 459 static void qbus_list_dev(BusState *bus, char *dest, int len)
 460 {
 461     DeviceState *dev;
 462     const char *sep = " ";
 463     int pos = 0;
 464
 465     pos += snprintf(dest+pos, len-pos, "devices at \"%s\":",
 466                     bus->name);
 467     QLIST_FOREACH(dev, &bus->children, sibling) {
 468         pos += snprintf(dest+pos, len-pos, "%s\"%s\"",
 469                         sep, dev->info->name);
 470         if (dev->id)
 471             pos += snprintf(dest+pos, len-pos, "/\"%s\"", dev->id);
 472         sep = ", ";
 473     }
 474 }
 475
 476 static BusState *qbus_find_bus(DeviceState *dev, char *elem)
 477 {
 478     BusState *child;
 479
 480     QLIST_FOREACH(child, &dev->child_bus, sibling) {
 481         if (strcmp(child->name, elem) == 0) {
 482             return child;
 483         }
 484     }
 485     return NULL;
 486 }
 487
 488 static DeviceState *qbus_find_dev(BusState *bus, char *elem)
 489 {
 490     DeviceState *dev;
 491
 492     /*
 493      * try to match in order:
 494      *   (1) instance id, if present
 495      *   (2) driver name
 496      *   (3) driver alias, if present
 497      */
 498     QLIST_FOREACH(dev, &bus->children, sibling) {
 499         if (dev->id  &&  strcmp(dev->id, elem) == 0) {
 500             return dev;
 501         }
 502     }
 503     QLIST_FOREACH(dev, &bus->children, sibling) {
 504         if (strcmp(dev->info->name, elem) == 0) {
 505             return dev;
 506         }
 507     }
 508     QLIST_FOREACH(dev, &bus->children, sibling) {
 509         if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) {
 510             return dev;
 511         }
 512     }
 513     return NULL;
 514 }
 515
 516 static BusState *qbus_find(const char *path)
 517 {
 518     DeviceState *dev;
 519     BusState *bus;
 520     char elem[128], msg[256];
 521     int pos, len;
 522
 523     /* find start element */
 524     if (path[0] == '/') {
 525         bus = main_system_bus;
 526         pos = 0;
 527     } else {
 528         if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
 529             qemu_error("path parse error (\"%s\")\n", path);
 530             return NULL;
 531         }
 532         bus = qbus_find_recursive(main_system_bus, elem, NULL);
 533         if (!bus) {
 534             qemu_error("bus \"%s\" not found\n", elem);
 535             return NULL;
 536         }
 537         pos = len;
 538     }
 539
 540     for (;;) {
 541         if (path[pos] == '\0') {
 542             /* we are done */
 543             return bus;
 544         }
 545
 546         /* find device */
 547         if (sscanf(path+pos, "/%127[^/]%n", elem, &len) != 1) {
 548             qemu_error("path parse error (\"%s\" pos %d)\n", path, pos);
 549             return NULL;
 550         }
 551         pos += len;
 552         dev = qbus_find_dev(bus, elem);
 553         if (!dev) {
 554             qbus_list_dev(bus, msg, sizeof(msg));
 555             qemu_error("device \"%s\" not found\n%s\n", elem, msg);
 556             return NULL;
 557         }
 558         if (path[pos] == '\0') {
 559             /* last specified element is a device.  If it has exactly
 560              * one child bus accept it nevertheless */
 561             switch (dev->num_child_bus) {
 562             case 0:
 563                 qemu_error("device has no child bus (%s)\n", path);
 564                 return NULL;
 565             case 1:
 566                 return QLIST_FIRST(&dev->child_bus);
 567             default:
 568                 qbus_list_bus(dev, msg, sizeof(msg));
 569                 qemu_error("device has multiple child busses (%s)\n%s\n",
 570                            path, msg);
 571                 return NULL;
 572             }
 573         }
 574
 575         /* find bus */
 576         if (sscanf(path+pos, "/%127[^/]%n", elem, &len) != 1) {
 577             qemu_error("path parse error (\"%s\" pos %d)\n", path, pos);
 578             return NULL;
 579         }
 580         pos += len;
 581         bus = qbus_find_bus(dev, elem);
 582         if (!bus) {
 583             qbus_list_bus(dev, msg, sizeof(msg));
 584             qemu_error("child bus \"%s\" not found\n%s\n", elem, msg);
 585             return NULL;
 586         }
 587     }
 588 }
 589
 590 void qbus_create_inplace(BusState *bus, BusInfo *info,
 591                          DeviceState *parent, const char *name)
 592 {
 593     char *buf;
 594     int i,len;
 595
 596     bus->info = info;
 597     bus->parent = parent;
 598
 599     if (name) {
 600         /* use supplied name */
 601         bus->name = qemu_strdup(name);
 602     } else if (parent && parent->id) {
 603         /* parent device has id -> use it for bus name */
 604         len = strlen(parent->id) + 16;
 605         buf = qemu_malloc(len);
 606         snprintf(buf, len, "%s.%d", parent->id, parent->num_child_bus);
 607         bus->name = buf;
 608     } else {
 609         /* no id -> use lowercase bus type for bus name */
 610         len = strlen(info->name) + 16;
 611         buf = qemu_malloc(len);
 612         len = snprintf(buf, len, "%s.%d", info->name,
 613                        parent ? parent->num_child_bus : 0);
 614         for (i = 0; i < len; i++)
 615             buf[i] = qemu_tolower(buf[i]);
 616         bus->name = buf;
 617     }
 618
 619     QLIST_INIT(&bus->children);
 620     if (parent) {
 621         QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling);
 622         parent->num_child_bus++;
 623     }
 624
 625 }
 626
 627 BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name)
 628 {
 629     BusState *bus;
 630
 631     bus = qemu_mallocz(info->size);
 632     bus->qdev_allocated = 1;
 633     qbus_create_inplace(bus, info, parent, name);
 634     return bus;
 635 }
 636
 637 void qbus_free(BusState *bus)
 638 {
 639     DeviceState *dev;
 640
 641     while ((dev = QLIST_FIRST(&bus->children)) != NULL) {
 642         qdev_free(dev);
 643     }
 644     if (bus->parent) {
 645         QLIST_REMOVE(bus, sibling);
 646         bus->parent->num_child_bus--;
 647     }
 648     if (bus->qdev_allocated) {
 649         qemu_free(bus);
 650     }
 651 }
 652
 653 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
 654 static void qbus_print(Monitor *mon, BusState *bus, int indent);
 655
 656 static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
 657                              const char *prefix, int indent)
 658 {
 659     char buf[64];
 660
 661     if (!props)
 662         return;
 663     while (props->name) {
 664         if (props->info->print) {
 665             props->info->print(dev, props, buf, sizeof(buf));
 666             qdev_printf("%s-prop: %s = %s\n", prefix, props->name, buf);
 667         }
 668         props++;
 669     }
 670 }
 671
 672 static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
 673 {
 674     BusState *child;
 675     qdev_printf("dev: %s, id \"%s\"\n", dev->info->name,
 676                 dev->id ? dev->id : "");
 677     indent += 2;
 678     if (dev->num_gpio_in) {
 679         qdev_printf("gpio-in %d\n", dev->num_gpio_in);
 680     }
 681     if (dev->num_gpio_out) {
 682         qdev_printf("gpio-out %d\n", dev->num_gpio_out);
 683     }
 684     qdev_print_props(mon, dev, dev->info->props, "dev", indent);
 685     qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent);
 686     if (dev->parent_bus->info->print_dev)
 687         dev->parent_bus->info->print_dev(mon, dev, indent);
 688     QLIST_FOREACH(child, &dev->child_bus, sibling) {
 689         qbus_print(mon, child, indent);
 690     }
 691 }
 692
 693 static void qbus_print(Monitor *mon, BusState *bus, int indent)
 694 {
 695     struct DeviceState *dev;
 696
 697     qdev_printf("bus: %s\n", bus->name);
 698     indent += 2;
 699     qdev_printf("type %s\n", bus->info->name);
 700     QLIST_FOREACH(dev, &bus->children, sibling) {
 701         qdev_print(mon, dev, indent);
 702     }
 703 }
 704 #undef qdev_printf
 705
 706 void do_info_qtree(Monitor *mon)
 707 {
 708     if (main_system_bus)
 709         qbus_print(mon, main_system_bus, 0);
 710 }
 711
 712 void do_info_qdm(Monitor *mon)
 713 {
 714     DeviceInfo *info;
 715     char msg[256];
 716
 717     for (info = device_info_list; info != NULL; info = info->next) {
 718         qdev_print_devinfo(info, msg, sizeof(msg));
 719         monitor_printf(mon, "%s\n", msg);
 720     }
 721 }
 722
 723 void do_device_add(Monitor *mon, const QDict *qdict)
 724 {
 725     QemuOpts *opts;
 726
 727     opts = qemu_opts_parse(&qemu_device_opts,
 728                            qdict_get_str(qdict, "config"), "driver");
 729     if (opts)
 730         qdev_device_add(opts);
 731 }
 732
 733 void do_device_del(Monitor *mon, const QDict *qdict)
 734 {
 735     const char *id = qdict_get_str(qdict, "id");
 736     DeviceState *dev;
 737
 738     dev = qdev_find_recursive(main_system_bus, id);
 739     if (NULL == dev) {
 740         qemu_error("Device '%s' not found\n", id);
 741         return;
 742     }
 743     qdev_unplug(dev);
 744 }