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