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 AioContext *aio_context; 145 Error *local_err = NULL; 146 147 GLOBAL_STATE_CODE(); 148 GRAPH_RDLOCK_GUARD_MAINLOOP(); 149 150 bs = bdrv_find_node(id); 151 if (bs) { 152 qmp_blockdev_del(id, &local_err); 153 if (local_err) { 154 error_report_err(local_err); 155 } 156 return; 157 } 158 159 blk = blk_by_name(id); 160 if (!blk) { 161 error_report("Device '%s' not found", id); 162 return; 163 } 164 165 if (!blk_legacy_dinfo(blk)) { 166 error_report("Deleting device added with blockdev-add" 167 " is not supported"); 168 return; 169 } 170 171 aio_context = blk_get_aio_context(blk); 172 aio_context_acquire(aio_context); 173 174 bs = blk_bs(blk); 175 if (bs) { 176 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, &local_err)) { 177 error_report_err(local_err); 178 aio_context_release(aio_context); 179 return; 180 } 181 182 blk_remove_bs(blk); 183 } 184 185 /* Make the BlockBackend and the attached BlockDriverState anonymous */ 186 monitor_remove_blk(blk); 187 188 /* 189 * If this BlockBackend has a device attached to it, its refcount will be 190 * decremented when the device is removed; otherwise we have to do so here. 191 */ 192 if (blk_get_attached_dev(blk)) { 193 /* Further I/O must not pause the guest */ 194 blk_set_on_error(blk, BLOCKDEV_ON_ERROR_REPORT, 195 BLOCKDEV_ON_ERROR_REPORT); 196 } else { 197 blk_unref(blk); 198 } 199 200 aio_context_release(aio_context); 201 } 202 203 void hmp_commit(Monitor *mon, const QDict *qdict) 204 { 205 const char *device = qdict_get_str(qdict, "device"); 206 BlockBackend *blk; 207 int ret; 208 209 if (!strcmp(device, "all")) { 210 ret = blk_commit_all(); 211 } else { 212 BlockDriverState *bs; 213 AioContext *aio_context; 214 215 blk = blk_by_name(device); 216 if (!blk) { 217 error_report("Device '%s' not found", device); 218 return; 219 } 220 221 bs = bdrv_skip_implicit_filters(blk_bs(blk)); 222 aio_context = bdrv_get_aio_context(bs); 223 aio_context_acquire(aio_context); 224 225 if (!blk_is_available(blk)) { 226 error_report("Device '%s' has no medium", device); 227 aio_context_release(aio_context); 228 return; 229 } 230 231 ret = bdrv_commit(bs); 232 233 aio_context_release(aio_context); 234 } 235 if (ret < 0) { 236 error_report("'commit' error for '%s': %s", device, strerror(-ret)); 237 } 238 } 239 240 void hmp_drive_mirror(Monitor *mon, const QDict *qdict) 241 { 242 const char *filename = qdict_get_str(qdict, "target"); 243 const char *format = qdict_get_try_str(qdict, "format"); 244 bool reuse = qdict_get_try_bool(qdict, "reuse", false); 245 bool full = qdict_get_try_bool(qdict, "full", false); 246 Error *err = NULL; 247 DriveMirror mirror = { 248 .device = (char *)qdict_get_str(qdict, "device"), 249 .target = (char *)filename, 250 .format = (char *)format, 251 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP, 252 .has_mode = true, 253 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS, 254 .unmap = true, 255 }; 256 257 if (!filename) { 258 error_setg(&err, QERR_MISSING_PARAMETER, "target"); 259 goto end; 260 } 261 qmp_drive_mirror(&mirror, &err); 262 end: 263 hmp_handle_error(mon, err); 264 } 265 266 void hmp_drive_backup(Monitor *mon, const QDict *qdict) 267 { 268 const char *device = qdict_get_str(qdict, "device"); 269 const char *filename = qdict_get_str(qdict, "target"); 270 const char *format = qdict_get_try_str(qdict, "format"); 271 bool reuse = qdict_get_try_bool(qdict, "reuse", false); 272 bool full = qdict_get_try_bool(qdict, "full", false); 273 bool compress = qdict_get_try_bool(qdict, "compress", false); 274 Error *err = NULL; 275 DriveBackup backup = { 276 .device = (char *)device, 277 .target = (char *)filename, 278 .format = (char *)format, 279 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP, 280 .has_mode = true, 281 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS, 282 .has_compress = !!compress, 283 .compress = compress, 284 }; 285 286 if (!filename) { 287 error_setg(&err, QERR_MISSING_PARAMETER, "target"); 288 goto end; 289 } 290 291 qmp_drive_backup(&backup, &err); 292 end: 293 hmp_handle_error(mon, err); 294 } 295 296 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict) 297 { 298 Error *error = NULL; 299 const char *device = qdict_get_str(qdict, "device"); 300 int64_t value = qdict_get_int(qdict, "speed"); 301 302 qmp_block_job_set_speed(device, value, &error); 303 304 hmp_handle_error(mon, error); 305 } 306 307 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict) 308 { 309 Error *error = NULL; 310 const char *device = qdict_get_str(qdict, "device"); 311 bool force = qdict_get_try_bool(qdict, "force", false); 312 313 qmp_block_job_cancel(device, true, force, &error); 314 315 hmp_handle_error(mon, error); 316 } 317 318 void hmp_block_job_pause(Monitor *mon, const QDict *qdict) 319 { 320 Error *error = NULL; 321 const char *device = qdict_get_str(qdict, "device"); 322 323 qmp_block_job_pause(device, &error); 324 325 hmp_handle_error(mon, error); 326 } 327 328 void hmp_block_job_resume(Monitor *mon, const QDict *qdict) 329 { 330 Error *error = NULL; 331 const char *device = qdict_get_str(qdict, "device"); 332 333 qmp_block_job_resume(device, &error); 334 335 hmp_handle_error(mon, error); 336 } 337 338 void hmp_block_job_complete(Monitor *mon, const QDict *qdict) 339 { 340 Error *error = NULL; 341 const char *device = qdict_get_str(qdict, "device"); 342 343 qmp_block_job_complete(device, &error); 344 345 hmp_handle_error(mon, error); 346 } 347 348 void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict) 349 { 350 const char *device = qdict_get_str(qdict, "device"); 351 const char *filename = qdict_get_try_str(qdict, "snapshot-file"); 352 const char *format = qdict_get_try_str(qdict, "format"); 353 bool reuse = qdict_get_try_bool(qdict, "reuse", false); 354 enum NewImageMode mode; 355 Error *err = NULL; 356 357 if (!filename) { 358 /* 359 * In the future, if 'snapshot-file' is not specified, the snapshot 360 * will be taken internally. Today it's actually required. 361 */ 362 error_setg(&err, QERR_MISSING_PARAMETER, "snapshot-file"); 363 goto end; 364 } 365 366 mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS; 367 qmp_blockdev_snapshot_sync(device, NULL, filename, NULL, format, 368 true, mode, &err); 369 end: 370 hmp_handle_error(mon, err); 371 } 372 373 void hmp_snapshot_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 Error *err = NULL; 378 379 qmp_blockdev_snapshot_internal_sync(device, name, &err); 380 hmp_handle_error(mon, err); 381 } 382 383 void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict) 384 { 385 const char *device = qdict_get_str(qdict, "device"); 386 const char *name = qdict_get_str(qdict, "name"); 387 const char *id = qdict_get_try_str(qdict, "id"); 388 Error *err = NULL; 389 390 qmp_blockdev_snapshot_delete_internal_sync(device, id, name, &err); 391 hmp_handle_error(mon, err); 392 } 393 394 void hmp_nbd_server_start(Monitor *mon, const QDict *qdict) 395 { 396 const char *uri = qdict_get_str(qdict, "uri"); 397 bool writable = qdict_get_try_bool(qdict, "writable", false); 398 bool all = qdict_get_try_bool(qdict, "all", false); 399 Error *local_err = NULL; 400 BlockInfoList *block_list, *info; 401 SocketAddress *addr; 402 NbdServerAddOptions export; 403 404 if (writable && !all) { 405 error_setg(&local_err, "-w only valid together with -a"); 406 goto exit; 407 } 408 409 /* First check if the address is valid and start the server. */ 410 addr = socket_parse(uri, &local_err); 411 if (local_err != NULL) { 412 goto exit; 413 } 414 415 nbd_server_start(addr, NULL, NULL, 0, &local_err); 416 qapi_free_SocketAddress(addr); 417 if (local_err != NULL) { 418 goto exit; 419 } 420 421 if (!all) { 422 return; 423 } 424 425 /* Then try adding all block devices. If one fails, close all and 426 * exit. 427 */ 428 block_list = qmp_query_block(NULL); 429 430 for (info = block_list; info; info = info->next) { 431 if (!info->value->inserted) { 432 continue; 433 } 434 435 export = (NbdServerAddOptions) { 436 .device = info->value->device, 437 .has_writable = true, 438 .writable = writable, 439 }; 440 441 qmp_nbd_server_add(&export, &local_err); 442 443 if (local_err != NULL) { 444 qmp_nbd_server_stop(NULL); 445 break; 446 } 447 } 448 449 qapi_free_BlockInfoList(block_list); 450 451 exit: 452 hmp_handle_error(mon, local_err); 453 } 454 455 void hmp_nbd_server_add(Monitor *mon, const QDict *qdict) 456 { 457 const char *device = qdict_get_str(qdict, "device"); 458 const char *name = qdict_get_try_str(qdict, "name"); 459 bool writable = qdict_get_try_bool(qdict, "writable", false); 460 Error *local_err = NULL; 461 462 NbdServerAddOptions export = { 463 .device = (char *) device, 464 .name = (char *) name, 465 .has_writable = true, 466 .writable = writable, 467 }; 468 469 qmp_nbd_server_add(&export, &local_err); 470 hmp_handle_error(mon, local_err); 471 } 472 473 void hmp_nbd_server_remove(Monitor *mon, const QDict *qdict) 474 { 475 const char *name = qdict_get_str(qdict, "name"); 476 bool force = qdict_get_try_bool(qdict, "force", false); 477 Error *err = NULL; 478 479 /* Rely on BLOCK_EXPORT_REMOVE_MODE_SAFE being the default */ 480 qmp_nbd_server_remove(name, force, BLOCK_EXPORT_REMOVE_MODE_HARD, &err); 481 hmp_handle_error(mon, err); 482 } 483 484 void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict) 485 { 486 Error *err = NULL; 487 488 qmp_nbd_server_stop(&err); 489 hmp_handle_error(mon, err); 490 } 491 492 void coroutine_fn hmp_block_resize(Monitor *mon, const QDict *qdict) 493 { 494 const char *device = qdict_get_str(qdict, "device"); 495 int64_t size = qdict_get_int(qdict, "size"); 496 Error *err = NULL; 497 498 qmp_block_resize(device, NULL, size, &err); 499 hmp_handle_error(mon, err); 500 } 501 502 void hmp_block_stream(Monitor *mon, const QDict *qdict) 503 { 504 Error *error = NULL; 505 const char *device = qdict_get_str(qdict, "device"); 506 const char *base = qdict_get_try_str(qdict, "base"); 507 int64_t speed = qdict_get_try_int(qdict, "speed", 0); 508 509 qmp_block_stream(device, device, base, NULL, NULL, NULL, 510 qdict_haskey(qdict, "speed"), speed, 511 true, BLOCKDEV_ON_ERROR_REPORT, NULL, 512 false, false, false, false, &error); 513 514 hmp_handle_error(mon, error); 515 } 516 517 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict) 518 { 519 Error *err = NULL; 520 char *device = (char *) qdict_get_str(qdict, "device"); 521 BlockIOThrottle throttle = { 522 .bps = qdict_get_int(qdict, "bps"), 523 .bps_rd = qdict_get_int(qdict, "bps_rd"), 524 .bps_wr = qdict_get_int(qdict, "bps_wr"), 525 .iops = qdict_get_int(qdict, "iops"), 526 .iops_rd = qdict_get_int(qdict, "iops_rd"), 527 .iops_wr = qdict_get_int(qdict, "iops_wr"), 528 }; 529 530 /* 531 * qmp_block_set_io_throttle has separate parameters for the 532 * (deprecated) block device name and the qdev ID but the HMP 533 * version has only one, so we must decide which one to pass. 534 */ 535 if (blk_by_name(device)) { 536 throttle.device = device; 537 } else { 538 throttle.id = device; 539 } 540 541 qmp_block_set_io_throttle(&throttle, &err); 542 hmp_handle_error(mon, err); 543 } 544 545 void hmp_eject(Monitor *mon, const QDict *qdict) 546 { 547 bool force = qdict_get_try_bool(qdict, "force", false); 548 const char *device = qdict_get_str(qdict, "device"); 549 Error *err = NULL; 550 551 qmp_eject(device, NULL, true, force, &err); 552 hmp_handle_error(mon, err); 553 } 554 555 void hmp_qemu_io(Monitor *mon, const QDict *qdict) 556 { 557 BlockBackend *blk = NULL; 558 BlockDriverState *bs = NULL; 559 BlockBackend *local_blk = NULL; 560 AioContext *ctx = NULL; 561 bool qdev = qdict_get_try_bool(qdict, "qdev", false); 562 const char *device = qdict_get_str(qdict, "device"); 563 const char *command = qdict_get_str(qdict, "command"); 564 Error *err = NULL; 565 int ret; 566 567 if (qdev) { 568 blk = blk_by_qdev_id(device, &err); 569 if (!blk) { 570 goto fail; 571 } 572 } else { 573 blk = blk_by_name(device); 574 if (!blk) { 575 bs = bdrv_lookup_bs(NULL, device, &err); 576 if (!bs) { 577 goto fail; 578 } 579 } 580 } 581 582 ctx = blk ? blk_get_aio_context(blk) : bdrv_get_aio_context(bs); 583 aio_context_acquire(ctx); 584 585 if (bs) { 586 blk = local_blk = blk_new(bdrv_get_aio_context(bs), 0, BLK_PERM_ALL); 587 ret = blk_insert_bs(blk, bs, &err); 588 if (ret < 0) { 589 goto fail; 590 } 591 } 592 593 /* 594 * Notably absent: Proper permission management. This is sad, but it seems 595 * almost impossible to achieve without changing the semantics and thereby 596 * limiting the use cases of the qemu-io HMP command. 597 * 598 * In an ideal world we would unconditionally create a new BlockBackend for 599 * qemuio_command(), but we have commands like 'reopen' and want them to 600 * take effect on the exact BlockBackend whose name the user passed instead 601 * of just on a temporary copy of it. 602 * 603 * Another problem is that deleting the temporary BlockBackend involves 604 * draining all requests on it first, but some qemu-iotests cases want to 605 * issue multiple aio_read/write requests and expect them to complete in 606 * the background while the monitor has already returned. 607 * 608 * This is also what prevents us from saving the original permissions and 609 * restoring them later: We can't revoke permissions until all requests 610 * have completed, and we don't know when that is nor can we really let 611 * anything else run before we have revoken them to avoid race conditions. 612 * 613 * What happens now is that command() in qemu-io-cmds.c can extend the 614 * permissions if necessary for the qemu-io command. And they simply stay 615 * extended, possibly resulting in a read-only guest device keeping write 616 * permissions. Ugly, but it appears to be the lesser evil. 617 */ 618 qemuio_command(blk, command); 619 620 fail: 621 blk_unref(local_blk); 622 623 if (ctx) { 624 aio_context_release(ctx); 625 } 626 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->inserted || info->inserted == inserted); 636 637 if (info && *info->device) { 638 monitor_puts(mon, info->device); 639 if (inserted && inserted->node_name) { 640 monitor_printf(mon, " (%s)", inserted->node_name); 641 } 642 } else { 643 assert(info || inserted); 644 monitor_puts(mon, 645 inserted && inserted->node_name ? inserted->node_name 646 : info && info->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->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->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_node_info_dump(qapi_ImageInfo_base(image_info), 0, false); 735 if (image_info->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->inserted, 770 verbose); 771 printed = true; 772 } 773 774 qapi_free_BlockInfoList(block_list); 775 776 if ((!device && !nodes) || printed) { 777 return; 778 } 779 780 /* Print node information */ 781 blockdev_list = qmp_query_named_block_nodes(false, false, NULL); 782 for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) { 783 assert(blockdev->value->node_name); 784 if (device && strcmp(device, blockdev->value->node_name)) { 785 continue; 786 } 787 788 if (blockdev != blockdev_list) { 789 monitor_printf(mon, "\n"); 790 } 791 792 print_block_info(mon, NULL, blockdev->value, verbose); 793 } 794 qapi_free_BlockDeviceInfoList(blockdev_list); 795 } 796 797 void hmp_info_blockstats(Monitor *mon, const QDict *qdict) 798 { 799 BlockStatsList *stats_list, *stats; 800 801 stats_list = qmp_query_blockstats(false, false, NULL); 802 803 for (stats = stats_list; stats; stats = stats->next) { 804 if (!stats->value->device) { 805 continue; 806 } 807 808 monitor_printf(mon, "%s:", stats->value->device); 809 monitor_printf(mon, " rd_bytes=%" PRId64 810 " wr_bytes=%" PRId64 811 " rd_operations=%" PRId64 812 " wr_operations=%" PRId64 813 " flush_operations=%" PRId64 814 " wr_total_time_ns=%" PRId64 815 " rd_total_time_ns=%" PRId64 816 " flush_total_time_ns=%" PRId64 817 " rd_merged=%" PRId64 818 " wr_merged=%" PRId64 819 " idle_time_ns=%" PRId64 820 "\n", 821 stats->value->stats->rd_bytes, 822 stats->value->stats->wr_bytes, 823 stats->value->stats->rd_operations, 824 stats->value->stats->wr_operations, 825 stats->value->stats->flush_operations, 826 stats->value->stats->wr_total_time_ns, 827 stats->value->stats->rd_total_time_ns, 828 stats->value->stats->flush_total_time_ns, 829 stats->value->stats->rd_merged, 830 stats->value->stats->wr_merged, 831 stats->value->stats->idle_time_ns); 832 } 833 834 qapi_free_BlockStatsList(stats_list); 835 } 836 837 void hmp_info_block_jobs(Monitor *mon, const QDict *qdict) 838 { 839 BlockJobInfoList *list; 840 841 list = qmp_query_block_jobs(&error_abort); 842 843 if (!list) { 844 monitor_printf(mon, "No active jobs\n"); 845 return; 846 } 847 848 while (list) { 849 if (strcmp(list->value->type, "stream") == 0) { 850 monitor_printf(mon, "Streaming device %s: Completed %" PRId64 851 " of %" PRId64 " bytes, speed limit %" PRId64 852 " bytes/s\n", 853 list->value->device, 854 list->value->offset, 855 list->value->len, 856 list->value->speed); 857 } else { 858 monitor_printf(mon, "Type %s, device %s: Completed %" PRId64 859 " of %" PRId64 " bytes, speed limit %" PRId64 860 " bytes/s\n", 861 list->value->type, 862 list->value->device, 863 list->value->offset, 864 list->value->len, 865 list->value->speed); 866 } 867 list = list->next; 868 } 869 870 qapi_free_BlockJobInfoList(list); 871 } 872 873 void hmp_info_snapshots(Monitor *mon, const QDict *qdict) 874 { 875 BlockDriverState *bs, *bs1; 876 BdrvNextIterator it1; 877 QEMUSnapshotInfo *sn_tab, *sn; 878 bool no_snapshot = true; 879 int nb_sns, i; 880 int total; 881 int *global_snapshots; 882 AioContext *aio_context; 883 884 typedef struct SnapshotEntry { 885 QEMUSnapshotInfo sn; 886 QTAILQ_ENTRY(SnapshotEntry) next; 887 } SnapshotEntry; 888 889 typedef struct ImageEntry { 890 const char *imagename; 891 QTAILQ_ENTRY(ImageEntry) next; 892 QTAILQ_HEAD(, SnapshotEntry) snapshots; 893 } ImageEntry; 894 895 QTAILQ_HEAD(, ImageEntry) image_list = 896 QTAILQ_HEAD_INITIALIZER(image_list); 897 898 ImageEntry *image_entry, *next_ie; 899 SnapshotEntry *snapshot_entry; 900 Error *err = NULL; 901 902 GRAPH_RDLOCK_GUARD_MAINLOOP(); 903 904 bs = bdrv_all_find_vmstate_bs(NULL, false, NULL, &err); 905 if (!bs) { 906 error_report_err(err); 907 return; 908 } 909 aio_context = bdrv_get_aio_context(bs); 910 911 aio_context_acquire(aio_context); 912 nb_sns = bdrv_snapshot_list(bs, &sn_tab); 913 aio_context_release(aio_context); 914 915 if (nb_sns < 0) { 916 monitor_printf(mon, "bdrv_snapshot_list: error %d\n", nb_sns); 917 return; 918 } 919 920 for (bs1 = bdrv_first(&it1); bs1; bs1 = bdrv_next(&it1)) { 921 int bs1_nb_sns = 0; 922 ImageEntry *ie; 923 SnapshotEntry *se; 924 AioContext *ctx = bdrv_get_aio_context(bs1); 925 926 aio_context_acquire(ctx); 927 if (bdrv_can_snapshot(bs1)) { 928 sn = NULL; 929 bs1_nb_sns = bdrv_snapshot_list(bs1, &sn); 930 if (bs1_nb_sns > 0) { 931 no_snapshot = false; 932 ie = g_new0(ImageEntry, 1); 933 ie->imagename = bdrv_get_device_name(bs1); 934 QTAILQ_INIT(&ie->snapshots); 935 QTAILQ_INSERT_TAIL(&image_list, ie, next); 936 for (i = 0; i < bs1_nb_sns; i++) { 937 se = g_new0(SnapshotEntry, 1); 938 se->sn = sn[i]; 939 QTAILQ_INSERT_TAIL(&ie->snapshots, se, next); 940 } 941 } 942 g_free(sn); 943 } 944 aio_context_release(ctx); 945 } 946 947 if (no_snapshot) { 948 monitor_printf(mon, "There is no snapshot available.\n"); 949 return; 950 } 951 952 global_snapshots = g_new0(int, nb_sns); 953 total = 0; 954 for (i = 0; i < nb_sns; i++) { 955 SnapshotEntry *next_sn; 956 if (bdrv_all_has_snapshot(sn_tab[i].name, false, NULL, NULL) == 1) { 957 global_snapshots[total] = i; 958 total++; 959 QTAILQ_FOREACH(image_entry, &image_list, next) { 960 QTAILQ_FOREACH_SAFE(snapshot_entry, &image_entry->snapshots, 961 next, next_sn) { 962 if (!strcmp(sn_tab[i].name, snapshot_entry->sn.name)) { 963 QTAILQ_REMOVE(&image_entry->snapshots, snapshot_entry, 964 next); 965 g_free(snapshot_entry); 966 } 967 } 968 } 969 } 970 } 971 monitor_printf(mon, "List of snapshots present on all disks:\n"); 972 973 if (total > 0) { 974 bdrv_snapshot_dump(NULL); 975 monitor_printf(mon, "\n"); 976 for (i = 0; i < total; i++) { 977 sn = &sn_tab[global_snapshots[i]]; 978 /* 979 * The ID is not guaranteed to be the same on all images, so 980 * overwrite it. 981 */ 982 pstrcpy(sn->id_str, sizeof(sn->id_str), "--"); 983 bdrv_snapshot_dump(sn); 984 monitor_printf(mon, "\n"); 985 } 986 } else { 987 monitor_printf(mon, "None\n"); 988 } 989 990 QTAILQ_FOREACH(image_entry, &image_list, next) { 991 if (QTAILQ_EMPTY(&image_entry->snapshots)) { 992 continue; 993 } 994 monitor_printf(mon, 995 "\nList of partial (non-loadable) snapshots on '%s':\n", 996 image_entry->imagename); 997 bdrv_snapshot_dump(NULL); 998 monitor_printf(mon, "\n"); 999 QTAILQ_FOREACH(snapshot_entry, &image_entry->snapshots, next) { 1000 bdrv_snapshot_dump(&snapshot_entry->sn); 1001 monitor_printf(mon, "\n"); 1002 } 1003 } 1004 1005 QTAILQ_FOREACH_SAFE(image_entry, &image_list, next, next_ie) { 1006 SnapshotEntry *next_sn; 1007 QTAILQ_FOREACH_SAFE(snapshot_entry, &image_entry->snapshots, next, 1008 next_sn) { 1009 g_free(snapshot_entry); 1010 } 1011 g_free(image_entry); 1012 } 1013 g_free(sn_tab); 1014 g_free(global_snapshots); 1015 } 1016 1017 void hmp_change_medium(Monitor *mon, const char *device, const char *target, 1018 const char *arg, const char *read_only, bool force, 1019 Error **errp) 1020 { 1021 ERRP_GUARD(); 1022 BlockdevChangeReadOnlyMode read_only_mode = 0; 1023 1024 if (read_only) { 1025 read_only_mode = 1026 qapi_enum_parse(&BlockdevChangeReadOnlyMode_lookup, 1027 read_only, 1028 BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN, errp); 1029 if (*errp) { 1030 return; 1031 } 1032 } 1033 1034 qmp_blockdev_change_medium(device, NULL, target, arg, true, force, 1035 !!read_only, read_only_mode, errp); 1036 } 1037