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