monitor/hmp-cmds.c

   1 /*
   2  * Human Monitor Interface commands
   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 "qemu/osdep.h"
  17 #include "monitor/hmp.h"
  18 #include "net/net.h"
  19 #include "net/eth.h"
  20 #include "chardev/char.h"
  21 #include "sysemu/block-backend.h"
  22 #include "sysemu/runstate.h"
  23 #include "qemu/config-file.h"
  24 #include "qemu/option.h"
  25 #include "qemu/timer.h"
  26 #include "qemu/sockets.h"
  27 #include "qemu/help_option.h"
  28 #include "monitor/monitor-internal.h"
  29 #include "qapi/error.h"
  30 #include "qapi/clone-visitor.h"
  31 #include "qapi/opts-visitor.h"
  32 #include "qapi/qapi-builtin-visit.h"
  33 #include "qapi/qapi-commands-block.h"
  34 #include "qapi/qapi-commands-char.h"
  35 #include "qapi/qapi-commands-control.h"
  36 #include "qapi/qapi-commands-machine.h"
  37 #include "qapi/qapi-commands-migration.h"
  38 #include "qapi/qapi-commands-misc.h"
  39 #include "qapi/qapi-commands-net.h"
  40 #include "qapi/qapi-commands-pci.h"
  41 #include "qapi/qapi-commands-rocker.h"
  42 #include "qapi/qapi-commands-run-state.h"
  43 #include "qapi/qapi-commands-tpm.h"
  44 #include "qapi/qapi-commands-ui.h"
  45 #include "qapi/qapi-visit-net.h"
  46 #include "qapi/qapi-visit-migration.h"
  47 #include "qapi/qmp/qdict.h"
  48 #include "qapi/qmp/qerror.h"
  49 #include "qapi/string-input-visitor.h"
  50 #include "qapi/string-output-visitor.h"
  51 #include "qom/object_interfaces.h"
  52 #include "ui/console.h"
  53 #include "qemu/cutils.h"
  54 #include "qemu/error-report.h"
  55 #include "exec/ramlist.h"
  56 #include "hw/intc/intc.h"
  57 #include "hw/rdma/rdma.h"
  58 #include "migration/snapshot.h"
  59 #include "migration/misc.h"
  60
  61 #ifdef CONFIG_SPICE
  62 #include <spice/enums.h>
  63 #endif
  64
  65 void hmp_handle_error(Monitor *mon, Error *err)
  66 {
  67     if (err) {
  68         error_reportf_err(err, "Error: ");
  69     }
  70 }
  71
  72 /*
  73  * Produce a strList from a comma separated list.
  74  * A NULL or empty input string return NULL.
  75  */
  76 static strList *strList_from_comma_list(const char *in)
  77 {
  78     strList *res = NULL;
  79     strList **tail = &res;
  80
  81     while (in && in[0]) {
  82         char *comma = strchr(in, ',');
  83         char *value;
  84
  85         if (comma) {
  86             value = g_strndup(in, comma - in);
  87             in = comma + 1; /* skip the , */
  88         } else {
  89             value = g_strdup(in);
  90             in = NULL;
  91         }
  92         QAPI_LIST_APPEND(tail, value);
  93     }
  94
  95     return res;
  96 }
  97
  98 void hmp_info_name(Monitor *mon, const QDict *qdict)
  99 {
 100     NameInfo *info;
 101
 102     info = qmp_query_name(NULL);
 103     if (info->has_name) {
 104         monitor_printf(mon, "%s\n", info->name);
 105     }
 106     qapi_free_NameInfo(info);
 107 }
 108
 109 void hmp_info_version(Monitor *mon, const QDict *qdict)
 110 {
 111     VersionInfo *info;
 112
 113     info = qmp_query_version(NULL);
 114
 115     monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
 116                    info->qemu->major, info->qemu->minor, info->qemu->micro,
 117                    info->package);
 118
 119     qapi_free_VersionInfo(info);
 120 }
 121
 122 void hmp_info_kvm(Monitor *mon, const QDict *qdict)
 123 {
 124     KvmInfo *info;
 125
 126     info = qmp_query_kvm(NULL);
 127     monitor_printf(mon, "kvm support: ");
 128     if (info->present) {
 129         monitor_printf(mon, "%s\n", info->enabled ? "enabled" : "disabled");
 130     } else {
 131         monitor_printf(mon, "not compiled\n");
 132     }
 133
 134     qapi_free_KvmInfo(info);
 135 }
 136
 137 void hmp_info_status(Monitor *mon, const QDict *qdict)
 138 {
 139     StatusInfo *info;
 140
 141     info = qmp_query_status(NULL);
 142
 143     monitor_printf(mon, "VM status: %s%s",
 144                    info->running ? "running" : "paused",
 145                    info->singlestep ? " (single step mode)" : "");
 146
 147     if (!info->running && info->status != RUN_STATE_PAUSED) {
 148         monitor_printf(mon, " (%s)", RunState_str(info->status));
 149     }
 150
 151     monitor_printf(mon, "\n");
 152
 153     qapi_free_StatusInfo(info);
 154 }
 155
 156 void hmp_info_uuid(Monitor *mon, const QDict *qdict)
 157 {
 158     UuidInfo *info;
 159
 160     info = qmp_query_uuid(NULL);
 161     monitor_printf(mon, "%s\n", info->UUID);
 162     qapi_free_UuidInfo(info);
 163 }
 164
 165 void hmp_info_chardev(Monitor *mon, const QDict *qdict)
 166 {
 167     ChardevInfoList *char_info, *info;
 168
 169     char_info = qmp_query_chardev(NULL);
 170     for (info = char_info; info; info = info->next) {
 171         monitor_printf(mon, "%s: filename=%s\n", info->value->label,
 172                                                  info->value->filename);
 173     }
 174
 175     qapi_free_ChardevInfoList(char_info);
 176 }
 177
 178 void hmp_info_mice(Monitor *mon, const QDict *qdict)
 179 {
 180     MouseInfoList *mice_list, *mouse;
 181
 182     mice_list = qmp_query_mice(NULL);
 183     if (!mice_list) {
 184         monitor_printf(mon, "No mouse devices connected\n");
 185         return;
 186     }
 187
 188     for (mouse = mice_list; mouse; mouse = mouse->next) {
 189         monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n",
 190                        mouse->value->current ? '*' : ' ',
 191                        mouse->value->index, mouse->value->name,
 192                        mouse->value->absolute ? " (absolute)" : "");
 193     }
 194
 195     qapi_free_MouseInfoList(mice_list);
 196 }
 197
 198 static char *SocketAddress_to_str(SocketAddress *addr)
 199 {
 200     switch (addr->type) {
 201     case SOCKET_ADDRESS_TYPE_INET:
 202         return g_strdup_printf("tcp:%s:%s",
 203                                addr->u.inet.host,
 204                                addr->u.inet.port);
 205     case SOCKET_ADDRESS_TYPE_UNIX:
 206         return g_strdup_printf("unix:%s",
 207                                addr->u.q_unix.path);
 208     case SOCKET_ADDRESS_TYPE_FD:
 209         return g_strdup_printf("fd:%s", addr->u.fd.str);
 210     case SOCKET_ADDRESS_TYPE_VSOCK:
 211         return g_strdup_printf("tcp:%s:%s",
 212                                addr->u.vsock.cid,
 213                                addr->u.vsock.port);
 214     default:
 215         return g_strdup("unknown address type");
 216     }
 217 }
 218
 219 void hmp_info_migrate(Monitor *mon, const QDict *qdict)
 220 {
 221     MigrationInfo *info;
 222
 223     info = qmp_query_migrate(NULL);
 224
 225     migration_global_dump(mon);
 226
 227     if (info->blocked) {
 228         strList *reasons = info->blocked_reasons;
 229         monitor_printf(mon, "Outgoing migration blocked:\n");
 230         while (reasons) {
 231             monitor_printf(mon, "  %s\n", reasons->value);
 232             reasons = reasons->next;
 233         }
 234     }
 235
 236     if (info->has_status) {
 237         monitor_printf(mon, "Migration status: %s",
 238                        MigrationStatus_str(info->status));
 239         if (info->status == MIGRATION_STATUS_FAILED &&
 240             info->has_error_desc) {
 241             monitor_printf(mon, " (%s)\n", info->error_desc);
 242         } else {
 243             monitor_printf(mon, "\n");
 244         }
 245
 246         monitor_printf(mon, "total time: %" PRIu64 " ms\n",
 247                        info->total_time);
 248         if (info->has_expected_downtime) {
 249             monitor_printf(mon, "expected downtime: %" PRIu64 " ms\n",
 250                            info->expected_downtime);
 251         }
 252         if (info->has_downtime) {
 253             monitor_printf(mon, "downtime: %" PRIu64 " ms\n",
 254                            info->downtime);
 255         }
 256         if (info->has_setup_time) {
 257             monitor_printf(mon, "setup: %" PRIu64 " ms\n",
 258                            info->setup_time);
 259         }
 260     }
 261
 262     if (info->has_ram) {
 263         monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
 264                        info->ram->transferred >> 10);
 265         monitor_printf(mon, "throughput: %0.2f mbps\n",
 266                        info->ram->mbps);
 267         monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",
 268                        info->ram->remaining >> 10);
 269         monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",
 270                        info->ram->total >> 10);
 271         monitor_printf(mon, "duplicate: %" PRIu64 " pages\n",
 272                        info->ram->duplicate);
 273         monitor_printf(mon, "skipped: %" PRIu64 " pages\n",
 274                        info->ram->skipped);
 275         monitor_printf(mon, "normal: %" PRIu64 " pages\n",
 276                        info->ram->normal);
 277         monitor_printf(mon, "normal bytes: %" PRIu64 " kbytes\n",
 278                        info->ram->normal_bytes >> 10);
 279         monitor_printf(mon, "dirty sync count: %" PRIu64 "\n",
 280                        info->ram->dirty_sync_count);
 281         monitor_printf(mon, "page size: %" PRIu64 " kbytes\n",
 282                        info->ram->page_size >> 10);
 283         monitor_printf(mon, "multifd bytes: %" PRIu64 " kbytes\n",
 284                        info->ram->multifd_bytes >> 10);
 285         monitor_printf(mon, "pages-per-second: %" PRIu64 "\n",
 286                        info->ram->pages_per_second);
 287
 288         if (info->ram->dirty_pages_rate) {
 289             monitor_printf(mon, "dirty pages rate: %" PRIu64 " pages\n",
 290                            info->ram->dirty_pages_rate);
 291         }
 292         if (info->ram->postcopy_requests) {
 293             monitor_printf(mon, "postcopy request count: %" PRIu64 "\n",
 294                            info->ram->postcopy_requests);
 295         }
 296     }
 297
 298     if (info->has_disk) {
 299         monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n",
 300                        info->disk->transferred >> 10);
 301         monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n",
 302                        info->disk->remaining >> 10);
 303         monitor_printf(mon, "total disk: %" PRIu64 " kbytes\n",
 304                        info->disk->total >> 10);
 305     }
 306
 307     if (info->has_xbzrle_cache) {
 308         monitor_printf(mon, "cache size: %" PRIu64 " bytes\n",
 309                        info->xbzrle_cache->cache_size);
 310         monitor_printf(mon, "xbzrle transferred: %" PRIu64 " kbytes\n",
 311                        info->xbzrle_cache->bytes >> 10);
 312         monitor_printf(mon, "xbzrle pages: %" PRIu64 " pages\n",
 313                        info->xbzrle_cache->pages);
 314         monitor_printf(mon, "xbzrle cache miss: %" PRIu64 " pages\n",
 315                        info->xbzrle_cache->cache_miss);
 316         monitor_printf(mon, "xbzrle cache miss rate: %0.2f\n",
 317                        info->xbzrle_cache->cache_miss_rate);
 318         monitor_printf(mon, "xbzrle encoding rate: %0.2f\n",
 319                        info->xbzrle_cache->encoding_rate);
 320         monitor_printf(mon, "xbzrle overflow: %" PRIu64 "\n",
 321                        info->xbzrle_cache->overflow);
 322     }
 323
 324     if (info->has_compression) {
 325         monitor_printf(mon, "compression pages: %" PRIu64 " pages\n",
 326                        info->compression->pages);
 327         monitor_printf(mon, "compression busy: %" PRIu64 "\n",
 328                        info->compression->busy);
 329         monitor_printf(mon, "compression busy rate: %0.2f\n",
 330                        info->compression->busy_rate);
 331         monitor_printf(mon, "compressed size: %" PRIu64 " kbytes\n",
 332                        info->compression->compressed_size >> 10);
 333         monitor_printf(mon, "compression rate: %0.2f\n",
 334                        info->compression->compression_rate);
 335     }
 336
 337     if (info->has_cpu_throttle_percentage) {
 338         monitor_printf(mon, "cpu throttle percentage: %" PRIu64 "\n",
 339                        info->cpu_throttle_percentage);
 340     }
 341
 342     if (info->has_postcopy_blocktime) {
 343         monitor_printf(mon, "postcopy blocktime: %u\n",
 344                        info->postcopy_blocktime);
 345     }
 346
 347     if (info->has_postcopy_vcpu_blocktime) {
 348         Visitor *v;
 349         char *str;
 350         v = string_output_visitor_new(false, &str);
 351         visit_type_uint32List(v, NULL, &info->postcopy_vcpu_blocktime,
 352                               &error_abort);
 353         visit_complete(v, &str);
 354         monitor_printf(mon, "postcopy vcpu blocktime: %s\n", str);
 355         g_free(str);
 356         visit_free(v);
 357     }
 358     if (info->has_socket_address) {
 359         SocketAddressList *addr;
 360
 361         monitor_printf(mon, "socket address: [\n");
 362
 363         for (addr = info->socket_address; addr; addr = addr->next) {
 364             char *s = SocketAddress_to_str(addr->value);
 365             monitor_printf(mon, "\t%s\n", s);
 366             g_free(s);
 367         }
 368         monitor_printf(mon, "]\n");
 369     }
 370
 371     if (info->has_vfio) {
 372         monitor_printf(mon, "vfio device transferred: %" PRIu64 " kbytes\n",
 373                        info->vfio->transferred >> 10);
 374     }
 375
 376     qapi_free_MigrationInfo(info);
 377 }
 378
 379 void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict)
 380 {
 381     MigrationCapabilityStatusList *caps, *cap;
 382
 383     caps = qmp_query_migrate_capabilities(NULL);
 384
 385     if (caps) {
 386         for (cap = caps; cap; cap = cap->next) {
 387             monitor_printf(mon, "%s: %s\n",
 388                            MigrationCapability_str(cap->value->capability),
 389                            cap->value->state ? "on" : "off");
 390         }
 391     }
 392
 393     qapi_free_MigrationCapabilityStatusList(caps);
 394 }
 395
 396 void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict)
 397 {
 398     MigrationParameters *params;
 399
 400     params = qmp_query_migrate_parameters(NULL);
 401
 402     if (params) {
 403         monitor_printf(mon, "%s: %" PRIu64 " ms\n",
 404             MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_INITIAL),
 405             params->announce_initial);
 406         monitor_printf(mon, "%s: %" PRIu64 " ms\n",
 407             MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_MAX),
 408             params->announce_max);
 409         monitor_printf(mon, "%s: %" PRIu64 "\n",
 410             MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_ROUNDS),
 411             params->announce_rounds);
 412         monitor_printf(mon, "%s: %" PRIu64 " ms\n",
 413             MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_STEP),
 414             params->announce_step);
 415         assert(params->has_compress_level);
 416         monitor_printf(mon, "%s: %u\n",
 417             MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_LEVEL),
 418             params->compress_level);
 419         assert(params->has_compress_threads);
 420         monitor_printf(mon, "%s: %u\n",
 421             MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_THREADS),
 422             params->compress_threads);
 423         assert(params->has_compress_wait_thread);
 424         monitor_printf(mon, "%s: %s\n",
 425             MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD),
 426             params->compress_wait_thread ? "on" : "off");
 427         assert(params->has_decompress_threads);
 428         monitor_printf(mon, "%s: %u\n",
 429             MigrationParameter_str(MIGRATION_PARAMETER_DECOMPRESS_THREADS),
 430             params->decompress_threads);
 431         assert(params->has_throttle_trigger_threshold);
 432         monitor_printf(mon, "%s: %u\n",
 433             MigrationParameter_str(MIGRATION_PARAMETER_THROTTLE_TRIGGER_THRESHOLD),
 434             params->throttle_trigger_threshold);
 435         assert(params->has_cpu_throttle_initial);
 436         monitor_printf(mon, "%s: %u\n",
 437             MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL),
 438             params->cpu_throttle_initial);
 439         assert(params->has_cpu_throttle_increment);
 440         monitor_printf(mon, "%s: %u\n",
 441             MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT),
 442             params->cpu_throttle_increment);
 443         assert(params->has_cpu_throttle_tailslow);
 444         monitor_printf(mon, "%s: %s\n",
 445             MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_TAILSLOW),
 446             params->cpu_throttle_tailslow ? "on" : "off");
 447         assert(params->has_max_cpu_throttle);
 448         monitor_printf(mon, "%s: %u\n",
 449             MigrationParameter_str(MIGRATION_PARAMETER_MAX_CPU_THROTTLE),
 450             params->max_cpu_throttle);
 451         assert(params->has_tls_creds);
 452         monitor_printf(mon, "%s: '%s'\n",
 453             MigrationParameter_str(MIGRATION_PARAMETER_TLS_CREDS),
 454             params->tls_creds);
 455         assert(params->has_tls_hostname);
 456         monitor_printf(mon, "%s: '%s'\n",
 457             MigrationParameter_str(MIGRATION_PARAMETER_TLS_HOSTNAME),
 458             params->tls_hostname);
 459         assert(params->has_max_bandwidth);
 460         monitor_printf(mon, "%s: %" PRIu64 " bytes/second\n",
 461             MigrationParameter_str(MIGRATION_PARAMETER_MAX_BANDWIDTH),
 462             params->max_bandwidth);
 463         assert(params->has_downtime_limit);
 464         monitor_printf(mon, "%s: %" PRIu64 " ms\n",
 465             MigrationParameter_str(MIGRATION_PARAMETER_DOWNTIME_LIMIT),
 466             params->downtime_limit);
 467         assert(params->has_x_checkpoint_delay);
 468         monitor_printf(mon, "%s: %u ms\n",
 469             MigrationParameter_str(MIGRATION_PARAMETER_X_CHECKPOINT_DELAY),
 470             params->x_checkpoint_delay);
 471         assert(params->has_block_incremental);
 472         monitor_printf(mon, "%s: %s\n",
 473             MigrationParameter_str(MIGRATION_PARAMETER_BLOCK_INCREMENTAL),
 474             params->block_incremental ? "on" : "off");
 475         monitor_printf(mon, "%s: %u\n",
 476             MigrationParameter_str(MIGRATION_PARAMETER_MULTIFD_CHANNELS),
 477             params->multifd_channels);
 478         monitor_printf(mon, "%s: %s\n",
 479             MigrationParameter_str(MIGRATION_PARAMETER_MULTIFD_COMPRESSION),
 480             MultiFDCompression_str(params->multifd_compression));
 481         monitor_printf(mon, "%s: %" PRIu64 " bytes\n",
 482             MigrationParameter_str(MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE),
 483             params->xbzrle_cache_size);
 484         monitor_printf(mon, "%s: %" PRIu64 "\n",
 485             MigrationParameter_str(MIGRATION_PARAMETER_MAX_POSTCOPY_BANDWIDTH),
 486             params->max_postcopy_bandwidth);
 487         monitor_printf(mon, "%s: '%s'\n",
 488             MigrationParameter_str(MIGRATION_PARAMETER_TLS_AUTHZ),
 489             params->tls_authz);
 490
 491         if (params->has_block_bitmap_mapping) {
 492             const BitmapMigrationNodeAliasList *bmnal;
 493
 494             monitor_printf(mon, "%s:\n",
 495                            MigrationParameter_str(
 496                                MIGRATION_PARAMETER_BLOCK_BITMAP_MAPPING));
 497
 498             for (bmnal = params->block_bitmap_mapping;
 499                  bmnal;
 500                  bmnal = bmnal->next)
 501             {
 502                 const BitmapMigrationNodeAlias *bmna = bmnal->value;
 503                 const BitmapMigrationBitmapAliasList *bmbal;
 504
 505                 monitor_printf(mon, "  '%s' -> '%s'\n",
 506                                bmna->node_name, bmna->alias);
 507
 508                 for (bmbal = bmna->bitmaps; bmbal; bmbal = bmbal->next) {
 509                     const BitmapMigrationBitmapAlias *bmba = bmbal->value;
 510
 511                     monitor_printf(mon, "    '%s' -> '%s'\n",
 512                                    bmba->name, bmba->alias);
 513                 }
 514             }
 515         }
 516     }
 517
 518     qapi_free_MigrationParameters(params);
 519 }
 520
 521 void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict)
 522 {
 523     monitor_printf(mon, "xbzrel cache size: %" PRId64 " kbytes\n",
 524                    qmp_query_migrate_cache_size(NULL) >> 10);
 525 }
 526
 527
 528 #ifdef CONFIG_VNC
 529 /* Helper for hmp_info_vnc_clients, _servers */
 530 static void hmp_info_VncBasicInfo(Monitor *mon, VncBasicInfo *info,
 531                                   const char *name)
 532 {
 533     monitor_printf(mon, "  %s: %s:%s (%s%s)\n",
 534                    name,
 535                    info->host,
 536                    info->service,
 537                    NetworkAddressFamily_str(info->family),
 538                    info->websocket ? " (Websocket)" : "");
 539 }
 540
 541 /* Helper displaying and auth and crypt info */
 542 static void hmp_info_vnc_authcrypt(Monitor *mon, const char *indent,
 543                                    VncPrimaryAuth auth,
 544                                    VncVencryptSubAuth *vencrypt)
 545 {
 546     monitor_printf(mon, "%sAuth: %s (Sub: %s)\n", indent,
 547                    VncPrimaryAuth_str(auth),
 548                    vencrypt ? VncVencryptSubAuth_str(*vencrypt) : "none");
 549 }
 550
 551 static void hmp_info_vnc_clients(Monitor *mon, VncClientInfoList *client)
 552 {
 553     while (client) {
 554         VncClientInfo *cinfo = client->value;
 555
 556         hmp_info_VncBasicInfo(mon, qapi_VncClientInfo_base(cinfo), "Client");
 557         monitor_printf(mon, "    x509_dname: %s\n",
 558                        cinfo->has_x509_dname ?
 559                        cinfo->x509_dname : "none");
 560         monitor_printf(mon, "    sasl_username: %s\n",
 561                        cinfo->has_sasl_username ?
 562                        cinfo->sasl_username : "none");
 563
 564         client = client->next;
 565     }
 566 }
 567
 568 static void hmp_info_vnc_servers(Monitor *mon, VncServerInfo2List *server)
 569 {
 570     while (server) {
 571         VncServerInfo2 *sinfo = server->value;
 572         hmp_info_VncBasicInfo(mon, qapi_VncServerInfo2_base(sinfo), "Server");
 573         hmp_info_vnc_authcrypt(mon, "    ", sinfo->auth,
 574                                sinfo->has_vencrypt ? &sinfo->vencrypt : NULL);
 575         server = server->next;
 576     }
 577 }
 578
 579 void hmp_info_vnc(Monitor *mon, const QDict *qdict)
 580 {
 581     VncInfo2List *info2l, *info2l_head;
 582     Error *err = NULL;
 583
 584     info2l = qmp_query_vnc_servers(&err);
 585     info2l_head = info2l;
 586     if (err) {
 587         hmp_handle_error(mon, err);
 588         return;
 589     }
 590     if (!info2l) {
 591         monitor_printf(mon, "None\n");
 592         return;
 593     }
 594
 595     while (info2l) {
 596         VncInfo2 *info = info2l->value;
 597         monitor_printf(mon, "%s:\n", info->id);
 598         hmp_info_vnc_servers(mon, info->server);
 599         hmp_info_vnc_clients(mon, info->clients);
 600         if (!info->server) {
 601             /* The server entry displays its auth, we only
 602              * need to display in the case of 'reverse' connections
 603              * where there's no server.
 604              */
 605             hmp_info_vnc_authcrypt(mon, "  ", info->auth,
 606                                info->has_vencrypt ? &info->vencrypt : NULL);
 607         }
 608         if (info->has_display) {
 609             monitor_printf(mon, "  Display: %s\n", info->display);
 610         }
 611         info2l = info2l->next;
 612     }
 613
 614     qapi_free_VncInfo2List(info2l_head);
 615
 616 }
 617 #endif
 618
 619 #ifdef CONFIG_SPICE
 620 void hmp_info_spice(Monitor *mon, const QDict *qdict)
 621 {
 622     SpiceChannelList *chan;
 623     SpiceInfo *info;
 624     const char *channel_name;
 625     const char * const channel_names[] = {
 626         [SPICE_CHANNEL_MAIN] = "main",
 627         [SPICE_CHANNEL_DISPLAY] = "display",
 628         [SPICE_CHANNEL_INPUTS] = "inputs",
 629         [SPICE_CHANNEL_CURSOR] = "cursor",
 630         [SPICE_CHANNEL_PLAYBACK] = "playback",
 631         [SPICE_CHANNEL_RECORD] = "record",
 632         [SPICE_CHANNEL_TUNNEL] = "tunnel",
 633         [SPICE_CHANNEL_SMARTCARD] = "smartcard",
 634         [SPICE_CHANNEL_USBREDIR] = "usbredir",
 635         [SPICE_CHANNEL_PORT] = "port",
 636 #if 0
 637         /* minimum spice-protocol is 0.12.3, webdav was added in 0.12.7,
 638          * no easy way to #ifdef (SPICE_CHANNEL_* is a enum).  Disable
 639          * as quick fix for build failures with older versions. */
 640         [SPICE_CHANNEL_WEBDAV] = "webdav",
 641 #endif
 642     };
 643
 644     info = qmp_query_spice(NULL);
 645
 646     if (!info->enabled) {
 647         monitor_printf(mon, "Server: disabled\n");
 648         goto out;
 649     }
 650
 651     monitor_printf(mon, "Server:\n");
 652     if (info->has_port) {
 653         monitor_printf(mon, "     address: %s:%" PRId64 "\n",
 654                        info->host, info->port);
 655     }
 656     if (info->has_tls_port) {
 657         monitor_printf(mon, "     address: %s:%" PRId64 " [tls]\n",
 658                        info->host, info->tls_port);
 659     }
 660     monitor_printf(mon, "    migrated: %s\n",
 661                    info->migrated ? "true" : "false");
 662     monitor_printf(mon, "        auth: %s\n", info->auth);
 663     monitor_printf(mon, "    compiled: %s\n", info->compiled_version);
 664     monitor_printf(mon, "  mouse-mode: %s\n",
 665                    SpiceQueryMouseMode_str(info->mouse_mode));
 666
 667     if (!info->has_channels || info->channels == NULL) {
 668         monitor_printf(mon, "Channels: none\n");
 669     } else {
 670         for (chan = info->channels; chan; chan = chan->next) {
 671             monitor_printf(mon, "Channel:\n");
 672             monitor_printf(mon, "     address: %s:%s%s\n",
 673                            chan->value->host, chan->value->port,
 674                            chan->value->tls ? " [tls]" : "");
 675             monitor_printf(mon, "     session: %" PRId64 "\n",
 676                            chan->value->connection_id);
 677             monitor_printf(mon, "     channel: %" PRId64 ":%" PRId64 "\n",
 678                            chan->value->channel_type, chan->value->channel_id);
 679
 680             channel_name = "unknown";
 681             if (chan->value->channel_type > 0 &&
 682                 chan->value->channel_type < ARRAY_SIZE(channel_names) &&
 683                 channel_names[chan->value->channel_type]) {
 684                 channel_name = channel_names[chan->value->channel_type];
 685             }
 686
 687             monitor_printf(mon, "     channel name: %s\n", channel_name);
 688         }
 689     }
 690
 691 out:
 692     qapi_free_SpiceInfo(info);
 693 }
 694 #endif
 695
 696 void hmp_info_balloon(Monitor *mon, const QDict *qdict)
 697 {
 698     BalloonInfo *info;
 699     Error *err = NULL;
 700
 701     info = qmp_query_balloon(&err);
 702     if (err) {
 703         hmp_handle_error(mon, err);
 704         return;
 705     }
 706
 707     monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);
 708
 709     qapi_free_BalloonInfo(info);
 710 }
 711
 712 static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
 713 {
 714     PciMemoryRegionList *region;
 715
 716     monitor_printf(mon, "  Bus %2" PRId64 ", ", dev->bus);
 717     monitor_printf(mon, "device %3" PRId64 ", function %" PRId64 ":\n",
 718                    dev->slot, dev->function);
 719     monitor_printf(mon, "    ");
 720
 721     if (dev->class_info->has_desc) {
 722         monitor_printf(mon, "%s", dev->class_info->desc);
 723     } else {
 724         monitor_printf(mon, "Class %04" PRId64, dev->class_info->q_class);
 725     }
 726
 727     monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n",
 728                    dev->id->vendor, dev->id->device);
 729     if (dev->id->has_subsystem_vendor && dev->id->has_subsystem) {
 730         monitor_printf(mon, "      PCI subsystem %04" PRIx64 ":%04" PRIx64 "\n",
 731                        dev->id->subsystem_vendor, dev->id->subsystem);
 732     }
 733
 734     if (dev->has_irq) {
 735         monitor_printf(mon, "      IRQ %" PRId64 ", pin %c\n",
 736                        dev->irq, (char)('A' + dev->irq_pin - 1));
 737     }
 738
 739     if (dev->has_pci_bridge) {
 740         monitor_printf(mon, "      BUS %" PRId64 ".\n",
 741                        dev->pci_bridge->bus->number);
 742         monitor_printf(mon, "      secondary bus %" PRId64 ".\n",
 743                        dev->pci_bridge->bus->secondary);
 744         monitor_printf(mon, "      subordinate bus %" PRId64 ".\n",
 745                        dev->pci_bridge->bus->subordinate);
 746
 747         monitor_printf(mon, "      IO range [0x%04"PRIx64", 0x%04"PRIx64"]\n",
 748                        dev->pci_bridge->bus->io_range->base,
 749                        dev->pci_bridge->bus->io_range->limit);
 750
 751         monitor_printf(mon,
 752                        "      memory range [0x%08"PRIx64", 0x%08"PRIx64"]\n",
 753                        dev->pci_bridge->bus->memory_range->base,
 754                        dev->pci_bridge->bus->memory_range->limit);
 755
 756         monitor_printf(mon, "      prefetchable memory range "
 757                        "[0x%08"PRIx64", 0x%08"PRIx64"]\n",
 758                        dev->pci_bridge->bus->prefetchable_range->base,
 759                        dev->pci_bridge->bus->prefetchable_range->limit);
 760     }
 761
 762     for (region = dev->regions; region; region = region->next) {
 763         uint64_t addr, size;
 764
 765         addr = region->value->address;
 766         size = region->value->size;
 767
 768         monitor_printf(mon, "      BAR%" PRId64 ": ", region->value->bar);
 769
 770         if (!strcmp(region->value->type, "io")) {
 771             monitor_printf(mon, "I/O at 0x%04" PRIx64
 772                                 " [0x%04" PRIx64 "].\n",
 773                            addr, addr + size - 1);
 774         } else {
 775             monitor_printf(mon, "%d bit%s memory at 0x%08" PRIx64
 776                                " [0x%08" PRIx64 "].\n",
 777                            region->value->mem_type_64 ? 64 : 32,
 778                            region->value->prefetch ? " prefetchable" : "",
 779                            addr, addr + size - 1);
 780         }
 781     }
 782
 783     monitor_printf(mon, "      id \"%s\"\n", dev->qdev_id);
 784
 785     if (dev->has_pci_bridge) {
 786         if (dev->pci_bridge->has_devices) {
 787             PciDeviceInfoList *cdev;
 788             for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) {
 789                 hmp_info_pci_device(mon, cdev->value);
 790             }
 791         }
 792     }
 793 }
 794
 795 static int hmp_info_irq_foreach(Object *obj, void *opaque)
 796 {
 797     InterruptStatsProvider *intc;
 798     InterruptStatsProviderClass *k;
 799     Monitor *mon = opaque;
 800
 801     if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
 802         intc = INTERRUPT_STATS_PROVIDER(obj);
 803         k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
 804         uint64_t *irq_counts;
 805         unsigned int nb_irqs, i;
 806         if (k->get_statistics &&
 807             k->get_statistics(intc, &irq_counts, &nb_irqs)) {
 808             if (nb_irqs > 0) {
 809                 monitor_printf(mon, "IRQ statistics for %s:\n",
 810                                object_get_typename(obj));
 811                 for (i = 0; i < nb_irqs; i++) {
 812                     if (irq_counts[i] > 0) {
 813                         monitor_printf(mon, "%2d: %" PRId64 "\n", i,
 814                                        irq_counts[i]);
 815                     }
 816                 }
 817             }
 818         } else {
 819             monitor_printf(mon, "IRQ statistics not available for %s.\n",
 820                            object_get_typename(obj));
 821         }
 822     }
 823
 824     return 0;
 825 }
 826
 827 void hmp_info_irq(Monitor *mon, const QDict *qdict)
 828 {
 829     object_child_foreach_recursive(object_get_root(),
 830                                    hmp_info_irq_foreach, mon);
 831 }
 832
 833 static int hmp_info_pic_foreach(Object *obj, void *opaque)
 834 {
 835     InterruptStatsProvider *intc;
 836     InterruptStatsProviderClass *k;
 837     Monitor *mon = opaque;
 838
 839     if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
 840         intc = INTERRUPT_STATS_PROVIDER(obj);
 841         k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
 842         if (k->print_info) {
 843             k->print_info(intc, mon);
 844         } else {
 845             monitor_printf(mon, "Interrupt controller information not available for %s.\n",
 846                            object_get_typename(obj));
 847         }
 848     }
 849
 850     return 0;
 851 }
 852
 853 void hmp_info_pic(Monitor *mon, const QDict *qdict)
 854 {
 855     object_child_foreach_recursive(object_get_root(),
 856                                    hmp_info_pic_foreach, mon);
 857 }
 858
 859 static int hmp_info_rdma_foreach(Object *obj, void *opaque)
 860 {
 861     RdmaProvider *rdma;
 862     RdmaProviderClass *k;
 863     Monitor *mon = opaque;
 864
 865     if (object_dynamic_cast(obj, INTERFACE_RDMA_PROVIDER)) {
 866         rdma = RDMA_PROVIDER(obj);
 867         k = RDMA_PROVIDER_GET_CLASS(obj);
 868         if (k->print_statistics) {
 869             k->print_statistics(mon, rdma);
 870         } else {
 871             monitor_printf(mon, "RDMA statistics not available for %s.\n",
 872                            object_get_typename(obj));
 873         }
 874     }
 875
 876     return 0;
 877 }
 878
 879 void hmp_info_rdma(Monitor *mon, const QDict *qdict)
 880 {
 881     object_child_foreach_recursive(object_get_root(),
 882                                    hmp_info_rdma_foreach, mon);
 883 }
 884
 885 void hmp_info_pci(Monitor *mon, const QDict *qdict)
 886 {
 887     PciInfoList *info_list, *info;
 888     Error *err = NULL;
 889
 890     info_list = qmp_query_pci(&err);
 891     if (err) {
 892         monitor_printf(mon, "PCI devices not supported\n");
 893         error_free(err);
 894         return;
 895     }
 896
 897     for (info = info_list; info; info = info->next) {
 898         PciDeviceInfoList *dev;
 899
 900         for (dev = info->value->devices; dev; dev = dev->next) {
 901             hmp_info_pci_device(mon, dev->value);
 902         }
 903     }
 904
 905     qapi_free_PciInfoList(info_list);
 906 }
 907
 908 void hmp_info_tpm(Monitor *mon, const QDict *qdict)
 909 {
 910     TPMInfoList *info_list, *info;
 911     Error *err = NULL;
 912     unsigned int c = 0;
 913     TPMPassthroughOptions *tpo;
 914     TPMEmulatorOptions *teo;
 915
 916     info_list = qmp_query_tpm(&err);
 917     if (err) {
 918         monitor_printf(mon, "TPM device not supported\n");
 919         error_free(err);
 920         return;
 921     }
 922
 923     if (info_list) {
 924         monitor_printf(mon, "TPM device:\n");
 925     }
 926
 927     for (info = info_list; info; info = info->next) {
 928         TPMInfo *ti = info->value;
 929         monitor_printf(mon, " tpm%d: model=%s\n",
 930                        c, TpmModel_str(ti->model));
 931
 932         monitor_printf(mon, "  \\ %s: type=%s",
 933                        ti->id, TpmTypeOptionsKind_str(ti->options->type));
 934
 935         switch (ti->options->type) {
 936         case TPM_TYPE_OPTIONS_KIND_PASSTHROUGH:
 937             tpo = ti->options->u.passthrough.data;
 938             monitor_printf(mon, "%s%s%s%s",
 939                            tpo->has_path ? ",path=" : "",
 940                            tpo->has_path ? tpo->path : "",
 941                            tpo->has_cancel_path ? ",cancel-path=" : "",
 942                            tpo->has_cancel_path ? tpo->cancel_path : "");
 943             break;
 944         case TPM_TYPE_OPTIONS_KIND_EMULATOR:
 945             teo = ti->options->u.emulator.data;
 946             monitor_printf(mon, ",chardev=%s", teo->chardev);
 947             break;
 948         case TPM_TYPE_OPTIONS_KIND__MAX:
 949             break;
 950         }
 951         monitor_printf(mon, "\n");
 952         c++;
 953     }
 954     qapi_free_TPMInfoList(info_list);
 955 }
 956
 957 void hmp_quit(Monitor *mon, const QDict *qdict)
 958 {
 959     monitor_suspend(mon);
 960     qmp_quit(NULL);
 961 }
 962
 963 void hmp_stop(Monitor *mon, const QDict *qdict)
 964 {
 965     qmp_stop(NULL);
 966 }
 967
 968 void hmp_sync_profile(Monitor *mon, const QDict *qdict)
 969 {
 970     const char *op = qdict_get_try_str(qdict, "op");
 971
 972     if (op == NULL) {
 973         bool on = qsp_is_enabled();
 974
 975         monitor_printf(mon, "sync-profile is %s\n", on ? "on" : "off");
 976         return;
 977     }
 978     if (!strcmp(op, "on")) {
 979         qsp_enable();
 980     } else if (!strcmp(op, "off")) {
 981         qsp_disable();
 982     } else if (!strcmp(op, "reset")) {
 983         qsp_reset();
 984     } else {
 985         Error *err = NULL;
 986
 987         error_setg(&err, QERR_INVALID_PARAMETER, op);
 988         hmp_handle_error(mon, err);
 989     }
 990 }
 991
 992 void hmp_system_reset(Monitor *mon, const QDict *qdict)
 993 {
 994     qmp_system_reset(NULL);
 995 }
 996
 997 void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
 998 {
 999     qmp_system_powerdown(NULL);
1000 }
1001
1002 void hmp_exit_preconfig(Monitor *mon, const QDict *qdict)
1003 {
1004     Error *err = NULL;
1005
1006     qmp_x_exit_preconfig(&err);
1007     hmp_handle_error(mon, err);
1008 }
1009
1010 void hmp_cpu(Monitor *mon, const QDict *qdict)
1011 {
1012     int64_t cpu_index;
1013
1014     /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
1015             use it are converted to the QAPI */
1016     cpu_index = qdict_get_int(qdict, "index");
1017     if (monitor_set_cpu(mon, cpu_index) < 0) {
1018         monitor_printf(mon, "invalid CPU index\n");
1019     }
1020 }
1021
1022 void hmp_memsave(Monitor *mon, const QDict *qdict)
1023 {
1024     uint32_t size = qdict_get_int(qdict, "size");
1025     const char *filename = qdict_get_str(qdict, "filename");
1026     uint64_t addr = qdict_get_int(qdict, "val");
1027     Error *err = NULL;
1028     int cpu_index = monitor_get_cpu_index(mon);
1029
1030     if (cpu_index < 0) {
1031         monitor_printf(mon, "No CPU available\n");
1032         return;
1033     }
1034
1035     qmp_memsave(addr, size, filename, true, cpu_index, &err);
1036     hmp_handle_error(mon, err);
1037 }
1038
1039 void hmp_pmemsave(Monitor *mon, const QDict *qdict)
1040 {
1041     uint32_t size = qdict_get_int(qdict, "size");
1042     const char *filename = qdict_get_str(qdict, "filename");
1043     uint64_t addr = qdict_get_int(qdict, "val");
1044     Error *err = NULL;
1045
1046     qmp_pmemsave(addr, size, filename, &err);
1047     hmp_handle_error(mon, err);
1048 }
1049
1050 void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
1051 {
1052     const char *chardev = qdict_get_str(qdict, "device");
1053     const char *data = qdict_get_str(qdict, "data");
1054     Error *err = NULL;
1055
1056     qmp_ringbuf_write(chardev, data, false, 0, &err);
1057
1058     hmp_handle_error(mon, err);
1059 }
1060
1061 void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
1062 {
1063     uint32_t size = qdict_get_int(qdict, "size");
1064     const char *chardev = qdict_get_str(qdict, "device");
1065     char *data;
1066     Error *err = NULL;
1067     int i;
1068
1069     data = qmp_ringbuf_read(chardev, size, false, 0, &err);
1070     if (err) {
1071         hmp_handle_error(mon, err);
1072         return;
1073     }
1074
1075     for (i = 0; data[i]; i++) {
1076         unsigned char ch = data[i];
1077
1078         if (ch == '\\') {
1079             monitor_printf(mon, "\\\\");
1080         } else if ((ch < 0x20 && ch != '\n' && ch != '\t') || ch == 0x7F) {
1081             monitor_printf(mon, "\\u%04X", ch);
1082         } else {
1083             monitor_printf(mon, "%c", ch);
1084         }
1085
1086     }
1087     monitor_printf(mon, "\n");
1088     g_free(data);
1089 }
1090
1091 void hmp_cont(Monitor *mon, const QDict *qdict)
1092 {
1093     Error *err = NULL;
1094
1095     qmp_cont(&err);
1096     hmp_handle_error(mon, err);
1097 }
1098
1099 void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
1100 {
1101     Error *err = NULL;
1102
1103     qmp_system_wakeup(&err);
1104     hmp_handle_error(mon, err);
1105 }
1106
1107 void hmp_nmi(Monitor *mon, const QDict *qdict)
1108 {
1109     Error *err = NULL;
1110
1111     qmp_inject_nmi(&err);
1112     hmp_handle_error(mon, err);
1113 }
1114
1115 void hmp_set_link(Monitor *mon, const QDict *qdict)
1116 {
1117     const char *name = qdict_get_str(qdict, "name");
1118     bool up = qdict_get_bool(qdict, "up");
1119     Error *err = NULL;
1120
1121     qmp_set_link(name, up, &err);
1122     hmp_handle_error(mon, err);
1123 }
1124
1125 void hmp_balloon(Monitor *mon, const QDict *qdict)
1126 {
1127     int64_t value = qdict_get_int(qdict, "value");
1128     Error *err = NULL;
1129
1130     qmp_balloon(value, &err);
1131     hmp_handle_error(mon, err);
1132 }
1133
1134 void hmp_loadvm(Monitor *mon, const QDict *qdict)
1135 {
1136     int saved_vm_running  = runstate_is_running();
1137     const char *name = qdict_get_str(qdict, "name");
1138     Error *err = NULL;
1139
1140     vm_stop(RUN_STATE_RESTORE_VM);
1141
1142     if (!load_snapshot(name, NULL, false, NULL, &err) && saved_vm_running) {
1143         vm_start();
1144     }
1145     hmp_handle_error(mon, err);
1146 }
1147
1148 void hmp_savevm(Monitor *mon, const QDict *qdict)
1149 {
1150     Error *err = NULL;
1151
1152     save_snapshot(qdict_get_try_str(qdict, "name"),
1153                   true, NULL, false, NULL, &err);
1154     hmp_handle_error(mon, err);
1155 }
1156
1157 void hmp_delvm(Monitor *mon, const QDict *qdict)
1158 {
1159     Error *err = NULL;
1160     const char *name = qdict_get_str(qdict, "name");
1161
1162     delete_snapshot(name, false, NULL, &err);
1163     hmp_handle_error(mon, err);
1164 }
1165
1166 void hmp_announce_self(Monitor *mon, const QDict *qdict)
1167 {
1168     const char *interfaces_str = qdict_get_try_str(qdict, "interfaces");
1169     const char *id = qdict_get_try_str(qdict, "id");
1170     AnnounceParameters *params = QAPI_CLONE(AnnounceParameters,
1171                                             migrate_announce_params());
1172
1173     qapi_free_strList(params->interfaces);
1174     params->interfaces = strList_from_comma_list(interfaces_str);
1175     params->has_interfaces = params->interfaces != NULL;
1176     params->id = g_strdup(id);
1177     params->has_id = !!params->id;
1178     qmp_announce_self(params, NULL);
1179     qapi_free_AnnounceParameters(params);
1180 }
1181
1182 void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
1183 {
1184     qmp_migrate_cancel(NULL);
1185 }
1186
1187 void hmp_migrate_continue(Monitor *mon, const QDict *qdict)
1188 {
1189     Error *err = NULL;
1190     const char *state = qdict_get_str(qdict, "state");
1191     int val = qapi_enum_parse(&MigrationStatus_lookup, state, -1, &err);
1192
1193     if (val >= 0) {
1194         qmp_migrate_continue(val, &err);
1195     }
1196
1197     hmp_handle_error(mon, err);
1198 }
1199
1200 void hmp_migrate_incoming(Monitor *mon, const QDict *qdict)
1201 {
1202     Error *err = NULL;
1203     const char *uri = qdict_get_str(qdict, "uri");
1204
1205     qmp_migrate_incoming(uri, &err);
1206
1207     hmp_handle_error(mon, err);
1208 }
1209
1210 void hmp_migrate_recover(Monitor *mon, const QDict *qdict)
1211 {
1212     Error *err = NULL;
1213     const char *uri = qdict_get_str(qdict, "uri");
1214
1215     qmp_migrate_recover(uri, &err);
1216
1217     hmp_handle_error(mon, err);
1218 }
1219
1220 void hmp_migrate_pause(Monitor *mon, const QDict *qdict)
1221 {
1222     Error *err = NULL;
1223
1224     qmp_migrate_pause(&err);
1225
1226     hmp_handle_error(mon, err);
1227 }
1228
1229 /* Kept for backwards compatibility */
1230 void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
1231 {
1232     Error *err = NULL;
1233
1234     double value = qdict_get_double(qdict, "value");
1235     qmp_migrate_set_downtime(value, &err);
1236     hmp_handle_error(mon, err);
1237 }
1238
1239 void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
1240 {
1241     int64_t value = qdict_get_int(qdict, "value");
1242     Error *err = NULL;
1243
1244     qmp_migrate_set_cache_size(value, &err);
1245     hmp_handle_error(mon, err);
1246 }
1247
1248 /* Kept for backwards compatibility */
1249 void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
1250 {
1251     Error *err = NULL;
1252
1253     int64_t value = qdict_get_int(qdict, "value");
1254     qmp_migrate_set_speed(value, &err);
1255     hmp_handle_error(mon, err);
1256 }
1257
1258 void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict)
1259 {
1260     const char *cap = qdict_get_str(qdict, "capability");
1261     bool state = qdict_get_bool(qdict, "state");
1262     Error *err = NULL;
1263     MigrationCapabilityStatusList *caps = NULL;
1264     MigrationCapabilityStatus *value;
1265     int val;
1266
1267     val = qapi_enum_parse(&MigrationCapability_lookup, cap, -1, &err);
1268     if (val < 0) {
1269         goto end;
1270     }
1271
1272     value = g_malloc0(sizeof(*value));
1273     value->capability = val;
1274     value->state = state;
1275     QAPI_LIST_PREPEND(caps, value);
1276     qmp_migrate_set_capabilities(caps, &err);
1277     qapi_free_MigrationCapabilityStatusList(caps);
1278
1279 end:
1280     hmp_handle_error(mon, err);
1281 }
1282
1283 void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
1284 {
1285     const char *param = qdict_get_str(qdict, "parameter");
1286     const char *valuestr = qdict_get_str(qdict, "value");
1287     Visitor *v = string_input_visitor_new(valuestr);
1288     MigrateSetParameters *p = g_new0(MigrateSetParameters, 1);
1289     uint64_t valuebw = 0;
1290     uint64_t cache_size;
1291     Error *err = NULL;
1292     int val, ret;
1293
1294     val = qapi_enum_parse(&MigrationParameter_lookup, param, -1, &err);
1295     if (val < 0) {
1296         goto cleanup;
1297     }
1298
1299     switch (val) {
1300     case MIGRATION_PARAMETER_COMPRESS_LEVEL:
1301         p->has_compress_level = true;
1302         visit_type_uint8(v, param, &p->compress_level, &err);
1303         break;
1304     case MIGRATION_PARAMETER_COMPRESS_THREADS:
1305         p->has_compress_threads = true;
1306         visit_type_uint8(v, param, &p->compress_threads, &err);
1307         break;
1308     case MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD:
1309         p->has_compress_wait_thread = true;
1310         visit_type_bool(v, param, &p->compress_wait_thread, &err);
1311         break;
1312     case MIGRATION_PARAMETER_DECOMPRESS_THREADS:
1313         p->has_decompress_threads = true;
1314         visit_type_uint8(v, param, &p->decompress_threads, &err);
1315         break;
1316     case MIGRATION_PARAMETER_THROTTLE_TRIGGER_THRESHOLD:
1317         p->has_throttle_trigger_threshold = true;
1318         visit_type_uint8(v, param, &p->throttle_trigger_threshold, &err);
1319         break;
1320     case MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL:
1321         p->has_cpu_throttle_initial = true;
1322         visit_type_uint8(v, param, &p->cpu_throttle_initial, &err);
1323         break;
1324     case MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT:
1325         p->has_cpu_throttle_increment = true;
1326         visit_type_uint8(v, param, &p->cpu_throttle_increment, &err);
1327         break;
1328     case MIGRATION_PARAMETER_CPU_THROTTLE_TAILSLOW:
1329         p->has_cpu_throttle_tailslow = true;
1330         visit_type_bool(v, param, &p->cpu_throttle_tailslow, &err);
1331         break;
1332     case MIGRATION_PARAMETER_MAX_CPU_THROTTLE:
1333         p->has_max_cpu_throttle = true;
1334         visit_type_uint8(v, param, &p->max_cpu_throttle, &err);
1335         break;
1336     case MIGRATION_PARAMETER_TLS_CREDS:
1337         p->has_tls_creds = true;
1338         p->tls_creds = g_new0(StrOrNull, 1);
1339         p->tls_creds->type = QTYPE_QSTRING;
1340         visit_type_str(v, param, &p->tls_creds->u.s, &err);
1341         break;
1342     case MIGRATION_PARAMETER_TLS_HOSTNAME:
1343         p->has_tls_hostname = true;
1344         p->tls_hostname = g_new0(StrOrNull, 1);
1345         p->tls_hostname->type = QTYPE_QSTRING;
1346         visit_type_str(v, param, &p->tls_hostname->u.s, &err);
1347         break;
1348     case MIGRATION_PARAMETER_TLS_AUTHZ:
1349         p->has_tls_authz = true;
1350         p->tls_authz = g_new0(StrOrNull, 1);
1351         p->tls_authz->type = QTYPE_QSTRING;
1352         visit_type_str(v, param, &p->tls_authz->u.s, &err);
1353         break;
1354     case MIGRATION_PARAMETER_MAX_BANDWIDTH:
1355         p->has_max_bandwidth = true;
1356         /*
1357          * Can't use visit_type_size() here, because it
1358          * defaults to Bytes rather than Mebibytes.
1359          */
1360         ret = qemu_strtosz_MiB(valuestr, NULL, &valuebw);
1361         if (ret < 0 || valuebw > INT64_MAX
1362             || (size_t)valuebw != valuebw) {
1363             error_setg(&err, "Invalid size %s", valuestr);
1364             break;
1365         }
1366         p->max_bandwidth = valuebw;
1367         break;
1368     case MIGRATION_PARAMETER_DOWNTIME_LIMIT:
1369         p->has_downtime_limit = true;
1370         visit_type_size(v, param, &p->downtime_limit, &err);
1371         break;
1372     case MIGRATION_PARAMETER_X_CHECKPOINT_DELAY:
1373         p->has_x_checkpoint_delay = true;
1374         visit_type_uint32(v, param, &p->x_checkpoint_delay, &err);
1375         break;
1376     case MIGRATION_PARAMETER_BLOCK_INCREMENTAL:
1377         p->has_block_incremental = true;
1378         visit_type_bool(v, param, &p->block_incremental, &err);
1379         break;
1380     case MIGRATION_PARAMETER_MULTIFD_CHANNELS:
1381         p->has_multifd_channels = true;
1382         visit_type_uint8(v, param, &p->multifd_channels, &err);
1383         break;
1384     case MIGRATION_PARAMETER_MULTIFD_COMPRESSION:
1385         p->has_multifd_compression = true;
1386         visit_type_MultiFDCompression(v, param, &p->multifd_compression,
1387                                       &err);
1388         break;
1389     case MIGRATION_PARAMETER_MULTIFD_ZLIB_LEVEL:
1390         p->has_multifd_zlib_level = true;
1391         visit_type_uint8(v, param, &p->multifd_zlib_level, &err);
1392         break;
1393     case MIGRATION_PARAMETER_MULTIFD_ZSTD_LEVEL:
1394         p->has_multifd_zstd_level = true;
1395         visit_type_uint8(v, param, &p->multifd_zstd_level, &err);
1396         break;
1397     case MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE:
1398         p->has_xbzrle_cache_size = true;
1399         if (!visit_type_size(v, param, &cache_size, &err)) {
1400             break;
1401         }
1402         if (cache_size > INT64_MAX || (size_t)cache_size != cache_size) {
1403             error_setg(&err, "Invalid size %s", valuestr);
1404             break;
1405         }
1406         p->xbzrle_cache_size = cache_size;
1407         break;
1408     case MIGRATION_PARAMETER_MAX_POSTCOPY_BANDWIDTH:
1409         p->has_max_postcopy_bandwidth = true;
1410         visit_type_size(v, param, &p->max_postcopy_bandwidth, &err);
1411         break;
1412     case MIGRATION_PARAMETER_ANNOUNCE_INITIAL:
1413         p->has_announce_initial = true;
1414         visit_type_size(v, param, &p->announce_initial, &err);
1415         break;
1416     case MIGRATION_PARAMETER_ANNOUNCE_MAX:
1417         p->has_announce_max = true;
1418         visit_type_size(v, param, &p->announce_max, &err);
1419         break;
1420     case MIGRATION_PARAMETER_ANNOUNCE_ROUNDS:
1421         p->has_announce_rounds = true;
1422         visit_type_size(v, param, &p->announce_rounds, &err);
1423         break;
1424     case MIGRATION_PARAMETER_ANNOUNCE_STEP:
1425         p->has_announce_step = true;
1426         visit_type_size(v, param, &p->announce_step, &err);
1427         break;
1428     case MIGRATION_PARAMETER_BLOCK_BITMAP_MAPPING:
1429         error_setg(&err, "The block-bitmap-mapping parameter can only be set "
1430                    "through QMP");
1431         break;
1432     default:
1433         assert(0);
1434     }
1435
1436     if (err) {
1437         goto cleanup;
1438     }
1439
1440     qmp_migrate_set_parameters(p, &err);
1441
1442  cleanup:
1443     qapi_free_MigrateSetParameters(p);
1444     visit_free(v);
1445     hmp_handle_error(mon, err);
1446 }
1447
1448 void hmp_client_migrate_info(Monitor *mon, const QDict *qdict)
1449 {
1450     Error *err = NULL;
1451     const char *protocol = qdict_get_str(qdict, "protocol");
1452     const char *hostname = qdict_get_str(qdict, "hostname");
1453     bool has_port        = qdict_haskey(qdict, "port");
1454     int port             = qdict_get_try_int(qdict, "port", -1);
1455     bool has_tls_port    = qdict_haskey(qdict, "tls-port");
1456     int tls_port         = qdict_get_try_int(qdict, "tls-port", -1);
1457     const char *cert_subject = qdict_get_try_str(qdict, "cert-subject");
1458
1459     qmp_client_migrate_info(protocol, hostname,
1460                             has_port, port, has_tls_port, tls_port,
1461                             !!cert_subject, cert_subject, &err);
1462     hmp_handle_error(mon, err);
1463 }
1464
1465 void hmp_migrate_start_postcopy(Monitor *mon, const QDict *qdict)
1466 {
1467     Error *err = NULL;
1468     qmp_migrate_start_postcopy(&err);
1469     hmp_handle_error(mon, err);
1470 }
1471
1472 void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict)
1473 {
1474     Error *err = NULL;
1475
1476     qmp_x_colo_lost_heartbeat(&err);
1477     hmp_handle_error(mon, err);
1478 }
1479
1480 void hmp_set_password(Monitor *mon, const QDict *qdict)
1481 {
1482     const char *protocol  = qdict_get_str(qdict, "protocol");
1483     const char *password  = qdict_get_str(qdict, "password");
1484     const char *connected = qdict_get_try_str(qdict, "connected");
1485     Error *err = NULL;
1486
1487     qmp_set_password(protocol, password, !!connected, connected, &err);
1488     hmp_handle_error(mon, err);
1489 }
1490
1491 void hmp_expire_password(Monitor *mon, const QDict *qdict)
1492 {
1493     const char *protocol  = qdict_get_str(qdict, "protocol");
1494     const char *whenstr = qdict_get_str(qdict, "time");
1495     Error *err = NULL;
1496
1497     qmp_expire_password(protocol, whenstr, &err);
1498     hmp_handle_error(mon, err);
1499 }
1500
1501
1502 #ifdef CONFIG_VNC
1503 static void hmp_change_read_arg(void *opaque, const char *password,
1504                                 void *readline_opaque)
1505 {
1506     qmp_change_vnc_password(password, NULL);
1507     monitor_read_command(opaque, 1);
1508 }
1509 #endif
1510
1511 void hmp_change(Monitor *mon, const QDict *qdict)
1512 {
1513     const char *device = qdict_get_str(qdict, "device");
1514     const char *target = qdict_get_str(qdict, "target");
1515     const char *arg = qdict_get_try_str(qdict, "arg");
1516     const char *read_only = qdict_get_try_str(qdict, "read-only-mode");
1517     BlockdevChangeReadOnlyMode read_only_mode = 0;
1518     Error *err = NULL;
1519
1520 #ifdef CONFIG_VNC
1521     if (strcmp(device, "vnc") == 0) {
1522         if (read_only) {
1523             monitor_printf(mon,
1524                            "Parameter 'read-only-mode' is invalid for VNC\n");
1525             return;
1526         }
1527         if (strcmp(target, "passwd") == 0 ||
1528             strcmp(target, "password") == 0) {
1529             if (arg) {
1530                 MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
1531                 monitor_read_password(hmp_mon, hmp_change_read_arg, NULL);
1532                 return;
1533             } else {
1534                 qmp_change_vnc_password(arg, &err);
1535             }
1536         } else {
1537             monitor_printf(mon, "Expected 'password' after 'vnc'\n");
1538         }
1539     } else
1540 #endif
1541     {
1542         if (read_only) {
1543             read_only_mode =
1544                 qapi_enum_parse(&BlockdevChangeReadOnlyMode_lookup,
1545                                 read_only,
1546                                 BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN, &err);
1547             if (err) {
1548                 goto end;
1549             }
1550         }
1551
1552         qmp_blockdev_change_medium(true, device, false, NULL, target,
1553                                    !!arg, arg, !!read_only, read_only_mode,
1554                                    &err);
1555     }
1556
1557 end:
1558     hmp_handle_error(mon, err);
1559 }
1560
1561 typedef struct HMPMigrationStatus {
1562     QEMUTimer *timer;
1563     Monitor *mon;
1564     bool is_block_migration;
1565 } HMPMigrationStatus;
1566
1567 static void hmp_migrate_status_cb(void *opaque)
1568 {
1569     HMPMigrationStatus *status = opaque;
1570     MigrationInfo *info;
1571
1572     info = qmp_query_migrate(NULL);
1573     if (!info->has_status || info->status == MIGRATION_STATUS_ACTIVE ||
1574         info->status == MIGRATION_STATUS_SETUP) {
1575         if (info->has_disk) {
1576             int progress;
1577
1578             if (info->disk->remaining) {
1579                 progress = info->disk->transferred * 100 / info->disk->total;
1580             } else {
1581                 progress = 100;
1582             }
1583
1584             monitor_printf(status->mon, "Completed %d %%\r", progress);
1585             monitor_flush(status->mon);
1586         }
1587
1588         timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
1589     } else {
1590         if (status->is_block_migration) {
1591             monitor_printf(status->mon, "\n");
1592         }
1593         if (info->has_error_desc) {
1594             error_report("%s", info->error_desc);
1595         }
1596         monitor_resume(status->mon);
1597         timer_free(status->timer);
1598         g_free(status);
1599     }
1600
1601     qapi_free_MigrationInfo(info);
1602 }
1603
1604 void hmp_migrate(Monitor *mon, const QDict *qdict)
1605 {
1606     bool detach = qdict_get_try_bool(qdict, "detach", false);
1607     bool blk = qdict_get_try_bool(qdict, "blk", false);
1608     bool inc = qdict_get_try_bool(qdict, "inc", false);
1609     bool resume = qdict_get_try_bool(qdict, "resume", false);
1610     const char *uri = qdict_get_str(qdict, "uri");
1611     Error *err = NULL;
1612
1613     qmp_migrate(uri, !!blk, blk, !!inc, inc,
1614                 false, false, true, resume, &err);
1615     if (err) {
1616         hmp_handle_error(mon, err);
1617         return;
1618     }
1619
1620     if (!detach) {
1621         HMPMigrationStatus *status;
1622
1623         if (monitor_suspend(mon) < 0) {
1624             monitor_printf(mon, "terminal does not allow synchronous "
1625                            "migration, continuing detached\n");
1626             return;
1627         }
1628
1629         status = g_malloc0(sizeof(*status));
1630         status->mon = mon;
1631         status->is_block_migration = blk || inc;
1632         status->timer = timer_new_ms(QEMU_CLOCK_REALTIME, hmp_migrate_status_cb,
1633                                           status);
1634         timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
1635     }
1636 }
1637
1638 void hmp_netdev_add(Monitor *mon, const QDict *qdict)
1639 {
1640     Error *err = NULL;
1641     QemuOpts *opts;
1642     const char *type = qdict_get_try_str(qdict, "type");
1643
1644     if (type && is_help_option(type)) {
1645         show_netdevs();
1646         return;
1647     }
1648     opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &err);
1649     if (err) {
1650         goto out;
1651     }
1652
1653     netdev_add(opts, &err);
1654     if (err) {
1655         qemu_opts_del(opts);
1656     }
1657
1658 out:
1659     hmp_handle_error(mon, err);
1660 }
1661
1662 void hmp_netdev_del(Monitor *mon, const QDict *qdict)
1663 {
1664     const char *id = qdict_get_str(qdict, "id");
1665     Error *err = NULL;
1666
1667     qmp_netdev_del(id, &err);
1668     hmp_handle_error(mon, err);
1669 }
1670
1671 void hmp_object_add(Monitor *mon, const QDict *qdict)
1672 {
1673     Error *err = NULL;
1674     QemuOpts *opts;
1675     Object *obj = NULL;
1676
1677     opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
1678     if (err) {
1679         goto end;
1680     }
1681
1682     obj = user_creatable_add_opts(opts, &err);
1683     qemu_opts_del(opts);
1684
1685 end:
1686     hmp_handle_error(mon, err);
1687
1688     if (obj) {
1689         object_unref(obj);
1690     }
1691 }
1692
1693 void hmp_getfd(Monitor *mon, const QDict *qdict)
1694 {
1695     const char *fdname = qdict_get_str(qdict, "fdname");
1696     Error *err = NULL;
1697
1698     qmp_getfd(fdname, &err);
1699     hmp_handle_error(mon, err);
1700 }
1701
1702 void hmp_closefd(Monitor *mon, const QDict *qdict)
1703 {
1704     const char *fdname = qdict_get_str(qdict, "fdname");
1705     Error *err = NULL;
1706
1707     qmp_closefd(fdname, &err);
1708     hmp_handle_error(mon, err);
1709 }
1710
1711 void hmp_sendkey(Monitor *mon, const QDict *qdict)
1712 {
1713     const char *keys = qdict_get_str(qdict, "keys");
1714     KeyValue *v = NULL;
1715     KeyValueList *head = NULL, **tail = &head;
1716     int has_hold_time = qdict_haskey(qdict, "hold-time");
1717     int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
1718     Error *err = NULL;
1719     const char *separator;
1720     int keyname_len;
1721
1722     while (1) {
1723         separator = qemu_strchrnul(keys, '-');
1724         keyname_len = separator - keys;
1725
1726         /* Be compatible with old interface, convert user inputted "<" */
1727         if (keys[0] == '<' && keyname_len == 1) {
1728             keys = "less";
1729             keyname_len = 4;
1730         }
1731
1732         v = g_malloc0(sizeof(*v));
1733
1734         if (strstart(keys, "0x", NULL)) {
1735             char *endp;
1736             int value = strtoul(keys, &endp, 0);
1737             assert(endp <= keys + keyname_len);
1738             if (endp != keys + keyname_len) {
1739                 goto err_out;
1740             }
1741             v->type = KEY_VALUE_KIND_NUMBER;
1742             v->u.number.data = value;
1743         } else {
1744             int idx = index_from_key(keys, keyname_len);
1745             if (idx == Q_KEY_CODE__MAX) {
1746                 goto err_out;
1747             }
1748             v->type = KEY_VALUE_KIND_QCODE;
1749             v->u.qcode.data = idx;
1750         }
1751         QAPI_LIST_APPEND(tail, v);
1752         v = NULL;
1753
1754         if (!*separator) {
1755             break;
1756         }
1757         keys = separator + 1;
1758     }
1759
1760     qmp_send_key(head, has_hold_time, hold_time, &err);
1761     hmp_handle_error(mon, err);
1762
1763 out:
1764     qapi_free_KeyValue(v);
1765     qapi_free_KeyValueList(head);
1766     return;
1767
1768 err_out:
1769     monitor_printf(mon, "invalid parameter: %.*s\n", keyname_len, keys);
1770     goto out;
1771 }
1772
1773 void coroutine_fn
1774 hmp_screendump(Monitor *mon, const QDict *qdict)
1775 {
1776     const char *filename = qdict_get_str(qdict, "filename");
1777     const char *id = qdict_get_try_str(qdict, "device");
1778     int64_t head = qdict_get_try_int(qdict, "head", 0);
1779     Error *err = NULL;
1780
1781     qmp_screendump(filename, id != NULL, id, id != NULL, head, &err);
1782     hmp_handle_error(mon, err);
1783 }
1784
1785 void hmp_chardev_add(Monitor *mon, const QDict *qdict)
1786 {
1787     const char *args = qdict_get_str(qdict, "args");
1788     Error *err = NULL;
1789     QemuOpts *opts;
1790
1791     opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args, true);
1792     if (opts == NULL) {
1793         error_setg(&err, "Parsing chardev args failed");
1794     } else {
1795         qemu_chr_new_from_opts(opts, NULL, &err);
1796         qemu_opts_del(opts);
1797     }
1798     hmp_handle_error(mon, err);
1799 }
1800
1801 void hmp_chardev_change(Monitor *mon, const QDict *qdict)
1802 {
1803     const char *args = qdict_get_str(qdict, "args");
1804     const char *id;
1805     Error *err = NULL;
1806     ChardevBackend *backend = NULL;
1807     ChardevReturn *ret = NULL;
1808     QemuOpts *opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args,
1809                                              true);
1810     if (!opts) {
1811         error_setg(&err, "Parsing chardev args failed");
1812         goto end;
1813     }
1814
1815     id = qdict_get_str(qdict, "id");
1816     if (qemu_opts_id(opts)) {
1817         error_setg(&err, "Unexpected 'id' parameter");
1818         goto end;
1819     }
1820
1821     backend = qemu_chr_parse_opts(opts, &err);
1822     if (!backend) {
1823         goto end;
1824     }
1825
1826     ret = qmp_chardev_change(id, backend, &err);
1827
1828 end:
1829     qapi_free_ChardevReturn(ret);
1830     qapi_free_ChardevBackend(backend);
1831     qemu_opts_del(opts);
1832     hmp_handle_error(mon, err);
1833 }
1834
1835 void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
1836 {
1837     Error *local_err = NULL;
1838
1839     qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
1840     hmp_handle_error(mon, local_err);
1841 }
1842
1843 void hmp_chardev_send_break(Monitor *mon, const QDict *qdict)
1844 {
1845     Error *local_err = NULL;
1846
1847     qmp_chardev_send_break(qdict_get_str(qdict, "id"), &local_err);
1848     hmp_handle_error(mon, local_err);
1849 }
1850
1851 void hmp_object_del(Monitor *mon, const QDict *qdict)
1852 {
1853     const char *id = qdict_get_str(qdict, "id");
1854     Error *err = NULL;
1855
1856     user_creatable_del(id, &err);
1857     hmp_handle_error(mon, err);
1858 }
1859
1860 void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
1861 {
1862     Error *err = NULL;
1863     MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
1864     MemoryDeviceInfoList *info;
1865     VirtioPMEMDeviceInfo *vpi;
1866     VirtioMEMDeviceInfo *vmi;
1867     MemoryDeviceInfo *value;
1868     PCDIMMDeviceInfo *di;
1869
1870     for (info = info_list; info; info = info->next) {
1871         value = info->value;
1872
1873         if (value) {
1874             switch (value->type) {
1875             case MEMORY_DEVICE_INFO_KIND_DIMM:
1876             case MEMORY_DEVICE_INFO_KIND_NVDIMM:
1877                 di = value->type == MEMORY_DEVICE_INFO_KIND_DIMM ?
1878                      value->u.dimm.data : value->u.nvdimm.data;
1879                 monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
1880                                MemoryDeviceInfoKind_str(value->type),
1881                                di->id ? di->id : "");
1882                 monitor_printf(mon, "  addr: 0x%" PRIx64 "\n", di->addr);
1883                 monitor_printf(mon, "  slot: %" PRId64 "\n", di->slot);
1884                 monitor_printf(mon, "  node: %" PRId64 "\n", di->node);
1885                 monitor_printf(mon, "  size: %" PRIu64 "\n", di->size);
1886                 monitor_printf(mon, "  memdev: %s\n", di->memdev);
1887                 monitor_printf(mon, "  hotplugged: %s\n",
1888                                di->hotplugged ? "true" : "false");
1889                 monitor_printf(mon, "  hotpluggable: %s\n",
1890                                di->hotpluggable ? "true" : "false");
1891                 break;
1892             case MEMORY_DEVICE_INFO_KIND_VIRTIO_PMEM:
1893                 vpi = value->u.virtio_pmem.data;
1894                 monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
1895                                MemoryDeviceInfoKind_str(value->type),
1896                                vpi->id ? vpi->id : "");
1897                 monitor_printf(mon, "  memaddr: 0x%" PRIx64 "\n", vpi->memaddr);
1898                 monitor_printf(mon, "  size: %" PRIu64 "\n", vpi->size);
1899                 monitor_printf(mon, "  memdev: %s\n", vpi->memdev);
1900                 break;
1901             case MEMORY_DEVICE_INFO_KIND_VIRTIO_MEM:
1902                 vmi = value->u.virtio_mem.data;
1903                 monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
1904                                MemoryDeviceInfoKind_str(value->type),
1905                                vmi->id ? vmi->id : "");
1906                 monitor_printf(mon, "  memaddr: 0x%" PRIx64 "\n", vmi->memaddr);
1907                 monitor_printf(mon, "  node: %" PRId64 "\n", vmi->node);
1908                 monitor_printf(mon, "  requested-size: %" PRIu64 "\n",
1909                                vmi->requested_size);
1910                 monitor_printf(mon, "  size: %" PRIu64 "\n", vmi->size);
1911                 monitor_printf(mon, "  max-size: %" PRIu64 "\n", vmi->max_size);
1912                 monitor_printf(mon, "  block-size: %" PRIu64 "\n",
1913                                vmi->block_size);
1914                 monitor_printf(mon, "  memdev: %s\n", vmi->memdev);
1915                 break;
1916             default:
1917                 g_assert_not_reached();
1918             }
1919         }
1920     }
1921
1922     qapi_free_MemoryDeviceInfoList(info_list);
1923     hmp_handle_error(mon, err);
1924 }
1925
1926 void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
1927 {
1928     IOThreadInfoList *info_list = qmp_query_iothreads(NULL);
1929     IOThreadInfoList *info;
1930     IOThreadInfo *value;
1931
1932     for (info = info_list; info; info = info->next) {
1933         value = info->value;
1934         monitor_printf(mon, "%s:\n", value->id);
1935         monitor_printf(mon, "  thread_id=%" PRId64 "\n", value->thread_id);
1936         monitor_printf(mon, "  poll-max-ns=%" PRId64 "\n", value->poll_max_ns);
1937         monitor_printf(mon, "  poll-grow=%" PRId64 "\n", value->poll_grow);
1938         monitor_printf(mon, "  poll-shrink=%" PRId64 "\n", value->poll_shrink);
1939     }
1940
1941     qapi_free_IOThreadInfoList(info_list);
1942 }
1943
1944 void hmp_rocker(Monitor *mon, const QDict *qdict)
1945 {
1946     const char *name = qdict_get_str(qdict, "name");
1947     RockerSwitch *rocker;
1948     Error *err = NULL;
1949
1950     rocker = qmp_query_rocker(name, &err);
1951     if (err != NULL) {
1952         hmp_handle_error(mon, err);
1953         return;
1954     }
1955
1956     monitor_printf(mon, "name: %s\n", rocker->name);
1957     monitor_printf(mon, "id: 0x%" PRIx64 "\n", rocker->id);
1958     monitor_printf(mon, "ports: %d\n", rocker->ports);
1959
1960     qapi_free_RockerSwitch(rocker);
1961 }
1962
1963 void hmp_rocker_ports(Monitor *mon, const QDict *qdict)
1964 {
1965     RockerPortList *list, *port;
1966     const char *name = qdict_get_str(qdict, "name");
1967     Error *err = NULL;
1968
1969     list = qmp_query_rocker_ports(name, &err);
1970     if (err != NULL) {
1971         hmp_handle_error(mon, err);
1972         return;
1973     }
1974
1975     monitor_printf(mon, "            ena/    speed/ auto\n");
1976     monitor_printf(mon, "      port  link    duplex neg?\n");
1977
1978     for (port = list; port; port = port->next) {
1979         monitor_printf(mon, "%10s  %-4s   %-3s  %2s  %-3s\n",
1980                        port->value->name,
1981                        port->value->enabled ? port->value->link_up ?
1982                        "up" : "down" : "!ena",
1983                        port->value->speed == 10000 ? "10G" : "??",
1984                        port->value->duplex ? "FD" : "HD",
1985                        port->value->autoneg ? "Yes" : "No");
1986     }
1987
1988     qapi_free_RockerPortList(list);
1989 }
1990
1991 void hmp_rocker_of_dpa_flows(Monitor *mon, const QDict *qdict)
1992 {
1993     RockerOfDpaFlowList *list, *info;
1994     const char *name = qdict_get_str(qdict, "name");
1995     uint32_t tbl_id = qdict_get_try_int(qdict, "tbl_id", -1);
1996     Error *err = NULL;
1997
1998     list = qmp_query_rocker_of_dpa_flows(name, tbl_id != -1, tbl_id, &err);
1999     if (err != NULL) {
2000         hmp_handle_error(mon, err);
2001         return;
2002     }
2003
2004     monitor_printf(mon, "prio tbl hits key(mask) --> actions\n");
2005
2006     for (info = list; info; info = info->next) {
2007         RockerOfDpaFlow *flow = info->value;
2008         RockerOfDpaFlowKey *key = flow->key;
2009         RockerOfDpaFlowMask *mask = flow->mask;
2010         RockerOfDpaFlowAction *action = flow->action;
2011
2012         if (flow->hits) {
2013             monitor_printf(mon, "%-4d %-3d %-4" PRIu64,
2014                            key->priority, key->tbl_id, flow->hits);
2015         } else {
2016             monitor_printf(mon, "%-4d %-3d     ",
2017                            key->priority, key->tbl_id);
2018         }
2019
2020         if (key->has_in_pport) {
2021             monitor_printf(mon, " pport %d", key->in_pport);
2022             if (mask->has_in_pport) {
2023                 monitor_printf(mon, "(0x%x)", mask->in_pport);
2024             }
2025         }
2026
2027         if (key->has_vlan_id) {
2028             monitor_printf(mon, " vlan %d",
2029                            key->vlan_id & VLAN_VID_MASK);
2030             if (mask->has_vlan_id) {
2031                 monitor_printf(mon, "(0x%x)", mask->vlan_id);
2032             }
2033         }
2034
2035         if (key->has_tunnel_id) {
2036             monitor_printf(mon, " tunnel %d", key->tunnel_id);
2037             if (mask->has_tunnel_id) {
2038                 monitor_printf(mon, "(0x%x)", mask->tunnel_id);
2039             }
2040         }
2041
2042         if (key->has_eth_type) {
2043             switch (key->eth_type) {
2044             case 0x0806:
2045                 monitor_printf(mon, " ARP");
2046                 break;
2047             case 0x0800:
2048                 monitor_printf(mon, " IP");
2049                 break;
2050             case 0x86dd:
2051                 monitor_printf(mon, " IPv6");
2052                 break;
2053             case 0x8809:
2054                 monitor_printf(mon, " LACP");
2055                 break;
2056             case 0x88cc:
2057                 monitor_printf(mon, " LLDP");
2058                 break;
2059             default:
2060                 monitor_printf(mon, " eth type 0x%04x", key->eth_type);
2061                 break;
2062             }
2063         }
2064
2065         if (key->has_eth_src) {
2066             if ((strcmp(key->eth_src, "01:00:00:00:00:00") == 0) &&
2067                 (mask->has_eth_src) &&
2068                 (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) {
2069                 monitor_printf(mon, " src <any mcast/bcast>");
2070             } else if ((strcmp(key->eth_src, "00:00:00:00:00:00") == 0) &&
2071                 (mask->has_eth_src) &&
2072                 (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) {
2073                 monitor_printf(mon, " src <any ucast>");
2074             } else {
2075                 monitor_printf(mon, " src %s", key->eth_src);
2076                 if (mask->has_eth_src) {
2077                     monitor_printf(mon, "(%s)", mask->eth_src);
2078                 }
2079             }
2080         }
2081
2082         if (key->has_eth_dst) {
2083             if ((strcmp(key->eth_dst, "01:00:00:00:00:00") == 0) &&
2084                 (mask->has_eth_dst) &&
2085                 (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) {
2086                 monitor_printf(mon, " dst <any mcast/bcast>");
2087             } else if ((strcmp(key->eth_dst, "00:00:00:00:00:00") == 0) &&
2088                 (mask->has_eth_dst) &&
2089                 (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) {
2090                 monitor_printf(mon, " dst <any ucast>");
2091             } else {
2092                 monitor_printf(mon, " dst %s", key->eth_dst);
2093                 if (mask->has_eth_dst) {
2094                     monitor_printf(mon, "(%s)", mask->eth_dst);
2095                 }
2096             }
2097         }
2098
2099         if (key->has_ip_proto) {
2100             monitor_printf(mon, " proto %d", key->ip_proto);
2101             if (mask->has_ip_proto) {
2102                 monitor_printf(mon, "(0x%x)", mask->ip_proto);
2103             }
2104         }
2105
2106         if (key->has_ip_tos) {
2107             monitor_printf(mon, " TOS %d", key->ip_tos);
2108             if (mask->has_ip_tos) {
2109                 monitor_printf(mon, "(0x%x)", mask->ip_tos);
2110             }
2111         }
2112
2113         if (key->has_ip_dst) {
2114             monitor_printf(mon, " dst %s", key->ip_dst);
2115         }
2116
2117         if (action->has_goto_tbl || action->has_group_id ||
2118             action->has_new_vlan_id) {
2119             monitor_printf(mon, " -->");
2120         }
2121
2122         if (action->has_new_vlan_id) {
2123             monitor_printf(mon, " apply new vlan %d",
2124                            ntohs(action->new_vlan_id));
2125         }
2126
2127         if (action->has_group_id) {
2128             monitor_printf(mon, " write group 0x%08x", action->group_id);
2129         }
2130
2131         if (action->has_goto_tbl) {
2132             monitor_printf(mon, " goto tbl %d", action->goto_tbl);
2133         }
2134
2135         monitor_printf(mon, "\n");
2136     }
2137
2138     qapi_free_RockerOfDpaFlowList(list);
2139 }
2140
2141 void hmp_rocker_of_dpa_groups(Monitor *mon, const QDict *qdict)
2142 {
2143     RockerOfDpaGroupList *list, *g;
2144     const char *name = qdict_get_str(qdict, "name");
2145     uint8_t type = qdict_get_try_int(qdict, "type", 9);
2146     Error *err = NULL;
2147
2148     list = qmp_query_rocker_of_dpa_groups(name, type != 9, type, &err);
2149     if (err != NULL) {
2150         hmp_handle_error(mon, err);
2151         return;
2152     }
2153
2154     monitor_printf(mon, "id (decode) --> buckets\n");
2155
2156     for (g = list; g; g = g->next) {
2157         RockerOfDpaGroup *group = g->value;
2158         bool set = false;
2159
2160         monitor_printf(mon, "0x%08x", group->id);
2161
2162         monitor_printf(mon, " (type %s", group->type == 0 ? "L2 interface" :
2163                                          group->type == 1 ? "L2 rewrite" :
2164                                          group->type == 2 ? "L3 unicast" :
2165                                          group->type == 3 ? "L2 multicast" :
2166                                          group->type == 4 ? "L2 flood" :
2167                                          group->type == 5 ? "L3 interface" :
2168                                          group->type == 6 ? "L3 multicast" :
2169                                          group->type == 7 ? "L3 ECMP" :
2170                                          group->type == 8 ? "L2 overlay" :
2171                                          "unknown");
2172
2173         if (group->has_vlan_id) {
2174             monitor_printf(mon, " vlan %d", group->vlan_id);
2175         }
2176
2177         if (group->has_pport) {
2178             monitor_printf(mon, " pport %d", group->pport);
2179         }
2180
2181         if (group->has_index) {
2182             monitor_printf(mon, " index %d", group->index);
2183         }
2184
2185         monitor_printf(mon, ") -->");
2186
2187         if (group->has_set_vlan_id && group->set_vlan_id) {
2188             set = true;
2189             monitor_printf(mon, " set vlan %d",
2190                            group->set_vlan_id & VLAN_VID_MASK);
2191         }
2192
2193         if (group->has_set_eth_src) {
2194             if (!set) {
2195                 set = true;
2196                 monitor_printf(mon, " set");
2197             }
2198             monitor_printf(mon, " src %s", group->set_eth_src);
2199         }
2200
2201         if (group->has_set_eth_dst) {
2202             if (!set) {
2203                 monitor_printf(mon, " set");
2204             }
2205             monitor_printf(mon, " dst %s", group->set_eth_dst);
2206         }
2207
2208         if (group->has_ttl_check && group->ttl_check) {
2209             monitor_printf(mon, " check TTL");
2210         }
2211
2212         if (group->has_group_id && group->group_id) {
2213             monitor_printf(mon, " group id 0x%08x", group->group_id);
2214         }
2215
2216         if (group->has_pop_vlan && group->pop_vlan) {
2217             monitor_printf(mon, " pop vlan");
2218         }
2219
2220         if (group->has_out_pport) {
2221             monitor_printf(mon, " out pport %d", group->out_pport);
2222         }
2223
2224         if (group->has_group_ids) {
2225             struct uint32List *id;
2226
2227             monitor_printf(mon, " groups [");
2228             for (id = group->group_ids; id; id = id->next) {
2229                 monitor_printf(mon, "0x%08x", id->value);
2230                 if (id->next) {
2231                     monitor_printf(mon, ",");
2232                 }
2233             }
2234             monitor_printf(mon, "]");
2235         }
2236
2237         monitor_printf(mon, "\n");
2238     }
2239
2240     qapi_free_RockerOfDpaGroupList(list);
2241 }
2242
2243 void hmp_info_ramblock(Monitor *mon, const QDict *qdict)
2244 {
2245     ram_block_dump(mon);
2246 }
2247
2248 void hmp_info_vm_generation_id(Monitor *mon, const QDict *qdict)
2249 {
2250     Error *err = NULL;
2251     GuidInfo *info = qmp_query_vm_generation_id(&err);
2252     if (info) {
2253         monitor_printf(mon, "%s\n", info->guid);
2254     }
2255     hmp_handle_error(mon, err);
2256     qapi_free_GuidInfo(info);
2257 }
2258
2259 void hmp_info_memory_size_summary(Monitor *mon, const QDict *qdict)
2260 {
2261     Error *err = NULL;
2262     MemoryInfo *info = qmp_query_memory_size_summary(&err);
2263     if (info) {
2264         monitor_printf(mon, "base memory: %" PRIu64 "\n",
2265                        info->base_memory);
2266
2267         if (info->has_plugged_memory) {
2268             monitor_printf(mon, "plugged memory: %" PRIu64 "\n",
2269                            info->plugged_memory);
2270         }
2271
2272         qapi_free_MemoryInfo(info);
2273     }
2274     hmp_handle_error(mon, err);
2275 }