1 /* 2 * Blockdev HMP commands 3 * 4 * Authors: 5 * Anthony Liguori <aliguori@us.ibm.com> 6 * 7 * Copyright (c) 2003-2008 Fabrice Bellard 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2. 10 * See the COPYING file in the top-level directory. 11 * Contributions after 2012-01-13 are licensed under the terms of the 12 * GNU GPL, version 2 or (at your option) any later version. 13 * 14 * This file incorporates work covered by the following copyright and 15 * permission notice: 16 * 17 * Copyright (c) 2003-2008 Fabrice Bellard 18 * 19 * Permission is hereby granted, free of charge, to any person obtaining a copy 20 * of this software and associated documentation files (the "Software"), to deal 21 * in the Software without restriction, including without limitation the rights 22 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 23 * copies of the Software, and to permit persons to whom the Software is 24 * furnished to do so, subject to the following conditions: 25 * 26 * The above copyright notice and this permission notice shall be included in 27 * all copies or substantial portions of the Software. 28 * 29 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 30 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 31 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 32 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 33 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 34 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 35 * THE SOFTWARE. 36 */ 37 38 #include "qemu/osdep.h" 39 #include "hw/boards.h" 40 #include "sysemu/block-backend.h" 41 #include "sysemu/blockdev.h" 42 #include "qapi/qapi-commands-block.h" 43 #include "qapi/qapi-commands-block-export.h" 44 #include "qapi/qmp/qdict.h" 45 #include "qapi/error.h" 46 #include "qapi/qmp/qerror.h" 47 #include "qemu/config-file.h" 48 #include "qemu/option.h" 49 #include "qemu/sockets.h" 50 #include "qemu/cutils.h" 51 #include "qemu/error-report.h" 52 #include "sysemu/sysemu.h" 53 #include "monitor/monitor.h" 54 #include "monitor/hmp.h" 55 #include "block/nbd.h" 56 #include "block/qapi.h" 57 #include "block/block_int.h" 58 #include "block/block-hmp-cmds.h" 59 #include "qemu-io.h" 60 61 static void hmp_drive_add_node(Monitor *mon, const char *optstr) 62 { 63 QemuOpts *opts; 64 QDict *qdict; 65 Error *local_err = NULL; 66 67 opts = qemu_opts_parse_noisily(&qemu_drive_opts, optstr, false); 68 if (!opts) { 69 return; 70 } 71 72 qdict = qemu_opts_to_qdict(opts, NULL); 73 74 if (!qdict_get_try_str(qdict, "node-name")) { 75 qobject_unref(qdict); 76 error_report("'node-name' needs to be specified"); 77 goto out; 78 } 79 80 BlockDriverState *bs = bds_tree_init(qdict, &local_err); 81 if (!bs) { 82 error_report_err(local_err); 83 goto out; 84 } 85 86 bdrv_set_monitor_owned(bs); 87 out: 88 qemu_opts_del(opts); 89 } 90 91 void hmp_drive_add(Monitor *mon, const QDict *qdict) 92 { 93 Error *err = NULL; 94 DriveInfo *dinfo; 95 QemuOpts *opts; 96 MachineClass *mc; 97 const char *optstr = qdict_get_str(qdict, "opts"); 98 bool node = qdict_get_try_bool(qdict, "node", false); 99 100 if (node) { 101 hmp_drive_add_node(mon, optstr); 102 return; 103 } 104 105 opts = qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr, false); 106 if (!opts) 107 return; 108 109 mc = MACHINE_GET_CLASS(current_machine); 110 dinfo = drive_new(opts, mc->block_default_type, &err); 111 if (err) { 112 error_report_err(err); 113 qemu_opts_del(opts); 114 goto err; 115 } 116 117 if (!dinfo) { 118 return; 119 } 120 121 switch (dinfo->type) { 122 case IF_NONE: 123 monitor_printf(mon, "OK\n"); 124 break; 125 default: 126 monitor_printf(mon, "Can't hot-add drive to type %d\n", dinfo->type); 127 goto err; 128 } 129 return; 130 131 err: 132 if (dinfo) { 133 BlockBackend *blk = blk_by_legacy_dinfo(dinfo); 134 monitor_remove_blk(blk); 135 blk_unref(blk); 136 } 137 } 138 139 void hmp_drive_del(Monitor *mon, const QDict *qdict) 140 { 141 const char *id = qdict_get_str(qdict, "id"); 142 BlockBackend *blk; 143 BlockDriverState *bs; 144 Error *local_err = NULL; 145 146 GLOBAL_STATE_CODE(); 147 GRAPH_RDLOCK_GUARD_MAINLOOP(); 148 149 bs = bdrv_find_node(id); 150 if (bs) { 151 qmp_blockdev_del(id, &local_err); 152 if (local_err) { 153 error_report_err(local_err); 154 } 155 return; 156 } 157 158 blk = blk_by_name(id); 159 if (!blk) { 160 error_report("Device '%s' not found", id); 161 return; 162 } 163 164 if (!blk_legacy_dinfo(blk)) { 165 error_report("Deleting device added with blockdev-add" 166 " is not supported"); 167 return; 168 } 169 170 bs = blk_bs(blk); 171 if (bs) { 172 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, &local_err)) { 173 error_report_err(local_err); 174 return; 175 } 176 177 blk_remove_bs(blk); 178 } 179 180 /* Make the BlockBackend and the attached BlockDriverState anonymous */ 181 monitor_remove_blk(blk); 182 183 /* 184 * If this BlockBackend has a device attached to it, its refcount will be 185 * decremented when the device is removed; otherwise we have to do so here. 186 */ 187 if (blk_get_attached_dev(blk)) { 188 /* Further I/O must not pause the guest */ 189 blk_set_on_error(blk, BLOCKDEV_ON_ERROR_REPORT, 190 BLOCKDEV_ON_ERROR_REPORT); 191 } else { 192 blk_unref(blk); 193 } 194 } 195 196 void hmp_commit(Monitor *mon, const QDict *qdict) 197 { 198 const char *device = qdict_get_str(qdict, "device"); 199 BlockBackend *blk; 200 int ret; 201 202 GLOBAL_STATE_CODE(); 203 GRAPH_RDLOCK_GUARD_MAINLOOP(); 204 205 if (!strcmp(device, "all")) { 206 ret = blk_commit_all(); 207 } else { 208 BlockDriverState *bs; 209 210 blk = blk_by_name(device); 211 if (!blk) { 212 error_report("Device '%s' not found", device); 213 return; 214 } 215 216 bs = bdrv_skip_implicit_filters(blk_bs(blk)); 217 218 if (!blk_is_available(blk)) { 219 error_report("Device '%s' has no medium", device); 220 return; 221 } 222 223 ret = bdrv_commit(bs); 224 } 225 if (ret < 0) { 226 error_report("'commit' error for '%s': %s", device, strerror(-ret)); 227 } 228 } 229 230 void hmp_drive_mirror(Monitor *mon, const QDict *qdict) 231 { 232 const char *filename = qdict_get_str(qdict, "target"); 233 const char *format = qdict_get_try_str(qdict, "format"); 234 bool reuse = qdict_get_try_bool(qdict, "reuse", false); 235 bool full = qdict_get_try_bool(qdict, "full", false); 236 Error *err = NULL; 237 DriveMirror mirror = { 238 .device = (char *)qdict_get_str(qdict, "device"), 239 .target = (char *)filename, 240 .format = (char *)format, 241 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP, 242 .has_mode = true, 243 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS, 244 .unmap = true, 245 }; 246 247 if (!filename) { 248 error_setg(&err, QERR_MISSING_PARAMETER, "target"); 249 goto end; 250 } 251 qmp_drive_mirror(&mirror, &err); 252 end: 253 hmp_handle_error(mon, err); 254 } 255 256 void hmp_drive_backup(Monitor *mon, const QDict *qdict) 257 { 258 const char *device = qdict_get_str(qdict, "device"); 259 const char *filename = qdict_get_str(qdict, "target"); 260 const char *format = qdict_get_try_str(qdict, "format"); 261 bool reuse = qdict_get_try_bool(qdict, "reuse", false); 262 bool full = qdict_get_try_bool(qdict, "full", false); 263 bool compress = qdict_get_try_bool(qdict, "compress", false); 264 Error *err = NULL; 265 DriveBackup backup = { 266 .device = (char *)device, 267 .target = (char *)filename, 268 .format = (char *)format, 269 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP, 270 .has_mode = true, 271 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS, 272 .has_compress = !!compress, 273 .compress = compress, 274 }; 275 276 if (!filename) { 277 error_setg(&err, QERR_MISSING_PARAMETER, "target"); 278 goto end; 279 } 280 281 qmp_drive_backup(&backup, &err); 282 end: 283 hmp_handle_error(mon, err); 284 } 285 286 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict) 287 { 288 Error *error = NULL; 289 const char *device = qdict_get_str(qdict, "device"); 290 int64_t value = qdict_get_int(qdict, "speed"); 291 292 qmp_block_job_set_speed(device, value, &error); 293 294 hmp_handle_error(mon, error); 295 } 296 297 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict) 298 { 299 Error *error = NULL; 300 const char *device = qdict_get_str(qdict, "device"); 301 bool force = qdict_get_try_bool(qdict, "force", false); 302 303 qmp_block_job_cancel(device, true, force, &error); 304 305 hmp_handle_error(mon, error); 306 } 307 308 void hmp_block_job_pause(Monitor *mon, const QDict *qdict) 309 { 310 Error *error = NULL; 311 const char *device = qdict_get_str(qdict, "device"); 312 313 qmp_block_job_pause(device, &error); 314 315 hmp_handle_error(mon, error); 316 } 317 318 void hmp_block_job_resume(Monitor *mon, const QDict *qdict) 319 { 320 Error *error = NULL; 321 const char *device = qdict_get_str(qdict, "device"); 322 323 qmp_block_job_resume(device, &error); 324 325 hmp_handle_error(mon, error); 326 } 327 328 void hmp_block_job_complete(Monitor *mon, const QDict *qdict) 329 { 330 Error *error = NULL; 331 const char *device = qdict_get_str(qdict, "device"); 332 333 qmp_block_job_complete(device, &error); 334 335 hmp_handle_error(mon, error); 336 } 337 338 void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict) 339 { 340 const char *device = qdict_get_str(qdict, "device"); 341 const char *filename = qdict_get_try_str(qdict, "snapshot-file"); 342 const char *format = qdict_get_try_str(qdict, "format"); 343 bool reuse = qdict_get_try_bool(qdict, "reuse", false); 344 enum NewImageMode mode; 345 Error *err = NULL; 346 347 if (!filename) { 348 /* 349 * In the future, if 'snapshot-file' is not specified, the snapshot 350 * will be taken internally. Today it's actually required. 351 */ 352 error_setg(&err, QERR_MISSING_PARAMETER, "snapshot-file"); 353 goto end; 354 } 355 356 mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS; 357 qmp_blockdev_snapshot_sync(device, NULL, filename, NULL, format, 358 true, mode, &err); 359 end: 360 hmp_handle_error(mon, err); 361 } 362 363 void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict) 364 { 365 const char *device = qdict_get_str(qdict, "device"); 366 const char *name = qdict_get_str(qdict, "name"); 367 Error *err = NULL; 368 369 qmp_blockdev_snapshot_internal_sync(device, name, &err); 370 hmp_handle_error(mon, err); 371 } 372 373 void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict) 374 { 375 const char *device = qdict_get_str(qdict, "device"); 376 const char *name = qdict_get_str(qdict, "name"); 377 const char *id = qdict_get_try_str(qdict, "id"); 378 Error *err = NULL; 379 380 qmp_blockdev_snapshot_delete_internal_sync(device, id, name, &err); 381 hmp_handle_error(mon, err); 382 } 383 384 void hmp_nbd_server_start(Monitor *mon, const QDict *qdict) 385 { 386 const char *uri = qdict_get_str(qdict, "uri"); 387 bool writable = qdict_get_try_bool(qdict, "writable", false); 388 bool all = qdict_get_try_bool(qdict, "all", false); 389 Error *local_err = NULL; 390 BlockInfoList *block_list, *info; 391 SocketAddress *addr; 392 NbdServerAddOptions export; 393 394 if (writable && !all) { 395 error_setg(&local_err, "-w only valid together with -a"); 396 goto exit; 397 } 398 399 /* First check if the address is valid and start the server. */ 400 addr = socket_parse(uri, &local_err); 401 if (local_err != NULL) { 402 goto exit; 403 } 404 405 nbd_server_start(addr, NULL, NULL, NBD_DEFAULT_MAX_CONNECTIONS, 406 &local_err); 407 qapi_free_SocketAddress(addr); 408 if (local_err != NULL) { 409 goto exit; 410 } 411 412 if (!all) { 413 return; 414 } 415 416 /* Then try adding all block devices. If one fails, close all and 417 * exit. 418 */ 419 block_list = qmp_query_block(NULL); 420 421 for (info = block_list; info; info = info->next) { 422 if (!info->value->inserted) { 423 continue; 424 } 425 426 export = (NbdServerAddOptions) { 427 .device = info->value->device, 428 .has_writable = true, 429 .writable = writable, 430 }; 431 432 qmp_nbd_server_add(&export, &local_err); 433 434 if (local_err != NULL) { 435 qmp_nbd_server_stop(NULL); 436 break; 437 } 438 } 439 440 qapi_free_BlockInfoList(block_list); 441 442 exit: 443 hmp_handle_error(mon, local_err); 444 } 445 446 void hmp_nbd_server_add(Monitor *mon, const QDict *qdict) 447 { 448 const char *device = qdict_get_str(qdict, "device"); 449 const char *name = qdict_get_try_str(qdict, "name"); 450 bool writable = qdict_get_try_bool(qdict, "writable", false); 451 Error *local_err = NULL; 452 453 NbdServerAddOptions export = { 454 .device = (char *) device, 455 .name = (char *) name, 456 .has_writable = true, 457 .writable = writable, 458 }; 459 460 qmp_nbd_server_add(&export, &local_err); 461 hmp_handle_error(mon, local_err); 462 } 463 464 void hmp_nbd_server_remove(Monitor *mon, const QDict *qdict) 465 { 466 const char *name = qdict_get_str(qdict, "name"); 467 bool force = qdict_get_try_bool(qdict, "force", false); 468 Error *err = NULL; 469 470 /* Rely on BLOCK_EXPORT_REMOVE_MODE_SAFE being the default */ 471 qmp_nbd_server_remove(name, force, BLOCK_EXPORT_REMOVE_MODE_HARD, &err); 472 hmp_handle_error(mon, err); 473 } 474 475 void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict) 476 { 477 Error *err = NULL; 478 479 qmp_nbd_server_stop(&err); 480 hmp_handle_error(mon, err); 481 } 482 483 void coroutine_fn hmp_block_resize(Monitor *mon, const QDict *qdict) 484 { 485 const char *device = qdict_get_str(qdict, "device"); 486 int64_t size = qdict_get_int(qdict, "size"); 487 Error *err = NULL; 488 489 qmp_block_resize(device, NULL, size, &err); 490 hmp_handle_error(mon, err); 491 } 492 493 void hmp_block_stream(Monitor *mon, const QDict *qdict) 494 { 495 Error *error = NULL; 496 const char *device = qdict_get_str(qdict, "device"); 497 const char *base = qdict_get_try_str(qdict, "base"); 498 int64_t speed = qdict_get_try_int(qdict, "speed", 0); 499 500 qmp_block_stream(device, device, base, NULL, NULL, false, false, NULL, 501 qdict_haskey(qdict, "speed"), speed, 502 true, BLOCKDEV_ON_ERROR_REPORT, NULL, 503 false, false, false, false, &error); 504 505 hmp_handle_error(mon, error); 506 } 507 508 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict) 509 { 510 Error *err = NULL; 511 char *device = (char *) qdict_get_str(qdict, "device"); 512 BlockIOThrottle throttle = { 513 .bps = qdict_get_int(qdict, "bps"), 514 .bps_rd = qdict_get_int(qdict, "bps_rd"), 515 .bps_wr = qdict_get_int(qdict, "bps_wr"), 516 .iops = qdict_get_int(qdict, "iops"), 517 .iops_rd = qdict_get_int(qdict, "iops_rd"), 518 .iops_wr = qdict_get_int(qdict, "iops_wr"), 519 }; 520 521 /* 522 * qmp_block_set_io_throttle has separate parameters for the 523 * (deprecated) block device name and the qdev ID but the HMP 524 * version has only one, so we must decide which one to pass. 525 */ 526 if (blk_by_name(device)) { 527 throttle.device = device; 528 } else { 529 throttle.id = device; 530 } 531 532 qmp_block_set_io_throttle(&throttle, &err); 533 hmp_handle_error(mon, err); 534 } 535 536 void hmp_eject(Monitor *mon, const QDict *qdict) 537 { 538 bool force = qdict_get_try_bool(qdict, "force", false); 539 const char *device = qdict_get_str(qdict, "device"); 540 Error *err = NULL; 541 542 qmp_eject(device, NULL, true, force, &err); 543 hmp_handle_error(mon, err); 544 } 545 546 void hmp_qemu_io(Monitor *mon, const QDict *qdict) 547 { 548 BlockBackend *blk = NULL; 549 BlockDriverState *bs = NULL; 550 BlockBackend *local_blk = NULL; 551 bool qdev = qdict_get_try_bool(qdict, "qdev", false); 552 const char *device = qdict_get_str(qdict, "device"); 553 const char *command = qdict_get_str(qdict, "command"); 554 Error *err = NULL; 555 int ret; 556 557 if (qdev) { 558 blk = blk_by_qdev_id(device, &err); 559 if (!blk) { 560 goto fail; 561 } 562 } else { 563 blk = blk_by_name(device); 564 if (!blk) { 565 bs = bdrv_lookup_bs(NULL, device, &err); 566 if (!bs) { 567 goto fail; 568 } 569 } 570 } 571 572 if (bs) { 573 blk = local_blk = blk_new(bdrv_get_aio_context(bs), 0, BLK_PERM_ALL); 574 ret = blk_insert_bs(blk, bs, &err); 575 if (ret < 0) { 576 goto fail; 577 } 578 } 579 580 /* 581 * Notably absent: Proper permission management. This is sad, but it seems 582 * almost impossible to achieve without changing the semantics and thereby 583 * limiting the use cases of the qemu-io HMP command. 584 * 585 * In an ideal world we would unconditionally create a new BlockBackend for 586 * qemuio_command(), but we have commands like 'reopen' and want them to 587 * take effect on the exact BlockBackend whose name the user passed instead 588 * of just on a temporary copy of it. 589 * 590 * Another problem is that deleting the temporary BlockBackend involves 591 * draining all requests on it first, but some qemu-iotests cases want to 592 * issue multiple aio_read/write requests and expect them to complete in 593 * the background while the monitor has already returned. 594 * 595 * This is also what prevents us from saving the original permissions and 596 * restoring them later: We can't revoke permissions until all requests 597 * have completed, and we don't know when that is nor can we really let 598 * anything else run before we have revoken them to avoid race conditions. 599 * 600 * What happens now is that command() in qemu-io-cmds.c can extend the 601 * permissions if necessary for the qemu-io command. And they simply stay 602 * extended, possibly resulting in a read-only guest device keeping write 603 * permissions. Ugly, but it appears to be the lesser evil. 604 */ 605 qemuio_command(blk, command); 606 607 fail: 608 blk_unref(local_blk); 609 hmp_handle_error(mon, err); 610 } 611 612 static void print_block_info(Monitor *mon, BlockInfo *info, 613 BlockDeviceInfo *inserted, bool verbose) 614 { 615 ImageInfo *image_info; 616 617 assert(!info || !info->inserted || info->inserted == inserted); 618 619 if (info && *info->device) { 620 monitor_puts(mon, info->device); 621 if (inserted && inserted->node_name) { 622 monitor_printf(mon, " (%s)", inserted->node_name); 623 } 624 } else { 625 assert(info || inserted); 626 monitor_puts(mon, 627 inserted && inserted->node_name ? inserted->node_name 628 : info && info->qdev ? info->qdev 629 : "<anonymous>"); 630 } 631 632 if (inserted) { 633 monitor_printf(mon, ": %s (%s%s%s)\n", 634 inserted->file, 635 inserted->drv, 636 inserted->ro ? ", read-only" : "", 637 inserted->encrypted ? ", encrypted" : ""); 638 } else { 639 monitor_printf(mon, ": [not inserted]\n"); 640 } 641 642 if (info) { 643 if (info->qdev) { 644 monitor_printf(mon, " Attached to: %s\n", info->qdev); 645 } 646 if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) { 647 monitor_printf(mon, " I/O status: %s\n", 648 BlockDeviceIoStatus_str(info->io_status)); 649 } 650 651 if (info->removable) { 652 monitor_printf(mon, " Removable device: %slocked, tray %s\n", 653 info->locked ? "" : "not ", 654 info->tray_open ? "open" : "closed"); 655 } 656 } 657 658 659 if (!inserted) { 660 return; 661 } 662 663 monitor_printf(mon, " Cache mode: %s%s%s\n", 664 inserted->cache->writeback ? "writeback" : "writethrough", 665 inserted->cache->direct ? ", direct" : "", 666 inserted->cache->no_flush ? ", ignore flushes" : ""); 667 668 if (inserted->backing_file) { 669 monitor_printf(mon, 670 " Backing file: %s " 671 "(chain depth: %" PRId64 ")\n", 672 inserted->backing_file, 673 inserted->backing_file_depth); 674 } 675 676 if (inserted->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) { 677 monitor_printf(mon, " Detect zeroes: %s\n", 678 BlockdevDetectZeroesOptions_str(inserted->detect_zeroes)); 679 } 680 681 if (inserted->bps || inserted->bps_rd || inserted->bps_wr || 682 inserted->iops || inserted->iops_rd || inserted->iops_wr) 683 { 684 monitor_printf(mon, " I/O throttling: bps=%" PRId64 685 " bps_rd=%" PRId64 " bps_wr=%" PRId64 686 " bps_max=%" PRId64 687 " bps_rd_max=%" PRId64 688 " bps_wr_max=%" PRId64 689 " iops=%" PRId64 " iops_rd=%" PRId64 690 " iops_wr=%" PRId64 691 " iops_max=%" PRId64 692 " iops_rd_max=%" PRId64 693 " iops_wr_max=%" PRId64 694 " iops_size=%" PRId64 695 " group=%s\n", 696 inserted->bps, 697 inserted->bps_rd, 698 inserted->bps_wr, 699 inserted->bps_max, 700 inserted->bps_rd_max, 701 inserted->bps_wr_max, 702 inserted->iops, 703 inserted->iops_rd, 704 inserted->iops_wr, 705 inserted->iops_max, 706 inserted->iops_rd_max, 707 inserted->iops_wr_max, 708 inserted->iops_size, 709 inserted->group); 710 } 711 712 if (verbose) { 713 monitor_printf(mon, "\nImages:\n"); 714 image_info = inserted->image; 715 while (1) { 716 bdrv_node_info_dump(qapi_ImageInfo_base(image_info), 0, false); 717 if (image_info->backing_image) { 718 image_info = image_info->backing_image; 719 } else { 720 break; 721 } 722 } 723 } 724 } 725 726 void hmp_info_block(Monitor *mon, const QDict *qdict) 727 { 728 BlockInfoList *block_list, *info; 729 BlockDeviceInfoList *blockdev_list, *blockdev; 730 const char *device = qdict_get_try_str(qdict, "device"); 731 bool verbose = qdict_get_try_bool(qdict, "verbose", false); 732 bool nodes = qdict_get_try_bool(qdict, "nodes", false); 733 bool printed = false; 734 735 /* Print BlockBackend information */ 736 if (!nodes) { 737 block_list = qmp_query_block(NULL); 738 } else { 739 block_list = NULL; 740 } 741 742 for (info = block_list; info; info = info->next) { 743 if (device && strcmp(device, info->value->device)) { 744 continue; 745 } 746 747 if (info != block_list) { 748 monitor_printf(mon, "\n"); 749 } 750 751 print_block_info(mon, info->value, info->value->inserted, 752 verbose); 753 printed = true; 754 } 755 756 qapi_free_BlockInfoList(block_list); 757 758 if ((!device && !nodes) || printed) { 759 return; 760 } 761 762 /* Print node information */ 763 blockdev_list = qmp_query_named_block_nodes(false, false, NULL); 764 for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) { 765 assert(blockdev->value->node_name); 766 if (device && strcmp(device, blockdev->value->node_name)) { 767 continue; 768 } 769 770 if (blockdev != blockdev_list) { 771 monitor_printf(mon, "\n"); 772 } 773 774 print_block_info(mon, NULL, blockdev->value, verbose); 775 } 776 qapi_free_BlockDeviceInfoList(blockdev_list); 777 } 778 779 void hmp_info_blockstats(Monitor *mon, const QDict *qdict) 780 { 781 BlockStatsList *stats_list, *stats; 782 783 stats_list = qmp_query_blockstats(false, false, NULL); 784 785 for (stats = stats_list; stats; stats = stats->next) { 786 if (!stats->value->device) { 787 continue; 788 } 789 790 monitor_printf(mon, "%s:", stats->value->device); 791 monitor_printf(mon, " rd_bytes=%" PRId64 792 " wr_bytes=%" PRId64 793 " rd_operations=%" PRId64 794 " wr_operations=%" PRId64 795 " flush_operations=%" PRId64 796 " wr_total_time_ns=%" PRId64 797 " rd_total_time_ns=%" PRId64 798 " flush_total_time_ns=%" PRId64 799 " rd_merged=%" PRId64 800 " wr_merged=%" PRId64 801 " idle_time_ns=%" PRId64 802 "\n", 803 stats->value->stats->rd_bytes, 804 stats->value->stats->wr_bytes, 805 stats->value->stats->rd_operations, 806 stats->value->stats->wr_operations, 807 stats->value->stats->flush_operations, 808 stats->value->stats->wr_total_time_ns, 809 stats->value->stats->rd_total_time_ns, 810 stats->value->stats->flush_total_time_ns, 811 stats->value->stats->rd_merged, 812 stats->value->stats->wr_merged, 813 stats->value->stats->idle_time_ns); 814 } 815 816 qapi_free_BlockStatsList(stats_list); 817 } 818 819 void hmp_info_block_jobs(Monitor *mon, const QDict *qdict) 820 { 821 BlockJobInfoList *list; 822 823 list = qmp_query_block_jobs(&error_abort); 824 825 if (!list) { 826 monitor_printf(mon, "No active jobs\n"); 827 return; 828 } 829 830 while (list) { 831 if (list->value->type == JOB_TYPE_STREAM) { 832 monitor_printf(mon, "Streaming device %s: Completed %" PRId64 833 " of %" PRId64 " bytes, speed limit %" PRId64 834 " bytes/s\n", 835 list->value->device, 836 list->value->offset, 837 list->value->len, 838 list->value->speed); 839 } else { 840 monitor_printf(mon, "Type %s, device %s: Completed %" PRId64 841 " of %" PRId64 " bytes, speed limit %" PRId64 842 " bytes/s\n", 843 JobType_str(list->value->type), 844 list->value->device, 845 list->value->offset, 846 list->value->len, 847 list->value->speed); 848 } 849 list = list->next; 850 } 851 852 qapi_free_BlockJobInfoList(list); 853 } 854 855 void hmp_info_snapshots(Monitor *mon, const QDict *qdict) 856 { 857 BlockDriverState *bs, *bs1; 858 BdrvNextIterator it1; 859 QEMUSnapshotInfo *sn_tab, *sn; 860 bool no_snapshot = true; 861 int nb_sns, i; 862 int total; 863 int *global_snapshots; 864 865 typedef struct SnapshotEntry { 866 QEMUSnapshotInfo sn; 867 QTAILQ_ENTRY(SnapshotEntry) next; 868 } SnapshotEntry; 869 870 typedef struct ImageEntry { 871 const char *imagename; 872 QTAILQ_ENTRY(ImageEntry) next; 873 QTAILQ_HEAD(, SnapshotEntry) snapshots; 874 } ImageEntry; 875 876 QTAILQ_HEAD(, ImageEntry) image_list = 877 QTAILQ_HEAD_INITIALIZER(image_list); 878 879 ImageEntry *image_entry, *next_ie; 880 SnapshotEntry *snapshot_entry; 881 Error *err = NULL; 882 883 GRAPH_RDLOCK_GUARD_MAINLOOP(); 884 885 bs = bdrv_all_find_vmstate_bs(NULL, false, NULL, &err); 886 if (!bs) { 887 error_report_err(err); 888 return; 889 } 890 891 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 892 893 if (nb_sns < 0) { 894 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns); 895 return; 896 } 897 898 for (bs1 = bdrv_first(&it1); bs1; bs1 = bdrv_next(&it1)) { 899 int bs1_nb_sns = 0; 900 ImageEntry *ie; 901 SnapshotEntry *se; 902 903 if (bdrv_can_snapshot(bs1)) { 904 sn = NULL; 905 bs1_nb_sns = bdrv_snapshot_list(bs1, &sn); 906 if (bs1_nb_sns > 0) { 907 no_snapshot = false; 908 ie = g_new0(ImageEntry, 1); 909 ie->imagename = bdrv_get_device_name(bs1); 910 QTAILQ_INIT(&ie->snapshots); 911 QTAILQ_INSERT_TAIL(&image_list, ie, next); 912 for (i = 0; i < bs1_nb_sns; i++) { 913 se = g_new0(SnapshotEntry, 1); 914 se->sn = sn[i]; 915 QTAILQ_INSERT_TAIL(&ie->snapshots, se, next); 916 } 917 } 918 g_free(sn); 919 } 920 } 921 922 if (no_snapshot) { 923 monitor_printf(mon, "There is no snapshot available.\n"); 924 return; 925 } 926 927 global_snapshots = g_new0(int, nb_sns); 928 total = 0; 929 for (i = 0; i < nb_sns; i++) { 930 SnapshotEntry *next_sn; 931 if (bdrv_all_has_snapshot(sn_tab[i].name, false, NULL, NULL) == 1) { 932 global_snapshots[total] = i; 933 total++; 934 QTAILQ_FOREACH(image_entry, &image_list, next) { 935 QTAILQ_FOREACH_SAFE(snapshot_entry, &image_entry->snapshots, 936 next, next_sn) { 937 if (!strcmp(sn_tab[i].name, snapshot_entry->sn.name)) { 938 QTAILQ_REMOVE(&image_entry->snapshots, snapshot_entry, 939 next); 940 g_free(snapshot_entry); 941 } 942 } 943 } 944 } 945 } 946 monitor_printf(mon, "List of snapshots present on all disks:\n"); 947 948 if (total > 0) { 949 bdrv_snapshot_dump(NULL); 950 monitor_printf(mon, "\n"); 951 for (i = 0; i < total; i++) { 952 sn = &sn_tab[global_snapshots[i]]; 953 /* 954 * The ID is not guaranteed to be the same on all images, so 955 * overwrite it. 956 */ 957 pstrcpy(sn->id_str, sizeof(sn->id_str), "--"); 958 bdrv_snapshot_dump(sn); 959 monitor_printf(mon, "\n"); 960 } 961 } else { 962 monitor_printf(mon, "None\n"); 963 } 964 965 QTAILQ_FOREACH(image_entry, &image_list, next) { 966 if (QTAILQ_EMPTY(&image_entry->snapshots)) { 967 continue; 968 } 969 monitor_printf(mon, 970 "\nList of partial (non-loadable) snapshots on '%s':\n", 971 image_entry->imagename); 972 bdrv_snapshot_dump(NULL); 973 monitor_printf(mon, "\n"); 974 QTAILQ_FOREACH(snapshot_entry, &image_entry->snapshots, next) { 975 bdrv_snapshot_dump(&snapshot_entry->sn); 976 monitor_printf(mon, "\n"); 977 } 978 } 979 980 QTAILQ_FOREACH_SAFE(image_entry, &image_list, next, next_ie) { 981 SnapshotEntry *next_sn; 982 QTAILQ_FOREACH_SAFE(snapshot_entry, &image_entry->snapshots, next, 983 next_sn) { 984 g_free(snapshot_entry); 985 } 986 g_free(image_entry); 987 } 988 g_free(sn_tab); 989 g_free(global_snapshots); 990 } 991 992 void hmp_change_medium(Monitor *mon, const char *device, const char *target, 993 const char *arg, const char *read_only, bool force, 994 Error **errp) 995 { 996 ERRP_GUARD(); 997 BlockdevChangeReadOnlyMode read_only_mode = 0; 998 999 if (read_only) { 1000 read_only_mode = 1001 qapi_enum_parse(&BlockdevChangeReadOnlyMode_lookup, 1002 read_only, 1003 BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN, errp); 1004 if (*errp) { 1005 return; 1006 } 1007 } 1008 1009 qmp_blockdev_change_medium(device, NULL, target, arg, true, force, 1010 !!read_only, read_only_mode, errp); 1011 } 1012