block/monitor/block-hmp-cmds.c

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