hmp.c

   1 /*
   2  * Human Monitor Interface
   3  *
   4  * Copyright IBM, Corp. 2011
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  * Contributions after 2012-01-13 are licensed under the terms of the
  13  * GNU GPL, version 2 or (at your option) any later version.
  14  */
  15
  16 #include "hmp.h"
  17 #include "net/net.h"
  18 #include "sysemu/char.h"
  19 #include "sysemu/block-backend.h"
  20 #include "qemu/option.h"
  21 #include "qemu/timer.h"
  22 #include "qmp-commands.h"
  23 #include "qemu/sockets.h"
  24 #include "monitor/monitor.h"
  25 #include "monitor/qdev.h"
  26 #include "qapi/opts-visitor.h"
  27 #include "qapi/string-output-visitor.h"
  28 #include "qapi-visit.h"
  29 #include "ui/console.h"
  30 #include "block/qapi.h"
  31 #include "qemu-io.h"
  32
  33 #ifdef CONFIG_SPICE
  34 #include <spice/enums.h>
  35 #endif
  36
  37 static void hmp_handle_error(Monitor *mon, Error **errp)
  38 {
  39     assert(errp);
  40     if (*errp) {
  41         monitor_printf(mon, "%s\n", error_get_pretty(*errp));
  42         error_free(*errp);
  43     }
  44 }
  45
  46 void hmp_info_name(Monitor *mon, const QDict *qdict)
  47 {
  48     NameInfo *info;
  49
  50     info = qmp_query_name(NULL);
  51     if (info->has_name) {
  52         monitor_printf(mon, "%s\n", info->name);
  53     }
  54     qapi_free_NameInfo(info);
  55 }
  56
  57 void hmp_info_version(Monitor *mon, const QDict *qdict)
  58 {
  59     VersionInfo *info;
  60
  61     info = qmp_query_version(NULL);
  62
  63     monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
  64                    info->qemu->major, info->qemu->minor, info->qemu->micro,
  65                    info->package);
  66
  67     qapi_free_VersionInfo(info);
  68 }
  69
  70 void hmp_info_kvm(Monitor *mon, const QDict *qdict)
  71 {
  72     KvmInfo *info;
  73
  74     info = qmp_query_kvm(NULL);
  75     monitor_printf(mon, "kvm support: ");
  76     if (info->present) {
  77         monitor_printf(mon, "%s\n", info->enabled ? "enabled" : "disabled");
  78     } else {
  79         monitor_printf(mon, "not compiled\n");
  80     }
  81
  82     qapi_free_KvmInfo(info);
  83 }
  84
  85 void hmp_info_status(Monitor *mon, const QDict *qdict)
  86 {
  87     StatusInfo *info;
  88
  89     info = qmp_query_status(NULL);
  90
  91     monitor_printf(mon, "VM status: %s%s",
  92                    info->running ? "running" : "paused",
  93                    info->singlestep ? " (single step mode)" : "");
  94
  95     if (!info->running && info->status != RUN_STATE_PAUSED) {
  96         monitor_printf(mon, " (%s)", RunState_lookup[info->status]);
  97     }
  98
  99     monitor_printf(mon, "\n");
 100
 101     qapi_free_StatusInfo(info);
 102 }
 103
 104 void hmp_info_uuid(Monitor *mon, const QDict *qdict)
 105 {
 106     UuidInfo *info;
 107
 108     info = qmp_query_uuid(NULL);
 109     monitor_printf(mon, "%s\n", info->UUID);
 110     qapi_free_UuidInfo(info);
 111 }
 112
 113 void hmp_info_chardev(Monitor *mon, const QDict *qdict)
 114 {
 115     ChardevInfoList *char_info, *info;
 116
 117     char_info = qmp_query_chardev(NULL);
 118     for (info = char_info; info; info = info->next) {
 119         monitor_printf(mon, "%s: filename=%s\n", info->value->label,
 120                                                  info->value->filename);
 121     }
 122
 123     qapi_free_ChardevInfoList(char_info);
 124 }
 125
 126 void hmp_info_mice(Monitor *mon, const QDict *qdict)
 127 {
 128     MouseInfoList *mice_list, *mouse;
 129
 130     mice_list = qmp_query_mice(NULL);
 131     if (!mice_list) {
 132         monitor_printf(mon, "No mouse devices connected\n");
 133         return;
 134     }
 135
 136     for (mouse = mice_list; mouse; mouse = mouse->next) {
 137         monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n",
 138                        mouse->value->current ? '*' : ' ',
 139                        mouse->value->index, mouse->value->name,
 140                        mouse->value->absolute ? " (absolute)" : "");
 141     }
 142
 143     qapi_free_MouseInfoList(mice_list);
 144 }
 145
 146 void hmp_info_migrate(Monitor *mon, const QDict *qdict)
 147 {
 148     MigrationInfo *info;
 149     MigrationCapabilityStatusList *caps, *cap;
 150
 151     info = qmp_query_migrate(NULL);
 152     caps = qmp_query_migrate_capabilities(NULL);
 153
 154     /* do not display parameters during setup */
 155     if (info->has_status && caps) {
 156         monitor_printf(mon, "capabilities: ");
 157         for (cap = caps; cap; cap = cap->next) {
 158             monitor_printf(mon, "%s: %s ",
 159                            MigrationCapability_lookup[cap->value->capability],
 160                            cap->value->state ? "on" : "off");
 161         }
 162         monitor_printf(mon, "\n");
 163     }
 164
 165     if (info->has_status) {
 166         monitor_printf(mon, "Migration status: %s\n",
 167                        MigrationStatus_lookup[info->status]);
 168         monitor_printf(mon, "total time: %" PRIu64 " milliseconds\n",
 169                        info->total_time);
 170         if (info->has_expected_downtime) {
 171             monitor_printf(mon, "expected downtime: %" PRIu64 " milliseconds\n",
 172                            info->expected_downtime);
 173         }
 174         if (info->has_downtime) {
 175             monitor_printf(mon, "downtime: %" PRIu64 " milliseconds\n",
 176                            info->downtime);
 177         }
 178         if (info->has_setup_time) {
 179             monitor_printf(mon, "setup: %" PRIu64 " milliseconds\n",
 180                            info->setup_time);
 181         }
 182     }
 183
 184     if (info->has_ram) {
 185         monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
 186                        info->ram->transferred >> 10);
 187         monitor_printf(mon, "throughput: %0.2f mbps\n",
 188                        info->ram->mbps);
 189         monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",
 190                        info->ram->remaining >> 10);
 191         monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",
 192                        info->ram->total >> 10);
 193         monitor_printf(mon, "duplicate: %" PRIu64 " pages\n",
 194                        info->ram->duplicate);
 195         monitor_printf(mon, "skipped: %" PRIu64 " pages\n",
 196                        info->ram->skipped);
 197         monitor_printf(mon, "normal: %" PRIu64 " pages\n",
 198                        info->ram->normal);
 199         monitor_printf(mon, "normal bytes: %" PRIu64 " kbytes\n",
 200                        info->ram->normal_bytes >> 10);
 201         monitor_printf(mon, "dirty sync count: %" PRIu64 "\n",
 202                        info->ram->dirty_sync_count);
 203         if (info->ram->dirty_pages_rate) {
 204             monitor_printf(mon, "dirty pages rate: %" PRIu64 " pages\n",
 205                            info->ram->dirty_pages_rate);
 206         }
 207     }
 208
 209     if (info->has_disk) {
 210         monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n",
 211                        info->disk->transferred >> 10);
 212         monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n",
 213                        info->disk->remaining >> 10);
 214         monitor_printf(mon, "total disk: %" PRIu64 " kbytes\n",
 215                        info->disk->total >> 10);
 216     }
 217
 218     if (info->has_xbzrle_cache) {
 219         monitor_printf(mon, "cache size: %" PRIu64 " bytes\n",
 220                        info->xbzrle_cache->cache_size);
 221         monitor_printf(mon, "xbzrle transferred: %" PRIu64 " kbytes\n",
 222                        info->xbzrle_cache->bytes >> 10);
 223         monitor_printf(mon, "xbzrle pages: %" PRIu64 " pages\n",
 224                        info->xbzrle_cache->pages);
 225         monitor_printf(mon, "xbzrle cache miss: %" PRIu64 "\n",
 226                        info->xbzrle_cache->cache_miss);
 227         monitor_printf(mon, "xbzrle cache miss rate: %0.2f\n",
 228                        info->xbzrle_cache->cache_miss_rate);
 229         monitor_printf(mon, "xbzrle overflow : %" PRIu64 "\n",
 230                        info->xbzrle_cache->overflow);
 231     }
 232
 233     qapi_free_MigrationInfo(info);
 234     qapi_free_MigrationCapabilityStatusList(caps);
 235 }
 236
 237 void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict)
 238 {
 239     MigrationCapabilityStatusList *caps, *cap;
 240
 241     caps = qmp_query_migrate_capabilities(NULL);
 242
 243     if (caps) {
 244         monitor_printf(mon, "capabilities: ");
 245         for (cap = caps; cap; cap = cap->next) {
 246             monitor_printf(mon, "%s: %s ",
 247                            MigrationCapability_lookup[cap->value->capability],
 248                            cap->value->state ? "on" : "off");
 249         }
 250         monitor_printf(mon, "\n");
 251     }
 252
 253     qapi_free_MigrationCapabilityStatusList(caps);
 254 }
 255
 256 void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict)
 257 {
 258     MigrationParameters *params;
 259
 260     params = qmp_query_migrate_parameters(NULL);
 261
 262     if (params) {
 263         monitor_printf(mon, "parameters:");
 264         monitor_printf(mon, " %s: %" PRId64,
 265             MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_LEVEL],
 266             params->compress_level);
 267         monitor_printf(mon, " %s: %" PRId64,
 268             MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_THREADS],
 269             params->compress_threads);
 270         monitor_printf(mon, " %s: %" PRId64,
 271             MigrationParameter_lookup[MIGRATION_PARAMETER_DECOMPRESS_THREADS],
 272             params->decompress_threads);
 273         monitor_printf(mon, "\n");
 274     }
 275
 276     qapi_free_MigrationParameters(params);
 277 }
 278
 279 void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict)
 280 {
 281     monitor_printf(mon, "xbzrel cache size: %" PRId64 " kbytes\n",
 282                    qmp_query_migrate_cache_size(NULL) >> 10);
 283 }
 284
 285 void hmp_info_cpus(Monitor *mon, const QDict *qdict)
 286 {
 287     CpuInfoList *cpu_list, *cpu;
 288
 289     cpu_list = qmp_query_cpus(NULL);
 290
 291     for (cpu = cpu_list; cpu; cpu = cpu->next) {
 292         int active = ' ';
 293
 294         if (cpu->value->CPU == monitor_get_cpu_index()) {
 295             active = '*';
 296         }
 297
 298         monitor_printf(mon, "%c CPU #%" PRId64 ":", active, cpu->value->CPU);
 299
 300         if (cpu->value->has_pc) {
 301             monitor_printf(mon, " pc=0x%016" PRIx64, cpu->value->pc);
 302         }
 303         if (cpu->value->has_nip) {
 304             monitor_printf(mon, " nip=0x%016" PRIx64, cpu->value->nip);
 305         }
 306         if (cpu->value->has_npc) {
 307             monitor_printf(mon, " npc=0x%016" PRIx64, cpu->value->npc);
 308         }
 309         if (cpu->value->has_PC) {
 310             monitor_printf(mon, " PC=0x%016" PRIx64, cpu->value->PC);
 311         }
 312
 313         if (cpu->value->halted) {
 314             monitor_printf(mon, " (halted)");
 315         }
 316
 317         monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id);
 318     }
 319
 320     qapi_free_CpuInfoList(cpu_list);
 321 }
 322
 323 static void print_block_info(Monitor *mon, BlockInfo *info,
 324                              BlockDeviceInfo *inserted, bool verbose)
 325 {
 326     ImageInfo *image_info;
 327
 328     assert(!info || !info->has_inserted || info->inserted == inserted);
 329
 330     if (info) {
 331         monitor_printf(mon, "%s", info->device);
 332         if (inserted && inserted->has_node_name) {
 333             monitor_printf(mon, " (%s)", inserted->node_name);
 334         }
 335     } else {
 336         assert(inserted);
 337         monitor_printf(mon, "%s",
 338                        inserted->has_node_name
 339                        ? inserted->node_name
 340                        : "<anonymous>");
 341     }
 342
 343     if (inserted) {
 344         monitor_printf(mon, ": %s (%s%s%s)\n",
 345                        inserted->file,
 346                        inserted->drv,
 347                        inserted->ro ? ", read-only" : "",
 348                        inserted->encrypted ? ", encrypted" : "");
 349     } else {
 350         monitor_printf(mon, ": [not inserted]\n");
 351     }
 352
 353     if (info) {
 354         if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) {
 355             monitor_printf(mon, "    I/O status:       %s\n",
 356                            BlockDeviceIoStatus_lookup[info->io_status]);
 357         }
 358
 359         if (info->removable) {
 360             monitor_printf(mon, "    Removable device: %slocked, tray %s\n",
 361                            info->locked ? "" : "not ",
 362                            info->tray_open ? "open" : "closed");
 363         }
 364     }
 365
 366
 367     if (!inserted) {
 368         return;
 369     }
 370
 371     monitor_printf(mon, "    Cache mode:       %s%s%s\n",
 372                    inserted->cache->writeback ? "writeback" : "writethrough",
 373                    inserted->cache->direct ? ", direct" : "",
 374                    inserted->cache->no_flush ? ", ignore flushes" : "");
 375
 376     if (inserted->has_backing_file) {
 377         monitor_printf(mon,
 378                        "    Backing file:     %s "
 379                        "(chain depth: %" PRId64 ")\n",
 380                        inserted->backing_file,
 381                        inserted->backing_file_depth);
 382     }
 383
 384     if (inserted->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) {
 385         monitor_printf(mon, "    Detect zeroes:    %s\n",
 386                        BlockdevDetectZeroesOptions_lookup[inserted->detect_zeroes]);
 387     }
 388
 389     if (inserted->bps  || inserted->bps_rd  || inserted->bps_wr  ||
 390         inserted->iops || inserted->iops_rd || inserted->iops_wr)
 391     {
 392         monitor_printf(mon, "    I/O throttling:   bps=%" PRId64
 393                         " bps_rd=%" PRId64  " bps_wr=%" PRId64
 394                         " bps_max=%" PRId64
 395                         " bps_rd_max=%" PRId64
 396                         " bps_wr_max=%" PRId64
 397                         " iops=%" PRId64 " iops_rd=%" PRId64
 398                         " iops_wr=%" PRId64
 399                         " iops_max=%" PRId64
 400                         " iops_rd_max=%" PRId64
 401                         " iops_wr_max=%" PRId64
 402                         " iops_size=%" PRId64
 403                         " group=%s\n",
 404                         inserted->bps,
 405                         inserted->bps_rd,
 406                         inserted->bps_wr,
 407                         inserted->bps_max,
 408                         inserted->bps_rd_max,
 409                         inserted->bps_wr_max,
 410                         inserted->iops,
 411                         inserted->iops_rd,
 412                         inserted->iops_wr,
 413                         inserted->iops_max,
 414                         inserted->iops_rd_max,
 415                         inserted->iops_wr_max,
 416                         inserted->iops_size,
 417                         inserted->group);
 418     }
 419
 420     if (verbose) {
 421         monitor_printf(mon, "\nImages:\n");
 422         image_info = inserted->image;
 423         while (1) {
 424                 bdrv_image_info_dump((fprintf_function)monitor_printf,
 425                                      mon, image_info);
 426             if (image_info->has_backing_image) {
 427                 image_info = image_info->backing_image;
 428             } else {
 429                 break;
 430             }
 431         }
 432     }
 433 }
 434
 435 void hmp_info_block(Monitor *mon, const QDict *qdict)
 436 {
 437     BlockInfoList *block_list, *info;
 438     BlockDeviceInfoList *blockdev_list, *blockdev;
 439     const char *device = qdict_get_try_str(qdict, "device");
 440     bool verbose = qdict_get_try_bool(qdict, "verbose", 0);
 441     bool nodes = qdict_get_try_bool(qdict, "nodes", 0);
 442     bool printed = false;
 443
 444     /* Print BlockBackend information */
 445     if (!nodes) {
 446         block_list = qmp_query_block(NULL);
 447     } else {
 448         block_list = NULL;
 449     }
 450
 451     for (info = block_list; info; info = info->next) {
 452         if (device && strcmp(device, info->value->device)) {
 453             continue;
 454         }
 455
 456         if (info != block_list) {
 457             monitor_printf(mon, "\n");
 458         }
 459
 460         print_block_info(mon, info->value, info->value->has_inserted
 461                                            ? info->value->inserted : NULL,
 462                          verbose);
 463         printed = true;
 464     }
 465
 466     qapi_free_BlockInfoList(block_list);
 467
 468     if ((!device && !nodes) || printed) {
 469         return;
 470     }
 471
 472     /* Print node information */
 473     blockdev_list = qmp_query_named_block_nodes(NULL);
 474     for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) {
 475         assert(blockdev->value->has_node_name);
 476         if (device && strcmp(device, blockdev->value->node_name)) {
 477             continue;
 478         }
 479
 480         if (blockdev != blockdev_list) {
 481             monitor_printf(mon, "\n");
 482         }
 483
 484         print_block_info(mon, NULL, blockdev->value, verbose);
 485     }
 486     qapi_free_BlockDeviceInfoList(blockdev_list);
 487 }
 488
 489 void hmp_info_blockstats(Monitor *mon, const QDict *qdict)
 490 {
 491     BlockStatsList *stats_list, *stats;
 492
 493     stats_list = qmp_query_blockstats(false, false, NULL);
 494
 495     for (stats = stats_list; stats; stats = stats->next) {
 496         if (!stats->value->has_device) {
 497             continue;
 498         }
 499
 500         monitor_printf(mon, "%s:", stats->value->device);
 501         monitor_printf(mon, " rd_bytes=%" PRId64
 502                        " wr_bytes=%" PRId64
 503                        " rd_operations=%" PRId64
 504                        " wr_operations=%" PRId64
 505                        " flush_operations=%" PRId64
 506                        " wr_total_time_ns=%" PRId64
 507                        " rd_total_time_ns=%" PRId64
 508                        " flush_total_time_ns=%" PRId64
 509                        " rd_merged=%" PRId64
 510                        " wr_merged=%" PRId64
 511                        "\n",
 512                        stats->value->stats->rd_bytes,
 513                        stats->value->stats->wr_bytes,
 514                        stats->value->stats->rd_operations,
 515                        stats->value->stats->wr_operations,
 516                        stats->value->stats->flush_operations,
 517                        stats->value->stats->wr_total_time_ns,
 518                        stats->value->stats->rd_total_time_ns,
 519                        stats->value->stats->flush_total_time_ns,
 520                        stats->value->stats->rd_merged,
 521                        stats->value->stats->wr_merged);
 522     }
 523
 524     qapi_free_BlockStatsList(stats_list);
 525 }
 526
 527 void hmp_info_vnc(Monitor *mon, const QDict *qdict)
 528 {
 529     VncInfo *info;
 530     Error *err = NULL;
 531     VncClientInfoList *client;
 532
 533     info = qmp_query_vnc(&err);
 534     if (err) {
 535         monitor_printf(mon, "%s\n", error_get_pretty(err));
 536         error_free(err);
 537         return;
 538     }
 539
 540     if (!info->enabled) {
 541         monitor_printf(mon, "Server: disabled\n");
 542         goto out;
 543     }
 544
 545     monitor_printf(mon, "Server:\n");
 546     if (info->has_host && info->has_service) {
 547         monitor_printf(mon, "     address: %s:%s\n", info->host, info->service);
 548     }
 549     if (info->has_auth) {
 550         monitor_printf(mon, "        auth: %s\n", info->auth);
 551     }
 552
 553     if (!info->has_clients || info->clients == NULL) {
 554         monitor_printf(mon, "Client: none\n");
 555     } else {
 556         for (client = info->clients; client; client = client->next) {
 557             monitor_printf(mon, "Client:\n");
 558             monitor_printf(mon, "     address: %s:%s\n",
 559                            client->value->base->host,
 560                            client->value->base->service);
 561             monitor_printf(mon, "  x509_dname: %s\n",
 562                            client->value->x509_dname ?
 563                            client->value->x509_dname : "none");
 564             monitor_printf(mon, "    username: %s\n",
 565                            client->value->has_sasl_username ?
 566                            client->value->sasl_username : "none");
 567         }
 568     }
 569
 570 out:
 571     qapi_free_VncInfo(info);
 572 }
 573
 574 #ifdef CONFIG_SPICE
 575 void hmp_info_spice(Monitor *mon, const QDict *qdict)
 576 {
 577     SpiceChannelList *chan;
 578     SpiceInfo *info;
 579     const char *channel_name;
 580     const char * const channel_names[] = {
 581         [SPICE_CHANNEL_MAIN] = "main",
 582         [SPICE_CHANNEL_DISPLAY] = "display",
 583         [SPICE_CHANNEL_INPUTS] = "inputs",
 584         [SPICE_CHANNEL_CURSOR] = "cursor",
 585         [SPICE_CHANNEL_PLAYBACK] = "playback",
 586         [SPICE_CHANNEL_RECORD] = "record",
 587         [SPICE_CHANNEL_TUNNEL] = "tunnel",
 588         [SPICE_CHANNEL_SMARTCARD] = "smartcard",
 589         [SPICE_CHANNEL_USBREDIR] = "usbredir",
 590         [SPICE_CHANNEL_PORT] = "port",
 591 #if 0
 592         /* minimum spice-protocol is 0.12.3, webdav was added in 0.12.7,
 593          * no easy way to #ifdef (SPICE_CHANNEL_* is a enum).  Disable
 594          * as quick fix for build failures with older versions. */
 595         [SPICE_CHANNEL_WEBDAV] = "webdav",
 596 #endif
 597     };
 598
 599     info = qmp_query_spice(NULL);
 600
 601     if (!info->enabled) {
 602         monitor_printf(mon, "Server: disabled\n");
 603         goto out;
 604     }
 605
 606     monitor_printf(mon, "Server:\n");
 607     if (info->has_port) {
 608         monitor_printf(mon, "     address: %s:%" PRId64 "\n",
 609                        info->host, info->port);
 610     }
 611     if (info->has_tls_port) {
 612         monitor_printf(mon, "     address: %s:%" PRId64 " [tls]\n",
 613                        info->host, info->tls_port);
 614     }
 615     monitor_printf(mon, "    migrated: %s\n",
 616                    info->migrated ? "true" : "false");
 617     monitor_printf(mon, "        auth: %s\n", info->auth);
 618     monitor_printf(mon, "    compiled: %s\n", info->compiled_version);
 619     monitor_printf(mon, "  mouse-mode: %s\n",
 620                    SpiceQueryMouseMode_lookup[info->mouse_mode]);
 621
 622     if (!info->has_channels || info->channels == NULL) {
 623         monitor_printf(mon, "Channels: none\n");
 624     } else {
 625         for (chan = info->channels; chan; chan = chan->next) {
 626             monitor_printf(mon, "Channel:\n");
 627             monitor_printf(mon, "     address: %s:%s%s\n",
 628                            chan->value->base->host, chan->value->base->port,
 629                            chan->value->tls ? " [tls]" : "");
 630             monitor_printf(mon, "     session: %" PRId64 "\n",
 631                            chan->value->connection_id);
 632             monitor_printf(mon, "     channel: %" PRId64 ":%" PRId64 "\n",
 633                            chan->value->channel_type, chan->value->channel_id);
 634
 635             channel_name = "unknown";
 636             if (chan->value->channel_type > 0 &&
 637                 chan->value->channel_type < ARRAY_SIZE(channel_names) &&
 638                 channel_names[chan->value->channel_type]) {
 639                 channel_name = channel_names[chan->value->channel_type];
 640             }
 641
 642             monitor_printf(mon, "     channel name: %s\n", channel_name);
 643         }
 644     }
 645
 646 out:
 647     qapi_free_SpiceInfo(info);
 648 }
 649 #endif
 650
 651 void hmp_info_balloon(Monitor *mon, const QDict *qdict)
 652 {
 653     BalloonInfo *info;
 654     Error *err = NULL;
 655
 656     info = qmp_query_balloon(&err);
 657     if (err) {
 658         monitor_printf(mon, "%s\n", error_get_pretty(err));
 659         error_free(err);
 660         return;
 661     }
 662
 663     monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);
 664
 665     qapi_free_BalloonInfo(info);
 666 }
 667
 668 static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
 669 {
 670     PciMemoryRegionList *region;
 671
 672     monitor_printf(mon, "  Bus %2" PRId64 ", ", dev->bus);
 673     monitor_printf(mon, "device %3" PRId64 ", function %" PRId64 ":\n",
 674                    dev->slot, dev->function);
 675     monitor_printf(mon, "    ");
 676
 677     if (dev->class_info->has_desc) {
 678         monitor_printf(mon, "%s", dev->class_info->desc);
 679     } else {
 680         monitor_printf(mon, "Class %04" PRId64, dev->class_info->q_class);
 681     }
 682
 683     monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n",
 684                    dev->id->vendor, dev->id->device);
 685
 686     if (dev->has_irq) {
 687         monitor_printf(mon, "      IRQ %" PRId64 ".\n", dev->irq);
 688     }
 689
 690     if (dev->has_pci_bridge) {
 691         monitor_printf(mon, "      BUS %" PRId64 ".\n",
 692                        dev->pci_bridge->bus->number);
 693         monitor_printf(mon, "      secondary bus %" PRId64 ".\n",
 694                        dev->pci_bridge->bus->secondary);
 695         monitor_printf(mon, "      subordinate bus %" PRId64 ".\n",
 696                        dev->pci_bridge->bus->subordinate);
 697
 698         monitor_printf(mon, "      IO range [0x%04"PRIx64", 0x%04"PRIx64"]\n",
 699                        dev->pci_bridge->bus->io_range->base,
 700                        dev->pci_bridge->bus->io_range->limit);
 701
 702         monitor_printf(mon,
 703                        "      memory range [0x%08"PRIx64", 0x%08"PRIx64"]\n",
 704                        dev->pci_bridge->bus->memory_range->base,
 705                        dev->pci_bridge->bus->memory_range->limit);
 706
 707         monitor_printf(mon, "      prefetchable memory range "
 708                        "[0x%08"PRIx64", 0x%08"PRIx64"]\n",
 709                        dev->pci_bridge->bus->prefetchable_range->base,
 710                        dev->pci_bridge->bus->prefetchable_range->limit);
 711     }
 712
 713     for (region = dev->regions; region; region = region->next) {
 714         uint64_t addr, size;
 715
 716         addr = region->value->address;
 717         size = region->value->size;
 718
 719         monitor_printf(mon, "      BAR%" PRId64 ": ", region->value->bar);
 720
 721         if (!strcmp(region->value->type, "io")) {
 722             monitor_printf(mon, "I/O at 0x%04" PRIx64
 723                                 " [0x%04" PRIx64 "].\n",
 724                            addr, addr + size - 1);
 725         } else {
 726             monitor_printf(mon, "%d bit%s memory at 0x%08" PRIx64
 727                                " [0x%08" PRIx64 "].\n",
 728                            region->value->mem_type_64 ? 64 : 32,
 729                            region->value->prefetch ? " prefetchable" : "",
 730                            addr, addr + size - 1);
 731         }
 732     }
 733
 734     monitor_printf(mon, "      id \"%s\"\n", dev->qdev_id);
 735
 736     if (dev->has_pci_bridge) {
 737         if (dev->pci_bridge->has_devices) {
 738             PciDeviceInfoList *cdev;
 739             for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) {
 740                 hmp_info_pci_device(mon, cdev->value);
 741             }
 742         }
 743     }
 744 }
 745
 746 void hmp_info_pci(Monitor *mon, const QDict *qdict)
 747 {
 748     PciInfoList *info_list, *info;
 749     Error *err = NULL;
 750
 751     info_list = qmp_query_pci(&err);
 752     if (err) {
 753         monitor_printf(mon, "PCI devices not supported\n");
 754         error_free(err);
 755         return;
 756     }
 757
 758     for (info = info_list; info; info = info->next) {
 759         PciDeviceInfoList *dev;
 760
 761         for (dev = info->value->devices; dev; dev = dev->next) {
 762             hmp_info_pci_device(mon, dev->value);
 763         }
 764     }
 765
 766     qapi_free_PciInfoList(info_list);
 767 }
 768
 769 void hmp_info_block_jobs(Monitor *mon, const QDict *qdict)
 770 {
 771     BlockJobInfoList *list;
 772     Error *err = NULL;
 773
 774     list = qmp_query_block_jobs(&err);
 775     assert(!err);
 776
 777     if (!list) {
 778         monitor_printf(mon, "No active jobs\n");
 779         return;
 780     }
 781
 782     while (list) {
 783         if (strcmp(list->value->type, "stream") == 0) {
 784             monitor_printf(mon, "Streaming device %s: Completed %" PRId64
 785                            " of %" PRId64 " bytes, speed limit %" PRId64
 786                            " bytes/s\n",
 787                            list->value->device,
 788                            list->value->offset,
 789                            list->value->len,
 790                            list->value->speed);
 791         } else {
 792             monitor_printf(mon, "Type %s, device %s: Completed %" PRId64
 793                            " of %" PRId64 " bytes, speed limit %" PRId64
 794                            " bytes/s\n",
 795                            list->value->type,
 796                            list->value->device,
 797                            list->value->offset,
 798                            list->value->len,
 799                            list->value->speed);
 800         }
 801         list = list->next;
 802     }
 803
 804     qapi_free_BlockJobInfoList(list);
 805 }
 806
 807 void hmp_info_tpm(Monitor *mon, const QDict *qdict)
 808 {
 809     TPMInfoList *info_list, *info;
 810     Error *err = NULL;
 811     unsigned int c = 0;
 812     TPMPassthroughOptions *tpo;
 813
 814     info_list = qmp_query_tpm(&err);
 815     if (err) {
 816         monitor_printf(mon, "TPM device not supported\n");
 817         error_free(err);
 818         return;
 819     }
 820
 821     if (info_list) {
 822         monitor_printf(mon, "TPM device:\n");
 823     }
 824
 825     for (info = info_list; info; info = info->next) {
 826         TPMInfo *ti = info->value;
 827         monitor_printf(mon, " tpm%d: model=%s\n",
 828                        c, TpmModel_lookup[ti->model]);
 829
 830         monitor_printf(mon, "  \\ %s: type=%s",
 831                        ti->id, TpmTypeOptionsKind_lookup[ti->options->kind]);
 832
 833         switch (ti->options->kind) {
 834         case TPM_TYPE_OPTIONS_KIND_PASSTHROUGH:
 835             tpo = ti->options->passthrough;
 836             monitor_printf(mon, "%s%s%s%s",
 837                            tpo->has_path ? ",path=" : "",
 838                            tpo->has_path ? tpo->path : "",
 839                            tpo->has_cancel_path ? ",cancel-path=" : "",
 840                            tpo->has_cancel_path ? tpo->cancel_path : "");
 841             break;
 842         case TPM_TYPE_OPTIONS_KIND_MAX:
 843             break;
 844         }
 845         monitor_printf(mon, "\n");
 846         c++;
 847     }
 848     qapi_free_TPMInfoList(info_list);
 849 }
 850
 851 void hmp_quit(Monitor *mon, const QDict *qdict)
 852 {
 853     monitor_suspend(mon);
 854     qmp_quit(NULL);
 855 }
 856
 857 void hmp_stop(Monitor *mon, const QDict *qdict)
 858 {
 859     qmp_stop(NULL);
 860 }
 861
 862 void hmp_system_reset(Monitor *mon, const QDict *qdict)
 863 {
 864     qmp_system_reset(NULL);
 865 }
 866
 867 void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
 868 {
 869     qmp_system_powerdown(NULL);
 870 }
 871
 872 void hmp_cpu(Monitor *mon, const QDict *qdict)
 873 {
 874     int64_t cpu_index;
 875
 876     /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
 877             use it are converted to the QAPI */
 878     cpu_index = qdict_get_int(qdict, "index");
 879     if (monitor_set_cpu(cpu_index) < 0) {
 880         monitor_printf(mon, "invalid CPU index\n");
 881     }
 882 }
 883
 884 void hmp_memsave(Monitor *mon, const QDict *qdict)
 885 {
 886     uint32_t size = qdict_get_int(qdict, "size");
 887     const char *filename = qdict_get_str(qdict, "filename");
 888     uint64_t addr = qdict_get_int(qdict, "val");
 889     Error *err = NULL;
 890
 891     qmp_memsave(addr, size, filename, true, monitor_get_cpu_index(), &err);
 892     hmp_handle_error(mon, &err);
 893 }
 894
 895 void hmp_pmemsave(Monitor *mon, const QDict *qdict)
 896 {
 897     uint32_t size = qdict_get_int(qdict, "size");
 898     const char *filename = qdict_get_str(qdict, "filename");
 899     uint64_t addr = qdict_get_int(qdict, "val");
 900     Error *err = NULL;
 901
 902     qmp_pmemsave(addr, size, filename, &err);
 903     hmp_handle_error(mon, &err);
 904 }
 905
 906 void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
 907 {
 908     const char *chardev = qdict_get_str(qdict, "device");
 909     const char *data = qdict_get_str(qdict, "data");
 910     Error *err = NULL;
 911
 912     qmp_ringbuf_write(chardev, data, false, 0, &err);
 913
 914     hmp_handle_error(mon, &err);
 915 }
 916
 917 void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
 918 {
 919     uint32_t size = qdict_get_int(qdict, "size");
 920     const char *chardev = qdict_get_str(qdict, "device");
 921     char *data;
 922     Error *err = NULL;
 923     int i;
 924
 925     data = qmp_ringbuf_read(chardev, size, false, 0, &err);
 926     if (err) {
 927         monitor_printf(mon, "%s\n", error_get_pretty(err));
 928         error_free(err);
 929         return;
 930     }
 931
 932     for (i = 0; data[i]; i++) {
 933         unsigned char ch = data[i];
 934
 935         if (ch == '\\') {
 936             monitor_printf(mon, "\\\\");
 937         } else if ((ch < 0x20 && ch != '\n' && ch != '\t') || ch == 0x7F) {
 938             monitor_printf(mon, "\\u%04X", ch);
 939         } else {
 940             monitor_printf(mon, "%c", ch);
 941         }
 942
 943     }
 944     monitor_printf(mon, "\n");
 945     g_free(data);
 946 }
 947
 948 static void hmp_cont_cb(void *opaque, int err)
 949 {
 950     if (!err) {
 951         qmp_cont(NULL);
 952     }
 953 }
 954
 955 static bool key_is_missing(const BlockInfo *bdev)
 956 {
 957     return (bdev->inserted && bdev->inserted->encryption_key_missing);
 958 }
 959
 960 void hmp_cont(Monitor *mon, const QDict *qdict)
 961 {
 962     BlockInfoList *bdev_list, *bdev;
 963     Error *err = NULL;
 964
 965     bdev_list = qmp_query_block(NULL);
 966     for (bdev = bdev_list; bdev; bdev = bdev->next) {
 967         if (key_is_missing(bdev->value)) {
 968             monitor_read_block_device_key(mon, bdev->value->device,
 969                                           hmp_cont_cb, NULL);
 970             goto out;
 971         }
 972     }
 973
 974     qmp_cont(&err);
 975     hmp_handle_error(mon, &err);
 976
 977 out:
 978     qapi_free_BlockInfoList(bdev_list);
 979 }
 980
 981 void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
 982 {
 983     qmp_system_wakeup(NULL);
 984 }
 985
 986 void hmp_nmi(Monitor *mon, const QDict *qdict)
 987 {
 988     Error *err = NULL;
 989
 990     qmp_inject_nmi(&err);
 991     hmp_handle_error(mon, &err);
 992 }
 993
 994 void hmp_set_link(Monitor *mon, const QDict *qdict)
 995 {
 996     const char *name = qdict_get_str(qdict, "name");
 997     int up = qdict_get_bool(qdict, "up");
 998     Error *err = NULL;
 999
1000     qmp_set_link(name, up, &err);
1001     hmp_handle_error(mon, &err);
1002 }
1003
1004 void hmp_block_passwd(Monitor *mon, const QDict *qdict)
1005 {
1006     const char *device = qdict_get_str(qdict, "device");
1007     const char *password = qdict_get_str(qdict, "password");
1008     Error *err = NULL;
1009
1010     qmp_block_passwd(true, device, false, NULL, password, &err);
1011     hmp_handle_error(mon, &err);
1012 }
1013
1014 void hmp_balloon(Monitor *mon, const QDict *qdict)
1015 {
1016     int64_t value = qdict_get_int(qdict, "value");
1017     Error *err = NULL;
1018
1019     qmp_balloon(value, &err);
1020     if (err) {
1021         monitor_printf(mon, "balloon: %s\n", error_get_pretty(err));
1022         error_free(err);
1023     }
1024 }
1025
1026 void hmp_block_resize(Monitor *mon, const QDict *qdict)
1027 {
1028     const char *device = qdict_get_str(qdict, "device");
1029     int64_t size = qdict_get_int(qdict, "size");
1030     Error *err = NULL;
1031
1032     qmp_block_resize(true, device, false, NULL, size, &err);
1033     hmp_handle_error(mon, &err);
1034 }
1035
1036 void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
1037 {
1038     const char *device = qdict_get_str(qdict, "device");
1039     const char *filename = qdict_get_str(qdict, "target");
1040     const char *format = qdict_get_try_str(qdict, "format");
1041     int reuse = qdict_get_try_bool(qdict, "reuse", 0);
1042     int full = qdict_get_try_bool(qdict, "full", 0);
1043     enum NewImageMode mode;
1044     Error *err = NULL;
1045
1046     if (!filename) {
1047         error_set(&err, QERR_MISSING_PARAMETER, "target");
1048         hmp_handle_error(mon, &err);
1049         return;
1050     }
1051
1052     if (reuse) {
1053         mode = NEW_IMAGE_MODE_EXISTING;
1054     } else {
1055         mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1056     }
1057
1058     qmp_drive_mirror(device, filename, !!format, format,
1059                      false, NULL, false, NULL,
1060                      full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
1061                      true, mode, false, 0, false, 0, false, 0,
1062                      false, 0, false, 0, &err);
1063     hmp_handle_error(mon, &err);
1064 }
1065
1066 void hmp_drive_backup(Monitor *mon, const QDict *qdict)
1067 {
1068     const char *device = qdict_get_str(qdict, "device");
1069     const char *filename = qdict_get_str(qdict, "target");
1070     const char *format = qdict_get_try_str(qdict, "format");
1071     int reuse = qdict_get_try_bool(qdict, "reuse", 0);
1072     int full = qdict_get_try_bool(qdict, "full", 0);
1073     enum NewImageMode mode;
1074     Error *err = NULL;
1075
1076     if (!filename) {
1077         error_set(&err, QERR_MISSING_PARAMETER, "target");
1078         hmp_handle_error(mon, &err);
1079         return;
1080     }
1081
1082     if (reuse) {
1083         mode = NEW_IMAGE_MODE_EXISTING;
1084     } else {
1085         mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1086     }
1087
1088     qmp_drive_backup(device, filename, !!format, format,
1089                      full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
1090                      true, mode, false, 0, false, NULL,
1091                      false, 0, false, 0, &err);
1092     hmp_handle_error(mon, &err);
1093 }
1094
1095 void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
1096 {
1097     const char *device = qdict_get_str(qdict, "device");
1098     const char *filename = qdict_get_try_str(qdict, "snapshot-file");
1099     const char *format = qdict_get_try_str(qdict, "format");
1100     int reuse = qdict_get_try_bool(qdict, "reuse", 0);
1101     enum NewImageMode mode;
1102     Error *err = NULL;
1103
1104     if (!filename) {
1105         /* In the future, if 'snapshot-file' is not specified, the snapshot
1106            will be taken internally. Today it's actually required. */
1107         error_set(&err, QERR_MISSING_PARAMETER, "snapshot-file");
1108         hmp_handle_error(mon, &err);
1109         return;
1110     }
1111
1112     mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1113     qmp_blockdev_snapshot_sync(true, device, false, NULL,
1114                                filename, false, NULL,
1115                                !!format, format,
1116                                true, mode, &err);
1117     hmp_handle_error(mon, &err);
1118 }
1119
1120 void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict)
1121 {
1122     const char *device = qdict_get_str(qdict, "device");
1123     const char *name = qdict_get_str(qdict, "name");
1124     Error *err = NULL;
1125
1126     qmp_blockdev_snapshot_internal_sync(device, name, &err);
1127     hmp_handle_error(mon, &err);
1128 }
1129
1130 void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
1131 {
1132     const char *device = qdict_get_str(qdict, "device");
1133     const char *name = qdict_get_str(qdict, "name");
1134     const char *id = qdict_get_try_str(qdict, "id");
1135     Error *err = NULL;
1136
1137     qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id,
1138                                                true, name, &err);
1139     hmp_handle_error(mon, &err);
1140 }
1141
1142 void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
1143 {
1144     qmp_migrate_cancel(NULL);
1145 }
1146
1147 void hmp_migrate_incoming(Monitor *mon, const QDict *qdict)
1148 {
1149     Error *err = NULL;
1150     const char *uri = qdict_get_str(qdict, "uri");
1151
1152     qmp_migrate_incoming(uri, &err);
1153
1154     hmp_handle_error(mon, &err);
1155 }
1156
1157 void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
1158 {
1159     double value = qdict_get_double(qdict, "value");
1160     qmp_migrate_set_downtime(value, NULL);
1161 }
1162
1163 void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
1164 {
1165     int64_t value = qdict_get_int(qdict, "value");
1166     Error *err = NULL;
1167
1168     qmp_migrate_set_cache_size(value, &err);
1169     if (err) {
1170         monitor_printf(mon, "%s\n", error_get_pretty(err));
1171         error_free(err);
1172         return;
1173     }
1174 }
1175
1176 void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
1177 {
1178     int64_t value = qdict_get_int(qdict, "value");
1179     qmp_migrate_set_speed(value, NULL);
1180 }
1181
1182 void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict)
1183 {
1184     const char *cap = qdict_get_str(qdict, "capability");
1185     bool state = qdict_get_bool(qdict, "state");
1186     Error *err = NULL;
1187     MigrationCapabilityStatusList *caps = g_malloc0(sizeof(*caps));
1188     int i;
1189
1190     for (i = 0; i < MIGRATION_CAPABILITY_MAX; i++) {
1191         if (strcmp(cap, MigrationCapability_lookup[i]) == 0) {
1192             caps->value = g_malloc0(sizeof(*caps->value));
1193             caps->value->capability = i;
1194             caps->value->state = state;
1195             caps->next = NULL;
1196             qmp_migrate_set_capabilities(caps, &err);
1197             break;
1198         }
1199     }
1200
1201     if (i == MIGRATION_CAPABILITY_MAX) {
1202         error_set(&err, QERR_INVALID_PARAMETER, cap);
1203     }
1204
1205     qapi_free_MigrationCapabilityStatusList(caps);
1206
1207     if (err) {
1208         monitor_printf(mon, "migrate_set_capability: %s\n",
1209                        error_get_pretty(err));
1210         error_free(err);
1211     }
1212 }
1213
1214 void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
1215 {
1216     const char *param = qdict_get_str(qdict, "parameter");
1217     int value = qdict_get_int(qdict, "value");
1218     Error *err = NULL;
1219     bool has_compress_level = false;
1220     bool has_compress_threads = false;
1221     bool has_decompress_threads = false;
1222     int i;
1223
1224     for (i = 0; i < MIGRATION_PARAMETER_MAX; i++) {
1225         if (strcmp(param, MigrationParameter_lookup[i]) == 0) {
1226             switch (i) {
1227             case MIGRATION_PARAMETER_COMPRESS_LEVEL:
1228                 has_compress_level = true;
1229                 break;
1230             case MIGRATION_PARAMETER_COMPRESS_THREADS:
1231                 has_compress_threads = true;
1232                 break;
1233             case MIGRATION_PARAMETER_DECOMPRESS_THREADS:
1234                 has_decompress_threads = true;
1235                 break;
1236             }
1237             qmp_migrate_set_parameters(has_compress_level, value,
1238                                        has_compress_threads, value,
1239                                        has_decompress_threads, value,
1240                                        &err);
1241             break;
1242         }
1243     }
1244
1245     if (i == MIGRATION_PARAMETER_MAX) {
1246         error_set(&err, QERR_INVALID_PARAMETER, param);
1247     }
1248
1249     if (err) {
1250         monitor_printf(mon, "migrate_set_parameter: %s\n",
1251                        error_get_pretty(err));
1252         error_free(err);
1253     }
1254 }
1255
1256 void hmp_client_migrate_info(Monitor *mon, const QDict *qdict)
1257 {
1258     Error *err = NULL;
1259     const char *protocol = qdict_get_str(qdict, "protocol");
1260     const char *hostname = qdict_get_str(qdict, "hostname");
1261     bool has_port        = qdict_haskey(qdict, "port");
1262     int port             = qdict_get_try_int(qdict, "port", -1);
1263     bool has_tls_port    = qdict_haskey(qdict, "tls-port");
1264     int tls_port         = qdict_get_try_int(qdict, "tls-port", -1);
1265     const char *cert_subject = qdict_get_try_str(qdict, "cert-subject");
1266
1267     qmp_client_migrate_info(protocol, hostname,
1268                             has_port, port, has_tls_port, tls_port,
1269                             !!cert_subject, cert_subject, &err);
1270     hmp_handle_error(mon, &err);
1271 }
1272
1273 void hmp_set_password(Monitor *mon, const QDict *qdict)
1274 {
1275     const char *protocol  = qdict_get_str(qdict, "protocol");
1276     const char *password  = qdict_get_str(qdict, "password");
1277     const char *connected = qdict_get_try_str(qdict, "connected");
1278     Error *err = NULL;
1279
1280     qmp_set_password(protocol, password, !!connected, connected, &err);
1281     hmp_handle_error(mon, &err);
1282 }
1283
1284 void hmp_expire_password(Monitor *mon, const QDict *qdict)
1285 {
1286     const char *protocol  = qdict_get_str(qdict, "protocol");
1287     const char *whenstr = qdict_get_str(qdict, "time");
1288     Error *err = NULL;
1289
1290     qmp_expire_password(protocol, whenstr, &err);
1291     hmp_handle_error(mon, &err);
1292 }
1293
1294 void hmp_eject(Monitor *mon, const QDict *qdict)
1295 {
1296     int force = qdict_get_try_bool(qdict, "force", 0);
1297     const char *device = qdict_get_str(qdict, "device");
1298     Error *err = NULL;
1299
1300     qmp_eject(device, true, force, &err);
1301     hmp_handle_error(mon, &err);
1302 }
1303
1304 static void hmp_change_read_arg(void *opaque, const char *password,
1305                                 void *readline_opaque)
1306 {
1307     qmp_change_vnc_password(password, NULL);
1308     monitor_read_command(opaque, 1);
1309 }
1310
1311 void hmp_change(Monitor *mon, const QDict *qdict)
1312 {
1313     const char *device = qdict_get_str(qdict, "device");
1314     const char *target = qdict_get_str(qdict, "target");
1315     const char *arg = qdict_get_try_str(qdict, "arg");
1316     Error *err = NULL;
1317
1318     if (strcmp(device, "vnc") == 0 &&
1319             (strcmp(target, "passwd") == 0 ||
1320              strcmp(target, "password") == 0)) {
1321         if (!arg) {
1322             monitor_read_password(mon, hmp_change_read_arg, NULL);
1323             return;
1324         }
1325     }
1326
1327     qmp_change(device, target, !!arg, arg, &err);
1328     if (err &&
1329         error_get_class(err) == ERROR_CLASS_DEVICE_ENCRYPTED) {
1330         error_free(err);
1331         monitor_read_block_device_key(mon, device, NULL, NULL);
1332         return;
1333     }
1334     hmp_handle_error(mon, &err);
1335 }
1336
1337 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
1338 {
1339     Error *err = NULL;
1340
1341     qmp_block_set_io_throttle(qdict_get_str(qdict, "device"),
1342                               qdict_get_int(qdict, "bps"),
1343                               qdict_get_int(qdict, "bps_rd"),
1344                               qdict_get_int(qdict, "bps_wr"),
1345                               qdict_get_int(qdict, "iops"),
1346                               qdict_get_int(qdict, "iops_rd"),
1347                               qdict_get_int(qdict, "iops_wr"),
1348                               false, /* no burst max via HMP */
1349                               0,
1350                               false,
1351                               0,
1352                               false,
1353                               0,
1354                               false,
1355                               0,
1356                               false,
1357                               0,
1358                               false,
1359                               0,
1360                               false, /* No default I/O size */
1361                               0,
1362                               false,
1363                               NULL, &err);
1364     hmp_handle_error(mon, &err);
1365 }
1366
1367 void hmp_block_stream(Monitor *mon, const QDict *qdict)
1368 {
1369     Error *error = NULL;
1370     const char *device = qdict_get_str(qdict, "device");
1371     const char *base = qdict_get_try_str(qdict, "base");
1372     int64_t speed = qdict_get_try_int(qdict, "speed", 0);
1373
1374     qmp_block_stream(device, base != NULL, base, false, NULL,
1375                      qdict_haskey(qdict, "speed"), speed,
1376                      true, BLOCKDEV_ON_ERROR_REPORT, &error);
1377
1378     hmp_handle_error(mon, &error);
1379 }
1380
1381 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
1382 {
1383     Error *error = NULL;
1384     const char *device = qdict_get_str(qdict, "device");
1385     int64_t value = qdict_get_int(qdict, "speed");
1386
1387     qmp_block_job_set_speed(device, value, &error);
1388
1389     hmp_handle_error(mon, &error);
1390 }
1391
1392 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
1393 {
1394     Error *error = NULL;
1395     const char *device = qdict_get_str(qdict, "device");
1396     bool force = qdict_get_try_bool(qdict, "force", 0);
1397
1398     qmp_block_job_cancel(device, true, force, &error);
1399
1400     hmp_handle_error(mon, &error);
1401 }
1402
1403 void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
1404 {
1405     Error *error = NULL;
1406     const char *device = qdict_get_str(qdict, "device");
1407
1408     qmp_block_job_pause(device, &error);
1409
1410     hmp_handle_error(mon, &error);
1411 }
1412
1413 void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
1414 {
1415     Error *error = NULL;
1416     const char *device = qdict_get_str(qdict, "device");
1417
1418     qmp_block_job_resume(device, &error);
1419
1420     hmp_handle_error(mon, &error);
1421 }
1422
1423 void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
1424 {
1425     Error *error = NULL;
1426     const char *device = qdict_get_str(qdict, "device");
1427
1428     qmp_block_job_complete(device, &error);
1429
1430     hmp_handle_error(mon, &error);
1431 }
1432
1433 typedef struct HMPMigrationStatus
1434 {
1435     QEMUTimer *timer;
1436     Monitor *mon;
1437     bool is_block_migration;
1438 } HMPMigrationStatus;
1439
1440 static void hmp_migrate_status_cb(void *opaque)
1441 {
1442     HMPMigrationStatus *status = opaque;
1443     MigrationInfo *info;
1444
1445     info = qmp_query_migrate(NULL);
1446     if (!info->has_status || info->status == MIGRATION_STATUS_ACTIVE ||
1447         info->status == MIGRATION_STATUS_SETUP) {
1448         if (info->has_disk) {
1449             int progress;
1450
1451             if (info->disk->remaining) {
1452                 progress = info->disk->transferred * 100 / info->disk->total;
1453             } else {
1454                 progress = 100;
1455             }
1456
1457             monitor_printf(status->mon, "Completed %d %%\r", progress);
1458             monitor_flush(status->mon);
1459         }
1460
1461         timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
1462     } else {
1463         if (status->is_block_migration) {
1464             monitor_printf(status->mon, "\n");
1465         }
1466         monitor_resume(status->mon);
1467         timer_del(status->timer);
1468         g_free(status);
1469     }
1470
1471     qapi_free_MigrationInfo(info);
1472 }
1473
1474 void hmp_migrate(Monitor *mon, const QDict *qdict)
1475 {
1476     int detach = qdict_get_try_bool(qdict, "detach", 0);
1477     int blk = qdict_get_try_bool(qdict, "blk", 0);
1478     int inc = qdict_get_try_bool(qdict, "inc", 0);
1479     const char *uri = qdict_get_str(qdict, "uri");
1480     Error *err = NULL;
1481
1482     qmp_migrate(uri, !!blk, blk, !!inc, inc, false, false, &err);
1483     if (err) {
1484         monitor_printf(mon, "migrate: %s\n", error_get_pretty(err));
1485         error_free(err);
1486         return;
1487     }
1488
1489     if (!detach) {
1490         HMPMigrationStatus *status;
1491
1492         if (monitor_suspend(mon) < 0) {
1493             monitor_printf(mon, "terminal does not allow synchronous "
1494                            "migration, continuing detached\n");
1495             return;
1496         }
1497
1498         status = g_malloc0(sizeof(*status));
1499         status->mon = mon;
1500         status->is_block_migration = blk || inc;
1501         status->timer = timer_new_ms(QEMU_CLOCK_REALTIME, hmp_migrate_status_cb,
1502                                           status);
1503         timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
1504     }
1505 }
1506
1507 void hmp_device_add(Monitor *mon, const QDict *qdict)
1508 {
1509     do_device_add(mon, qdict, NULL);
1510 }
1511
1512 void hmp_device_del(Monitor *mon, const QDict *qdict)
1513 {
1514     const char *id = qdict_get_str(qdict, "id");
1515     Error *err = NULL;
1516
1517     qmp_device_del(id, &err);
1518     hmp_handle_error(mon, &err);
1519 }
1520
1521 void hmp_dump_guest_memory(Monitor *mon, const QDict *qdict)
1522 {
1523     Error *err = NULL;
1524     int paging = qdict_get_try_bool(qdict, "paging", 0);
1525     int zlib = qdict_get_try_bool(qdict, "zlib", 0);
1526     int lzo = qdict_get_try_bool(qdict, "lzo", 0);
1527     int snappy = qdict_get_try_bool(qdict, "snappy", 0);
1528     const char *file = qdict_get_str(qdict, "filename");
1529     bool has_begin = qdict_haskey(qdict, "begin");
1530     bool has_length = qdict_haskey(qdict, "length");
1531     int64_t begin = 0;
1532     int64_t length = 0;
1533     enum DumpGuestMemoryFormat dump_format = DUMP_GUEST_MEMORY_FORMAT_ELF;
1534     char *prot;
1535
1536     if (zlib + lzo + snappy > 1) {
1537         error_setg(&err, "only one of '-z|-l|-s' can be set");
1538         hmp_handle_error(mon, &err);
1539         return;
1540     }
1541
1542     if (zlib) {
1543         dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
1544     }
1545
1546     if (lzo) {
1547         dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
1548     }
1549
1550     if (snappy) {
1551         dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
1552     }
1553
1554     if (has_begin) {
1555         begin = qdict_get_int(qdict, "begin");
1556     }
1557     if (has_length) {
1558         length = qdict_get_int(qdict, "length");
1559     }
1560
1561     prot = g_strconcat("file:", file, NULL);
1562
1563     qmp_dump_guest_memory(paging, prot, has_begin, begin, has_length, length,
1564                           true, dump_format, &err);
1565     hmp_handle_error(mon, &err);
1566     g_free(prot);
1567 }
1568
1569 void hmp_netdev_add(Monitor *mon, const QDict *qdict)
1570 {
1571     Error *err = NULL;
1572     QemuOpts *opts;
1573
1574     opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &err);
1575     if (err) {
1576         goto out;
1577     }
1578
1579     netdev_add(opts, &err);
1580     if (err) {
1581         qemu_opts_del(opts);
1582     }
1583
1584 out:
1585     hmp_handle_error(mon, &err);
1586 }
1587
1588 void hmp_netdev_del(Monitor *mon, const QDict *qdict)
1589 {
1590     const char *id = qdict_get_str(qdict, "id");
1591     Error *err = NULL;
1592
1593     qmp_netdev_del(id, &err);
1594     hmp_handle_error(mon, &err);
1595 }
1596
1597 void hmp_object_add(Monitor *mon, const QDict *qdict)
1598 {
1599     Error *err = NULL;
1600     Error *err_end = NULL;
1601     QemuOpts *opts;
1602     char *type = NULL;
1603     char *id = NULL;
1604     void *dummy = NULL;
1605     OptsVisitor *ov;
1606     QDict *pdict;
1607
1608     opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
1609     if (err) {
1610         goto out;
1611     }
1612
1613     ov = opts_visitor_new(opts);
1614     pdict = qdict_clone_shallow(qdict);
1615
1616     visit_start_struct(opts_get_visitor(ov), &dummy, NULL, NULL, 0, &err);
1617     if (err) {
1618         goto out_clean;
1619     }
1620
1621     qdict_del(pdict, "qom-type");
1622     visit_type_str(opts_get_visitor(ov), &type, "qom-type", &err);
1623     if (err) {
1624         goto out_end;
1625     }
1626
1627     qdict_del(pdict, "id");
1628     visit_type_str(opts_get_visitor(ov), &id, "id", &err);
1629     if (err) {
1630         goto out_end;
1631     }
1632
1633     object_add(type, id, pdict, opts_get_visitor(ov), &err);
1634
1635 out_end:
1636     visit_end_struct(opts_get_visitor(ov), &err_end);
1637     if (!err && err_end) {
1638         qmp_object_del(id, NULL);
1639     }
1640     error_propagate(&err, err_end);
1641 out_clean:
1642     opts_visitor_cleanup(ov);
1643
1644     QDECREF(pdict);
1645     qemu_opts_del(opts);
1646     g_free(id);
1647     g_free(type);
1648     g_free(dummy);
1649
1650 out:
1651     hmp_handle_error(mon, &err);
1652 }
1653
1654 void hmp_getfd(Monitor *mon, const QDict *qdict)
1655 {
1656     const char *fdname = qdict_get_str(qdict, "fdname");
1657     Error *err = NULL;
1658
1659     qmp_getfd(fdname, &err);
1660     hmp_handle_error(mon, &err);
1661 }
1662
1663 void hmp_closefd(Monitor *mon, const QDict *qdict)
1664 {
1665     const char *fdname = qdict_get_str(qdict, "fdname");
1666     Error *err = NULL;
1667
1668     qmp_closefd(fdname, &err);
1669     hmp_handle_error(mon, &err);
1670 }
1671
1672 void hmp_sendkey(Monitor *mon, const QDict *qdict)
1673 {
1674     const char *keys = qdict_get_str(qdict, "keys");
1675     KeyValueList *keylist, *head = NULL, *tmp = NULL;
1676     int has_hold_time = qdict_haskey(qdict, "hold-time");
1677     int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
1678     Error *err = NULL;
1679     char keyname_buf[16];
1680     char *separator;
1681     int keyname_len;
1682
1683     while (1) {
1684         separator = strchr(keys, '-');
1685         keyname_len = separator ? separator - keys : strlen(keys);
1686         pstrcpy(keyname_buf, sizeof(keyname_buf), keys);
1687
1688         /* Be compatible with old interface, convert user inputted "<" */
1689         if (!strncmp(keyname_buf, "<", 1) && keyname_len == 1) {
1690             pstrcpy(keyname_buf, sizeof(keyname_buf), "less");
1691             keyname_len = 4;
1692         }
1693         keyname_buf[keyname_len] = 0;
1694
1695         keylist = g_malloc0(sizeof(*keylist));
1696         keylist->value = g_malloc0(sizeof(*keylist->value));
1697
1698         if (!head) {
1699             head = keylist;
1700         }
1701         if (tmp) {
1702             tmp->next = keylist;
1703         }
1704         tmp = keylist;
1705
1706         if (strstart(keyname_buf, "0x", NULL)) {
1707             char *endp;
1708             int value = strtoul(keyname_buf, &endp, 0);
1709             if (*endp != '\0') {
1710                 goto err_out;
1711             }
1712             keylist->value->kind = KEY_VALUE_KIND_NUMBER;
1713             keylist->value->number = value;
1714         } else {
1715             int idx = index_from_key(keyname_buf);
1716             if (idx == Q_KEY_CODE_MAX) {
1717                 goto err_out;
1718             }
1719             keylist->value->kind = KEY_VALUE_KIND_QCODE;
1720             keylist->value->qcode = idx;
1721         }
1722
1723         if (!separator) {
1724             break;
1725         }
1726         keys = separator + 1;
1727     }
1728
1729     qmp_send_key(head, has_hold_time, hold_time, &err);
1730     hmp_handle_error(mon, &err);
1731
1732 out:
1733     qapi_free_KeyValueList(head);
1734     return;
1735
1736 err_out:
1737     monitor_printf(mon, "invalid parameter: %s\n", keyname_buf);
1738     goto out;
1739 }
1740
1741 void hmp_screendump(Monitor *mon, const QDict *qdict)
1742 {
1743     const char *filename = qdict_get_str(qdict, "filename");
1744     Error *err = NULL;
1745
1746     qmp_screendump(filename, &err);
1747     hmp_handle_error(mon, &err);
1748 }
1749
1750 void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
1751 {
1752     const char *uri = qdict_get_str(qdict, "uri");
1753     int writable = qdict_get_try_bool(qdict, "writable", 0);
1754     int all = qdict_get_try_bool(qdict, "all", 0);
1755     Error *local_err = NULL;
1756     BlockInfoList *block_list, *info;
1757     SocketAddress *addr;
1758
1759     if (writable && !all) {
1760         error_setg(&local_err, "-w only valid together with -a");
1761         goto exit;
1762     }
1763
1764     /* First check if the address is valid and start the server.  */
1765     addr = socket_parse(uri, &local_err);
1766     if (local_err != NULL) {
1767         goto exit;
1768     }
1769
1770     qmp_nbd_server_start(addr, &local_err);
1771     qapi_free_SocketAddress(addr);
1772     if (local_err != NULL) {
1773         goto exit;
1774     }
1775
1776     if (!all) {
1777         return;
1778     }
1779
1780     /* Then try adding all block devices.  If one fails, close all and
1781      * exit.
1782      */
1783     block_list = qmp_query_block(NULL);
1784
1785     for (info = block_list; info; info = info->next) {
1786         if (!info->value->has_inserted) {
1787             continue;
1788         }
1789
1790         qmp_nbd_server_add(info->value->device, true, writable, &local_err);
1791
1792         if (local_err != NULL) {
1793             qmp_nbd_server_stop(NULL);
1794             break;
1795         }
1796     }
1797
1798     qapi_free_BlockInfoList(block_list);
1799
1800 exit:
1801     hmp_handle_error(mon, &local_err);
1802 }
1803
1804 void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
1805 {
1806     const char *device = qdict_get_str(qdict, "device");
1807     int writable = qdict_get_try_bool(qdict, "writable", 0);
1808     Error *local_err = NULL;
1809
1810     qmp_nbd_server_add(device, true, writable, &local_err);
1811
1812     if (local_err != NULL) {
1813         hmp_handle_error(mon, &local_err);
1814     }
1815 }
1816
1817 void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
1818 {
1819     Error *err = NULL;
1820
1821     qmp_nbd_server_stop(&err);
1822     hmp_handle_error(mon, &err);
1823 }
1824
1825 void hmp_cpu_add(Monitor *mon, const QDict *qdict)
1826 {
1827     int cpuid;
1828     Error *err = NULL;
1829
1830     cpuid = qdict_get_int(qdict, "id");
1831     qmp_cpu_add(cpuid, &err);
1832     hmp_handle_error(mon, &err);
1833 }
1834
1835 void hmp_chardev_add(Monitor *mon, const QDict *qdict)
1836 {
1837     const char *args = qdict_get_str(qdict, "args");
1838     Error *err = NULL;
1839     QemuOpts *opts;
1840
1841     opts = qemu_opts_parse(qemu_find_opts("chardev"), args, 1);
1842     if (opts == NULL) {
1843         error_setg(&err, "Parsing chardev args failed");
1844     } else {
1845         qemu_chr_new_from_opts(opts, NULL, &err);
1846     }
1847     hmp_handle_error(mon, &err);
1848 }
1849
1850 void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
1851 {
1852     Error *local_err = NULL;
1853
1854     qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
1855     hmp_handle_error(mon, &local_err);
1856 }
1857
1858 void hmp_qemu_io(Monitor *mon, const QDict *qdict)
1859 {
1860     BlockBackend *blk;
1861     const char* device = qdict_get_str(qdict, "device");
1862     const char* command = qdict_get_str(qdict, "command");
1863     Error *err = NULL;
1864
1865     blk = blk_by_name(device);
1866     if (blk) {
1867         qemuio_command(blk, command);
1868     } else {
1869         error_set(&err, QERR_DEVICE_NOT_FOUND, device);
1870     }
1871
1872     hmp_handle_error(mon, &err);
1873 }
1874
1875 void hmp_object_del(Monitor *mon, const QDict *qdict)
1876 {
1877     const char *id = qdict_get_str(qdict, "id");
1878     Error *err = NULL;
1879
1880     qmp_object_del(id, &err);
1881     hmp_handle_error(mon, &err);
1882 }
1883
1884 void hmp_info_memdev(Monitor *mon, const QDict *qdict)
1885 {
1886     Error *err = NULL;
1887     MemdevList *memdev_list = qmp_query_memdev(&err);
1888     MemdevList *m = memdev_list;
1889     StringOutputVisitor *ov;
1890     char *str;
1891     int i = 0;
1892
1893
1894     while (m) {
1895         ov = string_output_visitor_new(false);
1896         visit_type_uint16List(string_output_get_visitor(ov),
1897                               &m->value->host_nodes, NULL, NULL);
1898         monitor_printf(mon, "memory backend: %d\n", i);
1899         monitor_printf(mon, "  size:  %" PRId64 "\n", m->value->size);
1900         monitor_printf(mon, "  merge: %s\n",
1901                        m->value->merge ? "true" : "false");
1902         monitor_printf(mon, "  dump: %s\n",
1903                        m->value->dump ? "true" : "false");
1904         monitor_printf(mon, "  prealloc: %s\n",
1905                        m->value->prealloc ? "true" : "false");
1906         monitor_printf(mon, "  policy: %s\n",
1907                        HostMemPolicy_lookup[m->value->policy]);
1908         str = string_output_get_string(ov);
1909         monitor_printf(mon, "  host nodes: %s\n", str);
1910
1911         g_free(str);
1912         string_output_visitor_cleanup(ov);
1913         m = m->next;
1914         i++;
1915     }
1916
1917     monitor_printf(mon, "\n");
1918
1919     qapi_free_MemdevList(memdev_list);
1920 }
1921
1922 void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
1923 {
1924     Error *err = NULL;
1925     MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
1926     MemoryDeviceInfoList *info;
1927     MemoryDeviceInfo *value;
1928     PCDIMMDeviceInfo *di;
1929
1930     for (info = info_list; info; info = info->next) {
1931         value = info->value;
1932
1933         if (value) {
1934             switch (value->kind) {
1935             case MEMORY_DEVICE_INFO_KIND_DIMM:
1936                 di = value->dimm;
1937
1938                 monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
1939                                MemoryDeviceInfoKind_lookup[value->kind],
1940                                di->id ? di->id : "");
1941                 monitor_printf(mon, "  addr: 0x%" PRIx64 "\n", di->addr);
1942                 monitor_printf(mon, "  slot: %" PRId64 "\n", di->slot);
1943                 monitor_printf(mon, "  node: %" PRId64 "\n", di->node);
1944                 monitor_printf(mon, "  size: %" PRIu64 "\n", di->size);
1945                 monitor_printf(mon, "  memdev: %s\n", di->memdev);
1946                 monitor_printf(mon, "  hotplugged: %s\n",
1947                                di->hotplugged ? "true" : "false");
1948                 monitor_printf(mon, "  hotpluggable: %s\n",
1949                                di->hotpluggable ? "true" : "false");
1950                 break;
1951             default:
1952                 break;
1953             }
1954         }
1955     }
1956
1957     qapi_free_MemoryDeviceInfoList(info_list);
1958 }
1959
1960 void hmp_qom_list(Monitor *mon, const QDict *qdict)
1961 {
1962     const char *path = qdict_get_try_str(qdict, "path");
1963     ObjectPropertyInfoList *list;
1964     Error *err = NULL;
1965
1966     if (path == NULL) {
1967         monitor_printf(mon, "/\n");
1968         return;
1969     }
1970
1971     list = qmp_qom_list(path, &err);
1972     if (err == NULL) {
1973         ObjectPropertyInfoList *start = list;
1974         while (list != NULL) {
1975             ObjectPropertyInfo *value = list->value;
1976
1977             monitor_printf(mon, "%s (%s)\n",
1978                            value->name, value->type);
1979             list = list->next;
1980         }
1981         qapi_free_ObjectPropertyInfoList(start);
1982     }
1983     hmp_handle_error(mon, &err);
1984 }
1985
1986 void hmp_qom_set(Monitor *mon, const QDict *qdict)
1987 {
1988     const char *path = qdict_get_str(qdict, "path");
1989     const char *property = qdict_get_str(qdict, "property");
1990     const char *value = qdict_get_str(qdict, "value");
1991     Error *err = NULL;
1992     bool ambiguous = false;
1993     Object *obj;
1994
1995     obj = object_resolve_path(path, &ambiguous);
1996     if (obj == NULL) {
1997         error_set(&err, QERR_DEVICE_NOT_FOUND, path);
1998     } else {
1999         if (ambiguous) {
2000             monitor_printf(mon, "Warning: Path '%s' is ambiguous\n", path);
2001         }
2002         object_property_parse(obj, value, property, &err);
2003     }
2004     hmp_handle_error(mon, &err);
2005 }