qemu/softmmu/qdev-monitor.c
<<
>>
Prefs
   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.1 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#include "qemu/osdep.h"
  21#include "hw/sysbus.h"
  22#include "monitor/hmp.h"
  23#include "monitor/monitor.h"
  24#include "monitor/qdev.h"
  25#include "sysemu/arch_init.h"
  26#include "qapi/error.h"
  27#include "qapi/qapi-commands-qdev.h"
  28#include "qapi/qmp/dispatch.h"
  29#include "qapi/qmp/qdict.h"
  30#include "qapi/qmp/qerror.h"
  31#include "qapi/qmp/qstring.h"
  32#include "qapi/qobject-input-visitor.h"
  33#include "qemu/config-file.h"
  34#include "qemu/error-report.h"
  35#include "qemu/help_option.h"
  36#include "qemu/option.h"
  37#include "qemu/qemu-print.h"
  38#include "qemu/option_int.h"
  39#include "sysemu/block-backend.h"
  40#include "migration/misc.h"
  41#include "migration/migration.h"
  42#include "qemu/cutils.h"
  43#include "hw/qdev-properties.h"
  44#include "hw/clock.h"
  45#include "hw/boards.h"
  46
  47/*
  48 * Aliases were a bad idea from the start.  Let's keep them
  49 * from spreading further.
  50 */
  51typedef struct QDevAlias
  52{
  53    const char *typename;
  54    const char *alias;
  55    uint32_t arch_mask;
  56} QDevAlias;
  57
  58/* default virtio transport per architecture */
  59#define QEMU_ARCH_VIRTIO_PCI (QEMU_ARCH_ALPHA | QEMU_ARCH_ARM | \
  60                              QEMU_ARCH_HPPA | QEMU_ARCH_I386 | \
  61                              QEMU_ARCH_MIPS | QEMU_ARCH_PPC |  \
  62                              QEMU_ARCH_RISCV | QEMU_ARCH_SH4 | \
  63                              QEMU_ARCH_SPARC | QEMU_ARCH_XTENSA | \
  64                              QEMU_ARCH_LOONGARCH)
  65#define QEMU_ARCH_VIRTIO_CCW (QEMU_ARCH_S390X)
  66#define QEMU_ARCH_VIRTIO_MMIO (QEMU_ARCH_M68K)
  67
  68/* Please keep this table sorted by typename. */
  69static const QDevAlias qdev_alias_table[] = {
  70    { "AC97", "ac97" }, /* -soundhw name */
  71    { "e1000", "e1000-82540em" },
  72    { "ES1370", "es1370" }, /* -soundhw name */
  73    { "ich9-ahci", "ahci" },
  74    { "lsi53c895a", "lsi" },
  75    { "virtio-9p-device", "virtio-9p", QEMU_ARCH_VIRTIO_MMIO },
  76    { "virtio-9p-ccw", "virtio-9p", QEMU_ARCH_VIRTIO_CCW },
  77    { "virtio-9p-pci", "virtio-9p", QEMU_ARCH_VIRTIO_PCI },
  78    { "virtio-balloon-device", "virtio-balloon", QEMU_ARCH_VIRTIO_MMIO },
  79    { "virtio-balloon-ccw", "virtio-balloon", QEMU_ARCH_VIRTIO_CCW },
  80    { "virtio-balloon-pci", "virtio-balloon", QEMU_ARCH_VIRTIO_PCI },
  81    { "virtio-blk-device", "virtio-blk", QEMU_ARCH_VIRTIO_MMIO },
  82    { "virtio-blk-ccw", "virtio-blk", QEMU_ARCH_VIRTIO_CCW },
  83    { "virtio-blk-pci", "virtio-blk", QEMU_ARCH_VIRTIO_PCI },
  84    { "virtio-gpu-device", "virtio-gpu", QEMU_ARCH_VIRTIO_MMIO },
  85    { "virtio-gpu-ccw", "virtio-gpu", QEMU_ARCH_VIRTIO_CCW },
  86    { "virtio-gpu-pci", "virtio-gpu", QEMU_ARCH_VIRTIO_PCI },
  87    { "virtio-gpu-gl-device", "virtio-gpu-gl", QEMU_ARCH_VIRTIO_MMIO },
  88    { "virtio-gpu-gl-pci", "virtio-gpu-gl", QEMU_ARCH_VIRTIO_PCI },
  89    { "virtio-input-host-device", "virtio-input-host", QEMU_ARCH_VIRTIO_MMIO },
  90    { "virtio-input-host-ccw", "virtio-input-host", QEMU_ARCH_VIRTIO_CCW },
  91    { "virtio-input-host-pci", "virtio-input-host", QEMU_ARCH_VIRTIO_PCI },
  92    { "virtio-iommu-pci", "virtio-iommu", QEMU_ARCH_VIRTIO_PCI },
  93    { "virtio-keyboard-device", "virtio-keyboard", QEMU_ARCH_VIRTIO_MMIO },
  94    { "virtio-keyboard-ccw", "virtio-keyboard", QEMU_ARCH_VIRTIO_CCW },
  95    { "virtio-keyboard-pci", "virtio-keyboard", QEMU_ARCH_VIRTIO_PCI },
  96    { "virtio-mouse-device", "virtio-mouse", QEMU_ARCH_VIRTIO_MMIO },
  97    { "virtio-mouse-ccw", "virtio-mouse", QEMU_ARCH_VIRTIO_CCW },
  98    { "virtio-mouse-pci", "virtio-mouse", QEMU_ARCH_VIRTIO_PCI },
  99    { "virtio-net-device", "virtio-net", QEMU_ARCH_VIRTIO_MMIO },
 100    { "virtio-net-ccw", "virtio-net", QEMU_ARCH_VIRTIO_CCW },
 101    { "virtio-net-pci", "virtio-net", QEMU_ARCH_VIRTIO_PCI },
 102    { "virtio-rng-device", "virtio-rng", QEMU_ARCH_VIRTIO_MMIO },
 103    { "virtio-rng-ccw", "virtio-rng", QEMU_ARCH_VIRTIO_CCW },
 104    { "virtio-rng-pci", "virtio-rng", QEMU_ARCH_VIRTIO_PCI },
 105    { "virtio-scsi-device", "virtio-scsi", QEMU_ARCH_VIRTIO_MMIO },
 106    { "virtio-scsi-ccw", "virtio-scsi", QEMU_ARCH_VIRTIO_CCW },
 107    { "virtio-scsi-pci", "virtio-scsi", QEMU_ARCH_VIRTIO_PCI },
 108    { "virtio-serial-device", "virtio-serial", QEMU_ARCH_VIRTIO_MMIO },
 109    { "virtio-serial-ccw", "virtio-serial", QEMU_ARCH_VIRTIO_CCW },
 110    { "virtio-serial-pci", "virtio-serial", QEMU_ARCH_VIRTIO_PCI},
 111    { "virtio-tablet-device", "virtio-tablet", QEMU_ARCH_VIRTIO_MMIO },
 112    { "virtio-tablet-ccw", "virtio-tablet", QEMU_ARCH_VIRTIO_CCW },
 113    { "virtio-tablet-pci", "virtio-tablet", QEMU_ARCH_VIRTIO_PCI },
 114    { }
 115};
 116
 117static const char *qdev_class_get_alias(DeviceClass *dc)
 118{
 119    const char *typename = object_class_get_name(OBJECT_CLASS(dc));
 120    int i;
 121
 122    for (i = 0; qdev_alias_table[i].typename; i++) {
 123        if (qdev_alias_table[i].arch_mask &&
 124            !(qdev_alias_table[i].arch_mask & arch_type)) {
 125            continue;
 126        }
 127
 128        if (strcmp(qdev_alias_table[i].typename, typename) == 0) {
 129            return qdev_alias_table[i].alias;
 130        }
 131    }
 132
 133    return NULL;
 134}
 135
 136static bool qdev_class_has_alias(DeviceClass *dc)
 137{
 138    return (qdev_class_get_alias(dc) != NULL);
 139}
 140
 141static void qdev_print_devinfo(DeviceClass *dc)
 142{
 143    qemu_printf("name \"%s\"", object_class_get_name(OBJECT_CLASS(dc)));
 144    if (dc->bus_type) {
 145        qemu_printf(", bus %s", dc->bus_type);
 146    }
 147    if (qdev_class_has_alias(dc)) {
 148        qemu_printf(", alias \"%s\"", qdev_class_get_alias(dc));
 149    }
 150    if (dc->desc) {
 151        qemu_printf(", desc \"%s\"", dc->desc);
 152    }
 153    if (!dc->user_creatable) {
 154        qemu_printf(", no-user");
 155    }
 156    qemu_printf("\n");
 157}
 158
 159static void qdev_print_devinfos(bool show_no_user)
 160{
 161    static const char *cat_name[DEVICE_CATEGORY_MAX + 1] = {
 162        [DEVICE_CATEGORY_BRIDGE]  = "Controller/Bridge/Hub",
 163        [DEVICE_CATEGORY_USB]     = "USB",
 164        [DEVICE_CATEGORY_STORAGE] = "Storage",
 165        [DEVICE_CATEGORY_NETWORK] = "Network",
 166        [DEVICE_CATEGORY_INPUT]   = "Input",
 167        [DEVICE_CATEGORY_DISPLAY] = "Display",
 168        [DEVICE_CATEGORY_SOUND]   = "Sound",
 169        [DEVICE_CATEGORY_MISC]    = "Misc",
 170        [DEVICE_CATEGORY_CPU]     = "CPU",
 171        [DEVICE_CATEGORY_WATCHDOG]= "Watchdog",
 172        [DEVICE_CATEGORY_MAX]     = "Uncategorized",
 173    };
 174    GSList *list, *elt;
 175    int i;
 176    bool cat_printed;
 177
 178    module_load_qom_all();
 179    list = object_class_get_list_sorted(TYPE_DEVICE, false);
 180
 181    for (i = 0; i <= DEVICE_CATEGORY_MAX; i++) {
 182        cat_printed = false;
 183        for (elt = list; elt; elt = elt->next) {
 184            DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
 185                                                 TYPE_DEVICE);
 186            if ((i < DEVICE_CATEGORY_MAX
 187                 ? !test_bit(i, dc->categories)
 188                 : !bitmap_empty(dc->categories, DEVICE_CATEGORY_MAX))
 189                || (!show_no_user
 190                    && !dc->user_creatable)) {
 191                continue;
 192            }
 193            if (!cat_printed) {
 194                qemu_printf("%s%s devices:\n", i ? "\n" : "", cat_name[i]);
 195                cat_printed = true;
 196            }
 197            qdev_print_devinfo(dc);
 198        }
 199    }
 200
 201    g_slist_free(list);
 202}
 203
 204static const char *find_typename_by_alias(const char *alias)
 205{
 206    int i;
 207
 208    for (i = 0; qdev_alias_table[i].alias; i++) {
 209        if (qdev_alias_table[i].arch_mask &&
 210            !(qdev_alias_table[i].arch_mask & arch_type)) {
 211            continue;
 212        }
 213
 214        if (strcmp(qdev_alias_table[i].alias, alias) == 0) {
 215            return qdev_alias_table[i].typename;
 216        }
 217    }
 218
 219    return NULL;
 220}
 221
 222static DeviceClass *qdev_get_device_class(const char **driver, Error **errp)
 223{
 224    ObjectClass *oc;
 225    DeviceClass *dc;
 226    const char *original_name = *driver;
 227
 228    oc = module_object_class_by_name(*driver);
 229    if (!oc) {
 230        const char *typename = find_typename_by_alias(*driver);
 231
 232        if (typename) {
 233            *driver = typename;
 234            oc = module_object_class_by_name(*driver);
 235        }
 236    }
 237
 238    if (!object_class_dynamic_cast(oc, TYPE_DEVICE)) {
 239        if (*driver != original_name) {
 240            error_setg(errp, "'%s' (alias '%s') is not a valid device model"
 241                       " name", original_name, *driver);
 242        } else {
 243            error_setg(errp, "'%s' is not a valid device model name", *driver);
 244        }
 245        return NULL;
 246    }
 247
 248    if (object_class_is_abstract(oc)) {
 249        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
 250                   "a non-abstract device type");
 251        return NULL;
 252    }
 253
 254    dc = DEVICE_CLASS(oc);
 255    if (!dc->user_creatable ||
 256        (phase_check(PHASE_MACHINE_READY) && !dc->hotpluggable)) {
 257        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
 258                   "a pluggable device type");
 259        return NULL;
 260    }
 261
 262    if (object_class_dynamic_cast(oc, TYPE_SYS_BUS_DEVICE)) {
 263        /* sysbus devices need to be allowed by the machine */
 264        MachineClass *mc = MACHINE_CLASS(object_get_class(qdev_get_machine()));
 265        if (!device_type_is_dynamic_sysbus(mc, *driver)) {
 266            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
 267                       "a dynamic sysbus device type for the machine");
 268            return NULL;
 269        }
 270    }
 271
 272    return dc;
 273}
 274
 275
 276int qdev_device_help(QemuOpts *opts)
 277{
 278    Error *local_err = NULL;
 279    const char *driver;
 280    ObjectPropertyInfoList *prop_list;
 281    ObjectPropertyInfoList *prop;
 282    GPtrArray *array;
 283    int i;
 284
 285    driver = qemu_opt_get(opts, "driver");
 286    if (driver && is_help_option(driver)) {
 287        qdev_print_devinfos(false);
 288        return 1;
 289    }
 290
 291    if (!driver || !qemu_opt_has_help_opt(opts)) {
 292        return 0;
 293    }
 294
 295    if (!object_class_by_name(driver)) {
 296        const char *typename = find_typename_by_alias(driver);
 297
 298        if (typename) {
 299            driver = typename;
 300        }
 301    }
 302
 303    prop_list = qmp_device_list_properties(driver, &local_err);
 304    if (local_err) {
 305        goto error;
 306    }
 307
 308    if (prop_list) {
 309        qemu_printf("%s options:\n", driver);
 310    } else {
 311        qemu_printf("There are no options for %s.\n", driver);
 312    }
 313    array = g_ptr_array_new();
 314    for (prop = prop_list; prop; prop = prop->next) {
 315        g_ptr_array_add(array,
 316                        object_property_help(prop->value->name,
 317                                             prop->value->type,
 318                                             prop->value->default_value,
 319                                             prop->value->description));
 320    }
 321    g_ptr_array_sort(array, (GCompareFunc)qemu_pstrcmp0);
 322    for (i = 0; i < array->len; i++) {
 323        qemu_printf("%s\n", (char *)array->pdata[i]);
 324    }
 325    g_ptr_array_set_free_func(array, g_free);
 326    g_ptr_array_free(array, true);
 327    qapi_free_ObjectPropertyInfoList(prop_list);
 328    return 1;
 329
 330error:
 331    error_report_err(local_err);
 332    return 1;
 333}
 334
 335static Object *qdev_get_peripheral(void)
 336{
 337    static Object *dev;
 338
 339    if (dev == NULL) {
 340        dev = container_get(qdev_get_machine(), "/peripheral");
 341    }
 342
 343    return dev;
 344}
 345
 346static Object *qdev_get_peripheral_anon(void)
 347{
 348    static Object *dev;
 349
 350    if (dev == NULL) {
 351        dev = container_get(qdev_get_machine(), "/peripheral-anon");
 352    }
 353
 354    return dev;
 355}
 356
 357static void qbus_error_append_bus_list_hint(DeviceState *dev,
 358                                            Error *const *errp)
 359{
 360    BusState *child;
 361    const char *sep = " ";
 362
 363    error_append_hint(errp, "child buses at \"%s\":",
 364                      dev->id ? dev->id : object_get_typename(OBJECT(dev)));
 365    QLIST_FOREACH(child, &dev->child_bus, sibling) {
 366        error_append_hint(errp, "%s\"%s\"", sep, child->name);
 367        sep = ", ";
 368    }
 369    error_append_hint(errp, "\n");
 370}
 371
 372static void qbus_error_append_dev_list_hint(BusState *bus,
 373                                            Error *const *errp)
 374{
 375    BusChild *kid;
 376    const char *sep = " ";
 377
 378    error_append_hint(errp, "devices at \"%s\":", bus->name);
 379    QTAILQ_FOREACH(kid, &bus->children, sibling) {
 380        DeviceState *dev = kid->child;
 381        error_append_hint(errp, "%s\"%s\"", sep,
 382                          object_get_typename(OBJECT(dev)));
 383        if (dev->id) {
 384            error_append_hint(errp, "/\"%s\"", dev->id);
 385        }
 386        sep = ", ";
 387    }
 388    error_append_hint(errp, "\n");
 389}
 390
 391static BusState *qbus_find_bus(DeviceState *dev, char *elem)
 392{
 393    BusState *child;
 394
 395    QLIST_FOREACH(child, &dev->child_bus, sibling) {
 396        if (strcmp(child->name, elem) == 0) {
 397            return child;
 398        }
 399    }
 400    return NULL;
 401}
 402
 403static DeviceState *qbus_find_dev(BusState *bus, char *elem)
 404{
 405    BusChild *kid;
 406
 407    /*
 408     * try to match in order:
 409     *   (1) instance id, if present
 410     *   (2) driver name
 411     *   (3) driver alias, if present
 412     */
 413    QTAILQ_FOREACH(kid, &bus->children, sibling) {
 414        DeviceState *dev = kid->child;
 415        if (dev->id  &&  strcmp(dev->id, elem) == 0) {
 416            return dev;
 417        }
 418    }
 419    QTAILQ_FOREACH(kid, &bus->children, sibling) {
 420        DeviceState *dev = kid->child;
 421        if (strcmp(object_get_typename(OBJECT(dev)), elem) == 0) {
 422            return dev;
 423        }
 424    }
 425    QTAILQ_FOREACH(kid, &bus->children, sibling) {
 426        DeviceState *dev = kid->child;
 427        DeviceClass *dc = DEVICE_GET_CLASS(dev);
 428
 429        if (qdev_class_has_alias(dc) &&
 430            strcmp(qdev_class_get_alias(dc), elem) == 0) {
 431            return dev;
 432        }
 433    }
 434    return NULL;
 435}
 436
 437static inline bool qbus_is_full(BusState *bus)
 438{
 439    BusClass *bus_class;
 440
 441    if (bus->full) {
 442        return true;
 443    }
 444    bus_class = BUS_GET_CLASS(bus);
 445    return bus_class->max_dev && bus->num_children >= bus_class->max_dev;
 446}
 447
 448/*
 449 * Search the tree rooted at @bus for a bus.
 450 * If @name, search for a bus with that name.  Note that bus names
 451 * need not be unique.  Yes, that's screwed up.
 452 * Else search for a bus that is a subtype of @bus_typename.
 453 * If more than one exists, prefer one that can take another device.
 454 * Return the bus if found, else %NULL.
 455 */
 456static BusState *qbus_find_recursive(BusState *bus, const char *name,
 457                                     const char *bus_typename)
 458{
 459    BusChild *kid;
 460    BusState *pick, *child, *ret;
 461    bool match;
 462
 463    assert(name || bus_typename);
 464    if (name) {
 465        match = !strcmp(bus->name, name);
 466    } else {
 467        match = !!object_dynamic_cast(OBJECT(bus), bus_typename);
 468    }
 469
 470    if (match && !qbus_is_full(bus)) {
 471        return bus;             /* root matches and isn't full */
 472    }
 473
 474    pick = match ? bus : NULL;
 475
 476    QTAILQ_FOREACH(kid, &bus->children, sibling) {
 477        DeviceState *dev = kid->child;
 478        QLIST_FOREACH(child, &dev->child_bus, sibling) {
 479            ret = qbus_find_recursive(child, name, bus_typename);
 480            if (ret && !qbus_is_full(ret)) {
 481                return ret;     /* a descendant matches and isn't full */
 482            }
 483            if (ret && !pick) {
 484                pick = ret;
 485            }
 486        }
 487    }
 488
 489    /* root or a descendant matches, but is full */
 490    return pick;
 491}
 492
 493static BusState *qbus_find(const char *path, Error **errp)
 494{
 495    DeviceState *dev;
 496    BusState *bus;
 497    char elem[128];
 498    int pos, len;
 499
 500    /* find start element */
 501    if (path[0] == '/') {
 502        bus = sysbus_get_default();
 503        pos = 0;
 504    } else {
 505        if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
 506            assert(!path[0]);
 507            elem[0] = len = 0;
 508        }
 509        bus = qbus_find_recursive(sysbus_get_default(), elem, NULL);
 510        if (!bus) {
 511            error_setg(errp, "Bus '%s' not found", elem);
 512            return NULL;
 513        }
 514        pos = len;
 515    }
 516
 517    for (;;) {
 518        assert(path[pos] == '/' || !path[pos]);
 519        while (path[pos] == '/') {
 520            pos++;
 521        }
 522        if (path[pos] == '\0') {
 523            break;
 524        }
 525
 526        /* find device */
 527        if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
 528            g_assert_not_reached();
 529            elem[0] = len = 0;
 530        }
 531        pos += len;
 532        dev = qbus_find_dev(bus, elem);
 533        if (!dev) {
 534            error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
 535                      "Device '%s' not found", elem);
 536            qbus_error_append_dev_list_hint(bus, errp);
 537            return NULL;
 538        }
 539
 540        assert(path[pos] == '/' || !path[pos]);
 541        while (path[pos] == '/') {
 542            pos++;
 543        }
 544        if (path[pos] == '\0') {
 545            /* last specified element is a device.  If it has exactly
 546             * one child bus accept it nevertheless */
 547            if (dev->num_child_bus == 1) {
 548                bus = QLIST_FIRST(&dev->child_bus);
 549                break;
 550            }
 551            if (dev->num_child_bus) {
 552                error_setg(errp, "Device '%s' has multiple child buses",
 553                           elem);
 554                qbus_error_append_bus_list_hint(dev, errp);
 555            } else {
 556                error_setg(errp, "Device '%s' has no child bus", elem);
 557            }
 558            return NULL;
 559        }
 560
 561        /* find bus */
 562        if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
 563            g_assert_not_reached();
 564            elem[0] = len = 0;
 565        }
 566        pos += len;
 567        bus = qbus_find_bus(dev, elem);
 568        if (!bus) {
 569            error_setg(errp, "Bus '%s' not found", elem);
 570            qbus_error_append_bus_list_hint(dev, errp);
 571            return NULL;
 572        }
 573    }
 574
 575    if (qbus_is_full(bus)) {
 576        error_setg(errp, "Bus '%s' is full", path);
 577        return NULL;
 578    }
 579    return bus;
 580}
 581
 582/* Takes ownership of @id, will be freed when deleting the device */
 583const char *qdev_set_id(DeviceState *dev, char *id, Error **errp)
 584{
 585    ObjectProperty *prop;
 586
 587    assert(!dev->id && !dev->realized);
 588
 589    /*
 590     * object_property_[try_]add_child() below will assert the device
 591     * has no parent
 592     */
 593    if (id) {
 594        prop = object_property_try_add_child(qdev_get_peripheral(), id,
 595                                             OBJECT(dev), NULL);
 596        if (prop) {
 597            dev->id = id;
 598        } else {
 599            error_setg(errp, "Duplicate device ID '%s'", id);
 600            g_free(id);
 601            return NULL;
 602        }
 603    } else {
 604        static int anon_count;
 605        gchar *name = g_strdup_printf("device[%d]", anon_count++);
 606        prop = object_property_add_child(qdev_get_peripheral_anon(), name,
 607                                         OBJECT(dev));
 608        g_free(name);
 609    }
 610
 611    return prop->name;
 612}
 613
 614DeviceState *qdev_device_add_from_qdict(const QDict *opts,
 615                                        bool from_json, Error **errp)
 616{
 617    ERRP_GUARD();
 618    DeviceClass *dc;
 619    const char *driver, *path;
 620    char *id;
 621    DeviceState *dev = NULL;
 622    BusState *bus = NULL;
 623
 624    driver = qdict_get_try_str(opts, "driver");
 625    if (!driver) {
 626        error_setg(errp, QERR_MISSING_PARAMETER, "driver");
 627        return NULL;
 628    }
 629
 630    /* find driver */
 631    dc = qdev_get_device_class(&driver, errp);
 632    if (!dc) {
 633        return NULL;
 634    }
 635
 636    /* find bus */
 637    path = qdict_get_try_str(opts, "bus");
 638    if (path != NULL) {
 639        bus = qbus_find(path, errp);
 640        if (!bus) {
 641            return NULL;
 642        }
 643        if (!object_dynamic_cast(OBJECT(bus), dc->bus_type)) {
 644            error_setg(errp, "Device '%s' can't go on %s bus",
 645                       driver, object_get_typename(OBJECT(bus)));
 646            return NULL;
 647        }
 648    } else if (dc->bus_type != NULL) {
 649        bus = qbus_find_recursive(sysbus_get_default(), NULL, dc->bus_type);
 650        if (!bus || qbus_is_full(bus)) {
 651            error_setg(errp, "No '%s' bus found for device '%s'",
 652                       dc->bus_type, driver);
 653            return NULL;
 654        }
 655    }
 656
 657    if (qdev_should_hide_device(opts, from_json, errp)) {
 658        if (bus && !qbus_is_hotpluggable(bus)) {
 659            error_setg(errp, QERR_BUS_NO_HOTPLUG, bus->name);
 660        }
 661        return NULL;
 662    } else if (*errp) {
 663        return NULL;
 664    }
 665
 666    if (phase_check(PHASE_MACHINE_READY) && bus && !qbus_is_hotpluggable(bus)) {
 667        error_setg(errp, QERR_BUS_NO_HOTPLUG, bus->name);
 668        return NULL;
 669    }
 670
 671    if (!migration_is_idle()) {
 672        error_setg(errp, "device_add not allowed while migrating");
 673        return NULL;
 674    }
 675
 676    /* create device */
 677    dev = qdev_new(driver);
 678
 679    /* Check whether the hotplug is allowed by the machine */
 680    if (phase_check(PHASE_MACHINE_READY)) {
 681        if (!qdev_hotplug_allowed(dev, errp)) {
 682            goto err_del_dev;
 683        }
 684
 685        if (!bus && !qdev_get_machine_hotplug_handler(dev)) {
 686            /* No bus, no machine hotplug handler --> device is not hotpluggable */
 687            error_setg(errp, "Device '%s' can not be hotplugged on this machine",
 688                       driver);
 689            goto err_del_dev;
 690        }
 691    }
 692
 693    /*
 694     * set dev's parent and register its id.
 695     * If it fails it means the id is already taken.
 696     */
 697    id = g_strdup(qdict_get_try_str(opts, "id"));
 698    if (!qdev_set_id(dev, id, errp)) {
 699        goto err_del_dev;
 700    }
 701
 702    /* set properties */
 703    dev->opts = qdict_clone_shallow(opts);
 704    qdict_del(dev->opts, "driver");
 705    qdict_del(dev->opts, "bus");
 706    qdict_del(dev->opts, "id");
 707
 708    object_set_properties_from_keyval(&dev->parent_obj, dev->opts, from_json,
 709                                      errp);
 710    if (*errp) {
 711        goto err_del_dev;
 712    }
 713
 714    if (!qdev_realize(DEVICE(dev), bus, errp)) {
 715        goto err_del_dev;
 716    }
 717    return dev;
 718
 719err_del_dev:
 720    if (dev) {
 721        object_unparent(OBJECT(dev));
 722        object_unref(OBJECT(dev));
 723    }
 724    return NULL;
 725}
 726
 727/* Takes ownership of @opts on success */
 728DeviceState *qdev_device_add(QemuOpts *opts, Error **errp)
 729{
 730    QDict *qdict = qemu_opts_to_qdict(opts, NULL);
 731    DeviceState *ret;
 732
 733    ret = qdev_device_add_from_qdict(qdict, false, errp);
 734    if (ret) {
 735        qemu_opts_del(opts);
 736    }
 737    qobject_unref(qdict);
 738    return ret;
 739}
 740
 741#define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
 742static void qbus_print(Monitor *mon, BusState *bus, int indent);
 743
 744static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
 745                             int indent)
 746{
 747    if (!props)
 748        return;
 749    for (; props->name; props++) {
 750        char *value;
 751        char *legacy_name = g_strdup_printf("legacy-%s", props->name);
 752
 753        if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
 754            value = object_property_get_str(OBJECT(dev), legacy_name, NULL);
 755        } else {
 756            value = object_property_print(OBJECT(dev), props->name, true,
 757                                          NULL);
 758        }
 759        g_free(legacy_name);
 760
 761        if (!value) {
 762            continue;
 763        }
 764        qdev_printf("%s = %s\n", props->name,
 765                    *value ? value : "<null>");
 766        g_free(value);
 767    }
 768}
 769
 770static void bus_print_dev(BusState *bus, Monitor *mon, DeviceState *dev, int indent)
 771{
 772    BusClass *bc = BUS_GET_CLASS(bus);
 773
 774    if (bc->print_dev) {
 775        bc->print_dev(mon, dev, indent);
 776    }
 777}
 778
 779static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
 780{
 781    ObjectClass *class;
 782    BusState *child;
 783    NamedGPIOList *ngl;
 784    NamedClockList *ncl;
 785
 786    qdev_printf("dev: %s, id \"%s\"\n", object_get_typename(OBJECT(dev)),
 787                dev->id ? dev->id : "");
 788    indent += 2;
 789    QLIST_FOREACH(ngl, &dev->gpios, node) {
 790        if (ngl->num_in) {
 791            qdev_printf("gpio-in \"%s\" %d\n", ngl->name ? ngl->name : "",
 792                        ngl->num_in);
 793        }
 794        if (ngl->num_out) {
 795            qdev_printf("gpio-out \"%s\" %d\n", ngl->name ? ngl->name : "",
 796                        ngl->num_out);
 797        }
 798    }
 799    QLIST_FOREACH(ncl, &dev->clocks, node) {
 800        g_autofree char *freq_str = clock_display_freq(ncl->clock);
 801        qdev_printf("clock-%s%s \"%s\" freq_hz=%s\n",
 802                    ncl->output ? "out" : "in",
 803                    ncl->alias ? " (alias)" : "",
 804                    ncl->name, freq_str);
 805    }
 806    class = object_get_class(OBJECT(dev));
 807    do {
 808        qdev_print_props(mon, dev, DEVICE_CLASS(class)->props_, indent);
 809        class = object_class_get_parent(class);
 810    } while (class != object_class_by_name(TYPE_DEVICE));
 811    bus_print_dev(dev->parent_bus, mon, dev, indent);
 812    QLIST_FOREACH(child, &dev->child_bus, sibling) {
 813        qbus_print(mon, child, indent);
 814    }
 815}
 816
 817static void qbus_print(Monitor *mon, BusState *bus, int indent)
 818{
 819    BusChild *kid;
 820
 821    qdev_printf("bus: %s\n", bus->name);
 822    indent += 2;
 823    qdev_printf("type %s\n", object_get_typename(OBJECT(bus)));
 824    QTAILQ_FOREACH(kid, &bus->children, sibling) {
 825        DeviceState *dev = kid->child;
 826        qdev_print(mon, dev, indent);
 827    }
 828}
 829#undef qdev_printf
 830
 831void hmp_info_qtree(Monitor *mon, const QDict *qdict)
 832{
 833    if (sysbus_get_default())
 834        qbus_print(mon, sysbus_get_default(), 0);
 835}
 836
 837void hmp_info_qdm(Monitor *mon, const QDict *qdict)
 838{
 839    qdev_print_devinfos(true);
 840}
 841
 842void qmp_device_add(QDict *qdict, QObject **ret_data, Error **errp)
 843{
 844    QemuOpts *opts;
 845    DeviceState *dev;
 846
 847    opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, errp);
 848    if (!opts) {
 849        return;
 850    }
 851    if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
 852        qemu_opts_del(opts);
 853        return;
 854    }
 855    dev = qdev_device_add(opts, errp);
 856
 857    /*
 858     * Drain all pending RCU callbacks. This is done because
 859     * some bus related operations can delay a device removal
 860     * (in this case this can happen if device is added and then
 861     * removed due to a configuration error)
 862     * to a RCU callback, but user might expect that this interface
 863     * will finish its job completely once qmp command returns result
 864     * to the user
 865     */
 866    drain_call_rcu();
 867
 868    if (!dev) {
 869        qemu_opts_del(opts);
 870        return;
 871    }
 872    object_unref(OBJECT(dev));
 873}
 874
 875static DeviceState *find_device_state(const char *id, Error **errp)
 876{
 877    Object *obj = object_resolve_path_at(qdev_get_peripheral(), id);
 878    DeviceState *dev;
 879
 880    if (!obj) {
 881        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
 882                  "Device '%s' not found", id);
 883        return NULL;
 884    }
 885
 886    dev = (DeviceState *)object_dynamic_cast(obj, TYPE_DEVICE);
 887    if (!dev) {
 888        error_setg(errp, "%s is not a hotpluggable device", id);
 889        return NULL;
 890    }
 891
 892    return dev;
 893}
 894
 895void qdev_unplug(DeviceState *dev, Error **errp)
 896{
 897    DeviceClass *dc = DEVICE_GET_CLASS(dev);
 898    HotplugHandler *hotplug_ctrl;
 899    HotplugHandlerClass *hdc;
 900    Error *local_err = NULL;
 901
 902    if (qdev_unplug_blocked(dev, errp)) {
 903        return;
 904    }
 905
 906    if (dev->parent_bus && !qbus_is_hotpluggable(dev->parent_bus)) {
 907        error_setg(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
 908        return;
 909    }
 910
 911    if (!dc->hotpluggable) {
 912        error_setg(errp, QERR_DEVICE_NO_HOTPLUG,
 913                   object_get_typename(OBJECT(dev)));
 914        return;
 915    }
 916
 917    if (!migration_is_idle() && !dev->allow_unplug_during_migration) {
 918        error_setg(errp, "device_del not allowed while migrating");
 919        return;
 920    }
 921
 922    qdev_hot_removed = true;
 923
 924    hotplug_ctrl = qdev_get_hotplug_handler(dev);
 925    /* hotpluggable device MUST have HotplugHandler, if it doesn't
 926     * then something is very wrong with it */
 927    g_assert(hotplug_ctrl);
 928
 929    /* If device supports async unplug just request it to be done,
 930     * otherwise just remove it synchronously */
 931    hdc = HOTPLUG_HANDLER_GET_CLASS(hotplug_ctrl);
 932    if (hdc->unplug_request) {
 933        hotplug_handler_unplug_request(hotplug_ctrl, dev, &local_err);
 934    } else {
 935        hotplug_handler_unplug(hotplug_ctrl, dev, &local_err);
 936        if (!local_err) {
 937            object_unparent(OBJECT(dev));
 938        }
 939    }
 940    error_propagate(errp, local_err);
 941}
 942
 943void qmp_device_del(const char *id, Error **errp)
 944{
 945    DeviceState *dev = find_device_state(id, errp);
 946    if (dev != NULL) {
 947        if (dev->pending_deleted_event &&
 948            (dev->pending_deleted_expires_ms == 0 ||
 949             dev->pending_deleted_expires_ms > qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL))) {
 950            error_setg(errp, "Device %s is already in the "
 951                             "process of unplug", id);
 952            return;
 953        }
 954
 955        qdev_unplug(dev, errp);
 956    }
 957}
 958
 959void hmp_device_add(Monitor *mon, const QDict *qdict)
 960{
 961    Error *err = NULL;
 962
 963    qmp_device_add((QDict *)qdict, NULL, &err);
 964    hmp_handle_error(mon, err);
 965}
 966
 967void hmp_device_del(Monitor *mon, const QDict *qdict)
 968{
 969    const char *id = qdict_get_str(qdict, "id");
 970    Error *err = NULL;
 971
 972    qmp_device_del(id, &err);
 973    hmp_handle_error(mon, err);
 974}
 975
 976void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
 977{
 978    GSList *list, *elt;
 979    size_t len;
 980
 981    if (nb_args != 2) {
 982        return;
 983    }
 984
 985    len = strlen(str);
 986    readline_set_completion_index(rs, len);
 987    list = elt = object_class_get_list(TYPE_DEVICE, false);
 988    while (elt) {
 989        DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
 990                                             TYPE_DEVICE);
 991
 992        if (dc->user_creatable) {
 993            readline_add_completion_of(rs, str,
 994                                object_class_get_name(OBJECT_CLASS(dc)));
 995        }
 996        elt = elt->next;
 997    }
 998    g_slist_free(list);
 999}
