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