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 25 #include "qemu/osdep.h" 26 #include "block/trace.h" 27 #include "block/block_int.h" 28 #include "block/blockjob.h" 29 #include "block/nbd.h" 30 #include "qemu/error-report.h" 31 #include "module_block.h" 32 #include "qemu/module.h" 33 #include "qapi/error.h" 34 #include "qapi/qmp/qdict.h" 35 #include "qapi/qmp/qjson.h" 36 #include "qapi/qmp/qnull.h" 37 #include "qapi/qmp/qstring.h" 38 #include "qapi/qobject-output-visitor.h" 39 #include "qapi/qapi-visit-block-core.h" 40 #include "sysemu/block-backend.h" 41 #include "sysemu/sysemu.h" 42 #include "qemu/notify.h" 43 #include "qemu/option.h" 44 #include "qemu/coroutine.h" 45 #include "block/qapi.h" 46 #include "qemu/timer.h" 47 #include "qemu/cutils.h" 48 #include "qemu/id.h" 49 50 #ifdef CONFIG_BSD 51 #include <sys/ioctl.h> 52 #include <sys/queue.h> 53 #ifndef __DragonFly__ 54 #include <sys/disk.h> 55 #endif 56 #endif 57 58 #ifdef _WIN32 59 #include <windows.h> 60 #endif 61 62 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ 63 64 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states = 65 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states); 66 67 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states = 68 QTAILQ_HEAD_INITIALIZER(all_bdrv_states); 69 70 static QLIST_HEAD(, BlockDriver) bdrv_drivers = 71 QLIST_HEAD_INITIALIZER(bdrv_drivers); 72 73 static BlockDriverState *bdrv_open_inherit(const char *filename, 74 const char *reference, 75 QDict *options, int flags, 76 BlockDriverState *parent, 77 const BdrvChildRole *child_role, 78 Error **errp); 79 80 /* If non-zero, use only whitelisted block drivers */ 81 static int use_bdrv_whitelist; 82 83 #ifdef _WIN32 84 static int is_windows_drive_prefix(const char *filename) 85 { 86 return (((filename[0] >= 'a' && filename[0] <= 'z') || 87 (filename[0] >= 'A' && filename[0] <= 'Z')) && 88 filename[1] == ':'); 89 } 90 91 int is_windows_drive(const char *filename) 92 { 93 if (is_windows_drive_prefix(filename) && 94 filename[2] == '\0') 95 return 1; 96 if (strstart(filename, "\\\\.\\", NULL) || 97 strstart(filename, "//./", NULL)) 98 return 1; 99 return 0; 100 } 101 #endif 102 103 size_t bdrv_opt_mem_align(BlockDriverState *bs) 104 { 105 if (!bs || !bs->drv) { 106 /* page size or 4k (hdd sector size) should be on the safe side */ 107 return MAX(4096, getpagesize()); 108 } 109 110 return bs->bl.opt_mem_alignment; 111 } 112 113 size_t bdrv_min_mem_align(BlockDriverState *bs) 114 { 115 if (!bs || !bs->drv) { 116 /* page size or 4k (hdd sector size) should be on the safe side */ 117 return MAX(4096, getpagesize()); 118 } 119 120 return bs->bl.min_mem_alignment; 121 } 122 123 /* check if the path starts with "<protocol>:" */ 124 int path_has_protocol(const char *path) 125 { 126 const char *p; 127 128 #ifdef _WIN32 129 if (is_windows_drive(path) || 130 is_windows_drive_prefix(path)) { 131 return 0; 132 } 133 p = path + strcspn(path, ":/\\"); 134 #else 135 p = path + strcspn(path, ":/"); 136 #endif 137 138 return *p == ':'; 139 } 140 141 int path_is_absolute(const char *path) 142 { 143 #ifdef _WIN32 144 /* specific case for names like: "\\.\d:" */ 145 if (is_windows_drive(path) || is_windows_drive_prefix(path)) { 146 return 1; 147 } 148 return (*path == '/' || *path == '\\'); 149 #else 150 return (*path == '/'); 151 #endif 152 } 153 154 /* if filename is absolute, just copy it to dest. Otherwise, build a 155 path to it by considering it is relative to base_path. URL are 156 supported. */ 157 void path_combine(char *dest, int dest_size, 158 const char *base_path, 159 const char *filename) 160 { 161 const char *p, *p1; 162 int len; 163 164 if (dest_size <= 0) 165 return; 166 if (path_is_absolute(filename)) { 167 pstrcpy(dest, dest_size, filename); 168 } else { 169 const char *protocol_stripped = NULL; 170 171 if (path_has_protocol(base_path)) { 172 protocol_stripped = strchr(base_path, ':'); 173 if (protocol_stripped) { 174 protocol_stripped++; 175 } 176 } 177 p = protocol_stripped ?: base_path; 178 179 p1 = strrchr(base_path, '/'); 180 #ifdef _WIN32 181 { 182 const char *p2; 183 p2 = strrchr(base_path, '\\'); 184 if (!p1 || p2 > p1) 185 p1 = p2; 186 } 187 #endif 188 if (p1) 189 p1++; 190 else 191 p1 = base_path; 192 if (p1 > p) 193 p = p1; 194 len = p - base_path; 195 if (len > dest_size - 1) 196 len = dest_size - 1; 197 memcpy(dest, base_path, len); 198 dest[len] = '\0'; 199 pstrcat(dest, dest_size, filename); 200 } 201 } 202 203 /* 204 * Helper function for bdrv_parse_filename() implementations to remove optional 205 * protocol prefixes (especially "file:") from a filename and for putting the 206 * stripped filename into the options QDict if there is such a prefix. 207 */ 208 void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix, 209 QDict *options) 210 { 211 if (strstart(filename, prefix, &filename)) { 212 /* Stripping the explicit protocol prefix may result in a protocol 213 * prefix being (wrongly) detected (if the filename contains a colon) */ 214 if (path_has_protocol(filename)) { 215 QString *fat_filename; 216 217 /* This means there is some colon before the first slash; therefore, 218 * this cannot be an absolute path */ 219 assert(!path_is_absolute(filename)); 220 221 /* And we can thus fix the protocol detection issue by prefixing it 222 * by "./" */ 223 fat_filename = qstring_from_str("./"); 224 qstring_append(fat_filename, filename); 225 226 assert(!path_has_protocol(qstring_get_str(fat_filename))); 227 228 qdict_put(options, "filename", fat_filename); 229 } else { 230 /* If no protocol prefix was detected, we can use the shortened 231 * filename as-is */ 232 qdict_put_str(options, "filename", filename); 233 } 234 } 235 } 236 237 238 /* Returns whether the image file is opened as read-only. Note that this can 239 * return false and writing to the image file is still not possible because the 240 * image is inactivated. */ 241 bool bdrv_is_read_only(BlockDriverState *bs) 242 { 243 return bs->read_only; 244 } 245 246 int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, 247 bool ignore_allow_rdw, Error **errp) 248 { 249 /* Do not set read_only if copy_on_read is enabled */ 250 if (bs->copy_on_read && read_only) { 251 error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled", 252 bdrv_get_device_or_node_name(bs)); 253 return -EINVAL; 254 } 255 256 /* Do not clear read_only if it is prohibited */ 257 if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) && 258 !ignore_allow_rdw) 259 { 260 error_setg(errp, "Node '%s' is read only", 261 bdrv_get_device_or_node_name(bs)); 262 return -EPERM; 263 } 264 265 return 0; 266 } 267 268 /* TODO Remove (deprecated since 2.11) 269 * Block drivers are not supposed to automatically change bs->read_only. 270 * Instead, they should just check whether they can provide what the user 271 * explicitly requested and error out if read-write is requested, but they can 272 * only provide read-only access. */ 273 int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp) 274 { 275 int ret = 0; 276 277 ret = bdrv_can_set_read_only(bs, read_only, false, errp); 278 if (ret < 0) { 279 return ret; 280 } 281 282 bs->read_only = read_only; 283 return 0; 284 } 285 286 void bdrv_get_full_backing_filename_from_filename(const char *backed, 287 const char *backing, 288 char *dest, size_t sz, 289 Error **errp) 290 { 291 if (backing[0] == '\0' || path_has_protocol(backing) || 292 path_is_absolute(backing)) 293 { 294 pstrcpy(dest, sz, backing); 295 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) { 296 error_setg(errp, "Cannot use relative backing file names for '%s'", 297 backed); 298 } else { 299 path_combine(dest, sz, backed, backing); 300 } 301 } 302 303 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz, 304 Error **errp) 305 { 306 char *backed = bs->exact_filename[0] ? bs->exact_filename : bs->filename; 307 308 bdrv_get_full_backing_filename_from_filename(backed, bs->backing_file, 309 dest, sz, errp); 310 } 311 312 void bdrv_register(BlockDriver *bdrv) 313 { 314 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list); 315 } 316 317 BlockDriverState *bdrv_new(void) 318 { 319 BlockDriverState *bs; 320 int i; 321 322 bs = g_new0(BlockDriverState, 1); 323 QLIST_INIT(&bs->dirty_bitmaps); 324 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 325 QLIST_INIT(&bs->op_blockers[i]); 326 } 327 notifier_with_return_list_init(&bs->before_write_notifiers); 328 qemu_co_mutex_init(&bs->reqs_lock); 329 qemu_mutex_init(&bs->dirty_bitmap_mutex); 330 bs->refcnt = 1; 331 bs->aio_context = qemu_get_aio_context(); 332 333 qemu_co_queue_init(&bs->flush_queue); 334 335 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list); 336 337 return bs; 338 } 339 340 static BlockDriver *bdrv_do_find_format(const char *format_name) 341 { 342 BlockDriver *drv1; 343 344 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 345 if (!strcmp(drv1->format_name, format_name)) { 346 return drv1; 347 } 348 } 349 350 return NULL; 351 } 352 353 BlockDriver *bdrv_find_format(const char *format_name) 354 { 355 BlockDriver *drv1; 356 int i; 357 358 drv1 = bdrv_do_find_format(format_name); 359 if (drv1) { 360 return drv1; 361 } 362 363 /* The driver isn't registered, maybe we need to load a module */ 364 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) { 365 if (!strcmp(block_driver_modules[i].format_name, format_name)) { 366 block_module_load_one(block_driver_modules[i].library_name); 367 break; 368 } 369 } 370 371 return bdrv_do_find_format(format_name); 372 } 373 374 int bdrv_is_whitelisted(BlockDriver *drv, bool read_only) 375 { 376 static const char *whitelist_rw[] = { 377 CONFIG_BDRV_RW_WHITELIST 378 }; 379 static const char *whitelist_ro[] = { 380 CONFIG_BDRV_RO_WHITELIST 381 }; 382 const char **p; 383 384 if (!whitelist_rw[0] && !whitelist_ro[0]) { 385 return 1; /* no whitelist, anything goes */ 386 } 387 388 for (p = whitelist_rw; *p; p++) { 389 if (!strcmp(drv->format_name, *p)) { 390 return 1; 391 } 392 } 393 if (read_only) { 394 for (p = whitelist_ro; *p; p++) { 395 if (!strcmp(drv->format_name, *p)) { 396 return 1; 397 } 398 } 399 } 400 return 0; 401 } 402 403 bool bdrv_uses_whitelist(void) 404 { 405 return use_bdrv_whitelist; 406 } 407 408 typedef struct CreateCo { 409 BlockDriver *drv; 410 char *filename; 411 QemuOpts *opts; 412 int ret; 413 Error *err; 414 } CreateCo; 415 416 static void coroutine_fn bdrv_create_co_entry(void *opaque) 417 { 418 Error *local_err = NULL; 419 int ret; 420 421 CreateCo *cco = opaque; 422 assert(cco->drv); 423 424 ret = cco->drv->bdrv_co_create_opts(cco->filename, cco->opts, &local_err); 425 error_propagate(&cco->err, local_err); 426 cco->ret = ret; 427 } 428 429 int bdrv_create(BlockDriver *drv, const char* filename, 430 QemuOpts *opts, Error **errp) 431 { 432 int ret; 433 434 Coroutine *co; 435 CreateCo cco = { 436 .drv = drv, 437 .filename = g_strdup(filename), 438 .opts = opts, 439 .ret = NOT_DONE, 440 .err = NULL, 441 }; 442 443 if (!drv->bdrv_co_create_opts) { 444 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name); 445 ret = -ENOTSUP; 446 goto out; 447 } 448 449 if (qemu_in_coroutine()) { 450 /* Fast-path if already in coroutine context */ 451 bdrv_create_co_entry(&cco); 452 } else { 453 co = qemu_coroutine_create(bdrv_create_co_entry, &cco); 454 qemu_coroutine_enter(co); 455 while (cco.ret == NOT_DONE) { 456 aio_poll(qemu_get_aio_context(), true); 457 } 458 } 459 460 ret = cco.ret; 461 if (ret < 0) { 462 if (cco.err) { 463 error_propagate(errp, cco.err); 464 } else { 465 error_setg_errno(errp, -ret, "Could not create image"); 466 } 467 } 468 469 out: 470 g_free(cco.filename); 471 return ret; 472 } 473 474 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp) 475 { 476 BlockDriver *drv; 477 Error *local_err = NULL; 478 int ret; 479 480 drv = bdrv_find_protocol(filename, true, errp); 481 if (drv == NULL) { 482 return -ENOENT; 483 } 484 485 ret = bdrv_create(drv, filename, opts, &local_err); 486 error_propagate(errp, local_err); 487 return ret; 488 } 489 490 /** 491 * Try to get @bs's logical and physical block size. 492 * On success, store them in @bsz struct and return 0. 493 * On failure return -errno. 494 * @bs must not be empty. 495 */ 496 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz) 497 { 498 BlockDriver *drv = bs->drv; 499 500 if (drv && drv->bdrv_probe_blocksizes) { 501 return drv->bdrv_probe_blocksizes(bs, bsz); 502 } else if (drv && drv->is_filter && bs->file) { 503 return bdrv_probe_blocksizes(bs->file->bs, bsz); 504 } 505 506 return -ENOTSUP; 507 } 508 509 /** 510 * Try to get @bs's geometry (cyls, heads, sectors). 511 * On success, store them in @geo struct and return 0. 512 * On failure return -errno. 513 * @bs must not be empty. 514 */ 515 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo) 516 { 517 BlockDriver *drv = bs->drv; 518 519 if (drv && drv->bdrv_probe_geometry) { 520 return drv->bdrv_probe_geometry(bs, geo); 521 } else if (drv && drv->is_filter && bs->file) { 522 return bdrv_probe_geometry(bs->file->bs, geo); 523 } 524 525 return -ENOTSUP; 526 } 527 528 /* 529 * Create a uniquely-named empty temporary file. 530 * Return 0 upon success, otherwise a negative errno value. 531 */ 532 int get_tmp_filename(char *filename, int size) 533 { 534 #ifdef _WIN32 535 char temp_dir[MAX_PATH]; 536 /* GetTempFileName requires that its output buffer (4th param) 537 have length MAX_PATH or greater. */ 538 assert(size >= MAX_PATH); 539 return (GetTempPath(MAX_PATH, temp_dir) 540 && GetTempFileName(temp_dir, "qem", 0, filename) 541 ? 0 : -GetLastError()); 542 #else 543 int fd; 544 const char *tmpdir; 545 tmpdir = getenv("TMPDIR"); 546 if (!tmpdir) { 547 tmpdir = "/var/tmp"; 548 } 549 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) { 550 return -EOVERFLOW; 551 } 552 fd = mkstemp(filename); 553 if (fd < 0) { 554 return -errno; 555 } 556 if (close(fd) != 0) { 557 unlink(filename); 558 return -errno; 559 } 560 return 0; 561 #endif 562 } 563 564 /* 565 * Detect host devices. By convention, /dev/cdrom[N] is always 566 * recognized as a host CDROM. 567 */ 568 static BlockDriver *find_hdev_driver(const char *filename) 569 { 570 int score_max = 0, score; 571 BlockDriver *drv = NULL, *d; 572 573 QLIST_FOREACH(d, &bdrv_drivers, list) { 574 if (d->bdrv_probe_device) { 575 score = d->bdrv_probe_device(filename); 576 if (score > score_max) { 577 score_max = score; 578 drv = d; 579 } 580 } 581 } 582 583 return drv; 584 } 585 586 static BlockDriver *bdrv_do_find_protocol(const char *protocol) 587 { 588 BlockDriver *drv1; 589 590 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 591 if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) { 592 return drv1; 593 } 594 } 595 596 return NULL; 597 } 598 599 BlockDriver *bdrv_find_protocol(const char *filename, 600 bool allow_protocol_prefix, 601 Error **errp) 602 { 603 BlockDriver *drv1; 604 char protocol[128]; 605 int len; 606 const char *p; 607 int i; 608 609 /* TODO Drivers without bdrv_file_open must be specified explicitly */ 610 611 /* 612 * XXX(hch): we really should not let host device detection 613 * override an explicit protocol specification, but moving this 614 * later breaks access to device names with colons in them. 615 * Thanks to the brain-dead persistent naming schemes on udev- 616 * based Linux systems those actually are quite common. 617 */ 618 drv1 = find_hdev_driver(filename); 619 if (drv1) { 620 return drv1; 621 } 622 623 if (!path_has_protocol(filename) || !allow_protocol_prefix) { 624 return &bdrv_file; 625 } 626 627 p = strchr(filename, ':'); 628 assert(p != NULL); 629 len = p - filename; 630 if (len > sizeof(protocol) - 1) 631 len = sizeof(protocol) - 1; 632 memcpy(protocol, filename, len); 633 protocol[len] = '\0'; 634 635 drv1 = bdrv_do_find_protocol(protocol); 636 if (drv1) { 637 return drv1; 638 } 639 640 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) { 641 if (block_driver_modules[i].protocol_name && 642 !strcmp(block_driver_modules[i].protocol_name, protocol)) { 643 block_module_load_one(block_driver_modules[i].library_name); 644 break; 645 } 646 } 647 648 drv1 = bdrv_do_find_protocol(protocol); 649 if (!drv1) { 650 error_setg(errp, "Unknown protocol '%s'", protocol); 651 } 652 return drv1; 653 } 654 655 /* 656 * Guess image format by probing its contents. 657 * This is not a good idea when your image is raw (CVE-2008-2004), but 658 * we do it anyway for backward compatibility. 659 * 660 * @buf contains the image's first @buf_size bytes. 661 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE, 662 * but can be smaller if the image file is smaller) 663 * @filename is its filename. 664 * 665 * For all block drivers, call the bdrv_probe() method to get its 666 * probing score. 667 * Return the first block driver with the highest probing score. 668 */ 669 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, 670 const char *filename) 671 { 672 int score_max = 0, score; 673 BlockDriver *drv = NULL, *d; 674 675 QLIST_FOREACH(d, &bdrv_drivers, list) { 676 if (d->bdrv_probe) { 677 score = d->bdrv_probe(buf, buf_size, filename); 678 if (score > score_max) { 679 score_max = score; 680 drv = d; 681 } 682 } 683 } 684 685 return drv; 686 } 687 688 static int find_image_format(BlockBackend *file, const char *filename, 689 BlockDriver **pdrv, Error **errp) 690 { 691 BlockDriver *drv; 692 uint8_t buf[BLOCK_PROBE_BUF_SIZE]; 693 int ret = 0; 694 695 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */ 696 if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) { 697 *pdrv = &bdrv_raw; 698 return ret; 699 } 700 701 ret = blk_pread(file, 0, buf, sizeof(buf)); 702 if (ret < 0) { 703 error_setg_errno(errp, -ret, "Could not read image for determining its " 704 "format"); 705 *pdrv = NULL; 706 return ret; 707 } 708 709 drv = bdrv_probe_all(buf, ret, filename); 710 if (!drv) { 711 error_setg(errp, "Could not determine image format: No compatible " 712 "driver found"); 713 ret = -ENOENT; 714 } 715 *pdrv = drv; 716 return ret; 717 } 718 719 /** 720 * Set the current 'total_sectors' value 721 * Return 0 on success, -errno on error. 722 */ 723 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint) 724 { 725 BlockDriver *drv = bs->drv; 726 727 if (!drv) { 728 return -ENOMEDIUM; 729 } 730 731 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */ 732 if (bdrv_is_sg(bs)) 733 return 0; 734 735 /* query actual device if possible, otherwise just trust the hint */ 736 if (drv->bdrv_getlength) { 737 int64_t length = drv->bdrv_getlength(bs); 738 if (length < 0) { 739 return length; 740 } 741 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE); 742 } 743 744 bs->total_sectors = hint; 745 return 0; 746 } 747 748 /** 749 * Combines a QDict of new block driver @options with any missing options taken 750 * from @old_options, so that leaving out an option defaults to its old value. 751 */ 752 static void bdrv_join_options(BlockDriverState *bs, QDict *options, 753 QDict *old_options) 754 { 755 if (bs->drv && bs->drv->bdrv_join_options) { 756 bs->drv->bdrv_join_options(options, old_options); 757 } else { 758 qdict_join(options, old_options, false); 759 } 760 } 761 762 /** 763 * Set open flags for a given discard mode 764 * 765 * Return 0 on success, -1 if the discard mode was invalid. 766 */ 767 int bdrv_parse_discard_flags(const char *mode, int *flags) 768 { 769 *flags &= ~BDRV_O_UNMAP; 770 771 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) { 772 /* do nothing */ 773 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) { 774 *flags |= BDRV_O_UNMAP; 775 } else { 776 return -1; 777 } 778 779 return 0; 780 } 781 782 /** 783 * Set open flags for a given cache mode 784 * 785 * Return 0 on success, -1 if the cache mode was invalid. 786 */ 787 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough) 788 { 789 *flags &= ~BDRV_O_CACHE_MASK; 790 791 if (!strcmp(mode, "off") || !strcmp(mode, "none")) { 792 *writethrough = false; 793 *flags |= BDRV_O_NOCACHE; 794 } else if (!strcmp(mode, "directsync")) { 795 *writethrough = true; 796 *flags |= BDRV_O_NOCACHE; 797 } else if (!strcmp(mode, "writeback")) { 798 *writethrough = false; 799 } else if (!strcmp(mode, "unsafe")) { 800 *writethrough = false; 801 *flags |= BDRV_O_NO_FLUSH; 802 } else if (!strcmp(mode, "writethrough")) { 803 *writethrough = true; 804 } else { 805 return -1; 806 } 807 808 return 0; 809 } 810 811 static char *bdrv_child_get_parent_desc(BdrvChild *c) 812 { 813 BlockDriverState *parent = c->opaque; 814 return g_strdup(bdrv_get_device_or_node_name(parent)); 815 } 816 817 static void bdrv_child_cb_drained_begin(BdrvChild *child) 818 { 819 BlockDriverState *bs = child->opaque; 820 bdrv_drained_begin(bs); 821 } 822 823 static void bdrv_child_cb_drained_end(BdrvChild *child) 824 { 825 BlockDriverState *bs = child->opaque; 826 bdrv_drained_end(bs); 827 } 828 829 static void bdrv_child_cb_attach(BdrvChild *child) 830 { 831 BlockDriverState *bs = child->opaque; 832 bdrv_apply_subtree_drain(child, bs); 833 } 834 835 static void bdrv_child_cb_detach(BdrvChild *child) 836 { 837 BlockDriverState *bs = child->opaque; 838 bdrv_unapply_subtree_drain(child, bs); 839 } 840 841 static int bdrv_child_cb_inactivate(BdrvChild *child) 842 { 843 BlockDriverState *bs = child->opaque; 844 assert(bs->open_flags & BDRV_O_INACTIVE); 845 return 0; 846 } 847 848 /* 849 * Returns the options and flags that a temporary snapshot should get, based on 850 * the originally requested flags (the originally requested image will have 851 * flags like a backing file) 852 */ 853 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options, 854 int parent_flags, QDict *parent_options) 855 { 856 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY; 857 858 /* For temporary files, unconditional cache=unsafe is fine */ 859 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off"); 860 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on"); 861 862 /* Copy the read-only option from the parent */ 863 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY); 864 865 /* aio=native doesn't work for cache.direct=off, so disable it for the 866 * temporary snapshot */ 867 *child_flags &= ~BDRV_O_NATIVE_AIO; 868 } 869 870 /* 871 * Returns the options and flags that bs->file should get if a protocol driver 872 * is expected, based on the given options and flags for the parent BDS 873 */ 874 static void bdrv_inherited_options(int *child_flags, QDict *child_options, 875 int parent_flags, QDict *parent_options) 876 { 877 int flags = parent_flags; 878 879 /* Enable protocol handling, disable format probing for bs->file */ 880 flags |= BDRV_O_PROTOCOL; 881 882 /* If the cache mode isn't explicitly set, inherit direct and no-flush from 883 * the parent. */ 884 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT); 885 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH); 886 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE); 887 888 /* Inherit the read-only option from the parent if it's not set */ 889 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY); 890 891 /* Our block drivers take care to send flushes and respect unmap policy, 892 * so we can default to enable both on lower layers regardless of the 893 * corresponding parent options. */ 894 qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap"); 895 896 /* Clear flags that only apply to the top layer */ 897 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ | 898 BDRV_O_NO_IO); 899 900 *child_flags = flags; 901 } 902 903 const BdrvChildRole child_file = { 904 .get_parent_desc = bdrv_child_get_parent_desc, 905 .inherit_options = bdrv_inherited_options, 906 .drained_begin = bdrv_child_cb_drained_begin, 907 .drained_end = bdrv_child_cb_drained_end, 908 .attach = bdrv_child_cb_attach, 909 .detach = bdrv_child_cb_detach, 910 .inactivate = bdrv_child_cb_inactivate, 911 }; 912 913 /* 914 * Returns the options and flags that bs->file should get if the use of formats 915 * (and not only protocols) is permitted for it, based on the given options and 916 * flags for the parent BDS 917 */ 918 static void bdrv_inherited_fmt_options(int *child_flags, QDict *child_options, 919 int parent_flags, QDict *parent_options) 920 { 921 child_file.inherit_options(child_flags, child_options, 922 parent_flags, parent_options); 923 924 *child_flags &= ~(BDRV_O_PROTOCOL | BDRV_O_NO_IO); 925 } 926 927 const BdrvChildRole child_format = { 928 .get_parent_desc = bdrv_child_get_parent_desc, 929 .inherit_options = bdrv_inherited_fmt_options, 930 .drained_begin = bdrv_child_cb_drained_begin, 931 .drained_end = bdrv_child_cb_drained_end, 932 .attach = bdrv_child_cb_attach, 933 .detach = bdrv_child_cb_detach, 934 .inactivate = bdrv_child_cb_inactivate, 935 }; 936 937 static void bdrv_backing_attach(BdrvChild *c) 938 { 939 BlockDriverState *parent = c->opaque; 940 BlockDriverState *backing_hd = c->bs; 941 942 assert(!parent->backing_blocker); 943 error_setg(&parent->backing_blocker, 944 "node is used as backing hd of '%s'", 945 bdrv_get_device_or_node_name(parent)); 946 947 parent->open_flags &= ~BDRV_O_NO_BACKING; 948 pstrcpy(parent->backing_file, sizeof(parent->backing_file), 949 backing_hd->filename); 950 pstrcpy(parent->backing_format, sizeof(parent->backing_format), 951 backing_hd->drv ? backing_hd->drv->format_name : ""); 952 953 bdrv_op_block_all(backing_hd, parent->backing_blocker); 954 /* Otherwise we won't be able to commit or stream */ 955 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET, 956 parent->backing_blocker); 957 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM, 958 parent->backing_blocker); 959 /* 960 * We do backup in 3 ways: 961 * 1. drive backup 962 * The target bs is new opened, and the source is top BDS 963 * 2. blockdev backup 964 * Both the source and the target are top BDSes. 965 * 3. internal backup(used for block replication) 966 * Both the source and the target are backing file 967 * 968 * In case 1 and 2, neither the source nor the target is the backing file. 969 * In case 3, we will block the top BDS, so there is only one block job 970 * for the top BDS and its backing chain. 971 */ 972 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE, 973 parent->backing_blocker); 974 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET, 975 parent->backing_blocker); 976 977 bdrv_child_cb_attach(c); 978 } 979 980 static void bdrv_backing_detach(BdrvChild *c) 981 { 982 BlockDriverState *parent = c->opaque; 983 984 assert(parent->backing_blocker); 985 bdrv_op_unblock_all(c->bs, parent->backing_blocker); 986 error_free(parent->backing_blocker); 987 parent->backing_blocker = NULL; 988 989 bdrv_child_cb_detach(c); 990 } 991 992 /* 993 * Returns the options and flags that bs->backing should get, based on the 994 * given options and flags for the parent BDS 995 */ 996 static void bdrv_backing_options(int *child_flags, QDict *child_options, 997 int parent_flags, QDict *parent_options) 998 { 999 int flags = parent_flags; 1000 1001 /* The cache mode is inherited unmodified for backing files; except WCE, 1002 * which is only applied on the top level (BlockBackend) */ 1003 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT); 1004 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH); 1005 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE); 1006 1007 /* backing files always opened read-only */ 1008 qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on"); 1009 flags &= ~BDRV_O_COPY_ON_READ; 1010 1011 /* snapshot=on is handled on the top layer */ 1012 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY); 1013 1014 *child_flags = flags; 1015 } 1016 1017 static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base, 1018 const char *filename, Error **errp) 1019 { 1020 BlockDriverState *parent = c->opaque; 1021 int orig_flags = bdrv_get_flags(parent); 1022 int ret; 1023 1024 if (!(orig_flags & BDRV_O_RDWR)) { 1025 ret = bdrv_reopen(parent, orig_flags | BDRV_O_RDWR, errp); 1026 if (ret < 0) { 1027 return ret; 1028 } 1029 } 1030 1031 ret = bdrv_change_backing_file(parent, filename, 1032 base->drv ? base->drv->format_name : ""); 1033 if (ret < 0) { 1034 error_setg_errno(errp, -ret, "Could not update backing file link"); 1035 } 1036 1037 if (!(orig_flags & BDRV_O_RDWR)) { 1038 bdrv_reopen(parent, orig_flags, NULL); 1039 } 1040 1041 return ret; 1042 } 1043 1044 const BdrvChildRole child_backing = { 1045 .get_parent_desc = bdrv_child_get_parent_desc, 1046 .attach = bdrv_backing_attach, 1047 .detach = bdrv_backing_detach, 1048 .inherit_options = bdrv_backing_options, 1049 .drained_begin = bdrv_child_cb_drained_begin, 1050 .drained_end = bdrv_child_cb_drained_end, 1051 .inactivate = bdrv_child_cb_inactivate, 1052 .update_filename = bdrv_backing_update_filename, 1053 }; 1054 1055 static int bdrv_open_flags(BlockDriverState *bs, int flags) 1056 { 1057 int open_flags = flags; 1058 1059 /* 1060 * Clear flags that are internal to the block layer before opening the 1061 * image. 1062 */ 1063 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL); 1064 1065 /* 1066 * Snapshots should be writable. 1067 */ 1068 if (flags & BDRV_O_TEMPORARY) { 1069 open_flags |= BDRV_O_RDWR; 1070 } 1071 1072 return open_flags; 1073 } 1074 1075 static void update_flags_from_options(int *flags, QemuOpts *opts) 1076 { 1077 *flags &= ~BDRV_O_CACHE_MASK; 1078 1079 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_NO_FLUSH)); 1080 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) { 1081 *flags |= BDRV_O_NO_FLUSH; 1082 } 1083 1084 assert(qemu_opt_find(opts, BDRV_OPT_CACHE_DIRECT)); 1085 if (qemu_opt_get_bool(opts, BDRV_OPT_CACHE_DIRECT, false)) { 1086 *flags |= BDRV_O_NOCACHE; 1087 } 1088 1089 *flags &= ~BDRV_O_RDWR; 1090 1091 assert(qemu_opt_find(opts, BDRV_OPT_READ_ONLY)); 1092 if (!qemu_opt_get_bool(opts, BDRV_OPT_READ_ONLY, false)) { 1093 *flags |= BDRV_O_RDWR; 1094 } 1095 1096 } 1097 1098 static void update_options_from_flags(QDict *options, int flags) 1099 { 1100 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) { 1101 qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE); 1102 } 1103 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) { 1104 qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH, 1105 flags & BDRV_O_NO_FLUSH); 1106 } 1107 if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) { 1108 qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR)); 1109 } 1110 } 1111 1112 static void bdrv_assign_node_name(BlockDriverState *bs, 1113 const char *node_name, 1114 Error **errp) 1115 { 1116 char *gen_node_name = NULL; 1117 1118 if (!node_name) { 1119 node_name = gen_node_name = id_generate(ID_BLOCK); 1120 } else if (!id_wellformed(node_name)) { 1121 /* 1122 * Check for empty string or invalid characters, but not if it is 1123 * generated (generated names use characters not available to the user) 1124 */ 1125 error_setg(errp, "Invalid node name"); 1126 return; 1127 } 1128 1129 /* takes care of avoiding namespaces collisions */ 1130 if (blk_by_name(node_name)) { 1131 error_setg(errp, "node-name=%s is conflicting with a device id", 1132 node_name); 1133 goto out; 1134 } 1135 1136 /* takes care of avoiding duplicates node names */ 1137 if (bdrv_find_node(node_name)) { 1138 error_setg(errp, "Duplicate node name"); 1139 goto out; 1140 } 1141 1142 /* copy node name into the bs and insert it into the graph list */ 1143 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name); 1144 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list); 1145 out: 1146 g_free(gen_node_name); 1147 } 1148 1149 static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv, 1150 const char *node_name, QDict *options, 1151 int open_flags, Error **errp) 1152 { 1153 Error *local_err = NULL; 1154 int ret; 1155 1156 bdrv_assign_node_name(bs, node_name, &local_err); 1157 if (local_err) { 1158 error_propagate(errp, local_err); 1159 return -EINVAL; 1160 } 1161 1162 bs->drv = drv; 1163 bs->read_only = !(bs->open_flags & BDRV_O_RDWR); 1164 bs->opaque = g_malloc0(drv->instance_size); 1165 1166 if (drv->bdrv_file_open) { 1167 assert(!drv->bdrv_needs_filename || bs->filename[0]); 1168 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err); 1169 } else if (drv->bdrv_open) { 1170 ret = drv->bdrv_open(bs, options, open_flags, &local_err); 1171 } else { 1172 ret = 0; 1173 } 1174 1175 if (ret < 0) { 1176 if (local_err) { 1177 error_propagate(errp, local_err); 1178 } else if (bs->filename[0]) { 1179 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename); 1180 } else { 1181 error_setg_errno(errp, -ret, "Could not open image"); 1182 } 1183 goto open_failed; 1184 } 1185 1186 ret = refresh_total_sectors(bs, bs->total_sectors); 1187 if (ret < 0) { 1188 error_setg_errno(errp, -ret, "Could not refresh total sector count"); 1189 return ret; 1190 } 1191 1192 bdrv_refresh_limits(bs, &local_err); 1193 if (local_err) { 1194 error_propagate(errp, local_err); 1195 return -EINVAL; 1196 } 1197 1198 assert(bdrv_opt_mem_align(bs) != 0); 1199 assert(bdrv_min_mem_align(bs) != 0); 1200 assert(is_power_of_2(bs->bl.request_alignment)); 1201 1202 return 0; 1203 open_failed: 1204 bs->drv = NULL; 1205 if (bs->file != NULL) { 1206 bdrv_unref_child(bs, bs->file); 1207 bs->file = NULL; 1208 } 1209 g_free(bs->opaque); 1210 bs->opaque = NULL; 1211 return ret; 1212 } 1213 1214 BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name, 1215 int flags, Error **errp) 1216 { 1217 BlockDriverState *bs; 1218 int ret; 1219 1220 bs = bdrv_new(); 1221 bs->open_flags = flags; 1222 bs->explicit_options = qdict_new(); 1223 bs->options = qdict_new(); 1224 bs->opaque = NULL; 1225 1226 update_options_from_flags(bs->options, flags); 1227 1228 ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp); 1229 if (ret < 0) { 1230 QDECREF(bs->explicit_options); 1231 bs->explicit_options = NULL; 1232 QDECREF(bs->options); 1233 bs->options = NULL; 1234 bdrv_unref(bs); 1235 return NULL; 1236 } 1237 1238 return bs; 1239 } 1240 1241 QemuOptsList bdrv_runtime_opts = { 1242 .name = "bdrv_common", 1243 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head), 1244 .desc = { 1245 { 1246 .name = "node-name", 1247 .type = QEMU_OPT_STRING, 1248 .help = "Node name of the block device node", 1249 }, 1250 { 1251 .name = "driver", 1252 .type = QEMU_OPT_STRING, 1253 .help = "Block driver to use for the node", 1254 }, 1255 { 1256 .name = BDRV_OPT_CACHE_DIRECT, 1257 .type = QEMU_OPT_BOOL, 1258 .help = "Bypass software writeback cache on the host", 1259 }, 1260 { 1261 .name = BDRV_OPT_CACHE_NO_FLUSH, 1262 .type = QEMU_OPT_BOOL, 1263 .help = "Ignore flush requests", 1264 }, 1265 { 1266 .name = BDRV_OPT_READ_ONLY, 1267 .type = QEMU_OPT_BOOL, 1268 .help = "Node is opened in read-only mode", 1269 }, 1270 { 1271 .name = "detect-zeroes", 1272 .type = QEMU_OPT_STRING, 1273 .help = "try to optimize zero writes (off, on, unmap)", 1274 }, 1275 { 1276 .name = "discard", 1277 .type = QEMU_OPT_STRING, 1278 .help = "discard operation (ignore/off, unmap/on)", 1279 }, 1280 { 1281 .name = BDRV_OPT_FORCE_SHARE, 1282 .type = QEMU_OPT_BOOL, 1283 .help = "always accept other writers (default: off)", 1284 }, 1285 { /* end of list */ } 1286 }, 1287 }; 1288 1289 /* 1290 * Common part for opening disk images and files 1291 * 1292 * Removes all processed options from *options. 1293 */ 1294 static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file, 1295 QDict *options, Error **errp) 1296 { 1297 int ret, open_flags; 1298 const char *filename; 1299 const char *driver_name = NULL; 1300 const char *node_name = NULL; 1301 const char *discard; 1302 const char *detect_zeroes; 1303 QemuOpts *opts; 1304 BlockDriver *drv; 1305 Error *local_err = NULL; 1306 1307 assert(bs->file == NULL); 1308 assert(options != NULL && bs->options != options); 1309 1310 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort); 1311 qemu_opts_absorb_qdict(opts, options, &local_err); 1312 if (local_err) { 1313 error_propagate(errp, local_err); 1314 ret = -EINVAL; 1315 goto fail_opts; 1316 } 1317 1318 update_flags_from_options(&bs->open_flags, opts); 1319 1320 driver_name = qemu_opt_get(opts, "driver"); 1321 drv = bdrv_find_format(driver_name); 1322 assert(drv != NULL); 1323 1324 bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false); 1325 1326 if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) { 1327 error_setg(errp, 1328 BDRV_OPT_FORCE_SHARE 1329 "=on can only be used with read-only images"); 1330 ret = -EINVAL; 1331 goto fail_opts; 1332 } 1333 1334 if (file != NULL) { 1335 filename = blk_bs(file)->filename; 1336 } else { 1337 /* 1338 * Caution: while qdict_get_try_str() is fine, getting 1339 * non-string types would require more care. When @options 1340 * come from -blockdev or blockdev_add, its members are typed 1341 * according to the QAPI schema, but when they come from 1342 * -drive, they're all QString. 1343 */ 1344 filename = qdict_get_try_str(options, "filename"); 1345 } 1346 1347 if (drv->bdrv_needs_filename && (!filename || !filename[0])) { 1348 error_setg(errp, "The '%s' block driver requires a file name", 1349 drv->format_name); 1350 ret = -EINVAL; 1351 goto fail_opts; 1352 } 1353 1354 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags, 1355 drv->format_name); 1356 1357 bs->read_only = !(bs->open_flags & BDRV_O_RDWR); 1358 1359 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) { 1360 error_setg(errp, 1361 !bs->read_only && bdrv_is_whitelisted(drv, true) 1362 ? "Driver '%s' can only be used for read-only devices" 1363 : "Driver '%s' is not whitelisted", 1364 drv->format_name); 1365 ret = -ENOTSUP; 1366 goto fail_opts; 1367 } 1368 1369 /* bdrv_new() and bdrv_close() make it so */ 1370 assert(atomic_read(&bs->copy_on_read) == 0); 1371 1372 if (bs->open_flags & BDRV_O_COPY_ON_READ) { 1373 if (!bs->read_only) { 1374 bdrv_enable_copy_on_read(bs); 1375 } else { 1376 error_setg(errp, "Can't use copy-on-read on read-only device"); 1377 ret = -EINVAL; 1378 goto fail_opts; 1379 } 1380 } 1381 1382 discard = qemu_opt_get(opts, "discard"); 1383 if (discard != NULL) { 1384 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) { 1385 error_setg(errp, "Invalid discard option"); 1386 ret = -EINVAL; 1387 goto fail_opts; 1388 } 1389 } 1390 1391 detect_zeroes = qemu_opt_get(opts, "detect-zeroes"); 1392 if (detect_zeroes) { 1393 BlockdevDetectZeroesOptions value = 1394 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup, 1395 detect_zeroes, 1396 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF, 1397 &local_err); 1398 if (local_err) { 1399 error_propagate(errp, local_err); 1400 ret = -EINVAL; 1401 goto fail_opts; 1402 } 1403 1404 if (value == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP && 1405 !(bs->open_flags & BDRV_O_UNMAP)) 1406 { 1407 error_setg(errp, "setting detect-zeroes to unmap is not allowed " 1408 "without setting discard operation to unmap"); 1409 ret = -EINVAL; 1410 goto fail_opts; 1411 } 1412 1413 bs->detect_zeroes = value; 1414 } 1415 1416 if (filename != NULL) { 1417 pstrcpy(bs->filename, sizeof(bs->filename), filename); 1418 } else { 1419 bs->filename[0] = '\0'; 1420 } 1421 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename); 1422 1423 /* Open the image, either directly or using a protocol */ 1424 open_flags = bdrv_open_flags(bs, bs->open_flags); 1425 node_name = qemu_opt_get(opts, "node-name"); 1426 1427 assert(!drv->bdrv_file_open || file == NULL); 1428 ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp); 1429 if (ret < 0) { 1430 goto fail_opts; 1431 } 1432 1433 qemu_opts_del(opts); 1434 return 0; 1435 1436 fail_opts: 1437 qemu_opts_del(opts); 1438 return ret; 1439 } 1440 1441 static QDict *parse_json_filename(const char *filename, Error **errp) 1442 { 1443 QObject *options_obj; 1444 QDict *options; 1445 int ret; 1446 1447 ret = strstart(filename, "json:", &filename); 1448 assert(ret); 1449 1450 options_obj = qobject_from_json(filename, errp); 1451 if (!options_obj) { 1452 /* Work around qobject_from_json() lossage TODO fix that */ 1453 if (errp && !*errp) { 1454 error_setg(errp, "Could not parse the JSON options"); 1455 return NULL; 1456 } 1457 error_prepend(errp, "Could not parse the JSON options: "); 1458 return NULL; 1459 } 1460 1461 options = qobject_to(QDict, options_obj); 1462 if (!options) { 1463 qobject_decref(options_obj); 1464 error_setg(errp, "Invalid JSON object given"); 1465 return NULL; 1466 } 1467 1468 qdict_flatten(options); 1469 1470 return options; 1471 } 1472 1473 static void parse_json_protocol(QDict *options, const char **pfilename, 1474 Error **errp) 1475 { 1476 QDict *json_options; 1477 Error *local_err = NULL; 1478 1479 /* Parse json: pseudo-protocol */ 1480 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) { 1481 return; 1482 } 1483 1484 json_options = parse_json_filename(*pfilename, &local_err); 1485 if (local_err) { 1486 error_propagate(errp, local_err); 1487 return; 1488 } 1489 1490 /* Options given in the filename have lower priority than options 1491 * specified directly */ 1492 qdict_join(options, json_options, false); 1493 QDECREF(json_options); 1494 *pfilename = NULL; 1495 } 1496 1497 /* 1498 * Fills in default options for opening images and converts the legacy 1499 * filename/flags pair to option QDict entries. 1500 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a 1501 * block driver has been specified explicitly. 1502 */ 1503 static int bdrv_fill_options(QDict **options, const char *filename, 1504 int *flags, Error **errp) 1505 { 1506 const char *drvname; 1507 bool protocol = *flags & BDRV_O_PROTOCOL; 1508 bool parse_filename = false; 1509 BlockDriver *drv = NULL; 1510 Error *local_err = NULL; 1511 1512 /* 1513 * Caution: while qdict_get_try_str() is fine, getting non-string 1514 * types would require more care. When @options come from 1515 * -blockdev or blockdev_add, its members are typed according to 1516 * the QAPI schema, but when they come from -drive, they're all 1517 * QString. 1518 */ 1519 drvname = qdict_get_try_str(*options, "driver"); 1520 if (drvname) { 1521 drv = bdrv_find_format(drvname); 1522 if (!drv) { 1523 error_setg(errp, "Unknown driver '%s'", drvname); 1524 return -ENOENT; 1525 } 1526 /* If the user has explicitly specified the driver, this choice should 1527 * override the BDRV_O_PROTOCOL flag */ 1528 protocol = drv->bdrv_file_open; 1529 } 1530 1531 if (protocol) { 1532 *flags |= BDRV_O_PROTOCOL; 1533 } else { 1534 *flags &= ~BDRV_O_PROTOCOL; 1535 } 1536 1537 /* Translate cache options from flags into options */ 1538 update_options_from_flags(*options, *flags); 1539 1540 /* Fetch the file name from the options QDict if necessary */ 1541 if (protocol && filename) { 1542 if (!qdict_haskey(*options, "filename")) { 1543 qdict_put_str(*options, "filename", filename); 1544 parse_filename = true; 1545 } else { 1546 error_setg(errp, "Can't specify 'file' and 'filename' options at " 1547 "the same time"); 1548 return -EINVAL; 1549 } 1550 } 1551 1552 /* Find the right block driver */ 1553 /* See cautionary note on accessing @options above */ 1554 filename = qdict_get_try_str(*options, "filename"); 1555 1556 if (!drvname && protocol) { 1557 if (filename) { 1558 drv = bdrv_find_protocol(filename, parse_filename, errp); 1559 if (!drv) { 1560 return -EINVAL; 1561 } 1562 1563 drvname = drv->format_name; 1564 qdict_put_str(*options, "driver", drvname); 1565 } else { 1566 error_setg(errp, "Must specify either driver or file"); 1567 return -EINVAL; 1568 } 1569 } 1570 1571 assert(drv || !protocol); 1572 1573 /* Driver-specific filename parsing */ 1574 if (drv && drv->bdrv_parse_filename && parse_filename) { 1575 drv->bdrv_parse_filename(filename, *options, &local_err); 1576 if (local_err) { 1577 error_propagate(errp, local_err); 1578 return -EINVAL; 1579 } 1580 1581 if (!drv->bdrv_needs_filename) { 1582 qdict_del(*options, "filename"); 1583 } 1584 } 1585 1586 return 0; 1587 } 1588 1589 static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q, 1590 uint64_t perm, uint64_t shared, 1591 GSList *ignore_children, Error **errp); 1592 static void bdrv_child_abort_perm_update(BdrvChild *c); 1593 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared); 1594 1595 typedef struct BlockReopenQueueEntry { 1596 bool prepared; 1597 BDRVReopenState state; 1598 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry; 1599 } BlockReopenQueueEntry; 1600 1601 /* 1602 * Return the flags that @bs will have after the reopens in @q have 1603 * successfully completed. If @q is NULL (or @bs is not contained in @q), 1604 * return the current flags. 1605 */ 1606 static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs) 1607 { 1608 BlockReopenQueueEntry *entry; 1609 1610 if (q != NULL) { 1611 QSIMPLEQ_FOREACH(entry, q, entry) { 1612 if (entry->state.bs == bs) { 1613 return entry->state.flags; 1614 } 1615 } 1616 } 1617 1618 return bs->open_flags; 1619 } 1620 1621 /* Returns whether the image file can be written to after the reopen queue @q 1622 * has been successfully applied, or right now if @q is NULL. */ 1623 static bool bdrv_is_writable(BlockDriverState *bs, BlockReopenQueue *q) 1624 { 1625 int flags = bdrv_reopen_get_flags(q, bs); 1626 1627 return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR; 1628 } 1629 1630 static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs, 1631 BdrvChild *c, const BdrvChildRole *role, 1632 BlockReopenQueue *reopen_queue, 1633 uint64_t parent_perm, uint64_t parent_shared, 1634 uint64_t *nperm, uint64_t *nshared) 1635 { 1636 if (bs->drv && bs->drv->bdrv_child_perm) { 1637 bs->drv->bdrv_child_perm(bs, c, role, reopen_queue, 1638 parent_perm, parent_shared, 1639 nperm, nshared); 1640 } 1641 /* TODO Take force_share from reopen_queue */ 1642 if (child_bs && child_bs->force_share) { 1643 *nshared = BLK_PERM_ALL; 1644 } 1645 } 1646 1647 /* 1648 * Check whether permissions on this node can be changed in a way that 1649 * @cumulative_perms and @cumulative_shared_perms are the new cumulative 1650 * permissions of all its parents. This involves checking whether all necessary 1651 * permission changes to child nodes can be performed. 1652 * 1653 * A call to this function must always be followed by a call to bdrv_set_perm() 1654 * or bdrv_abort_perm_update(). 1655 */ 1656 static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q, 1657 uint64_t cumulative_perms, 1658 uint64_t cumulative_shared_perms, 1659 GSList *ignore_children, Error **errp) 1660 { 1661 BlockDriver *drv = bs->drv; 1662 BdrvChild *c; 1663 int ret; 1664 1665 /* Write permissions never work with read-only images */ 1666 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) && 1667 !bdrv_is_writable(bs, q)) 1668 { 1669 error_setg(errp, "Block node is read-only"); 1670 return -EPERM; 1671 } 1672 1673 /* Check this node */ 1674 if (!drv) { 1675 return 0; 1676 } 1677 1678 if (drv->bdrv_check_perm) { 1679 return drv->bdrv_check_perm(bs, cumulative_perms, 1680 cumulative_shared_perms, errp); 1681 } 1682 1683 /* Drivers that never have children can omit .bdrv_child_perm() */ 1684 if (!drv->bdrv_child_perm) { 1685 assert(QLIST_EMPTY(&bs->children)); 1686 return 0; 1687 } 1688 1689 /* Check all children */ 1690 QLIST_FOREACH(c, &bs->children, next) { 1691 uint64_t cur_perm, cur_shared; 1692 bdrv_child_perm(bs, c->bs, c, c->role, q, 1693 cumulative_perms, cumulative_shared_perms, 1694 &cur_perm, &cur_shared); 1695 ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared, 1696 ignore_children, errp); 1697 if (ret < 0) { 1698 return ret; 1699 } 1700 } 1701 1702 return 0; 1703 } 1704 1705 /* 1706 * Notifies drivers that after a previous bdrv_check_perm() call, the 1707 * permission update is not performed and any preparations made for it (e.g. 1708 * taken file locks) need to be undone. 1709 * 1710 * This function recursively notifies all child nodes. 1711 */ 1712 static void bdrv_abort_perm_update(BlockDriverState *bs) 1713 { 1714 BlockDriver *drv = bs->drv; 1715 BdrvChild *c; 1716 1717 if (!drv) { 1718 return; 1719 } 1720 1721 if (drv->bdrv_abort_perm_update) { 1722 drv->bdrv_abort_perm_update(bs); 1723 } 1724 1725 QLIST_FOREACH(c, &bs->children, next) { 1726 bdrv_child_abort_perm_update(c); 1727 } 1728 } 1729 1730 static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms, 1731 uint64_t cumulative_shared_perms) 1732 { 1733 BlockDriver *drv = bs->drv; 1734 BdrvChild *c; 1735 1736 if (!drv) { 1737 return; 1738 } 1739 1740 /* Update this node */ 1741 if (drv->bdrv_set_perm) { 1742 drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms); 1743 } 1744 1745 /* Drivers that never have children can omit .bdrv_child_perm() */ 1746 if (!drv->bdrv_child_perm) { 1747 assert(QLIST_EMPTY(&bs->children)); 1748 return; 1749 } 1750 1751 /* Update all children */ 1752 QLIST_FOREACH(c, &bs->children, next) { 1753 uint64_t cur_perm, cur_shared; 1754 bdrv_child_perm(bs, c->bs, c, c->role, NULL, 1755 cumulative_perms, cumulative_shared_perms, 1756 &cur_perm, &cur_shared); 1757 bdrv_child_set_perm(c, cur_perm, cur_shared); 1758 } 1759 } 1760 1761 static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm, 1762 uint64_t *shared_perm) 1763 { 1764 BdrvChild *c; 1765 uint64_t cumulative_perms = 0; 1766 uint64_t cumulative_shared_perms = BLK_PERM_ALL; 1767 1768 QLIST_FOREACH(c, &bs->parents, next_parent) { 1769 cumulative_perms |= c->perm; 1770 cumulative_shared_perms &= c->shared_perm; 1771 } 1772 1773 *perm = cumulative_perms; 1774 *shared_perm = cumulative_shared_perms; 1775 } 1776 1777 static char *bdrv_child_user_desc(BdrvChild *c) 1778 { 1779 if (c->role->get_parent_desc) { 1780 return c->role->get_parent_desc(c); 1781 } 1782 1783 return g_strdup("another user"); 1784 } 1785 1786 char *bdrv_perm_names(uint64_t perm) 1787 { 1788 struct perm_name { 1789 uint64_t perm; 1790 const char *name; 1791 } permissions[] = { 1792 { BLK_PERM_CONSISTENT_READ, "consistent read" }, 1793 { BLK_PERM_WRITE, "write" }, 1794 { BLK_PERM_WRITE_UNCHANGED, "write unchanged" }, 1795 { BLK_PERM_RESIZE, "resize" }, 1796 { BLK_PERM_GRAPH_MOD, "change children" }, 1797 { 0, NULL } 1798 }; 1799 1800 char *result = g_strdup(""); 1801 struct perm_name *p; 1802 1803 for (p = permissions; p->name; p++) { 1804 if (perm & p->perm) { 1805 char *old = result; 1806 result = g_strdup_printf("%s%s%s", old, *old ? ", " : "", p->name); 1807 g_free(old); 1808 } 1809 } 1810 1811 return result; 1812 } 1813 1814 /* 1815 * Checks whether a new reference to @bs can be added if the new user requires 1816 * @new_used_perm/@new_shared_perm as its permissions. If @ignore_children is 1817 * set, the BdrvChild objects in this list are ignored in the calculations; 1818 * this allows checking permission updates for an existing reference. 1819 * 1820 * Needs to be followed by a call to either bdrv_set_perm() or 1821 * bdrv_abort_perm_update(). */ 1822 static int bdrv_check_update_perm(BlockDriverState *bs, BlockReopenQueue *q, 1823 uint64_t new_used_perm, 1824 uint64_t new_shared_perm, 1825 GSList *ignore_children, Error **errp) 1826 { 1827 BdrvChild *c; 1828 uint64_t cumulative_perms = new_used_perm; 1829 uint64_t cumulative_shared_perms = new_shared_perm; 1830 1831 /* There is no reason why anyone couldn't tolerate write_unchanged */ 1832 assert(new_shared_perm & BLK_PERM_WRITE_UNCHANGED); 1833 1834 QLIST_FOREACH(c, &bs->parents, next_parent) { 1835 if (g_slist_find(ignore_children, c)) { 1836 continue; 1837 } 1838 1839 if ((new_used_perm & c->shared_perm) != new_used_perm) { 1840 char *user = bdrv_child_user_desc(c); 1841 char *perm_names = bdrv_perm_names(new_used_perm & ~c->shared_perm); 1842 error_setg(errp, "Conflicts with use by %s as '%s', which does not " 1843 "allow '%s' on %s", 1844 user, c->name, perm_names, bdrv_get_node_name(c->bs)); 1845 g_free(user); 1846 g_free(perm_names); 1847 return -EPERM; 1848 } 1849 1850 if ((c->perm & new_shared_perm) != c->perm) { 1851 char *user = bdrv_child_user_desc(c); 1852 char *perm_names = bdrv_perm_names(c->perm & ~new_shared_perm); 1853 error_setg(errp, "Conflicts with use by %s as '%s', which uses " 1854 "'%s' on %s", 1855 user, c->name, perm_names, bdrv_get_node_name(c->bs)); 1856 g_free(user); 1857 g_free(perm_names); 1858 return -EPERM; 1859 } 1860 1861 cumulative_perms |= c->perm; 1862 cumulative_shared_perms &= c->shared_perm; 1863 } 1864 1865 return bdrv_check_perm(bs, q, cumulative_perms, cumulative_shared_perms, 1866 ignore_children, errp); 1867 } 1868 1869 /* Needs to be followed by a call to either bdrv_child_set_perm() or 1870 * bdrv_child_abort_perm_update(). */ 1871 static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q, 1872 uint64_t perm, uint64_t shared, 1873 GSList *ignore_children, Error **errp) 1874 { 1875 int ret; 1876 1877 ignore_children = g_slist_prepend(g_slist_copy(ignore_children), c); 1878 ret = bdrv_check_update_perm(c->bs, q, perm, shared, ignore_children, errp); 1879 g_slist_free(ignore_children); 1880 1881 return ret; 1882 } 1883 1884 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared) 1885 { 1886 uint64_t cumulative_perms, cumulative_shared_perms; 1887 1888 c->perm = perm; 1889 c->shared_perm = shared; 1890 1891 bdrv_get_cumulative_perm(c->bs, &cumulative_perms, 1892 &cumulative_shared_perms); 1893 bdrv_set_perm(c->bs, cumulative_perms, cumulative_shared_perms); 1894 } 1895 1896 static void bdrv_child_abort_perm_update(BdrvChild *c) 1897 { 1898 bdrv_abort_perm_update(c->bs); 1899 } 1900 1901 int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared, 1902 Error **errp) 1903 { 1904 int ret; 1905 1906 ret = bdrv_child_check_perm(c, NULL, perm, shared, NULL, errp); 1907 if (ret < 0) { 1908 bdrv_child_abort_perm_update(c); 1909 return ret; 1910 } 1911 1912 bdrv_child_set_perm(c, perm, shared); 1913 1914 return 0; 1915 } 1916 1917 #define DEFAULT_PERM_PASSTHROUGH (BLK_PERM_CONSISTENT_READ \ 1918 | BLK_PERM_WRITE \ 1919 | BLK_PERM_WRITE_UNCHANGED \ 1920 | BLK_PERM_RESIZE) 1921 #define DEFAULT_PERM_UNCHANGED (BLK_PERM_ALL & ~DEFAULT_PERM_PASSTHROUGH) 1922 1923 void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c, 1924 const BdrvChildRole *role, 1925 BlockReopenQueue *reopen_queue, 1926 uint64_t perm, uint64_t shared, 1927 uint64_t *nperm, uint64_t *nshared) 1928 { 1929 if (c == NULL) { 1930 *nperm = perm & DEFAULT_PERM_PASSTHROUGH; 1931 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED; 1932 return; 1933 } 1934 1935 *nperm = (perm & DEFAULT_PERM_PASSTHROUGH) | 1936 (c->perm & DEFAULT_PERM_UNCHANGED); 1937 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | 1938 (c->shared_perm & DEFAULT_PERM_UNCHANGED); 1939 } 1940 1941 void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c, 1942 const BdrvChildRole *role, 1943 BlockReopenQueue *reopen_queue, 1944 uint64_t perm, uint64_t shared, 1945 uint64_t *nperm, uint64_t *nshared) 1946 { 1947 bool backing = (role == &child_backing); 1948 assert(role == &child_backing || role == &child_file); 1949 1950 if (!backing) { 1951 int flags = bdrv_reopen_get_flags(reopen_queue, bs); 1952 1953 /* Apart from the modifications below, the same permissions are 1954 * forwarded and left alone as for filters */ 1955 bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared, 1956 &perm, &shared); 1957 1958 /* Format drivers may touch metadata even if the guest doesn't write */ 1959 if (bdrv_is_writable(bs, reopen_queue)) { 1960 perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE; 1961 } 1962 1963 /* bs->file always needs to be consistent because of the metadata. We 1964 * can never allow other users to resize or write to it. */ 1965 if (!(flags & BDRV_O_NO_IO)) { 1966 perm |= BLK_PERM_CONSISTENT_READ; 1967 } 1968 shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE); 1969 } else { 1970 /* We want consistent read from backing files if the parent needs it. 1971 * No other operations are performed on backing files. */ 1972 perm &= BLK_PERM_CONSISTENT_READ; 1973 1974 /* If the parent can deal with changing data, we're okay with a 1975 * writable and resizable backing file. */ 1976 /* TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? */ 1977 if (shared & BLK_PERM_WRITE) { 1978 shared = BLK_PERM_WRITE | BLK_PERM_RESIZE; 1979 } else { 1980 shared = 0; 1981 } 1982 1983 shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD | 1984 BLK_PERM_WRITE_UNCHANGED; 1985 } 1986 1987 if (bs->open_flags & BDRV_O_INACTIVE) { 1988 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE; 1989 } 1990 1991 *nperm = perm; 1992 *nshared = shared; 1993 } 1994 1995 static void bdrv_replace_child_noperm(BdrvChild *child, 1996 BlockDriverState *new_bs) 1997 { 1998 BlockDriverState *old_bs = child->bs; 1999 int i; 2000 2001 if (old_bs && new_bs) { 2002 assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs)); 2003 } 2004 if (old_bs) { 2005 /* Detach first so that the recursive drain sections coming from @child 2006 * are already gone and we only end the drain sections that came from 2007 * elsewhere. */ 2008 if (child->role->detach) { 2009 child->role->detach(child); 2010 } 2011 if (old_bs->quiesce_counter && child->role->drained_end) { 2012 for (i = 0; i < old_bs->quiesce_counter; i++) { 2013 child->role->drained_end(child); 2014 } 2015 } 2016 QLIST_REMOVE(child, next_parent); 2017 } 2018 2019 child->bs = new_bs; 2020 2021 if (new_bs) { 2022 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent); 2023 if (new_bs->quiesce_counter && child->role->drained_begin) { 2024 for (i = 0; i < new_bs->quiesce_counter; i++) { 2025 child->role->drained_begin(child); 2026 } 2027 } 2028 2029 /* Attach only after starting new drained sections, so that recursive 2030 * drain sections coming from @child don't get an extra .drained_begin 2031 * callback. */ 2032 if (child->role->attach) { 2033 child->role->attach(child); 2034 } 2035 } 2036 } 2037 2038 /* 2039 * Updates @child to change its reference to point to @new_bs, including 2040 * checking and applying the necessary permisson updates both to the old node 2041 * and to @new_bs. 2042 * 2043 * NULL is passed as @new_bs for removing the reference before freeing @child. 2044 * 2045 * If @new_bs is not NULL, bdrv_check_perm() must be called beforehand, as this 2046 * function uses bdrv_set_perm() to update the permissions according to the new 2047 * reference that @new_bs gets. 2048 */ 2049 static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs) 2050 { 2051 BlockDriverState *old_bs = child->bs; 2052 uint64_t perm, shared_perm; 2053 2054 bdrv_replace_child_noperm(child, new_bs); 2055 2056 if (old_bs) { 2057 /* Update permissions for old node. This is guaranteed to succeed 2058 * because we're just taking a parent away, so we're loosening 2059 * restrictions. */ 2060 bdrv_get_cumulative_perm(old_bs, &perm, &shared_perm); 2061 bdrv_check_perm(old_bs, NULL, perm, shared_perm, NULL, &error_abort); 2062 bdrv_set_perm(old_bs, perm, shared_perm); 2063 } 2064 2065 if (new_bs) { 2066 bdrv_get_cumulative_perm(new_bs, &perm, &shared_perm); 2067 bdrv_set_perm(new_bs, perm, shared_perm); 2068 } 2069 } 2070 2071 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs, 2072 const char *child_name, 2073 const BdrvChildRole *child_role, 2074 uint64_t perm, uint64_t shared_perm, 2075 void *opaque, Error **errp) 2076 { 2077 BdrvChild *child; 2078 int ret; 2079 2080 ret = bdrv_check_update_perm(child_bs, NULL, perm, shared_perm, NULL, errp); 2081 if (ret < 0) { 2082 bdrv_abort_perm_update(child_bs); 2083 return NULL; 2084 } 2085 2086 child = g_new(BdrvChild, 1); 2087 *child = (BdrvChild) { 2088 .bs = NULL, 2089 .name = g_strdup(child_name), 2090 .role = child_role, 2091 .perm = perm, 2092 .shared_perm = shared_perm, 2093 .opaque = opaque, 2094 }; 2095 2096 /* This performs the matching bdrv_set_perm() for the above check. */ 2097 bdrv_replace_child(child, child_bs); 2098 2099 return child; 2100 } 2101 2102 BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs, 2103 BlockDriverState *child_bs, 2104 const char *child_name, 2105 const BdrvChildRole *child_role, 2106 Error **errp) 2107 { 2108 BdrvChild *child; 2109 uint64_t perm, shared_perm; 2110 2111 bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm); 2112 2113 assert(parent_bs->drv); 2114 assert(bdrv_get_aio_context(parent_bs) == bdrv_get_aio_context(child_bs)); 2115 bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL, 2116 perm, shared_perm, &perm, &shared_perm); 2117 2118 child = bdrv_root_attach_child(child_bs, child_name, child_role, 2119 perm, shared_perm, parent_bs, errp); 2120 if (child == NULL) { 2121 return NULL; 2122 } 2123 2124 QLIST_INSERT_HEAD(&parent_bs->children, child, next); 2125 return child; 2126 } 2127 2128 static void bdrv_detach_child(BdrvChild *child) 2129 { 2130 if (child->next.le_prev) { 2131 QLIST_REMOVE(child, next); 2132 child->next.le_prev = NULL; 2133 } 2134 2135 bdrv_replace_child(child, NULL); 2136 2137 g_free(child->name); 2138 g_free(child); 2139 } 2140 2141 void bdrv_root_unref_child(BdrvChild *child) 2142 { 2143 BlockDriverState *child_bs; 2144 2145 child_bs = child->bs; 2146 bdrv_detach_child(child); 2147 bdrv_unref(child_bs); 2148 } 2149 2150 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child) 2151 { 2152 if (child == NULL) { 2153 return; 2154 } 2155 2156 if (child->bs->inherits_from == parent) { 2157 BdrvChild *c; 2158 2159 /* Remove inherits_from only when the last reference between parent and 2160 * child->bs goes away. */ 2161 QLIST_FOREACH(c, &parent->children, next) { 2162 if (c != child && c->bs == child->bs) { 2163 break; 2164 } 2165 } 2166 if (c == NULL) { 2167 child->bs->inherits_from = NULL; 2168 } 2169 } 2170 2171 bdrv_root_unref_child(child); 2172 } 2173 2174 2175 static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load) 2176 { 2177 BdrvChild *c; 2178 QLIST_FOREACH(c, &bs->parents, next_parent) { 2179 if (c->role->change_media) { 2180 c->role->change_media(c, load); 2181 } 2182 } 2183 } 2184 2185 static void bdrv_parent_cb_resize(BlockDriverState *bs) 2186 { 2187 BdrvChild *c; 2188 QLIST_FOREACH(c, &bs->parents, next_parent) { 2189 if (c->role->resize) { 2190 c->role->resize(c); 2191 } 2192 } 2193 } 2194 2195 /* 2196 * Sets the backing file link of a BDS. A new reference is created; callers 2197 * which don't need their own reference any more must call bdrv_unref(). 2198 */ 2199 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd, 2200 Error **errp) 2201 { 2202 if (backing_hd) { 2203 bdrv_ref(backing_hd); 2204 } 2205 2206 if (bs->backing) { 2207 bdrv_unref_child(bs, bs->backing); 2208 } 2209 2210 if (!backing_hd) { 2211 bs->backing = NULL; 2212 goto out; 2213 } 2214 2215 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_backing, 2216 errp); 2217 if (!bs->backing) { 2218 bdrv_unref(backing_hd); 2219 } 2220 2221 bdrv_refresh_filename(bs); 2222 2223 out: 2224 bdrv_refresh_limits(bs, NULL); 2225 } 2226 2227 /* 2228 * Opens the backing file for a BlockDriverState if not yet open 2229 * 2230 * bdref_key specifies the key for the image's BlockdevRef in the options QDict. 2231 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict 2232 * itself, all options starting with "${bdref_key}." are considered part of the 2233 * BlockdevRef. 2234 * 2235 * TODO Can this be unified with bdrv_open_image()? 2236 */ 2237 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options, 2238 const char *bdref_key, Error **errp) 2239 { 2240 char *backing_filename = g_malloc0(PATH_MAX); 2241 char *bdref_key_dot; 2242 const char *reference = NULL; 2243 int ret = 0; 2244 BlockDriverState *backing_hd; 2245 QDict *options; 2246 QDict *tmp_parent_options = NULL; 2247 Error *local_err = NULL; 2248 2249 if (bs->backing != NULL) { 2250 goto free_exit; 2251 } 2252 2253 /* NULL means an empty set of options */ 2254 if (parent_options == NULL) { 2255 tmp_parent_options = qdict_new(); 2256 parent_options = tmp_parent_options; 2257 } 2258 2259 bs->open_flags &= ~BDRV_O_NO_BACKING; 2260 2261 bdref_key_dot = g_strdup_printf("%s.", bdref_key); 2262 qdict_extract_subqdict(parent_options, &options, bdref_key_dot); 2263 g_free(bdref_key_dot); 2264 2265 /* 2266 * Caution: while qdict_get_try_str() is fine, getting non-string 2267 * types would require more care. When @parent_options come from 2268 * -blockdev or blockdev_add, its members are typed according to 2269 * the QAPI schema, but when they come from -drive, they're all 2270 * QString. 2271 */ 2272 reference = qdict_get_try_str(parent_options, bdref_key); 2273 if (reference || qdict_haskey(options, "file.filename")) { 2274 backing_filename[0] = '\0'; 2275 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) { 2276 QDECREF(options); 2277 goto free_exit; 2278 } else { 2279 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX, 2280 &local_err); 2281 if (local_err) { 2282 ret = -EINVAL; 2283 error_propagate(errp, local_err); 2284 QDECREF(options); 2285 goto free_exit; 2286 } 2287 } 2288 2289 if (!bs->drv || !bs->drv->supports_backing) { 2290 ret = -EINVAL; 2291 error_setg(errp, "Driver doesn't support backing files"); 2292 QDECREF(options); 2293 goto free_exit; 2294 } 2295 2296 if (!reference && 2297 bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) { 2298 qdict_put_str(options, "driver", bs->backing_format); 2299 } 2300 2301 backing_hd = bdrv_open_inherit(*backing_filename ? backing_filename : NULL, 2302 reference, options, 0, bs, &child_backing, 2303 errp); 2304 if (!backing_hd) { 2305 bs->open_flags |= BDRV_O_NO_BACKING; 2306 error_prepend(errp, "Could not open backing file: "); 2307 ret = -EINVAL; 2308 goto free_exit; 2309 } 2310 bdrv_set_aio_context(backing_hd, bdrv_get_aio_context(bs)); 2311 2312 /* Hook up the backing file link; drop our reference, bs owns the 2313 * backing_hd reference now */ 2314 bdrv_set_backing_hd(bs, backing_hd, &local_err); 2315 bdrv_unref(backing_hd); 2316 if (local_err) { 2317 error_propagate(errp, local_err); 2318 ret = -EINVAL; 2319 goto free_exit; 2320 } 2321 2322 qdict_del(parent_options, bdref_key); 2323 2324 free_exit: 2325 g_free(backing_filename); 2326 QDECREF(tmp_parent_options); 2327 return ret; 2328 } 2329 2330 static BlockDriverState * 2331 bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key, 2332 BlockDriverState *parent, const BdrvChildRole *child_role, 2333 bool allow_none, Error **errp) 2334 { 2335 BlockDriverState *bs = NULL; 2336 QDict *image_options; 2337 char *bdref_key_dot; 2338 const char *reference; 2339 2340 assert(child_role != NULL); 2341 2342 bdref_key_dot = g_strdup_printf("%s.", bdref_key); 2343 qdict_extract_subqdict(options, &image_options, bdref_key_dot); 2344 g_free(bdref_key_dot); 2345 2346 /* 2347 * Caution: while qdict_get_try_str() is fine, getting non-string 2348 * types would require more care. When @options come from 2349 * -blockdev or blockdev_add, its members are typed according to 2350 * the QAPI schema, but when they come from -drive, they're all 2351 * QString. 2352 */ 2353 reference = qdict_get_try_str(options, bdref_key); 2354 if (!filename && !reference && !qdict_size(image_options)) { 2355 if (!allow_none) { 2356 error_setg(errp, "A block device must be specified for \"%s\"", 2357 bdref_key); 2358 } 2359 QDECREF(image_options); 2360 goto done; 2361 } 2362 2363 bs = bdrv_open_inherit(filename, reference, image_options, 0, 2364 parent, child_role, errp); 2365 if (!bs) { 2366 goto done; 2367 } 2368 2369 done: 2370 qdict_del(options, bdref_key); 2371 return bs; 2372 } 2373 2374 /* 2375 * Opens a disk image whose options are given as BlockdevRef in another block 2376 * device's options. 2377 * 2378 * If allow_none is true, no image will be opened if filename is false and no 2379 * BlockdevRef is given. NULL will be returned, but errp remains unset. 2380 * 2381 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict. 2382 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict 2383 * itself, all options starting with "${bdref_key}." are considered part of the 2384 * BlockdevRef. 2385 * 2386 * The BlockdevRef will be removed from the options QDict. 2387 */ 2388 BdrvChild *bdrv_open_child(const char *filename, 2389 QDict *options, const char *bdref_key, 2390 BlockDriverState *parent, 2391 const BdrvChildRole *child_role, 2392 bool allow_none, Error **errp) 2393 { 2394 BdrvChild *c; 2395 BlockDriverState *bs; 2396 2397 bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role, 2398 allow_none, errp); 2399 if (bs == NULL) { 2400 return NULL; 2401 } 2402 2403 c = bdrv_attach_child(parent, bs, bdref_key, child_role, errp); 2404 if (!c) { 2405 bdrv_unref(bs); 2406 return NULL; 2407 } 2408 2409 return c; 2410 } 2411 2412 /* TODO Future callers may need to specify parent/child_role in order for 2413 * option inheritance to work. Existing callers use it for the root node. */ 2414 BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp) 2415 { 2416 BlockDriverState *bs = NULL; 2417 Error *local_err = NULL; 2418 QObject *obj = NULL; 2419 QDict *qdict = NULL; 2420 const char *reference = NULL; 2421 Visitor *v = NULL; 2422 2423 if (ref->type == QTYPE_QSTRING) { 2424 reference = ref->u.reference; 2425 } else { 2426 BlockdevOptions *options = &ref->u.definition; 2427 assert(ref->type == QTYPE_QDICT); 2428 2429 v = qobject_output_visitor_new(&obj); 2430 visit_type_BlockdevOptions(v, NULL, &options, &local_err); 2431 if (local_err) { 2432 error_propagate(errp, local_err); 2433 goto fail; 2434 } 2435 visit_complete(v, &obj); 2436 2437 qdict = qobject_to(QDict, obj); 2438 qdict_flatten(qdict); 2439 2440 /* bdrv_open_inherit() defaults to the values in bdrv_flags (for 2441 * compatibility with other callers) rather than what we want as the 2442 * real defaults. Apply the defaults here instead. */ 2443 qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off"); 2444 qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off"); 2445 qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off"); 2446 } 2447 2448 bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, errp); 2449 obj = NULL; 2450 2451 fail: 2452 qobject_decref(obj); 2453 visit_free(v); 2454 return bs; 2455 } 2456 2457 static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs, 2458 int flags, 2459 QDict *snapshot_options, 2460 Error **errp) 2461 { 2462 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */ 2463 char *tmp_filename = g_malloc0(PATH_MAX + 1); 2464 int64_t total_size; 2465 QemuOpts *opts = NULL; 2466 BlockDriverState *bs_snapshot = NULL; 2467 Error *local_err = NULL; 2468 int ret; 2469 2470 /* if snapshot, we create a temporary backing file and open it 2471 instead of opening 'filename' directly */ 2472 2473 /* Get the required size from the image */ 2474 total_size = bdrv_getlength(bs); 2475 if (total_size < 0) { 2476 error_setg_errno(errp, -total_size, "Could not get image size"); 2477 goto out; 2478 } 2479 2480 /* Create the temporary image */ 2481 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1); 2482 if (ret < 0) { 2483 error_setg_errno(errp, -ret, "Could not get temporary filename"); 2484 goto out; 2485 } 2486 2487 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0, 2488 &error_abort); 2489 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort); 2490 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp); 2491 qemu_opts_del(opts); 2492 if (ret < 0) { 2493 error_prepend(errp, "Could not create temporary overlay '%s': ", 2494 tmp_filename); 2495 goto out; 2496 } 2497 2498 /* Prepare options QDict for the temporary file */ 2499 qdict_put_str(snapshot_options, "file.driver", "file"); 2500 qdict_put_str(snapshot_options, "file.filename", tmp_filename); 2501 qdict_put_str(snapshot_options, "driver", "qcow2"); 2502 2503 bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp); 2504 snapshot_options = NULL; 2505 if (!bs_snapshot) { 2506 goto out; 2507 } 2508 2509 /* bdrv_append() consumes a strong reference to bs_snapshot 2510 * (i.e. it will call bdrv_unref() on it) even on error, so in 2511 * order to be able to return one, we have to increase 2512 * bs_snapshot's refcount here */ 2513 bdrv_ref(bs_snapshot); 2514 bdrv_append(bs_snapshot, bs, &local_err); 2515 if (local_err) { 2516 error_propagate(errp, local_err); 2517 bs_snapshot = NULL; 2518 goto out; 2519 } 2520 2521 out: 2522 QDECREF(snapshot_options); 2523 g_free(tmp_filename); 2524 return bs_snapshot; 2525 } 2526 2527 /* 2528 * Opens a disk image (raw, qcow2, vmdk, ...) 2529 * 2530 * options is a QDict of options to pass to the block drivers, or NULL for an 2531 * empty set of options. The reference to the QDict belongs to the block layer 2532 * after the call (even on failure), so if the caller intends to reuse the 2533 * dictionary, it needs to use QINCREF() before calling bdrv_open. 2534 * 2535 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there. 2536 * If it is not NULL, the referenced BDS will be reused. 2537 * 2538 * The reference parameter may be used to specify an existing block device which 2539 * should be opened. If specified, neither options nor a filename may be given, 2540 * nor can an existing BDS be reused (that is, *pbs has to be NULL). 2541 */ 2542 static BlockDriverState *bdrv_open_inherit(const char *filename, 2543 const char *reference, 2544 QDict *options, int flags, 2545 BlockDriverState *parent, 2546 const BdrvChildRole *child_role, 2547 Error **errp) 2548 { 2549 int ret; 2550 BlockBackend *file = NULL; 2551 BlockDriverState *bs; 2552 BlockDriver *drv = NULL; 2553 const char *drvname; 2554 const char *backing; 2555 Error *local_err = NULL; 2556 QDict *snapshot_options = NULL; 2557 int snapshot_flags = 0; 2558 2559 assert(!child_role || !flags); 2560 assert(!child_role == !parent); 2561 2562 if (reference) { 2563 bool options_non_empty = options ? qdict_size(options) : false; 2564 QDECREF(options); 2565 2566 if (filename || options_non_empty) { 2567 error_setg(errp, "Cannot reference an existing block device with " 2568 "additional options or a new filename"); 2569 return NULL; 2570 } 2571 2572 bs = bdrv_lookup_bs(reference, reference, errp); 2573 if (!bs) { 2574 return NULL; 2575 } 2576 2577 bdrv_ref(bs); 2578 return bs; 2579 } 2580 2581 bs = bdrv_new(); 2582 2583 /* NULL means an empty set of options */ 2584 if (options == NULL) { 2585 options = qdict_new(); 2586 } 2587 2588 /* json: syntax counts as explicit options, as if in the QDict */ 2589 parse_json_protocol(options, &filename, &local_err); 2590 if (local_err) { 2591 goto fail; 2592 } 2593 2594 bs->explicit_options = qdict_clone_shallow(options); 2595 2596 if (child_role) { 2597 bs->inherits_from = parent; 2598 child_role->inherit_options(&flags, options, 2599 parent->open_flags, parent->options); 2600 } 2601 2602 ret = bdrv_fill_options(&options, filename, &flags, &local_err); 2603 if (local_err) { 2604 goto fail; 2605 } 2606 2607 /* 2608 * Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags. 2609 * Caution: getting a boolean member of @options requires care. 2610 * When @options come from -blockdev or blockdev_add, members are 2611 * typed according to the QAPI schema, but when they come from 2612 * -drive, they're all QString. 2613 */ 2614 if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") && 2615 !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) { 2616 flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR); 2617 } else { 2618 flags &= ~BDRV_O_RDWR; 2619 } 2620 2621 if (flags & BDRV_O_SNAPSHOT) { 2622 snapshot_options = qdict_new(); 2623 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options, 2624 flags, options); 2625 /* Let bdrv_backing_options() override "read-only" */ 2626 qdict_del(options, BDRV_OPT_READ_ONLY); 2627 bdrv_backing_options(&flags, options, flags, options); 2628 } 2629 2630 bs->open_flags = flags; 2631 bs->options = options; 2632 options = qdict_clone_shallow(options); 2633 2634 /* Find the right image format driver */ 2635 /* See cautionary note on accessing @options above */ 2636 drvname = qdict_get_try_str(options, "driver"); 2637 if (drvname) { 2638 drv = bdrv_find_format(drvname); 2639 if (!drv) { 2640 error_setg(errp, "Unknown driver: '%s'", drvname); 2641 goto fail; 2642 } 2643 } 2644 2645 assert(drvname || !(flags & BDRV_O_PROTOCOL)); 2646 2647 /* See cautionary note on accessing @options above */ 2648 backing = qdict_get_try_str(options, "backing"); 2649 if (qobject_to(QNull, qdict_get(options, "backing")) != NULL || 2650 (backing && *backing == '\0')) 2651 { 2652 if (backing) { 2653 warn_report("Use of \"backing\": \"\" is deprecated; " 2654 "use \"backing\": null instead"); 2655 } 2656 flags |= BDRV_O_NO_BACKING; 2657 qdict_del(options, "backing"); 2658 } 2659 2660 /* Open image file without format layer. This BlockBackend is only used for 2661 * probing, the block drivers will do their own bdrv_open_child() for the 2662 * same BDS, which is why we put the node name back into options. */ 2663 if ((flags & BDRV_O_PROTOCOL) == 0) { 2664 BlockDriverState *file_bs; 2665 2666 file_bs = bdrv_open_child_bs(filename, options, "file", bs, 2667 &child_file, true, &local_err); 2668 if (local_err) { 2669 goto fail; 2670 } 2671 if (file_bs != NULL) { 2672 /* Not requesting BLK_PERM_CONSISTENT_READ because we're only 2673 * looking at the header to guess the image format. This works even 2674 * in cases where a guest would not see a consistent state. */ 2675 file = blk_new(0, BLK_PERM_ALL); 2676 blk_insert_bs(file, file_bs, &local_err); 2677 bdrv_unref(file_bs); 2678 if (local_err) { 2679 goto fail; 2680 } 2681 2682 qdict_put_str(options, "file", bdrv_get_node_name(file_bs)); 2683 } 2684 } 2685 2686 /* Image format probing */ 2687 bs->probed = !drv; 2688 if (!drv && file) { 2689 ret = find_image_format(file, filename, &drv, &local_err); 2690 if (ret < 0) { 2691 goto fail; 2692 } 2693 /* 2694 * This option update would logically belong in bdrv_fill_options(), 2695 * but we first need to open bs->file for the probing to work, while 2696 * opening bs->file already requires the (mostly) final set of options 2697 * so that cache mode etc. can be inherited. 2698 * 2699 * Adding the driver later is somewhat ugly, but it's not an option 2700 * that would ever be inherited, so it's correct. We just need to make 2701 * sure to update both bs->options (which has the full effective 2702 * options for bs) and options (which has file.* already removed). 2703 */ 2704 qdict_put_str(bs->options, "driver", drv->format_name); 2705 qdict_put_str(options, "driver", drv->format_name); 2706 } else if (!drv) { 2707 error_setg(errp, "Must specify either driver or file"); 2708 goto fail; 2709 } 2710 2711 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */ 2712 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open); 2713 /* file must be NULL if a protocol BDS is about to be created 2714 * (the inverse results in an error message from bdrv_open_common()) */ 2715 assert(!(flags & BDRV_O_PROTOCOL) || !file); 2716 2717 /* Open the image */ 2718 ret = bdrv_open_common(bs, file, options, &local_err); 2719 if (ret < 0) { 2720 goto fail; 2721 } 2722 2723 if (file) { 2724 blk_unref(file); 2725 file = NULL; 2726 } 2727 2728 /* If there is a backing file, use it */ 2729 if ((flags & BDRV_O_NO_BACKING) == 0) { 2730 ret = bdrv_open_backing_file(bs, options, "backing", &local_err); 2731 if (ret < 0) { 2732 goto close_and_fail; 2733 } 2734 } 2735 2736 bdrv_refresh_filename(bs); 2737 2738 /* Check if any unknown options were used */ 2739 if (qdict_size(options) != 0) { 2740 const QDictEntry *entry = qdict_first(options); 2741 if (flags & BDRV_O_PROTOCOL) { 2742 error_setg(errp, "Block protocol '%s' doesn't support the option " 2743 "'%s'", drv->format_name, entry->key); 2744 } else { 2745 error_setg(errp, 2746 "Block format '%s' does not support the option '%s'", 2747 drv->format_name, entry->key); 2748 } 2749 2750 goto close_and_fail; 2751 } 2752 2753 bdrv_parent_cb_change_media(bs, true); 2754 2755 QDECREF(options); 2756 2757 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the 2758 * temporary snapshot afterwards. */ 2759 if (snapshot_flags) { 2760 BlockDriverState *snapshot_bs; 2761 snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags, 2762 snapshot_options, &local_err); 2763 snapshot_options = NULL; 2764 if (local_err) { 2765 goto close_and_fail; 2766 } 2767 /* We are not going to return bs but the overlay on top of it 2768 * (snapshot_bs); thus, we have to drop the strong reference to bs 2769 * (which we obtained by calling bdrv_new()). bs will not be deleted, 2770 * though, because the overlay still has a reference to it. */ 2771 bdrv_unref(bs); 2772 bs = snapshot_bs; 2773 } 2774 2775 return bs; 2776 2777 fail: 2778 blk_unref(file); 2779 QDECREF(snapshot_options); 2780 QDECREF(bs->explicit_options); 2781 QDECREF(bs->options); 2782 QDECREF(options); 2783 bs->options = NULL; 2784 bs->explicit_options = NULL; 2785 bdrv_unref(bs); 2786 error_propagate(errp, local_err); 2787 return NULL; 2788 2789 close_and_fail: 2790 bdrv_unref(bs); 2791 QDECREF(snapshot_options); 2792 QDECREF(options); 2793 error_propagate(errp, local_err); 2794 return NULL; 2795 } 2796 2797 BlockDriverState *bdrv_open(const char *filename, const char *reference, 2798 QDict *options, int flags, Error **errp) 2799 { 2800 return bdrv_open_inherit(filename, reference, options, flags, NULL, 2801 NULL, errp); 2802 } 2803 2804 /* 2805 * Adds a BlockDriverState to a simple queue for an atomic, transactional 2806 * reopen of multiple devices. 2807 * 2808 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT 2809 * already performed, or alternatively may be NULL a new BlockReopenQueue will 2810 * be created and initialized. This newly created BlockReopenQueue should be 2811 * passed back in for subsequent calls that are intended to be of the same 2812 * atomic 'set'. 2813 * 2814 * bs is the BlockDriverState to add to the reopen queue. 2815 * 2816 * options contains the changed options for the associated bs 2817 * (the BlockReopenQueue takes ownership) 2818 * 2819 * flags contains the open flags for the associated bs 2820 * 2821 * returns a pointer to bs_queue, which is either the newly allocated 2822 * bs_queue, or the existing bs_queue being used. 2823 * 2824 * bs must be drained between bdrv_reopen_queue() and bdrv_reopen_multiple(). 2825 */ 2826 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue, 2827 BlockDriverState *bs, 2828 QDict *options, 2829 int flags, 2830 const BdrvChildRole *role, 2831 QDict *parent_options, 2832 int parent_flags) 2833 { 2834 assert(bs != NULL); 2835 2836 BlockReopenQueueEntry *bs_entry; 2837 BdrvChild *child; 2838 QDict *old_options, *explicit_options; 2839 2840 /* Make sure that the caller remembered to use a drained section. This is 2841 * important to avoid graph changes between the recursive queuing here and 2842 * bdrv_reopen_multiple(). */ 2843 assert(bs->quiesce_counter > 0); 2844 2845 if (bs_queue == NULL) { 2846 bs_queue = g_new0(BlockReopenQueue, 1); 2847 QSIMPLEQ_INIT(bs_queue); 2848 } 2849 2850 if (!options) { 2851 options = qdict_new(); 2852 } 2853 2854 /* Check if this BlockDriverState is already in the queue */ 2855 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) { 2856 if (bs == bs_entry->state.bs) { 2857 break; 2858 } 2859 } 2860 2861 /* 2862 * Precedence of options: 2863 * 1. Explicitly passed in options (highest) 2864 * 2. Set in flags (only for top level) 2865 * 3. Retained from explicitly set options of bs 2866 * 4. Inherited from parent node 2867 * 5. Retained from effective options of bs 2868 */ 2869 2870 if (!parent_options) { 2871 /* 2872 * Any setting represented by flags is always updated. If the 2873 * corresponding QDict option is set, it takes precedence. Otherwise 2874 * the flag is translated into a QDict option. The old setting of bs is 2875 * not considered. 2876 */ 2877 update_options_from_flags(options, flags); 2878 } 2879 2880 /* Old explicitly set values (don't overwrite by inherited value) */ 2881 if (bs_entry) { 2882 old_options = qdict_clone_shallow(bs_entry->state.explicit_options); 2883 } else { 2884 old_options = qdict_clone_shallow(bs->explicit_options); 2885 } 2886 bdrv_join_options(bs, options, old_options); 2887 QDECREF(old_options); 2888 2889 explicit_options = qdict_clone_shallow(options); 2890 2891 /* Inherit from parent node */ 2892 if (parent_options) { 2893 QemuOpts *opts; 2894 QDict *options_copy; 2895 assert(!flags); 2896 role->inherit_options(&flags, options, parent_flags, parent_options); 2897 options_copy = qdict_clone_shallow(options); 2898 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort); 2899 qemu_opts_absorb_qdict(opts, options_copy, NULL); 2900 update_flags_from_options(&flags, opts); 2901 qemu_opts_del(opts); 2902 QDECREF(options_copy); 2903 } 2904 2905 /* Old values are used for options that aren't set yet */ 2906 old_options = qdict_clone_shallow(bs->options); 2907 bdrv_join_options(bs, options, old_options); 2908 QDECREF(old_options); 2909 2910 /* bdrv_open_inherit() sets and clears some additional flags internally */ 2911 flags &= ~BDRV_O_PROTOCOL; 2912 if (flags & BDRV_O_RDWR) { 2913 flags |= BDRV_O_ALLOW_RDWR; 2914 } 2915 2916 if (!bs_entry) { 2917 bs_entry = g_new0(BlockReopenQueueEntry, 1); 2918 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry); 2919 } else { 2920 QDECREF(bs_entry->state.options); 2921 QDECREF(bs_entry->state.explicit_options); 2922 } 2923 2924 bs_entry->state.bs = bs; 2925 bs_entry->state.options = options; 2926 bs_entry->state.explicit_options = explicit_options; 2927 bs_entry->state.flags = flags; 2928 2929 /* This needs to be overwritten in bdrv_reopen_prepare() */ 2930 bs_entry->state.perm = UINT64_MAX; 2931 bs_entry->state.shared_perm = 0; 2932 2933 QLIST_FOREACH(child, &bs->children, next) { 2934 QDict *new_child_options; 2935 char *child_key_dot; 2936 2937 /* reopen can only change the options of block devices that were 2938 * implicitly created and inherited options. For other (referenced) 2939 * block devices, a syntax like "backing.foo" results in an error. */ 2940 if (child->bs->inherits_from != bs) { 2941 continue; 2942 } 2943 2944 child_key_dot = g_strdup_printf("%s.", child->name); 2945 qdict_extract_subqdict(options, &new_child_options, child_key_dot); 2946 g_free(child_key_dot); 2947 2948 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 0, 2949 child->role, options, flags); 2950 } 2951 2952 return bs_queue; 2953 } 2954 2955 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue, 2956 BlockDriverState *bs, 2957 QDict *options, int flags) 2958 { 2959 return bdrv_reopen_queue_child(bs_queue, bs, options, flags, 2960 NULL, NULL, 0); 2961 } 2962 2963 /* 2964 * Reopen multiple BlockDriverStates atomically & transactionally. 2965 * 2966 * The queue passed in (bs_queue) must have been built up previous 2967 * via bdrv_reopen_queue(). 2968 * 2969 * Reopens all BDS specified in the queue, with the appropriate 2970 * flags. All devices are prepared for reopen, and failure of any 2971 * device will cause all device changes to be abandonded, and intermediate 2972 * data cleaned up. 2973 * 2974 * If all devices prepare successfully, then the changes are committed 2975 * to all devices. 2976 * 2977 * All affected nodes must be drained between bdrv_reopen_queue() and 2978 * bdrv_reopen_multiple(). 2979 */ 2980 int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp) 2981 { 2982 int ret = -1; 2983 BlockReopenQueueEntry *bs_entry, *next; 2984 Error *local_err = NULL; 2985 2986 assert(bs_queue != NULL); 2987 2988 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) { 2989 assert(bs_entry->state.bs->quiesce_counter > 0); 2990 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) { 2991 error_propagate(errp, local_err); 2992 goto cleanup; 2993 } 2994 bs_entry->prepared = true; 2995 } 2996 2997 /* If we reach this point, we have success and just need to apply the 2998 * changes 2999 */ 3000 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) { 3001 bdrv_reopen_commit(&bs_entry->state); 3002 } 3003 3004 ret = 0; 3005 3006 cleanup: 3007 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) { 3008 if (ret && bs_entry->prepared) { 3009 bdrv_reopen_abort(&bs_entry->state); 3010 } else if (ret) { 3011 QDECREF(bs_entry->state.explicit_options); 3012 } 3013 QDECREF(bs_entry->state.options); 3014 g_free(bs_entry); 3015 } 3016 g_free(bs_queue); 3017 3018 return ret; 3019 } 3020 3021 3022 /* Reopen a single BlockDriverState with the specified flags. */ 3023 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp) 3024 { 3025 int ret = -1; 3026 Error *local_err = NULL; 3027 BlockReopenQueue *queue; 3028 3029 bdrv_subtree_drained_begin(bs); 3030 3031 queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags); 3032 ret = bdrv_reopen_multiple(bdrv_get_aio_context(bs), queue, &local_err); 3033 if (local_err != NULL) { 3034 error_propagate(errp, local_err); 3035 } 3036 3037 bdrv_subtree_drained_end(bs); 3038 3039 return ret; 3040 } 3041 3042 static BlockReopenQueueEntry *find_parent_in_reopen_queue(BlockReopenQueue *q, 3043 BdrvChild *c) 3044 { 3045 BlockReopenQueueEntry *entry; 3046 3047 QSIMPLEQ_FOREACH(entry, q, entry) { 3048 BlockDriverState *bs = entry->state.bs; 3049 BdrvChild *child; 3050 3051 QLIST_FOREACH(child, &bs->children, next) { 3052 if (child == c) { 3053 return entry; 3054 } 3055 } 3056 } 3057 3058 return NULL; 3059 } 3060 3061 static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs, 3062 uint64_t *perm, uint64_t *shared) 3063 { 3064 BdrvChild *c; 3065 BlockReopenQueueEntry *parent; 3066 uint64_t cumulative_perms = 0; 3067 uint64_t cumulative_shared_perms = BLK_PERM_ALL; 3068 3069 QLIST_FOREACH(c, &bs->parents, next_parent) { 3070 parent = find_parent_in_reopen_queue(q, c); 3071 if (!parent) { 3072 cumulative_perms |= c->perm; 3073 cumulative_shared_perms &= c->shared_perm; 3074 } else { 3075 uint64_t nperm, nshared; 3076 3077 bdrv_child_perm(parent->state.bs, bs, c, c->role, q, 3078 parent->state.perm, parent->state.shared_perm, 3079 &nperm, &nshared); 3080 3081 cumulative_perms |= nperm; 3082 cumulative_shared_perms &= nshared; 3083 } 3084 } 3085 *perm = cumulative_perms; 3086 *shared = cumulative_shared_perms; 3087 } 3088 3089 /* 3090 * Prepares a BlockDriverState for reopen. All changes are staged in the 3091 * 'opaque' field of the BDRVReopenState, which is used and allocated by 3092 * the block driver layer .bdrv_reopen_prepare() 3093 * 3094 * bs is the BlockDriverState to reopen 3095 * flags are the new open flags 3096 * queue is the reopen queue 3097 * 3098 * Returns 0 on success, non-zero on error. On error errp will be set 3099 * as well. 3100 * 3101 * On failure, bdrv_reopen_abort() will be called to clean up any data. 3102 * It is the responsibility of the caller to then call the abort() or 3103 * commit() for any other BDS that have been left in a prepare() state 3104 * 3105 */ 3106 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, 3107 Error **errp) 3108 { 3109 int ret = -1; 3110 Error *local_err = NULL; 3111 BlockDriver *drv; 3112 QemuOpts *opts; 3113 const char *value; 3114 bool read_only; 3115 3116 assert(reopen_state != NULL); 3117 assert(reopen_state->bs->drv != NULL); 3118 drv = reopen_state->bs->drv; 3119 3120 /* Process generic block layer options */ 3121 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort); 3122 qemu_opts_absorb_qdict(opts, reopen_state->options, &local_err); 3123 if (local_err) { 3124 error_propagate(errp, local_err); 3125 ret = -EINVAL; 3126 goto error; 3127 } 3128 3129 update_flags_from_options(&reopen_state->flags, opts); 3130 3131 /* node-name and driver must be unchanged. Put them back into the QDict, so 3132 * that they are checked at the end of this function. */ 3133 value = qemu_opt_get(opts, "node-name"); 3134 if (value) { 3135 qdict_put_str(reopen_state->options, "node-name", value); 3136 } 3137 3138 value = qemu_opt_get(opts, "driver"); 3139 if (value) { 3140 qdict_put_str(reopen_state->options, "driver", value); 3141 } 3142 3143 /* If we are to stay read-only, do not allow permission change 3144 * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is 3145 * not set, or if the BDS still has copy_on_read enabled */ 3146 read_only = !(reopen_state->flags & BDRV_O_RDWR); 3147 ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err); 3148 if (local_err) { 3149 error_propagate(errp, local_err); 3150 goto error; 3151 } 3152 3153 /* Calculate required permissions after reopening */ 3154 bdrv_reopen_perm(queue, reopen_state->bs, 3155 &reopen_state->perm, &reopen_state->shared_perm); 3156 3157 ret = bdrv_flush(reopen_state->bs); 3158 if (ret) { 3159 error_setg_errno(errp, -ret, "Error flushing drive"); 3160 goto error; 3161 } 3162 3163 if (drv->bdrv_reopen_prepare) { 3164 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err); 3165 if (ret) { 3166 if (local_err != NULL) { 3167 error_propagate(errp, local_err); 3168 } else { 3169 error_setg(errp, "failed while preparing to reopen image '%s'", 3170 reopen_state->bs->filename); 3171 } 3172 goto error; 3173 } 3174 } else { 3175 /* It is currently mandatory to have a bdrv_reopen_prepare() 3176 * handler for each supported drv. */ 3177 error_setg(errp, "Block format '%s' used by node '%s' " 3178 "does not support reopening files", drv->format_name, 3179 bdrv_get_device_or_node_name(reopen_state->bs)); 3180 ret = -1; 3181 goto error; 3182 } 3183 3184 /* Options that are not handled are only okay if they are unchanged 3185 * compared to the old state. It is expected that some options are only 3186 * used for the initial open, but not reopen (e.g. filename) */ 3187 if (qdict_size(reopen_state->options)) { 3188 const QDictEntry *entry = qdict_first(reopen_state->options); 3189 3190 do { 3191 QObject *new = entry->value; 3192 QObject *old = qdict_get(reopen_state->bs->options, entry->key); 3193 3194 /* 3195 * TODO: When using -drive to specify blockdev options, all values 3196 * will be strings; however, when using -blockdev, blockdev-add or 3197 * filenames using the json:{} pseudo-protocol, they will be 3198 * correctly typed. 3199 * In contrast, reopening options are (currently) always strings 3200 * (because you can only specify them through qemu-io; all other 3201 * callers do not specify any options). 3202 * Therefore, when using anything other than -drive to create a BDS, 3203 * this cannot detect non-string options as unchanged, because 3204 * qobject_is_equal() always returns false for objects of different 3205 * type. In the future, this should be remedied by correctly typing 3206 * all options. For now, this is not too big of an issue because 3207 * the user can simply omit options which cannot be changed anyway, 3208 * so they will stay unchanged. 3209 */ 3210 if (!qobject_is_equal(new, old)) { 3211 error_setg(errp, "Cannot change the option '%s'", entry->key); 3212 ret = -EINVAL; 3213 goto error; 3214 } 3215 } while ((entry = qdict_next(reopen_state->options, entry))); 3216 } 3217 3218 ret = bdrv_check_perm(reopen_state->bs, queue, reopen_state->perm, 3219 reopen_state->shared_perm, NULL, errp); 3220 if (ret < 0) { 3221 goto error; 3222 } 3223 3224 ret = 0; 3225 3226 error: 3227 qemu_opts_del(opts); 3228 return ret; 3229 } 3230 3231 /* 3232 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and 3233 * makes them final by swapping the staging BlockDriverState contents into 3234 * the active BlockDriverState contents. 3235 */ 3236 void bdrv_reopen_commit(BDRVReopenState *reopen_state) 3237 { 3238 BlockDriver *drv; 3239 BlockDriverState *bs; 3240 bool old_can_write, new_can_write; 3241 3242 assert(reopen_state != NULL); 3243 bs = reopen_state->bs; 3244 drv = bs->drv; 3245 assert(drv != NULL); 3246 3247 old_can_write = 3248 !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE); 3249 3250 /* If there are any driver level actions to take */ 3251 if (drv->bdrv_reopen_commit) { 3252 drv->bdrv_reopen_commit(reopen_state); 3253 } 3254 3255 /* set BDS specific flags now */ 3256 QDECREF(bs->explicit_options); 3257 3258 bs->explicit_options = reopen_state->explicit_options; 3259 bs->open_flags = reopen_state->flags; 3260 bs->read_only = !(reopen_state->flags & BDRV_O_RDWR); 3261 3262 bdrv_refresh_limits(bs, NULL); 3263 3264 bdrv_set_perm(reopen_state->bs, reopen_state->perm, 3265 reopen_state->shared_perm); 3266 3267 new_can_write = 3268 !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE); 3269 if (!old_can_write && new_can_write && drv->bdrv_reopen_bitmaps_rw) { 3270 Error *local_err = NULL; 3271 if (drv->bdrv_reopen_bitmaps_rw(bs, &local_err) < 0) { 3272 /* This is not fatal, bitmaps just left read-only, so all following 3273 * writes will fail. User can remove read-only bitmaps to unblock 3274 * writes. 3275 */ 3276 error_reportf_err(local_err, 3277 "%s: Failed to make dirty bitmaps writable: ", 3278 bdrv_get_node_name(bs)); 3279 } 3280 } 3281 } 3282 3283 /* 3284 * Abort the reopen, and delete and free the staged changes in 3285 * reopen_state 3286 */ 3287 void bdrv_reopen_abort(BDRVReopenState *reopen_state) 3288 { 3289 BlockDriver *drv; 3290 3291 assert(reopen_state != NULL); 3292 drv = reopen_state->bs->drv; 3293 assert(drv != NULL); 3294 3295 if (drv->bdrv_reopen_abort) { 3296 drv->bdrv_reopen_abort(reopen_state); 3297 } 3298 3299 QDECREF(reopen_state->explicit_options); 3300 3301 bdrv_abort_perm_update(reopen_state->bs); 3302 } 3303 3304 3305 static void bdrv_close(BlockDriverState *bs) 3306 { 3307 BdrvAioNotifier *ban, *ban_next; 3308 BdrvChild *child, *next; 3309 3310 assert(!bs->job); 3311 assert(!bs->refcnt); 3312 3313 bdrv_drained_begin(bs); /* complete I/O */ 3314 bdrv_flush(bs); 3315 bdrv_drain(bs); /* in case flush left pending I/O */ 3316 3317 if (bs->drv) { 3318 bs->drv->bdrv_close(bs); 3319 bs->drv = NULL; 3320 } 3321 3322 bdrv_set_backing_hd(bs, NULL, &error_abort); 3323 3324 if (bs->file != NULL) { 3325 bdrv_unref_child(bs, bs->file); 3326 bs->file = NULL; 3327 } 3328 3329 QLIST_FOREACH_SAFE(child, &bs->children, next, next) { 3330 /* TODO Remove bdrv_unref() from drivers' close function and use 3331 * bdrv_unref_child() here */ 3332 if (child->bs->inherits_from == bs) { 3333 child->bs->inherits_from = NULL; 3334 } 3335 bdrv_detach_child(child); 3336 } 3337 3338 g_free(bs->opaque); 3339 bs->opaque = NULL; 3340 atomic_set(&bs->copy_on_read, 0); 3341 bs->backing_file[0] = '\0'; 3342 bs->backing_format[0] = '\0'; 3343 bs->total_sectors = 0; 3344 bs->encrypted = false; 3345 bs->sg = false; 3346 QDECREF(bs->options); 3347 QDECREF(bs->explicit_options); 3348 bs->options = NULL; 3349 bs->explicit_options = NULL; 3350 QDECREF(bs->full_open_options); 3351 bs->full_open_options = NULL; 3352 3353 bdrv_release_named_dirty_bitmaps(bs); 3354 assert(QLIST_EMPTY(&bs->dirty_bitmaps)); 3355 3356 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { 3357 g_free(ban); 3358 } 3359 QLIST_INIT(&bs->aio_notifiers); 3360 bdrv_drained_end(bs); 3361 } 3362 3363 void bdrv_close_all(void) 3364 { 3365 block_job_cancel_sync_all(); 3366 nbd_export_close_all(); 3367 3368 /* Drop references from requests still in flight, such as canceled block 3369 * jobs whose AIO context has not been polled yet */ 3370 bdrv_drain_all(); 3371 3372 blk_remove_all_bs(); 3373 blockdev_close_all_bdrv_states(); 3374 3375 assert(QTAILQ_EMPTY(&all_bdrv_states)); 3376 } 3377 3378 static bool should_update_child(BdrvChild *c, BlockDriverState *to) 3379 { 3380 BdrvChild *to_c; 3381 3382 if (c->role->stay_at_node) { 3383 return false; 3384 } 3385 3386 if (c->role == &child_backing) { 3387 /* If @from is a backing file of @to, ignore the child to avoid 3388 * creating a loop. We only want to change the pointer of other 3389 * parents. */ 3390 QLIST_FOREACH(to_c, &to->children, next) { 3391 if (to_c == c) { 3392 break; 3393 } 3394 } 3395 if (to_c) { 3396 return false; 3397 } 3398 } 3399 3400 return true; 3401 } 3402 3403 void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to, 3404 Error **errp) 3405 { 3406 BdrvChild *c, *next; 3407 GSList *list = NULL, *p; 3408 uint64_t old_perm, old_shared; 3409 uint64_t perm = 0, shared = BLK_PERM_ALL; 3410 int ret; 3411 3412 assert(!atomic_read(&from->in_flight)); 3413 assert(!atomic_read(&to->in_flight)); 3414 3415 /* Make sure that @from doesn't go away until we have successfully attached 3416 * all of its parents to @to. */ 3417 bdrv_ref(from); 3418 3419 /* Put all parents into @list and calculate their cumulative permissions */ 3420 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) { 3421 if (!should_update_child(c, to)) { 3422 continue; 3423 } 3424 list = g_slist_prepend(list, c); 3425 perm |= c->perm; 3426 shared &= c->shared_perm; 3427 } 3428 3429 /* Check whether the required permissions can be granted on @to, ignoring 3430 * all BdrvChild in @list so that they can't block themselves. */ 3431 ret = bdrv_check_update_perm(to, NULL, perm, shared, list, errp); 3432 if (ret < 0) { 3433 bdrv_abort_perm_update(to); 3434 goto out; 3435 } 3436 3437 /* Now actually perform the change. We performed the permission check for 3438 * all elements of @list at once, so set the permissions all at once at the 3439 * very end. */ 3440 for (p = list; p != NULL; p = p->next) { 3441 c = p->data; 3442 3443 bdrv_ref(to); 3444 bdrv_replace_child_noperm(c, to); 3445 bdrv_unref(from); 3446 } 3447 3448 bdrv_get_cumulative_perm(to, &old_perm, &old_shared); 3449 bdrv_set_perm(to, old_perm | perm, old_shared | shared); 3450 3451 out: 3452 g_slist_free(list); 3453 bdrv_unref(from); 3454 } 3455 3456 /* 3457 * Add new bs contents at the top of an image chain while the chain is 3458 * live, while keeping required fields on the top layer. 3459 * 3460 * This will modify the BlockDriverState fields, and swap contents 3461 * between bs_new and bs_top. Both bs_new and bs_top are modified. 3462 * 3463 * bs_new must not be attached to a BlockBackend. 3464 * 3465 * This function does not create any image files. 3466 * 3467 * bdrv_append() takes ownership of a bs_new reference and unrefs it because 3468 * that's what the callers commonly need. bs_new will be referenced by the old 3469 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a 3470 * reference of its own, it must call bdrv_ref(). 3471 */ 3472 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top, 3473 Error **errp) 3474 { 3475 Error *local_err = NULL; 3476 3477 bdrv_set_backing_hd(bs_new, bs_top, &local_err); 3478 if (local_err) { 3479 error_propagate(errp, local_err); 3480 goto out; 3481 } 3482 3483 bdrv_replace_node(bs_top, bs_new, &local_err); 3484 if (local_err) { 3485 error_propagate(errp, local_err); 3486 bdrv_set_backing_hd(bs_new, NULL, &error_abort); 3487 goto out; 3488 } 3489 3490 /* bs_new is now referenced by its new parents, we don't need the 3491 * additional reference any more. */ 3492 out: 3493 bdrv_unref(bs_new); 3494 } 3495 3496 static void bdrv_delete(BlockDriverState *bs) 3497 { 3498 assert(!bs->job); 3499 assert(bdrv_op_blocker_is_empty(bs)); 3500 assert(!bs->refcnt); 3501 3502 bdrv_close(bs); 3503 3504 /* remove from list, if necessary */ 3505 if (bs->node_name[0] != '\0') { 3506 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list); 3507 } 3508 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list); 3509 3510 g_free(bs); 3511 } 3512 3513 /* 3514 * Run consistency checks on an image 3515 * 3516 * Returns 0 if the check could be completed (it doesn't mean that the image is 3517 * free of errors) or -errno when an internal error occurred. The results of the 3518 * check are stored in res. 3519 */ 3520 static int coroutine_fn bdrv_co_check(BlockDriverState *bs, 3521 BdrvCheckResult *res, BdrvCheckMode fix) 3522 { 3523 if (bs->drv == NULL) { 3524 return -ENOMEDIUM; 3525 } 3526 if (bs->drv->bdrv_co_check == NULL) { 3527 return -ENOTSUP; 3528 } 3529 3530 memset(res, 0, sizeof(*res)); 3531 return bs->drv->bdrv_co_check(bs, res, fix); 3532 } 3533 3534 typedef struct CheckCo { 3535 BlockDriverState *bs; 3536 BdrvCheckResult *res; 3537 BdrvCheckMode fix; 3538 int ret; 3539 } CheckCo; 3540 3541 static void bdrv_check_co_entry(void *opaque) 3542 { 3543 CheckCo *cco = opaque; 3544 cco->ret = bdrv_co_check(cco->bs, cco->res, cco->fix); 3545 } 3546 3547 int bdrv_check(BlockDriverState *bs, 3548 BdrvCheckResult *res, BdrvCheckMode fix) 3549 { 3550 Coroutine *co; 3551 CheckCo cco = { 3552 .bs = bs, 3553 .res = res, 3554 .ret = -EINPROGRESS, 3555 .fix = fix, 3556 }; 3557 3558 if (qemu_in_coroutine()) { 3559 /* Fast-path if already in coroutine context */ 3560 bdrv_check_co_entry(&cco); 3561 } else { 3562 co = qemu_coroutine_create(bdrv_check_co_entry, &cco); 3563 qemu_coroutine_enter(co); 3564 BDRV_POLL_WHILE(bs, cco.ret == -EINPROGRESS); 3565 } 3566 3567 return cco.ret; 3568 } 3569 3570 /* 3571 * Return values: 3572 * 0 - success 3573 * -EINVAL - backing format specified, but no file 3574 * -ENOSPC - can't update the backing file because no space is left in the 3575 * image file header 3576 * -ENOTSUP - format driver doesn't support changing the backing file 3577 */ 3578 int bdrv_change_backing_file(BlockDriverState *bs, 3579 const char *backing_file, const char *backing_fmt) 3580 { 3581 BlockDriver *drv = bs->drv; 3582 int ret; 3583 3584 if (!drv) { 3585 return -ENOMEDIUM; 3586 } 3587 3588 /* Backing file format doesn't make sense without a backing file */ 3589 if (backing_fmt && !backing_file) { 3590 return -EINVAL; 3591 } 3592 3593 if (drv->bdrv_change_backing_file != NULL) { 3594 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt); 3595 } else { 3596 ret = -ENOTSUP; 3597 } 3598 3599 if (ret == 0) { 3600 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); 3601 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); 3602 } 3603 return ret; 3604 } 3605 3606 /* 3607 * Finds the image layer in the chain that has 'bs' as its backing file. 3608 * 3609 * active is the current topmost image. 3610 * 3611 * Returns NULL if bs is not found in active's image chain, 3612 * or if active == bs. 3613 * 3614 * Returns the bottommost base image if bs == NULL. 3615 */ 3616 BlockDriverState *bdrv_find_overlay(BlockDriverState *active, 3617 BlockDriverState *bs) 3618 { 3619 while (active && bs != backing_bs(active)) { 3620 active = backing_bs(active); 3621 } 3622 3623 return active; 3624 } 3625 3626 /* Given a BDS, searches for the base layer. */ 3627 BlockDriverState *bdrv_find_base(BlockDriverState *bs) 3628 { 3629 return bdrv_find_overlay(bs, NULL); 3630 } 3631 3632 /* 3633 * Drops images above 'base' up to and including 'top', and sets the image 3634 * above 'top' to have base as its backing file. 3635 * 3636 * Requires that the overlay to 'top' is opened r/w, so that the backing file 3637 * information in 'bs' can be properly updated. 3638 * 3639 * E.g., this will convert the following chain: 3640 * bottom <- base <- intermediate <- top <- active 3641 * 3642 * to 3643 * 3644 * bottom <- base <- active 3645 * 3646 * It is allowed for bottom==base, in which case it converts: 3647 * 3648 * base <- intermediate <- top <- active 3649 * 3650 * to 3651 * 3652 * base <- active 3653 * 3654 * If backing_file_str is non-NULL, it will be used when modifying top's 3655 * overlay image metadata. 3656 * 3657 * Error conditions: 3658 * if active == top, that is considered an error 3659 * 3660 */ 3661 int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base, 3662 const char *backing_file_str) 3663 { 3664 BdrvChild *c, *next; 3665 Error *local_err = NULL; 3666 int ret = -EIO; 3667 3668 bdrv_ref(top); 3669 3670 if (!top->drv || !base->drv) { 3671 goto exit; 3672 } 3673 3674 /* Make sure that base is in the backing chain of top */ 3675 if (!bdrv_chain_contains(top, base)) { 3676 goto exit; 3677 } 3678 3679 /* success - we can delete the intermediate states, and link top->base */ 3680 /* TODO Check graph modification op blockers (BLK_PERM_GRAPH_MOD) once 3681 * we've figured out how they should work. */ 3682 backing_file_str = backing_file_str ? backing_file_str : base->filename; 3683 3684 QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) { 3685 /* Check whether we are allowed to switch c from top to base */ 3686 GSList *ignore_children = g_slist_prepend(NULL, c); 3687 bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm, 3688 ignore_children, &local_err); 3689 g_slist_free(ignore_children); 3690 if (local_err) { 3691 ret = -EPERM; 3692 error_report_err(local_err); 3693 goto exit; 3694 } 3695 3696 /* If so, update the backing file path in the image file */ 3697 if (c->role->update_filename) { 3698 ret = c->role->update_filename(c, base, backing_file_str, 3699 &local_err); 3700 if (ret < 0) { 3701 bdrv_abort_perm_update(base); 3702 error_report_err(local_err); 3703 goto exit; 3704 } 3705 } 3706 3707 /* Do the actual switch in the in-memory graph. 3708 * Completes bdrv_check_update_perm() transaction internally. */ 3709 bdrv_ref(base); 3710 bdrv_replace_child(c, base); 3711 bdrv_unref(top); 3712 } 3713 3714 ret = 0; 3715 exit: 3716 bdrv_unref(top); 3717 return ret; 3718 } 3719 3720 /** 3721 * Truncate file to 'offset' bytes (needed only for file protocols) 3722 */ 3723 int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc, 3724 Error **errp) 3725 { 3726 BlockDriverState *bs = child->bs; 3727 BlockDriver *drv = bs->drv; 3728 int ret; 3729 3730 assert(child->perm & BLK_PERM_RESIZE); 3731 3732 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */ 3733 if (!drv) { 3734 error_setg(errp, "No medium inserted"); 3735 return -ENOMEDIUM; 3736 } 3737 if (offset < 0) { 3738 error_setg(errp, "Image size cannot be negative"); 3739 return -EINVAL; 3740 } 3741 3742 if (!drv->bdrv_truncate) { 3743 if (bs->file && drv->is_filter) { 3744 return bdrv_truncate(bs->file, offset, prealloc, errp); 3745 } 3746 error_setg(errp, "Image format driver does not support resize"); 3747 return -ENOTSUP; 3748 } 3749 if (bs->read_only) { 3750 error_setg(errp, "Image is read-only"); 3751 return -EACCES; 3752 } 3753 3754 assert(!(bs->open_flags & BDRV_O_INACTIVE)); 3755 3756 ret = drv->bdrv_truncate(bs, offset, prealloc, errp); 3757 if (ret < 0) { 3758 return ret; 3759 } 3760 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS); 3761 if (ret < 0) { 3762 error_setg_errno(errp, -ret, "Could not refresh total sector count"); 3763 } else { 3764 offset = bs->total_sectors * BDRV_SECTOR_SIZE; 3765 } 3766 bdrv_dirty_bitmap_truncate(bs, offset); 3767 bdrv_parent_cb_resize(bs); 3768 atomic_inc(&bs->write_gen); 3769 return ret; 3770 } 3771 3772 /** 3773 * Length of a allocated file in bytes. Sparse files are counted by actual 3774 * allocated space. Return < 0 if error or unknown. 3775 */ 3776 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs) 3777 { 3778 BlockDriver *drv = bs->drv; 3779 if (!drv) { 3780 return -ENOMEDIUM; 3781 } 3782 if (drv->bdrv_get_allocated_file_size) { 3783 return drv->bdrv_get_allocated_file_size(bs); 3784 } 3785 if (bs->file) { 3786 return bdrv_get_allocated_file_size(bs->file->bs); 3787 } 3788 return -ENOTSUP; 3789 } 3790 3791 /* 3792 * bdrv_measure: 3793 * @drv: Format driver 3794 * @opts: Creation options for new image 3795 * @in_bs: Existing image containing data for new image (may be NULL) 3796 * @errp: Error object 3797 * Returns: A #BlockMeasureInfo (free using qapi_free_BlockMeasureInfo()) 3798 * or NULL on error 3799 * 3800 * Calculate file size required to create a new image. 3801 * 3802 * If @in_bs is given then space for allocated clusters and zero clusters 3803 * from that image are included in the calculation. If @opts contains a 3804 * backing file that is shared by @in_bs then backing clusters may be omitted 3805 * from the calculation. 3806 * 3807 * If @in_bs is NULL then the calculation includes no allocated clusters 3808 * unless a preallocation option is given in @opts. 3809 * 3810 * Note that @in_bs may use a different BlockDriver from @drv. 3811 * 3812 * If an error occurs the @errp pointer is set. 3813 */ 3814 BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts, 3815 BlockDriverState *in_bs, Error **errp) 3816 { 3817 if (!drv->bdrv_measure) { 3818 error_setg(errp, "Block driver '%s' does not support size measurement", 3819 drv->format_name); 3820 return NULL; 3821 } 3822 3823 return drv->bdrv_measure(opts, in_bs, errp); 3824 } 3825 3826 /** 3827 * Return number of sectors on success, -errno on error. 3828 */ 3829 int64_t bdrv_nb_sectors(BlockDriverState *bs) 3830 { 3831 BlockDriver *drv = bs->drv; 3832 3833 if (!drv) 3834 return -ENOMEDIUM; 3835 3836 if (drv->has_variable_length) { 3837 int ret = refresh_total_sectors(bs, bs->total_sectors); 3838 if (ret < 0) { 3839 return ret; 3840 } 3841 } 3842 return bs->total_sectors; 3843 } 3844 3845 /** 3846 * Return length in bytes on success, -errno on error. 3847 * The length is always a multiple of BDRV_SECTOR_SIZE. 3848 */ 3849 int64_t bdrv_getlength(BlockDriverState *bs) 3850 { 3851 int64_t ret = bdrv_nb_sectors(bs); 3852 3853 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret; 3854 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE; 3855 } 3856 3857 /* return 0 as number of sectors if no device present or error */ 3858 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) 3859 { 3860 int64_t nb_sectors = bdrv_nb_sectors(bs); 3861 3862 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors; 3863 } 3864 3865 bool bdrv_is_sg(BlockDriverState *bs) 3866 { 3867 return bs->sg; 3868 } 3869 3870 bool bdrv_is_encrypted(BlockDriverState *bs) 3871 { 3872 if (bs->backing && bs->backing->bs->encrypted) { 3873 return true; 3874 } 3875 return bs->encrypted; 3876 } 3877 3878 const char *bdrv_get_format_name(BlockDriverState *bs) 3879 { 3880 return bs->drv ? bs->drv->format_name : NULL; 3881 } 3882 3883 static int qsort_strcmp(const void *a, const void *b) 3884 { 3885 return strcmp(*(char *const *)a, *(char *const *)b); 3886 } 3887 3888 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 3889 void *opaque) 3890 { 3891 BlockDriver *drv; 3892 int count = 0; 3893 int i; 3894 const char **formats = NULL; 3895 3896 QLIST_FOREACH(drv, &bdrv_drivers, list) { 3897 if (drv->format_name) { 3898 bool found = false; 3899 int i = count; 3900 while (formats && i && !found) { 3901 found = !strcmp(formats[--i], drv->format_name); 3902 } 3903 3904 if (!found) { 3905 formats = g_renew(const char *, formats, count + 1); 3906 formats[count++] = drv->format_name; 3907 } 3908 } 3909 } 3910 3911 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) { 3912 const char *format_name = block_driver_modules[i].format_name; 3913 3914 if (format_name) { 3915 bool found = false; 3916 int j = count; 3917 3918 while (formats && j && !found) { 3919 found = !strcmp(formats[--j], format_name); 3920 } 3921 3922 if (!found) { 3923 formats = g_renew(const char *, formats, count + 1); 3924 formats[count++] = format_name; 3925 } 3926 } 3927 } 3928 3929 qsort(formats, count, sizeof(formats[0]), qsort_strcmp); 3930 3931 for (i = 0; i < count; i++) { 3932 it(opaque, formats[i]); 3933 } 3934 3935 g_free(formats); 3936 } 3937 3938 /* This function is to find a node in the bs graph */ 3939 BlockDriverState *bdrv_find_node(const char *node_name) 3940 { 3941 BlockDriverState *bs; 3942 3943 assert(node_name); 3944 3945 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { 3946 if (!strcmp(node_name, bs->node_name)) { 3947 return bs; 3948 } 3949 } 3950 return NULL; 3951 } 3952 3953 /* Put this QMP function here so it can access the static graph_bdrv_states. */ 3954 BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp) 3955 { 3956 BlockDeviceInfoList *list, *entry; 3957 BlockDriverState *bs; 3958 3959 list = NULL; 3960 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { 3961 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp); 3962 if (!info) { 3963 qapi_free_BlockDeviceInfoList(list); 3964 return NULL; 3965 } 3966 entry = g_malloc0(sizeof(*entry)); 3967 entry->value = info; 3968 entry->next = list; 3969 list = entry; 3970 } 3971 3972 return list; 3973 } 3974 3975 BlockDriverState *bdrv_lookup_bs(const char *device, 3976 const char *node_name, 3977 Error **errp) 3978 { 3979 BlockBackend *blk; 3980 BlockDriverState *bs; 3981 3982 if (device) { 3983 blk = blk_by_name(device); 3984 3985 if (blk) { 3986 bs = blk_bs(blk); 3987 if (!bs) { 3988 error_setg(errp, "Device '%s' has no medium", device); 3989 } 3990 3991 return bs; 3992 } 3993 } 3994 3995 if (node_name) { 3996 bs = bdrv_find_node(node_name); 3997 3998 if (bs) { 3999 return bs; 4000 } 4001 } 4002 4003 error_setg(errp, "Cannot find device=%s nor node_name=%s", 4004 device ? device : "", 4005 node_name ? node_name : ""); 4006 return NULL; 4007 } 4008 4009 /* If 'base' is in the same chain as 'top', return true. Otherwise, 4010 * return false. If either argument is NULL, return false. */ 4011 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base) 4012 { 4013 while (top && top != base) { 4014 top = backing_bs(top); 4015 } 4016 4017 return top != NULL; 4018 } 4019 4020 BlockDriverState *bdrv_next_node(BlockDriverState *bs) 4021 { 4022 if (!bs) { 4023 return QTAILQ_FIRST(&graph_bdrv_states); 4024 } 4025 return QTAILQ_NEXT(bs, node_list); 4026 } 4027 4028 const char *bdrv_get_node_name(const BlockDriverState *bs) 4029 { 4030 return bs->node_name; 4031 } 4032 4033 const char *bdrv_get_parent_name(const BlockDriverState *bs) 4034 { 4035 BdrvChild *c; 4036 const char *name; 4037 4038 /* If multiple parents have a name, just pick the first one. */ 4039 QLIST_FOREACH(c, &bs->parents, next_parent) { 4040 if (c->role->get_name) { 4041 name = c->role->get_name(c); 4042 if (name && *name) { 4043 return name; 4044 } 4045 } 4046 } 4047 4048 return NULL; 4049 } 4050 4051 /* TODO check what callers really want: bs->node_name or blk_name() */ 4052 const char *bdrv_get_device_name(const BlockDriverState *bs) 4053 { 4054 return bdrv_get_parent_name(bs) ?: ""; 4055 } 4056 4057 /* This can be used to identify nodes that might not have a device 4058 * name associated. Since node and device names live in the same 4059 * namespace, the result is unambiguous. The exception is if both are 4060 * absent, then this returns an empty (non-null) string. */ 4061 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs) 4062 { 4063 return bdrv_get_parent_name(bs) ?: bs->node_name; 4064 } 4065 4066 int bdrv_get_flags(BlockDriverState *bs) 4067 { 4068 return bs->open_flags; 4069 } 4070 4071 int bdrv_has_zero_init_1(BlockDriverState *bs) 4072 { 4073 return 1; 4074 } 4075 4076 int bdrv_has_zero_init(BlockDriverState *bs) 4077 { 4078 if (!bs->drv) { 4079 return 0; 4080 } 4081 4082 /* If BS is a copy on write image, it is initialized to 4083 the contents of the base image, which may not be zeroes. */ 4084 if (bs->backing) { 4085 return 0; 4086 } 4087 if (bs->drv->bdrv_has_zero_init) { 4088 return bs->drv->bdrv_has_zero_init(bs); 4089 } 4090 if (bs->file && bs->drv->is_filter) { 4091 return bdrv_has_zero_init(bs->file->bs); 4092 } 4093 4094 /* safe default */ 4095 return 0; 4096 } 4097 4098 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs) 4099 { 4100 BlockDriverInfo bdi; 4101 4102 if (bs->backing) { 4103 return false; 4104 } 4105 4106 if (bdrv_get_info(bs, &bdi) == 0) { 4107 return bdi.unallocated_blocks_are_zero; 4108 } 4109 4110 return false; 4111 } 4112 4113 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs) 4114 { 4115 if (!(bs->open_flags & BDRV_O_UNMAP)) { 4116 return false; 4117 } 4118 4119 return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP; 4120 } 4121 4122 const char *bdrv_get_encrypted_filename(BlockDriverState *bs) 4123 { 4124 if (bs->backing && bs->backing->bs->encrypted) 4125 return bs->backing_file; 4126 else if (bs->encrypted) 4127 return bs->filename; 4128 else 4129 return NULL; 4130 } 4131 4132 void bdrv_get_backing_filename(BlockDriverState *bs, 4133 char *filename, int filename_size) 4134 { 4135 pstrcpy(filename, filename_size, bs->backing_file); 4136 } 4137 4138 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 4139 { 4140 BlockDriver *drv = bs->drv; 4141 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */ 4142 if (!drv) { 4143 return -ENOMEDIUM; 4144 } 4145 if (!drv->bdrv_get_info) { 4146 if (bs->file && drv->is_filter) { 4147 return bdrv_get_info(bs->file->bs, bdi); 4148 } 4149 return -ENOTSUP; 4150 } 4151 memset(bdi, 0, sizeof(*bdi)); 4152 return drv->bdrv_get_info(bs, bdi); 4153 } 4154 4155 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs) 4156 { 4157 BlockDriver *drv = bs->drv; 4158 if (drv && drv->bdrv_get_specific_info) { 4159 return drv->bdrv_get_specific_info(bs); 4160 } 4161 return NULL; 4162 } 4163 4164 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event) 4165 { 4166 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) { 4167 return; 4168 } 4169 4170 bs->drv->bdrv_debug_event(bs, event); 4171 } 4172 4173 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event, 4174 const char *tag) 4175 { 4176 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) { 4177 bs = bs->file ? bs->file->bs : NULL; 4178 } 4179 4180 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) { 4181 return bs->drv->bdrv_debug_breakpoint(bs, event, tag); 4182 } 4183 4184 return -ENOTSUP; 4185 } 4186 4187 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag) 4188 { 4189 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) { 4190 bs = bs->file ? bs->file->bs : NULL; 4191 } 4192 4193 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) { 4194 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag); 4195 } 4196 4197 return -ENOTSUP; 4198 } 4199 4200 int bdrv_debug_resume(BlockDriverState *bs, const char *tag) 4201 { 4202 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) { 4203 bs = bs->file ? bs->file->bs : NULL; 4204 } 4205 4206 if (bs && bs->drv && bs->drv->bdrv_debug_resume) { 4207 return bs->drv->bdrv_debug_resume(bs, tag); 4208 } 4209 4210 return -ENOTSUP; 4211 } 4212 4213 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag) 4214 { 4215 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) { 4216 bs = bs->file ? bs->file->bs : NULL; 4217 } 4218 4219 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) { 4220 return bs->drv->bdrv_debug_is_suspended(bs, tag); 4221 } 4222 4223 return false; 4224 } 4225 4226 /* backing_file can either be relative, or absolute, or a protocol. If it is 4227 * relative, it must be relative to the chain. So, passing in bs->filename 4228 * from a BDS as backing_file should not be done, as that may be relative to 4229 * the CWD rather than the chain. */ 4230 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, 4231 const char *backing_file) 4232 { 4233 char *filename_full = NULL; 4234 char *backing_file_full = NULL; 4235 char *filename_tmp = NULL; 4236 int is_protocol = 0; 4237 BlockDriverState *curr_bs = NULL; 4238 BlockDriverState *retval = NULL; 4239 Error *local_error = NULL; 4240 4241 if (!bs || !bs->drv || !backing_file) { 4242 return NULL; 4243 } 4244 4245 filename_full = g_malloc(PATH_MAX); 4246 backing_file_full = g_malloc(PATH_MAX); 4247 filename_tmp = g_malloc(PATH_MAX); 4248 4249 is_protocol = path_has_protocol(backing_file); 4250 4251 for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) { 4252 4253 /* If either of the filename paths is actually a protocol, then 4254 * compare unmodified paths; otherwise make paths relative */ 4255 if (is_protocol || path_has_protocol(curr_bs->backing_file)) { 4256 if (strcmp(backing_file, curr_bs->backing_file) == 0) { 4257 retval = curr_bs->backing->bs; 4258 break; 4259 } 4260 /* Also check against the full backing filename for the image */ 4261 bdrv_get_full_backing_filename(curr_bs, backing_file_full, PATH_MAX, 4262 &local_error); 4263 if (local_error == NULL) { 4264 if (strcmp(backing_file, backing_file_full) == 0) { 4265 retval = curr_bs->backing->bs; 4266 break; 4267 } 4268 } else { 4269 error_free(local_error); 4270 local_error = NULL; 4271 } 4272 } else { 4273 /* If not an absolute filename path, make it relative to the current 4274 * image's filename path */ 4275 path_combine(filename_tmp, PATH_MAX, curr_bs->filename, 4276 backing_file); 4277 4278 /* We are going to compare absolute pathnames */ 4279 if (!realpath(filename_tmp, filename_full)) { 4280 continue; 4281 } 4282 4283 /* We need to make sure the backing filename we are comparing against 4284 * is relative to the current image filename (or absolute) */ 4285 path_combine(filename_tmp, PATH_MAX, curr_bs->filename, 4286 curr_bs->backing_file); 4287 4288 if (!realpath(filename_tmp, backing_file_full)) { 4289 continue; 4290 } 4291 4292 if (strcmp(backing_file_full, filename_full) == 0) { 4293 retval = curr_bs->backing->bs; 4294 break; 4295 } 4296 } 4297 } 4298 4299 g_free(filename_full); 4300 g_free(backing_file_full); 4301 g_free(filename_tmp); 4302 return retval; 4303 } 4304 4305 void bdrv_init(void) 4306 { 4307 module_call_init(MODULE_INIT_BLOCK); 4308 } 4309 4310 void bdrv_init_with_whitelist(void) 4311 { 4312 use_bdrv_whitelist = 1; 4313 bdrv_init(); 4314 } 4315 4316 static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, 4317 Error **errp) 4318 { 4319 BdrvChild *child, *parent; 4320 uint64_t perm, shared_perm; 4321 Error *local_err = NULL; 4322 int ret; 4323 4324 if (!bs->drv) { 4325 return; 4326 } 4327 4328 if (!(bs->open_flags & BDRV_O_INACTIVE)) { 4329 return; 4330 } 4331 4332 QLIST_FOREACH(child, &bs->children, next) { 4333 bdrv_co_invalidate_cache(child->bs, &local_err); 4334 if (local_err) { 4335 error_propagate(errp, local_err); 4336 return; 4337 } 4338 } 4339 4340 /* 4341 * Update permissions, they may differ for inactive nodes. 4342 * 4343 * Note that the required permissions of inactive images are always a 4344 * subset of the permissions required after activating the image. This 4345 * allows us to just get the permissions upfront without restricting 4346 * drv->bdrv_invalidate_cache(). 4347 * 4348 * It also means that in error cases, we don't have to try and revert to 4349 * the old permissions (which is an operation that could fail, too). We can 4350 * just keep the extended permissions for the next time that an activation 4351 * of the image is tried. 4352 */ 4353 bs->open_flags &= ~BDRV_O_INACTIVE; 4354 bdrv_get_cumulative_perm(bs, &perm, &shared_perm); 4355 ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &local_err); 4356 if (ret < 0) { 4357 bs->open_flags |= BDRV_O_INACTIVE; 4358 error_propagate(errp, local_err); 4359 return; 4360 } 4361 bdrv_set_perm(bs, perm, shared_perm); 4362 4363 if (bs->drv->bdrv_co_invalidate_cache) { 4364 bs->drv->bdrv_co_invalidate_cache(bs, &local_err); 4365 if (local_err) { 4366 bs->open_flags |= BDRV_O_INACTIVE; 4367 error_propagate(errp, local_err); 4368 return; 4369 } 4370 } 4371 4372 ret = refresh_total_sectors(bs, bs->total_sectors); 4373 if (ret < 0) { 4374 bs->open_flags |= BDRV_O_INACTIVE; 4375 error_setg_errno(errp, -ret, "Could not refresh total sector count"); 4376 return; 4377 } 4378 4379 QLIST_FOREACH(parent, &bs->parents, next_parent) { 4380 if (parent->role->activate) { 4381 parent->role->activate(parent, &local_err); 4382 if (local_err) { 4383 error_propagate(errp, local_err); 4384 return; 4385 } 4386 } 4387 } 4388 } 4389 4390 typedef struct InvalidateCacheCo { 4391 BlockDriverState *bs; 4392 Error **errp; 4393 bool done; 4394 } InvalidateCacheCo; 4395 4396 static void coroutine_fn bdrv_invalidate_cache_co_entry(void *opaque) 4397 { 4398 InvalidateCacheCo *ico = opaque; 4399 bdrv_co_invalidate_cache(ico->bs, ico->errp); 4400 ico->done = true; 4401 } 4402 4403 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 4404 { 4405 Coroutine *co; 4406 InvalidateCacheCo ico = { 4407 .bs = bs, 4408 .done = false, 4409 .errp = errp 4410 }; 4411 4412 if (qemu_in_coroutine()) { 4413 /* Fast-path if already in coroutine context */ 4414 bdrv_invalidate_cache_co_entry(&ico); 4415 } else { 4416 co = qemu_coroutine_create(bdrv_invalidate_cache_co_entry, &ico); 4417 qemu_coroutine_enter(co); 4418 BDRV_POLL_WHILE(bs, !ico.done); 4419 } 4420 } 4421 4422 void bdrv_invalidate_cache_all(Error **errp) 4423 { 4424 BlockDriverState *bs; 4425 Error *local_err = NULL; 4426 BdrvNextIterator it; 4427 4428 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { 4429 AioContext *aio_context = bdrv_get_aio_context(bs); 4430 4431 aio_context_acquire(aio_context); 4432 bdrv_invalidate_cache(bs, &local_err); 4433 aio_context_release(aio_context); 4434 if (local_err) { 4435 error_propagate(errp, local_err); 4436 bdrv_next_cleanup(&it); 4437 return; 4438 } 4439 } 4440 } 4441 4442 static int bdrv_inactivate_recurse(BlockDriverState *bs, 4443 bool setting_flag) 4444 { 4445 BdrvChild *child, *parent; 4446 int ret; 4447 4448 if (!bs->drv) { 4449 return -ENOMEDIUM; 4450 } 4451 4452 if (!setting_flag && bs->drv->bdrv_inactivate) { 4453 ret = bs->drv->bdrv_inactivate(bs); 4454 if (ret < 0) { 4455 return ret; 4456 } 4457 } 4458 4459 if (setting_flag && !(bs->open_flags & BDRV_O_INACTIVE)) { 4460 uint64_t perm, shared_perm; 4461 4462 QLIST_FOREACH(parent, &bs->parents, next_parent) { 4463 if (parent->role->inactivate) { 4464 ret = parent->role->inactivate(parent); 4465 if (ret < 0) { 4466 return ret; 4467 } 4468 } 4469 } 4470 4471 bs->open_flags |= BDRV_O_INACTIVE; 4472 4473 /* Update permissions, they may differ for inactive nodes */ 4474 bdrv_get_cumulative_perm(bs, &perm, &shared_perm); 4475 bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, &error_abort); 4476 bdrv_set_perm(bs, perm, shared_perm); 4477 } 4478 4479 QLIST_FOREACH(child, &bs->children, next) { 4480 ret = bdrv_inactivate_recurse(child->bs, setting_flag); 4481 if (ret < 0) { 4482 return ret; 4483 } 4484 } 4485 4486 /* At this point persistent bitmaps should be already stored by the format 4487 * driver */ 4488 bdrv_release_persistent_dirty_bitmaps(bs); 4489 4490 return 0; 4491 } 4492 4493 int bdrv_inactivate_all(void) 4494 { 4495 BlockDriverState *bs = NULL; 4496 BdrvNextIterator it; 4497 int ret = 0; 4498 int pass; 4499 GSList *aio_ctxs = NULL, *ctx; 4500 4501 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { 4502 AioContext *aio_context = bdrv_get_aio_context(bs); 4503 4504 if (!g_slist_find(aio_ctxs, aio_context)) { 4505 aio_ctxs = g_slist_prepend(aio_ctxs, aio_context); 4506 aio_context_acquire(aio_context); 4507 } 4508 } 4509 4510 /* We do two passes of inactivation. The first pass calls to drivers' 4511 * .bdrv_inactivate callbacks recursively so all cache is flushed to disk; 4512 * the second pass sets the BDRV_O_INACTIVE flag so that no further write 4513 * is allowed. */ 4514 for (pass = 0; pass < 2; pass++) { 4515 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { 4516 ret = bdrv_inactivate_recurse(bs, pass); 4517 if (ret < 0) { 4518 bdrv_next_cleanup(&it); 4519 goto out; 4520 } 4521 } 4522 } 4523 4524 out: 4525 for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) { 4526 AioContext *aio_context = ctx->data; 4527 aio_context_release(aio_context); 4528 } 4529 g_slist_free(aio_ctxs); 4530 4531 return ret; 4532 } 4533 4534 /**************************************************************/ 4535 /* removable device support */ 4536 4537 /** 4538 * Return TRUE if the media is present 4539 */ 4540 bool bdrv_is_inserted(BlockDriverState *bs) 4541 { 4542 BlockDriver *drv = bs->drv; 4543 BdrvChild *child; 4544 4545 if (!drv) { 4546 return false; 4547 } 4548 if (drv->bdrv_is_inserted) { 4549 return drv->bdrv_is_inserted(bs); 4550 } 4551 QLIST_FOREACH(child, &bs->children, next) { 4552 if (!bdrv_is_inserted(child->bs)) { 4553 return false; 4554 } 4555 } 4556 return true; 4557 } 4558 4559 /** 4560 * If eject_flag is TRUE, eject the media. Otherwise, close the tray 4561 */ 4562 void bdrv_eject(BlockDriverState *bs, bool eject_flag) 4563 { 4564 BlockDriver *drv = bs->drv; 4565 4566 if (drv && drv->bdrv_eject) { 4567 drv->bdrv_eject(bs, eject_flag); 4568 } 4569 } 4570 4571 /** 4572 * Lock or unlock the media (if it is locked, the user won't be able 4573 * to eject it manually). 4574 */ 4575 void bdrv_lock_medium(BlockDriverState *bs, bool locked) 4576 { 4577 BlockDriver *drv = bs->drv; 4578 4579 trace_bdrv_lock_medium(bs, locked); 4580 4581 if (drv && drv->bdrv_lock_medium) { 4582 drv->bdrv_lock_medium(bs, locked); 4583 } 4584 } 4585 4586 /* Get a reference to bs */ 4587 void bdrv_ref(BlockDriverState *bs) 4588 { 4589 bs->refcnt++; 4590 } 4591 4592 /* Release a previously grabbed reference to bs. 4593 * If after releasing, reference count is zero, the BlockDriverState is 4594 * deleted. */ 4595 void bdrv_unref(BlockDriverState *bs) 4596 { 4597 if (!bs) { 4598 return; 4599 } 4600 assert(bs->refcnt > 0); 4601 if (--bs->refcnt == 0) { 4602 bdrv_delete(bs); 4603 } 4604 } 4605 4606 struct BdrvOpBlocker { 4607 Error *reason; 4608 QLIST_ENTRY(BdrvOpBlocker) list; 4609 }; 4610 4611 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) 4612 { 4613 BdrvOpBlocker *blocker; 4614 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 4615 if (!QLIST_EMPTY(&bs->op_blockers[op])) { 4616 blocker = QLIST_FIRST(&bs->op_blockers[op]); 4617 error_propagate(errp, error_copy(blocker->reason)); 4618 error_prepend(errp, "Node '%s' is busy: ", 4619 bdrv_get_device_or_node_name(bs)); 4620 return true; 4621 } 4622 return false; 4623 } 4624 4625 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason) 4626 { 4627 BdrvOpBlocker *blocker; 4628 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 4629 4630 blocker = g_new0(BdrvOpBlocker, 1); 4631 blocker->reason = reason; 4632 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list); 4633 } 4634 4635 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason) 4636 { 4637 BdrvOpBlocker *blocker, *next; 4638 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 4639 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) { 4640 if (blocker->reason == reason) { 4641 QLIST_REMOVE(blocker, list); 4642 g_free(blocker); 4643 } 4644 } 4645 } 4646 4647 void bdrv_op_block_all(BlockDriverState *bs, Error *reason) 4648 { 4649 int i; 4650 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 4651 bdrv_op_block(bs, i, reason); 4652 } 4653 } 4654 4655 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason) 4656 { 4657 int i; 4658 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 4659 bdrv_op_unblock(bs, i, reason); 4660 } 4661 } 4662 4663 bool bdrv_op_blocker_is_empty(BlockDriverState *bs) 4664 { 4665 int i; 4666 4667 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 4668 if (!QLIST_EMPTY(&bs->op_blockers[i])) { 4669 return false; 4670 } 4671 } 4672 return true; 4673 } 4674 4675 void bdrv_img_create(const char *filename, const char *fmt, 4676 const char *base_filename, const char *base_fmt, 4677 char *options, uint64_t img_size, int flags, bool quiet, 4678 Error **errp) 4679 { 4680 QemuOptsList *create_opts = NULL; 4681 QemuOpts *opts = NULL; 4682 const char *backing_fmt, *backing_file; 4683 int64_t size; 4684 BlockDriver *drv, *proto_drv; 4685 Error *local_err = NULL; 4686 int ret = 0; 4687 4688 /* Find driver and parse its options */ 4689 drv = bdrv_find_format(fmt); 4690 if (!drv) { 4691 error_setg(errp, "Unknown file format '%s'", fmt); 4692 return; 4693 } 4694 4695 proto_drv = bdrv_find_protocol(filename, true, errp); 4696 if (!proto_drv) { 4697 return; 4698 } 4699 4700 if (!drv->create_opts) { 4701 error_setg(errp, "Format driver '%s' does not support image creation", 4702 drv->format_name); 4703 return; 4704 } 4705 4706 if (!proto_drv->create_opts) { 4707 error_setg(errp, "Protocol driver '%s' does not support image creation", 4708 proto_drv->format_name); 4709 return; 4710 } 4711 4712 create_opts = qemu_opts_append(create_opts, drv->create_opts); 4713 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); 4714 4715 /* Create parameter list with default values */ 4716 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 4717 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort); 4718 4719 /* Parse -o options */ 4720 if (options) { 4721 qemu_opts_do_parse(opts, options, NULL, &local_err); 4722 if (local_err) { 4723 error_report_err(local_err); 4724 local_err = NULL; 4725 error_setg(errp, "Invalid options for file format '%s'", fmt); 4726 goto out; 4727 } 4728 } 4729 4730 if (base_filename) { 4731 qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err); 4732 if (local_err) { 4733 error_setg(errp, "Backing file not supported for file format '%s'", 4734 fmt); 4735 goto out; 4736 } 4737 } 4738 4739 if (base_fmt) { 4740 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, &local_err); 4741 if (local_err) { 4742 error_setg(errp, "Backing file format not supported for file " 4743 "format '%s'", fmt); 4744 goto out; 4745 } 4746 } 4747 4748 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE); 4749 if (backing_file) { 4750 if (!strcmp(filename, backing_file)) { 4751 error_setg(errp, "Error: Trying to create an image with the " 4752 "same filename as the backing file"); 4753 goto out; 4754 } 4755 } 4756 4757 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT); 4758 4759 /* The size for the image must always be specified, unless we have a backing 4760 * file and we have not been forbidden from opening it. */ 4761 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size); 4762 if (backing_file && !(flags & BDRV_O_NO_BACKING)) { 4763 BlockDriverState *bs; 4764 char *full_backing = g_new0(char, PATH_MAX); 4765 int back_flags; 4766 QDict *backing_options = NULL; 4767 4768 bdrv_get_full_backing_filename_from_filename(filename, backing_file, 4769 full_backing, PATH_MAX, 4770 &local_err); 4771 if (local_err) { 4772 g_free(full_backing); 4773 goto out; 4774 } 4775 4776 /* backing files always opened read-only */ 4777 back_flags = flags; 4778 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); 4779 4780 backing_options = qdict_new(); 4781 if (backing_fmt) { 4782 qdict_put_str(backing_options, "driver", backing_fmt); 4783 } 4784 qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true); 4785 4786 bs = bdrv_open(full_backing, NULL, backing_options, back_flags, 4787 &local_err); 4788 g_free(full_backing); 4789 if (!bs && size != -1) { 4790 /* Couldn't open BS, but we have a size, so it's nonfatal */ 4791 warn_reportf_err(local_err, 4792 "Could not verify backing image. " 4793 "This may become an error in future versions.\n"); 4794 local_err = NULL; 4795 } else if (!bs) { 4796 /* Couldn't open bs, do not have size */ 4797 error_append_hint(&local_err, 4798 "Could not open backing image to determine size.\n"); 4799 goto out; 4800 } else { 4801 if (size == -1) { 4802 /* Opened BS, have no size */ 4803 size = bdrv_getlength(bs); 4804 if (size < 0) { 4805 error_setg_errno(errp, -size, "Could not get size of '%s'", 4806 backing_file); 4807 bdrv_unref(bs); 4808 goto out; 4809 } 4810 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort); 4811 } 4812 bdrv_unref(bs); 4813 } 4814 } /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */ 4815 4816 if (size == -1) { 4817 error_setg(errp, "Image creation needs a size parameter"); 4818 goto out; 4819 } 4820 4821 if (!quiet) { 4822 printf("Formatting '%s', fmt=%s ", filename, fmt); 4823 qemu_opts_print(opts, " "); 4824 puts(""); 4825 } 4826 4827 ret = bdrv_create(drv, filename, opts, &local_err); 4828 4829 if (ret == -EFBIG) { 4830 /* This is generally a better message than whatever the driver would 4831 * deliver (especially because of the cluster_size_hint), since that 4832 * is most probably not much different from "image too large". */ 4833 const char *cluster_size_hint = ""; 4834 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) { 4835 cluster_size_hint = " (try using a larger cluster size)"; 4836 } 4837 error_setg(errp, "The image size is too large for file format '%s'" 4838 "%s", fmt, cluster_size_hint); 4839 error_free(local_err); 4840 local_err = NULL; 4841 } 4842 4843 out: 4844 qemu_opts_del(opts); 4845 qemu_opts_free(create_opts); 4846 error_propagate(errp, local_err); 4847 } 4848 4849 AioContext *bdrv_get_aio_context(BlockDriverState *bs) 4850 { 4851 return bs ? bs->aio_context : qemu_get_aio_context(); 4852 } 4853 4854 AioWait *bdrv_get_aio_wait(BlockDriverState *bs) 4855 { 4856 return bs ? &bs->wait : NULL; 4857 } 4858 4859 void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co) 4860 { 4861 aio_co_enter(bdrv_get_aio_context(bs), co); 4862 } 4863 4864 static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban) 4865 { 4866 QLIST_REMOVE(ban, list); 4867 g_free(ban); 4868 } 4869 4870 void bdrv_detach_aio_context(BlockDriverState *bs) 4871 { 4872 BdrvAioNotifier *baf, *baf_tmp; 4873 BdrvChild *child; 4874 4875 if (!bs->drv) { 4876 return; 4877 } 4878 4879 assert(!bs->walking_aio_notifiers); 4880 bs->walking_aio_notifiers = true; 4881 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) { 4882 if (baf->deleted) { 4883 bdrv_do_remove_aio_context_notifier(baf); 4884 } else { 4885 baf->detach_aio_context(baf->opaque); 4886 } 4887 } 4888 /* Never mind iterating again to check for ->deleted. bdrv_close() will 4889 * remove remaining aio notifiers if we aren't called again. 4890 */ 4891 bs->walking_aio_notifiers = false; 4892 4893 if (bs->drv->bdrv_detach_aio_context) { 4894 bs->drv->bdrv_detach_aio_context(bs); 4895 } 4896 QLIST_FOREACH(child, &bs->children, next) { 4897 bdrv_detach_aio_context(child->bs); 4898 } 4899 4900 bs->aio_context = NULL; 4901 } 4902 4903 void bdrv_attach_aio_context(BlockDriverState *bs, 4904 AioContext *new_context) 4905 { 4906 BdrvAioNotifier *ban, *ban_tmp; 4907 BdrvChild *child; 4908 4909 if (!bs->drv) { 4910 return; 4911 } 4912 4913 bs->aio_context = new_context; 4914 4915 QLIST_FOREACH(child, &bs->children, next) { 4916 bdrv_attach_aio_context(child->bs, new_context); 4917 } 4918 if (bs->drv->bdrv_attach_aio_context) { 4919 bs->drv->bdrv_attach_aio_context(bs, new_context); 4920 } 4921 4922 assert(!bs->walking_aio_notifiers); 4923 bs->walking_aio_notifiers = true; 4924 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) { 4925 if (ban->deleted) { 4926 bdrv_do_remove_aio_context_notifier(ban); 4927 } else { 4928 ban->attached_aio_context(new_context, ban->opaque); 4929 } 4930 } 4931 bs->walking_aio_notifiers = false; 4932 } 4933 4934 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context) 4935 { 4936 AioContext *ctx = bdrv_get_aio_context(bs); 4937 4938 aio_disable_external(ctx); 4939 bdrv_parent_drained_begin(bs, NULL); 4940 bdrv_drain(bs); /* ensure there are no in-flight requests */ 4941 4942 while (aio_poll(ctx, false)) { 4943 /* wait for all bottom halves to execute */ 4944 } 4945 4946 bdrv_detach_aio_context(bs); 4947 4948 /* This function executes in the old AioContext so acquire the new one in 4949 * case it runs in a different thread. 4950 */ 4951 aio_context_acquire(new_context); 4952 bdrv_attach_aio_context(bs, new_context); 4953 bdrv_parent_drained_end(bs, NULL); 4954 aio_enable_external(ctx); 4955 aio_context_release(new_context); 4956 } 4957 4958 void bdrv_add_aio_context_notifier(BlockDriverState *bs, 4959 void (*attached_aio_context)(AioContext *new_context, void *opaque), 4960 void (*detach_aio_context)(void *opaque), void *opaque) 4961 { 4962 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1); 4963 *ban = (BdrvAioNotifier){ 4964 .attached_aio_context = attached_aio_context, 4965 .detach_aio_context = detach_aio_context, 4966 .opaque = opaque 4967 }; 4968 4969 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list); 4970 } 4971 4972 void bdrv_remove_aio_context_notifier(BlockDriverState *bs, 4973 void (*attached_aio_context)(AioContext *, 4974 void *), 4975 void (*detach_aio_context)(void *), 4976 void *opaque) 4977 { 4978 BdrvAioNotifier *ban, *ban_next; 4979 4980 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { 4981 if (ban->attached_aio_context == attached_aio_context && 4982 ban->detach_aio_context == detach_aio_context && 4983 ban->opaque == opaque && 4984 ban->deleted == false) 4985 { 4986 if (bs->walking_aio_notifiers) { 4987 ban->deleted = true; 4988 } else { 4989 bdrv_do_remove_aio_context_notifier(ban); 4990 } 4991 return; 4992 } 4993 } 4994 4995 abort(); 4996 } 4997 4998 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts, 4999 BlockDriverAmendStatusCB *status_cb, void *cb_opaque) 5000 { 5001 if (!bs->drv) { 5002 return -ENOMEDIUM; 5003 } 5004 if (!bs->drv->bdrv_amend_options) { 5005 return -ENOTSUP; 5006 } 5007 return bs->drv->bdrv_amend_options(bs, opts, status_cb, cb_opaque); 5008 } 5009 5010 /* This function will be called by the bdrv_recurse_is_first_non_filter method 5011 * of block filter and by bdrv_is_first_non_filter. 5012 * It is used to test if the given bs is the candidate or recurse more in the 5013 * node graph. 5014 */ 5015 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs, 5016 BlockDriverState *candidate) 5017 { 5018 /* return false if basic checks fails */ 5019 if (!bs || !bs->drv) { 5020 return false; 5021 } 5022 5023 /* the code reached a non block filter driver -> check if the bs is 5024 * the same as the candidate. It's the recursion termination condition. 5025 */ 5026 if (!bs->drv->is_filter) { 5027 return bs == candidate; 5028 } 5029 /* Down this path the driver is a block filter driver */ 5030 5031 /* If the block filter recursion method is defined use it to recurse down 5032 * the node graph. 5033 */ 5034 if (bs->drv->bdrv_recurse_is_first_non_filter) { 5035 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate); 5036 } 5037 5038 /* the driver is a block filter but don't allow to recurse -> return false 5039 */ 5040 return false; 5041 } 5042 5043 /* This function checks if the candidate is the first non filter bs down it's 5044 * bs chain. Since we don't have pointers to parents it explore all bs chains 5045 * from the top. Some filters can choose not to pass down the recursion. 5046 */ 5047 bool bdrv_is_first_non_filter(BlockDriverState *candidate) 5048 { 5049 BlockDriverState *bs; 5050 BdrvNextIterator it; 5051 5052 /* walk down the bs forest recursively */ 5053 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { 5054 bool perm; 5055 5056 /* try to recurse in this top level bs */ 5057 perm = bdrv_recurse_is_first_non_filter(bs, candidate); 5058 5059 /* candidate is the first non filter */ 5060 if (perm) { 5061 bdrv_next_cleanup(&it); 5062 return true; 5063 } 5064 } 5065 5066 return false; 5067 } 5068 5069 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs, 5070 const char *node_name, Error **errp) 5071 { 5072 BlockDriverState *to_replace_bs = bdrv_find_node(node_name); 5073 AioContext *aio_context; 5074 5075 if (!to_replace_bs) { 5076 error_setg(errp, "Node name '%s' not found", node_name); 5077 return NULL; 5078 } 5079 5080 aio_context = bdrv_get_aio_context(to_replace_bs); 5081 aio_context_acquire(aio_context); 5082 5083 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) { 5084 to_replace_bs = NULL; 5085 goto out; 5086 } 5087 5088 /* We don't want arbitrary node of the BDS chain to be replaced only the top 5089 * most non filter in order to prevent data corruption. 5090 * Another benefit is that this tests exclude backing files which are 5091 * blocked by the backing blockers. 5092 */ 5093 if (!bdrv_recurse_is_first_non_filter(parent_bs, to_replace_bs)) { 5094 error_setg(errp, "Only top most non filter can be replaced"); 5095 to_replace_bs = NULL; 5096 goto out; 5097 } 5098 5099 out: 5100 aio_context_release(aio_context); 5101 return to_replace_bs; 5102 } 5103 5104 static bool append_open_options(QDict *d, BlockDriverState *bs) 5105 { 5106 const QDictEntry *entry; 5107 QemuOptDesc *desc; 5108 BdrvChild *child; 5109 bool found_any = false; 5110 const char *p; 5111 5112 for (entry = qdict_first(bs->options); entry; 5113 entry = qdict_next(bs->options, entry)) 5114 { 5115 /* Exclude options for children */ 5116 QLIST_FOREACH(child, &bs->children, next) { 5117 if (strstart(qdict_entry_key(entry), child->name, &p) 5118 && (!*p || *p == '.')) 5119 { 5120 break; 5121 } 5122 } 5123 if (child) { 5124 continue; 5125 } 5126 5127 /* And exclude all non-driver-specific options */ 5128 for (desc = bdrv_runtime_opts.desc; desc->name; desc++) { 5129 if (!strcmp(qdict_entry_key(entry), desc->name)) { 5130 break; 5131 } 5132 } 5133 if (desc->name) { 5134 continue; 5135 } 5136 5137 qobject_incref(qdict_entry_value(entry)); 5138 qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry)); 5139 found_any = true; 5140 } 5141 5142 return found_any; 5143 } 5144 5145 /* Updates the following BDS fields: 5146 * - exact_filename: A filename which may be used for opening a block device 5147 * which (mostly) equals the given BDS (even without any 5148 * other options; so reading and writing must return the same 5149 * results, but caching etc. may be different) 5150 * - full_open_options: Options which, when given when opening a block device 5151 * (without a filename), result in a BDS (mostly) 5152 * equalling the given one 5153 * - filename: If exact_filename is set, it is copied here. Otherwise, 5154 * full_open_options is converted to a JSON object, prefixed with 5155 * "json:" (for use through the JSON pseudo protocol) and put here. 5156 */ 5157 void bdrv_refresh_filename(BlockDriverState *bs) 5158 { 5159 BlockDriver *drv = bs->drv; 5160 QDict *opts; 5161 5162 if (!drv) { 5163 return; 5164 } 5165 5166 /* This BDS's file name will most probably depend on its file's name, so 5167 * refresh that first */ 5168 if (bs->file) { 5169 bdrv_refresh_filename(bs->file->bs); 5170 } 5171 5172 if (drv->bdrv_refresh_filename) { 5173 /* Obsolete information is of no use here, so drop the old file name 5174 * information before refreshing it */ 5175 bs->exact_filename[0] = '\0'; 5176 if (bs->full_open_options) { 5177 QDECREF(bs->full_open_options); 5178 bs->full_open_options = NULL; 5179 } 5180 5181 opts = qdict_new(); 5182 append_open_options(opts, bs); 5183 drv->bdrv_refresh_filename(bs, opts); 5184 QDECREF(opts); 5185 } else if (bs->file) { 5186 /* Try to reconstruct valid information from the underlying file */ 5187 bool has_open_options; 5188 5189 bs->exact_filename[0] = '\0'; 5190 if (bs->full_open_options) { 5191 QDECREF(bs->full_open_options); 5192 bs->full_open_options = NULL; 5193 } 5194 5195 opts = qdict_new(); 5196 has_open_options = append_open_options(opts, bs); 5197 5198 /* If no specific options have been given for this BDS, the filename of 5199 * the underlying file should suffice for this one as well */ 5200 if (bs->file->bs->exact_filename[0] && !has_open_options) { 5201 strcpy(bs->exact_filename, bs->file->bs->exact_filename); 5202 } 5203 /* Reconstructing the full options QDict is simple for most format block 5204 * drivers, as long as the full options are known for the underlying 5205 * file BDS. The full options QDict of that file BDS should somehow 5206 * contain a representation of the filename, therefore the following 5207 * suffices without querying the (exact_)filename of this BDS. */ 5208 if (bs->file->bs->full_open_options) { 5209 qdict_put_str(opts, "driver", drv->format_name); 5210 QINCREF(bs->file->bs->full_open_options); 5211 qdict_put(opts, "file", bs->file->bs->full_open_options); 5212 5213 bs->full_open_options = opts; 5214 } else { 5215 QDECREF(opts); 5216 } 5217 } else if (!bs->full_open_options && qdict_size(bs->options)) { 5218 /* There is no underlying file BDS (at least referenced by BDS.file), 5219 * so the full options QDict should be equal to the options given 5220 * specifically for this block device when it was opened (plus the 5221 * driver specification). 5222 * Because those options don't change, there is no need to update 5223 * full_open_options when it's already set. */ 5224 5225 opts = qdict_new(); 5226 append_open_options(opts, bs); 5227 qdict_put_str(opts, "driver", drv->format_name); 5228 5229 if (bs->exact_filename[0]) { 5230 /* This may not work for all block protocol drivers (some may 5231 * require this filename to be parsed), but we have to find some 5232 * default solution here, so just include it. If some block driver 5233 * does not support pure options without any filename at all or 5234 * needs some special format of the options QDict, it needs to 5235 * implement the driver-specific bdrv_refresh_filename() function. 5236 */ 5237 qdict_put_str(opts, "filename", bs->exact_filename); 5238 } 5239 5240 bs->full_open_options = opts; 5241 } 5242 5243 if (bs->exact_filename[0]) { 5244 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename); 5245 } else if (bs->full_open_options) { 5246 QString *json = qobject_to_json(QOBJECT(bs->full_open_options)); 5247 snprintf(bs->filename, sizeof(bs->filename), "json:%s", 5248 qstring_get_str(json)); 5249 QDECREF(json); 5250 } 5251 } 5252 5253 /* 5254 * Hot add/remove a BDS's child. So the user can take a child offline when 5255 * it is broken and take a new child online 5256 */ 5257 void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs, 5258 Error **errp) 5259 { 5260 5261 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) { 5262 error_setg(errp, "The node %s does not support adding a child", 5263 bdrv_get_device_or_node_name(parent_bs)); 5264 return; 5265 } 5266 5267 if (!QLIST_EMPTY(&child_bs->parents)) { 5268 error_setg(errp, "The node %s already has a parent", 5269 child_bs->node_name); 5270 return; 5271 } 5272 5273 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp); 5274 } 5275 5276 void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp) 5277 { 5278 BdrvChild *tmp; 5279 5280 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) { 5281 error_setg(errp, "The node %s does not support removing a child", 5282 bdrv_get_device_or_node_name(parent_bs)); 5283 return; 5284 } 5285 5286 QLIST_FOREACH(tmp, &parent_bs->children, next) { 5287 if (tmp == child) { 5288 break; 5289 } 5290 } 5291 5292 if (!tmp) { 5293 error_setg(errp, "The node %s does not have a child named %s", 5294 bdrv_get_device_or_node_name(parent_bs), 5295 bdrv_get_device_or_node_name(child->bs)); 5296 return; 5297 } 5298 5299 parent_bs->drv->bdrv_del_child(parent_bs, child, errp); 5300 } 5301 5302 bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name, 5303 uint32_t granularity, Error **errp) 5304 { 5305 BlockDriver *drv = bs->drv; 5306 5307 if (!drv) { 5308 error_setg_errno(errp, ENOMEDIUM, 5309 "Can't store persistent bitmaps to %s", 5310 bdrv_get_device_or_node_name(bs)); 5311 return false; 5312 } 5313 5314 if (!drv->bdrv_can_store_new_dirty_bitmap) { 5315 error_setg_errno(errp, ENOTSUP, 5316 "Can't store persistent bitmaps to %s", 5317 bdrv_get_device_or_node_name(bs)); 5318 return false; 5319 } 5320 5321 return drv->bdrv_can_store_new_dirty_bitmap(bs, name, granularity, errp); 5322 } 5323