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