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