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