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 "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/sysemu.h" 23 #include "qemu/config-file.h" 24 #include "qemu/option.h" 25 #include "qemu/timer.h" 26 #include "qemu/sockets.h" 27 #include "monitor/monitor.h" 28 #include "monitor/qdev.h" 29 #include "qapi/error.h" 30 #include "qapi/opts-visitor.h" 31 #include "qapi/qapi-builtin-visit.h" 32 #include "qapi/qapi-commands-block.h" 33 #include "qapi/qapi-commands-char.h" 34 #include "qapi/qapi-commands-migration.h" 35 #include "qapi/qapi-commands-misc.h" 36 #include "qapi/qapi-commands-net.h" 37 #include "qapi/qapi-commands-rocker.h" 38 #include "qapi/qapi-commands-run-state.h" 39 #include "qapi/qapi-commands-tpm.h" 40 #include "qapi/qapi-commands-ui.h" 41 #include "qapi/qmp/qdict.h" 42 #include "qapi/qmp/qerror.h" 43 #include "qapi/string-input-visitor.h" 44 #include "qapi/string-output-visitor.h" 45 #include "qom/object_interfaces.h" 46 #include "ui/console.h" 47 #include "block/nbd.h" 48 #include "block/qapi.h" 49 #include "qemu-io.h" 50 #include "qemu/cutils.h" 51 #include "qemu/error-report.h" 52 #include "exec/ramlist.h" 53 #include "hw/intc/intc.h" 54 #include "hw/rdma/rdma.h" 55 #include "migration/snapshot.h" 56 #include "migration/misc.h" 57 58 #ifdef CONFIG_SPICE 59 #include <spice/enums.h> 60 #endif 61 62 static void hmp_handle_error(Monitor *mon, Error **errp) 63 { 64 assert(errp); 65 if (*errp) { 66 error_reportf_err(*errp, "Error: "); 67 } 68 } 69 70 void hmp_info_name(Monitor *mon, const QDict *qdict) 71 { 72 NameInfo *info; 73 74 info = qmp_query_name(NULL); 75 if (info->has_name) { 76 monitor_printf(mon, "%s\n", info->name); 77 } 78 qapi_free_NameInfo(info); 79 } 80 81 void hmp_info_version(Monitor *mon, const QDict *qdict) 82 { 83 VersionInfo *info; 84 85 info = qmp_query_version(NULL); 86 87 monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n", 88 info->qemu->major, info->qemu->minor, info->qemu->micro, 89 info->package); 90 91 qapi_free_VersionInfo(info); 92 } 93 94 void hmp_info_kvm(Monitor *mon, const QDict *qdict) 95 { 96 KvmInfo *info; 97 98 info = qmp_query_kvm(NULL); 99 monitor_printf(mon, "kvm support: "); 100 if (info->present) { 101 monitor_printf(mon, "%s\n", info->enabled ? "enabled" : "disabled"); 102 } else { 103 monitor_printf(mon, "not compiled\n"); 104 } 105 106 qapi_free_KvmInfo(info); 107 } 108 109 void hmp_info_status(Monitor *mon, const QDict *qdict) 110 { 111 StatusInfo *info; 112 113 info = qmp_query_status(NULL); 114 115 monitor_printf(mon, "VM status: %s%s", 116 info->running ? "running" : "paused", 117 info->singlestep ? " (single step mode)" : ""); 118 119 if (!info->running && info->status != RUN_STATE_PAUSED) { 120 monitor_printf(mon, " (%s)", RunState_str(info->status)); 121 } 122 123 monitor_printf(mon, "\n"); 124 125 qapi_free_StatusInfo(info); 126 } 127 128 void hmp_info_uuid(Monitor *mon, const QDict *qdict) 129 { 130 UuidInfo *info; 131 132 info = qmp_query_uuid(NULL); 133 monitor_printf(mon, "%s\n", info->UUID); 134 qapi_free_UuidInfo(info); 135 } 136 137 void hmp_info_chardev(Monitor *mon, const QDict *qdict) 138 { 139 ChardevInfoList *char_info, *info; 140 141 char_info = qmp_query_chardev(NULL); 142 for (info = char_info; info; info = info->next) { 143 monitor_printf(mon, "%s: filename=%s\n", info->value->label, 144 info->value->filename); 145 } 146 147 qapi_free_ChardevInfoList(char_info); 148 } 149 150 void hmp_info_mice(Monitor *mon, const QDict *qdict) 151 { 152 MouseInfoList *mice_list, *mouse; 153 154 mice_list = qmp_query_mice(NULL); 155 if (!mice_list) { 156 monitor_printf(mon, "No mouse devices connected\n"); 157 return; 158 } 159 160 for (mouse = mice_list; mouse; mouse = mouse->next) { 161 monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n", 162 mouse->value->current ? '*' : ' ', 163 mouse->value->index, mouse->value->name, 164 mouse->value->absolute ? " (absolute)" : ""); 165 } 166 167 qapi_free_MouseInfoList(mice_list); 168 } 169 170 static char *SocketAddress_to_str(SocketAddress *addr) 171 { 172 switch (addr->type) { 173 case SOCKET_ADDRESS_TYPE_INET: 174 return g_strdup_printf("tcp:%s:%s", 175 addr->u.inet.host, 176 addr->u.inet.port); 177 case SOCKET_ADDRESS_TYPE_UNIX: 178 return g_strdup_printf("unix:%s", 179 addr->u.q_unix.path); 180 case SOCKET_ADDRESS_TYPE_FD: 181 return g_strdup_printf("fd:%s", addr->u.fd.str); 182 case SOCKET_ADDRESS_TYPE_VSOCK: 183 return g_strdup_printf("tcp:%s:%s", 184 addr->u.vsock.cid, 185 addr->u.vsock.port); 186 default: 187 return g_strdup("unknown address type"); 188 } 189 } 190 191 void hmp_info_migrate(Monitor *mon, const QDict *qdict) 192 { 193 MigrationInfo *info; 194 MigrationCapabilityStatusList *caps, *cap; 195 196 info = qmp_query_migrate(NULL); 197 caps = qmp_query_migrate_capabilities(NULL); 198 199 migration_global_dump(mon); 200 201 /* do not display parameters during setup */ 202 if (info->has_status && caps) { 203 monitor_printf(mon, "capabilities: "); 204 for (cap = caps; cap; cap = cap->next) { 205 monitor_printf(mon, "%s: %s ", 206 MigrationCapability_str(cap->value->capability), 207 cap->value->state ? "on" : "off"); 208 } 209 monitor_printf(mon, "\n"); 210 } 211 212 if (info->has_status) { 213 monitor_printf(mon, "Migration status: %s", 214 MigrationStatus_str(info->status)); 215 if (info->status == MIGRATION_STATUS_FAILED && 216 info->has_error_desc) { 217 monitor_printf(mon, " (%s)\n", info->error_desc); 218 } else { 219 monitor_printf(mon, "\n"); 220 } 221 222 monitor_printf(mon, "total time: %" PRIu64 " milliseconds\n", 223 info->total_time); 224 if (info->has_expected_downtime) { 225 monitor_printf(mon, "expected downtime: %" PRIu64 " milliseconds\n", 226 info->expected_downtime); 227 } 228 if (info->has_downtime) { 229 monitor_printf(mon, "downtime: %" PRIu64 " milliseconds\n", 230 info->downtime); 231 } 232 if (info->has_setup_time) { 233 monitor_printf(mon, "setup: %" PRIu64 " milliseconds\n", 234 info->setup_time); 235 } 236 } 237 238 if (info->has_ram) { 239 monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n", 240 info->ram->transferred >> 10); 241 monitor_printf(mon, "throughput: %0.2f mbps\n", 242 info->ram->mbps); 243 monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n", 244 info->ram->remaining >> 10); 245 monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n", 246 info->ram->total >> 10); 247 monitor_printf(mon, "duplicate: %" PRIu64 " pages\n", 248 info->ram->duplicate); 249 monitor_printf(mon, "skipped: %" PRIu64 " pages\n", 250 info->ram->skipped); 251 monitor_printf(mon, "normal: %" PRIu64 " pages\n", 252 info->ram->normal); 253 monitor_printf(mon, "normal bytes: %" PRIu64 " kbytes\n", 254 info->ram->normal_bytes >> 10); 255 monitor_printf(mon, "dirty sync count: %" PRIu64 "\n", 256 info->ram->dirty_sync_count); 257 monitor_printf(mon, "page size: %" PRIu64 " kbytes\n", 258 info->ram->page_size >> 10); 259 monitor_printf(mon, "multifd bytes: %" PRIu64 " kbytes\n", 260 info->ram->multifd_bytes >> 10); 261 monitor_printf(mon, "pages-per-second: %" PRIu64 "\n", 262 info->ram->pages_per_second); 263 264 if (info->ram->dirty_pages_rate) { 265 monitor_printf(mon, "dirty pages rate: %" PRIu64 " pages\n", 266 info->ram->dirty_pages_rate); 267 } 268 if (info->ram->postcopy_requests) { 269 monitor_printf(mon, "postcopy request count: %" PRIu64 "\n", 270 info->ram->postcopy_requests); 271 } 272 } 273 274 if (info->has_disk) { 275 monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n", 276 info->disk->transferred >> 10); 277 monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n", 278 info->disk->remaining >> 10); 279 monitor_printf(mon, "total disk: %" PRIu64 " kbytes\n", 280 info->disk->total >> 10); 281 } 282 283 if (info->has_xbzrle_cache) { 284 monitor_printf(mon, "cache size: %" PRIu64 " bytes\n", 285 info->xbzrle_cache->cache_size); 286 monitor_printf(mon, "xbzrle transferred: %" PRIu64 " kbytes\n", 287 info->xbzrle_cache->bytes >> 10); 288 monitor_printf(mon, "xbzrle pages: %" PRIu64 " pages\n", 289 info->xbzrle_cache->pages); 290 monitor_printf(mon, "xbzrle cache miss: %" PRIu64 "\n", 291 info->xbzrle_cache->cache_miss); 292 monitor_printf(mon, "xbzrle cache miss rate: %0.2f\n", 293 info->xbzrle_cache->cache_miss_rate); 294 monitor_printf(mon, "xbzrle overflow : %" PRIu64 "\n", 295 info->xbzrle_cache->overflow); 296 } 297 298 if (info->has_compression) { 299 monitor_printf(mon, "compression pages: %" PRIu64 " pages\n", 300 info->compression->pages); 301 monitor_printf(mon, "compression busy: %" PRIu64 "\n", 302 info->compression->busy); 303 monitor_printf(mon, "compression busy rate: %0.2f\n", 304 info->compression->busy_rate); 305 monitor_printf(mon, "compressed size: %" PRIu64 "\n", 306 info->compression->compressed_size); 307 monitor_printf(mon, "compression rate: %0.2f\n", 308 info->compression->compression_rate); 309 } 310 311 if (info->has_cpu_throttle_percentage) { 312 monitor_printf(mon, "cpu throttle percentage: %" PRIu64 "\n", 313 info->cpu_throttle_percentage); 314 } 315 316 if (info->has_postcopy_blocktime) { 317 monitor_printf(mon, "postcopy blocktime: %u\n", 318 info->postcopy_blocktime); 319 } 320 321 if (info->has_postcopy_vcpu_blocktime) { 322 Visitor *v; 323 char *str; 324 v = string_output_visitor_new(false, &str); 325 visit_type_uint32List(v, NULL, &info->postcopy_vcpu_blocktime, NULL); 326 visit_complete(v, &str); 327 monitor_printf(mon, "postcopy vcpu blocktime: %s\n", str); 328 g_free(str); 329 visit_free(v); 330 } 331 if (info->has_socket_address) { 332 SocketAddressList *addr; 333 334 monitor_printf(mon, "socket address: [\n"); 335 336 for (addr = info->socket_address; addr; addr = addr->next) { 337 char *s = SocketAddress_to_str(addr->value); 338 monitor_printf(mon, "\t%s\n", s); 339 g_free(s); 340 } 341 monitor_printf(mon, "]\n"); 342 } 343 qapi_free_MigrationInfo(info); 344 qapi_free_MigrationCapabilityStatusList(caps); 345 } 346 347 void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict) 348 { 349 MigrationCapabilityStatusList *caps, *cap; 350 351 caps = qmp_query_migrate_capabilities(NULL); 352 353 if (caps) { 354 for (cap = caps; cap; cap = cap->next) { 355 monitor_printf(mon, "%s: %s\n", 356 MigrationCapability_str(cap->value->capability), 357 cap->value->state ? "on" : "off"); 358 } 359 } 360 361 qapi_free_MigrationCapabilityStatusList(caps); 362 } 363 364 void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict) 365 { 366 MigrationParameters *params; 367 368 params = qmp_query_migrate_parameters(NULL); 369 370 if (params) { 371 monitor_printf(mon, "%s: %" PRIu64 " ms\n", 372 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_INITIAL), 373 params->announce_initial); 374 monitor_printf(mon, "%s: %" PRIu64 " ms\n", 375 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_MAX), 376 params->announce_max); 377 monitor_printf(mon, "%s: %" PRIu64 "\n", 378 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_ROUNDS), 379 params->announce_rounds); 380 monitor_printf(mon, "%s: %" PRIu64 " ms\n", 381 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_STEP), 382 params->announce_step); 383 assert(params->has_compress_level); 384 monitor_printf(mon, "%s: %u\n", 385 MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_LEVEL), 386 params->compress_level); 387 assert(params->has_compress_threads); 388 monitor_printf(mon, "%s: %u\n", 389 MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_THREADS), 390 params->compress_threads); 391 assert(params->has_compress_wait_thread); 392 monitor_printf(mon, "%s: %s\n", 393 MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD), 394 params->compress_wait_thread ? "on" : "off"); 395 assert(params->has_decompress_threads); 396 monitor_printf(mon, "%s: %u\n", 397 MigrationParameter_str(MIGRATION_PARAMETER_DECOMPRESS_THREADS), 398 params->decompress_threads); 399 assert(params->has_cpu_throttle_initial); 400 monitor_printf(mon, "%s: %u\n", 401 MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL), 402 params->cpu_throttle_initial); 403 assert(params->has_cpu_throttle_increment); 404 monitor_printf(mon, "%s: %u\n", 405 MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT), 406 params->cpu_throttle_increment); 407 assert(params->has_max_cpu_throttle); 408 monitor_printf(mon, "%s: %u\n", 409 MigrationParameter_str(MIGRATION_PARAMETER_MAX_CPU_THROTTLE), 410 params->max_cpu_throttle); 411 assert(params->has_tls_creds); 412 monitor_printf(mon, "%s: '%s'\n", 413 MigrationParameter_str(MIGRATION_PARAMETER_TLS_CREDS), 414 params->tls_creds); 415 assert(params->has_tls_hostname); 416 monitor_printf(mon, "%s: '%s'\n", 417 MigrationParameter_str(MIGRATION_PARAMETER_TLS_HOSTNAME), 418 params->tls_hostname); 419 assert(params->has_max_bandwidth); 420 monitor_printf(mon, "%s: %" PRIu64 " bytes/second\n", 421 MigrationParameter_str(MIGRATION_PARAMETER_MAX_BANDWIDTH), 422 params->max_bandwidth); 423 assert(params->has_downtime_limit); 424 monitor_printf(mon, "%s: %" PRIu64 " milliseconds\n", 425 MigrationParameter_str(MIGRATION_PARAMETER_DOWNTIME_LIMIT), 426 params->downtime_limit); 427 assert(params->has_x_checkpoint_delay); 428 monitor_printf(mon, "%s: %u\n", 429 MigrationParameter_str(MIGRATION_PARAMETER_X_CHECKPOINT_DELAY), 430 params->x_checkpoint_delay); 431 assert(params->has_block_incremental); 432 monitor_printf(mon, "%s: %s\n", 433 MigrationParameter_str(MIGRATION_PARAMETER_BLOCK_INCREMENTAL), 434 params->block_incremental ? "on" : "off"); 435 monitor_printf(mon, "%s: %u\n", 436 MigrationParameter_str(MIGRATION_PARAMETER_MULTIFD_CHANNELS), 437 params->multifd_channels); 438 monitor_printf(mon, "%s: %" PRIu64 "\n", 439 MigrationParameter_str(MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE), 440 params->xbzrle_cache_size); 441 monitor_printf(mon, "%s: %" PRIu64 "\n", 442 MigrationParameter_str(MIGRATION_PARAMETER_MAX_POSTCOPY_BANDWIDTH), 443 params->max_postcopy_bandwidth); 444 monitor_printf(mon, " %s: '%s'\n", 445 MigrationParameter_str(MIGRATION_PARAMETER_TLS_AUTHZ), 446 params->has_tls_authz ? params->tls_authz : ""); 447 } 448 449 qapi_free_MigrationParameters(params); 450 } 451 452 void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict) 453 { 454 monitor_printf(mon, "xbzrel cache size: %" PRId64 " kbytes\n", 455 qmp_query_migrate_cache_size(NULL) >> 10); 456 } 457 458 void hmp_info_cpus(Monitor *mon, const QDict *qdict) 459 { 460 CpuInfoFastList *cpu_list, *cpu; 461 462 cpu_list = qmp_query_cpus_fast(NULL); 463 464 for (cpu = cpu_list; cpu; cpu = cpu->next) { 465 int active = ' '; 466 467 if (cpu->value->cpu_index == monitor_get_cpu_index()) { 468 active = '*'; 469 } 470 471 monitor_printf(mon, "%c CPU #%" PRId64 ":", active, 472 cpu->value->cpu_index); 473 monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id); 474 } 475 476 qapi_free_CpuInfoFastList(cpu_list); 477 } 478 479 static void print_block_info(Monitor *mon, BlockInfo *info, 480 BlockDeviceInfo *inserted, bool verbose) 481 { 482 ImageInfo *image_info; 483 484 assert(!info || !info->has_inserted || info->inserted == inserted); 485 486 if (info && *info->device) { 487 monitor_printf(mon, "%s", info->device); 488 if (inserted && inserted->has_node_name) { 489 monitor_printf(mon, " (%s)", inserted->node_name); 490 } 491 } else { 492 assert(info || inserted); 493 monitor_printf(mon, "%s", 494 inserted && inserted->has_node_name ? inserted->node_name 495 : info && info->has_qdev ? info->qdev 496 : "<anonymous>"); 497 } 498 499 if (inserted) { 500 monitor_printf(mon, ": %s (%s%s%s)\n", 501 inserted->file, 502 inserted->drv, 503 inserted->ro ? ", read-only" : "", 504 inserted->encrypted ? ", encrypted" : ""); 505 } else { 506 monitor_printf(mon, ": [not inserted]\n"); 507 } 508 509 if (info) { 510 if (info->has_qdev) { 511 monitor_printf(mon, " Attached to: %s\n", info->qdev); 512 } 513 if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) { 514 monitor_printf(mon, " I/O status: %s\n", 515 BlockDeviceIoStatus_str(info->io_status)); 516 } 517 518 if (info->removable) { 519 monitor_printf(mon, " Removable device: %slocked, tray %s\n", 520 info->locked ? "" : "not ", 521 info->tray_open ? "open" : "closed"); 522 } 523 } 524 525 526 if (!inserted) { 527 return; 528 } 529 530 monitor_printf(mon, " Cache mode: %s%s%s\n", 531 inserted->cache->writeback ? "writeback" : "writethrough", 532 inserted->cache->direct ? ", direct" : "", 533 inserted->cache->no_flush ? ", ignore flushes" : ""); 534 535 if (inserted->has_backing_file) { 536 monitor_printf(mon, 537 " Backing file: %s " 538 "(chain depth: %" PRId64 ")\n", 539 inserted->backing_file, 540 inserted->backing_file_depth); 541 } 542 543 if (inserted->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) { 544 monitor_printf(mon, " Detect zeroes: %s\n", 545 BlockdevDetectZeroesOptions_str(inserted->detect_zeroes)); 546 } 547 548 if (inserted->bps || inserted->bps_rd || inserted->bps_wr || 549 inserted->iops || inserted->iops_rd || inserted->iops_wr) 550 { 551 monitor_printf(mon, " I/O throttling: bps=%" PRId64 552 " bps_rd=%" PRId64 " bps_wr=%" PRId64 553 " bps_max=%" PRId64 554 " bps_rd_max=%" PRId64 555 " bps_wr_max=%" PRId64 556 " iops=%" PRId64 " iops_rd=%" PRId64 557 " iops_wr=%" PRId64 558 " iops_max=%" PRId64 559 " iops_rd_max=%" PRId64 560 " iops_wr_max=%" PRId64 561 " iops_size=%" PRId64 562 " group=%s\n", 563 inserted->bps, 564 inserted->bps_rd, 565 inserted->bps_wr, 566 inserted->bps_max, 567 inserted->bps_rd_max, 568 inserted->bps_wr_max, 569 inserted->iops, 570 inserted->iops_rd, 571 inserted->iops_wr, 572 inserted->iops_max, 573 inserted->iops_rd_max, 574 inserted->iops_wr_max, 575 inserted->iops_size, 576 inserted->group); 577 } 578 579 if (verbose) { 580 monitor_printf(mon, "\nImages:\n"); 581 image_info = inserted->image; 582 while (1) { 583 bdrv_image_info_dump(image_info); 584 if (image_info->has_backing_image) { 585 image_info = image_info->backing_image; 586 } else { 587 break; 588 } 589 } 590 } 591 } 592 593 void hmp_info_block(Monitor *mon, const QDict *qdict) 594 { 595 BlockInfoList *block_list, *info; 596 BlockDeviceInfoList *blockdev_list, *blockdev; 597 const char *device = qdict_get_try_str(qdict, "device"); 598 bool verbose = qdict_get_try_bool(qdict, "verbose", false); 599 bool nodes = qdict_get_try_bool(qdict, "nodes", false); 600 bool printed = false; 601 602 /* Print BlockBackend information */ 603 if (!nodes) { 604 block_list = qmp_query_block(NULL); 605 } else { 606 block_list = NULL; 607 } 608 609 for (info = block_list; info; info = info->next) { 610 if (device && strcmp(device, info->value->device)) { 611 continue; 612 } 613 614 if (info != block_list) { 615 monitor_printf(mon, "\n"); 616 } 617 618 print_block_info(mon, info->value, info->value->has_inserted 619 ? info->value->inserted : NULL, 620 verbose); 621 printed = true; 622 } 623 624 qapi_free_BlockInfoList(block_list); 625 626 if ((!device && !nodes) || printed) { 627 return; 628 } 629 630 /* Print node information */ 631 blockdev_list = qmp_query_named_block_nodes(NULL); 632 for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) { 633 assert(blockdev->value->has_node_name); 634 if (device && strcmp(device, blockdev->value->node_name)) { 635 continue; 636 } 637 638 if (blockdev != blockdev_list) { 639 monitor_printf(mon, "\n"); 640 } 641 642 print_block_info(mon, NULL, blockdev->value, verbose); 643 } 644 qapi_free_BlockDeviceInfoList(blockdev_list); 645 } 646 647 void hmp_info_blockstats(Monitor *mon, const QDict *qdict) 648 { 649 BlockStatsList *stats_list, *stats; 650 651 stats_list = qmp_query_blockstats(false, false, NULL); 652 653 for (stats = stats_list; stats; stats = stats->next) { 654 if (!stats->value->has_device) { 655 continue; 656 } 657 658 monitor_printf(mon, "%s:", stats->value->device); 659 monitor_printf(mon, " rd_bytes=%" PRId64 660 " wr_bytes=%" PRId64 661 " rd_operations=%" PRId64 662 " wr_operations=%" PRId64 663 " flush_operations=%" PRId64 664 " wr_total_time_ns=%" PRId64 665 " rd_total_time_ns=%" PRId64 666 " flush_total_time_ns=%" PRId64 667 " rd_merged=%" PRId64 668 " wr_merged=%" PRId64 669 " idle_time_ns=%" PRId64 670 "\n", 671 stats->value->stats->rd_bytes, 672 stats->value->stats->wr_bytes, 673 stats->value->stats->rd_operations, 674 stats->value->stats->wr_operations, 675 stats->value->stats->flush_operations, 676 stats->value->stats->wr_total_time_ns, 677 stats->value->stats->rd_total_time_ns, 678 stats->value->stats->flush_total_time_ns, 679 stats->value->stats->rd_merged, 680 stats->value->stats->wr_merged, 681 stats->value->stats->idle_time_ns); 682 } 683 684 qapi_free_BlockStatsList(stats_list); 685 } 686 687 #ifdef CONFIG_VNC 688 /* Helper for hmp_info_vnc_clients, _servers */ 689 static void hmp_info_VncBasicInfo(Monitor *mon, VncBasicInfo *info, 690 const char *name) 691 { 692 monitor_printf(mon, " %s: %s:%s (%s%s)\n", 693 name, 694 info->host, 695 info->service, 696 NetworkAddressFamily_str(info->family), 697 info->websocket ? " (Websocket)" : ""); 698 } 699 700 /* Helper displaying and auth and crypt info */ 701 static void hmp_info_vnc_authcrypt(Monitor *mon, const char *indent, 702 VncPrimaryAuth auth, 703 VncVencryptSubAuth *vencrypt) 704 { 705 monitor_printf(mon, "%sAuth: %s (Sub: %s)\n", indent, 706 VncPrimaryAuth_str(auth), 707 vencrypt ? VncVencryptSubAuth_str(*vencrypt) : "none"); 708 } 709 710 static void hmp_info_vnc_clients(Monitor *mon, VncClientInfoList *client) 711 { 712 while (client) { 713 VncClientInfo *cinfo = client->value; 714 715 hmp_info_VncBasicInfo(mon, qapi_VncClientInfo_base(cinfo), "Client"); 716 monitor_printf(mon, " x509_dname: %s\n", 717 cinfo->has_x509_dname ? 718 cinfo->x509_dname : "none"); 719 monitor_printf(mon, " sasl_username: %s\n", 720 cinfo->has_sasl_username ? 721 cinfo->sasl_username : "none"); 722 723 client = client->next; 724 } 725 } 726 727 static void hmp_info_vnc_servers(Monitor *mon, VncServerInfo2List *server) 728 { 729 while (server) { 730 VncServerInfo2 *sinfo = server->value; 731 hmp_info_VncBasicInfo(mon, qapi_VncServerInfo2_base(sinfo), "Server"); 732 hmp_info_vnc_authcrypt(mon, " ", sinfo->auth, 733 sinfo->has_vencrypt ? &sinfo->vencrypt : NULL); 734 server = server->next; 735 } 736 } 737 738 void hmp_info_vnc(Monitor *mon, const QDict *qdict) 739 { 740 VncInfo2List *info2l; 741 Error *err = NULL; 742 743 info2l = qmp_query_vnc_servers(&err); 744 if (err) { 745 hmp_handle_error(mon, &err); 746 return; 747 } 748 if (!info2l) { 749 monitor_printf(mon, "None\n"); 750 return; 751 } 752 753 while (info2l) { 754 VncInfo2 *info = info2l->value; 755 monitor_printf(mon, "%s:\n", info->id); 756 hmp_info_vnc_servers(mon, info->server); 757 hmp_info_vnc_clients(mon, info->clients); 758 if (!info->server) { 759 /* The server entry displays its auth, we only 760 * need to display in the case of 'reverse' connections 761 * where there's no server. 762 */ 763 hmp_info_vnc_authcrypt(mon, " ", info->auth, 764 info->has_vencrypt ? &info->vencrypt : NULL); 765 } 766 if (info->has_display) { 767 monitor_printf(mon, " Display: %s\n", info->display); 768 } 769 info2l = info2l->next; 770 } 771 772 qapi_free_VncInfo2List(info2l); 773 774 } 775 #endif 776 777 #ifdef CONFIG_SPICE 778 void hmp_info_spice(Monitor *mon, const QDict *qdict) 779 { 780 SpiceChannelList *chan; 781 SpiceInfo *info; 782 const char *channel_name; 783 const char * const channel_names[] = { 784 [SPICE_CHANNEL_MAIN] = "main", 785 [SPICE_CHANNEL_DISPLAY] = "display", 786 [SPICE_CHANNEL_INPUTS] = "inputs", 787 [SPICE_CHANNEL_CURSOR] = "cursor", 788 [SPICE_CHANNEL_PLAYBACK] = "playback", 789 [SPICE_CHANNEL_RECORD] = "record", 790 [SPICE_CHANNEL_TUNNEL] = "tunnel", 791 [SPICE_CHANNEL_SMARTCARD] = "smartcard", 792 [SPICE_CHANNEL_USBREDIR] = "usbredir", 793 [SPICE_CHANNEL_PORT] = "port", 794 #if 0 795 /* minimum spice-protocol is 0.12.3, webdav was added in 0.12.7, 796 * no easy way to #ifdef (SPICE_CHANNEL_* is a enum). Disable 797 * as quick fix for build failures with older versions. */ 798 [SPICE_CHANNEL_WEBDAV] = "webdav", 799 #endif 800 }; 801 802 info = qmp_query_spice(NULL); 803 804 if (!info->enabled) { 805 monitor_printf(mon, "Server: disabled\n"); 806 goto out; 807 } 808 809 monitor_printf(mon, "Server:\n"); 810 if (info->has_port) { 811 monitor_printf(mon, " address: %s:%" PRId64 "\n", 812 info->host, info->port); 813 } 814 if (info->has_tls_port) { 815 monitor_printf(mon, " address: %s:%" PRId64 " [tls]\n", 816 info->host, info->tls_port); 817 } 818 monitor_printf(mon, " migrated: %s\n", 819 info->migrated ? "true" : "false"); 820 monitor_printf(mon, " auth: %s\n", info->auth); 821 monitor_printf(mon, " compiled: %s\n", info->compiled_version); 822 monitor_printf(mon, " mouse-mode: %s\n", 823 SpiceQueryMouseMode_str(info->mouse_mode)); 824 825 if (!info->has_channels || info->channels == NULL) { 826 monitor_printf(mon, "Channels: none\n"); 827 } else { 828 for (chan = info->channels; chan; chan = chan->next) { 829 monitor_printf(mon, "Channel:\n"); 830 monitor_printf(mon, " address: %s:%s%s\n", 831 chan->value->host, chan->value->port, 832 chan->value->tls ? " [tls]" : ""); 833 monitor_printf(mon, " session: %" PRId64 "\n", 834 chan->value->connection_id); 835 monitor_printf(mon, " channel: %" PRId64 ":%" PRId64 "\n", 836 chan->value->channel_type, chan->value->channel_id); 837 838 channel_name = "unknown"; 839 if (chan->value->channel_type > 0 && 840 chan->value->channel_type < ARRAY_SIZE(channel_names) && 841 channel_names[chan->value->channel_type]) { 842 channel_name = channel_names[chan->value->channel_type]; 843 } 844 845 monitor_printf(mon, " channel name: %s\n", channel_name); 846 } 847 } 848 849 out: 850 qapi_free_SpiceInfo(info); 851 } 852 #endif 853 854 void hmp_info_balloon(Monitor *mon, const QDict *qdict) 855 { 856 BalloonInfo *info; 857 Error *err = NULL; 858 859 info = qmp_query_balloon(&err); 860 if (err) { 861 hmp_handle_error(mon, &err); 862 return; 863 } 864 865 monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20); 866 867 qapi_free_BalloonInfo(info); 868 } 869 870 static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev) 871 { 872 PciMemoryRegionList *region; 873 874 monitor_printf(mon, " Bus %2" PRId64 ", ", dev->bus); 875 monitor_printf(mon, "device %3" PRId64 ", function %" PRId64 ":\n", 876 dev->slot, dev->function); 877 monitor_printf(mon, " "); 878 879 if (dev->class_info->has_desc) { 880 monitor_printf(mon, "%s", dev->class_info->desc); 881 } else { 882 monitor_printf(mon, "Class %04" PRId64, dev->class_info->q_class); 883 } 884 885 monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n", 886 dev->id->vendor, dev->id->device); 887 if (dev->id->has_subsystem_vendor && dev->id->has_subsystem) { 888 monitor_printf(mon, " PCI subsystem %04" PRIx64 ":%04" PRIx64 "\n", 889 dev->id->subsystem_vendor, dev->id->subsystem); 890 } 891 892 if (dev->has_irq) { 893 monitor_printf(mon, " IRQ %" PRId64 ".\n", dev->irq); 894 } 895 896 if (dev->has_pci_bridge) { 897 monitor_printf(mon, " BUS %" PRId64 ".\n", 898 dev->pci_bridge->bus->number); 899 monitor_printf(mon, " secondary bus %" PRId64 ".\n", 900 dev->pci_bridge->bus->secondary); 901 monitor_printf(mon, " subordinate bus %" PRId64 ".\n", 902 dev->pci_bridge->bus->subordinate); 903 904 monitor_printf(mon, " IO range [0x%04"PRIx64", 0x%04"PRIx64"]\n", 905 dev->pci_bridge->bus->io_range->base, 906 dev->pci_bridge->bus->io_range->limit); 907 908 monitor_printf(mon, 909 " memory range [0x%08"PRIx64", 0x%08"PRIx64"]\n", 910 dev->pci_bridge->bus->memory_range->base, 911 dev->pci_bridge->bus->memory_range->limit); 912 913 monitor_printf(mon, " prefetchable memory range " 914 "[0x%08"PRIx64", 0x%08"PRIx64"]\n", 915 dev->pci_bridge->bus->prefetchable_range->base, 916 dev->pci_bridge->bus->prefetchable_range->limit); 917 } 918 919 for (region = dev->regions; region; region = region->next) { 920 uint64_t addr, size; 921 922 addr = region->value->address; 923 size = region->value->size; 924 925 monitor_printf(mon, " BAR%" PRId64 ": ", region->value->bar); 926 927 if (!strcmp(region->value->type, "io")) { 928 monitor_printf(mon, "I/O at 0x%04" PRIx64 929 " [0x%04" PRIx64 "].\n", 930 addr, addr + size - 1); 931 } else { 932 monitor_printf(mon, "%d bit%s memory at 0x%08" PRIx64 933 " [0x%08" PRIx64 "].\n", 934 region->value->mem_type_64 ? 64 : 32, 935 region->value->prefetch ? " prefetchable" : "", 936 addr, addr + size - 1); 937 } 938 } 939 940 monitor_printf(mon, " id \"%s\"\n", dev->qdev_id); 941 942 if (dev->has_pci_bridge) { 943 if (dev->pci_bridge->has_devices) { 944 PciDeviceInfoList *cdev; 945 for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) { 946 hmp_info_pci_device(mon, cdev->value); 947 } 948 } 949 } 950 } 951 952 static int hmp_info_irq_foreach(Object *obj, void *opaque) 953 { 954 InterruptStatsProvider *intc; 955 InterruptStatsProviderClass *k; 956 Monitor *mon = opaque; 957 958 if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) { 959 intc = INTERRUPT_STATS_PROVIDER(obj); 960 k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj); 961 uint64_t *irq_counts; 962 unsigned int nb_irqs, i; 963 if (k->get_statistics && 964 k->get_statistics(intc, &irq_counts, &nb_irqs)) { 965 if (nb_irqs > 0) { 966 monitor_printf(mon, "IRQ statistics for %s:\n", 967 object_get_typename(obj)); 968 for (i = 0; i < nb_irqs; i++) { 969 if (irq_counts[i] > 0) { 970 monitor_printf(mon, "%2d: %" PRId64 "\n", i, 971 irq_counts[i]); 972 } 973 } 974 } 975 } else { 976 monitor_printf(mon, "IRQ statistics not available for %s.\n", 977 object_get_typename(obj)); 978 } 979 } 980 981 return 0; 982 } 983 984 void hmp_info_irq(Monitor *mon, const QDict *qdict) 985 { 986 object_child_foreach_recursive(object_get_root(), 987 hmp_info_irq_foreach, mon); 988 } 989 990 static int hmp_info_pic_foreach(Object *obj, void *opaque) 991 { 992 InterruptStatsProvider *intc; 993 InterruptStatsProviderClass *k; 994 Monitor *mon = opaque; 995 996 if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) { 997 intc = INTERRUPT_STATS_PROVIDER(obj); 998 k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj); 999 if (k->print_info) { 1000 k->print_info(intc, mon); 1001 } else { 1002 monitor_printf(mon, "Interrupt controller information not available for %s.\n", 1003 object_get_typename(obj)); 1004 } 1005 } 1006 1007 return 0; 1008 } 1009 1010 void hmp_info_pic(Monitor *mon, const QDict *qdict) 1011 { 1012 object_child_foreach_recursive(object_get_root(), 1013 hmp_info_pic_foreach, mon); 1014 } 1015 1016 static int hmp_info_rdma_foreach(Object *obj, void *opaque) 1017 { 1018 RdmaProvider *rdma; 1019 RdmaProviderClass *k; 1020 Monitor *mon = opaque; 1021 1022 if (object_dynamic_cast(obj, INTERFACE_RDMA_PROVIDER)) { 1023 rdma = RDMA_PROVIDER(obj); 1024 k = RDMA_PROVIDER_GET_CLASS(obj); 1025 if (k->print_statistics) { 1026 k->print_statistics(mon, rdma); 1027 } else { 1028 monitor_printf(mon, "RDMA statistics not available for %s.\n", 1029 object_get_typename(obj)); 1030 } 1031 } 1032 1033 return 0; 1034 } 1035 1036 void hmp_info_rdma(Monitor *mon, const QDict *qdict) 1037 { 1038 object_child_foreach_recursive(object_get_root(), 1039 hmp_info_rdma_foreach, mon); 1040 } 1041 1042 void hmp_info_pci(Monitor *mon, const QDict *qdict) 1043 { 1044 PciInfoList *info_list, *info; 1045 Error *err = NULL; 1046 1047 info_list = qmp_query_pci(&err); 1048 if (err) { 1049 monitor_printf(mon, "PCI devices not supported\n"); 1050 error_free(err); 1051 return; 1052 } 1053 1054 for (info = info_list; info; info = info->next) { 1055 PciDeviceInfoList *dev; 1056 1057 for (dev = info->value->devices; dev; dev = dev->next) { 1058 hmp_info_pci_device(mon, dev->value); 1059 } 1060 } 1061 1062 qapi_free_PciInfoList(info_list); 1063 } 1064 1065 void hmp_info_block_jobs(Monitor *mon, const QDict *qdict) 1066 { 1067 BlockJobInfoList *list; 1068 Error *err = NULL; 1069 1070 list = qmp_query_block_jobs(&err); 1071 assert(!err); 1072 1073 if (!list) { 1074 monitor_printf(mon, "No active jobs\n"); 1075 return; 1076 } 1077 1078 while (list) { 1079 if (strcmp(list->value->type, "stream") == 0) { 1080 monitor_printf(mon, "Streaming device %s: Completed %" PRId64 1081 " of %" PRId64 " bytes, speed limit %" PRId64 1082 " bytes/s\n", 1083 list->value->device, 1084 list->value->offset, 1085 list->value->len, 1086 list->value->speed); 1087 } else { 1088 monitor_printf(mon, "Type %s, device %s: Completed %" PRId64 1089 " of %" PRId64 " bytes, speed limit %" PRId64 1090 " bytes/s\n", 1091 list->value->type, 1092 list->value->device, 1093 list->value->offset, 1094 list->value->len, 1095 list->value->speed); 1096 } 1097 list = list->next; 1098 } 1099 1100 qapi_free_BlockJobInfoList(list); 1101 } 1102 1103 void hmp_info_tpm(Monitor *mon, const QDict *qdict) 1104 { 1105 TPMInfoList *info_list, *info; 1106 Error *err = NULL; 1107 unsigned int c = 0; 1108 TPMPassthroughOptions *tpo; 1109 TPMEmulatorOptions *teo; 1110 1111 info_list = qmp_query_tpm(&err); 1112 if (err) { 1113 monitor_printf(mon, "TPM device not supported\n"); 1114 error_free(err); 1115 return; 1116 } 1117 1118 if (info_list) { 1119 monitor_printf(mon, "TPM device:\n"); 1120 } 1121 1122 for (info = info_list; info; info = info->next) { 1123 TPMInfo *ti = info->value; 1124 monitor_printf(mon, " tpm%d: model=%s\n", 1125 c, TpmModel_str(ti->model)); 1126 1127 monitor_printf(mon, " \\ %s: type=%s", 1128 ti->id, TpmTypeOptionsKind_str(ti->options->type)); 1129 1130 switch (ti->options->type) { 1131 case TPM_TYPE_OPTIONS_KIND_PASSTHROUGH: 1132 tpo = ti->options->u.passthrough.data; 1133 monitor_printf(mon, "%s%s%s%s", 1134 tpo->has_path ? ",path=" : "", 1135 tpo->has_path ? tpo->path : "", 1136 tpo->has_cancel_path ? ",cancel-path=" : "", 1137 tpo->has_cancel_path ? tpo->cancel_path : ""); 1138 break; 1139 case TPM_TYPE_OPTIONS_KIND_EMULATOR: 1140 teo = ti->options->u.emulator.data; 1141 monitor_printf(mon, ",chardev=%s", teo->chardev); 1142 break; 1143 case TPM_TYPE_OPTIONS_KIND__MAX: 1144 break; 1145 } 1146 monitor_printf(mon, "\n"); 1147 c++; 1148 } 1149 qapi_free_TPMInfoList(info_list); 1150 } 1151 1152 void hmp_quit(Monitor *mon, const QDict *qdict) 1153 { 1154 monitor_suspend(mon); 1155 qmp_quit(NULL); 1156 } 1157 1158 void hmp_stop(Monitor *mon, const QDict *qdict) 1159 { 1160 qmp_stop(NULL); 1161 } 1162 1163 void hmp_sync_profile(Monitor *mon, const QDict *qdict) 1164 { 1165 const char *op = qdict_get_try_str(qdict, "op"); 1166 1167 if (op == NULL) { 1168 bool on = qsp_is_enabled(); 1169 1170 monitor_printf(mon, "sync-profile is %s\n", on ? "on" : "off"); 1171 return; 1172 } 1173 if (!strcmp(op, "on")) { 1174 qsp_enable(); 1175 } else if (!strcmp(op, "off")) { 1176 qsp_disable(); 1177 } else if (!strcmp(op, "reset")) { 1178 qsp_reset(); 1179 } else { 1180 Error *err = NULL; 1181 1182 error_setg(&err, QERR_INVALID_PARAMETER, op); 1183 hmp_handle_error(mon, &err); 1184 } 1185 } 1186 1187 void hmp_system_reset(Monitor *mon, const QDict *qdict) 1188 { 1189 qmp_system_reset(NULL); 1190 } 1191 1192 void hmp_system_powerdown(Monitor *mon, const QDict *qdict) 1193 { 1194 qmp_system_powerdown(NULL); 1195 } 1196 1197 void hmp_exit_preconfig(Monitor *mon, const QDict *qdict) 1198 { 1199 Error *err = NULL; 1200 1201 qmp_x_exit_preconfig(&err); 1202 hmp_handle_error(mon, &err); 1203 } 1204 1205 void hmp_cpu(Monitor *mon, const QDict *qdict) 1206 { 1207 int64_t cpu_index; 1208 1209 /* XXX: drop the monitor_set_cpu() usage when all HMP commands that 1210 use it are converted to the QAPI */ 1211 cpu_index = qdict_get_int(qdict, "index"); 1212 if (monitor_set_cpu(cpu_index) < 0) { 1213 monitor_printf(mon, "invalid CPU index\n"); 1214 } 1215 } 1216 1217 void hmp_memsave(Monitor *mon, const QDict *qdict) 1218 { 1219 uint32_t size = qdict_get_int(qdict, "size"); 1220 const char *filename = qdict_get_str(qdict, "filename"); 1221 uint64_t addr = qdict_get_int(qdict, "val"); 1222 Error *err = NULL; 1223 int cpu_index = monitor_get_cpu_index(); 1224 1225 if (cpu_index < 0) { 1226 monitor_printf(mon, "No CPU available\n"); 1227 return; 1228 } 1229 1230 qmp_memsave(addr, size, filename, true, cpu_index, &err); 1231 hmp_handle_error(mon, &err); 1232 } 1233 1234 void hmp_pmemsave(Monitor *mon, const QDict *qdict) 1235 { 1236 uint32_t size = qdict_get_int(qdict, "size"); 1237 const char *filename = qdict_get_str(qdict, "filename"); 1238 uint64_t addr = qdict_get_int(qdict, "val"); 1239 Error *err = NULL; 1240 1241 qmp_pmemsave(addr, size, filename, &err); 1242 hmp_handle_error(mon, &err); 1243 } 1244 1245 void hmp_ringbuf_write(Monitor *mon, const QDict *qdict) 1246 { 1247 const char *chardev = qdict_get_str(qdict, "device"); 1248 const char *data = qdict_get_str(qdict, "data"); 1249 Error *err = NULL; 1250 1251 qmp_ringbuf_write(chardev, data, false, 0, &err); 1252 1253 hmp_handle_error(mon, &err); 1254 } 1255 1256 void hmp_ringbuf_read(Monitor *mon, const QDict *qdict) 1257 { 1258 uint32_t size = qdict_get_int(qdict, "size"); 1259 const char *chardev = qdict_get_str(qdict, "device"); 1260 char *data; 1261 Error *err = NULL; 1262 int i; 1263 1264 data = qmp_ringbuf_read(chardev, size, false, 0, &err); 1265 if (err) { 1266 hmp_handle_error(mon, &err); 1267 return; 1268 } 1269 1270 for (i = 0; data[i]; i++) { 1271 unsigned char ch = data[i]; 1272 1273 if (ch == '\\') { 1274 monitor_printf(mon, "\\\\"); 1275 } else if ((ch < 0x20 && ch != '\n' && ch != '\t') || ch == 0x7F) { 1276 monitor_printf(mon, "\\u%04X", ch); 1277 } else { 1278 monitor_printf(mon, "%c", ch); 1279 } 1280 1281 } 1282 monitor_printf(mon, "\n"); 1283 g_free(data); 1284 } 1285 1286 void hmp_cont(Monitor *mon, const QDict *qdict) 1287 { 1288 Error *err = NULL; 1289 1290 qmp_cont(&err); 1291 hmp_handle_error(mon, &err); 1292 } 1293 1294 void hmp_system_wakeup(Monitor *mon, const QDict *qdict) 1295 { 1296 Error *err = NULL; 1297 1298 qmp_system_wakeup(&err); 1299 hmp_handle_error(mon, &err); 1300 } 1301 1302 void hmp_nmi(Monitor *mon, const QDict *qdict) 1303 { 1304 Error *err = NULL; 1305 1306 qmp_inject_nmi(&err); 1307 hmp_handle_error(mon, &err); 1308 } 1309 1310 void hmp_set_link(Monitor *mon, const QDict *qdict) 1311 { 1312 const char *name = qdict_get_str(qdict, "name"); 1313 bool up = qdict_get_bool(qdict, "up"); 1314 Error *err = NULL; 1315 1316 qmp_set_link(name, up, &err); 1317 hmp_handle_error(mon, &err); 1318 } 1319 1320 void hmp_block_passwd(Monitor *mon, const QDict *qdict) 1321 { 1322 const char *device = qdict_get_str(qdict, "device"); 1323 const char *password = qdict_get_str(qdict, "password"); 1324 Error *err = NULL; 1325 1326 qmp_block_passwd(true, device, false, NULL, password, &err); 1327 hmp_handle_error(mon, &err); 1328 } 1329 1330 void hmp_balloon(Monitor *mon, const QDict *qdict) 1331 { 1332 int64_t value = qdict_get_int(qdict, "value"); 1333 Error *err = NULL; 1334 1335 qmp_balloon(value, &err); 1336 hmp_handle_error(mon, &err); 1337 } 1338 1339 void hmp_block_resize(Monitor *mon, const QDict *qdict) 1340 { 1341 const char *device = qdict_get_str(qdict, "device"); 1342 int64_t size = qdict_get_int(qdict, "size"); 1343 Error *err = NULL; 1344 1345 qmp_block_resize(true, device, false, NULL, size, &err); 1346 hmp_handle_error(mon, &err); 1347 } 1348 1349 void hmp_drive_mirror(Monitor *mon, const QDict *qdict) 1350 { 1351 const char *filename = qdict_get_str(qdict, "target"); 1352 const char *format = qdict_get_try_str(qdict, "format"); 1353 bool reuse = qdict_get_try_bool(qdict, "reuse", false); 1354 bool full = qdict_get_try_bool(qdict, "full", false); 1355 Error *err = NULL; 1356 DriveMirror mirror = { 1357 .device = (char *)qdict_get_str(qdict, "device"), 1358 .target = (char *)filename, 1359 .has_format = !!format, 1360 .format = (char *)format, 1361 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP, 1362 .has_mode = true, 1363 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS, 1364 .unmap = true, 1365 }; 1366 1367 if (!filename) { 1368 error_setg(&err, QERR_MISSING_PARAMETER, "target"); 1369 hmp_handle_error(mon, &err); 1370 return; 1371 } 1372 qmp_drive_mirror(&mirror, &err); 1373 hmp_handle_error(mon, &err); 1374 } 1375 1376 void hmp_drive_backup(Monitor *mon, const QDict *qdict) 1377 { 1378 const char *device = qdict_get_str(qdict, "device"); 1379 const char *filename = qdict_get_str(qdict, "target"); 1380 const char *format = qdict_get_try_str(qdict, "format"); 1381 bool reuse = qdict_get_try_bool(qdict, "reuse", false); 1382 bool full = qdict_get_try_bool(qdict, "full", false); 1383 bool compress = qdict_get_try_bool(qdict, "compress", false); 1384 Error *err = NULL; 1385 DriveBackup backup = { 1386 .device = (char *)device, 1387 .target = (char *)filename, 1388 .has_format = !!format, 1389 .format = (char *)format, 1390 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP, 1391 .has_mode = true, 1392 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS, 1393 .has_compress = !!compress, 1394 .compress = compress, 1395 }; 1396 1397 if (!filename) { 1398 error_setg(&err, QERR_MISSING_PARAMETER, "target"); 1399 hmp_handle_error(mon, &err); 1400 return; 1401 } 1402 1403 qmp_drive_backup(&backup, &err); 1404 hmp_handle_error(mon, &err); 1405 } 1406 1407 void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict) 1408 { 1409 const char *device = qdict_get_str(qdict, "device"); 1410 const char *filename = qdict_get_try_str(qdict, "snapshot-file"); 1411 const char *format = qdict_get_try_str(qdict, "format"); 1412 bool reuse = qdict_get_try_bool(qdict, "reuse", false); 1413 enum NewImageMode mode; 1414 Error *err = NULL; 1415 1416 if (!filename) { 1417 /* In the future, if 'snapshot-file' is not specified, the snapshot 1418 will be taken internally. Today it's actually required. */ 1419 error_setg(&err, QERR_MISSING_PARAMETER, "snapshot-file"); 1420 hmp_handle_error(mon, &err); 1421 return; 1422 } 1423 1424 mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS; 1425 qmp_blockdev_snapshot_sync(true, device, false, NULL, 1426 filename, false, NULL, 1427 !!format, format, 1428 true, mode, &err); 1429 hmp_handle_error(mon, &err); 1430 } 1431 1432 void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict) 1433 { 1434 const char *device = qdict_get_str(qdict, "device"); 1435 const char *name = qdict_get_str(qdict, "name"); 1436 Error *err = NULL; 1437 1438 qmp_blockdev_snapshot_internal_sync(device, name, &err); 1439 hmp_handle_error(mon, &err); 1440 } 1441 1442 void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict) 1443 { 1444 const char *device = qdict_get_str(qdict, "device"); 1445 const char *name = qdict_get_str(qdict, "name"); 1446 const char *id = qdict_get_try_str(qdict, "id"); 1447 Error *err = NULL; 1448 1449 qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id, 1450 true, name, &err); 1451 hmp_handle_error(mon, &err); 1452 } 1453 1454 void hmp_loadvm(Monitor *mon, const QDict *qdict) 1455 { 1456 int saved_vm_running = runstate_is_running(); 1457 const char *name = qdict_get_str(qdict, "name"); 1458 Error *err = NULL; 1459 1460 vm_stop(RUN_STATE_RESTORE_VM); 1461 1462 if (load_snapshot(name, &err) == 0 && saved_vm_running) { 1463 vm_start(); 1464 } 1465 hmp_handle_error(mon, &err); 1466 } 1467 1468 void hmp_savevm(Monitor *mon, const QDict *qdict) 1469 { 1470 Error *err = NULL; 1471 1472 save_snapshot(qdict_get_try_str(qdict, "name"), &err); 1473 hmp_handle_error(mon, &err); 1474 } 1475 1476 void hmp_delvm(Monitor *mon, const QDict *qdict) 1477 { 1478 BlockDriverState *bs; 1479 Error *err = NULL; 1480 const char *name = qdict_get_str(qdict, "name"); 1481 1482 if (bdrv_all_delete_snapshot(name, &bs, &err) < 0) { 1483 error_prepend(&err, 1484 "deleting snapshot on device '%s': ", 1485 bdrv_get_device_name(bs)); 1486 } 1487 hmp_handle_error(mon, &err); 1488 } 1489 1490 void hmp_info_snapshots(Monitor *mon, const QDict *qdict) 1491 { 1492 BlockDriverState *bs, *bs1; 1493 BdrvNextIterator it1; 1494 QEMUSnapshotInfo *sn_tab, *sn; 1495 bool no_snapshot = true; 1496 int nb_sns, i; 1497 int total; 1498 int *global_snapshots; 1499 AioContext *aio_context; 1500 1501 typedef struct SnapshotEntry { 1502 QEMUSnapshotInfo sn; 1503 QTAILQ_ENTRY(SnapshotEntry) next; 1504 } SnapshotEntry; 1505 1506 typedef struct ImageEntry { 1507 const char *imagename; 1508 QTAILQ_ENTRY(ImageEntry) next; 1509 QTAILQ_HEAD(, SnapshotEntry) snapshots; 1510 } ImageEntry; 1511 1512 QTAILQ_HEAD(, ImageEntry) image_list = 1513 QTAILQ_HEAD_INITIALIZER(image_list); 1514 1515 ImageEntry *image_entry, *next_ie; 1516 SnapshotEntry *snapshot_entry; 1517 1518 bs = bdrv_all_find_vmstate_bs(); 1519 if (!bs) { 1520 monitor_printf(mon, "No available block device supports snapshots\n"); 1521 return; 1522 } 1523 aio_context = bdrv_get_aio_context(bs); 1524 1525 aio_context_acquire(aio_context); 1526 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 1527 aio_context_release(aio_context); 1528 1529 if (nb_sns < 0) { 1530 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns); 1531 return; 1532 } 1533 1534 for (bs1 = bdrv_first(&it1); bs1; bs1 = bdrv_next(&it1)) { 1535 int bs1_nb_sns = 0; 1536 ImageEntry *ie; 1537 SnapshotEntry *se; 1538 AioContext *ctx = bdrv_get_aio_context(bs1); 1539 1540 aio_context_acquire(ctx); 1541 if (bdrv_can_snapshot(bs1)) { 1542 sn = NULL; 1543 bs1_nb_sns = bdrv_snapshot_list(bs1, &sn); 1544 if (bs1_nb_sns > 0) { 1545 no_snapshot = false; 1546 ie = g_new0(ImageEntry, 1); 1547 ie->imagename = bdrv_get_device_name(bs1); 1548 QTAILQ_INIT(&ie->snapshots); 1549 QTAILQ_INSERT_TAIL(&image_list, ie, next); 1550 for (i = 0; i < bs1_nb_sns; i++) { 1551 se = g_new0(SnapshotEntry, 1); 1552 se->sn = sn[i]; 1553 QTAILQ_INSERT_TAIL(&ie->snapshots, se, next); 1554 } 1555 } 1556 g_free(sn); 1557 } 1558 aio_context_release(ctx); 1559 } 1560 1561 if (no_snapshot) { 1562 monitor_printf(mon, "There is no snapshot available.\n"); 1563 return; 1564 } 1565 1566 global_snapshots = g_new0(int, nb_sns); 1567 total = 0; 1568 for (i = 0; i < nb_sns; i++) { 1569 SnapshotEntry *next_sn; 1570 if (bdrv_all_find_snapshot(sn_tab[i].name, &bs1) == 0) { 1571 global_snapshots[total] = i; 1572 total++; 1573 QTAILQ_FOREACH(image_entry, &image_list, next) { 1574 QTAILQ_FOREACH_SAFE(snapshot_entry, &image_entry->snapshots, 1575 next, next_sn) { 1576 if (!strcmp(sn_tab[i].name, snapshot_entry->sn.name)) { 1577 QTAILQ_REMOVE(&image_entry->snapshots, snapshot_entry, 1578 next); 1579 g_free(snapshot_entry); 1580 } 1581 } 1582 } 1583 } 1584 } 1585 1586 monitor_printf(mon, "List of snapshots present on all disks:\n"); 1587 1588 if (total > 0) { 1589 bdrv_snapshot_dump(NULL); 1590 monitor_printf(mon, "\n"); 1591 for (i = 0; i < total; i++) { 1592 sn = &sn_tab[global_snapshots[i]]; 1593 /* The ID is not guaranteed to be the same on all images, so 1594 * overwrite it. 1595 */ 1596 pstrcpy(sn->id_str, sizeof(sn->id_str), "--"); 1597 bdrv_snapshot_dump(sn); 1598 monitor_printf(mon, "\n"); 1599 } 1600 } else { 1601 monitor_printf(mon, "None\n"); 1602 } 1603 1604 QTAILQ_FOREACH(image_entry, &image_list, next) { 1605 if (QTAILQ_EMPTY(&image_entry->snapshots)) { 1606 continue; 1607 } 1608 monitor_printf(mon, 1609 "\nList of partial (non-loadable) snapshots on '%s':\n", 1610 image_entry->imagename); 1611 bdrv_snapshot_dump(NULL); 1612 monitor_printf(mon, "\n"); 1613 QTAILQ_FOREACH(snapshot_entry, &image_entry->snapshots, next) { 1614 bdrv_snapshot_dump(&snapshot_entry->sn); 1615 monitor_printf(mon, "\n"); 1616 } 1617 } 1618 1619 QTAILQ_FOREACH_SAFE(image_entry, &image_list, next, next_ie) { 1620 SnapshotEntry *next_sn; 1621 QTAILQ_FOREACH_SAFE(snapshot_entry, &image_entry->snapshots, next, 1622 next_sn) { 1623 g_free(snapshot_entry); 1624 } 1625 g_free(image_entry); 1626 } 1627 g_free(sn_tab); 1628 g_free(global_snapshots); 1629 1630 } 1631 1632 void hmp_announce_self(Monitor *mon, const QDict *qdict) 1633 { 1634 qmp_announce_self(migrate_announce_params(), NULL); 1635 } 1636 1637 void hmp_migrate_cancel(Monitor *mon, const QDict *qdict) 1638 { 1639 qmp_migrate_cancel(NULL); 1640 } 1641 1642 void hmp_migrate_continue(Monitor *mon, const QDict *qdict) 1643 { 1644 Error *err = NULL; 1645 const char *state = qdict_get_str(qdict, "state"); 1646 int val = qapi_enum_parse(&MigrationStatus_lookup, state, -1, &err); 1647 1648 if (val >= 0) { 1649 qmp_migrate_continue(val, &err); 1650 } 1651 1652 hmp_handle_error(mon, &err); 1653 } 1654 1655 void hmp_migrate_incoming(Monitor *mon, const QDict *qdict) 1656 { 1657 Error *err = NULL; 1658 const char *uri = qdict_get_str(qdict, "uri"); 1659 1660 qmp_migrate_incoming(uri, &err); 1661 1662 hmp_handle_error(mon, &err); 1663 } 1664 1665 void hmp_migrate_recover(Monitor *mon, const QDict *qdict) 1666 { 1667 Error *err = NULL; 1668 const char *uri = qdict_get_str(qdict, "uri"); 1669 1670 qmp_migrate_recover(uri, &err); 1671 1672 hmp_handle_error(mon, &err); 1673 } 1674 1675 void hmp_migrate_pause(Monitor *mon, const QDict *qdict) 1676 { 1677 Error *err = NULL; 1678 1679 qmp_migrate_pause(&err); 1680 1681 hmp_handle_error(mon, &err); 1682 } 1683 1684 /* Kept for backwards compatibility */ 1685 void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict) 1686 { 1687 double value = qdict_get_double(qdict, "value"); 1688 qmp_migrate_set_downtime(value, NULL); 1689 } 1690 1691 void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict) 1692 { 1693 int64_t value = qdict_get_int(qdict, "value"); 1694 Error *err = NULL; 1695 1696 qmp_migrate_set_cache_size(value, &err); 1697 hmp_handle_error(mon, &err); 1698 } 1699 1700 /* Kept for backwards compatibility */ 1701 void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict) 1702 { 1703 int64_t value = qdict_get_int(qdict, "value"); 1704 qmp_migrate_set_speed(value, NULL); 1705 } 1706 1707 void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict) 1708 { 1709 const char *cap = qdict_get_str(qdict, "capability"); 1710 bool state = qdict_get_bool(qdict, "state"); 1711 Error *err = NULL; 1712 MigrationCapabilityStatusList *caps = g_malloc0(sizeof(*caps)); 1713 int val; 1714 1715 val = qapi_enum_parse(&MigrationCapability_lookup, cap, -1, &err); 1716 if (val < 0) { 1717 goto end; 1718 } 1719 1720 caps->value = g_malloc0(sizeof(*caps->value)); 1721 caps->value->capability = val; 1722 caps->value->state = state; 1723 caps->next = NULL; 1724 qmp_migrate_set_capabilities(caps, &err); 1725 1726 end: 1727 qapi_free_MigrationCapabilityStatusList(caps); 1728 hmp_handle_error(mon, &err); 1729 } 1730 1731 void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict) 1732 { 1733 const char *param = qdict_get_str(qdict, "parameter"); 1734 const char *valuestr = qdict_get_str(qdict, "value"); 1735 Visitor *v = string_input_visitor_new(valuestr); 1736 MigrateSetParameters *p = g_new0(MigrateSetParameters, 1); 1737 uint64_t valuebw = 0; 1738 uint64_t cache_size; 1739 Error *err = NULL; 1740 int val, ret; 1741 1742 val = qapi_enum_parse(&MigrationParameter_lookup, param, -1, &err); 1743 if (val < 0) { 1744 goto cleanup; 1745 } 1746 1747 switch (val) { 1748 case MIGRATION_PARAMETER_COMPRESS_LEVEL: 1749 p->has_compress_level = true; 1750 visit_type_int(v, param, &p->compress_level, &err); 1751 break; 1752 case MIGRATION_PARAMETER_COMPRESS_THREADS: 1753 p->has_compress_threads = true; 1754 visit_type_int(v, param, &p->compress_threads, &err); 1755 break; 1756 case MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD: 1757 p->has_compress_wait_thread = true; 1758 visit_type_bool(v, param, &p->compress_wait_thread, &err); 1759 break; 1760 case MIGRATION_PARAMETER_DECOMPRESS_THREADS: 1761 p->has_decompress_threads = true; 1762 visit_type_int(v, param, &p->decompress_threads, &err); 1763 break; 1764 case MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL: 1765 p->has_cpu_throttle_initial = true; 1766 visit_type_int(v, param, &p->cpu_throttle_initial, &err); 1767 break; 1768 case MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT: 1769 p->has_cpu_throttle_increment = true; 1770 visit_type_int(v, param, &p->cpu_throttle_increment, &err); 1771 break; 1772 case MIGRATION_PARAMETER_MAX_CPU_THROTTLE: 1773 p->has_max_cpu_throttle = true; 1774 visit_type_int(v, param, &p->max_cpu_throttle, &err); 1775 break; 1776 case MIGRATION_PARAMETER_TLS_CREDS: 1777 p->has_tls_creds = true; 1778 p->tls_creds = g_new0(StrOrNull, 1); 1779 p->tls_creds->type = QTYPE_QSTRING; 1780 visit_type_str(v, param, &p->tls_creds->u.s, &err); 1781 break; 1782 case MIGRATION_PARAMETER_TLS_HOSTNAME: 1783 p->has_tls_hostname = true; 1784 p->tls_hostname = g_new0(StrOrNull, 1); 1785 p->tls_hostname->type = QTYPE_QSTRING; 1786 visit_type_str(v, param, &p->tls_hostname->u.s, &err); 1787 break; 1788 case MIGRATION_PARAMETER_TLS_AUTHZ: 1789 p->has_tls_authz = true; 1790 p->tls_authz = g_new0(StrOrNull, 1); 1791 p->tls_authz->type = QTYPE_QSTRING; 1792 visit_type_str(v, param, &p->tls_authz->u.s, &err); 1793 break; 1794 case MIGRATION_PARAMETER_MAX_BANDWIDTH: 1795 p->has_max_bandwidth = true; 1796 /* 1797 * Can't use visit_type_size() here, because it 1798 * defaults to Bytes rather than Mebibytes. 1799 */ 1800 ret = qemu_strtosz_MiB(valuestr, NULL, &valuebw); 1801 if (ret < 0 || valuebw > INT64_MAX 1802 || (size_t)valuebw != valuebw) { 1803 error_setg(&err, "Invalid size %s", valuestr); 1804 break; 1805 } 1806 p->max_bandwidth = valuebw; 1807 break; 1808 case MIGRATION_PARAMETER_DOWNTIME_LIMIT: 1809 p->has_downtime_limit = true; 1810 visit_type_int(v, param, &p->downtime_limit, &err); 1811 break; 1812 case MIGRATION_PARAMETER_X_CHECKPOINT_DELAY: 1813 p->has_x_checkpoint_delay = true; 1814 visit_type_int(v, param, &p->x_checkpoint_delay, &err); 1815 break; 1816 case MIGRATION_PARAMETER_BLOCK_INCREMENTAL: 1817 p->has_block_incremental = true; 1818 visit_type_bool(v, param, &p->block_incremental, &err); 1819 break; 1820 case MIGRATION_PARAMETER_MULTIFD_CHANNELS: 1821 p->has_multifd_channels = true; 1822 visit_type_int(v, param, &p->multifd_channels, &err); 1823 break; 1824 case MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE: 1825 p->has_xbzrle_cache_size = true; 1826 visit_type_size(v, param, &cache_size, &err); 1827 if (err) { 1828 break; 1829 } 1830 if (cache_size > INT64_MAX || (size_t)cache_size != cache_size) { 1831 error_setg(&err, "Invalid size %s", valuestr); 1832 break; 1833 } 1834 p->xbzrle_cache_size = cache_size; 1835 break; 1836 case MIGRATION_PARAMETER_MAX_POSTCOPY_BANDWIDTH: 1837 p->has_max_postcopy_bandwidth = true; 1838 visit_type_size(v, param, &p->max_postcopy_bandwidth, &err); 1839 break; 1840 case MIGRATION_PARAMETER_ANNOUNCE_INITIAL: 1841 p->has_announce_initial = true; 1842 visit_type_size(v, param, &p->announce_initial, &err); 1843 break; 1844 case MIGRATION_PARAMETER_ANNOUNCE_MAX: 1845 p->has_announce_max = true; 1846 visit_type_size(v, param, &p->announce_max, &err); 1847 break; 1848 case MIGRATION_PARAMETER_ANNOUNCE_ROUNDS: 1849 p->has_announce_rounds = true; 1850 visit_type_size(v, param, &p->announce_rounds, &err); 1851 break; 1852 case MIGRATION_PARAMETER_ANNOUNCE_STEP: 1853 p->has_announce_step = true; 1854 visit_type_size(v, param, &p->announce_step, &err); 1855 break; 1856 default: 1857 assert(0); 1858 } 1859 1860 if (err) { 1861 goto cleanup; 1862 } 1863 1864 qmp_migrate_set_parameters(p, &err); 1865 1866 cleanup: 1867 qapi_free_MigrateSetParameters(p); 1868 visit_free(v); 1869 hmp_handle_error(mon, &err); 1870 } 1871 1872 void hmp_client_migrate_info(Monitor *mon, const QDict *qdict) 1873 { 1874 Error *err = NULL; 1875 const char *protocol = qdict_get_str(qdict, "protocol"); 1876 const char *hostname = qdict_get_str(qdict, "hostname"); 1877 bool has_port = qdict_haskey(qdict, "port"); 1878 int port = qdict_get_try_int(qdict, "port", -1); 1879 bool has_tls_port = qdict_haskey(qdict, "tls-port"); 1880 int tls_port = qdict_get_try_int(qdict, "tls-port", -1); 1881 const char *cert_subject = qdict_get_try_str(qdict, "cert-subject"); 1882 1883 qmp_client_migrate_info(protocol, hostname, 1884 has_port, port, has_tls_port, tls_port, 1885 !!cert_subject, cert_subject, &err); 1886 hmp_handle_error(mon, &err); 1887 } 1888 1889 void hmp_migrate_start_postcopy(Monitor *mon, const QDict *qdict) 1890 { 1891 Error *err = NULL; 1892 qmp_migrate_start_postcopy(&err); 1893 hmp_handle_error(mon, &err); 1894 } 1895 1896 void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict) 1897 { 1898 Error *err = NULL; 1899 1900 qmp_x_colo_lost_heartbeat(&err); 1901 hmp_handle_error(mon, &err); 1902 } 1903 1904 void hmp_set_password(Monitor *mon, const QDict *qdict) 1905 { 1906 const char *protocol = qdict_get_str(qdict, "protocol"); 1907 const char *password = qdict_get_str(qdict, "password"); 1908 const char *connected = qdict_get_try_str(qdict, "connected"); 1909 Error *err = NULL; 1910 1911 qmp_set_password(protocol, password, !!connected, connected, &err); 1912 hmp_handle_error(mon, &err); 1913 } 1914 1915 void hmp_expire_password(Monitor *mon, const QDict *qdict) 1916 { 1917 const char *protocol = qdict_get_str(qdict, "protocol"); 1918 const char *whenstr = qdict_get_str(qdict, "time"); 1919 Error *err = NULL; 1920 1921 qmp_expire_password(protocol, whenstr, &err); 1922 hmp_handle_error(mon, &err); 1923 } 1924 1925 void hmp_eject(Monitor *mon, const QDict *qdict) 1926 { 1927 bool force = qdict_get_try_bool(qdict, "force", false); 1928 const char *device = qdict_get_str(qdict, "device"); 1929 Error *err = NULL; 1930 1931 qmp_eject(true, device, false, NULL, true, force, &err); 1932 hmp_handle_error(mon, &err); 1933 } 1934 1935 #ifdef CONFIG_VNC 1936 static void hmp_change_read_arg(void *opaque, const char *password, 1937 void *readline_opaque) 1938 { 1939 qmp_change_vnc_password(password, NULL); 1940 monitor_read_command(opaque, 1); 1941 } 1942 #endif 1943 1944 void hmp_change(Monitor *mon, const QDict *qdict) 1945 { 1946 /* FIXME Make MonitorHMP public and use container_of */ 1947 MonitorHMP *hmp_mon = (MonitorHMP *)mon; 1948 const char *device = qdict_get_str(qdict, "device"); 1949 const char *target = qdict_get_str(qdict, "target"); 1950 const char *arg = qdict_get_try_str(qdict, "arg"); 1951 const char *read_only = qdict_get_try_str(qdict, "read-only-mode"); 1952 BlockdevChangeReadOnlyMode read_only_mode = 0; 1953 Error *err = NULL; 1954 1955 #ifdef CONFIG_VNC 1956 if (strcmp(device, "vnc") == 0) { 1957 if (read_only) { 1958 monitor_printf(mon, 1959 "Parameter 'read-only-mode' is invalid for VNC\n"); 1960 return; 1961 } 1962 if (strcmp(target, "passwd") == 0 || 1963 strcmp(target, "password") == 0) { 1964 if (!arg) { 1965 monitor_read_password(hmp_mon, hmp_change_read_arg, NULL); 1966 return; 1967 } 1968 } 1969 qmp_change("vnc", target, !!arg, arg, &err); 1970 } else 1971 #endif 1972 { 1973 if (read_only) { 1974 read_only_mode = 1975 qapi_enum_parse(&BlockdevChangeReadOnlyMode_lookup, 1976 read_only, 1977 BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN, &err); 1978 if (err) { 1979 hmp_handle_error(mon, &err); 1980 return; 1981 } 1982 } 1983 1984 qmp_blockdev_change_medium(true, device, false, NULL, target, 1985 !!arg, arg, !!read_only, read_only_mode, 1986 &err); 1987 } 1988 1989 hmp_handle_error(mon, &err); 1990 } 1991 1992 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict) 1993 { 1994 Error *err = NULL; 1995 char *device = (char *) qdict_get_str(qdict, "device"); 1996 BlockIOThrottle throttle = { 1997 .bps = qdict_get_int(qdict, "bps"), 1998 .bps_rd = qdict_get_int(qdict, "bps_rd"), 1999 .bps_wr = qdict_get_int(qdict, "bps_wr"), 2000 .iops = qdict_get_int(qdict, "iops"), 2001 .iops_rd = qdict_get_int(qdict, "iops_rd"), 2002 .iops_wr = qdict_get_int(qdict, "iops_wr"), 2003 }; 2004 2005 /* qmp_block_set_io_throttle has separate parameters for the 2006 * (deprecated) block device name and the qdev ID but the HMP 2007 * version has only one, so we must decide which one to pass. */ 2008 if (blk_by_name(device)) { 2009 throttle.has_device = true; 2010 throttle.device = device; 2011 } else { 2012 throttle.has_id = true; 2013 throttle.id = device; 2014 } 2015 2016 qmp_block_set_io_throttle(&throttle, &err); 2017 hmp_handle_error(mon, &err); 2018 } 2019 2020 void hmp_block_stream(Monitor *mon, const QDict *qdict) 2021 { 2022 Error *error = NULL; 2023 const char *device = qdict_get_str(qdict, "device"); 2024 const char *base = qdict_get_try_str(qdict, "base"); 2025 int64_t speed = qdict_get_try_int(qdict, "speed", 0); 2026 2027 qmp_block_stream(true, device, device, base != NULL, base, false, NULL, 2028 false, NULL, qdict_haskey(qdict, "speed"), speed, true, 2029 BLOCKDEV_ON_ERROR_REPORT, false, false, false, false, 2030 &error); 2031 2032 hmp_handle_error(mon, &error); 2033 } 2034 2035 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict) 2036 { 2037 Error *error = NULL; 2038 const char *device = qdict_get_str(qdict, "device"); 2039 int64_t value = qdict_get_int(qdict, "speed"); 2040 2041 qmp_block_job_set_speed(device, value, &error); 2042 2043 hmp_handle_error(mon, &error); 2044 } 2045 2046 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict) 2047 { 2048 Error *error = NULL; 2049 const char *device = qdict_get_str(qdict, "device"); 2050 bool force = qdict_get_try_bool(qdict, "force", false); 2051 2052 qmp_block_job_cancel(device, true, force, &error); 2053 2054 hmp_handle_error(mon, &error); 2055 } 2056 2057 void hmp_block_job_pause(Monitor *mon, const QDict *qdict) 2058 { 2059 Error *error = NULL; 2060 const char *device = qdict_get_str(qdict, "device"); 2061 2062 qmp_block_job_pause(device, &error); 2063 2064 hmp_handle_error(mon, &error); 2065 } 2066 2067 void hmp_block_job_resume(Monitor *mon, const QDict *qdict) 2068 { 2069 Error *error = NULL; 2070 const char *device = qdict_get_str(qdict, "device"); 2071 2072 qmp_block_job_resume(device, &error); 2073 2074 hmp_handle_error(mon, &error); 2075 } 2076 2077 void hmp_block_job_complete(Monitor *mon, const QDict *qdict) 2078 { 2079 Error *error = NULL; 2080 const char *device = qdict_get_str(qdict, "device"); 2081 2082 qmp_block_job_complete(device, &error); 2083 2084 hmp_handle_error(mon, &error); 2085 } 2086 2087 typedef struct HMPMigrationStatus 2088 { 2089 QEMUTimer *timer; 2090 Monitor *mon; 2091 bool is_block_migration; 2092 } HMPMigrationStatus; 2093 2094 static void hmp_migrate_status_cb(void *opaque) 2095 { 2096 HMPMigrationStatus *status = opaque; 2097 MigrationInfo *info; 2098 2099 info = qmp_query_migrate(NULL); 2100 if (!info->has_status || info->status == MIGRATION_STATUS_ACTIVE || 2101 info->status == MIGRATION_STATUS_SETUP) { 2102 if (info->has_disk) { 2103 int progress; 2104 2105 if (info->disk->remaining) { 2106 progress = info->disk->transferred * 100 / info->disk->total; 2107 } else { 2108 progress = 100; 2109 } 2110 2111 monitor_printf(status->mon, "Completed %d %%\r", progress); 2112 monitor_flush(status->mon); 2113 } 2114 2115 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000); 2116 } else { 2117 if (status->is_block_migration) { 2118 monitor_printf(status->mon, "\n"); 2119 } 2120 if (info->has_error_desc) { 2121 error_report("%s", info->error_desc); 2122 } 2123 monitor_resume(status->mon); 2124 timer_del(status->timer); 2125 timer_free(status->timer); 2126 g_free(status); 2127 } 2128 2129 qapi_free_MigrationInfo(info); 2130 } 2131 2132 void hmp_migrate(Monitor *mon, const QDict *qdict) 2133 { 2134 bool detach = qdict_get_try_bool(qdict, "detach", false); 2135 bool blk = qdict_get_try_bool(qdict, "blk", false); 2136 bool inc = qdict_get_try_bool(qdict, "inc", false); 2137 bool resume = qdict_get_try_bool(qdict, "resume", false); 2138 const char *uri = qdict_get_str(qdict, "uri"); 2139 Error *err = NULL; 2140 2141 qmp_migrate(uri, !!blk, blk, !!inc, inc, 2142 false, false, true, resume, &err); 2143 if (err) { 2144 hmp_handle_error(mon, &err); 2145 return; 2146 } 2147 2148 if (!detach) { 2149 HMPMigrationStatus *status; 2150 2151 if (monitor_suspend(mon) < 0) { 2152 monitor_printf(mon, "terminal does not allow synchronous " 2153 "migration, continuing detached\n"); 2154 return; 2155 } 2156 2157 status = g_malloc0(sizeof(*status)); 2158 status->mon = mon; 2159 status->is_block_migration = blk || inc; 2160 status->timer = timer_new_ms(QEMU_CLOCK_REALTIME, hmp_migrate_status_cb, 2161 status); 2162 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME)); 2163 } 2164 } 2165 2166 void hmp_device_add(Monitor *mon, const QDict *qdict) 2167 { 2168 Error *err = NULL; 2169 2170 qmp_device_add((QDict *)qdict, NULL, &err); 2171 hmp_handle_error(mon, &err); 2172 } 2173 2174 void hmp_device_del(Monitor *mon, const QDict *qdict) 2175 { 2176 const char *id = qdict_get_str(qdict, "id"); 2177 Error *err = NULL; 2178 2179 qmp_device_del(id, &err); 2180 hmp_handle_error(mon, &err); 2181 } 2182 2183 void hmp_dump_guest_memory(Monitor *mon, const QDict *qdict) 2184 { 2185 Error *err = NULL; 2186 bool win_dmp = qdict_get_try_bool(qdict, "windmp", false); 2187 bool paging = qdict_get_try_bool(qdict, "paging", false); 2188 bool zlib = qdict_get_try_bool(qdict, "zlib", false); 2189 bool lzo = qdict_get_try_bool(qdict, "lzo", false); 2190 bool snappy = qdict_get_try_bool(qdict, "snappy", false); 2191 const char *file = qdict_get_str(qdict, "filename"); 2192 bool has_begin = qdict_haskey(qdict, "begin"); 2193 bool has_length = qdict_haskey(qdict, "length"); 2194 bool has_detach = qdict_haskey(qdict, "detach"); 2195 int64_t begin = 0; 2196 int64_t length = 0; 2197 bool detach = false; 2198 enum DumpGuestMemoryFormat dump_format = DUMP_GUEST_MEMORY_FORMAT_ELF; 2199 char *prot; 2200 2201 if (zlib + lzo + snappy + win_dmp > 1) { 2202 error_setg(&err, "only one of '-z|-l|-s|-w' can be set"); 2203 hmp_handle_error(mon, &err); 2204 return; 2205 } 2206 2207 if (win_dmp) { 2208 dump_format = DUMP_GUEST_MEMORY_FORMAT_WIN_DMP; 2209 } 2210 2211 if (zlib) { 2212 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB; 2213 } 2214 2215 if (lzo) { 2216 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO; 2217 } 2218 2219 if (snappy) { 2220 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY; 2221 } 2222 2223 if (has_begin) { 2224 begin = qdict_get_int(qdict, "begin"); 2225 } 2226 if (has_length) { 2227 length = qdict_get_int(qdict, "length"); 2228 } 2229 if (has_detach) { 2230 detach = qdict_get_bool(qdict, "detach"); 2231 } 2232 2233 prot = g_strconcat("file:", file, NULL); 2234 2235 qmp_dump_guest_memory(paging, prot, true, detach, has_begin, begin, 2236 has_length, length, true, dump_format, &err); 2237 hmp_handle_error(mon, &err); 2238 g_free(prot); 2239 } 2240 2241 void hmp_netdev_add(Monitor *mon, const QDict *qdict) 2242 { 2243 Error *err = NULL; 2244 QemuOpts *opts; 2245 2246 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &err); 2247 if (err) { 2248 goto out; 2249 } 2250 2251 netdev_add(opts, &err); 2252 if (err) { 2253 qemu_opts_del(opts); 2254 } 2255 2256 out: 2257 hmp_handle_error(mon, &err); 2258 } 2259 2260 void hmp_netdev_del(Monitor *mon, const QDict *qdict) 2261 { 2262 const char *id = qdict_get_str(qdict, "id"); 2263 Error *err = NULL; 2264 2265 qmp_netdev_del(id, &err); 2266 hmp_handle_error(mon, &err); 2267 } 2268 2269 void hmp_object_add(Monitor *mon, const QDict *qdict) 2270 { 2271 Error *err = NULL; 2272 QemuOpts *opts; 2273 Object *obj = NULL; 2274 2275 opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err); 2276 if (err) { 2277 hmp_handle_error(mon, &err); 2278 return; 2279 } 2280 2281 obj = user_creatable_add_opts(opts, &err); 2282 qemu_opts_del(opts); 2283 2284 if (err) { 2285 hmp_handle_error(mon, &err); 2286 } 2287 if (obj) { 2288 object_unref(obj); 2289 } 2290 } 2291 2292 void hmp_getfd(Monitor *mon, const QDict *qdict) 2293 { 2294 const char *fdname = qdict_get_str(qdict, "fdname"); 2295 Error *err = NULL; 2296 2297 qmp_getfd(fdname, &err); 2298 hmp_handle_error(mon, &err); 2299 } 2300 2301 void hmp_closefd(Monitor *mon, const QDict *qdict) 2302 { 2303 const char *fdname = qdict_get_str(qdict, "fdname"); 2304 Error *err = NULL; 2305 2306 qmp_closefd(fdname, &err); 2307 hmp_handle_error(mon, &err); 2308 } 2309 2310 void hmp_sendkey(Monitor *mon, const QDict *qdict) 2311 { 2312 const char *keys = qdict_get_str(qdict, "keys"); 2313 KeyValueList *keylist, *head = NULL, *tmp = NULL; 2314 int has_hold_time = qdict_haskey(qdict, "hold-time"); 2315 int hold_time = qdict_get_try_int(qdict, "hold-time", -1); 2316 Error *err = NULL; 2317 const char *separator; 2318 int keyname_len; 2319 2320 while (1) { 2321 separator = qemu_strchrnul(keys, '-'); 2322 keyname_len = separator - keys; 2323 2324 /* Be compatible with old interface, convert user inputted "<" */ 2325 if (keys[0] == '<' && keyname_len == 1) { 2326 keys = "less"; 2327 keyname_len = 4; 2328 } 2329 2330 keylist = g_malloc0(sizeof(*keylist)); 2331 keylist->value = g_malloc0(sizeof(*keylist->value)); 2332 2333 if (!head) { 2334 head = keylist; 2335 } 2336 if (tmp) { 2337 tmp->next = keylist; 2338 } 2339 tmp = keylist; 2340 2341 if (strstart(keys, "0x", NULL)) { 2342 char *endp; 2343 int value = strtoul(keys, &endp, 0); 2344 assert(endp <= keys + keyname_len); 2345 if (endp != keys + keyname_len) { 2346 goto err_out; 2347 } 2348 keylist->value->type = KEY_VALUE_KIND_NUMBER; 2349 keylist->value->u.number.data = value; 2350 } else { 2351 int idx = index_from_key(keys, keyname_len); 2352 if (idx == Q_KEY_CODE__MAX) { 2353 goto err_out; 2354 } 2355 keylist->value->type = KEY_VALUE_KIND_QCODE; 2356 keylist->value->u.qcode.data = idx; 2357 } 2358 2359 if (!*separator) { 2360 break; 2361 } 2362 keys = separator + 1; 2363 } 2364 2365 qmp_send_key(head, has_hold_time, hold_time, &err); 2366 hmp_handle_error(mon, &err); 2367 2368 out: 2369 qapi_free_KeyValueList(head); 2370 return; 2371 2372 err_out: 2373 monitor_printf(mon, "invalid parameter: %.*s\n", keyname_len, keys); 2374 goto out; 2375 } 2376 2377 void hmp_screendump(Monitor *mon, const QDict *qdict) 2378 { 2379 const char *filename = qdict_get_str(qdict, "filename"); 2380 const char *id = qdict_get_try_str(qdict, "device"); 2381 int64_t head = qdict_get_try_int(qdict, "head", 0); 2382 Error *err = NULL; 2383 2384 qmp_screendump(filename, id != NULL, id, id != NULL, head, &err); 2385 hmp_handle_error(mon, &err); 2386 } 2387 2388 void hmp_nbd_server_start(Monitor *mon, const QDict *qdict) 2389 { 2390 const char *uri = qdict_get_str(qdict, "uri"); 2391 bool writable = qdict_get_try_bool(qdict, "writable", false); 2392 bool all = qdict_get_try_bool(qdict, "all", false); 2393 Error *local_err = NULL; 2394 BlockInfoList *block_list, *info; 2395 SocketAddress *addr; 2396 2397 if (writable && !all) { 2398 error_setg(&local_err, "-w only valid together with -a"); 2399 goto exit; 2400 } 2401 2402 /* First check if the address is valid and start the server. */ 2403 addr = socket_parse(uri, &local_err); 2404 if (local_err != NULL) { 2405 goto exit; 2406 } 2407 2408 nbd_server_start(addr, NULL, NULL, &local_err); 2409 qapi_free_SocketAddress(addr); 2410 if (local_err != NULL) { 2411 goto exit; 2412 } 2413 2414 if (!all) { 2415 return; 2416 } 2417 2418 /* Then try adding all block devices. If one fails, close all and 2419 * exit. 2420 */ 2421 block_list = qmp_query_block(NULL); 2422 2423 for (info = block_list; info; info = info->next) { 2424 if (!info->value->has_inserted) { 2425 continue; 2426 } 2427 2428 qmp_nbd_server_add(info->value->device, false, NULL, 2429 true, writable, false, NULL, &local_err); 2430 2431 if (local_err != NULL) { 2432 qmp_nbd_server_stop(NULL); 2433 break; 2434 } 2435 } 2436 2437 qapi_free_BlockInfoList(block_list); 2438 2439 exit: 2440 hmp_handle_error(mon, &local_err); 2441 } 2442 2443 void hmp_nbd_server_add(Monitor *mon, const QDict *qdict) 2444 { 2445 const char *device = qdict_get_str(qdict, "device"); 2446 const char *name = qdict_get_try_str(qdict, "name"); 2447 bool writable = qdict_get_try_bool(qdict, "writable", false); 2448 Error *local_err = NULL; 2449 2450 qmp_nbd_server_add(device, !!name, name, true, writable, 2451 false, NULL, &local_err); 2452 hmp_handle_error(mon, &local_err); 2453 } 2454 2455 void hmp_nbd_server_remove(Monitor *mon, const QDict *qdict) 2456 { 2457 const char *name = qdict_get_str(qdict, "name"); 2458 bool force = qdict_get_try_bool(qdict, "force", false); 2459 Error *err = NULL; 2460 2461 /* Rely on NBD_SERVER_REMOVE_MODE_SAFE being the default */ 2462 qmp_nbd_server_remove(name, force, NBD_SERVER_REMOVE_MODE_HARD, &err); 2463 hmp_handle_error(mon, &err); 2464 } 2465 2466 void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict) 2467 { 2468 Error *err = NULL; 2469 2470 qmp_nbd_server_stop(&err); 2471 hmp_handle_error(mon, &err); 2472 } 2473 2474 void hmp_cpu_add(Monitor *mon, const QDict *qdict) 2475 { 2476 int cpuid; 2477 Error *err = NULL; 2478 2479 error_report("cpu_add is deprecated, please use device_add instead"); 2480 2481 cpuid = qdict_get_int(qdict, "id"); 2482 qmp_cpu_add(cpuid, &err); 2483 hmp_handle_error(mon, &err); 2484 } 2485 2486 void hmp_chardev_add(Monitor *mon, const QDict *qdict) 2487 { 2488 const char *args = qdict_get_str(qdict, "args"); 2489 Error *err = NULL; 2490 QemuOpts *opts; 2491 2492 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args, true); 2493 if (opts == NULL) { 2494 error_setg(&err, "Parsing chardev args failed"); 2495 } else { 2496 qemu_chr_new_from_opts(opts, NULL, &err); 2497 qemu_opts_del(opts); 2498 } 2499 hmp_handle_error(mon, &err); 2500 } 2501 2502 void hmp_chardev_change(Monitor *mon, const QDict *qdict) 2503 { 2504 const char *args = qdict_get_str(qdict, "args"); 2505 const char *id; 2506 Error *err = NULL; 2507 ChardevBackend *backend = NULL; 2508 ChardevReturn *ret = NULL; 2509 QemuOpts *opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args, 2510 true); 2511 if (!opts) { 2512 error_setg(&err, "Parsing chardev args failed"); 2513 goto end; 2514 } 2515 2516 id = qdict_get_str(qdict, "id"); 2517 if (qemu_opts_id(opts)) { 2518 error_setg(&err, "Unexpected 'id' parameter"); 2519 goto end; 2520 } 2521 2522 backend = qemu_chr_parse_opts(opts, &err); 2523 if (!backend) { 2524 goto end; 2525 } 2526 2527 ret = qmp_chardev_change(id, backend, &err); 2528 2529 end: 2530 qapi_free_ChardevReturn(ret); 2531 qapi_free_ChardevBackend(backend); 2532 qemu_opts_del(opts); 2533 hmp_handle_error(mon, &err); 2534 } 2535 2536 void hmp_chardev_remove(Monitor *mon, const QDict *qdict) 2537 { 2538 Error *local_err = NULL; 2539 2540 qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err); 2541 hmp_handle_error(mon, &local_err); 2542 } 2543 2544 void hmp_chardev_send_break(Monitor *mon, const QDict *qdict) 2545 { 2546 Error *local_err = NULL; 2547 2548 qmp_chardev_send_break(qdict_get_str(qdict, "id"), &local_err); 2549 hmp_handle_error(mon, &local_err); 2550 } 2551 2552 void hmp_qemu_io(Monitor *mon, const QDict *qdict) 2553 { 2554 BlockBackend *blk; 2555 BlockBackend *local_blk = NULL; 2556 const char* device = qdict_get_str(qdict, "device"); 2557 const char* command = qdict_get_str(qdict, "command"); 2558 Error *err = NULL; 2559 int ret; 2560 2561 blk = blk_by_name(device); 2562 if (!blk) { 2563 BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err); 2564 if (bs) { 2565 blk = local_blk = blk_new(bdrv_get_aio_context(bs), 2566 0, BLK_PERM_ALL); 2567 ret = blk_insert_bs(blk, bs, &err); 2568 if (ret < 0) { 2569 goto fail; 2570 } 2571 } else { 2572 goto fail; 2573 } 2574 } 2575 2576 /* 2577 * Notably absent: Proper permission management. This is sad, but it seems 2578 * almost impossible to achieve without changing the semantics and thereby 2579 * limiting the use cases of the qemu-io HMP command. 2580 * 2581 * In an ideal world we would unconditionally create a new BlockBackend for 2582 * qemuio_command(), but we have commands like 'reopen' and want them to 2583 * take effect on the exact BlockBackend whose name the user passed instead 2584 * of just on a temporary copy of it. 2585 * 2586 * Another problem is that deleting the temporary BlockBackend involves 2587 * draining all requests on it first, but some qemu-iotests cases want to 2588 * issue multiple aio_read/write requests and expect them to complete in 2589 * the background while the monitor has already returned. 2590 * 2591 * This is also what prevents us from saving the original permissions and 2592 * restoring them later: We can't revoke permissions until all requests 2593 * have completed, and we don't know when that is nor can we really let 2594 * anything else run before we have revoken them to avoid race conditions. 2595 * 2596 * What happens now is that command() in qemu-io-cmds.c can extend the 2597 * permissions if necessary for the qemu-io command. And they simply stay 2598 * extended, possibly resulting in a read-only guest device keeping write 2599 * permissions. Ugly, but it appears to be the lesser evil. 2600 */ 2601 qemuio_command(blk, command); 2602 2603 fail: 2604 blk_unref(local_blk); 2605 hmp_handle_error(mon, &err); 2606 } 2607 2608 void hmp_object_del(Monitor *mon, const QDict *qdict) 2609 { 2610 const char *id = qdict_get_str(qdict, "id"); 2611 Error *err = NULL; 2612 2613 user_creatable_del(id, &err); 2614 hmp_handle_error(mon, &err); 2615 } 2616 2617 void hmp_info_memdev(Monitor *mon, const QDict *qdict) 2618 { 2619 Error *err = NULL; 2620 MemdevList *memdev_list = qmp_query_memdev(&err); 2621 MemdevList *m = memdev_list; 2622 Visitor *v; 2623 char *str; 2624 2625 while (m) { 2626 v = string_output_visitor_new(false, &str); 2627 visit_type_uint16List(v, NULL, &m->value->host_nodes, NULL); 2628 monitor_printf(mon, "memory backend: %s\n", m->value->id); 2629 monitor_printf(mon, " size: %" PRId64 "\n", m->value->size); 2630 monitor_printf(mon, " merge: %s\n", 2631 m->value->merge ? "true" : "false"); 2632 monitor_printf(mon, " dump: %s\n", 2633 m->value->dump ? "true" : "false"); 2634 monitor_printf(mon, " prealloc: %s\n", 2635 m->value->prealloc ? "true" : "false"); 2636 monitor_printf(mon, " policy: %s\n", 2637 HostMemPolicy_str(m->value->policy)); 2638 visit_complete(v, &str); 2639 monitor_printf(mon, " host nodes: %s\n", str); 2640 2641 g_free(str); 2642 visit_free(v); 2643 m = m->next; 2644 } 2645 2646 monitor_printf(mon, "\n"); 2647 2648 qapi_free_MemdevList(memdev_list); 2649 hmp_handle_error(mon, &err); 2650 } 2651 2652 void hmp_info_memory_devices(Monitor *mon, const QDict *qdict) 2653 { 2654 Error *err = NULL; 2655 MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err); 2656 MemoryDeviceInfoList *info; 2657 MemoryDeviceInfo *value; 2658 PCDIMMDeviceInfo *di; 2659 2660 for (info = info_list; info; info = info->next) { 2661 value = info->value; 2662 2663 if (value) { 2664 switch (value->type) { 2665 case MEMORY_DEVICE_INFO_KIND_DIMM: 2666 di = value->u.dimm.data; 2667 break; 2668 2669 case MEMORY_DEVICE_INFO_KIND_NVDIMM: 2670 di = value->u.nvdimm.data; 2671 break; 2672 2673 default: 2674 di = NULL; 2675 break; 2676 } 2677 2678 if (di) { 2679 monitor_printf(mon, "Memory device [%s]: \"%s\"\n", 2680 MemoryDeviceInfoKind_str(value->type), 2681 di->id ? di->id : ""); 2682 monitor_printf(mon, " addr: 0x%" PRIx64 "\n", di->addr); 2683 monitor_printf(mon, " slot: %" PRId64 "\n", di->slot); 2684 monitor_printf(mon, " node: %" PRId64 "\n", di->node); 2685 monitor_printf(mon, " size: %" PRIu64 "\n", di->size); 2686 monitor_printf(mon, " memdev: %s\n", di->memdev); 2687 monitor_printf(mon, " hotplugged: %s\n", 2688 di->hotplugged ? "true" : "false"); 2689 monitor_printf(mon, " hotpluggable: %s\n", 2690 di->hotpluggable ? "true" : "false"); 2691 } 2692 } 2693 } 2694 2695 qapi_free_MemoryDeviceInfoList(info_list); 2696 hmp_handle_error(mon, &err); 2697 } 2698 2699 void hmp_info_iothreads(Monitor *mon, const QDict *qdict) 2700 { 2701 IOThreadInfoList *info_list = qmp_query_iothreads(NULL); 2702 IOThreadInfoList *info; 2703 IOThreadInfo *value; 2704 2705 for (info = info_list; info; info = info->next) { 2706 value = info->value; 2707 monitor_printf(mon, "%s:\n", value->id); 2708 monitor_printf(mon, " thread_id=%" PRId64 "\n", value->thread_id); 2709 monitor_printf(mon, " poll-max-ns=%" PRId64 "\n", value->poll_max_ns); 2710 monitor_printf(mon, " poll-grow=%" PRId64 "\n", value->poll_grow); 2711 monitor_printf(mon, " poll-shrink=%" PRId64 "\n", value->poll_shrink); 2712 } 2713 2714 qapi_free_IOThreadInfoList(info_list); 2715 } 2716 2717 void hmp_qom_list(Monitor *mon, const QDict *qdict) 2718 { 2719 const char *path = qdict_get_try_str(qdict, "path"); 2720 ObjectPropertyInfoList *list; 2721 Error *err = NULL; 2722 2723 if (path == NULL) { 2724 monitor_printf(mon, "/\n"); 2725 return; 2726 } 2727 2728 list = qmp_qom_list(path, &err); 2729 if (err == NULL) { 2730 ObjectPropertyInfoList *start = list; 2731 while (list != NULL) { 2732 ObjectPropertyInfo *value = list->value; 2733 2734 monitor_printf(mon, "%s (%s)\n", 2735 value->name, value->type); 2736 list = list->next; 2737 } 2738 qapi_free_ObjectPropertyInfoList(start); 2739 } 2740 hmp_handle_error(mon, &err); 2741 } 2742 2743 void hmp_qom_set(Monitor *mon, const QDict *qdict) 2744 { 2745 const char *path = qdict_get_str(qdict, "path"); 2746 const char *property = qdict_get_str(qdict, "property"); 2747 const char *value = qdict_get_str(qdict, "value"); 2748 Error *err = NULL; 2749 bool ambiguous = false; 2750 Object *obj; 2751 2752 obj = object_resolve_path(path, &ambiguous); 2753 if (obj == NULL) { 2754 error_set(&err, ERROR_CLASS_DEVICE_NOT_FOUND, 2755 "Device '%s' not found", path); 2756 } else { 2757 if (ambiguous) { 2758 monitor_printf(mon, "Warning: Path '%s' is ambiguous\n", path); 2759 } 2760 object_property_parse(obj, value, property, &err); 2761 } 2762 hmp_handle_error(mon, &err); 2763 } 2764 2765 void hmp_rocker(Monitor *mon, const QDict *qdict) 2766 { 2767 const char *name = qdict_get_str(qdict, "name"); 2768 RockerSwitch *rocker; 2769 Error *err = NULL; 2770 2771 rocker = qmp_query_rocker(name, &err); 2772 if (err != NULL) { 2773 hmp_handle_error(mon, &err); 2774 return; 2775 } 2776 2777 monitor_printf(mon, "name: %s\n", rocker->name); 2778 monitor_printf(mon, "id: 0x%" PRIx64 "\n", rocker->id); 2779 monitor_printf(mon, "ports: %d\n", rocker->ports); 2780 2781 qapi_free_RockerSwitch(rocker); 2782 } 2783 2784 void hmp_rocker_ports(Monitor *mon, const QDict *qdict) 2785 { 2786 RockerPortList *list, *port; 2787 const char *name = qdict_get_str(qdict, "name"); 2788 Error *err = NULL; 2789 2790 list = qmp_query_rocker_ports(name, &err); 2791 if (err != NULL) { 2792 hmp_handle_error(mon, &err); 2793 return; 2794 } 2795 2796 monitor_printf(mon, " ena/ speed/ auto\n"); 2797 monitor_printf(mon, " port link duplex neg?\n"); 2798 2799 for (port = list; port; port = port->next) { 2800 monitor_printf(mon, "%10s %-4s %-3s %2s %-3s\n", 2801 port->value->name, 2802 port->value->enabled ? port->value->link_up ? 2803 "up" : "down" : "!ena", 2804 port->value->speed == 10000 ? "10G" : "??", 2805 port->value->duplex ? "FD" : "HD", 2806 port->value->autoneg ? "Yes" : "No"); 2807 } 2808 2809 qapi_free_RockerPortList(list); 2810 } 2811 2812 void hmp_rocker_of_dpa_flows(Monitor *mon, const QDict *qdict) 2813 { 2814 RockerOfDpaFlowList *list, *info; 2815 const char *name = qdict_get_str(qdict, "name"); 2816 uint32_t tbl_id = qdict_get_try_int(qdict, "tbl_id", -1); 2817 Error *err = NULL; 2818 2819 list = qmp_query_rocker_of_dpa_flows(name, tbl_id != -1, tbl_id, &err); 2820 if (err != NULL) { 2821 hmp_handle_error(mon, &err); 2822 return; 2823 } 2824 2825 monitor_printf(mon, "prio tbl hits key(mask) --> actions\n"); 2826 2827 for (info = list; info; info = info->next) { 2828 RockerOfDpaFlow *flow = info->value; 2829 RockerOfDpaFlowKey *key = flow->key; 2830 RockerOfDpaFlowMask *mask = flow->mask; 2831 RockerOfDpaFlowAction *action = flow->action; 2832 2833 if (flow->hits) { 2834 monitor_printf(mon, "%-4d %-3d %-4" PRIu64, 2835 key->priority, key->tbl_id, flow->hits); 2836 } else { 2837 monitor_printf(mon, "%-4d %-3d ", 2838 key->priority, key->tbl_id); 2839 } 2840 2841 if (key->has_in_pport) { 2842 monitor_printf(mon, " pport %d", key->in_pport); 2843 if (mask->has_in_pport) { 2844 monitor_printf(mon, "(0x%x)", mask->in_pport); 2845 } 2846 } 2847 2848 if (key->has_vlan_id) { 2849 monitor_printf(mon, " vlan %d", 2850 key->vlan_id & VLAN_VID_MASK); 2851 if (mask->has_vlan_id) { 2852 monitor_printf(mon, "(0x%x)", mask->vlan_id); 2853 } 2854 } 2855 2856 if (key->has_tunnel_id) { 2857 monitor_printf(mon, " tunnel %d", key->tunnel_id); 2858 if (mask->has_tunnel_id) { 2859 monitor_printf(mon, "(0x%x)", mask->tunnel_id); 2860 } 2861 } 2862 2863 if (key->has_eth_type) { 2864 switch (key->eth_type) { 2865 case 0x0806: 2866 monitor_printf(mon, " ARP"); 2867 break; 2868 case 0x0800: 2869 monitor_printf(mon, " IP"); 2870 break; 2871 case 0x86dd: 2872 monitor_printf(mon, " IPv6"); 2873 break; 2874 case 0x8809: 2875 monitor_printf(mon, " LACP"); 2876 break; 2877 case 0x88cc: 2878 monitor_printf(mon, " LLDP"); 2879 break; 2880 default: 2881 monitor_printf(mon, " eth type 0x%04x", key->eth_type); 2882 break; 2883 } 2884 } 2885 2886 if (key->has_eth_src) { 2887 if ((strcmp(key->eth_src, "01:00:00:00:00:00") == 0) && 2888 (mask->has_eth_src) && 2889 (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) { 2890 monitor_printf(mon, " src <any mcast/bcast>"); 2891 } else if ((strcmp(key->eth_src, "00:00:00:00:00:00") == 0) && 2892 (mask->has_eth_src) && 2893 (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) { 2894 monitor_printf(mon, " src <any ucast>"); 2895 } else { 2896 monitor_printf(mon, " src %s", key->eth_src); 2897 if (mask->has_eth_src) { 2898 monitor_printf(mon, "(%s)", mask->eth_src); 2899 } 2900 } 2901 } 2902 2903 if (key->has_eth_dst) { 2904 if ((strcmp(key->eth_dst, "01:00:00:00:00:00") == 0) && 2905 (mask->has_eth_dst) && 2906 (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) { 2907 monitor_printf(mon, " dst <any mcast/bcast>"); 2908 } else if ((strcmp(key->eth_dst, "00:00:00:00:00:00") == 0) && 2909 (mask->has_eth_dst) && 2910 (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) { 2911 monitor_printf(mon, " dst <any ucast>"); 2912 } else { 2913 monitor_printf(mon, " dst %s", key->eth_dst); 2914 if (mask->has_eth_dst) { 2915 monitor_printf(mon, "(%s)", mask->eth_dst); 2916 } 2917 } 2918 } 2919 2920 if (key->has_ip_proto) { 2921 monitor_printf(mon, " proto %d", key->ip_proto); 2922 if (mask->has_ip_proto) { 2923 monitor_printf(mon, "(0x%x)", mask->ip_proto); 2924 } 2925 } 2926 2927 if (key->has_ip_tos) { 2928 monitor_printf(mon, " TOS %d", key->ip_tos); 2929 if (mask->has_ip_tos) { 2930 monitor_printf(mon, "(0x%x)", mask->ip_tos); 2931 } 2932 } 2933 2934 if (key->has_ip_dst) { 2935 monitor_printf(mon, " dst %s", key->ip_dst); 2936 } 2937 2938 if (action->has_goto_tbl || action->has_group_id || 2939 action->has_new_vlan_id) { 2940 monitor_printf(mon, " -->"); 2941 } 2942 2943 if (action->has_new_vlan_id) { 2944 monitor_printf(mon, " apply new vlan %d", 2945 ntohs(action->new_vlan_id)); 2946 } 2947 2948 if (action->has_group_id) { 2949 monitor_printf(mon, " write group 0x%08x", action->group_id); 2950 } 2951 2952 if (action->has_goto_tbl) { 2953 monitor_printf(mon, " goto tbl %d", action->goto_tbl); 2954 } 2955 2956 monitor_printf(mon, "\n"); 2957 } 2958 2959 qapi_free_RockerOfDpaFlowList(list); 2960 } 2961 2962 void hmp_rocker_of_dpa_groups(Monitor *mon, const QDict *qdict) 2963 { 2964 RockerOfDpaGroupList *list, *g; 2965 const char *name = qdict_get_str(qdict, "name"); 2966 uint8_t type = qdict_get_try_int(qdict, "type", 9); 2967 Error *err = NULL; 2968 bool set = false; 2969 2970 list = qmp_query_rocker_of_dpa_groups(name, type != 9, type, &err); 2971 if (err != NULL) { 2972 hmp_handle_error(mon, &err); 2973 return; 2974 } 2975 2976 monitor_printf(mon, "id (decode) --> buckets\n"); 2977 2978 for (g = list; g; g = g->next) { 2979 RockerOfDpaGroup *group = g->value; 2980 2981 monitor_printf(mon, "0x%08x", group->id); 2982 2983 monitor_printf(mon, " (type %s", group->type == 0 ? "L2 interface" : 2984 group->type == 1 ? "L2 rewrite" : 2985 group->type == 2 ? "L3 unicast" : 2986 group->type == 3 ? "L2 multicast" : 2987 group->type == 4 ? "L2 flood" : 2988 group->type == 5 ? "L3 interface" : 2989 group->type == 6 ? "L3 multicast" : 2990 group->type == 7 ? "L3 ECMP" : 2991 group->type == 8 ? "L2 overlay" : 2992 "unknown"); 2993 2994 if (group->has_vlan_id) { 2995 monitor_printf(mon, " vlan %d", group->vlan_id); 2996 } 2997 2998 if (group->has_pport) { 2999 monitor_printf(mon, " pport %d", group->pport); 3000 } 3001 3002 if (group->has_index) { 3003 monitor_printf(mon, " index %d", group->index); 3004 } 3005 3006 monitor_printf(mon, ") -->"); 3007 3008 if (group->has_set_vlan_id && group->set_vlan_id) { 3009 set = true; 3010 monitor_printf(mon, " set vlan %d", 3011 group->set_vlan_id & VLAN_VID_MASK); 3012 } 3013 3014 if (group->has_set_eth_src) { 3015 if (!set) { 3016 set = true; 3017 monitor_printf(mon, " set"); 3018 } 3019 monitor_printf(mon, " src %s", group->set_eth_src); 3020 } 3021 3022 if (group->has_set_eth_dst) { 3023 if (!set) { 3024 set = true; 3025 monitor_printf(mon, " set"); 3026 } 3027 monitor_printf(mon, " dst %s", group->set_eth_dst); 3028 } 3029 3030 set = false; 3031 3032 if (group->has_ttl_check && group->ttl_check) { 3033 monitor_printf(mon, " check TTL"); 3034 } 3035 3036 if (group->has_group_id && group->group_id) { 3037 monitor_printf(mon, " group id 0x%08x", group->group_id); 3038 } 3039 3040 if (group->has_pop_vlan && group->pop_vlan) { 3041 monitor_printf(mon, " pop vlan"); 3042 } 3043 3044 if (group->has_out_pport) { 3045 monitor_printf(mon, " out pport %d", group->out_pport); 3046 } 3047 3048 if (group->has_group_ids) { 3049 struct uint32List *id; 3050 3051 monitor_printf(mon, " groups ["); 3052 for (id = group->group_ids; id; id = id->next) { 3053 monitor_printf(mon, "0x%08x", id->value); 3054 if (id->next) { 3055 monitor_printf(mon, ","); 3056 } 3057 } 3058 monitor_printf(mon, "]"); 3059 } 3060 3061 monitor_printf(mon, "\n"); 3062 } 3063 3064 qapi_free_RockerOfDpaGroupList(list); 3065 } 3066 3067 void hmp_info_dump(Monitor *mon, const QDict *qdict) 3068 { 3069 DumpQueryResult *result = qmp_query_dump(NULL); 3070 3071 assert(result && result->status < DUMP_STATUS__MAX); 3072 monitor_printf(mon, "Status: %s\n", DumpStatus_str(result->status)); 3073 3074 if (result->status == DUMP_STATUS_ACTIVE) { 3075 float percent = 0; 3076 assert(result->total != 0); 3077 percent = 100.0 * result->completed / result->total; 3078 monitor_printf(mon, "Finished: %.2f %%\n", percent); 3079 } 3080 3081 qapi_free_DumpQueryResult(result); 3082 } 3083 3084 void hmp_info_ramblock(Monitor *mon, const QDict *qdict) 3085 { 3086 ram_block_dump(mon); 3087 } 3088 3089 void hmp_hotpluggable_cpus(Monitor *mon, const QDict *qdict) 3090 { 3091 Error *err = NULL; 3092 HotpluggableCPUList *l = qmp_query_hotpluggable_cpus(&err); 3093 HotpluggableCPUList *saved = l; 3094 CpuInstanceProperties *c; 3095 3096 if (err != NULL) { 3097 hmp_handle_error(mon, &err); 3098 return; 3099 } 3100 3101 monitor_printf(mon, "Hotpluggable CPUs:\n"); 3102 while (l) { 3103 monitor_printf(mon, " type: \"%s\"\n", l->value->type); 3104 monitor_printf(mon, " vcpus_count: \"%" PRIu64 "\"\n", 3105 l->value->vcpus_count); 3106 if (l->value->has_qom_path) { 3107 monitor_printf(mon, " qom_path: \"%s\"\n", l->value->qom_path); 3108 } 3109 3110 c = l->value->props; 3111 monitor_printf(mon, " CPUInstance Properties:\n"); 3112 if (c->has_node_id) { 3113 monitor_printf(mon, " node-id: \"%" PRIu64 "\"\n", c->node_id); 3114 } 3115 if (c->has_socket_id) { 3116 monitor_printf(mon, " socket-id: \"%" PRIu64 "\"\n", c->socket_id); 3117 } 3118 if (c->has_core_id) { 3119 monitor_printf(mon, " core-id: \"%" PRIu64 "\"\n", c->core_id); 3120 } 3121 if (c->has_thread_id) { 3122 monitor_printf(mon, " thread-id: \"%" PRIu64 "\"\n", c->thread_id); 3123 } 3124 3125 l = l->next; 3126 } 3127 3128 qapi_free_HotpluggableCPUList(saved); 3129 } 3130 3131 void hmp_info_vm_generation_id(Monitor *mon, const QDict *qdict) 3132 { 3133 Error *err = NULL; 3134 GuidInfo *info = qmp_query_vm_generation_id(&err); 3135 if (info) { 3136 monitor_printf(mon, "%s\n", info->guid); 3137 } 3138 hmp_handle_error(mon, &err); 3139 qapi_free_GuidInfo(info); 3140 } 3141 3142 void hmp_info_memory_size_summary(Monitor *mon, const QDict *qdict) 3143 { 3144 Error *err = NULL; 3145 MemoryInfo *info = qmp_query_memory_size_summary(&err); 3146 if (info) { 3147 monitor_printf(mon, "base memory: %" PRIu64 "\n", 3148 info->base_memory); 3149 3150 if (info->has_plugged_memory) { 3151 monitor_printf(mon, "plugged memory: %" PRIu64 "\n", 3152 info->plugged_memory); 3153 } 3154 3155 qapi_free_MemoryInfo(info); 3156 } 3157 hmp_handle_error(mon, &err); 3158 } 3159