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