1000
1001static int qdev_add_hotpluggable_device(Object *obj, void *opaque)
1002{
1003    GSList **list = opaque;
1004    DeviceState *dev = (DeviceState *)object_dynamic_cast(obj, TYPE_DEVICE);
1005
1006    if (dev == NULL) {
1007        return 0;
1008    }
1009
1010    if (dev->realized && object_property_get_bool(obj, "hotpluggable", NULL)) {
1011        *list = g_slist_append(*list, dev);
1012    }
1013
1014    return 0;
1015}
1016
1017static GSList *qdev_build_hotpluggable_device_list(Object *peripheral)
1018{
1019    GSList *list = NULL;
1020
1021    object_child_foreach(peripheral, qdev_add_hotpluggable_device, &list);
1022
1023    return list;
1024}
1025
1026static void peripheral_device_del_completion(ReadLineState *rs,
1027                                             const char *str)
1028{
1029    Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
1030    GSList *list, *item;
1031
1032    list = qdev_build_hotpluggable_device_list(peripheral);
1033    if (!list) {
1034        return;
1035    }
1036
1037    for (item = list; item; item = g_slist_next(item)) {
1038        DeviceState *dev = item->data;
1039
1040        if (dev->id) {
1041            readline_add_completion_of(rs, str, dev->id);
1042        }
1043    }
1044
1045    g_slist_free(list);
1046}
1047
1048void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
1049{
1050    if (nb_args != 2) {
1051        return;
1052    }
1053
1054    readline_set_completion_index(rs, strlen(str));
1055    peripheral_device_del_completion(rs, str);
1056}
1057
1058BlockBackend *blk_by_qdev_id(const char *id, Error **errp)
1059{
1060    DeviceState *dev;
1061    BlockBackend *blk;
1062
1063    GLOBAL_STATE_CODE();
1064
1065    dev = find_device_state(id, errp);
1066    if (dev == NULL) {
1067        return NULL;
1068    }
1069
1070    blk = blk_by_dev(dev);
1071    if (!blk) {
1072        error_setg(errp, "Device does not have a block device backend");
1073    }
1074    return blk;
1075}
1076
1077QemuOptsList qemu_device_opts = {
1078    .name = "device",
1079    .implied_opt_name = "driver",
1080    .head = QTAILQ_HEAD_INITIALIZER(qemu_device_opts.head),
1081    .desc = {
1082        /*
1083         * no elements => accept any
1084         * sanity checking will happen later
1085         * when setting device properties
1086         */
1087        { /* end of list */ }
1088    },
1089};
1090
1091QemuOptsList qemu_global_opts = {
1092    .name = "global",
1093    .head = QTAILQ_HEAD_INITIALIZER(qemu_global_opts.head),
1094    .desc = {
1095        {
1096            .name = "driver",
1097            .type = QEMU_OPT_STRING,
1098        },{
1099            .name = "property",
1100            .type = QEMU_OPT_STRING,
1101        },{
1102            .name = "value",
1103            .type = QEMU_OPT_STRING,
1104        },
1105        { /* end of list */ }
1106    },
1107};
1108
1109int qemu_global_option(const char *str)
1110{
1111    char driver[64], property[64];
1112    QemuOpts *opts;
1113    int rc, offset;
1114
1115    rc = sscanf(str, "%63[^.=].%63[^=]%n", driver, property, &offset);
1116    if (rc == 2 && str[offset] == '=') {
1117        opts = qemu_opts_create(&qemu_global_opts, NULL, 0, &error_abort);
1118        qemu_opt_set(opts, "driver", driver, &error_abort);
1119        qemu_opt_set(opts, "property", property, &error_abort);
1120        qemu_opt_set(opts, "value", str + offset + 1, &error_abort);
1121        return 0;
1122    }
1123
1124    opts = qemu_opts_parse_noisily(&qemu_global_opts, str, false);
1125    if (!opts) {
1126        return -1;
1127    }
1128    if (!qemu_opt_get(opts, "driver")
1129        || !qemu_opt_get(opts, "property")
1130        || !qemu_opt_get(opts, "value")) {
1131        error_report("options 'driver', 'property', and 'value'"
1132                     " are required");
1133        return -1;
1134    }
1135
1136    return 0;
1137}
1138
1139bool qmp_command_available(const QmpCommand *cmd, Error **errp)
1140{
1141    if (!phase_check(PHASE_MACHINE_READY) &&
1142        !(cmd->options & QCO_ALLOW_PRECONFIG)) {
1143        error_setg(errp, "The command '%s' is permitted only after machine initialization has completed",
1144                   cmd->name);
1145        return false;
1146    }
1147    return true;
1148}
1149