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