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