1 /* 2 * QEMU host block devices 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or 7 * later. See the COPYING file in the top-level directory. 8 * 9 * This file incorporates work covered by the following copyright and 10 * permission notice: 11 * 12 * Copyright (c) 2003-2008 Fabrice Bellard 13 * 14 * Permission is hereby granted, free of charge, to any person obtaining a copy 15 * of this software and associated documentation files (the "Software"), to deal 16 * in the Software without restriction, including without limitation the rights 17 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 18 * copies of the Software, and to permit persons to whom the Software is 19 * furnished to do so, subject to the following conditions: 20 * 21 * The above copyright notice and this permission notice shall be included in 22 * all copies or substantial portions of the Software. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 27 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 29 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 30 * THE SOFTWARE. 31 */ 32 33 #include "qemu/osdep.h" 34 #include "sysemu/block-backend.h" 35 #include "sysemu/blockdev.h" 36 #include "hw/block/block.h" 37 #include "block/blockjob.h" 38 #include "block/qdict.h" 39 #include "block/throttle-groups.h" 40 #include "monitor/monitor.h" 41 #include "qemu/error-report.h" 42 #include "qemu/option.h" 43 #include "qemu/qemu-print.h" 44 #include "qemu/config-file.h" 45 #include "qapi/qapi-commands-block.h" 46 #include "qapi/qapi-commands-transaction.h" 47 #include "qapi/qapi-visit-block-core.h" 48 #include "qapi/qmp/qdict.h" 49 #include "qapi/qmp/qnum.h" 50 #include "qapi/qmp/qstring.h" 51 #include "qapi/error.h" 52 #include "qapi/qmp/qerror.h" 53 #include "qapi/qmp/qlist.h" 54 #include "qapi/qobject-output-visitor.h" 55 #include "sysemu/sysemu.h" 56 #include "sysemu/iothread.h" 57 #include "block/block_int.h" 58 #include "block/trace.h" 59 #include "sysemu/arch_init.h" 60 #include "sysemu/qtest.h" 61 #include "sysemu/runstate.h" 62 #include "qemu/cutils.h" 63 #include "qemu/help_option.h" 64 #include "qemu/main-loop.h" 65 #include "qemu/throttle-options.h" 66 67 static QTAILQ_HEAD(, BlockDriverState) monitor_bdrv_states = 68 QTAILQ_HEAD_INITIALIZER(monitor_bdrv_states); 69 70 static const char *const if_name[IF_COUNT] = { 71 [IF_NONE] = "none", 72 [IF_IDE] = "ide", 73 [IF_SCSI] = "scsi", 74 [IF_FLOPPY] = "floppy", 75 [IF_PFLASH] = "pflash", 76 [IF_MTD] = "mtd", 77 [IF_SD] = "sd", 78 [IF_VIRTIO] = "virtio", 79 [IF_XEN] = "xen", 80 }; 81 82 static int if_max_devs[IF_COUNT] = { 83 /* 84 * Do not change these numbers! They govern how drive option 85 * index maps to unit and bus. That mapping is ABI. 86 * 87 * All controllers used to implement if=T drives need to support 88 * if_max_devs[T] units, for any T with if_max_devs[T] != 0. 89 * Otherwise, some index values map to "impossible" bus, unit 90 * values. 91 * 92 * For instance, if you change [IF_SCSI] to 255, -drive 93 * if=scsi,index=12 no longer means bus=1,unit=5, but 94 * bus=0,unit=12. With an lsi53c895a controller (7 units max), 95 * the drive can't be set up. Regression. 96 */ 97 [IF_IDE] = 2, 98 [IF_SCSI] = 7, 99 }; 100 101 /** 102 * Boards may call this to offer board-by-board overrides 103 * of the default, global values. 104 */ 105 void override_max_devs(BlockInterfaceType type, int max_devs) 106 { 107 BlockBackend *blk; 108 DriveInfo *dinfo; 109 110 if (max_devs <= 0) { 111 return; 112 } 113 114 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { 115 dinfo = blk_legacy_dinfo(blk); 116 if (dinfo->type == type) { 117 fprintf(stderr, "Cannot override units-per-bus property of" 118 " the %s interface, because a drive of that type has" 119 " already been added.\n", if_name[type]); 120 g_assert_not_reached(); 121 } 122 } 123 124 if_max_devs[type] = max_devs; 125 } 126 127 /* 128 * We automatically delete the drive when a device using it gets 129 * unplugged. Questionable feature, but we can't just drop it. 130 * Device models call blockdev_mark_auto_del() to schedule the 131 * automatic deletion, and generic qdev code calls blockdev_auto_del() 132 * when deletion is actually safe. 133 */ 134 void blockdev_mark_auto_del(BlockBackend *blk) 135 { 136 DriveInfo *dinfo = blk_legacy_dinfo(blk); 137 BlockJob *job; 138 139 if (!dinfo) { 140 return; 141 } 142 143 for (job = block_job_next(NULL); job; job = block_job_next(job)) { 144 if (block_job_has_bdrv(job, blk_bs(blk))) { 145 AioContext *aio_context = job->job.aio_context; 146 aio_context_acquire(aio_context); 147 148 job_cancel(&job->job, false); 149 150 aio_context_release(aio_context); 151 } 152 } 153 154 dinfo->auto_del = 1; 155 } 156 157 void blockdev_auto_del(BlockBackend *blk) 158 { 159 DriveInfo *dinfo = blk_legacy_dinfo(blk); 160 161 if (dinfo && dinfo->auto_del) { 162 monitor_remove_blk(blk); 163 blk_unref(blk); 164 } 165 } 166 167 /** 168 * Returns the current mapping of how many units per bus 169 * a particular interface can support. 170 * 171 * A positive integer indicates n units per bus. 172 * 0 implies the mapping has not been established. 173 * -1 indicates an invalid BlockInterfaceType was given. 174 */ 175 int drive_get_max_devs(BlockInterfaceType type) 176 { 177 if (type >= IF_IDE && type < IF_COUNT) { 178 return if_max_devs[type]; 179 } 180 181 return -1; 182 } 183 184 static int drive_index_to_bus_id(BlockInterfaceType type, int index) 185 { 186 int max_devs = if_max_devs[type]; 187 return max_devs ? index / max_devs : 0; 188 } 189 190 static int drive_index_to_unit_id(BlockInterfaceType type, int index) 191 { 192 int max_devs = if_max_devs[type]; 193 return max_devs ? index % max_devs : index; 194 } 195 196 QemuOpts *drive_def(const char *optstr) 197 { 198 return qemu_opts_parse_noisily(qemu_find_opts("drive"), optstr, false); 199 } 200 201 QemuOpts *drive_add(BlockInterfaceType type, int index, const char *file, 202 const char *optstr) 203 { 204 QemuOpts *opts; 205 206 opts = drive_def(optstr); 207 if (!opts) { 208 return NULL; 209 } 210 if (type != IF_DEFAULT) { 211 qemu_opt_set(opts, "if", if_name[type], &error_abort); 212 } 213 if (index >= 0) { 214 qemu_opt_set_number(opts, "index", index, &error_abort); 215 } 216 if (file) 217 qemu_opt_set(opts, "file", file, &error_abort); 218 return opts; 219 } 220 221 DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit) 222 { 223 BlockBackend *blk; 224 DriveInfo *dinfo; 225 226 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { 227 dinfo = blk_legacy_dinfo(blk); 228 if (dinfo && dinfo->type == type 229 && dinfo->bus == bus && dinfo->unit == unit) { 230 return dinfo; 231 } 232 } 233 234 return NULL; 235 } 236 237 void drive_check_orphaned(void) 238 { 239 BlockBackend *blk; 240 DriveInfo *dinfo; 241 Location loc; 242 bool orphans = false; 243 244 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { 245 dinfo = blk_legacy_dinfo(blk); 246 if (!blk_get_attached_dev(blk) && !dinfo->is_default && 247 dinfo->type != IF_NONE) { 248 loc_push_none(&loc); 249 qemu_opts_loc_restore(dinfo->opts); 250 error_report("machine type does not support" 251 " if=%s,bus=%d,unit=%d", 252 if_name[dinfo->type], dinfo->bus, dinfo->unit); 253 loc_pop(&loc); 254 orphans = true; 255 } 256 } 257 258 if (orphans) { 259 exit(1); 260 } 261 } 262 263 DriveInfo *drive_get_by_index(BlockInterfaceType type, int index) 264 { 265 return drive_get(type, 266 drive_index_to_bus_id(type, index), 267 drive_index_to_unit_id(type, index)); 268 } 269 270 int drive_get_max_bus(BlockInterfaceType type) 271 { 272 int max_bus; 273 BlockBackend *blk; 274 DriveInfo *dinfo; 275 276 max_bus = -1; 277 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { 278 dinfo = blk_legacy_dinfo(blk); 279 if (dinfo && dinfo->type == type && dinfo->bus > max_bus) { 280 max_bus = dinfo->bus; 281 } 282 } 283 return max_bus; 284 } 285 286 /* Get a block device. This should only be used for single-drive devices 287 (e.g. SD/Floppy/MTD). Multi-disk devices (scsi/ide) should use the 288 appropriate bus. */ 289 DriveInfo *drive_get_next(BlockInterfaceType type) 290 { 291 static int next_block_unit[IF_COUNT]; 292 293 return drive_get(type, 0, next_block_unit[type]++); 294 } 295 296 static void bdrv_format_print(void *opaque, const char *name) 297 { 298 qemu_printf(" %s", name); 299 } 300 301 typedef struct { 302 QEMUBH *bh; 303 BlockDriverState *bs; 304 } BDRVPutRefBH; 305 306 static int parse_block_error_action(const char *buf, bool is_read, Error **errp) 307 { 308 if (!strcmp(buf, "ignore")) { 309 return BLOCKDEV_ON_ERROR_IGNORE; 310 } else if (!is_read && !strcmp(buf, "enospc")) { 311 return BLOCKDEV_ON_ERROR_ENOSPC; 312 } else if (!strcmp(buf, "stop")) { 313 return BLOCKDEV_ON_ERROR_STOP; 314 } else if (!strcmp(buf, "report")) { 315 return BLOCKDEV_ON_ERROR_REPORT; 316 } else { 317 error_setg(errp, "'%s' invalid %s error action", 318 buf, is_read ? "read" : "write"); 319 return -1; 320 } 321 } 322 323 static bool parse_stats_intervals(BlockAcctStats *stats, QList *intervals, 324 Error **errp) 325 { 326 const QListEntry *entry; 327 for (entry = qlist_first(intervals); entry; entry = qlist_next(entry)) { 328 switch (qobject_type(entry->value)) { 329 330 case QTYPE_QSTRING: { 331 unsigned long long length; 332 const char *str = qstring_get_str(qobject_to(QString, 333 entry->value)); 334 if (parse_uint_full(str, &length, 10) == 0 && 335 length > 0 && length <= UINT_MAX) { 336 block_acct_add_interval(stats, (unsigned) length); 337 } else { 338 error_setg(errp, "Invalid interval length: %s", str); 339 return false; 340 } 341 break; 342 } 343 344 case QTYPE_QNUM: { 345 int64_t length = qnum_get_int(qobject_to(QNum, entry->value)); 346 347 if (length > 0 && length <= UINT_MAX) { 348 block_acct_add_interval(stats, (unsigned) length); 349 } else { 350 error_setg(errp, "Invalid interval length: %" PRId64, length); 351 return false; 352 } 353 break; 354 } 355 356 default: 357 error_setg(errp, "The specification of stats-intervals is invalid"); 358 return false; 359 } 360 } 361 return true; 362 } 363 364 typedef enum { MEDIA_DISK, MEDIA_CDROM } DriveMediaType; 365 366 /* All parameters but @opts are optional and may be set to NULL. */ 367 static void extract_common_blockdev_options(QemuOpts *opts, int *bdrv_flags, 368 const char **throttling_group, ThrottleConfig *throttle_cfg, 369 BlockdevDetectZeroesOptions *detect_zeroes, Error **errp) 370 { 371 Error *local_error = NULL; 372 const char *aio; 373 374 if (bdrv_flags) { 375 if (qemu_opt_get_bool(opts, "copy-on-read", false)) { 376 *bdrv_flags |= BDRV_O_COPY_ON_READ; 377 } 378 379 if ((aio = qemu_opt_get(opts, "aio")) != NULL) { 380 if (bdrv_parse_aio(aio, bdrv_flags) < 0) { 381 error_setg(errp, "invalid aio option"); 382 return; 383 } 384 } 385 } 386 387 /* disk I/O throttling */ 388 if (throttling_group) { 389 *throttling_group = qemu_opt_get(opts, "throttling.group"); 390 } 391 392 if (throttle_cfg) { 393 throttle_config_init(throttle_cfg); 394 throttle_cfg->buckets[THROTTLE_BPS_TOTAL].avg = 395 qemu_opt_get_number(opts, "throttling.bps-total", 0); 396 throttle_cfg->buckets[THROTTLE_BPS_READ].avg = 397 qemu_opt_get_number(opts, "throttling.bps-read", 0); 398 throttle_cfg->buckets[THROTTLE_BPS_WRITE].avg = 399 qemu_opt_get_number(opts, "throttling.bps-write", 0); 400 throttle_cfg->buckets[THROTTLE_OPS_TOTAL].avg = 401 qemu_opt_get_number(opts, "throttling.iops-total", 0); 402 throttle_cfg->buckets[THROTTLE_OPS_READ].avg = 403 qemu_opt_get_number(opts, "throttling.iops-read", 0); 404 throttle_cfg->buckets[THROTTLE_OPS_WRITE].avg = 405 qemu_opt_get_number(opts, "throttling.iops-write", 0); 406 407 throttle_cfg->buckets[THROTTLE_BPS_TOTAL].max = 408 qemu_opt_get_number(opts, "throttling.bps-total-max", 0); 409 throttle_cfg->buckets[THROTTLE_BPS_READ].max = 410 qemu_opt_get_number(opts, "throttling.bps-read-max", 0); 411 throttle_cfg->buckets[THROTTLE_BPS_WRITE].max = 412 qemu_opt_get_number(opts, "throttling.bps-write-max", 0); 413 throttle_cfg->buckets[THROTTLE_OPS_TOTAL].max = 414 qemu_opt_get_number(opts, "throttling.iops-total-max", 0); 415 throttle_cfg->buckets[THROTTLE_OPS_READ].max = 416 qemu_opt_get_number(opts, "throttling.iops-read-max", 0); 417 throttle_cfg->buckets[THROTTLE_OPS_WRITE].max = 418 qemu_opt_get_number(opts, "throttling.iops-write-max", 0); 419 420 throttle_cfg->buckets[THROTTLE_BPS_TOTAL].burst_length = 421 qemu_opt_get_number(opts, "throttling.bps-total-max-length", 1); 422 throttle_cfg->buckets[THROTTLE_BPS_READ].burst_length = 423 qemu_opt_get_number(opts, "throttling.bps-read-max-length", 1); 424 throttle_cfg->buckets[THROTTLE_BPS_WRITE].burst_length = 425 qemu_opt_get_number(opts, "throttling.bps-write-max-length", 1); 426 throttle_cfg->buckets[THROTTLE_OPS_TOTAL].burst_length = 427 qemu_opt_get_number(opts, "throttling.iops-total-max-length", 1); 428 throttle_cfg->buckets[THROTTLE_OPS_READ].burst_length = 429 qemu_opt_get_number(opts, "throttling.iops-read-max-length", 1); 430 throttle_cfg->buckets[THROTTLE_OPS_WRITE].burst_length = 431 qemu_opt_get_number(opts, "throttling.iops-write-max-length", 1); 432 433 throttle_cfg->op_size = 434 qemu_opt_get_number(opts, "throttling.iops-size", 0); 435 436 if (!throttle_is_valid(throttle_cfg, errp)) { 437 return; 438 } 439 } 440 441 if (detect_zeroes) { 442 *detect_zeroes = 443 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup, 444 qemu_opt_get(opts, "detect-zeroes"), 445 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF, 446 &local_error); 447 if (local_error) { 448 error_propagate(errp, local_error); 449 return; 450 } 451 } 452 } 453 454 /* Takes the ownership of bs_opts */ 455 static BlockBackend *blockdev_init(const char *file, QDict *bs_opts, 456 Error **errp) 457 { 458 const char *buf; 459 int bdrv_flags = 0; 460 int on_read_error, on_write_error; 461 bool account_invalid, account_failed; 462 bool writethrough, read_only; 463 BlockBackend *blk; 464 BlockDriverState *bs; 465 ThrottleConfig cfg; 466 int snapshot = 0; 467 Error *error = NULL; 468 QemuOpts *opts; 469 QDict *interval_dict = NULL; 470 QList *interval_list = NULL; 471 const char *id; 472 BlockdevDetectZeroesOptions detect_zeroes = 473 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF; 474 const char *throttling_group = NULL; 475 476 /* Check common options by copying from bs_opts to opts, all other options 477 * stay in bs_opts for processing by bdrv_open(). */ 478 id = qdict_get_try_str(bs_opts, "id"); 479 opts = qemu_opts_create(&qemu_common_drive_opts, id, 1, &error); 480 if (error) { 481 error_propagate(errp, error); 482 goto err_no_opts; 483 } 484 485 qemu_opts_absorb_qdict(opts, bs_opts, &error); 486 if (error) { 487 error_propagate(errp, error); 488 goto early_err; 489 } 490 491 if (id) { 492 qdict_del(bs_opts, "id"); 493 } 494 495 /* extract parameters */ 496 snapshot = qemu_opt_get_bool(opts, "snapshot", 0); 497 498 account_invalid = qemu_opt_get_bool(opts, "stats-account-invalid", true); 499 account_failed = qemu_opt_get_bool(opts, "stats-account-failed", true); 500 501 writethrough = !qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, true); 502 503 id = qemu_opts_id(opts); 504 505 qdict_extract_subqdict(bs_opts, &interval_dict, "stats-intervals."); 506 qdict_array_split(interval_dict, &interval_list); 507 508 if (qdict_size(interval_dict) != 0) { 509 error_setg(errp, "Invalid option stats-intervals.%s", 510 qdict_first(interval_dict)->key); 511 goto early_err; 512 } 513 514 extract_common_blockdev_options(opts, &bdrv_flags, &throttling_group, &cfg, 515 &detect_zeroes, &error); 516 if (error) { 517 error_propagate(errp, error); 518 goto early_err; 519 } 520 521 if ((buf = qemu_opt_get(opts, "format")) != NULL) { 522 if (is_help_option(buf)) { 523 qemu_printf("Supported formats:"); 524 bdrv_iterate_format(bdrv_format_print, NULL, false); 525 qemu_printf("\nSupported formats (read-only):"); 526 bdrv_iterate_format(bdrv_format_print, NULL, true); 527 qemu_printf("\n"); 528 goto early_err; 529 } 530 531 if (qdict_haskey(bs_opts, "driver")) { 532 error_setg(errp, "Cannot specify both 'driver' and 'format'"); 533 goto early_err; 534 } 535 qdict_put_str(bs_opts, "driver", buf); 536 } 537 538 on_write_error = BLOCKDEV_ON_ERROR_ENOSPC; 539 if ((buf = qemu_opt_get(opts, "werror")) != NULL) { 540 on_write_error = parse_block_error_action(buf, 0, &error); 541 if (error) { 542 error_propagate(errp, error); 543 goto early_err; 544 } 545 } 546 547 on_read_error = BLOCKDEV_ON_ERROR_REPORT; 548 if ((buf = qemu_opt_get(opts, "rerror")) != NULL) { 549 on_read_error = parse_block_error_action(buf, 1, &error); 550 if (error) { 551 error_propagate(errp, error); 552 goto early_err; 553 } 554 } 555 556 if (snapshot) { 557 bdrv_flags |= BDRV_O_SNAPSHOT; 558 } 559 560 read_only = qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false); 561 562 /* init */ 563 if ((!file || !*file) && !qdict_size(bs_opts)) { 564 BlockBackendRootState *blk_rs; 565 566 blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL); 567 blk_rs = blk_get_root_state(blk); 568 blk_rs->open_flags = bdrv_flags; 569 blk_rs->read_only = read_only; 570 blk_rs->detect_zeroes = detect_zeroes; 571 572 qobject_unref(bs_opts); 573 } else { 574 if (file && !*file) { 575 file = NULL; 576 } 577 578 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility 579 * with other callers) rather than what we want as the real defaults. 580 * Apply the defaults here instead. */ 581 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off"); 582 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off"); 583 qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY, 584 read_only ? "on" : "off"); 585 qdict_set_default_str(bs_opts, BDRV_OPT_AUTO_READ_ONLY, "on"); 586 assert((bdrv_flags & BDRV_O_CACHE_MASK) == 0); 587 588 if (runstate_check(RUN_STATE_INMIGRATE)) { 589 bdrv_flags |= BDRV_O_INACTIVE; 590 } 591 592 blk = blk_new_open(file, NULL, bs_opts, bdrv_flags, errp); 593 if (!blk) { 594 goto err_no_bs_opts; 595 } 596 bs = blk_bs(blk); 597 598 bs->detect_zeroes = detect_zeroes; 599 600 block_acct_setup(blk_get_stats(blk), account_invalid, account_failed); 601 602 if (!parse_stats_intervals(blk_get_stats(blk), interval_list, errp)) { 603 blk_unref(blk); 604 blk = NULL; 605 goto err_no_bs_opts; 606 } 607 } 608 609 /* disk I/O throttling */ 610 if (throttle_enabled(&cfg)) { 611 if (!throttling_group) { 612 throttling_group = id; 613 } 614 blk_io_limits_enable(blk, throttling_group); 615 blk_set_io_limits(blk, &cfg); 616 } 617 618 blk_set_enable_write_cache(blk, !writethrough); 619 blk_set_on_error(blk, on_read_error, on_write_error); 620 621 if (!monitor_add_blk(blk, id, errp)) { 622 blk_unref(blk); 623 blk = NULL; 624 goto err_no_bs_opts; 625 } 626 627 err_no_bs_opts: 628 qemu_opts_del(opts); 629 qobject_unref(interval_dict); 630 qobject_unref(interval_list); 631 return blk; 632 633 early_err: 634 qemu_opts_del(opts); 635 qobject_unref(interval_dict); 636 qobject_unref(interval_list); 637 err_no_opts: 638 qobject_unref(bs_opts); 639 return NULL; 640 } 641 642 /* Takes the ownership of bs_opts */ 643 static BlockDriverState *bds_tree_init(QDict *bs_opts, Error **errp) 644 { 645 int bdrv_flags = 0; 646 647 /* bdrv_open() defaults to the values in bdrv_flags (for compatibility 648 * with other callers) rather than what we want as the real defaults. 649 * Apply the defaults here instead. */ 650 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_DIRECT, "off"); 651 qdict_set_default_str(bs_opts, BDRV_OPT_CACHE_NO_FLUSH, "off"); 652 qdict_set_default_str(bs_opts, BDRV_OPT_READ_ONLY, "off"); 653 654 if (runstate_check(RUN_STATE_INMIGRATE)) { 655 bdrv_flags |= BDRV_O_INACTIVE; 656 } 657 658 return bdrv_open(NULL, NULL, bs_opts, bdrv_flags, errp); 659 } 660 661 void blockdev_close_all_bdrv_states(void) 662 { 663 BlockDriverState *bs, *next_bs; 664 665 QTAILQ_FOREACH_SAFE(bs, &monitor_bdrv_states, monitor_list, next_bs) { 666 AioContext *ctx = bdrv_get_aio_context(bs); 667 668 aio_context_acquire(ctx); 669 bdrv_unref(bs); 670 aio_context_release(ctx); 671 } 672 } 673 674 /* Iterates over the list of monitor-owned BlockDriverStates */ 675 BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs) 676 { 677 return bs ? QTAILQ_NEXT(bs, monitor_list) 678 : QTAILQ_FIRST(&monitor_bdrv_states); 679 } 680 681 static void qemu_opt_rename(QemuOpts *opts, const char *from, const char *to, 682 Error **errp) 683 { 684 const char *value; 685 686 value = qemu_opt_get(opts, from); 687 if (value) { 688 if (qemu_opt_find(opts, to)) { 689 error_setg(errp, "'%s' and its alias '%s' can't be used at the " 690 "same time", to, from); 691 return; 692 } 693 } 694 695 /* rename all items in opts */ 696 while ((value = qemu_opt_get(opts, from))) { 697 qemu_opt_set(opts, to, value, &error_abort); 698 qemu_opt_unset(opts, from); 699 } 700 } 701 702 QemuOptsList qemu_legacy_drive_opts = { 703 .name = "drive", 704 .head = QTAILQ_HEAD_INITIALIZER(qemu_legacy_drive_opts.head), 705 .desc = { 706 { 707 .name = "bus", 708 .type = QEMU_OPT_NUMBER, 709 .help = "bus number", 710 },{ 711 .name = "unit", 712 .type = QEMU_OPT_NUMBER, 713 .help = "unit number (i.e. lun for scsi)", 714 },{ 715 .name = "index", 716 .type = QEMU_OPT_NUMBER, 717 .help = "index number", 718 },{ 719 .name = "media", 720 .type = QEMU_OPT_STRING, 721 .help = "media type (disk, cdrom)", 722 },{ 723 .name = "if", 724 .type = QEMU_OPT_STRING, 725 .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)", 726 },{ 727 .name = "file", 728 .type = QEMU_OPT_STRING, 729 .help = "file name", 730 }, 731 732 /* Options that are passed on, but have special semantics with -drive */ 733 { 734 .name = BDRV_OPT_READ_ONLY, 735 .type = QEMU_OPT_BOOL, 736 .help = "open drive file as read-only", 737 },{ 738 .name = "rerror", 739 .type = QEMU_OPT_STRING, 740 .help = "read error action", 741 },{ 742 .name = "werror", 743 .type = QEMU_OPT_STRING, 744 .help = "write error action", 745 },{ 746 .name = "copy-on-read", 747 .type = QEMU_OPT_BOOL, 748 .help = "copy read data from backing file into image file", 749 }, 750 751 { /* end of list */ } 752 }, 753 }; 754 755 DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type, 756 Error **errp) 757 { 758 const char *value; 759 BlockBackend *blk; 760 DriveInfo *dinfo = NULL; 761 QDict *bs_opts; 762 QemuOpts *legacy_opts; 763 DriveMediaType media = MEDIA_DISK; 764 BlockInterfaceType type; 765 int max_devs, bus_id, unit_id, index; 766 const char *werror, *rerror; 767 bool read_only = false; 768 bool copy_on_read; 769 const char *filename; 770 Error *local_err = NULL; 771 int i; 772 773 /* Change legacy command line options into QMP ones */ 774 static const struct { 775 const char *from; 776 const char *to; 777 } opt_renames[] = { 778 { "iops", "throttling.iops-total" }, 779 { "iops_rd", "throttling.iops-read" }, 780 { "iops_wr", "throttling.iops-write" }, 781 782 { "bps", "throttling.bps-total" }, 783 { "bps_rd", "throttling.bps-read" }, 784 { "bps_wr", "throttling.bps-write" }, 785 786 { "iops_max", "throttling.iops-total-max" }, 787 { "iops_rd_max", "throttling.iops-read-max" }, 788 { "iops_wr_max", "throttling.iops-write-max" }, 789 790 { "bps_max", "throttling.bps-total-max" }, 791 { "bps_rd_max", "throttling.bps-read-max" }, 792 { "bps_wr_max", "throttling.bps-write-max" }, 793 794 { "iops_size", "throttling.iops-size" }, 795 796 { "group", "throttling.group" }, 797 798 { "readonly", BDRV_OPT_READ_ONLY }, 799 }; 800 801 for (i = 0; i < ARRAY_SIZE(opt_renames); i++) { 802 qemu_opt_rename(all_opts, opt_renames[i].from, opt_renames[i].to, 803 &local_err); 804 if (local_err) { 805 error_propagate(errp, local_err); 806 return NULL; 807 } 808 } 809 810 value = qemu_opt_get(all_opts, "cache"); 811 if (value) { 812 int flags = 0; 813 bool writethrough; 814 815 if (bdrv_parse_cache_mode(value, &flags, &writethrough) != 0) { 816 error_setg(errp, "invalid cache option"); 817 return NULL; 818 } 819 820 /* Specific options take precedence */ 821 if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_WB)) { 822 qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_WB, 823 !writethrough, &error_abort); 824 } 825 if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_DIRECT)) { 826 qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_DIRECT, 827 !!(flags & BDRV_O_NOCACHE), &error_abort); 828 } 829 if (!qemu_opt_get(all_opts, BDRV_OPT_CACHE_NO_FLUSH)) { 830 qemu_opt_set_bool(all_opts, BDRV_OPT_CACHE_NO_FLUSH, 831 !!(flags & BDRV_O_NO_FLUSH), &error_abort); 832 } 833 qemu_opt_unset(all_opts, "cache"); 834 } 835 836 /* Get a QDict for processing the options */ 837 bs_opts = qdict_new(); 838 qemu_opts_to_qdict(all_opts, bs_opts); 839 840 legacy_opts = qemu_opts_create(&qemu_legacy_drive_opts, NULL, 0, 841 &error_abort); 842 qemu_opts_absorb_qdict(legacy_opts, bs_opts, &local_err); 843 if (local_err) { 844 error_propagate(errp, local_err); 845 goto fail; 846 } 847 848 /* Media type */ 849 value = qemu_opt_get(legacy_opts, "media"); 850 if (value) { 851 if (!strcmp(value, "disk")) { 852 media = MEDIA_DISK; 853 } else if (!strcmp(value, "cdrom")) { 854 media = MEDIA_CDROM; 855 read_only = true; 856 } else { 857 error_setg(errp, "'%s' invalid media", value); 858 goto fail; 859 } 860 } 861 862 /* copy-on-read is disabled with a warning for read-only devices */ 863 read_only |= qemu_opt_get_bool(legacy_opts, BDRV_OPT_READ_ONLY, false); 864 copy_on_read = qemu_opt_get_bool(legacy_opts, "copy-on-read", false); 865 866 if (read_only && copy_on_read) { 867 warn_report("disabling copy-on-read on read-only drive"); 868 copy_on_read = false; 869 } 870 871 qdict_put_str(bs_opts, BDRV_OPT_READ_ONLY, read_only ? "on" : "off"); 872 qdict_put_str(bs_opts, "copy-on-read", copy_on_read ? "on" : "off"); 873 874 /* Controller type */ 875 value = qemu_opt_get(legacy_opts, "if"); 876 if (value) { 877 for (type = 0; 878 type < IF_COUNT && strcmp(value, if_name[type]); 879 type++) { 880 } 881 if (type == IF_COUNT) { 882 error_setg(errp, "unsupported bus type '%s'", value); 883 goto fail; 884 } 885 } else { 886 type = block_default_type; 887 } 888 889 /* Device address specified by bus/unit or index. 890 * If none was specified, try to find the first free one. */ 891 bus_id = qemu_opt_get_number(legacy_opts, "bus", 0); 892 unit_id = qemu_opt_get_number(legacy_opts, "unit", -1); 893 index = qemu_opt_get_number(legacy_opts, "index", -1); 894 895 max_devs = if_max_devs[type]; 896 897 if (index != -1) { 898 if (bus_id != 0 || unit_id != -1) { 899 error_setg(errp, "index cannot be used with bus and unit"); 900 goto fail; 901 } 902 bus_id = drive_index_to_bus_id(type, index); 903 unit_id = drive_index_to_unit_id(type, index); 904 } 905 906 if (unit_id == -1) { 907 unit_id = 0; 908 while (drive_get(type, bus_id, unit_id) != NULL) { 909 unit_id++; 910 if (max_devs && unit_id >= max_devs) { 911 unit_id -= max_devs; 912 bus_id++; 913 } 914 } 915 } 916 917 if (max_devs && unit_id >= max_devs) { 918 error_setg(errp, "unit %d too big (max is %d)", unit_id, max_devs - 1); 919 goto fail; 920 } 921 922 if (drive_get(type, bus_id, unit_id) != NULL) { 923 error_setg(errp, "drive with bus=%d, unit=%d (index=%d) exists", 924 bus_id, unit_id, index); 925 goto fail; 926 } 927 928 /* no id supplied -> create one */ 929 if (qemu_opts_id(all_opts) == NULL) { 930 char *new_id; 931 const char *mediastr = ""; 932 if (type == IF_IDE || type == IF_SCSI) { 933 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd"; 934 } 935 if (max_devs) { 936 new_id = g_strdup_printf("%s%i%s%i", if_name[type], bus_id, 937 mediastr, unit_id); 938 } else { 939 new_id = g_strdup_printf("%s%s%i", if_name[type], 940 mediastr, unit_id); 941 } 942 qdict_put_str(bs_opts, "id", new_id); 943 g_free(new_id); 944 } 945 946 /* Add virtio block device */ 947 if (type == IF_VIRTIO) { 948 QemuOpts *devopts; 949 devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0, 950 &error_abort); 951 if (arch_type == QEMU_ARCH_S390X) { 952 qemu_opt_set(devopts, "driver", "virtio-blk-ccw", &error_abort); 953 } else { 954 qemu_opt_set(devopts, "driver", "virtio-blk-pci", &error_abort); 955 } 956 qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"), 957 &error_abort); 958 } 959 960 filename = qemu_opt_get(legacy_opts, "file"); 961 962 /* Check werror/rerror compatibility with if=... */ 963 werror = qemu_opt_get(legacy_opts, "werror"); 964 if (werror != NULL) { 965 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO && 966 type != IF_NONE) { 967 error_setg(errp, "werror is not supported by this bus type"); 968 goto fail; 969 } 970 qdict_put_str(bs_opts, "werror", werror); 971 } 972 973 rerror = qemu_opt_get(legacy_opts, "rerror"); 974 if (rerror != NULL) { 975 if (type != IF_IDE && type != IF_VIRTIO && type != IF_SCSI && 976 type != IF_NONE) { 977 error_setg(errp, "rerror is not supported by this bus type"); 978 goto fail; 979 } 980 qdict_put_str(bs_opts, "rerror", rerror); 981 } 982 983 /* Actual block device init: Functionality shared with blockdev-add */ 984 blk = blockdev_init(filename, bs_opts, &local_err); 985 bs_opts = NULL; 986 if (!blk) { 987 error_propagate(errp, local_err); 988 goto fail; 989 } else { 990 assert(!local_err); 991 } 992 993 /* Create legacy DriveInfo */ 994 dinfo = g_malloc0(sizeof(*dinfo)); 995 dinfo->opts = all_opts; 996 997 dinfo->type = type; 998 dinfo->bus = bus_id; 999 dinfo->unit = unit_id; 1000 1001 blk_set_legacy_dinfo(blk, dinfo); 1002 1003 switch(type) { 1004 case IF_IDE: 1005 case IF_SCSI: 1006 case IF_XEN: 1007 case IF_NONE: 1008 dinfo->media_cd = media == MEDIA_CDROM; 1009 break; 1010 default: 1011 break; 1012 } 1013 1014 fail: 1015 qemu_opts_del(legacy_opts); 1016 qobject_unref(bs_opts); 1017 return dinfo; 1018 } 1019 1020 static BlockDriverState *qmp_get_root_bs(const char *name, Error **errp) 1021 { 1022 BlockDriverState *bs; 1023 1024 bs = bdrv_lookup_bs(name, name, errp); 1025 if (bs == NULL) { 1026 return NULL; 1027 } 1028 1029 if (!bdrv_is_root_node(bs)) { 1030 error_setg(errp, "Need a root block node"); 1031 return NULL; 1032 } 1033 1034 if (!bdrv_is_inserted(bs)) { 1035 error_setg(errp, "Device has no medium"); 1036 return NULL; 1037 } 1038 1039 return bs; 1040 } 1041 1042 void hmp_commit(Monitor *mon, const QDict *qdict) 1043 { 1044 const char *device = qdict_get_str(qdict, "device"); 1045 BlockBackend *blk; 1046 int ret; 1047 1048 if (!strcmp(device, "all")) { 1049 ret = blk_commit_all(); 1050 } else { 1051 BlockDriverState *bs; 1052 AioContext *aio_context; 1053 1054 blk = blk_by_name(device); 1055 if (!blk) { 1056 error_report("Device '%s' not found", device); 1057 return; 1058 } 1059 if (!blk_is_available(blk)) { 1060 error_report("Device '%s' has no medium", device); 1061 return; 1062 } 1063 1064 bs = blk_bs(blk); 1065 aio_context = bdrv_get_aio_context(bs); 1066 aio_context_acquire(aio_context); 1067 1068 ret = bdrv_commit(bs); 1069 1070 aio_context_release(aio_context); 1071 } 1072 if (ret < 0) { 1073 error_report("'commit' error for '%s': %s", device, strerror(-ret)); 1074 } 1075 } 1076 1077 static void blockdev_do_action(TransactionAction *action, Error **errp) 1078 { 1079 TransactionActionList list; 1080 1081 list.value = action; 1082 list.next = NULL; 1083 qmp_transaction(&list, false, NULL, errp); 1084 } 1085 1086 void qmp_blockdev_snapshot_sync(bool has_device, const char *device, 1087 bool has_node_name, const char *node_name, 1088 const char *snapshot_file, 1089 bool has_snapshot_node_name, 1090 const char *snapshot_node_name, 1091 bool has_format, const char *format, 1092 bool has_mode, NewImageMode mode, Error **errp) 1093 { 1094 BlockdevSnapshotSync snapshot = { 1095 .has_device = has_device, 1096 .device = (char *) device, 1097 .has_node_name = has_node_name, 1098 .node_name = (char *) node_name, 1099 .snapshot_file = (char *) snapshot_file, 1100 .has_snapshot_node_name = has_snapshot_node_name, 1101 .snapshot_node_name = (char *) snapshot_node_name, 1102 .has_format = has_format, 1103 .format = (char *) format, 1104 .has_mode = has_mode, 1105 .mode = mode, 1106 }; 1107 TransactionAction action = { 1108 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC, 1109 .u.blockdev_snapshot_sync.data = &snapshot, 1110 }; 1111 blockdev_do_action(&action, errp); 1112 } 1113 1114 void qmp_blockdev_snapshot(const char *node, const char *overlay, 1115 Error **errp) 1116 { 1117 BlockdevSnapshot snapshot_data = { 1118 .node = (char *) node, 1119 .overlay = (char *) overlay 1120 }; 1121 TransactionAction action = { 1122 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT, 1123 .u.blockdev_snapshot.data = &snapshot_data, 1124 }; 1125 blockdev_do_action(&action, errp); 1126 } 1127 1128 void qmp_blockdev_snapshot_internal_sync(const char *device, 1129 const char *name, 1130 Error **errp) 1131 { 1132 BlockdevSnapshotInternal snapshot = { 1133 .device = (char *) device, 1134 .name = (char *) name 1135 }; 1136 TransactionAction action = { 1137 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC, 1138 .u.blockdev_snapshot_internal_sync.data = &snapshot, 1139 }; 1140 blockdev_do_action(&action, errp); 1141 } 1142 1143 SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device, 1144 bool has_id, 1145 const char *id, 1146 bool has_name, 1147 const char *name, 1148 Error **errp) 1149 { 1150 BlockDriverState *bs; 1151 AioContext *aio_context; 1152 QEMUSnapshotInfo sn; 1153 Error *local_err = NULL; 1154 SnapshotInfo *info = NULL; 1155 int ret; 1156 1157 bs = qmp_get_root_bs(device, errp); 1158 if (!bs) { 1159 return NULL; 1160 } 1161 aio_context = bdrv_get_aio_context(bs); 1162 aio_context_acquire(aio_context); 1163 1164 if (!has_id) { 1165 id = NULL; 1166 } 1167 1168 if (!has_name) { 1169 name = NULL; 1170 } 1171 1172 if (!id && !name) { 1173 error_setg(errp, "Name or id must be provided"); 1174 goto out_aio_context; 1175 } 1176 1177 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT_DELETE, errp)) { 1178 goto out_aio_context; 1179 } 1180 1181 ret = bdrv_snapshot_find_by_id_and_name(bs, id, name, &sn, &local_err); 1182 if (local_err) { 1183 error_propagate(errp, local_err); 1184 goto out_aio_context; 1185 } 1186 if (!ret) { 1187 error_setg(errp, 1188 "Snapshot with id '%s' and name '%s' does not exist on " 1189 "device '%s'", 1190 STR_OR_NULL(id), STR_OR_NULL(name), device); 1191 goto out_aio_context; 1192 } 1193 1194 bdrv_snapshot_delete(bs, id, name, &local_err); 1195 if (local_err) { 1196 error_propagate(errp, local_err); 1197 goto out_aio_context; 1198 } 1199 1200 aio_context_release(aio_context); 1201 1202 info = g_new0(SnapshotInfo, 1); 1203 info->id = g_strdup(sn.id_str); 1204 info->name = g_strdup(sn.name); 1205 info->date_nsec = sn.date_nsec; 1206 info->date_sec = sn.date_sec; 1207 info->vm_state_size = sn.vm_state_size; 1208 info->vm_clock_nsec = sn.vm_clock_nsec % 1000000000; 1209 info->vm_clock_sec = sn.vm_clock_nsec / 1000000000; 1210 1211 return info; 1212 1213 out_aio_context: 1214 aio_context_release(aio_context); 1215 return NULL; 1216 } 1217 1218 /** 1219 * block_dirty_bitmap_lookup: 1220 * Return a dirty bitmap (if present), after validating 1221 * the node reference and bitmap names. 1222 * 1223 * @node: The name of the BDS node to search for bitmaps 1224 * @name: The name of the bitmap to search for 1225 * @pbs: Output pointer for BDS lookup, if desired. Can be NULL. 1226 * @errp: Output pointer for error information. Can be NULL. 1227 * 1228 * @return: A bitmap object on success, or NULL on failure. 1229 */ 1230 static BdrvDirtyBitmap *block_dirty_bitmap_lookup(const char *node, 1231 const char *name, 1232 BlockDriverState **pbs, 1233 Error **errp) 1234 { 1235 BlockDriverState *bs; 1236 BdrvDirtyBitmap *bitmap; 1237 1238 if (!node) { 1239 error_setg(errp, "Node cannot be NULL"); 1240 return NULL; 1241 } 1242 if (!name) { 1243 error_setg(errp, "Bitmap name cannot be NULL"); 1244 return NULL; 1245 } 1246 bs = bdrv_lookup_bs(node, node, NULL); 1247 if (!bs) { 1248 error_setg(errp, "Node '%s' not found", node); 1249 return NULL; 1250 } 1251 1252 bitmap = bdrv_find_dirty_bitmap(bs, name); 1253 if (!bitmap) { 1254 error_setg(errp, "Dirty bitmap '%s' not found", name); 1255 return NULL; 1256 } 1257 1258 if (pbs) { 1259 *pbs = bs; 1260 } 1261 1262 return bitmap; 1263 } 1264 1265 /* New and old BlockDriverState structs for atomic group operations */ 1266 1267 typedef struct BlkActionState BlkActionState; 1268 1269 /** 1270 * BlkActionOps: 1271 * Table of operations that define an Action. 1272 * 1273 * @instance_size: Size of state struct, in bytes. 1274 * @prepare: Prepare the work, must NOT be NULL. 1275 * @commit: Commit the changes, can be NULL. 1276 * @abort: Abort the changes on fail, can be NULL. 1277 * @clean: Clean up resources after all transaction actions have called 1278 * commit() or abort(). Can be NULL. 1279 * 1280 * Only prepare() may fail. In a single transaction, only one of commit() or 1281 * abort() will be called. clean() will always be called if it is present. 1282 */ 1283 typedef struct BlkActionOps { 1284 size_t instance_size; 1285 void (*prepare)(BlkActionState *common, Error **errp); 1286 void (*commit)(BlkActionState *common); 1287 void (*abort)(BlkActionState *common); 1288 void (*clean)(BlkActionState *common); 1289 } BlkActionOps; 1290 1291 /** 1292 * BlkActionState: 1293 * Describes one Action's state within a Transaction. 1294 * 1295 * @action: QAPI-defined enum identifying which Action to perform. 1296 * @ops: Table of ActionOps this Action can perform. 1297 * @block_job_txn: Transaction which this action belongs to. 1298 * @entry: List membership for all Actions in this Transaction. 1299 * 1300 * This structure must be arranged as first member in a subclassed type, 1301 * assuming that the compiler will also arrange it to the same offsets as the 1302 * base class. 1303 */ 1304 struct BlkActionState { 1305 TransactionAction *action; 1306 const BlkActionOps *ops; 1307 JobTxn *block_job_txn; 1308 TransactionProperties *txn_props; 1309 QTAILQ_ENTRY(BlkActionState) entry; 1310 }; 1311 1312 /* internal snapshot private data */ 1313 typedef struct InternalSnapshotState { 1314 BlkActionState common; 1315 BlockDriverState *bs; 1316 QEMUSnapshotInfo sn; 1317 bool created; 1318 } InternalSnapshotState; 1319 1320 1321 static int action_check_completion_mode(BlkActionState *s, Error **errp) 1322 { 1323 if (s->txn_props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) { 1324 error_setg(errp, 1325 "Action '%s' does not support Transaction property " 1326 "completion-mode = %s", 1327 TransactionActionKind_str(s->action->type), 1328 ActionCompletionMode_str(s->txn_props->completion_mode)); 1329 return -1; 1330 } 1331 return 0; 1332 } 1333 1334 static void internal_snapshot_prepare(BlkActionState *common, 1335 Error **errp) 1336 { 1337 Error *local_err = NULL; 1338 const char *device; 1339 const char *name; 1340 BlockDriverState *bs; 1341 QEMUSnapshotInfo old_sn, *sn; 1342 bool ret; 1343 qemu_timeval tv; 1344 BlockdevSnapshotInternal *internal; 1345 InternalSnapshotState *state; 1346 AioContext *aio_context; 1347 int ret1; 1348 1349 g_assert(common->action->type == 1350 TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC); 1351 internal = common->action->u.blockdev_snapshot_internal_sync.data; 1352 state = DO_UPCAST(InternalSnapshotState, common, common); 1353 1354 /* 1. parse input */ 1355 device = internal->device; 1356 name = internal->name; 1357 1358 /* 2. check for validation */ 1359 if (action_check_completion_mode(common, errp) < 0) { 1360 return; 1361 } 1362 1363 bs = qmp_get_root_bs(device, errp); 1364 if (!bs) { 1365 return; 1366 } 1367 1368 aio_context = bdrv_get_aio_context(bs); 1369 aio_context_acquire(aio_context); 1370 1371 state->bs = bs; 1372 1373 /* Paired with .clean() */ 1374 bdrv_drained_begin(bs); 1375 1376 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_INTERNAL_SNAPSHOT, errp)) { 1377 goto out; 1378 } 1379 1380 if (bdrv_is_read_only(bs)) { 1381 error_setg(errp, "Device '%s' is read only", device); 1382 goto out; 1383 } 1384 1385 if (!bdrv_can_snapshot(bs)) { 1386 error_setg(errp, "Block format '%s' used by device '%s' " 1387 "does not support internal snapshots", 1388 bs->drv->format_name, device); 1389 goto out; 1390 } 1391 1392 if (!strlen(name)) { 1393 error_setg(errp, "Name is empty"); 1394 goto out; 1395 } 1396 1397 /* check whether a snapshot with name exist */ 1398 ret = bdrv_snapshot_find_by_id_and_name(bs, NULL, name, &old_sn, 1399 &local_err); 1400 if (local_err) { 1401 error_propagate(errp, local_err); 1402 goto out; 1403 } else if (ret) { 1404 error_setg(errp, 1405 "Snapshot with name '%s' already exists on device '%s'", 1406 name, device); 1407 goto out; 1408 } 1409 1410 /* 3. take the snapshot */ 1411 sn = &state->sn; 1412 pstrcpy(sn->name, sizeof(sn->name), name); 1413 qemu_gettimeofday(&tv); 1414 sn->date_sec = tv.tv_sec; 1415 sn->date_nsec = tv.tv_usec * 1000; 1416 sn->vm_clock_nsec = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); 1417 1418 ret1 = bdrv_snapshot_create(bs, sn); 1419 if (ret1 < 0) { 1420 error_setg_errno(errp, -ret1, 1421 "Failed to create snapshot '%s' on device '%s'", 1422 name, device); 1423 goto out; 1424 } 1425 1426 /* 4. succeed, mark a snapshot is created */ 1427 state->created = true; 1428 1429 out: 1430 aio_context_release(aio_context); 1431 } 1432 1433 static void internal_snapshot_abort(BlkActionState *common) 1434 { 1435 InternalSnapshotState *state = 1436 DO_UPCAST(InternalSnapshotState, common, common); 1437 BlockDriverState *bs = state->bs; 1438 QEMUSnapshotInfo *sn = &state->sn; 1439 AioContext *aio_context; 1440 Error *local_error = NULL; 1441 1442 if (!state->created) { 1443 return; 1444 } 1445 1446 aio_context = bdrv_get_aio_context(state->bs); 1447 aio_context_acquire(aio_context); 1448 1449 if (bdrv_snapshot_delete(bs, sn->id_str, sn->name, &local_error) < 0) { 1450 error_reportf_err(local_error, 1451 "Failed to delete snapshot with id '%s' and " 1452 "name '%s' on device '%s' in abort: ", 1453 sn->id_str, sn->name, 1454 bdrv_get_device_name(bs)); 1455 } 1456 1457 aio_context_release(aio_context); 1458 } 1459 1460 static void internal_snapshot_clean(BlkActionState *common) 1461 { 1462 InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState, 1463 common, common); 1464 AioContext *aio_context; 1465 1466 if (!state->bs) { 1467 return; 1468 } 1469 1470 aio_context = bdrv_get_aio_context(state->bs); 1471 aio_context_acquire(aio_context); 1472 1473 bdrv_drained_end(state->bs); 1474 1475 aio_context_release(aio_context); 1476 } 1477 1478 /* external snapshot private data */ 1479 typedef struct ExternalSnapshotState { 1480 BlkActionState common; 1481 BlockDriverState *old_bs; 1482 BlockDriverState *new_bs; 1483 bool overlay_appended; 1484 } ExternalSnapshotState; 1485 1486 static void external_snapshot_prepare(BlkActionState *common, 1487 Error **errp) 1488 { 1489 int flags = 0; 1490 QDict *options = NULL; 1491 Error *local_err = NULL; 1492 /* Device and node name of the image to generate the snapshot from */ 1493 const char *device; 1494 const char *node_name; 1495 /* Reference to the new image (for 'blockdev-snapshot') */ 1496 const char *snapshot_ref; 1497 /* File name of the new image (for 'blockdev-snapshot-sync') */ 1498 const char *new_image_file; 1499 ExternalSnapshotState *state = 1500 DO_UPCAST(ExternalSnapshotState, common, common); 1501 TransactionAction *action = common->action; 1502 AioContext *aio_context; 1503 AioContext *old_context; 1504 int ret; 1505 1506 /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar 1507 * purpose but a different set of parameters */ 1508 switch (action->type) { 1509 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT: 1510 { 1511 BlockdevSnapshot *s = action->u.blockdev_snapshot.data; 1512 device = s->node; 1513 node_name = s->node; 1514 new_image_file = NULL; 1515 snapshot_ref = s->overlay; 1516 } 1517 break; 1518 case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC: 1519 { 1520 BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data; 1521 device = s->has_device ? s->device : NULL; 1522 node_name = s->has_node_name ? s->node_name : NULL; 1523 new_image_file = s->snapshot_file; 1524 snapshot_ref = NULL; 1525 } 1526 break; 1527 default: 1528 g_assert_not_reached(); 1529 } 1530 1531 /* start processing */ 1532 if (action_check_completion_mode(common, errp) < 0) { 1533 return; 1534 } 1535 1536 state->old_bs = bdrv_lookup_bs(device, node_name, errp); 1537 if (!state->old_bs) { 1538 return; 1539 } 1540 1541 aio_context = bdrv_get_aio_context(state->old_bs); 1542 aio_context_acquire(aio_context); 1543 1544 /* Paired with .clean() */ 1545 bdrv_drained_begin(state->old_bs); 1546 1547 if (!bdrv_is_inserted(state->old_bs)) { 1548 error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device); 1549 goto out; 1550 } 1551 1552 if (bdrv_op_is_blocked(state->old_bs, 1553 BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, errp)) { 1554 goto out; 1555 } 1556 1557 if (!bdrv_is_read_only(state->old_bs)) { 1558 if (bdrv_flush(state->old_bs)) { 1559 error_setg(errp, QERR_IO_ERROR); 1560 goto out; 1561 } 1562 } 1563 1564 if (action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC) { 1565 BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data; 1566 const char *format = s->has_format ? s->format : "qcow2"; 1567 enum NewImageMode mode; 1568 const char *snapshot_node_name = 1569 s->has_snapshot_node_name ? s->snapshot_node_name : NULL; 1570 1571 if (node_name && !snapshot_node_name) { 1572 error_setg(errp, "New overlay node name missing"); 1573 goto out; 1574 } 1575 1576 if (snapshot_node_name && 1577 bdrv_lookup_bs(snapshot_node_name, snapshot_node_name, NULL)) { 1578 error_setg(errp, "New overlay node name already in use"); 1579 goto out; 1580 } 1581 1582 flags = state->old_bs->open_flags; 1583 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_COPY_ON_READ); 1584 flags |= BDRV_O_NO_BACKING; 1585 1586 /* create new image w/backing file */ 1587 mode = s->has_mode ? s->mode : NEW_IMAGE_MODE_ABSOLUTE_PATHS; 1588 if (mode != NEW_IMAGE_MODE_EXISTING) { 1589 int64_t size = bdrv_getlength(state->old_bs); 1590 if (size < 0) { 1591 error_setg_errno(errp, -size, "bdrv_getlength failed"); 1592 goto out; 1593 } 1594 bdrv_refresh_filename(state->old_bs); 1595 bdrv_img_create(new_image_file, format, 1596 state->old_bs->filename, 1597 state->old_bs->drv->format_name, 1598 NULL, size, flags, false, &local_err); 1599 if (local_err) { 1600 error_propagate(errp, local_err); 1601 goto out; 1602 } 1603 } 1604 1605 options = qdict_new(); 1606 if (snapshot_node_name) { 1607 qdict_put_str(options, "node-name", snapshot_node_name); 1608 } 1609 qdict_put_str(options, "driver", format); 1610 } 1611 1612 state->new_bs = bdrv_open(new_image_file, snapshot_ref, options, flags, 1613 errp); 1614 /* We will manually add the backing_hd field to the bs later */ 1615 if (!state->new_bs) { 1616 goto out; 1617 } 1618 1619 if (bdrv_has_blk(state->new_bs)) { 1620 error_setg(errp, "The overlay is already in use"); 1621 goto out; 1622 } 1623 1624 if (bdrv_op_is_blocked(state->new_bs, BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, 1625 errp)) { 1626 goto out; 1627 } 1628 1629 if (state->new_bs->backing != NULL) { 1630 error_setg(errp, "The overlay already has a backing image"); 1631 goto out; 1632 } 1633 1634 if (!state->new_bs->drv->supports_backing) { 1635 error_setg(errp, "The overlay does not support backing images"); 1636 goto out; 1637 } 1638 1639 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */ 1640 old_context = bdrv_get_aio_context(state->new_bs); 1641 aio_context_release(aio_context); 1642 aio_context_acquire(old_context); 1643 1644 ret = bdrv_try_set_aio_context(state->new_bs, aio_context, errp); 1645 1646 aio_context_release(old_context); 1647 aio_context_acquire(aio_context); 1648 1649 if (ret < 0) { 1650 goto out; 1651 } 1652 1653 /* This removes our old bs and adds the new bs. This is an operation that 1654 * can fail, so we need to do it in .prepare; undoing it for abort is 1655 * always possible. */ 1656 bdrv_ref(state->new_bs); 1657 bdrv_append(state->new_bs, state->old_bs, &local_err); 1658 if (local_err) { 1659 error_propagate(errp, local_err); 1660 goto out; 1661 } 1662 state->overlay_appended = true; 1663 1664 out: 1665 aio_context_release(aio_context); 1666 } 1667 1668 static void external_snapshot_commit(BlkActionState *common) 1669 { 1670 ExternalSnapshotState *state = 1671 DO_UPCAST(ExternalSnapshotState, common, common); 1672 AioContext *aio_context; 1673 1674 aio_context = bdrv_get_aio_context(state->old_bs); 1675 aio_context_acquire(aio_context); 1676 1677 /* We don't need (or want) to use the transactional 1678 * bdrv_reopen_multiple() across all the entries at once, because we 1679 * don't want to abort all of them if one of them fails the reopen */ 1680 if (!atomic_read(&state->old_bs->copy_on_read)) { 1681 bdrv_reopen_set_read_only(state->old_bs, true, NULL); 1682 } 1683 1684 aio_context_release(aio_context); 1685 } 1686 1687 static void external_snapshot_abort(BlkActionState *common) 1688 { 1689 ExternalSnapshotState *state = 1690 DO_UPCAST(ExternalSnapshotState, common, common); 1691 if (state->new_bs) { 1692 if (state->overlay_appended) { 1693 AioContext *aio_context; 1694 AioContext *tmp_context; 1695 int ret; 1696 1697 aio_context = bdrv_get_aio_context(state->old_bs); 1698 aio_context_acquire(aio_context); 1699 1700 bdrv_ref(state->old_bs); /* we can't let bdrv_set_backind_hd() 1701 close state->old_bs; we need it */ 1702 bdrv_set_backing_hd(state->new_bs, NULL, &error_abort); 1703 1704 /* 1705 * The call to bdrv_set_backing_hd() above returns state->old_bs to 1706 * the main AioContext. As we're still going to be using it, return 1707 * it to the AioContext it was before. 1708 */ 1709 tmp_context = bdrv_get_aio_context(state->old_bs); 1710 if (aio_context != tmp_context) { 1711 aio_context_release(aio_context); 1712 aio_context_acquire(tmp_context); 1713 1714 ret = bdrv_try_set_aio_context(state->old_bs, 1715 aio_context, NULL); 1716 assert(ret == 0); 1717 1718 aio_context_release(tmp_context); 1719 aio_context_acquire(aio_context); 1720 } 1721 1722 bdrv_replace_node(state->new_bs, state->old_bs, &error_abort); 1723 bdrv_unref(state->old_bs); /* bdrv_replace_node() ref'ed old_bs */ 1724 1725 aio_context_release(aio_context); 1726 } 1727 } 1728 } 1729 1730 static void external_snapshot_clean(BlkActionState *common) 1731 { 1732 ExternalSnapshotState *state = 1733 DO_UPCAST(ExternalSnapshotState, common, common); 1734 AioContext *aio_context; 1735 1736 if (!state->old_bs) { 1737 return; 1738 } 1739 1740 aio_context = bdrv_get_aio_context(state->old_bs); 1741 aio_context_acquire(aio_context); 1742 1743 bdrv_drained_end(state->old_bs); 1744 bdrv_unref(state->new_bs); 1745 1746 aio_context_release(aio_context); 1747 } 1748 1749 typedef struct DriveBackupState { 1750 BlkActionState common; 1751 BlockDriverState *bs; 1752 BlockJob *job; 1753 } DriveBackupState; 1754 1755 static BlockJob *do_backup_common(BackupCommon *backup, 1756 BlockDriverState *bs, 1757 BlockDriverState *target_bs, 1758 AioContext *aio_context, 1759 JobTxn *txn, Error **errp); 1760 1761 static void drive_backup_prepare(BlkActionState *common, Error **errp) 1762 { 1763 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common); 1764 DriveBackup *backup; 1765 BlockDriverState *bs; 1766 BlockDriverState *target_bs; 1767 BlockDriverState *source = NULL; 1768 AioContext *aio_context; 1769 AioContext *old_context; 1770 QDict *options; 1771 Error *local_err = NULL; 1772 int flags; 1773 int64_t size; 1774 bool set_backing_hd = false; 1775 int ret; 1776 1777 assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP); 1778 backup = common->action->u.drive_backup.data; 1779 1780 if (!backup->has_mode) { 1781 backup->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS; 1782 } 1783 1784 bs = bdrv_lookup_bs(backup->device, backup->device, errp); 1785 if (!bs) { 1786 return; 1787 } 1788 1789 if (!bs->drv) { 1790 error_setg(errp, "Device has no medium"); 1791 return; 1792 } 1793 1794 aio_context = bdrv_get_aio_context(bs); 1795 aio_context_acquire(aio_context); 1796 1797 /* Paired with .clean() */ 1798 bdrv_drained_begin(bs); 1799 1800 if (!backup->has_format) { 1801 backup->format = backup->mode == NEW_IMAGE_MODE_EXISTING ? 1802 NULL : (char *) bs->drv->format_name; 1803 } 1804 1805 /* Early check to avoid creating target */ 1806 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) { 1807 goto out; 1808 } 1809 1810 flags = bs->open_flags | BDRV_O_RDWR; 1811 1812 /* 1813 * See if we have a backing HD we can use to create our new image 1814 * on top of. 1815 */ 1816 if (backup->sync == MIRROR_SYNC_MODE_TOP) { 1817 source = backing_bs(bs); 1818 if (!source) { 1819 backup->sync = MIRROR_SYNC_MODE_FULL; 1820 } 1821 } 1822 if (backup->sync == MIRROR_SYNC_MODE_NONE) { 1823 source = bs; 1824 flags |= BDRV_O_NO_BACKING; 1825 set_backing_hd = true; 1826 } 1827 1828 size = bdrv_getlength(bs); 1829 if (size < 0) { 1830 error_setg_errno(errp, -size, "bdrv_getlength failed"); 1831 goto out; 1832 } 1833 1834 if (backup->mode != NEW_IMAGE_MODE_EXISTING) { 1835 assert(backup->format); 1836 if (source) { 1837 bdrv_refresh_filename(source); 1838 bdrv_img_create(backup->target, backup->format, source->filename, 1839 source->drv->format_name, NULL, 1840 size, flags, false, &local_err); 1841 } else { 1842 bdrv_img_create(backup->target, backup->format, NULL, NULL, NULL, 1843 size, flags, false, &local_err); 1844 } 1845 } 1846 1847 if (local_err) { 1848 error_propagate(errp, local_err); 1849 goto out; 1850 } 1851 1852 options = qdict_new(); 1853 qdict_put_str(options, "discard", "unmap"); 1854 qdict_put_str(options, "detect-zeroes", "unmap"); 1855 if (backup->format) { 1856 qdict_put_str(options, "driver", backup->format); 1857 } 1858 1859 target_bs = bdrv_open(backup->target, NULL, options, flags, errp); 1860 if (!target_bs) { 1861 goto out; 1862 } 1863 1864 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */ 1865 old_context = bdrv_get_aio_context(target_bs); 1866 aio_context_release(aio_context); 1867 aio_context_acquire(old_context); 1868 1869 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp); 1870 if (ret < 0) { 1871 bdrv_unref(target_bs); 1872 aio_context_release(old_context); 1873 return; 1874 } 1875 1876 aio_context_release(old_context); 1877 aio_context_acquire(aio_context); 1878 1879 if (set_backing_hd) { 1880 bdrv_set_backing_hd(target_bs, source, &local_err); 1881 if (local_err) { 1882 goto unref; 1883 } 1884 } 1885 1886 state->bs = bs; 1887 1888 state->job = do_backup_common(qapi_DriveBackup_base(backup), 1889 bs, target_bs, aio_context, 1890 common->block_job_txn, errp); 1891 1892 unref: 1893 bdrv_unref(target_bs); 1894 out: 1895 aio_context_release(aio_context); 1896 } 1897 1898 static void drive_backup_commit(BlkActionState *common) 1899 { 1900 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common); 1901 AioContext *aio_context; 1902 1903 aio_context = bdrv_get_aio_context(state->bs); 1904 aio_context_acquire(aio_context); 1905 1906 assert(state->job); 1907 job_start(&state->job->job); 1908 1909 aio_context_release(aio_context); 1910 } 1911 1912 static void drive_backup_abort(BlkActionState *common) 1913 { 1914 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common); 1915 1916 if (state->job) { 1917 AioContext *aio_context; 1918 1919 aio_context = bdrv_get_aio_context(state->bs); 1920 aio_context_acquire(aio_context); 1921 1922 job_cancel_sync(&state->job->job); 1923 1924 aio_context_release(aio_context); 1925 } 1926 } 1927 1928 static void drive_backup_clean(BlkActionState *common) 1929 { 1930 DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common); 1931 AioContext *aio_context; 1932 1933 if (!state->bs) { 1934 return; 1935 } 1936 1937 aio_context = bdrv_get_aio_context(state->bs); 1938 aio_context_acquire(aio_context); 1939 1940 bdrv_drained_end(state->bs); 1941 1942 aio_context_release(aio_context); 1943 } 1944 1945 typedef struct BlockdevBackupState { 1946 BlkActionState common; 1947 BlockDriverState *bs; 1948 BlockJob *job; 1949 } BlockdevBackupState; 1950 1951 static void blockdev_backup_prepare(BlkActionState *common, Error **errp) 1952 { 1953 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common); 1954 BlockdevBackup *backup; 1955 BlockDriverState *bs; 1956 BlockDriverState *target_bs; 1957 AioContext *aio_context; 1958 AioContext *old_context; 1959 int ret; 1960 1961 assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP); 1962 backup = common->action->u.blockdev_backup.data; 1963 1964 bs = bdrv_lookup_bs(backup->device, backup->device, errp); 1965 if (!bs) { 1966 return; 1967 } 1968 1969 target_bs = bdrv_lookup_bs(backup->target, backup->target, errp); 1970 if (!target_bs) { 1971 return; 1972 } 1973 1974 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */ 1975 aio_context = bdrv_get_aio_context(bs); 1976 old_context = bdrv_get_aio_context(target_bs); 1977 aio_context_acquire(old_context); 1978 1979 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp); 1980 if (ret < 0) { 1981 aio_context_release(old_context); 1982 return; 1983 } 1984 1985 aio_context_release(old_context); 1986 aio_context_acquire(aio_context); 1987 state->bs = bs; 1988 1989 /* Paired with .clean() */ 1990 bdrv_drained_begin(state->bs); 1991 1992 state->job = do_backup_common(qapi_BlockdevBackup_base(backup), 1993 bs, target_bs, aio_context, 1994 common->block_job_txn, errp); 1995 1996 aio_context_release(aio_context); 1997 } 1998 1999 static void blockdev_backup_commit(BlkActionState *common) 2000 { 2001 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common); 2002 AioContext *aio_context; 2003 2004 aio_context = bdrv_get_aio_context(state->bs); 2005 aio_context_acquire(aio_context); 2006 2007 assert(state->job); 2008 job_start(&state->job->job); 2009 2010 aio_context_release(aio_context); 2011 } 2012 2013 static void blockdev_backup_abort(BlkActionState *common) 2014 { 2015 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common); 2016 2017 if (state->job) { 2018 AioContext *aio_context; 2019 2020 aio_context = bdrv_get_aio_context(state->bs); 2021 aio_context_acquire(aio_context); 2022 2023 job_cancel_sync(&state->job->job); 2024 2025 aio_context_release(aio_context); 2026 } 2027 } 2028 2029 static void blockdev_backup_clean(BlkActionState *common) 2030 { 2031 BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common); 2032 AioContext *aio_context; 2033 2034 if (!state->bs) { 2035 return; 2036 } 2037 2038 aio_context = bdrv_get_aio_context(state->bs); 2039 aio_context_acquire(aio_context); 2040 2041 bdrv_drained_end(state->bs); 2042 2043 aio_context_release(aio_context); 2044 } 2045 2046 typedef struct BlockDirtyBitmapState { 2047 BlkActionState common; 2048 BdrvDirtyBitmap *bitmap; 2049 BlockDriverState *bs; 2050 HBitmap *backup; 2051 bool prepared; 2052 bool was_enabled; 2053 } BlockDirtyBitmapState; 2054 2055 static void block_dirty_bitmap_add_prepare(BlkActionState *common, 2056 Error **errp) 2057 { 2058 Error *local_err = NULL; 2059 BlockDirtyBitmapAdd *action; 2060 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2061 common, common); 2062 2063 if (action_check_completion_mode(common, errp) < 0) { 2064 return; 2065 } 2066 2067 action = common->action->u.block_dirty_bitmap_add.data; 2068 /* AIO context taken and released within qmp_block_dirty_bitmap_add */ 2069 qmp_block_dirty_bitmap_add(action->node, action->name, 2070 action->has_granularity, action->granularity, 2071 action->has_persistent, action->persistent, 2072 action->has_disabled, action->disabled, 2073 &local_err); 2074 2075 if (!local_err) { 2076 state->prepared = true; 2077 } else { 2078 error_propagate(errp, local_err); 2079 } 2080 } 2081 2082 static void block_dirty_bitmap_add_abort(BlkActionState *common) 2083 { 2084 BlockDirtyBitmapAdd *action; 2085 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2086 common, common); 2087 2088 action = common->action->u.block_dirty_bitmap_add.data; 2089 /* Should not be able to fail: IF the bitmap was added via .prepare(), 2090 * then the node reference and bitmap name must have been valid. 2091 */ 2092 if (state->prepared) { 2093 qmp_block_dirty_bitmap_remove(action->node, action->name, &error_abort); 2094 } 2095 } 2096 2097 static void block_dirty_bitmap_clear_prepare(BlkActionState *common, 2098 Error **errp) 2099 { 2100 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2101 common, common); 2102 BlockDirtyBitmap *action; 2103 2104 if (action_check_completion_mode(common, errp) < 0) { 2105 return; 2106 } 2107 2108 action = common->action->u.block_dirty_bitmap_clear.data; 2109 state->bitmap = block_dirty_bitmap_lookup(action->node, 2110 action->name, 2111 &state->bs, 2112 errp); 2113 if (!state->bitmap) { 2114 return; 2115 } 2116 2117 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_DEFAULT, errp)) { 2118 return; 2119 } 2120 2121 bdrv_clear_dirty_bitmap(state->bitmap, &state->backup); 2122 } 2123 2124 static void block_dirty_bitmap_restore(BlkActionState *common) 2125 { 2126 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2127 common, common); 2128 2129 if (state->backup) { 2130 bdrv_restore_dirty_bitmap(state->bitmap, state->backup); 2131 } 2132 } 2133 2134 static void block_dirty_bitmap_free_backup(BlkActionState *common) 2135 { 2136 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2137 common, common); 2138 2139 hbitmap_free(state->backup); 2140 } 2141 2142 static void block_dirty_bitmap_enable_prepare(BlkActionState *common, 2143 Error **errp) 2144 { 2145 BlockDirtyBitmap *action; 2146 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2147 common, common); 2148 2149 if (action_check_completion_mode(common, errp) < 0) { 2150 return; 2151 } 2152 2153 action = common->action->u.block_dirty_bitmap_enable.data; 2154 state->bitmap = block_dirty_bitmap_lookup(action->node, 2155 action->name, 2156 NULL, 2157 errp); 2158 if (!state->bitmap) { 2159 return; 2160 } 2161 2162 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) { 2163 return; 2164 } 2165 2166 state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap); 2167 bdrv_enable_dirty_bitmap(state->bitmap); 2168 } 2169 2170 static void block_dirty_bitmap_enable_abort(BlkActionState *common) 2171 { 2172 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2173 common, common); 2174 2175 if (!state->was_enabled) { 2176 bdrv_disable_dirty_bitmap(state->bitmap); 2177 } 2178 } 2179 2180 static void block_dirty_bitmap_disable_prepare(BlkActionState *common, 2181 Error **errp) 2182 { 2183 BlockDirtyBitmap *action; 2184 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2185 common, common); 2186 2187 if (action_check_completion_mode(common, errp) < 0) { 2188 return; 2189 } 2190 2191 action = common->action->u.block_dirty_bitmap_disable.data; 2192 state->bitmap = block_dirty_bitmap_lookup(action->node, 2193 action->name, 2194 NULL, 2195 errp); 2196 if (!state->bitmap) { 2197 return; 2198 } 2199 2200 if (bdrv_dirty_bitmap_check(state->bitmap, BDRV_BITMAP_ALLOW_RO, errp)) { 2201 return; 2202 } 2203 2204 state->was_enabled = bdrv_dirty_bitmap_enabled(state->bitmap); 2205 bdrv_disable_dirty_bitmap(state->bitmap); 2206 } 2207 2208 static void block_dirty_bitmap_disable_abort(BlkActionState *common) 2209 { 2210 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2211 common, common); 2212 2213 if (state->was_enabled) { 2214 bdrv_enable_dirty_bitmap(state->bitmap); 2215 } 2216 } 2217 2218 static BdrvDirtyBitmap *do_block_dirty_bitmap_merge( 2219 const char *node, const char *target, 2220 BlockDirtyBitmapMergeSourceList *bitmaps, 2221 HBitmap **backup, Error **errp); 2222 2223 static void block_dirty_bitmap_merge_prepare(BlkActionState *common, 2224 Error **errp) 2225 { 2226 BlockDirtyBitmapMerge *action; 2227 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2228 common, common); 2229 2230 if (action_check_completion_mode(common, errp) < 0) { 2231 return; 2232 } 2233 2234 action = common->action->u.block_dirty_bitmap_merge.data; 2235 2236 state->bitmap = do_block_dirty_bitmap_merge(action->node, action->target, 2237 action->bitmaps, &state->backup, 2238 errp); 2239 } 2240 2241 static BdrvDirtyBitmap *do_block_dirty_bitmap_remove( 2242 const char *node, const char *name, bool release, 2243 BlockDriverState **bitmap_bs, Error **errp); 2244 2245 static void block_dirty_bitmap_remove_prepare(BlkActionState *common, 2246 Error **errp) 2247 { 2248 BlockDirtyBitmap *action; 2249 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2250 common, common); 2251 2252 if (action_check_completion_mode(common, errp) < 0) { 2253 return; 2254 } 2255 2256 action = common->action->u.block_dirty_bitmap_remove.data; 2257 2258 state->bitmap = do_block_dirty_bitmap_remove(action->node, action->name, 2259 false, &state->bs, errp); 2260 if (state->bitmap) { 2261 bdrv_dirty_bitmap_skip_store(state->bitmap, true); 2262 bdrv_dirty_bitmap_set_busy(state->bitmap, true); 2263 } 2264 } 2265 2266 static void block_dirty_bitmap_remove_abort(BlkActionState *common) 2267 { 2268 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2269 common, common); 2270 2271 if (state->bitmap) { 2272 bdrv_dirty_bitmap_skip_store(state->bitmap, false); 2273 bdrv_dirty_bitmap_set_busy(state->bitmap, false); 2274 } 2275 } 2276 2277 static void block_dirty_bitmap_remove_commit(BlkActionState *common) 2278 { 2279 BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState, 2280 common, common); 2281 2282 bdrv_dirty_bitmap_set_busy(state->bitmap, false); 2283 bdrv_release_dirty_bitmap(state->bitmap); 2284 } 2285 2286 static void abort_prepare(BlkActionState *common, Error **errp) 2287 { 2288 error_setg(errp, "Transaction aborted using Abort action"); 2289 } 2290 2291 static void abort_commit(BlkActionState *common) 2292 { 2293 g_assert_not_reached(); /* this action never succeeds */ 2294 } 2295 2296 static const BlkActionOps actions[] = { 2297 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = { 2298 .instance_size = sizeof(ExternalSnapshotState), 2299 .prepare = external_snapshot_prepare, 2300 .commit = external_snapshot_commit, 2301 .abort = external_snapshot_abort, 2302 .clean = external_snapshot_clean, 2303 }, 2304 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = { 2305 .instance_size = sizeof(ExternalSnapshotState), 2306 .prepare = external_snapshot_prepare, 2307 .commit = external_snapshot_commit, 2308 .abort = external_snapshot_abort, 2309 .clean = external_snapshot_clean, 2310 }, 2311 [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = { 2312 .instance_size = sizeof(DriveBackupState), 2313 .prepare = drive_backup_prepare, 2314 .commit = drive_backup_commit, 2315 .abort = drive_backup_abort, 2316 .clean = drive_backup_clean, 2317 }, 2318 [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = { 2319 .instance_size = sizeof(BlockdevBackupState), 2320 .prepare = blockdev_backup_prepare, 2321 .commit = blockdev_backup_commit, 2322 .abort = blockdev_backup_abort, 2323 .clean = blockdev_backup_clean, 2324 }, 2325 [TRANSACTION_ACTION_KIND_ABORT] = { 2326 .instance_size = sizeof(BlkActionState), 2327 .prepare = abort_prepare, 2328 .commit = abort_commit, 2329 }, 2330 [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = { 2331 .instance_size = sizeof(InternalSnapshotState), 2332 .prepare = internal_snapshot_prepare, 2333 .abort = internal_snapshot_abort, 2334 .clean = internal_snapshot_clean, 2335 }, 2336 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD] = { 2337 .instance_size = sizeof(BlockDirtyBitmapState), 2338 .prepare = block_dirty_bitmap_add_prepare, 2339 .abort = block_dirty_bitmap_add_abort, 2340 }, 2341 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR] = { 2342 .instance_size = sizeof(BlockDirtyBitmapState), 2343 .prepare = block_dirty_bitmap_clear_prepare, 2344 .commit = block_dirty_bitmap_free_backup, 2345 .abort = block_dirty_bitmap_restore, 2346 }, 2347 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE] = { 2348 .instance_size = sizeof(BlockDirtyBitmapState), 2349 .prepare = block_dirty_bitmap_enable_prepare, 2350 .abort = block_dirty_bitmap_enable_abort, 2351 }, 2352 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE] = { 2353 .instance_size = sizeof(BlockDirtyBitmapState), 2354 .prepare = block_dirty_bitmap_disable_prepare, 2355 .abort = block_dirty_bitmap_disable_abort, 2356 }, 2357 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE] = { 2358 .instance_size = sizeof(BlockDirtyBitmapState), 2359 .prepare = block_dirty_bitmap_merge_prepare, 2360 .commit = block_dirty_bitmap_free_backup, 2361 .abort = block_dirty_bitmap_restore, 2362 }, 2363 [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE] = { 2364 .instance_size = sizeof(BlockDirtyBitmapState), 2365 .prepare = block_dirty_bitmap_remove_prepare, 2366 .commit = block_dirty_bitmap_remove_commit, 2367 .abort = block_dirty_bitmap_remove_abort, 2368 }, 2369 /* Where are transactions for MIRROR, COMMIT and STREAM? 2370 * Although these blockjobs use transaction callbacks like the backup job, 2371 * these jobs do not necessarily adhere to transaction semantics. 2372 * These jobs may not fully undo all of their actions on abort, nor do they 2373 * necessarily work in transactions with more than one job in them. 2374 */ 2375 }; 2376 2377 /** 2378 * Allocate a TransactionProperties structure if necessary, and fill 2379 * that structure with desired defaults if they are unset. 2380 */ 2381 static TransactionProperties *get_transaction_properties( 2382 TransactionProperties *props) 2383 { 2384 if (!props) { 2385 props = g_new0(TransactionProperties, 1); 2386 } 2387 2388 if (!props->has_completion_mode) { 2389 props->has_completion_mode = true; 2390 props->completion_mode = ACTION_COMPLETION_MODE_INDIVIDUAL; 2391 } 2392 2393 return props; 2394 } 2395 2396 /* 2397 * 'Atomic' group operations. The operations are performed as a set, and if 2398 * any fail then we roll back all operations in the group. 2399 */ 2400 void qmp_transaction(TransactionActionList *dev_list, 2401 bool has_props, 2402 struct TransactionProperties *props, 2403 Error **errp) 2404 { 2405 TransactionActionList *dev_entry = dev_list; 2406 JobTxn *block_job_txn = NULL; 2407 BlkActionState *state, *next; 2408 Error *local_err = NULL; 2409 2410 QTAILQ_HEAD(, BlkActionState) snap_bdrv_states; 2411 QTAILQ_INIT(&snap_bdrv_states); 2412 2413 /* Does this transaction get canceled as a group on failure? 2414 * If not, we don't really need to make a JobTxn. 2415 */ 2416 props = get_transaction_properties(props); 2417 if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) { 2418 block_job_txn = job_txn_new(); 2419 } 2420 2421 /* drain all i/o before any operations */ 2422 bdrv_drain_all(); 2423 2424 /* We don't do anything in this loop that commits us to the operations */ 2425 while (NULL != dev_entry) { 2426 TransactionAction *dev_info = NULL; 2427 const BlkActionOps *ops; 2428 2429 dev_info = dev_entry->value; 2430 dev_entry = dev_entry->next; 2431 2432 assert(dev_info->type < ARRAY_SIZE(actions)); 2433 2434 ops = &actions[dev_info->type]; 2435 assert(ops->instance_size > 0); 2436 2437 state = g_malloc0(ops->instance_size); 2438 state->ops = ops; 2439 state->action = dev_info; 2440 state->block_job_txn = block_job_txn; 2441 state->txn_props = props; 2442 QTAILQ_INSERT_TAIL(&snap_bdrv_states, state, entry); 2443 2444 state->ops->prepare(state, &local_err); 2445 if (local_err) { 2446 error_propagate(errp, local_err); 2447 goto delete_and_fail; 2448 } 2449 } 2450 2451 QTAILQ_FOREACH(state, &snap_bdrv_states, entry) { 2452 if (state->ops->commit) { 2453 state->ops->commit(state); 2454 } 2455 } 2456 2457 /* success */ 2458 goto exit; 2459 2460 delete_and_fail: 2461 /* failure, and it is all-or-none; roll back all operations */ 2462 QTAILQ_FOREACH_REVERSE(state, &snap_bdrv_states, entry) { 2463 if (state->ops->abort) { 2464 state->ops->abort(state); 2465 } 2466 } 2467 exit: 2468 QTAILQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) { 2469 if (state->ops->clean) { 2470 state->ops->clean(state); 2471 } 2472 g_free(state); 2473 } 2474 if (!has_props) { 2475 qapi_free_TransactionProperties(props); 2476 } 2477 job_txn_unref(block_job_txn); 2478 } 2479 2480 void qmp_block_passwd(bool has_device, const char *device, 2481 bool has_node_name, const char *node_name, 2482 const char *password, Error **errp) 2483 { 2484 error_setg(errp, 2485 "Setting block passwords directly is no longer supported"); 2486 } 2487 2488 void qmp_block_dirty_bitmap_add(const char *node, const char *name, 2489 bool has_granularity, uint32_t granularity, 2490 bool has_persistent, bool persistent, 2491 bool has_disabled, bool disabled, 2492 Error **errp) 2493 { 2494 BlockDriverState *bs; 2495 BdrvDirtyBitmap *bitmap; 2496 AioContext *aio_context; 2497 2498 if (!name || name[0] == '\0') { 2499 error_setg(errp, "Bitmap name cannot be empty"); 2500 return; 2501 } 2502 2503 bs = bdrv_lookup_bs(node, node, errp); 2504 if (!bs) { 2505 return; 2506 } 2507 2508 aio_context = bdrv_get_aio_context(bs); 2509 aio_context_acquire(aio_context); 2510 2511 if (has_granularity) { 2512 if (granularity < 512 || !is_power_of_2(granularity)) { 2513 error_setg(errp, "Granularity must be power of 2 " 2514 "and at least 512"); 2515 goto out; 2516 } 2517 } else { 2518 /* Default to cluster size, if available: */ 2519 granularity = bdrv_get_default_bitmap_granularity(bs); 2520 } 2521 2522 if (!has_persistent) { 2523 persistent = false; 2524 } 2525 2526 if (!has_disabled) { 2527 disabled = false; 2528 } 2529 2530 if (persistent && 2531 !bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp)) 2532 { 2533 goto out; 2534 } 2535 2536 bitmap = bdrv_create_dirty_bitmap(bs, granularity, name, errp); 2537 if (bitmap == NULL) { 2538 goto out; 2539 } 2540 2541 if (disabled) { 2542 bdrv_disable_dirty_bitmap(bitmap); 2543 } 2544 2545 bdrv_dirty_bitmap_set_persistence(bitmap, persistent); 2546 2547 out: 2548 aio_context_release(aio_context); 2549 } 2550 2551 static BdrvDirtyBitmap *do_block_dirty_bitmap_remove( 2552 const char *node, const char *name, bool release, 2553 BlockDriverState **bitmap_bs, Error **errp) 2554 { 2555 BlockDriverState *bs; 2556 BdrvDirtyBitmap *bitmap; 2557 AioContext *aio_context; 2558 2559 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp); 2560 if (!bitmap || !bs) { 2561 return NULL; 2562 } 2563 2564 aio_context = bdrv_get_aio_context(bs); 2565 aio_context_acquire(aio_context); 2566 2567 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_BUSY | BDRV_BITMAP_RO, 2568 errp)) { 2569 aio_context_release(aio_context); 2570 return NULL; 2571 } 2572 2573 if (bdrv_dirty_bitmap_get_persistence(bitmap) && 2574 bdrv_remove_persistent_dirty_bitmap(bs, name, errp) < 0) 2575 { 2576 aio_context_release(aio_context); 2577 return NULL; 2578 } 2579 2580 if (release) { 2581 bdrv_release_dirty_bitmap(bitmap); 2582 } 2583 2584 if (bitmap_bs) { 2585 *bitmap_bs = bs; 2586 } 2587 2588 aio_context_release(aio_context); 2589 return release ? NULL : bitmap; 2590 } 2591 2592 void qmp_block_dirty_bitmap_remove(const char *node, const char *name, 2593 Error **errp) 2594 { 2595 do_block_dirty_bitmap_remove(node, name, true, NULL, errp); 2596 } 2597 2598 /** 2599 * Completely clear a bitmap, for the purposes of synchronizing a bitmap 2600 * immediately after a full backup operation. 2601 */ 2602 void qmp_block_dirty_bitmap_clear(const char *node, const char *name, 2603 Error **errp) 2604 { 2605 BdrvDirtyBitmap *bitmap; 2606 BlockDriverState *bs; 2607 2608 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp); 2609 if (!bitmap || !bs) { 2610 return; 2611 } 2612 2613 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_DEFAULT, errp)) { 2614 return; 2615 } 2616 2617 bdrv_clear_dirty_bitmap(bitmap, NULL); 2618 } 2619 2620 void qmp_block_dirty_bitmap_enable(const char *node, const char *name, 2621 Error **errp) 2622 { 2623 BlockDriverState *bs; 2624 BdrvDirtyBitmap *bitmap; 2625 2626 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp); 2627 if (!bitmap) { 2628 return; 2629 } 2630 2631 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) { 2632 return; 2633 } 2634 2635 bdrv_enable_dirty_bitmap(bitmap); 2636 } 2637 2638 void qmp_block_dirty_bitmap_disable(const char *node, const char *name, 2639 Error **errp) 2640 { 2641 BlockDriverState *bs; 2642 BdrvDirtyBitmap *bitmap; 2643 2644 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp); 2645 if (!bitmap) { 2646 return; 2647 } 2648 2649 if (bdrv_dirty_bitmap_check(bitmap, BDRV_BITMAP_ALLOW_RO, errp)) { 2650 return; 2651 } 2652 2653 bdrv_disable_dirty_bitmap(bitmap); 2654 } 2655 2656 static BdrvDirtyBitmap *do_block_dirty_bitmap_merge( 2657 const char *node, const char *target, 2658 BlockDirtyBitmapMergeSourceList *bitmaps, 2659 HBitmap **backup, Error **errp) 2660 { 2661 BlockDriverState *bs; 2662 BdrvDirtyBitmap *dst, *src, *anon; 2663 BlockDirtyBitmapMergeSourceList *lst; 2664 Error *local_err = NULL; 2665 2666 dst = block_dirty_bitmap_lookup(node, target, &bs, errp); 2667 if (!dst) { 2668 return NULL; 2669 } 2670 2671 anon = bdrv_create_dirty_bitmap(bs, bdrv_dirty_bitmap_granularity(dst), 2672 NULL, errp); 2673 if (!anon) { 2674 return NULL; 2675 } 2676 2677 for (lst = bitmaps; lst; lst = lst->next) { 2678 switch (lst->value->type) { 2679 const char *name, *node; 2680 case QTYPE_QSTRING: 2681 name = lst->value->u.local; 2682 src = bdrv_find_dirty_bitmap(bs, name); 2683 if (!src) { 2684 error_setg(errp, "Dirty bitmap '%s' not found", name); 2685 dst = NULL; 2686 goto out; 2687 } 2688 break; 2689 case QTYPE_QDICT: 2690 node = lst->value->u.external.node; 2691 name = lst->value->u.external.name; 2692 src = block_dirty_bitmap_lookup(node, name, NULL, errp); 2693 if (!src) { 2694 dst = NULL; 2695 goto out; 2696 } 2697 break; 2698 default: 2699 abort(); 2700 } 2701 2702 bdrv_merge_dirty_bitmap(anon, src, NULL, &local_err); 2703 if (local_err) { 2704 error_propagate(errp, local_err); 2705 dst = NULL; 2706 goto out; 2707 } 2708 } 2709 2710 /* Merge into dst; dst is unchanged on failure. */ 2711 bdrv_merge_dirty_bitmap(dst, anon, backup, errp); 2712 2713 out: 2714 bdrv_release_dirty_bitmap(anon); 2715 return dst; 2716 } 2717 2718 void qmp_block_dirty_bitmap_merge(const char *node, const char *target, 2719 BlockDirtyBitmapMergeSourceList *bitmaps, 2720 Error **errp) 2721 { 2722 do_block_dirty_bitmap_merge(node, target, bitmaps, NULL, errp); 2723 } 2724 2725 BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *node, 2726 const char *name, 2727 Error **errp) 2728 { 2729 BdrvDirtyBitmap *bitmap; 2730 BlockDriverState *bs; 2731 BlockDirtyBitmapSha256 *ret = NULL; 2732 char *sha256; 2733 2734 bitmap = block_dirty_bitmap_lookup(node, name, &bs, errp); 2735 if (!bitmap || !bs) { 2736 return NULL; 2737 } 2738 2739 sha256 = bdrv_dirty_bitmap_sha256(bitmap, errp); 2740 if (sha256 == NULL) { 2741 return NULL; 2742 } 2743 2744 ret = g_new(BlockDirtyBitmapSha256, 1); 2745 ret->sha256 = sha256; 2746 2747 return ret; 2748 } 2749 2750 void hmp_drive_del(Monitor *mon, const QDict *qdict) 2751 { 2752 const char *id = qdict_get_str(qdict, "id"); 2753 BlockBackend *blk; 2754 BlockDriverState *bs; 2755 AioContext *aio_context; 2756 Error *local_err = NULL; 2757 2758 bs = bdrv_find_node(id); 2759 if (bs) { 2760 qmp_blockdev_del(id, &local_err); 2761 if (local_err) { 2762 error_report_err(local_err); 2763 } 2764 return; 2765 } 2766 2767 blk = blk_by_name(id); 2768 if (!blk) { 2769 error_report("Device '%s' not found", id); 2770 return; 2771 } 2772 2773 if (!blk_legacy_dinfo(blk)) { 2774 error_report("Deleting device added with blockdev-add" 2775 " is not supported"); 2776 return; 2777 } 2778 2779 aio_context = blk_get_aio_context(blk); 2780 aio_context_acquire(aio_context); 2781 2782 bs = blk_bs(blk); 2783 if (bs) { 2784 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, &local_err)) { 2785 error_report_err(local_err); 2786 aio_context_release(aio_context); 2787 return; 2788 } 2789 2790 blk_remove_bs(blk); 2791 } 2792 2793 /* Make the BlockBackend and the attached BlockDriverState anonymous */ 2794 monitor_remove_blk(blk); 2795 2796 /* If this BlockBackend has a device attached to it, its refcount will be 2797 * decremented when the device is removed; otherwise we have to do so here. 2798 */ 2799 if (blk_get_attached_dev(blk)) { 2800 /* Further I/O must not pause the guest */ 2801 blk_set_on_error(blk, BLOCKDEV_ON_ERROR_REPORT, 2802 BLOCKDEV_ON_ERROR_REPORT); 2803 } else { 2804 blk_unref(blk); 2805 } 2806 2807 aio_context_release(aio_context); 2808 } 2809 2810 void qmp_block_resize(bool has_device, const char *device, 2811 bool has_node_name, const char *node_name, 2812 int64_t size, Error **errp) 2813 { 2814 Error *local_err = NULL; 2815 BlockBackend *blk = NULL; 2816 BlockDriverState *bs; 2817 AioContext *aio_context; 2818 int ret; 2819 2820 bs = bdrv_lookup_bs(has_device ? device : NULL, 2821 has_node_name ? node_name : NULL, 2822 &local_err); 2823 if (local_err) { 2824 error_propagate(errp, local_err); 2825 return; 2826 } 2827 2828 aio_context = bdrv_get_aio_context(bs); 2829 aio_context_acquire(aio_context); 2830 2831 if (size < 0) { 2832 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "size", "a >0 size"); 2833 goto out; 2834 } 2835 2836 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) { 2837 error_setg(errp, QERR_DEVICE_IN_USE, device); 2838 goto out; 2839 } 2840 2841 blk = blk_new(bdrv_get_aio_context(bs), BLK_PERM_RESIZE, BLK_PERM_ALL); 2842 ret = blk_insert_bs(blk, bs, errp); 2843 if (ret < 0) { 2844 goto out; 2845 } 2846 2847 bdrv_drained_begin(bs); 2848 ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, errp); 2849 bdrv_drained_end(bs); 2850 2851 out: 2852 blk_unref(blk); 2853 aio_context_release(aio_context); 2854 } 2855 2856 void qmp_block_stream(bool has_job_id, const char *job_id, const char *device, 2857 bool has_base, const char *base, 2858 bool has_base_node, const char *base_node, 2859 bool has_backing_file, const char *backing_file, 2860 bool has_speed, int64_t speed, 2861 bool has_on_error, BlockdevOnError on_error, 2862 bool has_auto_finalize, bool auto_finalize, 2863 bool has_auto_dismiss, bool auto_dismiss, 2864 Error **errp) 2865 { 2866 BlockDriverState *bs, *iter; 2867 BlockDriverState *base_bs = NULL; 2868 AioContext *aio_context; 2869 Error *local_err = NULL; 2870 const char *base_name = NULL; 2871 int job_flags = JOB_DEFAULT; 2872 2873 if (!has_on_error) { 2874 on_error = BLOCKDEV_ON_ERROR_REPORT; 2875 } 2876 2877 bs = bdrv_lookup_bs(device, device, errp); 2878 if (!bs) { 2879 return; 2880 } 2881 2882 aio_context = bdrv_get_aio_context(bs); 2883 aio_context_acquire(aio_context); 2884 2885 if (has_base && has_base_node) { 2886 error_setg(errp, "'base' and 'base-node' cannot be specified " 2887 "at the same time"); 2888 goto out; 2889 } 2890 2891 if (has_base) { 2892 base_bs = bdrv_find_backing_image(bs, base); 2893 if (base_bs == NULL) { 2894 error_setg(errp, QERR_BASE_NOT_FOUND, base); 2895 goto out; 2896 } 2897 assert(bdrv_get_aio_context(base_bs) == aio_context); 2898 base_name = base; 2899 } 2900 2901 if (has_base_node) { 2902 base_bs = bdrv_lookup_bs(NULL, base_node, errp); 2903 if (!base_bs) { 2904 goto out; 2905 } 2906 if (bs == base_bs || !bdrv_chain_contains(bs, base_bs)) { 2907 error_setg(errp, "Node '%s' is not a backing image of '%s'", 2908 base_node, device); 2909 goto out; 2910 } 2911 assert(bdrv_get_aio_context(base_bs) == aio_context); 2912 bdrv_refresh_filename(base_bs); 2913 base_name = base_bs->filename; 2914 } 2915 2916 /* Check for op blockers in the whole chain between bs and base */ 2917 for (iter = bs; iter && iter != base_bs; iter = backing_bs(iter)) { 2918 if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_STREAM, errp)) { 2919 goto out; 2920 } 2921 } 2922 2923 /* if we are streaming the entire chain, the result will have no backing 2924 * file, and specifying one is therefore an error */ 2925 if (base_bs == NULL && has_backing_file) { 2926 error_setg(errp, "backing file specified, but streaming the " 2927 "entire chain"); 2928 goto out; 2929 } 2930 2931 /* backing_file string overrides base bs filename */ 2932 base_name = has_backing_file ? backing_file : base_name; 2933 2934 if (has_auto_finalize && !auto_finalize) { 2935 job_flags |= JOB_MANUAL_FINALIZE; 2936 } 2937 if (has_auto_dismiss && !auto_dismiss) { 2938 job_flags |= JOB_MANUAL_DISMISS; 2939 } 2940 2941 stream_start(has_job_id ? job_id : NULL, bs, base_bs, base_name, 2942 job_flags, has_speed ? speed : 0, on_error, &local_err); 2943 if (local_err) { 2944 error_propagate(errp, local_err); 2945 goto out; 2946 } 2947 2948 trace_qmp_block_stream(bs); 2949 2950 out: 2951 aio_context_release(aio_context); 2952 } 2953 2954 void qmp_block_commit(bool has_job_id, const char *job_id, const char *device, 2955 bool has_base_node, const char *base_node, 2956 bool has_base, const char *base, 2957 bool has_top_node, const char *top_node, 2958 bool has_top, const char *top, 2959 bool has_backing_file, const char *backing_file, 2960 bool has_speed, int64_t speed, 2961 bool has_on_error, BlockdevOnError on_error, 2962 bool has_filter_node_name, const char *filter_node_name, 2963 bool has_auto_finalize, bool auto_finalize, 2964 bool has_auto_dismiss, bool auto_dismiss, 2965 Error **errp) 2966 { 2967 BlockDriverState *bs; 2968 BlockDriverState *iter; 2969 BlockDriverState *base_bs, *top_bs; 2970 AioContext *aio_context; 2971 Error *local_err = NULL; 2972 int job_flags = JOB_DEFAULT; 2973 2974 if (!has_speed) { 2975 speed = 0; 2976 } 2977 if (!has_on_error) { 2978 on_error = BLOCKDEV_ON_ERROR_REPORT; 2979 } 2980 if (!has_filter_node_name) { 2981 filter_node_name = NULL; 2982 } 2983 if (has_auto_finalize && !auto_finalize) { 2984 job_flags |= JOB_MANUAL_FINALIZE; 2985 } 2986 if (has_auto_dismiss && !auto_dismiss) { 2987 job_flags |= JOB_MANUAL_DISMISS; 2988 } 2989 2990 /* Important Note: 2991 * libvirt relies on the DeviceNotFound error class in order to probe for 2992 * live commit feature versions; for this to work, we must make sure to 2993 * perform the device lookup before any generic errors that may occur in a 2994 * scenario in which all optional arguments are omitted. */ 2995 bs = qmp_get_root_bs(device, &local_err); 2996 if (!bs) { 2997 bs = bdrv_lookup_bs(device, device, NULL); 2998 if (!bs) { 2999 error_free(local_err); 3000 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 3001 "Device '%s' not found", device); 3002 } else { 3003 error_propagate(errp, local_err); 3004 } 3005 return; 3006 } 3007 3008 aio_context = bdrv_get_aio_context(bs); 3009 aio_context_acquire(aio_context); 3010 3011 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, errp)) { 3012 goto out; 3013 } 3014 3015 /* default top_bs is the active layer */ 3016 top_bs = bs; 3017 3018 if (has_top_node && has_top) { 3019 error_setg(errp, "'top-node' and 'top' are mutually exclusive"); 3020 goto out; 3021 } else if (has_top_node) { 3022 top_bs = bdrv_lookup_bs(NULL, top_node, errp); 3023 if (top_bs == NULL) { 3024 goto out; 3025 } 3026 if (!bdrv_chain_contains(bs, top_bs)) { 3027 error_setg(errp, "'%s' is not in this backing file chain", 3028 top_node); 3029 goto out; 3030 } 3031 } else if (has_top && top) { 3032 /* This strcmp() is just a shortcut, there is no need to 3033 * refresh @bs's filename. If it mismatches, 3034 * bdrv_find_backing_image() will do the refresh and may still 3035 * return @bs. */ 3036 if (strcmp(bs->filename, top) != 0) { 3037 top_bs = bdrv_find_backing_image(bs, top); 3038 } 3039 } 3040 3041 if (top_bs == NULL) { 3042 error_setg(errp, "Top image file %s not found", top ? top : "NULL"); 3043 goto out; 3044 } 3045 3046 assert(bdrv_get_aio_context(top_bs) == aio_context); 3047 3048 if (has_base_node && has_base) { 3049 error_setg(errp, "'base-node' and 'base' are mutually exclusive"); 3050 goto out; 3051 } else if (has_base_node) { 3052 base_bs = bdrv_lookup_bs(NULL, base_node, errp); 3053 if (base_bs == NULL) { 3054 goto out; 3055 } 3056 if (!bdrv_chain_contains(top_bs, base_bs)) { 3057 error_setg(errp, "'%s' is not in this backing file chain", 3058 base_node); 3059 goto out; 3060 } 3061 } else if (has_base && base) { 3062 base_bs = bdrv_find_backing_image(top_bs, base); 3063 } else { 3064 base_bs = bdrv_find_base(top_bs); 3065 } 3066 3067 if (base_bs == NULL) { 3068 error_setg(errp, QERR_BASE_NOT_FOUND, base ? base : "NULL"); 3069 goto out; 3070 } 3071 3072 assert(bdrv_get_aio_context(base_bs) == aio_context); 3073 3074 for (iter = top_bs; iter != backing_bs(base_bs); iter = backing_bs(iter)) { 3075 if (bdrv_op_is_blocked(iter, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) { 3076 goto out; 3077 } 3078 } 3079 3080 /* Do not allow attempts to commit an image into itself */ 3081 if (top_bs == base_bs) { 3082 error_setg(errp, "cannot commit an image into itself"); 3083 goto out; 3084 } 3085 3086 if (top_bs == bs) { 3087 if (has_backing_file) { 3088 error_setg(errp, "'backing-file' specified," 3089 " but 'top' is the active layer"); 3090 goto out; 3091 } 3092 commit_active_start(has_job_id ? job_id : NULL, bs, base_bs, 3093 job_flags, speed, on_error, 3094 filter_node_name, NULL, NULL, false, &local_err); 3095 } else { 3096 BlockDriverState *overlay_bs = bdrv_find_overlay(bs, top_bs); 3097 if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) { 3098 goto out; 3099 } 3100 commit_start(has_job_id ? job_id : NULL, bs, base_bs, top_bs, job_flags, 3101 speed, on_error, has_backing_file ? backing_file : NULL, 3102 filter_node_name, &local_err); 3103 } 3104 if (local_err != NULL) { 3105 error_propagate(errp, local_err); 3106 goto out; 3107 } 3108 3109 out: 3110 aio_context_release(aio_context); 3111 } 3112 3113 /* Common QMP interface for drive-backup and blockdev-backup */ 3114 static BlockJob *do_backup_common(BackupCommon *backup, 3115 BlockDriverState *bs, 3116 BlockDriverState *target_bs, 3117 AioContext *aio_context, 3118 JobTxn *txn, Error **errp) 3119 { 3120 BlockJob *job = NULL; 3121 BdrvDirtyBitmap *bmap = NULL; 3122 int job_flags = JOB_DEFAULT; 3123 3124 if (!backup->has_speed) { 3125 backup->speed = 0; 3126 } 3127 if (!backup->has_on_source_error) { 3128 backup->on_source_error = BLOCKDEV_ON_ERROR_REPORT; 3129 } 3130 if (!backup->has_on_target_error) { 3131 backup->on_target_error = BLOCKDEV_ON_ERROR_REPORT; 3132 } 3133 if (!backup->has_job_id) { 3134 backup->job_id = NULL; 3135 } 3136 if (!backup->has_auto_finalize) { 3137 backup->auto_finalize = true; 3138 } 3139 if (!backup->has_auto_dismiss) { 3140 backup->auto_dismiss = true; 3141 } 3142 if (!backup->has_compress) { 3143 backup->compress = false; 3144 } 3145 3146 if ((backup->sync == MIRROR_SYNC_MODE_BITMAP) || 3147 (backup->sync == MIRROR_SYNC_MODE_INCREMENTAL)) { 3148 /* done before desugaring 'incremental' to print the right message */ 3149 if (!backup->has_bitmap) { 3150 error_setg(errp, "must provide a valid bitmap name for " 3151 "'%s' sync mode", MirrorSyncMode_str(backup->sync)); 3152 return NULL; 3153 } 3154 } 3155 3156 if (backup->sync == MIRROR_SYNC_MODE_INCREMENTAL) { 3157 if (backup->has_bitmap_mode && 3158 backup->bitmap_mode != BITMAP_SYNC_MODE_ON_SUCCESS) { 3159 error_setg(errp, "Bitmap sync mode must be '%s' " 3160 "when using sync mode '%s'", 3161 BitmapSyncMode_str(BITMAP_SYNC_MODE_ON_SUCCESS), 3162 MirrorSyncMode_str(backup->sync)); 3163 return NULL; 3164 } 3165 backup->has_bitmap_mode = true; 3166 backup->sync = MIRROR_SYNC_MODE_BITMAP; 3167 backup->bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS; 3168 } 3169 3170 if (backup->has_bitmap) { 3171 bmap = bdrv_find_dirty_bitmap(bs, backup->bitmap); 3172 if (!bmap) { 3173 error_setg(errp, "Bitmap '%s' could not be found", backup->bitmap); 3174 return NULL; 3175 } 3176 if (!backup->has_bitmap_mode) { 3177 error_setg(errp, "Bitmap sync mode must be given " 3178 "when providing a bitmap"); 3179 return NULL; 3180 } 3181 if (bdrv_dirty_bitmap_check(bmap, BDRV_BITMAP_ALLOW_RO, errp)) { 3182 return NULL; 3183 } 3184 3185 /* This does not produce a useful bitmap artifact: */ 3186 if (backup->sync == MIRROR_SYNC_MODE_NONE) { 3187 error_setg(errp, "sync mode '%s' does not produce meaningful bitmap" 3188 " outputs", MirrorSyncMode_str(backup->sync)); 3189 return NULL; 3190 } 3191 3192 /* If the bitmap isn't used for input or output, this is useless: */ 3193 if (backup->bitmap_mode == BITMAP_SYNC_MODE_NEVER && 3194 backup->sync != MIRROR_SYNC_MODE_BITMAP) { 3195 error_setg(errp, "Bitmap sync mode '%s' has no meaningful effect" 3196 " when combined with sync mode '%s'", 3197 BitmapSyncMode_str(backup->bitmap_mode), 3198 MirrorSyncMode_str(backup->sync)); 3199 return NULL; 3200 } 3201 } 3202 3203 if (!backup->has_bitmap && backup->has_bitmap_mode) { 3204 error_setg(errp, "Cannot specify bitmap sync mode without a bitmap"); 3205 return NULL; 3206 } 3207 3208 if (!backup->auto_finalize) { 3209 job_flags |= JOB_MANUAL_FINALIZE; 3210 } 3211 if (!backup->auto_dismiss) { 3212 job_flags |= JOB_MANUAL_DISMISS; 3213 } 3214 3215 job = backup_job_create(backup->job_id, bs, target_bs, backup->speed, 3216 backup->sync, bmap, backup->bitmap_mode, 3217 backup->compress, 3218 backup->filter_node_name, 3219 backup->on_source_error, 3220 backup->on_target_error, 3221 job_flags, NULL, NULL, txn, errp); 3222 return job; 3223 } 3224 3225 void qmp_drive_backup(DriveBackup *backup, Error **errp) 3226 { 3227 TransactionAction action = { 3228 .type = TRANSACTION_ACTION_KIND_DRIVE_BACKUP, 3229 .u.drive_backup.data = backup, 3230 }; 3231 blockdev_do_action(&action, errp); 3232 } 3233 3234 BlockDeviceInfoList *qmp_query_named_block_nodes(bool has_flat, 3235 bool flat, 3236 Error **errp) 3237 { 3238 bool return_flat = has_flat && flat; 3239 3240 return bdrv_named_nodes_list(return_flat, errp); 3241 } 3242 3243 XDbgBlockGraph *qmp_x_debug_query_block_graph(Error **errp) 3244 { 3245 return bdrv_get_xdbg_block_graph(errp); 3246 } 3247 3248 void qmp_blockdev_backup(BlockdevBackup *backup, Error **errp) 3249 { 3250 TransactionAction action = { 3251 .type = TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP, 3252 .u.blockdev_backup.data = backup, 3253 }; 3254 blockdev_do_action(&action, errp); 3255 } 3256 3257 /* Parameter check and block job starting for drive mirroring. 3258 * Caller should hold @device and @target's aio context (must be the same). 3259 **/ 3260 static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs, 3261 BlockDriverState *target, 3262 bool has_replaces, const char *replaces, 3263 enum MirrorSyncMode sync, 3264 BlockMirrorBackingMode backing_mode, 3265 bool zero_target, 3266 bool has_speed, int64_t speed, 3267 bool has_granularity, uint32_t granularity, 3268 bool has_buf_size, int64_t buf_size, 3269 bool has_on_source_error, 3270 BlockdevOnError on_source_error, 3271 bool has_on_target_error, 3272 BlockdevOnError on_target_error, 3273 bool has_unmap, bool unmap, 3274 bool has_filter_node_name, 3275 const char *filter_node_name, 3276 bool has_copy_mode, MirrorCopyMode copy_mode, 3277 bool has_auto_finalize, bool auto_finalize, 3278 bool has_auto_dismiss, bool auto_dismiss, 3279 Error **errp) 3280 { 3281 int job_flags = JOB_DEFAULT; 3282 3283 if (!has_speed) { 3284 speed = 0; 3285 } 3286 if (!has_on_source_error) { 3287 on_source_error = BLOCKDEV_ON_ERROR_REPORT; 3288 } 3289 if (!has_on_target_error) { 3290 on_target_error = BLOCKDEV_ON_ERROR_REPORT; 3291 } 3292 if (!has_granularity) { 3293 granularity = 0; 3294 } 3295 if (!has_buf_size) { 3296 buf_size = 0; 3297 } 3298 if (!has_unmap) { 3299 unmap = true; 3300 } 3301 if (!has_filter_node_name) { 3302 filter_node_name = NULL; 3303 } 3304 if (!has_copy_mode) { 3305 copy_mode = MIRROR_COPY_MODE_BACKGROUND; 3306 } 3307 if (has_auto_finalize && !auto_finalize) { 3308 job_flags |= JOB_MANUAL_FINALIZE; 3309 } 3310 if (has_auto_dismiss && !auto_dismiss) { 3311 job_flags |= JOB_MANUAL_DISMISS; 3312 } 3313 3314 if (granularity != 0 && (granularity < 512 || granularity > 1048576 * 64)) { 3315 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity", 3316 "a value in range [512B, 64MB]"); 3317 return; 3318 } 3319 if (granularity & (granularity - 1)) { 3320 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "granularity", 3321 "power of 2"); 3322 return; 3323 } 3324 3325 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) { 3326 return; 3327 } 3328 if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_MIRROR_TARGET, errp)) { 3329 return; 3330 } 3331 3332 if (!bs->backing && sync == MIRROR_SYNC_MODE_TOP) { 3333 sync = MIRROR_SYNC_MODE_FULL; 3334 } 3335 3336 if (has_replaces) { 3337 BlockDriverState *to_replace_bs; 3338 AioContext *replace_aio_context; 3339 int64_t bs_size, replace_size; 3340 3341 bs_size = bdrv_getlength(bs); 3342 if (bs_size < 0) { 3343 error_setg_errno(errp, -bs_size, "Failed to query device's size"); 3344 return; 3345 } 3346 3347 to_replace_bs = check_to_replace_node(bs, replaces, errp); 3348 if (!to_replace_bs) { 3349 return; 3350 } 3351 3352 replace_aio_context = bdrv_get_aio_context(to_replace_bs); 3353 aio_context_acquire(replace_aio_context); 3354 replace_size = bdrv_getlength(to_replace_bs); 3355 aio_context_release(replace_aio_context); 3356 3357 if (replace_size < 0) { 3358 error_setg_errno(errp, -replace_size, 3359 "Failed to query the replacement node's size"); 3360 return; 3361 } 3362 if (bs_size != replace_size) { 3363 error_setg(errp, "cannot replace image with a mirror image of " 3364 "different size"); 3365 return; 3366 } 3367 } 3368 3369 /* pass the node name to replace to mirror start since it's loose coupling 3370 * and will allow to check whether the node still exist at mirror completion 3371 */ 3372 mirror_start(job_id, bs, target, 3373 has_replaces ? replaces : NULL, job_flags, 3374 speed, granularity, buf_size, sync, backing_mode, zero_target, 3375 on_source_error, on_target_error, unmap, filter_node_name, 3376 copy_mode, errp); 3377 } 3378 3379 void qmp_drive_mirror(DriveMirror *arg, Error **errp) 3380 { 3381 BlockDriverState *bs; 3382 BlockDriverState *source, *target_bs; 3383 AioContext *aio_context; 3384 AioContext *old_context; 3385 BlockMirrorBackingMode backing_mode; 3386 Error *local_err = NULL; 3387 QDict *options = NULL; 3388 int flags; 3389 int64_t size; 3390 const char *format = arg->format; 3391 bool zero_target; 3392 int ret; 3393 3394 bs = qmp_get_root_bs(arg->device, errp); 3395 if (!bs) { 3396 return; 3397 } 3398 3399 /* Early check to avoid creating target */ 3400 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_MIRROR_SOURCE, errp)) { 3401 return; 3402 } 3403 3404 aio_context = bdrv_get_aio_context(bs); 3405 aio_context_acquire(aio_context); 3406 3407 if (!arg->has_mode) { 3408 arg->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS; 3409 } 3410 3411 if (!arg->has_format) { 3412 format = (arg->mode == NEW_IMAGE_MODE_EXISTING 3413 ? NULL : bs->drv->format_name); 3414 } 3415 3416 flags = bs->open_flags | BDRV_O_RDWR; 3417 source = backing_bs(bs); 3418 if (!source && arg->sync == MIRROR_SYNC_MODE_TOP) { 3419 arg->sync = MIRROR_SYNC_MODE_FULL; 3420 } 3421 if (arg->sync == MIRROR_SYNC_MODE_NONE) { 3422 source = bs; 3423 } 3424 3425 size = bdrv_getlength(bs); 3426 if (size < 0) { 3427 error_setg_errno(errp, -size, "bdrv_getlength failed"); 3428 goto out; 3429 } 3430 3431 if (arg->has_replaces) { 3432 if (!arg->has_node_name) { 3433 error_setg(errp, "a node-name must be provided when replacing a" 3434 " named node of the graph"); 3435 goto out; 3436 } 3437 } 3438 3439 if (arg->mode == NEW_IMAGE_MODE_ABSOLUTE_PATHS) { 3440 backing_mode = MIRROR_SOURCE_BACKING_CHAIN; 3441 } else { 3442 backing_mode = MIRROR_OPEN_BACKING_CHAIN; 3443 } 3444 3445 /* Don't open backing image in create() */ 3446 flags |= BDRV_O_NO_BACKING; 3447 3448 if ((arg->sync == MIRROR_SYNC_MODE_FULL || !source) 3449 && arg->mode != NEW_IMAGE_MODE_EXISTING) 3450 { 3451 /* create new image w/o backing file */ 3452 assert(format); 3453 bdrv_img_create(arg->target, format, 3454 NULL, NULL, NULL, size, flags, false, &local_err); 3455 } else { 3456 switch (arg->mode) { 3457 case NEW_IMAGE_MODE_EXISTING: 3458 break; 3459 case NEW_IMAGE_MODE_ABSOLUTE_PATHS: 3460 /* create new image with backing file */ 3461 bdrv_refresh_filename(source); 3462 bdrv_img_create(arg->target, format, 3463 source->filename, 3464 source->drv->format_name, 3465 NULL, size, flags, false, &local_err); 3466 break; 3467 default: 3468 abort(); 3469 } 3470 } 3471 3472 if (local_err) { 3473 error_propagate(errp, local_err); 3474 goto out; 3475 } 3476 3477 options = qdict_new(); 3478 if (arg->has_node_name) { 3479 qdict_put_str(options, "node-name", arg->node_name); 3480 } 3481 if (format) { 3482 qdict_put_str(options, "driver", format); 3483 } 3484 3485 /* Mirroring takes care of copy-on-write using the source's backing 3486 * file. 3487 */ 3488 target_bs = bdrv_open(arg->target, NULL, options, flags, errp); 3489 if (!target_bs) { 3490 goto out; 3491 } 3492 3493 zero_target = (arg->sync == MIRROR_SYNC_MODE_FULL && 3494 (arg->mode == NEW_IMAGE_MODE_EXISTING || 3495 !bdrv_has_zero_init(target_bs))); 3496 3497 3498 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */ 3499 old_context = bdrv_get_aio_context(target_bs); 3500 aio_context_release(aio_context); 3501 aio_context_acquire(old_context); 3502 3503 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp); 3504 if (ret < 0) { 3505 bdrv_unref(target_bs); 3506 aio_context_release(old_context); 3507 return; 3508 } 3509 3510 aio_context_release(old_context); 3511 aio_context_acquire(aio_context); 3512 3513 blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs, 3514 arg->has_replaces, arg->replaces, arg->sync, 3515 backing_mode, zero_target, 3516 arg->has_speed, arg->speed, 3517 arg->has_granularity, arg->granularity, 3518 arg->has_buf_size, arg->buf_size, 3519 arg->has_on_source_error, arg->on_source_error, 3520 arg->has_on_target_error, arg->on_target_error, 3521 arg->has_unmap, arg->unmap, 3522 false, NULL, 3523 arg->has_copy_mode, arg->copy_mode, 3524 arg->has_auto_finalize, arg->auto_finalize, 3525 arg->has_auto_dismiss, arg->auto_dismiss, 3526 &local_err); 3527 bdrv_unref(target_bs); 3528 error_propagate(errp, local_err); 3529 out: 3530 aio_context_release(aio_context); 3531 } 3532 3533 void qmp_blockdev_mirror(bool has_job_id, const char *job_id, 3534 const char *device, const char *target, 3535 bool has_replaces, const char *replaces, 3536 MirrorSyncMode sync, 3537 bool has_speed, int64_t speed, 3538 bool has_granularity, uint32_t granularity, 3539 bool has_buf_size, int64_t buf_size, 3540 bool has_on_source_error, 3541 BlockdevOnError on_source_error, 3542 bool has_on_target_error, 3543 BlockdevOnError on_target_error, 3544 bool has_filter_node_name, 3545 const char *filter_node_name, 3546 bool has_copy_mode, MirrorCopyMode copy_mode, 3547 bool has_auto_finalize, bool auto_finalize, 3548 bool has_auto_dismiss, bool auto_dismiss, 3549 Error **errp) 3550 { 3551 BlockDriverState *bs; 3552 BlockDriverState *target_bs; 3553 AioContext *aio_context; 3554 AioContext *old_context; 3555 BlockMirrorBackingMode backing_mode = MIRROR_LEAVE_BACKING_CHAIN; 3556 Error *local_err = NULL; 3557 bool zero_target; 3558 int ret; 3559 3560 bs = qmp_get_root_bs(device, errp); 3561 if (!bs) { 3562 return; 3563 } 3564 3565 target_bs = bdrv_lookup_bs(target, target, errp); 3566 if (!target_bs) { 3567 return; 3568 } 3569 3570 zero_target = (sync == MIRROR_SYNC_MODE_FULL); 3571 3572 /* Honor bdrv_try_set_aio_context() context acquisition requirements. */ 3573 old_context = bdrv_get_aio_context(target_bs); 3574 aio_context = bdrv_get_aio_context(bs); 3575 aio_context_acquire(old_context); 3576 3577 ret = bdrv_try_set_aio_context(target_bs, aio_context, errp); 3578 3579 aio_context_release(old_context); 3580 aio_context_acquire(aio_context); 3581 3582 if (ret < 0) { 3583 goto out; 3584 } 3585 3586 blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs, 3587 has_replaces, replaces, sync, backing_mode, 3588 zero_target, has_speed, speed, 3589 has_granularity, granularity, 3590 has_buf_size, buf_size, 3591 has_on_source_error, on_source_error, 3592 has_on_target_error, on_target_error, 3593 true, true, 3594 has_filter_node_name, filter_node_name, 3595 has_copy_mode, copy_mode, 3596 has_auto_finalize, auto_finalize, 3597 has_auto_dismiss, auto_dismiss, 3598 &local_err); 3599 error_propagate(errp, local_err); 3600 out: 3601 aio_context_release(aio_context); 3602 } 3603 3604 /* Get a block job using its ID and acquire its AioContext */ 3605 static BlockJob *find_block_job(const char *id, AioContext **aio_context, 3606 Error **errp) 3607 { 3608 BlockJob *job; 3609 3610 assert(id != NULL); 3611 3612 *aio_context = NULL; 3613 3614 job = block_job_get(id); 3615 3616 if (!job) { 3617 error_set(errp, ERROR_CLASS_DEVICE_NOT_ACTIVE, 3618 "Block job '%s' not found", id); 3619 return NULL; 3620 } 3621 3622 *aio_context = blk_get_aio_context(job->blk); 3623 aio_context_acquire(*aio_context); 3624 3625 return job; 3626 } 3627 3628 void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp) 3629 { 3630 AioContext *aio_context; 3631 BlockJob *job = find_block_job(device, &aio_context, errp); 3632 3633 if (!job) { 3634 return; 3635 } 3636 3637 block_job_set_speed(job, speed, errp); 3638 aio_context_release(aio_context); 3639 } 3640 3641 void qmp_block_job_cancel(const char *device, 3642 bool has_force, bool force, Error **errp) 3643 { 3644 AioContext *aio_context; 3645 BlockJob *job = find_block_job(device, &aio_context, errp); 3646 3647 if (!job) { 3648 return; 3649 } 3650 3651 if (!has_force) { 3652 force = false; 3653 } 3654 3655 if (job_user_paused(&job->job) && !force) { 3656 error_setg(errp, "The block job for device '%s' is currently paused", 3657 device); 3658 goto out; 3659 } 3660 3661 trace_qmp_block_job_cancel(job); 3662 job_user_cancel(&job->job, force, errp); 3663 out: 3664 aio_context_release(aio_context); 3665 } 3666 3667 void qmp_block_job_pause(const char *device, Error **errp) 3668 { 3669 AioContext *aio_context; 3670 BlockJob *job = find_block_job(device, &aio_context, errp); 3671 3672 if (!job) { 3673 return; 3674 } 3675 3676 trace_qmp_block_job_pause(job); 3677 job_user_pause(&job->job, errp); 3678 aio_context_release(aio_context); 3679 } 3680 3681 void qmp_block_job_resume(const char *device, Error **errp) 3682 { 3683 AioContext *aio_context; 3684 BlockJob *job = find_block_job(device, &aio_context, errp); 3685 3686 if (!job) { 3687 return; 3688 } 3689 3690 trace_qmp_block_job_resume(job); 3691 job_user_resume(&job->job, errp); 3692 aio_context_release(aio_context); 3693 } 3694 3695 void qmp_block_job_complete(const char *device, Error **errp) 3696 { 3697 AioContext *aio_context; 3698 BlockJob *job = find_block_job(device, &aio_context, errp); 3699 3700 if (!job) { 3701 return; 3702 } 3703 3704 trace_qmp_block_job_complete(job); 3705 job_complete(&job->job, errp); 3706 aio_context_release(aio_context); 3707 } 3708 3709 void qmp_block_job_finalize(const char *id, Error **errp) 3710 { 3711 AioContext *aio_context; 3712 BlockJob *job = find_block_job(id, &aio_context, errp); 3713 3714 if (!job) { 3715 return; 3716 } 3717 3718 trace_qmp_block_job_finalize(job); 3719 job_finalize(&job->job, errp); 3720 aio_context_release(aio_context); 3721 } 3722 3723 void qmp_block_job_dismiss(const char *id, Error **errp) 3724 { 3725 AioContext *aio_context; 3726 BlockJob *bjob = find_block_job(id, &aio_context, errp); 3727 Job *job; 3728 3729 if (!bjob) { 3730 return; 3731 } 3732 3733 trace_qmp_block_job_dismiss(bjob); 3734 job = &bjob->job; 3735 job_dismiss(&job, errp); 3736 aio_context_release(aio_context); 3737 } 3738 3739 void qmp_change_backing_file(const char *device, 3740 const char *image_node_name, 3741 const char *backing_file, 3742 Error **errp) 3743 { 3744 BlockDriverState *bs = NULL; 3745 AioContext *aio_context; 3746 BlockDriverState *image_bs = NULL; 3747 Error *local_err = NULL; 3748 bool ro; 3749 int ret; 3750 3751 bs = qmp_get_root_bs(device, errp); 3752 if (!bs) { 3753 return; 3754 } 3755 3756 aio_context = bdrv_get_aio_context(bs); 3757 aio_context_acquire(aio_context); 3758 3759 image_bs = bdrv_lookup_bs(NULL, image_node_name, &local_err); 3760 if (local_err) { 3761 error_propagate(errp, local_err); 3762 goto out; 3763 } 3764 3765 if (!image_bs) { 3766 error_setg(errp, "image file not found"); 3767 goto out; 3768 } 3769 3770 if (bdrv_find_base(image_bs) == image_bs) { 3771 error_setg(errp, "not allowing backing file change on an image " 3772 "without a backing file"); 3773 goto out; 3774 } 3775 3776 /* even though we are not necessarily operating on bs, we need it to 3777 * determine if block ops are currently prohibited on the chain */ 3778 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_CHANGE, errp)) { 3779 goto out; 3780 } 3781 3782 /* final sanity check */ 3783 if (!bdrv_chain_contains(bs, image_bs)) { 3784 error_setg(errp, "'%s' and image file are not in the same chain", 3785 device); 3786 goto out; 3787 } 3788 3789 /* if not r/w, reopen to make r/w */ 3790 ro = bdrv_is_read_only(image_bs); 3791 3792 if (ro) { 3793 if (bdrv_reopen_set_read_only(image_bs, false, errp) != 0) { 3794 goto out; 3795 } 3796 } 3797 3798 ret = bdrv_change_backing_file(image_bs, backing_file, 3799 image_bs->drv ? image_bs->drv->format_name : ""); 3800 3801 if (ret < 0) { 3802 error_setg_errno(errp, -ret, "Could not change backing file to '%s'", 3803 backing_file); 3804 /* don't exit here, so we can try to restore open flags if 3805 * appropriate */ 3806 } 3807 3808 if (ro) { 3809 bdrv_reopen_set_read_only(image_bs, true, &local_err); 3810 error_propagate(errp, local_err); 3811 } 3812 3813 out: 3814 aio_context_release(aio_context); 3815 } 3816 3817 void hmp_drive_add_node(Monitor *mon, const char *optstr) 3818 { 3819 QemuOpts *opts; 3820 QDict *qdict; 3821 Error *local_err = NULL; 3822 3823 opts = qemu_opts_parse_noisily(&qemu_drive_opts, optstr, false); 3824 if (!opts) { 3825 return; 3826 } 3827 3828 qdict = qemu_opts_to_qdict(opts, NULL); 3829 3830 if (!qdict_get_try_str(qdict, "node-name")) { 3831 qobject_unref(qdict); 3832 error_report("'node-name' needs to be specified"); 3833 goto out; 3834 } 3835 3836 BlockDriverState *bs = bds_tree_init(qdict, &local_err); 3837 if (!bs) { 3838 error_report_err(local_err); 3839 goto out; 3840 } 3841 3842 QTAILQ_INSERT_TAIL(&monitor_bdrv_states, bs, monitor_list); 3843 3844 out: 3845 qemu_opts_del(opts); 3846 } 3847 3848 void qmp_blockdev_add(BlockdevOptions *options, Error **errp) 3849 { 3850 BlockDriverState *bs; 3851 QObject *obj; 3852 Visitor *v = qobject_output_visitor_new(&obj); 3853 QDict *qdict; 3854 Error *local_err = NULL; 3855 3856 visit_type_BlockdevOptions(v, NULL, &options, &local_err); 3857 if (local_err) { 3858 error_propagate(errp, local_err); 3859 goto fail; 3860 } 3861 3862 visit_complete(v, &obj); 3863 qdict = qobject_to(QDict, obj); 3864 3865 qdict_flatten(qdict); 3866 3867 if (!qdict_get_try_str(qdict, "node-name")) { 3868 error_setg(errp, "'node-name' must be specified for the root node"); 3869 goto fail; 3870 } 3871 3872 bs = bds_tree_init(qdict, errp); 3873 if (!bs) { 3874 goto fail; 3875 } 3876 3877 QTAILQ_INSERT_TAIL(&monitor_bdrv_states, bs, monitor_list); 3878 3879 fail: 3880 visit_free(v); 3881 } 3882 3883 void qmp_x_blockdev_reopen(BlockdevOptions *options, Error **errp) 3884 { 3885 BlockDriverState *bs; 3886 AioContext *ctx; 3887 QObject *obj; 3888 Visitor *v = qobject_output_visitor_new(&obj); 3889 Error *local_err = NULL; 3890 BlockReopenQueue *queue; 3891 QDict *qdict; 3892 3893 /* Check for the selected node name */ 3894 if (!options->has_node_name) { 3895 error_setg(errp, "Node name not specified"); 3896 goto fail; 3897 } 3898 3899 bs = bdrv_find_node(options->node_name); 3900 if (!bs) { 3901 error_setg(errp, "Cannot find node named '%s'", options->node_name); 3902 goto fail; 3903 } 3904 3905 /* Put all options in a QDict and flatten it */ 3906 visit_type_BlockdevOptions(v, NULL, &options, &local_err); 3907 if (local_err) { 3908 error_propagate(errp, local_err); 3909 goto fail; 3910 } 3911 3912 visit_complete(v, &obj); 3913 qdict = qobject_to(QDict, obj); 3914 3915 qdict_flatten(qdict); 3916 3917 /* Perform the reopen operation */ 3918 ctx = bdrv_get_aio_context(bs); 3919 aio_context_acquire(ctx); 3920 bdrv_subtree_drained_begin(bs); 3921 queue = bdrv_reopen_queue(NULL, bs, qdict, false); 3922 bdrv_reopen_multiple(queue, errp); 3923 bdrv_subtree_drained_end(bs); 3924 aio_context_release(ctx); 3925 3926 fail: 3927 visit_free(v); 3928 } 3929 3930 void qmp_blockdev_del(const char *node_name, Error **errp) 3931 { 3932 AioContext *aio_context; 3933 BlockDriverState *bs; 3934 3935 bs = bdrv_find_node(node_name); 3936 if (!bs) { 3937 error_setg(errp, "Cannot find node %s", node_name); 3938 return; 3939 } 3940 if (bdrv_has_blk(bs)) { 3941 error_setg(errp, "Node %s is in use", node_name); 3942 return; 3943 } 3944 aio_context = bdrv_get_aio_context(bs); 3945 aio_context_acquire(aio_context); 3946 3947 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_DRIVE_DEL, errp)) { 3948 goto out; 3949 } 3950 3951 if (!QTAILQ_IN_USE(bs, monitor_list)) { 3952 error_setg(errp, "Node %s is not owned by the monitor", 3953 bs->node_name); 3954 goto out; 3955 } 3956 3957 if (bs->refcnt > 1) { 3958 error_setg(errp, "Block device %s is in use", 3959 bdrv_get_device_or_node_name(bs)); 3960 goto out; 3961 } 3962 3963 QTAILQ_REMOVE(&monitor_bdrv_states, bs, monitor_list); 3964 bdrv_unref(bs); 3965 3966 out: 3967 aio_context_release(aio_context); 3968 } 3969 3970 static BdrvChild *bdrv_find_child(BlockDriverState *parent_bs, 3971 const char *child_name) 3972 { 3973 BdrvChild *child; 3974 3975 QLIST_FOREACH(child, &parent_bs->children, next) { 3976 if (strcmp(child->name, child_name) == 0) { 3977 return child; 3978 } 3979 } 3980 3981 return NULL; 3982 } 3983 3984 void qmp_x_blockdev_change(const char *parent, bool has_child, 3985 const char *child, bool has_node, 3986 const char *node, Error **errp) 3987 { 3988 BlockDriverState *parent_bs, *new_bs = NULL; 3989 BdrvChild *p_child; 3990 3991 parent_bs = bdrv_lookup_bs(parent, parent, errp); 3992 if (!parent_bs) { 3993 return; 3994 } 3995 3996 if (has_child == has_node) { 3997 if (has_child) { 3998 error_setg(errp, "The parameters child and node are in conflict"); 3999 } else { 4000 error_setg(errp, "Either child or node must be specified"); 4001 } 4002 return; 4003 } 4004 4005 if (has_child) { 4006 p_child = bdrv_find_child(parent_bs, child); 4007 if (!p_child) { 4008 error_setg(errp, "Node '%s' does not have child '%s'", 4009 parent, child); 4010 return; 4011 } 4012 bdrv_del_child(parent_bs, p_child, errp); 4013 } 4014 4015 if (has_node) { 4016 new_bs = bdrv_find_node(node); 4017 if (!new_bs) { 4018 error_setg(errp, "Node '%s' not found", node); 4019 return; 4020 } 4021 bdrv_add_child(parent_bs, new_bs, errp); 4022 } 4023 } 4024 4025 BlockJobInfoList *qmp_query_block_jobs(Error **errp) 4026 { 4027 BlockJobInfoList *head = NULL, **p_next = &head; 4028 BlockJob *job; 4029 4030 for (job = block_job_next(NULL); job; job = block_job_next(job)) { 4031 BlockJobInfoList *elem; 4032 AioContext *aio_context; 4033 4034 if (block_job_is_internal(job)) { 4035 continue; 4036 } 4037 elem = g_new0(BlockJobInfoList, 1); 4038 aio_context = blk_get_aio_context(job->blk); 4039 aio_context_acquire(aio_context); 4040 elem->value = block_job_query(job, errp); 4041 aio_context_release(aio_context); 4042 if (!elem->value) { 4043 g_free(elem); 4044 qapi_free_BlockJobInfoList(head); 4045 return NULL; 4046 } 4047 *p_next = elem; 4048 p_next = &elem->next; 4049 } 4050 4051 return head; 4052 } 4053 4054 void qmp_x_blockdev_set_iothread(const char *node_name, StrOrNull *iothread, 4055 bool has_force, bool force, Error **errp) 4056 { 4057 AioContext *old_context; 4058 AioContext *new_context; 4059 BlockDriverState *bs; 4060 4061 bs = bdrv_find_node(node_name); 4062 if (!bs) { 4063 error_setg(errp, "Cannot find node %s", node_name); 4064 return; 4065 } 4066 4067 /* Protects against accidents. */ 4068 if (!(has_force && force) && bdrv_has_blk(bs)) { 4069 error_setg(errp, "Node %s is associated with a BlockBackend and could " 4070 "be in use (use force=true to override this check)", 4071 node_name); 4072 return; 4073 } 4074 4075 if (iothread->type == QTYPE_QSTRING) { 4076 IOThread *obj = iothread_by_id(iothread->u.s); 4077 if (!obj) { 4078 error_setg(errp, "Cannot find iothread %s", iothread->u.s); 4079 return; 4080 } 4081 4082 new_context = iothread_get_aio_context(obj); 4083 } else { 4084 new_context = qemu_get_aio_context(); 4085 } 4086 4087 old_context = bdrv_get_aio_context(bs); 4088 aio_context_acquire(old_context); 4089 4090 bdrv_try_set_aio_context(bs, new_context, errp); 4091 4092 aio_context_release(old_context); 4093 } 4094 4095 QemuOptsList qemu_common_drive_opts = { 4096 .name = "drive", 4097 .head = QTAILQ_HEAD_INITIALIZER(qemu_common_drive_opts.head), 4098 .desc = { 4099 { 4100 .name = "snapshot", 4101 .type = QEMU_OPT_BOOL, 4102 .help = "enable/disable snapshot mode", 4103 },{ 4104 .name = "aio", 4105 .type = QEMU_OPT_STRING, 4106 .help = "host AIO implementation (threads, native, io_uring)", 4107 },{ 4108 .name = BDRV_OPT_CACHE_WB, 4109 .type = QEMU_OPT_BOOL, 4110 .help = "Enable writeback mode", 4111 },{ 4112 .name = "format", 4113 .type = QEMU_OPT_STRING, 4114 .help = "disk format (raw, qcow2, ...)", 4115 },{ 4116 .name = "rerror", 4117 .type = QEMU_OPT_STRING, 4118 .help = "read error action", 4119 },{ 4120 .name = "werror", 4121 .type = QEMU_OPT_STRING, 4122 .help = "write error action", 4123 },{ 4124 .name = BDRV_OPT_READ_ONLY, 4125 .type = QEMU_OPT_BOOL, 4126 .help = "open drive file as read-only", 4127 }, 4128 4129 THROTTLE_OPTS, 4130 4131 { 4132 .name = "throttling.group", 4133 .type = QEMU_OPT_STRING, 4134 .help = "name of the block throttling group", 4135 },{ 4136 .name = "copy-on-read", 4137 .type = QEMU_OPT_BOOL, 4138 .help = "copy read data from backing file into image file", 4139 },{ 4140 .name = "detect-zeroes", 4141 .type = QEMU_OPT_STRING, 4142 .help = "try to optimize zero writes (off, on, unmap)", 4143 },{ 4144 .name = "stats-account-invalid", 4145 .type = QEMU_OPT_BOOL, 4146 .help = "whether to account for invalid I/O operations " 4147 "in the statistics", 4148 },{ 4149 .name = "stats-account-failed", 4150 .type = QEMU_OPT_BOOL, 4151 .help = "whether to account for failed I/O operations " 4152 "in the statistics", 4153 }, 4154 { /* end of list */ } 4155 }, 4156 }; 4157 4158 QemuOptsList qemu_drive_opts = { 4159 .name = "drive", 4160 .head = QTAILQ_HEAD_INITIALIZER(qemu_drive_opts.head), 4161 .desc = { 4162 /* 4163 * no elements => accept any params 4164 * validation will happen later 4165 */ 4166 { /* end of list */ } 4167 }, 4168 }; 4169