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