1 /* 2 * QEMU System Emulator block driver 3 * 4 * Copyright (c) 2003 Fabrice Bellard 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu/osdep.h" 25 #include "qemu-common.h" 26 #include "trace.h" 27 #include "block/block_int.h" 28 #include "block/blockjob.h" 29 #include "qemu/error-report.h" 30 #include "qemu/module.h" 31 #include "qapi/qmp/qerror.h" 32 #include "qapi/qmp/qbool.h" 33 #include "qapi/qmp/qjson.h" 34 #include "sysemu/block-backend.h" 35 #include "sysemu/sysemu.h" 36 #include "qemu/notify.h" 37 #include "qemu/coroutine.h" 38 #include "block/qapi.h" 39 #include "qmp-commands.h" 40 #include "qemu/timer.h" 41 #include "qapi-event.h" 42 #include "block/throttle-groups.h" 43 44 #ifdef CONFIG_BSD 45 #include <sys/ioctl.h> 46 #include <sys/queue.h> 47 #ifndef __DragonFly__ 48 #include <sys/disk.h> 49 #endif 50 #endif 51 52 #ifdef _WIN32 53 #include <windows.h> 54 #endif 55 56 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ 57 58 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states = 59 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states); 60 61 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states = 62 QTAILQ_HEAD_INITIALIZER(all_bdrv_states); 63 64 static QLIST_HEAD(, BlockDriver) bdrv_drivers = 65 QLIST_HEAD_INITIALIZER(bdrv_drivers); 66 67 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename, 68 const char *reference, QDict *options, int flags, 69 BlockDriverState *parent, 70 const BdrvChildRole *child_role, Error **errp); 71 72 /* If non-zero, use only whitelisted block drivers */ 73 static int use_bdrv_whitelist; 74 75 static void bdrv_close(BlockDriverState *bs); 76 77 #ifdef _WIN32 78 static int is_windows_drive_prefix(const char *filename) 79 { 80 return (((filename[0] >= 'a' && filename[0] <= 'z') || 81 (filename[0] >= 'A' && filename[0] <= 'Z')) && 82 filename[1] == ':'); 83 } 84 85 int is_windows_drive(const char *filename) 86 { 87 if (is_windows_drive_prefix(filename) && 88 filename[2] == '\0') 89 return 1; 90 if (strstart(filename, "\\\\.\\", NULL) || 91 strstart(filename, "//./", NULL)) 92 return 1; 93 return 0; 94 } 95 #endif 96 97 size_t bdrv_opt_mem_align(BlockDriverState *bs) 98 { 99 if (!bs || !bs->drv) { 100 /* page size or 4k (hdd sector size) should be on the safe side */ 101 return MAX(4096, getpagesize()); 102 } 103 104 return bs->bl.opt_mem_alignment; 105 } 106 107 size_t bdrv_min_mem_align(BlockDriverState *bs) 108 { 109 if (!bs || !bs->drv) { 110 /* page size or 4k (hdd sector size) should be on the safe side */ 111 return MAX(4096, getpagesize()); 112 } 113 114 return bs->bl.min_mem_alignment; 115 } 116 117 /* check if the path starts with "<protocol>:" */ 118 int path_has_protocol(const char *path) 119 { 120 const char *p; 121 122 #ifdef _WIN32 123 if (is_windows_drive(path) || 124 is_windows_drive_prefix(path)) { 125 return 0; 126 } 127 p = path + strcspn(path, ":/\\"); 128 #else 129 p = path + strcspn(path, ":/"); 130 #endif 131 132 return *p == ':'; 133 } 134 135 int path_is_absolute(const char *path) 136 { 137 #ifdef _WIN32 138 /* specific case for names like: "\\.\d:" */ 139 if (is_windows_drive(path) || is_windows_drive_prefix(path)) { 140 return 1; 141 } 142 return (*path == '/' || *path == '\\'); 143 #else 144 return (*path == '/'); 145 #endif 146 } 147 148 /* if filename is absolute, just copy it to dest. Otherwise, build a 149 path to it by considering it is relative to base_path. URL are 150 supported. */ 151 void path_combine(char *dest, int dest_size, 152 const char *base_path, 153 const char *filename) 154 { 155 const char *p, *p1; 156 int len; 157 158 if (dest_size <= 0) 159 return; 160 if (path_is_absolute(filename)) { 161 pstrcpy(dest, dest_size, filename); 162 } else { 163 p = strchr(base_path, ':'); 164 if (p) 165 p++; 166 else 167 p = base_path; 168 p1 = strrchr(base_path, '/'); 169 #ifdef _WIN32 170 { 171 const char *p2; 172 p2 = strrchr(base_path, '\\'); 173 if (!p1 || p2 > p1) 174 p1 = p2; 175 } 176 #endif 177 if (p1) 178 p1++; 179 else 180 p1 = base_path; 181 if (p1 > p) 182 p = p1; 183 len = p - base_path; 184 if (len > dest_size - 1) 185 len = dest_size - 1; 186 memcpy(dest, base_path, len); 187 dest[len] = '\0'; 188 pstrcat(dest, dest_size, filename); 189 } 190 } 191 192 void bdrv_get_full_backing_filename_from_filename(const char *backed, 193 const char *backing, 194 char *dest, size_t sz, 195 Error **errp) 196 { 197 if (backing[0] == '\0' || path_has_protocol(backing) || 198 path_is_absolute(backing)) 199 { 200 pstrcpy(dest, sz, backing); 201 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) { 202 error_setg(errp, "Cannot use relative backing file names for '%s'", 203 backed); 204 } else { 205 path_combine(dest, sz, backed, backing); 206 } 207 } 208 209 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz, 210 Error **errp) 211 { 212 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename; 213 214 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file, 215 dest, sz, errp); 216 } 217 218 void bdrv_register(BlockDriver *bdrv) 219 { 220 bdrv_setup_io_funcs(bdrv); 221 222 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list); 223 } 224 225 BlockDriverState *bdrv_new_root(void) 226 { 227 return bdrv_new(); 228 } 229 230 BlockDriverState *bdrv_new(void) 231 { 232 BlockDriverState *bs; 233 int i; 234 235 bs = g_new0(BlockDriverState, 1); 236 QLIST_INIT(&bs->dirty_bitmaps); 237 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 238 QLIST_INIT(&bs->op_blockers[i]); 239 } 240 notifier_with_return_list_init(&bs->before_write_notifiers); 241 qemu_co_queue_init(&bs->throttled_reqs[0]); 242 qemu_co_queue_init(&bs->throttled_reqs[1]); 243 bs->refcnt = 1; 244 bs->aio_context = qemu_get_aio_context(); 245 246 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list); 247 248 return bs; 249 } 250 251 BlockDriver *bdrv_find_format(const char *format_name) 252 { 253 BlockDriver *drv1; 254 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 255 if (!strcmp(drv1->format_name, format_name)) { 256 return drv1; 257 } 258 } 259 return NULL; 260 } 261 262 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only) 263 { 264 static const char *whitelist_rw[] = { 265 CONFIG_BDRV_RW_WHITELIST 266 }; 267 static const char *whitelist_ro[] = { 268 CONFIG_BDRV_RO_WHITELIST 269 }; 270 const char **p; 271 272 if (!whitelist_rw[0] && !whitelist_ro[0]) { 273 return 1; /* no whitelist, anything goes */ 274 } 275 276 for (p = whitelist_rw; *p; p++) { 277 if (!strcmp(drv->format_name, *p)) { 278 return 1; 279 } 280 } 281 if (read_only) { 282 for (p = whitelist_ro; *p; p++) { 283 if (!strcmp(drv->format_name, *p)) { 284 return 1; 285 } 286 } 287 } 288 return 0; 289 } 290 291 typedef struct CreateCo { 292 BlockDriver *drv; 293 char *filename; 294 QemuOpts *opts; 295 int ret; 296 Error *err; 297 } CreateCo; 298 299 static void coroutine_fn bdrv_create_co_entry(void *opaque) 300 { 301 Error *local_err = NULL; 302 int ret; 303 304 CreateCo *cco = opaque; 305 assert(cco->drv); 306 307 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err); 308 if (local_err) { 309 error_propagate(&cco->err, local_err); 310 } 311 cco->ret = ret; 312 } 313 314 int bdrv_create(BlockDriver *drv, const char* filename, 315 QemuOpts *opts, Error **errp) 316 { 317 int ret; 318 319 Coroutine *co; 320 CreateCo cco = { 321 .drv = drv, 322 .filename = g_strdup(filename), 323 .opts = opts, 324 .ret = NOT_DONE, 325 .err = NULL, 326 }; 327 328 if (!drv->bdrv_create) { 329 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name); 330 ret = -ENOTSUP; 331 goto out; 332 } 333 334 if (qemu_in_coroutine()) { 335 /* Fast-path if already in coroutine context */ 336 bdrv_create_co_entry(&cco); 337 } else { 338 co = qemu_coroutine_create(bdrv_create_co_entry); 339 qemu_coroutine_enter(co, &cco); 340 while (cco.ret == NOT_DONE) { 341 aio_poll(qemu_get_aio_context(), true); 342 } 343 } 344 345 ret = cco.ret; 346 if (ret < 0) { 347 if (cco.err) { 348 error_propagate(errp, cco.err); 349 } else { 350 error_setg_errno(errp, -ret, "Could not create image"); 351 } 352 } 353 354 out: 355 g_free(cco.filename); 356 return ret; 357 } 358 359 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp) 360 { 361 BlockDriver *drv; 362 Error *local_err = NULL; 363 int ret; 364 365 drv = bdrv_find_protocol(filename, true, errp); 366 if (drv == NULL) { 367 return -ENOENT; 368 } 369 370 ret = bdrv_create(drv, filename, opts, &local_err); 371 if (local_err) { 372 error_propagate(errp, local_err); 373 } 374 return ret; 375 } 376 377 /** 378 * Try to get @bs's logical and physical block size. 379 * On success, store them in @bsz struct and return 0. 380 * On failure return -errno. 381 * @bs must not be empty. 382 */ 383 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz) 384 { 385 BlockDriver *drv = bs->drv; 386 387 if (drv && drv->bdrv_probe_blocksizes) { 388 return drv->bdrv_probe_blocksizes(bs, bsz); 389 } 390 391 return -ENOTSUP; 392 } 393 394 /** 395 * Try to get @bs's geometry (cyls, heads, sectors). 396 * On success, store them in @geo struct and return 0. 397 * On failure return -errno. 398 * @bs must not be empty. 399 */ 400 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo) 401 { 402 BlockDriver *drv = bs->drv; 403 404 if (drv && drv->bdrv_probe_geometry) { 405 return drv->bdrv_probe_geometry(bs, geo); 406 } 407 408 return -ENOTSUP; 409 } 410 411 /* 412 * Create a uniquely-named empty temporary file. 413 * Return 0 upon success, otherwise a negative errno value. 414 */ 415 int get_tmp_filename(char *filename, int size) 416 { 417 #ifdef _WIN32 418 char temp_dir[MAX_PATH]; 419 /* GetTempFileName requires that its output buffer (4th param) 420 have length MAX_PATH or greater. */ 421 assert(size >= MAX_PATH); 422 return (GetTempPath(MAX_PATH, temp_dir) 423 && GetTempFileName(temp_dir, "qem", 0, filename) 424 ? 0 : -GetLastError()); 425 #else 426 int fd; 427 const char *tmpdir; 428 tmpdir = getenv("TMPDIR"); 429 if (!tmpdir) { 430 tmpdir = "/var/tmp"; 431 } 432 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) { 433 return -EOVERFLOW; 434 } 435 fd = mkstemp(filename); 436 if (fd < 0) { 437 return -errno; 438 } 439 if (close(fd) != 0) { 440 unlink(filename); 441 return -errno; 442 } 443 return 0; 444 #endif 445 } 446 447 /* 448 * Detect host devices. By convention, /dev/cdrom[N] is always 449 * recognized as a host CDROM. 450 */ 451 static BlockDriver *find_hdev_driver(const char *filename) 452 { 453 int score_max = 0, score; 454 BlockDriver *drv = NULL, *d; 455 456 QLIST_FOREACH(d, &bdrv_drivers, list) { 457 if (d->bdrv_probe_device) { 458 score = d->bdrv_probe_device(filename); 459 if (score > score_max) { 460 score_max = score; 461 drv = d; 462 } 463 } 464 } 465 466 return drv; 467 } 468 469 BlockDriver *bdrv_find_protocol(const char *filename, 470 bool allow_protocol_prefix, 471 Error **errp) 472 { 473 BlockDriver *drv1; 474 char protocol[128]; 475 int len; 476 const char *p; 477 478 /* TODO Drivers without bdrv_file_open must be specified explicitly */ 479 480 /* 481 * XXX(hch): we really should not let host device detection 482 * override an explicit protocol specification, but moving this 483 * later breaks access to device names with colons in them. 484 * Thanks to the brain-dead persistent naming schemes on udev- 485 * based Linux systems those actually are quite common. 486 */ 487 drv1 = find_hdev_driver(filename); 488 if (drv1) { 489 return drv1; 490 } 491 492 if (!path_has_protocol(filename) || !allow_protocol_prefix) { 493 return &bdrv_file; 494 } 495 496 p = strchr(filename, ':'); 497 assert(p != NULL); 498 len = p - filename; 499 if (len > sizeof(protocol) - 1) 500 len = sizeof(protocol) - 1; 501 memcpy(protocol, filename, len); 502 protocol[len] = '\0'; 503 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 504 if (drv1->protocol_name && 505 !strcmp(drv1->protocol_name, protocol)) { 506 return drv1; 507 } 508 } 509 510 error_setg(errp, "Unknown protocol '%s'", protocol); 511 return NULL; 512 } 513 514 /* 515 * Guess image format by probing its contents. 516 * This is not a good idea when your image is raw (CVE-2008-2004), but 517 * we do it anyway for backward compatibility. 518 * 519 * @buf contains the image's first @buf_size bytes. 520 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE, 521 * but can be smaller if the image file is smaller) 522 * @filename is its filename. 523 * 524 * For all block drivers, call the bdrv_probe() method to get its 525 * probing score. 526 * Return the first block driver with the highest probing score. 527 */ 528 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, 529 const char *filename) 530 { 531 int score_max = 0, score; 532 BlockDriver *drv = NULL, *d; 533 534 QLIST_FOREACH(d, &bdrv_drivers, list) { 535 if (d->bdrv_probe) { 536 score = d->bdrv_probe(buf, buf_size, filename); 537 if (score > score_max) { 538 score_max = score; 539 drv = d; 540 } 541 } 542 } 543 544 return drv; 545 } 546 547 static int find_image_format(BlockDriverState *bs, const char *filename, 548 BlockDriver **pdrv, Error **errp) 549 { 550 BlockDriver *drv; 551 uint8_t buf[BLOCK_PROBE_BUF_SIZE]; 552 int ret = 0; 553 554 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */ 555 if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) { 556 *pdrv = &bdrv_raw; 557 return ret; 558 } 559 560 ret = bdrv_pread(bs, 0, buf, sizeof(buf)); 561 if (ret < 0) { 562 error_setg_errno(errp, -ret, "Could not read image for determining its " 563 "format"); 564 *pdrv = NULL; 565 return ret; 566 } 567 568 drv = bdrv_probe_all(buf, ret, filename); 569 if (!drv) { 570 error_setg(errp, "Could not determine image format: No compatible " 571 "driver found"); 572 ret = -ENOENT; 573 } 574 *pdrv = drv; 575 return ret; 576 } 577 578 /** 579 * Set the current 'total_sectors' value 580 * Return 0 on success, -errno on error. 581 */ 582 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint) 583 { 584 BlockDriver *drv = bs->drv; 585 586 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */ 587 if (bdrv_is_sg(bs)) 588 return 0; 589 590 /* query actual device if possible, otherwise just trust the hint */ 591 if (drv->bdrv_getlength) { 592 int64_t length = drv->bdrv_getlength(bs); 593 if (length < 0) { 594 return length; 595 } 596 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE); 597 } 598 599 bs->total_sectors = hint; 600 return 0; 601 } 602 603 /** 604 * Combines a QDict of new block driver @options with any missing options taken 605 * from @old_options, so that leaving out an option defaults to its old value. 606 */ 607 static void bdrv_join_options(BlockDriverState *bs, QDict *options, 608 QDict *old_options) 609 { 610 if (bs->drv && bs->drv->bdrv_join_options) { 611 bs->drv->bdrv_join_options(options, old_options); 612 } else { 613 qdict_join(options, old_options, false); 614 } 615 } 616 617 /** 618 * Set open flags for a given discard mode 619 * 620 * Return 0 on success, -1 if the discard mode was invalid. 621 */ 622 int bdrv_parse_discard_flags(const char *mode, int *flags) 623 { 624 *flags &= ~BDRV_O_UNMAP; 625 626 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) { 627 /* do nothing */ 628 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) { 629 *flags |= BDRV_O_UNMAP; 630 } else { 631 return -1; 632 } 633 634 return 0; 635 } 636 637 /** 638 * Set open flags for a given cache mode 639 * 640 * Return 0 on success, -1 if the cache mode was invalid. 641 */ 642 int bdrv_parse_cache_flags(const char *mode, int *flags) 643 { 644 *flags &= ~BDRV_O_CACHE_MASK; 645 646 if (!strcmp(mode, "off") || !strcmp(mode, "none")) { 647 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB; 648 } else if (!strcmp(mode, "directsync")) { 649 *flags |= BDRV_O_NOCACHE; 650 } else if (!strcmp(mode, "writeback")) { 651 *flags |= BDRV_O_CACHE_WB; 652 } else if (!strcmp(mode, "unsafe")) { 653 *flags |= BDRV_O_CACHE_WB; 654 *flags |= BDRV_O_NO_FLUSH; 655 } else if (!strcmp(mode, "writethrough")) { 656 /* this is the default */ 657 } else { 658 return -1; 659 } 660 661 return 0; 662 } 663 664 /* 665 * Returns the options and flags that a temporary snapshot should get, based on 666 * the originally requested flags (the originally requested image will have 667 * flags like a backing file) 668 */ 669 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options, 670 int parent_flags, QDict *parent_options) 671 { 672 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY; 673 674 /* For temporary files, unconditional cache=unsafe is fine */ 675 qdict_set_default_str(child_options, BDRV_OPT_CACHE_WB, "on"); 676 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off"); 677 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on"); 678 } 679 680 /* 681 * Returns the options and flags that bs->file should get if a protocol driver 682 * is expected, based on the given options and flags for the parent BDS 683 */ 684 static void bdrv_inherited_options(int *child_flags, QDict *child_options, 685 int parent_flags, QDict *parent_options) 686 { 687 int flags = parent_flags; 688 689 /* Enable protocol handling, disable format probing for bs->file */ 690 flags |= BDRV_O_PROTOCOL; 691 692 /* If the cache mode isn't explicitly set, inherit direct and no-flush from 693 * the parent. */ 694 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT); 695 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH); 696 697 /* Our block drivers take care to send flushes and respect unmap policy, 698 * so we can default to enable both on lower layers regardless of the 699 * corresponding parent options. */ 700 qdict_set_default_str(child_options, BDRV_OPT_CACHE_WB, "on"); 701 flags |= BDRV_O_UNMAP; 702 703 /* Clear flags that only apply to the top layer */ 704 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ); 705 706 *child_flags = flags; 707 } 708 709 const BdrvChildRole child_file = { 710 .inherit_options = bdrv_inherited_options, 711 }; 712 713 /* 714 * Returns the options and flags that bs->file should get if the use of formats 715 * (and not only protocols) is permitted for it, based on the given options and 716 * flags for the parent BDS 717 */ 718 static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options, 719 int parent_flags, QDict *parent_options) 720 { 721 child_file.inherit_options(child_flags, child_options, 722 parent_flags, parent_options); 723 724 *child_flags &= ~BDRV_O_PROTOCOL; 725 } 726 727 const BdrvChildRole child_format = { 728 .inherit_options = bdrv_inherited_fmt_options, 729 }; 730 731 /* 732 * Returns the options and flags that bs->backing should get, based on the 733 * given options and flags for the parent BDS 734 */ 735 static void bdrv_backing_options(int *child_flags, QDict *child_options, 736 int parent_flags, QDict *parent_options) 737 { 738 int flags = parent_flags; 739 740 /* The cache mode is inherited unmodified for backing files */ 741 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_WB); 742 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT); 743 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH); 744 745 /* backing files always opened read-only */ 746 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ); 747 748 /* snapshot=on is handled on the top layer */ 749 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY); 750 751 *child_flags = flags; 752 } 753 754 static const BdrvChildRole child_backing = { 755 .inherit_options = bdrv_backing_options, 756 }; 757 758 static int bdrv_open_flags(BlockDriverState *bs, int flags) 759 { 760 int open_flags = flags | BDRV_O_CACHE_WB; 761 762 /* 763 * Clear flags that are internal to the block layer before opening the 764 * image. 765 */ 766 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL); 767 768 /* 769 * Snapshots should be writable. 770 */ 771 if (flags & BDRV_O_TEMPORARY) { 772 open_flags |= BDRV_O_RDWR; 773 } 774 775 return open_flags; 776 } 777 778 static void update_flags_from_options(int *flags, QemuOpts *opts) 779 { 780 *flags &= ~BDRV_O_CACHE_MASK; 781 782 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_WB)); 783 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_WB, false)) { 784 *flags |= BDRV_O_CACHE_WB; 785 } 786 787 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH)); 788 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) { 789 *flags |= BDRV_O_NO_FLUSH; 790 } 791 792 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT)); 793 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) { 794 *flags |= BDRV_O_NOCACHE; 795 } 796 } 797 798 static void update_options_from_flags(QDict *options, int flags) 799 { 800 if (!qdict_haskey(options, BDRV_OPT_CACHE_WB)) { 801 qdict_put(options, BDRV_OPT_CACHE_WB, 802 qbool_from_bool(flags & BDRV_O_CACHE_WB)); 803 } 804 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) { 805 qdict_put(options, BDRV_OPT_CACHE_DIRECT, 806 qbool_from_bool(flags & BDRV_O_NOCACHE)); 807 } 808 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) { 809 qdict_put(options, BDRV_OPT_CACHE_NO_FLUSH, 810 qbool_from_bool(flags & BDRV_O_NO_FLUSH)); 811 } 812 } 813 814 static void bdrv_assign_node_name(BlockDriverState *bs, 815 const char *node_name, 816 Error **errp) 817 { 818 char *gen_node_name = NULL; 819 820 if (!node_name) { 821 node_name = gen_node_name = id_generate(ID_BLOCK); 822 } else if (!id_wellformed(node_name)) { 823 /* 824 * Check for empty string or invalid characters, but not if it is 825 * generated (generated names use characters not available to the user) 826 */ 827 error_setg(errp, "Invalid node name"); 828 return; 829 } 830 831 /* takes care of avoiding namespaces collisions */ 832 if (blk_by_name(node_name)) { 833 error_setg(errp, "node-name=%s is conflicting with a device id", 834 node_name); 835 goto out; 836 } 837 838 /* takes care of avoiding duplicates node names */ 839 if (bdrv_find_node(node_name)) { 840 error_setg(errp, "Duplicate node name"); 841 goto out; 842 } 843 844 /* copy node name into the bs and insert it into the graph list */ 845 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name); 846 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list); 847 out: 848 g_free(gen_node_name); 849 } 850 851 static QemuOptsList bdrv_runtime_opts = { 852 .name = "bdrv_common", 853 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head), 854 .desc = { 855 { 856 .name = "node-name", 857 .type = QEMU_OPT_STRING, 858 .help = "Node name of the block device node", 859 }, 860 { 861 .name = "driver", 862 .type = QEMU_OPT_STRING, 863 .help = "Block driver to use for the node", 864 }, 865 { 866 .name = BDRV_OPT_CACHE_WB, 867 .type = QEMU_OPT_BOOL, 868 .help = "Enable writeback mode", 869 }, 870 { 871 .name = BDRV_OPT_CACHE_DIRECT, 872 .type = QEMU_OPT_BOOL, 873 .help = "Bypass software writeback cache on the host", 874 }, 875 { 876 .name = BDRV_OPT_CACHE_NO_FLUSH, 877 .type = QEMU_OPT_BOOL, 878 .help = "Ignore flush requests", 879 }, 880 { /* end of list */ } 881 }, 882 }; 883 884 /* 885 * Common part for opening disk images and files 886 * 887 * Removes all processed options from *options. 888 */ 889 static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file, 890 QDict *options, Error **errp) 891 { 892 int ret, open_flags; 893 const char *filename; 894 const char *driver_name = NULL; 895 const char *node_name = NULL; 896 QemuOpts *opts; 897 BlockDriver *drv; 898 Error *local_err = NULL; 899 900 assert(bs->file == NULL); 901 assert(options != NULL && bs->options != options); 902 903 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort); 904 qemu_opts_absorb_qdict(opts, options, &local_err); 905 if (local_err) { 906 error_propagate(errp, local_err); 907 ret = -EINVAL; 908 goto fail_opts; 909 } 910 911 driver_name = qemu_opt_get(opts, "driver"); 912 drv = bdrv_find_format(driver_name); 913 assert(drv != NULL); 914 915 if (file != NULL) { 916 filename = file->bs->filename; 917 } else { 918 filename = qdict_get_try_str(options, "filename"); 919 } 920 921 if (drv->bdrv_needs_filename && !filename) { 922 error_setg(errp, "The '%s' block driver requires a file name", 923 drv->format_name); 924 ret = -EINVAL; 925 goto fail_opts; 926 } 927 928 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags, 929 drv->format_name); 930 931 node_name = qemu_opt_get(opts, "node-name"); 932 bdrv_assign_node_name(bs, node_name, &local_err); 933 if (local_err) { 934 error_propagate(errp, local_err); 935 ret = -EINVAL; 936 goto fail_opts; 937 } 938 939 bs->request_alignment = 512; 940 bs->zero_beyond_eof = true; 941 bs->read_only = !(bs->open_flags & BDRV_O_RDWR); 942 943 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) { 944 error_setg(errp, 945 !bs->read_only && bdrv_is_whitelisted(drv, true) 946 ? "Driver '%s' can only be used for read-only devices" 947 : "Driver '%s' is not whitelisted", 948 drv->format_name); 949 ret = -ENOTSUP; 950 goto fail_opts; 951 } 952 953 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */ 954 if (bs->open_flags & BDRV_O_COPY_ON_READ) { 955 if (!bs->read_only) { 956 bdrv_enable_copy_on_read(bs); 957 } else { 958 error_setg(errp, "Can't use copy-on-read on read-only device"); 959 ret = -EINVAL; 960 goto fail_opts; 961 } 962 } 963 964 if (filename != NULL) { 965 pstrcpy(bs->filename, sizeof(bs->filename), filename); 966 } else { 967 bs->filename[0] = '\0'; 968 } 969 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename); 970 971 bs->drv = drv; 972 bs->opaque = g_malloc0(drv->instance_size); 973 974 /* Apply cache mode options */ 975 update_flags_from_options(&bs->open_flags, opts); 976 bdrv_set_enable_write_cache(bs, bs->open_flags & BDRV_O_CACHE_WB); 977 978 /* Open the image, either directly or using a protocol */ 979 open_flags = bdrv_open_flags(bs, bs->open_flags); 980 if (drv->bdrv_file_open) { 981 assert(file == NULL); 982 assert(!drv->bdrv_needs_filename || filename != NULL); 983 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err); 984 } else { 985 if (file == NULL) { 986 error_setg(errp, "Can't use '%s' as a block driver for the " 987 "protocol level", drv->format_name); 988 ret = -EINVAL; 989 goto free_and_fail; 990 } 991 bs->file = file; 992 ret = drv->bdrv_open(bs, options, open_flags, &local_err); 993 } 994 995 if (ret < 0) { 996 if (local_err) { 997 error_propagate(errp, local_err); 998 } else if (bs->filename[0]) { 999 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename); 1000 } else { 1001 error_setg_errno(errp, -ret, "Could not open image"); 1002 } 1003 goto free_and_fail; 1004 } 1005 1006 if (bs->encrypted) { 1007 error_report("Encrypted images are deprecated"); 1008 error_printf("Support for them will be removed in a future release.\n" 1009 "You can use 'qemu-img convert' to convert your image" 1010 " to an unencrypted one.\n"); 1011 } 1012 1013 ret = refresh_total_sectors(bs, bs->total_sectors); 1014 if (ret < 0) { 1015 error_setg_errno(errp, -ret, "Could not refresh total sector count"); 1016 goto free_and_fail; 1017 } 1018 1019 bdrv_refresh_limits(bs, &local_err); 1020 if (local_err) { 1021 error_propagate(errp, local_err); 1022 ret = -EINVAL; 1023 goto free_and_fail; 1024 } 1025 1026 assert(bdrv_opt_mem_align(bs) != 0); 1027 assert(bdrv_min_mem_align(bs) != 0); 1028 assert((bs->request_alignment != 0) || bdrv_is_sg(bs)); 1029 1030 qemu_opts_del(opts); 1031 return 0; 1032 1033 free_and_fail: 1034 bs->file = NULL; 1035 g_free(bs->opaque); 1036 bs->opaque = NULL; 1037 bs->drv = NULL; 1038 fail_opts: 1039 qemu_opts_del(opts); 1040 return ret; 1041 } 1042 1043 static QDict *parse_json_filename(const char *filename, Error **errp) 1044 { 1045 QObject *options_obj; 1046 QDict *options; 1047 int ret; 1048 1049 ret = strstart(filename, "json:", &filename); 1050 assert(ret); 1051 1052 options_obj = qobject_from_json(filename); 1053 if (!options_obj) { 1054 error_setg(errp, "Could not parse the JSON options"); 1055 return NULL; 1056 } 1057 1058 if (qobject_type(options_obj) != QTYPE_QDICT) { 1059 qobject_decref(options_obj); 1060 error_setg(errp, "Invalid JSON object given"); 1061 return NULL; 1062 } 1063 1064 options = qobject_to_qdict(options_obj); 1065 qdict_flatten(options); 1066 1067 return options; 1068 } 1069 1070 static void parse_json_protocol(QDict *options, const char **pfilename, 1071 Error **errp) 1072 { 1073 QDict *json_options; 1074 Error *local_err = NULL; 1075 1076 /* Parse json: pseudo-protocol */ 1077 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) { 1078 return; 1079 } 1080 1081 json_options = parse_json_filename(*pfilename, &local_err); 1082 if (local_err) { 1083 error_propagate(errp, local_err); 1084 return; 1085 } 1086 1087 /* Options given in the filename have lower priority than options 1088 * specified directly */ 1089 qdict_join(options, json_options, false); 1090 QDECREF(json_options); 1091 *pfilename = NULL; 1092 } 1093 1094 /* 1095 * Fills in default options for opening images and converts the legacy 1096 * filename/flags pair to option QDict entries. 1097 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a 1098 * block driver has been specified explicitly. 1099 */ 1100 static int bdrv_fill_options(QDict **options, const char *filename, 1101 int *flags, Error **errp) 1102 { 1103 const char *drvname; 1104 bool protocol = *flags & BDRV_O_PROTOCOL; 1105 bool parse_filename = false; 1106 BlockDriver *drv = NULL; 1107 Error *local_err = NULL; 1108 1109 drvname = qdict_get_try_str(*options, "driver"); 1110 if (drvname) { 1111 drv = bdrv_find_format(drvname); 1112 if (!drv) { 1113 error_setg(errp, "Unknown driver '%s'", drvname); 1114 return -ENOENT; 1115 } 1116 /* If the user has explicitly specified the driver, this choice should 1117 * override the BDRV_O_PROTOCOL flag */ 1118 protocol = drv->bdrv_file_open; 1119 } 1120 1121 if (protocol) { 1122 *flags |= BDRV_O_PROTOCOL; 1123 } else { 1124 *flags &= ~BDRV_O_PROTOCOL; 1125 } 1126 1127 /* Translate cache options from flags into options */ 1128 update_options_from_flags(*options, *flags); 1129 1130 /* Fetch the file name from the options QDict if necessary */ 1131 if (protocol && filename) { 1132 if (!qdict_haskey(*options, "filename")) { 1133 qdict_put(*options, "filename", qstring_from_str(filename)); 1134 parse_filename = true; 1135 } else { 1136 error_setg(errp, "Can't specify 'file' and 'filename' options at " 1137 "the same time"); 1138 return -EINVAL; 1139 } 1140 } 1141 1142 /* Find the right block driver */ 1143 filename = qdict_get_try_str(*options, "filename"); 1144 1145 if (!drvname && protocol) { 1146 if (filename) { 1147 drv = bdrv_find_protocol(filename, parse_filename, errp); 1148 if (!drv) { 1149 return -EINVAL; 1150 } 1151 1152 drvname = drv->format_name; 1153 qdict_put(*options, "driver", qstring_from_str(drvname)); 1154 } else { 1155 error_setg(errp, "Must specify either driver or file"); 1156 return -EINVAL; 1157 } 1158 } 1159 1160 assert(drv || !protocol); 1161 1162 /* Driver-specific filename parsing */ 1163 if (drv && drv->bdrv_parse_filename && parse_filename) { 1164 drv->bdrv_parse_filename(filename, *options, &local_err); 1165 if (local_err) { 1166 error_propagate(errp, local_err); 1167 return -EINVAL; 1168 } 1169 1170 if (!drv->bdrv_needs_filename) { 1171 qdict_del(*options, "filename"); 1172 } 1173 } 1174 1175 return 0; 1176 } 1177 1178 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs, 1179 const char *child_name, 1180 const BdrvChildRole *child_role) 1181 { 1182 BdrvChild *child = g_new(BdrvChild, 1); 1183 *child = (BdrvChild) { 1184 .bs = child_bs, 1185 .name = g_strdup(child_name), 1186 .role = child_role, 1187 }; 1188 1189 QLIST_INSERT_HEAD(&child_bs->parents, child, next_parent); 1190 1191 return child; 1192 } 1193 1194 static BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs, 1195 BlockDriverState *child_bs, 1196 const char *child_name, 1197 const BdrvChildRole *child_role) 1198 { 1199 BdrvChild *child = bdrv_root_attach_child(child_bs, child_name, child_role); 1200 QLIST_INSERT_HEAD(&parent_bs->children, child, next); 1201 return child; 1202 } 1203 1204 static void bdrv_detach_child(BdrvChild *child) 1205 { 1206 if (child->next.le_prev) { 1207 QLIST_REMOVE(child, next); 1208 child->next.le_prev = NULL; 1209 } 1210 QLIST_REMOVE(child, next_parent); 1211 g_free(child->name); 1212 g_free(child); 1213 } 1214 1215 void bdrv_root_unref_child(BdrvChild *child) 1216 { 1217 BlockDriverState *child_bs; 1218 1219 child_bs = child->bs; 1220 bdrv_detach_child(child); 1221 bdrv_unref(child_bs); 1222 } 1223 1224 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child) 1225 { 1226 if (child == NULL) { 1227 return; 1228 } 1229 1230 if (child->bs->inherits_from == parent) { 1231 child->bs->inherits_from = NULL; 1232 } 1233 1234 bdrv_root_unref_child(child); 1235 } 1236 1237 /* 1238 * Sets the backing file link of a BDS. A new reference is created; callers 1239 * which don't need their own reference any more must call bdrv_unref(). 1240 */ 1241 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd) 1242 { 1243 if (backing_hd) { 1244 bdrv_ref(backing_hd); 1245 } 1246 1247 if (bs->backing) { 1248 assert(bs->backing_blocker); 1249 bdrv_op_unblock_all(bs->backing->bs, bs->backing_blocker); 1250 bdrv_unref_child(bs, bs->backing); 1251 } else if (backing_hd) { 1252 error_setg(&bs->backing_blocker, 1253 "node is used as backing hd of '%s'", 1254 bdrv_get_device_or_node_name(bs)); 1255 } 1256 1257 if (!backing_hd) { 1258 error_free(bs->backing_blocker); 1259 bs->backing_blocker = NULL; 1260 bs->backing = NULL; 1261 goto out; 1262 } 1263 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing); 1264 bs->open_flags &= ~BDRV_O_NO_BACKING; 1265 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename); 1266 pstrcpy(bs->backing_format, sizeof(bs->backing_format), 1267 backing_hd->drv ? backing_hd->drv->format_name : ""); 1268 1269 bdrv_op_block_all(backing_hd, bs->backing_blocker); 1270 /* Otherwise we won't be able to commit due to check in bdrv_commit */ 1271 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET, 1272 bs->backing_blocker); 1273 out: 1274 bdrv_refresh_limits(bs, NULL); 1275 } 1276 1277 /* 1278 * Opens the backing file for a BlockDriverState if not yet open 1279 * 1280 * bdref_key specifies the key for the image's BlockdevRef in the options QDict. 1281 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict 1282 * itself, all options starting with "${bdref_key}." are considered part of the 1283 * BlockdevRef. 1284 * 1285 * TODO Can this be unified with bdrv_open_image()? 1286 */ 1287 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options, 1288 const char *bdref_key, Error **errp) 1289 { 1290 char *backing_filename = g_malloc0(PATH_MAX); 1291 char *bdref_key_dot; 1292 const char *reference = NULL; 1293 int ret = 0; 1294 BlockDriverState *backing_hd; 1295 QDict *options; 1296 QDict *tmp_parent_options = NULL; 1297 Error *local_err = NULL; 1298 1299 if (bs->backing != NULL) { 1300 goto free_exit; 1301 } 1302 1303 /* NULL means an empty set of options */ 1304 if (parent_options == NULL) { 1305 tmp_parent_options = qdict_new(); 1306 parent_options = tmp_parent_options; 1307 } 1308 1309 bs->open_flags &= ~BDRV_O_NO_BACKING; 1310 1311 bdref_key_dot = g_strdup_printf("%s.", bdref_key); 1312 qdict_extract_subqdict(parent_options, &options, bdref_key_dot); 1313 g_free(bdref_key_dot); 1314 1315 reference = qdict_get_try_str(parent_options, bdref_key); 1316 if (reference || qdict_haskey(options, "file.filename")) { 1317 backing_filename[0] = '\0'; 1318 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) { 1319 QDECREF(options); 1320 goto free_exit; 1321 } else { 1322 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX, 1323 &local_err); 1324 if (local_err) { 1325 ret = -EINVAL; 1326 error_propagate(errp, local_err); 1327 QDECREF(options); 1328 goto free_exit; 1329 } 1330 } 1331 1332 if (!bs->drv || !bs->drv->supports_backing) { 1333 ret = -EINVAL; 1334 error_setg(errp, "Driver doesn't support backing files"); 1335 QDECREF(options); 1336 goto free_exit; 1337 } 1338 1339 if (bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) { 1340 qdict_put(options, "driver", qstring_from_str(bs->backing_format)); 1341 } 1342 1343 backing_hd = NULL; 1344 ret = bdrv_open_inherit(&backing_hd, 1345 *backing_filename ? backing_filename : NULL, 1346 reference, options, 0, bs, &child_backing, 1347 errp); 1348 if (ret < 0) { 1349 bs->open_flags |= BDRV_O_NO_BACKING; 1350 error_prepend(errp, "Could not open backing file: "); 1351 goto free_exit; 1352 } 1353 1354 /* Hook up the backing file link; drop our reference, bs owns the 1355 * backing_hd reference now */ 1356 bdrv_set_backing_hd(bs, backing_hd); 1357 bdrv_unref(backing_hd); 1358 1359 qdict_del(parent_options, bdref_key); 1360 1361 free_exit: 1362 g_free(backing_filename); 1363 QDECREF(tmp_parent_options); 1364 return ret; 1365 } 1366 1367 /* 1368 * Opens a disk image whose options are given as BlockdevRef in another block 1369 * device's options. 1370 * 1371 * If allow_none is true, no image will be opened if filename is false and no 1372 * BlockdevRef is given. NULL will be returned, but errp remains unset. 1373 * 1374 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict. 1375 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict 1376 * itself, all options starting with "${bdref_key}." are considered part of the 1377 * BlockdevRef. 1378 * 1379 * The BlockdevRef will be removed from the options QDict. 1380 */ 1381 BdrvChild *bdrv_open_child(const char *filename, 1382 QDict *options, const char *bdref_key, 1383 BlockDriverState* parent, 1384 const BdrvChildRole *child_role, 1385 bool allow_none, Error **errp) 1386 { 1387 BdrvChild *c = NULL; 1388 BlockDriverState *bs; 1389 QDict *image_options; 1390 int ret; 1391 char *bdref_key_dot; 1392 const char *reference; 1393 1394 assert(child_role != NULL); 1395 1396 bdref_key_dot = g_strdup_printf("%s.", bdref_key); 1397 qdict_extract_subqdict(options, &image_options, bdref_key_dot); 1398 g_free(bdref_key_dot); 1399 1400 reference = qdict_get_try_str(options, bdref_key); 1401 if (!filename && !reference && !qdict_size(image_options)) { 1402 if (!allow_none) { 1403 error_setg(errp, "A block device must be specified for \"%s\"", 1404 bdref_key); 1405 } 1406 QDECREF(image_options); 1407 goto done; 1408 } 1409 1410 bs = NULL; 1411 ret = bdrv_open_inherit(&bs, filename, reference, image_options, 0, 1412 parent, child_role, errp); 1413 if (ret < 0) { 1414 goto done; 1415 } 1416 1417 c = bdrv_attach_child(parent, bs, bdref_key, child_role); 1418 1419 done: 1420 qdict_del(options, bdref_key); 1421 return c; 1422 } 1423 1424 static int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, 1425 QDict *snapshot_options, Error **errp) 1426 { 1427 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */ 1428 char *tmp_filename = g_malloc0(PATH_MAX + 1); 1429 int64_t total_size; 1430 QemuOpts *opts = NULL; 1431 BlockDriverState *bs_snapshot; 1432 Error *local_err = NULL; 1433 int ret; 1434 1435 /* if snapshot, we create a temporary backing file and open it 1436 instead of opening 'filename' directly */ 1437 1438 /* Get the required size from the image */ 1439 total_size = bdrv_getlength(bs); 1440 if (total_size < 0) { 1441 ret = total_size; 1442 error_setg_errno(errp, -total_size, "Could not get image size"); 1443 goto out; 1444 } 1445 1446 /* Create the temporary image */ 1447 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1); 1448 if (ret < 0) { 1449 error_setg_errno(errp, -ret, "Could not get temporary filename"); 1450 goto out; 1451 } 1452 1453 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0, 1454 &error_abort); 1455 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort); 1456 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp); 1457 qemu_opts_del(opts); 1458 if (ret < 0) { 1459 error_prepend(errp, "Could not create temporary overlay '%s': ", 1460 tmp_filename); 1461 goto out; 1462 } 1463 1464 /* Prepare options QDict for the temporary file */ 1465 qdict_put(snapshot_options, "file.driver", 1466 qstring_from_str("file")); 1467 qdict_put(snapshot_options, "file.filename", 1468 qstring_from_str(tmp_filename)); 1469 qdict_put(snapshot_options, "driver", 1470 qstring_from_str("qcow2")); 1471 1472 bs_snapshot = bdrv_new(); 1473 1474 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options, 1475 flags, &local_err); 1476 snapshot_options = NULL; 1477 if (ret < 0) { 1478 error_propagate(errp, local_err); 1479 goto out; 1480 } 1481 1482 bdrv_append(bs_snapshot, bs); 1483 1484 out: 1485 QDECREF(snapshot_options); 1486 g_free(tmp_filename); 1487 return ret; 1488 } 1489 1490 /* 1491 * Opens a disk image (raw, qcow2, vmdk, ...) 1492 * 1493 * options is a QDict of options to pass to the block drivers, or NULL for an 1494 * empty set of options. The reference to the QDict belongs to the block layer 1495 * after the call (even on failure), so if the caller intends to reuse the 1496 * dictionary, it needs to use QINCREF() before calling bdrv_open. 1497 * 1498 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there. 1499 * If it is not NULL, the referenced BDS will be reused. 1500 * 1501 * The reference parameter may be used to specify an existing block device which 1502 * should be opened. If specified, neither options nor a filename may be given, 1503 * nor can an existing BDS be reused (that is, *pbs has to be NULL). 1504 */ 1505 static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename, 1506 const char *reference, QDict *options, int flags, 1507 BlockDriverState *parent, 1508 const BdrvChildRole *child_role, Error **errp) 1509 { 1510 int ret; 1511 BdrvChild *file = NULL; 1512 BlockDriverState *bs; 1513 BlockDriver *drv = NULL; 1514 const char *drvname; 1515 const char *backing; 1516 Error *local_err = NULL; 1517 QDict *snapshot_options = NULL; 1518 int snapshot_flags = 0; 1519 1520 assert(pbs); 1521 assert(!child_role || !flags); 1522 assert(!child_role == !parent); 1523 1524 if (reference) { 1525 bool options_non_empty = options ? qdict_size(options) : false; 1526 QDECREF(options); 1527 1528 if (*pbs) { 1529 error_setg(errp, "Cannot reuse an existing BDS when referencing " 1530 "another block device"); 1531 return -EINVAL; 1532 } 1533 1534 if (filename || options_non_empty) { 1535 error_setg(errp, "Cannot reference an existing block device with " 1536 "additional options or a new filename"); 1537 return -EINVAL; 1538 } 1539 1540 bs = bdrv_lookup_bs(reference, reference, errp); 1541 if (!bs) { 1542 return -ENODEV; 1543 } 1544 bdrv_ref(bs); 1545 *pbs = bs; 1546 return 0; 1547 } 1548 1549 if (*pbs) { 1550 bs = *pbs; 1551 } else { 1552 bs = bdrv_new(); 1553 } 1554 1555 /* NULL means an empty set of options */ 1556 if (options == NULL) { 1557 options = qdict_new(); 1558 } 1559 1560 /* json: syntax counts as explicit options, as if in the QDict */ 1561 parse_json_protocol(options, &filename, &local_err); 1562 if (local_err) { 1563 ret = -EINVAL; 1564 goto fail; 1565 } 1566 1567 bs->explicit_options = qdict_clone_shallow(options); 1568 1569 if (child_role) { 1570 bs->inherits_from = parent; 1571 child_role->inherit_options(&flags, options, 1572 parent->open_flags, parent->options); 1573 } 1574 1575 ret = bdrv_fill_options(&options, filename, &flags, &local_err); 1576 if (local_err) { 1577 goto fail; 1578 } 1579 1580 bs->open_flags = flags; 1581 bs->options = options; 1582 options = qdict_clone_shallow(options); 1583 1584 /* Find the right image format driver */ 1585 drvname = qdict_get_try_str(options, "driver"); 1586 if (drvname) { 1587 drv = bdrv_find_format(drvname); 1588 if (!drv) { 1589 error_setg(errp, "Unknown driver: '%s'", drvname); 1590 ret = -EINVAL; 1591 goto fail; 1592 } 1593 } 1594 1595 assert(drvname || !(flags & BDRV_O_PROTOCOL)); 1596 1597 backing = qdict_get_try_str(options, "backing"); 1598 if (backing && *backing == '\0') { 1599 flags |= BDRV_O_NO_BACKING; 1600 qdict_del(options, "backing"); 1601 } 1602 1603 /* Open image file without format layer */ 1604 if ((flags & BDRV_O_PROTOCOL) == 0) { 1605 if (flags & BDRV_O_RDWR) { 1606 flags |= BDRV_O_ALLOW_RDWR; 1607 } 1608 if (flags & BDRV_O_SNAPSHOT) { 1609 snapshot_options = qdict_new(); 1610 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options, 1611 flags, options); 1612 bdrv_backing_options(&flags, options, flags, options); 1613 } 1614 1615 bs->open_flags = flags; 1616 1617 file = bdrv_open_child(filename, options, "file", bs, 1618 &child_file, true, &local_err); 1619 if (local_err) { 1620 ret = -EINVAL; 1621 goto fail; 1622 } 1623 } 1624 1625 /* Image format probing */ 1626 bs->probed = !drv; 1627 if (!drv && file) { 1628 ret = find_image_format(file->bs, filename, &drv, &local_err); 1629 if (ret < 0) { 1630 goto fail; 1631 } 1632 /* 1633 * This option update would logically belong in bdrv_fill_options(), 1634 * but we first need to open bs->file for the probing to work, while 1635 * opening bs->file already requires the (mostly) final set of options 1636 * so that cache mode etc. can be inherited. 1637 * 1638 * Adding the driver later is somewhat ugly, but it's not an option 1639 * that would ever be inherited, so it's correct. We just need to make 1640 * sure to update both bs->options (which has the full effective 1641 * options for bs) and options (which has file.* already removed). 1642 */ 1643 qdict_put(bs->options, "driver", qstring_from_str(drv->format_name)); 1644 qdict_put(options, "driver", qstring_from_str(drv->format_name)); 1645 } else if (!drv) { 1646 error_setg(errp, "Must specify either driver or file"); 1647 ret = -EINVAL; 1648 goto fail; 1649 } 1650 1651 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */ 1652 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open); 1653 /* file must be NULL if a protocol BDS is about to be created 1654 * (the inverse results in an error message from bdrv_open_common()) */ 1655 assert(!(flags & BDRV_O_PROTOCOL) || !file); 1656 1657 /* Open the image */ 1658 ret = bdrv_open_common(bs, file, options, &local_err); 1659 if (ret < 0) { 1660 goto fail; 1661 } 1662 1663 if (file && (bs->file != file)) { 1664 bdrv_unref_child(bs, file); 1665 file = NULL; 1666 } 1667 1668 /* If there is a backing file, use it */ 1669 if ((flags & BDRV_O_NO_BACKING) == 0) { 1670 ret = bdrv_open_backing_file(bs, options, "backing", &local_err); 1671 if (ret < 0) { 1672 goto close_and_fail; 1673 } 1674 } 1675 1676 bdrv_refresh_filename(bs); 1677 1678 /* Check if any unknown options were used */ 1679 if (options && (qdict_size(options) != 0)) { 1680 const QDictEntry *entry = qdict_first(options); 1681 if (flags & BDRV_O_PROTOCOL) { 1682 error_setg(errp, "Block protocol '%s' doesn't support the option " 1683 "'%s'", drv->format_name, entry->key); 1684 } else { 1685 error_setg(errp, 1686 "Block format '%s' does not support the option '%s'", 1687 drv->format_name, entry->key); 1688 } 1689 1690 ret = -EINVAL; 1691 goto close_and_fail; 1692 } 1693 1694 if (!bdrv_key_required(bs)) { 1695 if (bs->blk) { 1696 blk_dev_change_media_cb(bs->blk, true); 1697 } 1698 } else if (!runstate_check(RUN_STATE_PRELAUNCH) 1699 && !runstate_check(RUN_STATE_INMIGRATE) 1700 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */ 1701 error_setg(errp, 1702 "Guest must be stopped for opening of encrypted image"); 1703 ret = -EBUSY; 1704 goto close_and_fail; 1705 } 1706 1707 QDECREF(options); 1708 *pbs = bs; 1709 1710 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the 1711 * temporary snapshot afterwards. */ 1712 if (snapshot_flags) { 1713 ret = bdrv_append_temp_snapshot(bs, snapshot_flags, snapshot_options, 1714 &local_err); 1715 snapshot_options = NULL; 1716 if (local_err) { 1717 goto close_and_fail; 1718 } 1719 } 1720 1721 return 0; 1722 1723 fail: 1724 if (file != NULL) { 1725 bdrv_unref_child(bs, file); 1726 } 1727 QDECREF(snapshot_options); 1728 QDECREF(bs->explicit_options); 1729 QDECREF(bs->options); 1730 QDECREF(options); 1731 bs->options = NULL; 1732 if (!*pbs) { 1733 /* If *pbs is NULL, a new BDS has been created in this function and 1734 needs to be freed now. Otherwise, it does not need to be closed, 1735 since it has not really been opened yet. */ 1736 bdrv_unref(bs); 1737 } 1738 if (local_err) { 1739 error_propagate(errp, local_err); 1740 } 1741 return ret; 1742 1743 close_and_fail: 1744 /* See fail path, but now the BDS has to be always closed */ 1745 if (*pbs) { 1746 bdrv_close(bs); 1747 } else { 1748 bdrv_unref(bs); 1749 } 1750 QDECREF(snapshot_options); 1751 QDECREF(options); 1752 if (local_err) { 1753 error_propagate(errp, local_err); 1754 } 1755 return ret; 1756 } 1757 1758 int bdrv_open(BlockDriverState **pbs, const char *filename, 1759 const char *reference, QDict *options, int flags, Error **errp) 1760 { 1761 return bdrv_open_inherit(pbs, filename, reference, options, flags, NULL, 1762 NULL, errp); 1763 } 1764 1765 typedef struct BlockReopenQueueEntry { 1766 bool prepared; 1767 BDRVReopenState state; 1768 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry; 1769 } BlockReopenQueueEntry; 1770 1771 /* 1772 * Adds a BlockDriverState to a simple queue for an atomic, transactional 1773 * reopen of multiple devices. 1774 * 1775 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT 1776 * already performed, or alternatively may be NULL a new BlockReopenQueue will 1777 * be created and initialized. This newly created BlockReopenQueue should be 1778 * passed back in for subsequent calls that are intended to be of the same 1779 * atomic 'set'. 1780 * 1781 * bs is the BlockDriverState to add to the reopen queue. 1782 * 1783 * options contains the changed options for the associated bs 1784 * (the BlockReopenQueue takes ownership) 1785 * 1786 * flags contains the open flags for the associated bs 1787 * 1788 * returns a pointer to bs_queue, which is either the newly allocated 1789 * bs_queue, or the existing bs_queue being used. 1790 * 1791 */ 1792 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue, 1793 BlockDriverState *bs, 1794 QDict *options, 1795 int flags, 1796 const BdrvChildRole *role, 1797 QDict *parent_options, 1798 int parent_flags) 1799 { 1800 assert(bs != NULL); 1801 1802 BlockReopenQueueEntry *bs_entry; 1803 BdrvChild *child; 1804 QDict *old_options, *explicit_options; 1805 1806 if (bs_queue == NULL) { 1807 bs_queue = g_new0(BlockReopenQueue, 1); 1808 QSIMPLEQ_INIT(bs_queue); 1809 } 1810 1811 if (!options) { 1812 options = qdict_new(); 1813 } 1814 1815 /* 1816 * Precedence of options: 1817 * 1. Explicitly passed in options (highest) 1818 * 2. Set in flags (only for top level) 1819 * 3. Retained from explicitly set options of bs 1820 * 4. Inherited from parent node 1821 * 5. Retained from effective options of bs 1822 */ 1823 1824 if (!parent_options) { 1825 /* 1826 * Any setting represented by flags is always updated. If the 1827 * corresponding QDict option is set, it takes precedence. Otherwise 1828 * the flag is translated into a QDict option. The old setting of bs is 1829 * not considered. 1830 */ 1831 update_options_from_flags(options, flags); 1832 } 1833 1834 /* Old explicitly set values (don't overwrite by inherited value) */ 1835 old_options = qdict_clone_shallow(bs->explicit_options); 1836 bdrv_join_options(bs, options, old_options); 1837 QDECREF(old_options); 1838 1839 explicit_options = qdict_clone_shallow(options); 1840 1841 /* Inherit from parent node */ 1842 if (parent_options) { 1843 assert(!flags); 1844 role->inherit_options(&flags, options, parent_flags, parent_options); 1845 } 1846 1847 /* Old values are used for options that aren't set yet */ 1848 old_options = qdict_clone_shallow(bs->options); 1849 bdrv_join_options(bs, options, old_options); 1850 QDECREF(old_options); 1851 1852 /* bdrv_open() masks this flag out */ 1853 flags &= ~BDRV_O_PROTOCOL; 1854 1855 QLIST_FOREACH(child, &bs->children, next) { 1856 QDict *new_child_options; 1857 char *child_key_dot; 1858 1859 /* reopen can only change the options of block devices that were 1860 * implicitly created and inherited options. For other (referenced) 1861 * block devices, a syntax like "backing.foo" results in an error. */ 1862 if (child->bs->inherits_from != bs) { 1863 continue; 1864 } 1865 1866 child_key_dot = g_strdup_printf("%s.", child->name); 1867 qdict_extract_subqdict(options, &new_child_options, child_key_dot); 1868 g_free(child_key_dot); 1869 1870 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0, 1871 child->role, options, flags); 1872 } 1873 1874 bs_entry = g_new0(BlockReopenQueueEntry, 1); 1875 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry); 1876 1877 bs_entry->state.bs = bs; 1878 bs_entry->state.options = options; 1879 bs_entry->state.explicit_options = explicit_options; 1880 bs_entry->state.flags = flags; 1881 1882 return bs_queue; 1883 } 1884 1885 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue, 1886 BlockDriverState *bs, 1887 QDict *options, int flags) 1888 { 1889 return bdrv_reopen_queue_child(bs_queue, bs, options, flags, 1890 NULL, NULL, 0); 1891 } 1892 1893 /* 1894 * Reopen multiple BlockDriverStates atomically & transactionally. 1895 * 1896 * The queue passed in (bs_queue) must have been built up previous 1897 * via bdrv_reopen_queue(). 1898 * 1899 * Reopens all BDS specified in the queue, with the appropriate 1900 * flags. All devices are prepared for reopen, and failure of any 1901 * device will cause all device changes to be abandonded, and intermediate 1902 * data cleaned up. 1903 * 1904 * If all devices prepare successfully, then the changes are committed 1905 * to all devices. 1906 * 1907 */ 1908 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp) 1909 { 1910 int ret = -1; 1911 BlockReopenQueueEntry *bs_entry, *next; 1912 Error *local_err = NULL; 1913 1914 assert(bs_queue != NULL); 1915 1916 bdrv_drain_all(); 1917 1918 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) { 1919 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) { 1920 error_propagate(errp, local_err); 1921 goto cleanup; 1922 } 1923 bs_entry->prepared = true; 1924 } 1925 1926 /* If we reach this point, we have success and just need to apply the 1927 * changes 1928 */ 1929 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) { 1930 bdrv_reopen_commit(&bs_entry->state); 1931 } 1932 1933 ret = 0; 1934 1935 cleanup: 1936 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) { 1937 if (ret && bs_entry->prepared) { 1938 bdrv_reopen_abort(&bs_entry->state); 1939 } else if (ret) { 1940 QDECREF(bs_entry->state.explicit_options); 1941 } 1942 QDECREF(bs_entry->state.options); 1943 g_free(bs_entry); 1944 } 1945 g_free(bs_queue); 1946 return ret; 1947 } 1948 1949 1950 /* Reopen a single BlockDriverState with the specified flags. */ 1951 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp) 1952 { 1953 int ret = -1; 1954 Error *local_err = NULL; 1955 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags); 1956 1957 ret = bdrv_reopen_multiple(queue, &local_err); 1958 if (local_err != NULL) { 1959 error_propagate(errp, local_err); 1960 } 1961 return ret; 1962 } 1963 1964 1965 /* 1966 * Prepares a BlockDriverState for reopen. All changes are staged in the 1967 * 'opaque' field of the BDRVReopenState, which is used and allocated by 1968 * the block driver layer .bdrv_reopen_prepare() 1969 * 1970 * bs is the BlockDriverState to reopen 1971 * flags are the new open flags 1972 * queue is the reopen queue 1973 * 1974 * Returns 0 on success, non-zero on error. On error errp will be set 1975 * as well. 1976 * 1977 * On failure, bdrv_reopen_abort() will be called to clean up any data. 1978 * It is the responsibility of the caller to then call the abort() or 1979 * commit() for any other BDS that have been left in a prepare() state 1980 * 1981 */ 1982 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, 1983 Error **errp) 1984 { 1985 int ret = -1; 1986 Error *local_err = NULL; 1987 BlockDriver *drv; 1988 QemuOpts *opts; 1989 const char *value; 1990 1991 assert(reopen_state != NULL); 1992 assert(reopen_state->bs->drv != NULL); 1993 drv = reopen_state->bs->drv; 1994 1995 /* Process generic block layer options */ 1996 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort); 1997 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err); 1998 if (local_err) { 1999 error_propagate(errp, local_err); 2000 ret = -EINVAL; 2001 goto error; 2002 } 2003 2004 update_flags_from_options(&reopen_state->flags, opts); 2005 2006 /* If a guest device is attached, it owns WCE */ 2007 if (reopen_state->bs->blk && blk_get_attached_dev(reopen_state->bs->blk)) { 2008 bool old_wce = bdrv_enable_write_cache(reopen_state->bs); 2009 bool new_wce = (reopen_state->flags & BDRV_O_CACHE_WB); 2010 if (old_wce != new_wce) { 2011 error_setg(errp, "Cannot change cache.writeback: Device attached"); 2012 ret = -EINVAL; 2013 goto error; 2014 } 2015 } 2016 2017 /* node-name and driver must be unchanged. Put them back into the QDict, so 2018 * that they are checked at the end of this function. */ 2019 value = qemu_opt_get(opts, "node-name"); 2020 if (value) { 2021 qdict_put(reopen_state->options, "node-name", qstring_from_str(value)); 2022 } 2023 2024 value = qemu_opt_get(opts, "driver"); 2025 if (value) { 2026 qdict_put(reopen_state->options, "driver", qstring_from_str(value)); 2027 } 2028 2029 /* if we are to stay read-only, do not allow permission change 2030 * to r/w */ 2031 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) && 2032 reopen_state->flags & BDRV_O_RDWR) { 2033 error_setg(errp, "Node '%s' is read only", 2034 bdrv_get_device_or_node_name(reopen_state->bs)); 2035 goto error; 2036 } 2037 2038 2039 ret = bdrv_flush(reopen_state->bs); 2040 if (ret) { 2041 error_setg_errno(errp, -ret, "Error flushing drive"); 2042 goto error; 2043 } 2044 2045 if (drv->bdrv_reopen_prepare) { 2046 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err); 2047 if (ret) { 2048 if (local_err != NULL) { 2049 error_propagate(errp, local_err); 2050 } else { 2051 error_setg(errp, "failed while preparing to reopen image '%s'", 2052 reopen_state->bs->filename); 2053 } 2054 goto error; 2055 } 2056 } else { 2057 /* It is currently mandatory to have a bdrv_reopen_prepare() 2058 * handler for each supported drv. */ 2059 error_setg(errp, "Block format '%s' used by node '%s' " 2060 "does not support reopening files", drv->format_name, 2061 bdrv_get_device_or_node_name(reopen_state->bs)); 2062 ret = -1; 2063 goto error; 2064 } 2065 2066 /* Options that are not handled are only okay if they are unchanged 2067 * compared to the old state. It is expected that some options are only 2068 * used for the initial open, but not reopen (e.g. filename) */ 2069 if (qdict_size(reopen_state->options)) { 2070 const QDictEntry *entry = qdict_first(reopen_state->options); 2071 2072 do { 2073 QString *new_obj = qobject_to_qstring(entry->value); 2074 const char *new = qstring_get_str(new_obj); 2075 const char *old = qdict_get_try_str(reopen_state->bs->options, 2076 entry->key); 2077 2078 if (!old || strcmp(new, old)) { 2079 error_setg(errp, "Cannot change the option '%s'", entry->key); 2080 ret = -EINVAL; 2081 goto error; 2082 } 2083 } while ((entry = qdict_next(reopen_state->options, entry))); 2084 } 2085 2086 ret = 0; 2087 2088 error: 2089 qemu_opts_del(opts); 2090 return ret; 2091 } 2092 2093 /* 2094 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and 2095 * makes them final by swapping the staging BlockDriverState contents into 2096 * the active BlockDriverState contents. 2097 */ 2098 void bdrv_reopen_commit(BDRVReopenState *reopen_state) 2099 { 2100 BlockDriver *drv; 2101 2102 assert(reopen_state != NULL); 2103 drv = reopen_state->bs->drv; 2104 assert(drv != NULL); 2105 2106 /* If there are any driver level actions to take */ 2107 if (drv->bdrv_reopen_commit) { 2108 drv->bdrv_reopen_commit(reopen_state); 2109 } 2110 2111 /* set BDS specific flags now */ 2112 QDECREF(reopen_state->bs->explicit_options); 2113 2114 reopen_state->bs->explicit_options = reopen_state->explicit_options; 2115 reopen_state->bs->open_flags = reopen_state->flags; 2116 reopen_state->bs->enable_write_cache = !!(reopen_state->flags & 2117 BDRV_O_CACHE_WB); 2118 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR); 2119 2120 bdrv_refresh_limits(reopen_state->bs, NULL); 2121 } 2122 2123 /* 2124 * Abort the reopen, and delete and free the staged changes in 2125 * reopen_state 2126 */ 2127 void bdrv_reopen_abort(BDRVReopenState *reopen_state) 2128 { 2129 BlockDriver *drv; 2130 2131 assert(reopen_state != NULL); 2132 drv = reopen_state->bs->drv; 2133 assert(drv != NULL); 2134 2135 if (drv->bdrv_reopen_abort) { 2136 drv->bdrv_reopen_abort(reopen_state); 2137 } 2138 2139 QDECREF(reopen_state->explicit_options); 2140 } 2141 2142 2143 static void bdrv_close(BlockDriverState *bs) 2144 { 2145 BdrvAioNotifier *ban, *ban_next; 2146 2147 assert(!bs->job); 2148 2149 /* Disable I/O limits and drain all pending throttled requests */ 2150 if (bs->throttle_state) { 2151 bdrv_io_limits_disable(bs); 2152 } 2153 2154 bdrv_drained_begin(bs); /* complete I/O */ 2155 bdrv_flush(bs); 2156 bdrv_drain(bs); /* in case flush left pending I/O */ 2157 2158 bdrv_release_named_dirty_bitmaps(bs); 2159 assert(QLIST_EMPTY(&bs->dirty_bitmaps)); 2160 2161 if (bs->blk) { 2162 blk_dev_change_media_cb(bs->blk, false); 2163 } 2164 2165 if (bs->drv) { 2166 BdrvChild *child, *next; 2167 2168 bs->drv->bdrv_close(bs); 2169 bs->drv = NULL; 2170 2171 bdrv_set_backing_hd(bs, NULL); 2172 2173 if (bs->file != NULL) { 2174 bdrv_unref_child(bs, bs->file); 2175 bs->file = NULL; 2176 } 2177 2178 QLIST_FOREACH_SAFE(child, &bs->children, next, next) { 2179 /* TODO Remove bdrv_unref() from drivers' close function and use 2180 * bdrv_unref_child() here */ 2181 if (child->bs->inherits_from == bs) { 2182 child->bs->inherits_from = NULL; 2183 } 2184 bdrv_detach_child(child); 2185 } 2186 2187 g_free(bs->opaque); 2188 bs->opaque = NULL; 2189 bs->copy_on_read = 0; 2190 bs->backing_file[0] = '\0'; 2191 bs->backing_format[0] = '\0'; 2192 bs->total_sectors = 0; 2193 bs->encrypted = 0; 2194 bs->valid_key = 0; 2195 bs->sg = 0; 2196 bs->zero_beyond_eof = false; 2197 QDECREF(bs->options); 2198 QDECREF(bs->explicit_options); 2199 bs->options = NULL; 2200 QDECREF(bs->full_open_options); 2201 bs->full_open_options = NULL; 2202 } 2203 2204 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { 2205 g_free(ban); 2206 } 2207 QLIST_INIT(&bs->aio_notifiers); 2208 bdrv_drained_end(bs); 2209 } 2210 2211 void bdrv_close_all(void) 2212 { 2213 BlockDriverState *bs; 2214 AioContext *aio_context; 2215 2216 /* Drop references from requests still in flight, such as canceled block 2217 * jobs whose AIO context has not been polled yet */ 2218 bdrv_drain_all(); 2219 2220 blk_remove_all_bs(); 2221 blockdev_close_all_bdrv_states(); 2222 2223 /* Cancel all block jobs */ 2224 while (!QTAILQ_EMPTY(&all_bdrv_states)) { 2225 QTAILQ_FOREACH(bs, &all_bdrv_states, bs_list) { 2226 aio_context = bdrv_get_aio_context(bs); 2227 2228 aio_context_acquire(aio_context); 2229 if (bs->job) { 2230 block_job_cancel_sync(bs->job); 2231 aio_context_release(aio_context); 2232 break; 2233 } 2234 aio_context_release(aio_context); 2235 } 2236 2237 /* All the remaining BlockDriverStates are referenced directly or 2238 * indirectly from block jobs, so there needs to be at least one BDS 2239 * directly used by a block job */ 2240 assert(bs); 2241 } 2242 } 2243 2244 /* make a BlockDriverState anonymous by removing from graph_bdrv_state list. 2245 * Also, NULL terminate the device_name to prevent double remove */ 2246 void bdrv_make_anon(BlockDriverState *bs) 2247 { 2248 if (bs->node_name[0] != '\0') { 2249 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list); 2250 } 2251 bs->node_name[0] = '\0'; 2252 } 2253 2254 /* Fields that need to stay with the top-level BDS */ 2255 static void bdrv_move_feature_fields(BlockDriverState *bs_dest, 2256 BlockDriverState *bs_src) 2257 { 2258 /* move some fields that need to stay attached to the device */ 2259 2260 /* dev info */ 2261 bs_dest->copy_on_read = bs_src->copy_on_read; 2262 2263 bs_dest->enable_write_cache = bs_src->enable_write_cache; 2264 2265 /* dirty bitmap */ 2266 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps; 2267 } 2268 2269 static void change_parent_backing_link(BlockDriverState *from, 2270 BlockDriverState *to) 2271 { 2272 BdrvChild *c, *next; 2273 2274 if (from->blk) { 2275 /* FIXME We bypass blk_set_bs(), so we need to make these updates 2276 * manually. The root problem is not in this change function, but the 2277 * existence of BlockDriverState.blk. */ 2278 to->blk = from->blk; 2279 from->blk = NULL; 2280 } 2281 2282 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) { 2283 assert(c->role != &child_backing); 2284 c->bs = to; 2285 QLIST_REMOVE(c, next_parent); 2286 QLIST_INSERT_HEAD(&to->parents, c, next_parent); 2287 bdrv_ref(to); 2288 bdrv_unref(from); 2289 } 2290 } 2291 2292 static void swap_feature_fields(BlockDriverState *bs_top, 2293 BlockDriverState *bs_new) 2294 { 2295 BlockDriverState tmp; 2296 2297 bdrv_move_feature_fields(&tmp, bs_top); 2298 bdrv_move_feature_fields(bs_top, bs_new); 2299 bdrv_move_feature_fields(bs_new, &tmp); 2300 2301 assert(!bs_new->throttle_state); 2302 if (bs_top->throttle_state) { 2303 assert(bs_top->io_limits_enabled); 2304 bdrv_io_limits_enable(bs_new, throttle_group_get_name(bs_top)); 2305 bdrv_io_limits_disable(bs_top); 2306 } 2307 } 2308 2309 /* 2310 * Add new bs contents at the top of an image chain while the chain is 2311 * live, while keeping required fields on the top layer. 2312 * 2313 * This will modify the BlockDriverState fields, and swap contents 2314 * between bs_new and bs_top. Both bs_new and bs_top are modified. 2315 * 2316 * bs_new must not be attached to a BlockBackend. 2317 * 2318 * This function does not create any image files. 2319 * 2320 * bdrv_append() takes ownership of a bs_new reference and unrefs it because 2321 * that's what the callers commonly need. bs_new will be referenced by the old 2322 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a 2323 * reference of its own, it must call bdrv_ref(). 2324 */ 2325 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top) 2326 { 2327 assert(!bdrv_requests_pending(bs_top)); 2328 assert(!bdrv_requests_pending(bs_new)); 2329 2330 bdrv_ref(bs_top); 2331 change_parent_backing_link(bs_top, bs_new); 2332 2333 /* Some fields always stay on top of the backing file chain */ 2334 swap_feature_fields(bs_top, bs_new); 2335 2336 bdrv_set_backing_hd(bs_new, bs_top); 2337 bdrv_unref(bs_top); 2338 2339 /* bs_new is now referenced by its new parents, we don't need the 2340 * additional reference any more. */ 2341 bdrv_unref(bs_new); 2342 } 2343 2344 void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new) 2345 { 2346 assert(!bdrv_requests_pending(old)); 2347 assert(!bdrv_requests_pending(new)); 2348 2349 bdrv_ref(old); 2350 2351 if (old->blk) { 2352 /* As long as these fields aren't in BlockBackend, but in the top-level 2353 * BlockDriverState, it's not possible for a BDS to have two BBs. 2354 * 2355 * We really want to copy the fields from old to new, but we go for a 2356 * swap instead so that pointers aren't duplicated and cause trouble. 2357 * (Also, bdrv_swap() used to do the same.) */ 2358 assert(!new->blk); 2359 swap_feature_fields(old, new); 2360 } 2361 change_parent_backing_link(old, new); 2362 2363 /* Change backing files if a previously independent node is added to the 2364 * chain. For active commit, we replace top by its own (indirect) backing 2365 * file and don't do anything here so we don't build a loop. */ 2366 if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) { 2367 bdrv_set_backing_hd(new, backing_bs(old)); 2368 bdrv_set_backing_hd(old, NULL); 2369 } 2370 2371 bdrv_unref(old); 2372 } 2373 2374 static void bdrv_delete(BlockDriverState *bs) 2375 { 2376 assert(!bs->job); 2377 assert(bdrv_op_blocker_is_empty(bs)); 2378 assert(!bs->refcnt); 2379 2380 bdrv_close(bs); 2381 2382 /* remove from list, if necessary */ 2383 bdrv_make_anon(bs); 2384 2385 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list); 2386 2387 g_free(bs); 2388 } 2389 2390 /* 2391 * Run consistency checks on an image 2392 * 2393 * Returns 0 if the check could be completed (it doesn't mean that the image is 2394 * free of errors) or -errno when an internal error occurred. The results of the 2395 * check are stored in res. 2396 */ 2397 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix) 2398 { 2399 if (bs->drv == NULL) { 2400 return -ENOMEDIUM; 2401 } 2402 if (bs->drv->bdrv_check == NULL) { 2403 return -ENOTSUP; 2404 } 2405 2406 memset(res, 0, sizeof(*res)); 2407 return bs->drv->bdrv_check(bs, res, fix); 2408 } 2409 2410 #define COMMIT_BUF_SECTORS 2048 2411 2412 /* commit COW file into the raw image */ 2413 int bdrv_commit(BlockDriverState *bs) 2414 { 2415 BlockDriver *drv = bs->drv; 2416 int64_t sector, total_sectors, length, backing_length; 2417 int n, ro, open_flags; 2418 int ret = 0; 2419 uint8_t *buf = NULL; 2420 2421 if (!drv) 2422 return -ENOMEDIUM; 2423 2424 if (!bs->backing) { 2425 return -ENOTSUP; 2426 } 2427 2428 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) || 2429 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) { 2430 return -EBUSY; 2431 } 2432 2433 ro = bs->backing->bs->read_only; 2434 open_flags = bs->backing->bs->open_flags; 2435 2436 if (ro) { 2437 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) { 2438 return -EACCES; 2439 } 2440 } 2441 2442 length = bdrv_getlength(bs); 2443 if (length < 0) { 2444 ret = length; 2445 goto ro_cleanup; 2446 } 2447 2448 backing_length = bdrv_getlength(bs->backing->bs); 2449 if (backing_length < 0) { 2450 ret = backing_length; 2451 goto ro_cleanup; 2452 } 2453 2454 /* If our top snapshot is larger than the backing file image, 2455 * grow the backing file image if possible. If not possible, 2456 * we must return an error */ 2457 if (length > backing_length) { 2458 ret = bdrv_truncate(bs->backing->bs, length); 2459 if (ret < 0) { 2460 goto ro_cleanup; 2461 } 2462 } 2463 2464 total_sectors = length >> BDRV_SECTOR_BITS; 2465 2466 /* qemu_try_blockalign() for bs will choose an alignment that works for 2467 * bs->backing->bs as well, so no need to compare the alignment manually. */ 2468 buf = qemu_try_blockalign(bs, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE); 2469 if (buf == NULL) { 2470 ret = -ENOMEM; 2471 goto ro_cleanup; 2472 } 2473 2474 for (sector = 0; sector < total_sectors; sector += n) { 2475 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n); 2476 if (ret < 0) { 2477 goto ro_cleanup; 2478 } 2479 if (ret) { 2480 ret = bdrv_read(bs, sector, buf, n); 2481 if (ret < 0) { 2482 goto ro_cleanup; 2483 } 2484 2485 ret = bdrv_write(bs->backing->bs, sector, buf, n); 2486 if (ret < 0) { 2487 goto ro_cleanup; 2488 } 2489 } 2490 } 2491 2492 if (drv->bdrv_make_empty) { 2493 ret = drv->bdrv_make_empty(bs); 2494 if (ret < 0) { 2495 goto ro_cleanup; 2496 } 2497 bdrv_flush(bs); 2498 } 2499 2500 /* 2501 * Make sure all data we wrote to the backing device is actually 2502 * stable on disk. 2503 */ 2504 if (bs->backing) { 2505 bdrv_flush(bs->backing->bs); 2506 } 2507 2508 ret = 0; 2509 ro_cleanup: 2510 qemu_vfree(buf); 2511 2512 if (ro) { 2513 /* ignoring error return here */ 2514 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL); 2515 } 2516 2517 return ret; 2518 } 2519 2520 /* 2521 * Return values: 2522 * 0 - success 2523 * -EINVAL - backing format specified, but no file 2524 * -ENOSPC - can't update the backing file because no space is left in the 2525 * image file header 2526 * -ENOTSUP - format driver doesn't support changing the backing file 2527 */ 2528 int bdrv_change_backing_file(BlockDriverState *bs, 2529 const char *backing_file, const char *backing_fmt) 2530 { 2531 BlockDriver *drv = bs->drv; 2532 int ret; 2533 2534 /* Backing file format doesn't make sense without a backing file */ 2535 if (backing_fmt && !backing_file) { 2536 return -EINVAL; 2537 } 2538 2539 if (drv->bdrv_change_backing_file != NULL) { 2540 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt); 2541 } else { 2542 ret = -ENOTSUP; 2543 } 2544 2545 if (ret == 0) { 2546 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); 2547 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); 2548 } 2549 return ret; 2550 } 2551 2552 /* 2553 * Finds the image layer in the chain that has 'bs' as its backing file. 2554 * 2555 * active is the current topmost image. 2556 * 2557 * Returns NULL if bs is not found in active's image chain, 2558 * or if active == bs. 2559 * 2560 * Returns the bottommost base image if bs == NULL. 2561 */ 2562 BlockDriverState *bdrv_find_overlay(BlockDriverState *active, 2563 BlockDriverState *bs) 2564 { 2565 while (active && bs != backing_bs(active)) { 2566 active = backing_bs(active); 2567 } 2568 2569 return active; 2570 } 2571 2572 /* Given a BDS, searches for the base layer. */ 2573 BlockDriverState *bdrv_find_base(BlockDriverState *bs) 2574 { 2575 return bdrv_find_overlay(bs, NULL); 2576 } 2577 2578 /* 2579 * Drops images above 'base' up to and including 'top', and sets the image 2580 * above 'top' to have base as its backing file. 2581 * 2582 * Requires that the overlay to 'top' is opened r/w, so that the backing file 2583 * information in 'bs' can be properly updated. 2584 * 2585 * E.g., this will convert the following chain: 2586 * bottom <- base <- intermediate <- top <- active 2587 * 2588 * to 2589 * 2590 * bottom <- base <- active 2591 * 2592 * It is allowed for bottom==base, in which case it converts: 2593 * 2594 * base <- intermediate <- top <- active 2595 * 2596 * to 2597 * 2598 * base <- active 2599 * 2600 * If backing_file_str is non-NULL, it will be used when modifying top's 2601 * overlay image metadata. 2602 * 2603 * Error conditions: 2604 * if active == top, that is considered an error 2605 * 2606 */ 2607 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top, 2608 BlockDriverState *base, const char *backing_file_str) 2609 { 2610 BlockDriverState *new_top_bs = NULL; 2611 int ret = -EIO; 2612 2613 if (!top->drv || !base->drv) { 2614 goto exit; 2615 } 2616 2617 new_top_bs = bdrv_find_overlay(active, top); 2618 2619 if (new_top_bs == NULL) { 2620 /* we could not find the image above 'top', this is an error */ 2621 goto exit; 2622 } 2623 2624 /* special case of new_top_bs->backing->bs already pointing to base - nothing 2625 * to do, no intermediate images */ 2626 if (backing_bs(new_top_bs) == base) { 2627 ret = 0; 2628 goto exit; 2629 } 2630 2631 /* Make sure that base is in the backing chain of top */ 2632 if (!bdrv_chain_contains(top, base)) { 2633 goto exit; 2634 } 2635 2636 /* success - we can delete the intermediate states, and link top->base */ 2637 backing_file_str = backing_file_str ? backing_file_str : base->filename; 2638 ret = bdrv_change_backing_file(new_top_bs, backing_file_str, 2639 base->drv ? base->drv->format_name : ""); 2640 if (ret) { 2641 goto exit; 2642 } 2643 bdrv_set_backing_hd(new_top_bs, base); 2644 2645 ret = 0; 2646 exit: 2647 return ret; 2648 } 2649 2650 /** 2651 * Truncate file to 'offset' bytes (needed only for file protocols) 2652 */ 2653 int bdrv_truncate(BlockDriverState *bs, int64_t offset) 2654 { 2655 BlockDriver *drv = bs->drv; 2656 int ret; 2657 if (!drv) 2658 return -ENOMEDIUM; 2659 if (!drv->bdrv_truncate) 2660 return -ENOTSUP; 2661 if (bs->read_only) 2662 return -EACCES; 2663 2664 ret = drv->bdrv_truncate(bs, offset); 2665 if (ret == 0) { 2666 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS); 2667 bdrv_dirty_bitmap_truncate(bs); 2668 if (bs->blk) { 2669 blk_dev_resize_cb(bs->blk); 2670 } 2671 } 2672 return ret; 2673 } 2674 2675 /** 2676 * Length of a allocated file in bytes. Sparse files are counted by actual 2677 * allocated space. Return < 0 if error or unknown. 2678 */ 2679 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs) 2680 { 2681 BlockDriver *drv = bs->drv; 2682 if (!drv) { 2683 return -ENOMEDIUM; 2684 } 2685 if (drv->bdrv_get_allocated_file_size) { 2686 return drv->bdrv_get_allocated_file_size(bs); 2687 } 2688 if (bs->file) { 2689 return bdrv_get_allocated_file_size(bs->file->bs); 2690 } 2691 return -ENOTSUP; 2692 } 2693 2694 /** 2695 * Return number of sectors on success, -errno on error. 2696 */ 2697 int64_t bdrv_nb_sectors(BlockDriverState *bs) 2698 { 2699 BlockDriver *drv = bs->drv; 2700 2701 if (!drv) 2702 return -ENOMEDIUM; 2703 2704 if (drv->has_variable_length) { 2705 int ret = refresh_total_sectors(bs, bs->total_sectors); 2706 if (ret < 0) { 2707 return ret; 2708 } 2709 } 2710 return bs->total_sectors; 2711 } 2712 2713 /** 2714 * Return length in bytes on success, -errno on error. 2715 * The length is always a multiple of BDRV_SECTOR_SIZE. 2716 */ 2717 int64_t bdrv_getlength(BlockDriverState *bs) 2718 { 2719 int64_t ret = bdrv_nb_sectors(bs); 2720 2721 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret; 2722 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE; 2723 } 2724 2725 /* return 0 as number of sectors if no device present or error */ 2726 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) 2727 { 2728 int64_t nb_sectors = bdrv_nb_sectors(bs); 2729 2730 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors; 2731 } 2732 2733 int bdrv_is_read_only(BlockDriverState *bs) 2734 { 2735 return bs->read_only; 2736 } 2737 2738 int bdrv_is_sg(BlockDriverState *bs) 2739 { 2740 return bs->sg; 2741 } 2742 2743 int bdrv_enable_write_cache(BlockDriverState *bs) 2744 { 2745 return bs->enable_write_cache; 2746 } 2747 2748 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce) 2749 { 2750 bs->enable_write_cache = wce; 2751 2752 /* so a reopen() will preserve wce */ 2753 if (wce) { 2754 bs->open_flags |= BDRV_O_CACHE_WB; 2755 } else { 2756 bs->open_flags &= ~BDRV_O_CACHE_WB; 2757 } 2758 } 2759 2760 int bdrv_is_encrypted(BlockDriverState *bs) 2761 { 2762 if (bs->backing && bs->backing->bs->encrypted) { 2763 return 1; 2764 } 2765 return bs->encrypted; 2766 } 2767 2768 int bdrv_key_required(BlockDriverState *bs) 2769 { 2770 BdrvChild *backing = bs->backing; 2771 2772 if (backing && backing->bs->encrypted && !backing->bs->valid_key) { 2773 return 1; 2774 } 2775 return (bs->encrypted && !bs->valid_key); 2776 } 2777 2778 int bdrv_set_key(BlockDriverState *bs, const char *key) 2779 { 2780 int ret; 2781 if (bs->backing && bs->backing->bs->encrypted) { 2782 ret = bdrv_set_key(bs->backing->bs, key); 2783 if (ret < 0) 2784 return ret; 2785 if (!bs->encrypted) 2786 return 0; 2787 } 2788 if (!bs->encrypted) { 2789 return -EINVAL; 2790 } else if (!bs->drv || !bs->drv->bdrv_set_key) { 2791 return -ENOMEDIUM; 2792 } 2793 ret = bs->drv->bdrv_set_key(bs, key); 2794 if (ret < 0) { 2795 bs->valid_key = 0; 2796 } else if (!bs->valid_key) { 2797 bs->valid_key = 1; 2798 if (bs->blk) { 2799 /* call the change callback now, we skipped it on open */ 2800 blk_dev_change_media_cb(bs->blk, true); 2801 } 2802 } 2803 return ret; 2804 } 2805 2806 /* 2807 * Provide an encryption key for @bs. 2808 * If @key is non-null: 2809 * If @bs is not encrypted, fail. 2810 * Else if the key is invalid, fail. 2811 * Else set @bs's key to @key, replacing the existing key, if any. 2812 * If @key is null: 2813 * If @bs is encrypted and still lacks a key, fail. 2814 * Else do nothing. 2815 * On failure, store an error object through @errp if non-null. 2816 */ 2817 void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp) 2818 { 2819 if (key) { 2820 if (!bdrv_is_encrypted(bs)) { 2821 error_setg(errp, "Node '%s' is not encrypted", 2822 bdrv_get_device_or_node_name(bs)); 2823 } else if (bdrv_set_key(bs, key) < 0) { 2824 error_setg(errp, QERR_INVALID_PASSWORD); 2825 } 2826 } else { 2827 if (bdrv_key_required(bs)) { 2828 error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED, 2829 "'%s' (%s) is encrypted", 2830 bdrv_get_device_or_node_name(bs), 2831 bdrv_get_encrypted_filename(bs)); 2832 } 2833 } 2834 } 2835 2836 const char *bdrv_get_format_name(BlockDriverState *bs) 2837 { 2838 return bs->drv ? bs->drv->format_name : NULL; 2839 } 2840 2841 static int qsort_strcmp(const void *a, const void *b) 2842 { 2843 return strcmp(a, b); 2844 } 2845 2846 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 2847 void *opaque) 2848 { 2849 BlockDriver *drv; 2850 int count = 0; 2851 int i; 2852 const char **formats = NULL; 2853 2854 QLIST_FOREACH(drv, &bdrv_drivers, list) { 2855 if (drv->format_name) { 2856 bool found = false; 2857 int i = count; 2858 while (formats && i && !found) { 2859 found = !strcmp(formats[--i], drv->format_name); 2860 } 2861 2862 if (!found) { 2863 formats = g_renew(const char *, formats, count + 1); 2864 formats[count++] = drv->format_name; 2865 } 2866 } 2867 } 2868 2869 qsort(formats, count, sizeof(formats[0]), qsort_strcmp); 2870 2871 for (i = 0; i < count; i++) { 2872 it(opaque, formats[i]); 2873 } 2874 2875 g_free(formats); 2876 } 2877 2878 /* This function is to find a node in the bs graph */ 2879 BlockDriverState *bdrv_find_node(const char *node_name) 2880 { 2881 BlockDriverState *bs; 2882 2883 assert(node_name); 2884 2885 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { 2886 if (!strcmp(node_name, bs->node_name)) { 2887 return bs; 2888 } 2889 } 2890 return NULL; 2891 } 2892 2893 /* Put this QMP function here so it can access the static graph_bdrv_states. */ 2894 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp) 2895 { 2896 BlockDeviceInfoList *list, *entry; 2897 BlockDriverState *bs; 2898 2899 list = NULL; 2900 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { 2901 BlockDeviceInfo *info = bdrv_block_device_info(bs, errp); 2902 if (!info) { 2903 qapi_free_BlockDeviceInfoList(list); 2904 return NULL; 2905 } 2906 entry = g_malloc0(sizeof(*entry)); 2907 entry->value = info; 2908 entry->next = list; 2909 list = entry; 2910 } 2911 2912 return list; 2913 } 2914 2915 BlockDriverState *bdrv_lookup_bs(const char *device, 2916 const char *node_name, 2917 Error **errp) 2918 { 2919 BlockBackend *blk; 2920 BlockDriverState *bs; 2921 2922 if (device) { 2923 blk = blk_by_name(device); 2924 2925 if (blk) { 2926 bs = blk_bs(blk); 2927 if (!bs) { 2928 error_setg(errp, "Device '%s' has no medium", device); 2929 } 2930 2931 return bs; 2932 } 2933 } 2934 2935 if (node_name) { 2936 bs = bdrv_find_node(node_name); 2937 2938 if (bs) { 2939 return bs; 2940 } 2941 } 2942 2943 error_setg(errp, "Cannot find device=%s nor node_name=%s", 2944 device ? device : "", 2945 node_name ? node_name : ""); 2946 return NULL; 2947 } 2948 2949 /* If 'base' is in the same chain as 'top', return true. Otherwise, 2950 * return false. If either argument is NULL, return false. */ 2951 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base) 2952 { 2953 while (top && top != base) { 2954 top = backing_bs(top); 2955 } 2956 2957 return top != NULL; 2958 } 2959 2960 BlockDriverState *bdrv_next_node(BlockDriverState *bs) 2961 { 2962 if (!bs) { 2963 return QTAILQ_FIRST(&graph_bdrv_states); 2964 } 2965 return QTAILQ_NEXT(bs, node_list); 2966 } 2967 2968 /* Iterates over all top-level BlockDriverStates, i.e. BDSs that are owned by 2969 * the monitor or attached to a BlockBackend */ 2970 BlockDriverState *bdrv_next(BlockDriverState *bs) 2971 { 2972 if (!bs || bs->blk) { 2973 bs = blk_next_root_bs(bs); 2974 if (bs) { 2975 return bs; 2976 } 2977 } 2978 2979 /* Ignore all BDSs that are attached to a BlockBackend here; they have been 2980 * handled by the above block already */ 2981 do { 2982 bs = bdrv_next_monitor_owned(bs); 2983 } while (bs && bs->blk); 2984 return bs; 2985 } 2986 2987 const char *bdrv_get_node_name(const BlockDriverState *bs) 2988 { 2989 return bs->node_name; 2990 } 2991 2992 /* TODO check what callers really want: bs->node_name or blk_name() */ 2993 const char *bdrv_get_device_name(const BlockDriverState *bs) 2994 { 2995 return bs->blk ? blk_name(bs->blk) : ""; 2996 } 2997 2998 /* This can be used to identify nodes that might not have a device 2999 * name associated. Since node and device names live in the same 3000 * namespace, the result is unambiguous. The exception is if both are 3001 * absent, then this returns an empty (non-null) string. */ 3002 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs) 3003 { 3004 return bs->blk ? blk_name(bs->blk) : bs->node_name; 3005 } 3006 3007 int bdrv_get_flags(BlockDriverState *bs) 3008 { 3009 return bs->open_flags; 3010 } 3011 3012 int bdrv_has_zero_init_1(BlockDriverState *bs) 3013 { 3014 return 1; 3015 } 3016 3017 int bdrv_has_zero_init(BlockDriverState *bs) 3018 { 3019 assert(bs->drv); 3020 3021 /* If BS is a copy on write image, it is initialized to 3022 the contents of the base image, which may not be zeroes. */ 3023 if (bs->backing) { 3024 return 0; 3025 } 3026 if (bs->drv->bdrv_has_zero_init) { 3027 return bs->drv->bdrv_has_zero_init(bs); 3028 } 3029 3030 /* safe default */ 3031 return 0; 3032 } 3033 3034 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs) 3035 { 3036 BlockDriverInfo bdi; 3037 3038 if (bs->backing) { 3039 return false; 3040 } 3041 3042 if (bdrv_get_info(bs, &bdi) == 0) { 3043 return bdi.unallocated_blocks_are_zero; 3044 } 3045 3046 return false; 3047 } 3048 3049 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs) 3050 { 3051 BlockDriverInfo bdi; 3052 3053 if (bs->backing || !(bs->open_flags & BDRV_O_UNMAP)) { 3054 return false; 3055 } 3056 3057 if (bdrv_get_info(bs, &bdi) == 0) { 3058 return bdi.can_write_zeroes_with_unmap; 3059 } 3060 3061 return false; 3062 } 3063 3064 const char *bdrv_get_encrypted_filename(BlockDriverState *bs) 3065 { 3066 if (bs->backing && bs->backing->bs->encrypted) 3067 return bs->backing_file; 3068 else if (bs->encrypted) 3069 return bs->filename; 3070 else 3071 return NULL; 3072 } 3073 3074 void bdrv_get_backing_filename(BlockDriverState *bs, 3075 char *filename, int filename_size) 3076 { 3077 pstrcpy(filename, filename_size, bs->backing_file); 3078 } 3079 3080 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 3081 { 3082 BlockDriver *drv = bs->drv; 3083 if (!drv) 3084 return -ENOMEDIUM; 3085 if (!drv->bdrv_get_info) 3086 return -ENOTSUP; 3087 memset(bdi, 0, sizeof(*bdi)); 3088 return drv->bdrv_get_info(bs, bdi); 3089 } 3090 3091 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs) 3092 { 3093 BlockDriver *drv = bs->drv; 3094 if (drv && drv->bdrv_get_specific_info) { 3095 return drv->bdrv_get_specific_info(bs); 3096 } 3097 return NULL; 3098 } 3099 3100 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event) 3101 { 3102 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) { 3103 return; 3104 } 3105 3106 bs->drv->bdrv_debug_event(bs, event); 3107 } 3108 3109 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event, 3110 const char *tag) 3111 { 3112 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) { 3113 bs = bs->file ? bs->file->bs : NULL; 3114 } 3115 3116 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) { 3117 return bs->drv->bdrv_debug_breakpoint(bs, event, tag); 3118 } 3119 3120 return -ENOTSUP; 3121 } 3122 3123 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag) 3124 { 3125 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) { 3126 bs = bs->file ? bs->file->bs : NULL; 3127 } 3128 3129 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) { 3130 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag); 3131 } 3132 3133 return -ENOTSUP; 3134 } 3135 3136 int bdrv_debug_resume(BlockDriverState *bs, const char *tag) 3137 { 3138 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) { 3139 bs = bs->file ? bs->file->bs : NULL; 3140 } 3141 3142 if (bs && bs->drv && bs->drv->bdrv_debug_resume) { 3143 return bs->drv->bdrv_debug_resume(bs, tag); 3144 } 3145 3146 return -ENOTSUP; 3147 } 3148 3149 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag) 3150 { 3151 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) { 3152 bs = bs->file ? bs->file->bs : NULL; 3153 } 3154 3155 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) { 3156 return bs->drv->bdrv_debug_is_suspended(bs, tag); 3157 } 3158 3159 return false; 3160 } 3161 3162 int bdrv_is_snapshot(BlockDriverState *bs) 3163 { 3164 return !!(bs->open_flags & BDRV_O_SNAPSHOT); 3165 } 3166 3167 /* backing_file can either be relative, or absolute, or a protocol. If it is 3168 * relative, it must be relative to the chain. So, passing in bs->filename 3169 * from a BDS as backing_file should not be done, as that may be relative to 3170 * the CWD rather than the chain. */ 3171 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, 3172 const char *backing_file) 3173 { 3174 char *filename_full = NULL; 3175 char *backing_file_full = NULL; 3176 char *filename_tmp = NULL; 3177 int is_protocol = 0; 3178 BlockDriverState *curr_bs = NULL; 3179 BlockDriverState *retval = NULL; 3180 3181 if (!bs || !bs->drv || !backing_file) { 3182 return NULL; 3183 } 3184 3185 filename_full = g_malloc(PATH_MAX); 3186 backing_file_full = g_malloc(PATH_MAX); 3187 filename_tmp = g_malloc(PATH_MAX); 3188 3189 is_protocol = path_has_protocol(backing_file); 3190 3191 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) { 3192 3193 /* If either of the filename paths is actually a protocol, then 3194 * compare unmodified paths; otherwise make paths relative */ 3195 if (is_protocol || path_has_protocol(curr_bs->backing_file)) { 3196 if (strcmp(backing_file, curr_bs->backing_file) == 0) { 3197 retval = curr_bs->backing->bs; 3198 break; 3199 } 3200 } else { 3201 /* If not an absolute filename path, make it relative to the current 3202 * image's filename path */ 3203 path_combine(filename_tmp, PATH_MAX, curr_bs->filename, 3204 backing_file); 3205 3206 /* We are going to compare absolute pathnames */ 3207 if (!realpath(filename_tmp, filename_full)) { 3208 continue; 3209 } 3210 3211 /* We need to make sure the backing filename we are comparing against 3212 * is relative to the current image filename (or absolute) */ 3213 path_combine(filename_tmp, PATH_MAX, curr_bs->filename, 3214 curr_bs->backing_file); 3215 3216 if (!realpath(filename_tmp, backing_file_full)) { 3217 continue; 3218 } 3219 3220 if (strcmp(backing_file_full, filename_full) == 0) { 3221 retval = curr_bs->backing->bs; 3222 break; 3223 } 3224 } 3225 } 3226 3227 g_free(filename_full); 3228 g_free(backing_file_full); 3229 g_free(filename_tmp); 3230 return retval; 3231 } 3232 3233 int bdrv_get_backing_file_depth(BlockDriverState *bs) 3234 { 3235 if (!bs->drv) { 3236 return 0; 3237 } 3238 3239 if (!bs->backing) { 3240 return 0; 3241 } 3242 3243 return 1 + bdrv_get_backing_file_depth(bs->backing->bs); 3244 } 3245 3246 void bdrv_init(void) 3247 { 3248 module_call_init(MODULE_INIT_BLOCK); 3249 } 3250 3251 void bdrv_init_with_whitelist(void) 3252 { 3253 use_bdrv_whitelist = 1; 3254 bdrv_init(); 3255 } 3256 3257 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 3258 { 3259 Error *local_err = NULL; 3260 int ret; 3261 3262 if (!bs->drv) { 3263 return; 3264 } 3265 3266 if (!(bs->open_flags & BDRV_O_INACTIVE)) { 3267 return; 3268 } 3269 bs->open_flags &= ~BDRV_O_INACTIVE; 3270 3271 if (bs->drv->bdrv_invalidate_cache) { 3272 bs->drv->bdrv_invalidate_cache(bs, &local_err); 3273 } else if (bs->file) { 3274 bdrv_invalidate_cache(bs->file->bs, &local_err); 3275 } 3276 if (local_err) { 3277 bs->open_flags |= BDRV_O_INACTIVE; 3278 error_propagate(errp, local_err); 3279 return; 3280 } 3281 3282 ret = refresh_total_sectors(bs, bs->total_sectors); 3283 if (ret < 0) { 3284 bs->open_flags |= BDRV_O_INACTIVE; 3285 error_setg_errno(errp, -ret, "Could not refresh total sector count"); 3286 return; 3287 } 3288 } 3289 3290 void bdrv_invalidate_cache_all(Error **errp) 3291 { 3292 BlockDriverState *bs = NULL; 3293 Error *local_err = NULL; 3294 3295 while ((bs = bdrv_next(bs)) != NULL) { 3296 AioContext *aio_context = bdrv_get_aio_context(bs); 3297 3298 aio_context_acquire(aio_context); 3299 bdrv_invalidate_cache(bs, &local_err); 3300 aio_context_release(aio_context); 3301 if (local_err) { 3302 error_propagate(errp, local_err); 3303 return; 3304 } 3305 } 3306 } 3307 3308 static int bdrv_inactivate(BlockDriverState *bs) 3309 { 3310 int ret; 3311 3312 if (bs->drv->bdrv_inactivate) { 3313 ret = bs->drv->bdrv_inactivate(bs); 3314 if (ret < 0) { 3315 return ret; 3316 } 3317 } 3318 3319 bs->open_flags |= BDRV_O_INACTIVE; 3320 return 0; 3321 } 3322 3323 int bdrv_inactivate_all(void) 3324 { 3325 BlockDriverState *bs = NULL; 3326 int ret; 3327 3328 while ((bs = bdrv_next(bs)) != NULL) { 3329 AioContext *aio_context = bdrv_get_aio_context(bs); 3330 3331 aio_context_acquire(aio_context); 3332 ret = bdrv_inactivate(bs); 3333 aio_context_release(aio_context); 3334 if (ret < 0) { 3335 return ret; 3336 } 3337 } 3338 3339 return 0; 3340 } 3341 3342 /**************************************************************/ 3343 /* removable device support */ 3344 3345 /** 3346 * Return TRUE if the media is present 3347 */ 3348 bool bdrv_is_inserted(BlockDriverState *bs) 3349 { 3350 BlockDriver *drv = bs->drv; 3351 BdrvChild *child; 3352 3353 if (!drv) { 3354 return false; 3355 } 3356 if (drv->bdrv_is_inserted) { 3357 return drv->bdrv_is_inserted(bs); 3358 } 3359 QLIST_FOREACH(child, &bs->children, next) { 3360 if (!bdrv_is_inserted(child->bs)) { 3361 return false; 3362 } 3363 } 3364 return true; 3365 } 3366 3367 /** 3368 * Return whether the media changed since the last call to this 3369 * function, or -ENOTSUP if we don't know. Most drivers don't know. 3370 */ 3371 int bdrv_media_changed(BlockDriverState *bs) 3372 { 3373 BlockDriver *drv = bs->drv; 3374 3375 if (drv && drv->bdrv_media_changed) { 3376 return drv->bdrv_media_changed(bs); 3377 } 3378 return -ENOTSUP; 3379 } 3380 3381 /** 3382 * If eject_flag is TRUE, eject the media. Otherwise, close the tray 3383 */ 3384 void bdrv_eject(BlockDriverState *bs, bool eject_flag) 3385 { 3386 BlockDriver *drv = bs->drv; 3387 const char *device_name; 3388 3389 if (drv && drv->bdrv_eject) { 3390 drv->bdrv_eject(bs, eject_flag); 3391 } 3392 3393 device_name = bdrv_get_device_name(bs); 3394 if (device_name[0] != '\0') { 3395 qapi_event_send_device_tray_moved(device_name, 3396 eject_flag, &error_abort); 3397 } 3398 } 3399 3400 /** 3401 * Lock or unlock the media (if it is locked, the user won't be able 3402 * to eject it manually). 3403 */ 3404 void bdrv_lock_medium(BlockDriverState *bs, bool locked) 3405 { 3406 BlockDriver *drv = bs->drv; 3407 3408 trace_bdrv_lock_medium(bs, locked); 3409 3410 if (drv && drv->bdrv_lock_medium) { 3411 drv->bdrv_lock_medium(bs, locked); 3412 } 3413 } 3414 3415 /* Get a reference to bs */ 3416 void bdrv_ref(BlockDriverState *bs) 3417 { 3418 bs->refcnt++; 3419 } 3420 3421 /* Release a previously grabbed reference to bs. 3422 * If after releasing, reference count is zero, the BlockDriverState is 3423 * deleted. */ 3424 void bdrv_unref(BlockDriverState *bs) 3425 { 3426 if (!bs) { 3427 return; 3428 } 3429 assert(bs->refcnt > 0); 3430 if (--bs->refcnt == 0) { 3431 bdrv_delete(bs); 3432 } 3433 } 3434 3435 struct BdrvOpBlocker { 3436 Error *reason; 3437 QLIST_ENTRY(BdrvOpBlocker) list; 3438 }; 3439 3440 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) 3441 { 3442 BdrvOpBlocker *blocker; 3443 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 3444 if (!QLIST_EMPTY(&bs->op_blockers[op])) { 3445 blocker = QLIST_FIRST(&bs->op_blockers[op]); 3446 if (errp) { 3447 *errp = error_copy(blocker->reason); 3448 error_prepend(errp, "Node '%s' is busy: ", 3449 bdrv_get_device_or_node_name(bs)); 3450 } 3451 return true; 3452 } 3453 return false; 3454 } 3455 3456 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason) 3457 { 3458 BdrvOpBlocker *blocker; 3459 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 3460 3461 blocker = g_new0(BdrvOpBlocker, 1); 3462 blocker->reason = reason; 3463 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list); 3464 } 3465 3466 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason) 3467 { 3468 BdrvOpBlocker *blocker, *next; 3469 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 3470 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) { 3471 if (blocker->reason == reason) { 3472 QLIST_REMOVE(blocker, list); 3473 g_free(blocker); 3474 } 3475 } 3476 } 3477 3478 void bdrv_op_block_all(BlockDriverState *bs, Error *reason) 3479 { 3480 int i; 3481 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 3482 bdrv_op_block(bs, i, reason); 3483 } 3484 } 3485 3486 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason) 3487 { 3488 int i; 3489 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 3490 bdrv_op_unblock(bs, i, reason); 3491 } 3492 } 3493 3494 bool bdrv_op_blocker_is_empty(BlockDriverState *bs) 3495 { 3496 int i; 3497 3498 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 3499 if (!QLIST_EMPTY(&bs->op_blockers[i])) { 3500 return false; 3501 } 3502 } 3503 return true; 3504 } 3505 3506 void bdrv_img_create(const char *filename, const char *fmt, 3507 const char *base_filename, const char *base_fmt, 3508 char *options, uint64_t img_size, int flags, 3509 Error **errp, bool quiet) 3510 { 3511 QemuOptsList *create_opts = NULL; 3512 QemuOpts *opts = NULL; 3513 const char *backing_fmt, *backing_file; 3514 int64_t size; 3515 BlockDriver *drv, *proto_drv; 3516 Error *local_err = NULL; 3517 int ret = 0; 3518 3519 /* Find driver and parse its options */ 3520 drv = bdrv_find_format(fmt); 3521 if (!drv) { 3522 error_setg(errp, "Unknown file format '%s'", fmt); 3523 return; 3524 } 3525 3526 proto_drv = bdrv_find_protocol(filename, true, errp); 3527 if (!proto_drv) { 3528 return; 3529 } 3530 3531 if (!drv->create_opts) { 3532 error_setg(errp, "Format driver '%s' does not support image creation", 3533 drv->format_name); 3534 return; 3535 } 3536 3537 if (!proto_drv->create_opts) { 3538 error_setg(errp, "Protocol driver '%s' does not support image creation", 3539 proto_drv->format_name); 3540 return; 3541 } 3542 3543 create_opts = qemu_opts_append(create_opts, drv->create_opts); 3544 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); 3545 3546 /* Create parameter list with default values */ 3547 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 3548 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort); 3549 3550 /* Parse -o options */ 3551 if (options) { 3552 qemu_opts_do_parse(opts, options, NULL, &local_err); 3553 if (local_err) { 3554 error_report_err(local_err); 3555 local_err = NULL; 3556 error_setg(errp, "Invalid options for file format '%s'", fmt); 3557 goto out; 3558 } 3559 } 3560 3561 if (base_filename) { 3562 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err); 3563 if (local_err) { 3564 error_setg(errp, "Backing file not supported for file format '%s'", 3565 fmt); 3566 goto out; 3567 } 3568 } 3569 3570 if (base_fmt) { 3571 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err); 3572 if (local_err) { 3573 error_setg(errp, "Backing file format not supported for file " 3574 "format '%s'", fmt); 3575 goto out; 3576 } 3577 } 3578 3579 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE); 3580 if (backing_file) { 3581 if (!strcmp(filename, backing_file)) { 3582 error_setg(errp, "Error: Trying to create an image with the " 3583 "same filename as the backing file"); 3584 goto out; 3585 } 3586 } 3587 3588 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT); 3589 3590 // The size for the image must always be specified, with one exception: 3591 // If we are using a backing file, we can obtain the size from there 3592 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0); 3593 if (size == -1) { 3594 if (backing_file) { 3595 BlockDriverState *bs; 3596 char *full_backing = g_new0(char, PATH_MAX); 3597 int64_t size; 3598 int back_flags; 3599 QDict *backing_options = NULL; 3600 3601 bdrv_get_full_backing_filename_from_filename(filename, backing_file, 3602 full_backing, PATH_MAX, 3603 &local_err); 3604 if (local_err) { 3605 g_free(full_backing); 3606 goto out; 3607 } 3608 3609 /* backing files always opened read-only */ 3610 back_flags = 3611 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); 3612 3613 if (backing_fmt) { 3614 backing_options = qdict_new(); 3615 qdict_put(backing_options, "driver", 3616 qstring_from_str(backing_fmt)); 3617 } 3618 3619 bs = NULL; 3620 ret = bdrv_open(&bs, full_backing, NULL, backing_options, 3621 back_flags, &local_err); 3622 g_free(full_backing); 3623 if (ret < 0) { 3624 goto out; 3625 } 3626 size = bdrv_getlength(bs); 3627 if (size < 0) { 3628 error_setg_errno(errp, -size, "Could not get size of '%s'", 3629 backing_file); 3630 bdrv_unref(bs); 3631 goto out; 3632 } 3633 3634 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort); 3635 3636 bdrv_unref(bs); 3637 } else { 3638 error_setg(errp, "Image creation needs a size parameter"); 3639 goto out; 3640 } 3641 } 3642 3643 if (!quiet) { 3644 printf("Formatting '%s', fmt=%s ", filename, fmt); 3645 qemu_opts_print(opts, " "); 3646 puts(""); 3647 } 3648 3649 ret = bdrv_create(drv, filename, opts, &local_err); 3650 3651 if (ret == -EFBIG) { 3652 /* This is generally a better message than whatever the driver would 3653 * deliver (especially because of the cluster_size_hint), since that 3654 * is most probably not much different from "image too large". */ 3655 const char *cluster_size_hint = ""; 3656 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) { 3657 cluster_size_hint = " (try using a larger cluster size)"; 3658 } 3659 error_setg(errp, "The image size is too large for file format '%s'" 3660 "%s", fmt, cluster_size_hint); 3661 error_free(local_err); 3662 local_err = NULL; 3663 } 3664 3665 out: 3666 qemu_opts_del(opts); 3667 qemu_opts_free(create_opts); 3668 if (local_err) { 3669 error_propagate(errp, local_err); 3670 } 3671 } 3672 3673 AioContext *bdrv_get_aio_context(BlockDriverState *bs) 3674 { 3675 return bs->aio_context; 3676 } 3677 3678 void bdrv_detach_aio_context(BlockDriverState *bs) 3679 { 3680 BdrvAioNotifier *baf; 3681 3682 if (!bs->drv) { 3683 return; 3684 } 3685 3686 QLIST_FOREACH(baf, &bs->aio_notifiers, list) { 3687 baf->detach_aio_context(baf->opaque); 3688 } 3689 3690 if (bs->throttle_state) { 3691 throttle_timers_detach_aio_context(&bs->throttle_timers); 3692 } 3693 if (bs->drv->bdrv_detach_aio_context) { 3694 bs->drv->bdrv_detach_aio_context(bs); 3695 } 3696 if (bs->file) { 3697 bdrv_detach_aio_context(bs->file->bs); 3698 } 3699 if (bs->backing) { 3700 bdrv_detach_aio_context(bs->backing->bs); 3701 } 3702 3703 bs->aio_context = NULL; 3704 } 3705 3706 void bdrv_attach_aio_context(BlockDriverState *bs, 3707 AioContext *new_context) 3708 { 3709 BdrvAioNotifier *ban; 3710 3711 if (!bs->drv) { 3712 return; 3713 } 3714 3715 bs->aio_context = new_context; 3716 3717 if (bs->backing) { 3718 bdrv_attach_aio_context(bs->backing->bs, new_context); 3719 } 3720 if (bs->file) { 3721 bdrv_attach_aio_context(bs->file->bs, new_context); 3722 } 3723 if (bs->drv->bdrv_attach_aio_context) { 3724 bs->drv->bdrv_attach_aio_context(bs, new_context); 3725 } 3726 if (bs->throttle_state) { 3727 throttle_timers_attach_aio_context(&bs->throttle_timers, new_context); 3728 } 3729 3730 QLIST_FOREACH(ban, &bs->aio_notifiers, list) { 3731 ban->attached_aio_context(new_context, ban->opaque); 3732 } 3733 } 3734 3735 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context) 3736 { 3737 bdrv_drain(bs); /* ensure there are no in-flight requests */ 3738 3739 bdrv_detach_aio_context(bs); 3740 3741 /* This function executes in the old AioContext so acquire the new one in 3742 * case it runs in a different thread. 3743 */ 3744 aio_context_acquire(new_context); 3745 bdrv_attach_aio_context(bs, new_context); 3746 aio_context_release(new_context); 3747 } 3748 3749 void bdrv_add_aio_context_notifier(BlockDriverState *bs, 3750 void (*attached_aio_context)(AioContext *new_context, void *opaque), 3751 void (*detach_aio_context)(void *opaque), void *opaque) 3752 { 3753 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1); 3754 *ban = (BdrvAioNotifier){ 3755 .attached_aio_context = attached_aio_context, 3756 .detach_aio_context = detach_aio_context, 3757 .opaque = opaque 3758 }; 3759 3760 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list); 3761 } 3762 3763 void bdrv_remove_aio_context_notifier(BlockDriverState *bs, 3764 void (*attached_aio_context)(AioContext *, 3765 void *), 3766 void (*detach_aio_context)(void *), 3767 void *opaque) 3768 { 3769 BdrvAioNotifier *ban, *ban_next; 3770 3771 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { 3772 if (ban->attached_aio_context == attached_aio_context && 3773 ban->detach_aio_context == detach_aio_context && 3774 ban->opaque == opaque) 3775 { 3776 QLIST_REMOVE(ban, list); 3777 g_free(ban); 3778 3779 return; 3780 } 3781 } 3782 3783 abort(); 3784 } 3785 3786 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts, 3787 BlockDriverAmendStatusCB *status_cb, void *cb_opaque) 3788 { 3789 if (!bs->drv->bdrv_amend_options) { 3790 return -ENOTSUP; 3791 } 3792 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque); 3793 } 3794 3795 /* This function will be called by the bdrv_recurse_is_first_non_filter method 3796 * of block filter and by bdrv_is_first_non_filter. 3797 * It is used to test if the given bs is the candidate or recurse more in the 3798 * node graph. 3799 */ 3800 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs, 3801 BlockDriverState *candidate) 3802 { 3803 /* return false if basic checks fails */ 3804 if (!bs || !bs->drv) { 3805 return false; 3806 } 3807 3808 /* the code reached a non block filter driver -> check if the bs is 3809 * the same as the candidate. It's the recursion termination condition. 3810 */ 3811 if (!bs->drv->is_filter) { 3812 return bs == candidate; 3813 } 3814 /* Down this path the driver is a block filter driver */ 3815 3816 /* If the block filter recursion method is defined use it to recurse down 3817 * the node graph. 3818 */ 3819 if (bs->drv->bdrv_recurse_is_first_non_filter) { 3820 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate); 3821 } 3822 3823 /* the driver is a block filter but don't allow to recurse -> return false 3824 */ 3825 return false; 3826 } 3827 3828 /* This function checks if the candidate is the first non filter bs down it's 3829 * bs chain. Since we don't have pointers to parents it explore all bs chains 3830 * from the top. Some filters can choose not to pass down the recursion. 3831 */ 3832 bool bdrv_is_first_non_filter(BlockDriverState *candidate) 3833 { 3834 BlockDriverState *bs = NULL; 3835 3836 /* walk down the bs forest recursively */ 3837 while ((bs = bdrv_next(bs)) != NULL) { 3838 bool perm; 3839 3840 /* try to recurse in this top level bs */ 3841 perm = bdrv_recurse_is_first_non_filter(bs, candidate); 3842 3843 /* candidate is the first non filter */ 3844 if (perm) { 3845 return true; 3846 } 3847 } 3848 3849 return false; 3850 } 3851 3852 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs, 3853 const char *node_name, Error **errp) 3854 { 3855 BlockDriverState *to_replace_bs = bdrv_find_node(node_name); 3856 AioContext *aio_context; 3857 3858 if (!to_replace_bs) { 3859 error_setg(errp, "Node name '%s' not found", node_name); 3860 return NULL; 3861 } 3862 3863 aio_context = bdrv_get_aio_context(to_replace_bs); 3864 aio_context_acquire(aio_context); 3865 3866 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) { 3867 to_replace_bs = NULL; 3868 goto out; 3869 } 3870 3871 /* We don't want arbitrary node of the BDS chain to be replaced only the top 3872 * most non filter in order to prevent data corruption. 3873 * Another benefit is that this tests exclude backing files which are 3874 * blocked by the backing blockers. 3875 */ 3876 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) { 3877 error_setg(errp, "Only top most non filter can be replaced"); 3878 to_replace_bs = NULL; 3879 goto out; 3880 } 3881 3882 out: 3883 aio_context_release(aio_context); 3884 return to_replace_bs; 3885 } 3886 3887 static bool append_open_options(QDict *d, BlockDriverState *bs) 3888 { 3889 const QDictEntry *entry; 3890 QemuOptDesc *desc; 3891 BdrvChild *child; 3892 bool found_any = false; 3893 const char *p; 3894 3895 for (entry = qdict_first(bs->options); entry; 3896 entry = qdict_next(bs->options, entry)) 3897 { 3898 /* Exclude options for children */ 3899 QLIST_FOREACH(child, &bs->children, next) { 3900 if (strstart(qdict_entry_key(entry), child->name, &p) 3901 && (!*p || *p == '.')) 3902 { 3903 break; 3904 } 3905 } 3906 if (child) { 3907 continue; 3908 } 3909 3910 /* And exclude all non-driver-specific options */ 3911 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) { 3912 if (!strcmp(qdict_entry_key(entry), desc->name)) { 3913 break; 3914 } 3915 } 3916 if (desc->name) { 3917 continue; 3918 } 3919 3920 qobject_incref(qdict_entry_value(entry)); 3921 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry)); 3922 found_any = true; 3923 } 3924 3925 return found_any; 3926 } 3927 3928 /* Updates the following BDS fields: 3929 * - exact_filename: A filename which may be used for opening a block device 3930 * which (mostly) equals the given BDS (even without any 3931 * other options; so reading and writing must return the same 3932 * results, but caching etc. may be different) 3933 * - full_open_options: Options which, when given when opening a block device 3934 * (without a filename), result in a BDS (mostly) 3935 * equalling the given one 3936 * - filename: If exact_filename is set, it is copied here. Otherwise, 3937 * full_open_options is converted to a JSON object, prefixed with 3938 * "json:" (for use through the JSON pseudo protocol) and put here. 3939 */ 3940 void bdrv_refresh_filename(BlockDriverState *bs) 3941 { 3942 BlockDriver *drv = bs->drv; 3943 QDict *opts; 3944 3945 if (!drv) { 3946 return; 3947 } 3948 3949 /* This BDS's file name will most probably depend on its file's name, so 3950 * refresh that first */ 3951 if (bs->file) { 3952 bdrv_refresh_filename(bs->file->bs); 3953 } 3954 3955 if (drv->bdrv_refresh_filename) { 3956 /* Obsolete information is of no use here, so drop the old file name 3957 * information before refreshing it */ 3958 bs->exact_filename[0] = '\0'; 3959 if (bs->full_open_options) { 3960 QDECREF(bs->full_open_options); 3961 bs->full_open_options = NULL; 3962 } 3963 3964 opts = qdict_new(); 3965 append_open_options(opts, bs); 3966 drv->bdrv_refresh_filename(bs, opts); 3967 QDECREF(opts); 3968 } else if (bs->file) { 3969 /* Try to reconstruct valid information from the underlying file */ 3970 bool has_open_options; 3971 3972 bs->exact_filename[0] = '\0'; 3973 if (bs->full_open_options) { 3974 QDECREF(bs->full_open_options); 3975 bs->full_open_options = NULL; 3976 } 3977 3978 opts = qdict_new(); 3979 has_open_options = append_open_options(opts, bs); 3980 3981 /* If no specific options have been given for this BDS, the filename of 3982 * the underlying file should suffice for this one as well */ 3983 if (bs->file->bs->exact_filename[0] && !has_open_options) { 3984 strcpy(bs->exact_filename, bs->file->bs->exact_filename); 3985 } 3986 /* Reconstructing the full options QDict is simple for most format block 3987 * drivers, as long as the full options are known for the underlying 3988 * file BDS. The full options QDict of that file BDS should somehow 3989 * contain a representation of the filename, therefore the following 3990 * suffices without querying the (exact_)filename of this BDS. */ 3991 if (bs->file->bs->full_open_options) { 3992 qdict_put_obj(opts, "driver", 3993 QOBJECT(qstring_from_str(drv->format_name))); 3994 QINCREF(bs->file->bs->full_open_options); 3995 qdict_put_obj(opts, "file", 3996 QOBJECT(bs->file->bs->full_open_options)); 3997 3998 bs->full_open_options = opts; 3999 } else { 4000 QDECREF(opts); 4001 } 4002 } else if (!bs->full_open_options && qdict_size(bs->options)) { 4003 /* There is no underlying file BDS (at least referenced by BDS.file), 4004 * so the full options QDict should be equal to the options given 4005 * specifically for this block device when it was opened (plus the 4006 * driver specification). 4007 * Because those options don't change, there is no need to update 4008 * full_open_options when it's already set. */ 4009 4010 opts = qdict_new(); 4011 append_open_options(opts, bs); 4012 qdict_put_obj(opts, "driver", 4013 QOBJECT(qstring_from_str(drv->format_name))); 4014 4015 if (bs->exact_filename[0]) { 4016 /* This may not work for all block protocol drivers (some may 4017 * require this filename to be parsed), but we have to find some 4018 * default solution here, so just include it. If some block driver 4019 * does not support pure options without any filename at all or 4020 * needs some special format of the options QDict, it needs to 4021 * implement the driver-specific bdrv_refresh_filename() function. 4022 */ 4023 qdict_put_obj(opts, "filename", 4024 QOBJECT(qstring_from_str(bs->exact_filename))); 4025 } 4026 4027 bs->full_open_options = opts; 4028 } 4029 4030 if (bs->exact_filename[0]) { 4031 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename); 4032 } else if (bs->full_open_options) { 4033 QString *json = qobject_to_json(QOBJECT(bs->full_open_options)); 4034 snprintf(bs->filename, sizeof(bs->filename), "json:%s", 4035 qstring_get_str(json)); 4036 QDECREF(json); 4037 } 4038 } 4039