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