hmp.c

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