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