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 "block/qdict.h" 31 #include "qemu/error-report.h" 32 #include "block/module_block.h" 33 #include "qemu/main-loop.h" 34 #include "qemu/module.h" 35 #include "qapi/error.h" 36 #include "qapi/qmp/qdict.h" 37 #include "qapi/qmp/qjson.h" 38 #include "qapi/qmp/qnull.h" 39 #include "qapi/qmp/qstring.h" 40 #include "qapi/qobject-output-visitor.h" 41 #include "qapi/qapi-visit-block-core.h" 42 #include "sysemu/block-backend.h" 43 #include "sysemu/sysemu.h" 44 #include "qemu/notify.h" 45 #include "qemu/option.h" 46 #include "qemu/coroutine.h" 47 #include "block/qapi.h" 48 #include "qemu/timer.h" 49 #include "qemu/cutils.h" 50 #include "qemu/id.h" 51 52 #ifdef CONFIG_BSD 53 #include <sys/ioctl.h> 54 #include <sys/queue.h> 55 #ifndef __DragonFly__ 56 #include <sys/disk.h> 57 #endif 58 #endif 59 60 #ifdef _WIN32 61 #include <windows.h> 62 #endif 63 64 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ 65 66 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states = 67 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states); 68 69 static QTAILQ_HEAD(, BlockDriverState) all_bdrv_states = 70 QTAILQ_HEAD_INITIALIZER(all_bdrv_states); 71 72 static QLIST_HEAD(, BlockDriver) bdrv_drivers = 73 QLIST_HEAD_INITIALIZER(bdrv_drivers); 74 75 static BlockDriverState *bdrv_open_inherit(const char *filename, 76 const char *reference, 77 QDict *options, int flags, 78 BlockDriverState *parent, 79 const BdrvChildClass *child_class, 80 BdrvChildRole child_role, 81 Error **errp); 82 83 /* If non-zero, use only whitelisted block drivers */ 84 static int use_bdrv_whitelist; 85 86 #ifdef _WIN32 87 static int is_windows_drive_prefix(const char *filename) 88 { 89 return (((filename[0] >= 'a' && filename[0] <= 'z') || 90 (filename[0] >= 'A' && filename[0] <= 'Z')) && 91 filename[1] == ':'); 92 } 93 94 int is_windows_drive(const char *filename) 95 { 96 if (is_windows_drive_prefix(filename) && 97 filename[2] == '\0') 98 return 1; 99 if (strstart(filename, "\\\\.\\", NULL) || 100 strstart(filename, "//./", NULL)) 101 return 1; 102 return 0; 103 } 104 #endif 105 106 size_t bdrv_opt_mem_align(BlockDriverState *bs) 107 { 108 if (!bs || !bs->drv) { 109 /* page size or 4k (hdd sector size) should be on the safe side */ 110 return MAX(4096, qemu_real_host_page_size); 111 } 112 113 return bs->bl.opt_mem_alignment; 114 } 115 116 size_t bdrv_min_mem_align(BlockDriverState *bs) 117 { 118 if (!bs || !bs->drv) { 119 /* page size or 4k (hdd sector size) should be on the safe side */ 120 return MAX(4096, qemu_real_host_page_size); 121 } 122 123 return bs->bl.min_mem_alignment; 124 } 125 126 /* check if the path starts with "<protocol>:" */ 127 int path_has_protocol(const char *path) 128 { 129 const char *p; 130 131 #ifdef _WIN32 132 if (is_windows_drive(path) || 133 is_windows_drive_prefix(path)) { 134 return 0; 135 } 136 p = path + strcspn(path, ":/\\"); 137 #else 138 p = path + strcspn(path, ":/"); 139 #endif 140 141 return *p == ':'; 142 } 143 144 int path_is_absolute(const char *path) 145 { 146 #ifdef _WIN32 147 /* specific case for names like: "\\.\d:" */ 148 if (is_windows_drive(path) || is_windows_drive_prefix(path)) { 149 return 1; 150 } 151 return (*path == '/' || *path == '\\'); 152 #else 153 return (*path == '/'); 154 #endif 155 } 156 157 /* if filename is absolute, just return its duplicate. Otherwise, build a 158 path to it by considering it is relative to base_path. URL are 159 supported. */ 160 char *path_combine(const char *base_path, const char *filename) 161 { 162 const char *protocol_stripped = NULL; 163 const char *p, *p1; 164 char *result; 165 int len; 166 167 if (path_is_absolute(filename)) { 168 return g_strdup(filename); 169 } 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 } 188 #endif 189 if (p1) { 190 p1++; 191 } else { 192 p1 = base_path; 193 } 194 if (p1 > p) { 195 p = p1; 196 } 197 len = p - base_path; 198 199 result = g_malloc(len + strlen(filename) + 1); 200 memcpy(result, base_path, len); 201 strcpy(result + len, filename); 202 203 return result; 204 } 205 206 /* 207 * Helper function for bdrv_parse_filename() implementations to remove optional 208 * protocol prefixes (especially "file:") from a filename and for putting the 209 * stripped filename into the options QDict if there is such a prefix. 210 */ 211 void bdrv_parse_filename_strip_prefix(const char *filename, const char *prefix, 212 QDict *options) 213 { 214 if (strstart(filename, prefix, &filename)) { 215 /* Stripping the explicit protocol prefix may result in a protocol 216 * prefix being (wrongly) detected (if the filename contains a colon) */ 217 if (path_has_protocol(filename)) { 218 QString *fat_filename; 219 220 /* This means there is some colon before the first slash; therefore, 221 * this cannot be an absolute path */ 222 assert(!path_is_absolute(filename)); 223 224 /* And we can thus fix the protocol detection issue by prefixing it 225 * by "./" */ 226 fat_filename = qstring_from_str("./"); 227 qstring_append(fat_filename, filename); 228 229 assert(!path_has_protocol(qstring_get_str(fat_filename))); 230 231 qdict_put(options, "filename", fat_filename); 232 } else { 233 /* If no protocol prefix was detected, we can use the shortened 234 * filename as-is */ 235 qdict_put_str(options, "filename", filename); 236 } 237 } 238 } 239 240 241 /* Returns whether the image file is opened as read-only. Note that this can 242 * return false and writing to the image file is still not possible because the 243 * image is inactivated. */ 244 bool bdrv_is_read_only(BlockDriverState *bs) 245 { 246 return bs->read_only; 247 } 248 249 int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, 250 bool ignore_allow_rdw, Error **errp) 251 { 252 /* Do not set read_only if copy_on_read is enabled */ 253 if (bs->copy_on_read && read_only) { 254 error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled", 255 bdrv_get_device_or_node_name(bs)); 256 return -EINVAL; 257 } 258 259 /* Do not clear read_only if it is prohibited */ 260 if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) && 261 !ignore_allow_rdw) 262 { 263 error_setg(errp, "Node '%s' is read only", 264 bdrv_get_device_or_node_name(bs)); 265 return -EPERM; 266 } 267 268 return 0; 269 } 270 271 /* 272 * Called by a driver that can only provide a read-only image. 273 * 274 * Returns 0 if the node is already read-only or it could switch the node to 275 * read-only because BDRV_O_AUTO_RDONLY is set. 276 * 277 * Returns -EACCES if the node is read-write and BDRV_O_AUTO_RDONLY is not set 278 * or bdrv_can_set_read_only() forbids making the node read-only. If @errmsg 279 * is not NULL, it is used as the error message for the Error object. 280 */ 281 int bdrv_apply_auto_read_only(BlockDriverState *bs, const char *errmsg, 282 Error **errp) 283 { 284 int ret = 0; 285 286 if (!(bs->open_flags & BDRV_O_RDWR)) { 287 return 0; 288 } 289 if (!(bs->open_flags & BDRV_O_AUTO_RDONLY)) { 290 goto fail; 291 } 292 293 ret = bdrv_can_set_read_only(bs, true, false, NULL); 294 if (ret < 0) { 295 goto fail; 296 } 297 298 bs->read_only = true; 299 bs->open_flags &= ~BDRV_O_RDWR; 300 301 return 0; 302 303 fail: 304 error_setg(errp, "%s", errmsg ?: "Image is read-only"); 305 return -EACCES; 306 } 307 308 /* 309 * If @backing is empty, this function returns NULL without setting 310 * @errp. In all other cases, NULL will only be returned with @errp 311 * set. 312 * 313 * Therefore, a return value of NULL without @errp set means that 314 * there is no backing file; if @errp is set, there is one but its 315 * absolute filename cannot be generated. 316 */ 317 char *bdrv_get_full_backing_filename_from_filename(const char *backed, 318 const char *backing, 319 Error **errp) 320 { 321 if (backing[0] == '\0') { 322 return NULL; 323 } else if (path_has_protocol(backing) || path_is_absolute(backing)) { 324 return g_strdup(backing); 325 } else if (backed[0] == '\0' || strstart(backed, "json:", NULL)) { 326 error_setg(errp, "Cannot use relative backing file names for '%s'", 327 backed); 328 return NULL; 329 } else { 330 return path_combine(backed, backing); 331 } 332 } 333 334 /* 335 * If @filename is empty or NULL, this function returns NULL without 336 * setting @errp. In all other cases, NULL will only be returned with 337 * @errp set. 338 */ 339 static char *bdrv_make_absolute_filename(BlockDriverState *relative_to, 340 const char *filename, Error **errp) 341 { 342 char *dir, *full_name; 343 344 if (!filename || filename[0] == '\0') { 345 return NULL; 346 } else if (path_has_protocol(filename) || path_is_absolute(filename)) { 347 return g_strdup(filename); 348 } 349 350 dir = bdrv_dirname(relative_to, errp); 351 if (!dir) { 352 return NULL; 353 } 354 355 full_name = g_strconcat(dir, filename, NULL); 356 g_free(dir); 357 return full_name; 358 } 359 360 char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp) 361 { 362 return bdrv_make_absolute_filename(bs, bs->backing_file, errp); 363 } 364 365 void bdrv_register(BlockDriver *bdrv) 366 { 367 assert(bdrv->format_name); 368 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list); 369 } 370 371 BlockDriverState *bdrv_new(void) 372 { 373 BlockDriverState *bs; 374 int i; 375 376 bs = g_new0(BlockDriverState, 1); 377 QLIST_INIT(&bs->dirty_bitmaps); 378 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 379 QLIST_INIT(&bs->op_blockers[i]); 380 } 381 notifier_with_return_list_init(&bs->before_write_notifiers); 382 qemu_co_mutex_init(&bs->reqs_lock); 383 qemu_mutex_init(&bs->dirty_bitmap_mutex); 384 bs->refcnt = 1; 385 bs->aio_context = qemu_get_aio_context(); 386 387 qemu_co_queue_init(&bs->flush_queue); 388 389 for (i = 0; i < bdrv_drain_all_count; i++) { 390 bdrv_drained_begin(bs); 391 } 392 393 QTAILQ_INSERT_TAIL(&all_bdrv_states, bs, bs_list); 394 395 return bs; 396 } 397 398 static BlockDriver *bdrv_do_find_format(const char *format_name) 399 { 400 BlockDriver *drv1; 401 402 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 403 if (!strcmp(drv1->format_name, format_name)) { 404 return drv1; 405 } 406 } 407 408 return NULL; 409 } 410 411 BlockDriver *bdrv_find_format(const char *format_name) 412 { 413 BlockDriver *drv1; 414 int i; 415 416 drv1 = bdrv_do_find_format(format_name); 417 if (drv1) { 418 return drv1; 419 } 420 421 /* The driver isn't registered, maybe we need to load a module */ 422 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) { 423 if (!strcmp(block_driver_modules[i].format_name, format_name)) { 424 block_module_load_one(block_driver_modules[i].library_name); 425 break; 426 } 427 } 428 429 return bdrv_do_find_format(format_name); 430 } 431 432 static int bdrv_format_is_whitelisted(const char *format_name, bool read_only) 433 { 434 static const char *whitelist_rw[] = { 435 CONFIG_BDRV_RW_WHITELIST 436 NULL 437 }; 438 static const char *whitelist_ro[] = { 439 CONFIG_BDRV_RO_WHITELIST 440 NULL 441 }; 442 const char **p; 443 444 if (!whitelist_rw[0] && !whitelist_ro[0]) { 445 return 1; /* no whitelist, anything goes */ 446 } 447 448 for (p = whitelist_rw; *p; p++) { 449 if (!strcmp(format_name, *p)) { 450 return 1; 451 } 452 } 453 if (read_only) { 454 for (p = whitelist_ro; *p; p++) { 455 if (!strcmp(format_name, *p)) { 456 return 1; 457 } 458 } 459 } 460 return 0; 461 } 462 463 int bdrv_is_whitelisted(BlockDriver *drv, bool read_only) 464 { 465 return bdrv_format_is_whitelisted(drv->format_name, read_only); 466 } 467 468 bool bdrv_uses_whitelist(void) 469 { 470 return use_bdrv_whitelist; 471 } 472 473 typedef struct CreateCo { 474 BlockDriver *drv; 475 char *filename; 476 QemuOpts *opts; 477 int ret; 478 Error *err; 479 } CreateCo; 480 481 static void coroutine_fn bdrv_create_co_entry(void *opaque) 482 { 483 Error *local_err = NULL; 484 int ret; 485 486 CreateCo *cco = opaque; 487 assert(cco->drv); 488 489 ret = cco->drv->bdrv_co_create_opts(cco->drv, 490 cco->filename, cco->opts, &local_err); 491 error_propagate(&cco->err, local_err); 492 cco->ret = ret; 493 } 494 495 int bdrv_create(BlockDriver *drv, const char* filename, 496 QemuOpts *opts, Error **errp) 497 { 498 int ret; 499 500 Coroutine *co; 501 CreateCo cco = { 502 .drv = drv, 503 .filename = g_strdup(filename), 504 .opts = opts, 505 .ret = NOT_DONE, 506 .err = NULL, 507 }; 508 509 if (!drv->bdrv_co_create_opts) { 510 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name); 511 ret = -ENOTSUP; 512 goto out; 513 } 514 515 if (qemu_in_coroutine()) { 516 /* Fast-path if already in coroutine context */ 517 bdrv_create_co_entry(&cco); 518 } else { 519 co = qemu_coroutine_create(bdrv_create_co_entry, &cco); 520 qemu_coroutine_enter(co); 521 while (cco.ret == NOT_DONE) { 522 aio_poll(qemu_get_aio_context(), true); 523 } 524 } 525 526 ret = cco.ret; 527 if (ret < 0) { 528 if (cco.err) { 529 error_propagate(errp, cco.err); 530 } else { 531 error_setg_errno(errp, -ret, "Could not create image"); 532 } 533 } 534 535 out: 536 g_free(cco.filename); 537 return ret; 538 } 539 540 /** 541 * Helper function for bdrv_create_file_fallback(): Resize @blk to at 542 * least the given @minimum_size. 543 * 544 * On success, return @blk's actual length. 545 * Otherwise, return -errno. 546 */ 547 static int64_t create_file_fallback_truncate(BlockBackend *blk, 548 int64_t minimum_size, Error **errp) 549 { 550 Error *local_err = NULL; 551 int64_t size; 552 int ret; 553 554 ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0, 555 &local_err); 556 if (ret < 0 && ret != -ENOTSUP) { 557 error_propagate(errp, local_err); 558 return ret; 559 } 560 561 size = blk_getlength(blk); 562 if (size < 0) { 563 error_free(local_err); 564 error_setg_errno(errp, -size, 565 "Failed to inquire the new image file's length"); 566 return size; 567 } 568 569 if (size < minimum_size) { 570 /* Need to grow the image, but we failed to do that */ 571 error_propagate(errp, local_err); 572 return -ENOTSUP; 573 } 574 575 error_free(local_err); 576 local_err = NULL; 577 578 return size; 579 } 580 581 /** 582 * Helper function for bdrv_create_file_fallback(): Zero the first 583 * sector to remove any potentially pre-existing image header. 584 */ 585 static int create_file_fallback_zero_first_sector(BlockBackend *blk, 586 int64_t current_size, 587 Error **errp) 588 { 589 int64_t bytes_to_clear; 590 int ret; 591 592 bytes_to_clear = MIN(current_size, BDRV_SECTOR_SIZE); 593 if (bytes_to_clear) { 594 ret = blk_pwrite_zeroes(blk, 0, bytes_to_clear, BDRV_REQ_MAY_UNMAP); 595 if (ret < 0) { 596 error_setg_errno(errp, -ret, 597 "Failed to clear the new image's first sector"); 598 return ret; 599 } 600 } 601 602 return 0; 603 } 604 605 /** 606 * Simple implementation of bdrv_co_create_opts for protocol drivers 607 * which only support creation via opening a file 608 * (usually existing raw storage device) 609 */ 610 int coroutine_fn bdrv_co_create_opts_simple(BlockDriver *drv, 611 const char *filename, 612 QemuOpts *opts, 613 Error **errp) 614 { 615 BlockBackend *blk; 616 QDict *options; 617 int64_t size = 0; 618 char *buf = NULL; 619 PreallocMode prealloc; 620 Error *local_err = NULL; 621 int ret; 622 623 size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0); 624 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); 625 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf, 626 PREALLOC_MODE_OFF, &local_err); 627 g_free(buf); 628 if (local_err) { 629 error_propagate(errp, local_err); 630 return -EINVAL; 631 } 632 633 if (prealloc != PREALLOC_MODE_OFF) { 634 error_setg(errp, "Unsupported preallocation mode '%s'", 635 PreallocMode_str(prealloc)); 636 return -ENOTSUP; 637 } 638 639 options = qdict_new(); 640 qdict_put_str(options, "driver", drv->format_name); 641 642 blk = blk_new_open(filename, NULL, options, 643 BDRV_O_RDWR | BDRV_O_RESIZE, errp); 644 if (!blk) { 645 error_prepend(errp, "Protocol driver '%s' does not support image " 646 "creation, and opening the image failed: ", 647 drv->format_name); 648 return -EINVAL; 649 } 650 651 size = create_file_fallback_truncate(blk, size, errp); 652 if (size < 0) { 653 ret = size; 654 goto out; 655 } 656 657 ret = create_file_fallback_zero_first_sector(blk, size, errp); 658 if (ret < 0) { 659 goto out; 660 } 661 662 ret = 0; 663 out: 664 blk_unref(blk); 665 return ret; 666 } 667 668 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp) 669 { 670 BlockDriver *drv; 671 672 drv = bdrv_find_protocol(filename, true, errp); 673 if (drv == NULL) { 674 return -ENOENT; 675 } 676 677 return bdrv_create(drv, filename, opts, errp); 678 } 679 680 int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp) 681 { 682 Error *local_err = NULL; 683 int ret; 684 685 assert(bs != NULL); 686 687 if (!bs->drv) { 688 error_setg(errp, "Block node '%s' is not opened", bs->filename); 689 return -ENOMEDIUM; 690 } 691 692 if (!bs->drv->bdrv_co_delete_file) { 693 error_setg(errp, "Driver '%s' does not support image deletion", 694 bs->drv->format_name); 695 return -ENOTSUP; 696 } 697 698 ret = bs->drv->bdrv_co_delete_file(bs, &local_err); 699 if (ret < 0) { 700 error_propagate(errp, local_err); 701 } 702 703 return ret; 704 } 705 706 /** 707 * Try to get @bs's logical and physical block size. 708 * On success, store them in @bsz struct and return 0. 709 * On failure return -errno. 710 * @bs must not be empty. 711 */ 712 int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz) 713 { 714 BlockDriver *drv = bs->drv; 715 BlockDriverState *filtered = bdrv_filter_bs(bs); 716 717 if (drv && drv->bdrv_probe_blocksizes) { 718 return drv->bdrv_probe_blocksizes(bs, bsz); 719 } else if (filtered) { 720 return bdrv_probe_blocksizes(filtered, bsz); 721 } 722 723 return -ENOTSUP; 724 } 725 726 /** 727 * Try to get @bs's geometry (cyls, heads, sectors). 728 * On success, store them in @geo struct and return 0. 729 * On failure return -errno. 730 * @bs must not be empty. 731 */ 732 int bdrv_probe_geometry(BlockDriverState *bs, HDGeometry *geo) 733 { 734 BlockDriver *drv = bs->drv; 735 BlockDriverState *filtered = bdrv_filter_bs(bs); 736 737 if (drv && drv->bdrv_probe_geometry) { 738 return drv->bdrv_probe_geometry(bs, geo); 739 } else if (filtered) { 740 return bdrv_probe_geometry(filtered, geo); 741 } 742 743 return -ENOTSUP; 744 } 745 746 /* 747 * Create a uniquely-named empty temporary file. 748 * Return 0 upon success, otherwise a negative errno value. 749 */ 750 int get_tmp_filename(char *filename, int size) 751 { 752 #ifdef _WIN32 753 char temp_dir[MAX_PATH]; 754 /* GetTempFileName requires that its output buffer (4th param) 755 have length MAX_PATH or greater. */ 756 assert(size >= MAX_PATH); 757 return (GetTempPath(MAX_PATH, temp_dir) 758 && GetTempFileName(temp_dir, "qem", 0, filename) 759 ? 0 : -GetLastError()); 760 #else 761 int fd; 762 const char *tmpdir; 763 tmpdir = getenv("TMPDIR"); 764 if (!tmpdir) { 765 tmpdir = "/var/tmp"; 766 } 767 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) { 768 return -EOVERFLOW; 769 } 770 fd = mkstemp(filename); 771 if (fd < 0) { 772 return -errno; 773 } 774 if (close(fd) != 0) { 775 unlink(filename); 776 return -errno; 777 } 778 return 0; 779 #endif 780 } 781 782 /* 783 * Detect host devices. By convention, /dev/cdrom[N] is always 784 * recognized as a host CDROM. 785 */ 786 static BlockDriver *find_hdev_driver(const char *filename) 787 { 788 int score_max = 0, score; 789 BlockDriver *drv = NULL, *d; 790 791 QLIST_FOREACH(d, &bdrv_drivers, list) { 792 if (d->bdrv_probe_device) { 793 score = d->bdrv_probe_device(filename); 794 if (score > score_max) { 795 score_max = score; 796 drv = d; 797 } 798 } 799 } 800 801 return drv; 802 } 803 804 static BlockDriver *bdrv_do_find_protocol(const char *protocol) 805 { 806 BlockDriver *drv1; 807 808 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 809 if (drv1->protocol_name && !strcmp(drv1->protocol_name, protocol)) { 810 return drv1; 811 } 812 } 813 814 return NULL; 815 } 816 817 BlockDriver *bdrv_find_protocol(const char *filename, 818 bool allow_protocol_prefix, 819 Error **errp) 820 { 821 BlockDriver *drv1; 822 char protocol[128]; 823 int len; 824 const char *p; 825 int i; 826 827 /* TODO Drivers without bdrv_file_open must be specified explicitly */ 828 829 /* 830 * XXX(hch): we really should not let host device detection 831 * override an explicit protocol specification, but moving this 832 * later breaks access to device names with colons in them. 833 * Thanks to the brain-dead persistent naming schemes on udev- 834 * based Linux systems those actually are quite common. 835 */ 836 drv1 = find_hdev_driver(filename); 837 if (drv1) { 838 return drv1; 839 } 840 841 if (!path_has_protocol(filename) || !allow_protocol_prefix) { 842 return &bdrv_file; 843 } 844 845 p = strchr(filename, ':'); 846 assert(p != NULL); 847 len = p - filename; 848 if (len > sizeof(protocol) - 1) 849 len = sizeof(protocol) - 1; 850 memcpy(protocol, filename, len); 851 protocol[len] = '\0'; 852 853 drv1 = bdrv_do_find_protocol(protocol); 854 if (drv1) { 855 return drv1; 856 } 857 858 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); ++i) { 859 if (block_driver_modules[i].protocol_name && 860 !strcmp(block_driver_modules[i].protocol_name, protocol)) { 861 block_module_load_one(block_driver_modules[i].library_name); 862 break; 863 } 864 } 865 866 drv1 = bdrv_do_find_protocol(protocol); 867 if (!drv1) { 868 error_setg(errp, "Unknown protocol '%s'", protocol); 869 } 870 return drv1; 871 } 872 873 /* 874 * Guess image format by probing its contents. 875 * This is not a good idea when your image is raw (CVE-2008-2004), but 876 * we do it anyway for backward compatibility. 877 * 878 * @buf contains the image's first @buf_size bytes. 879 * @buf_size is the buffer size in bytes (generally BLOCK_PROBE_BUF_SIZE, 880 * but can be smaller if the image file is smaller) 881 * @filename is its filename. 882 * 883 * For all block drivers, call the bdrv_probe() method to get its 884 * probing score. 885 * Return the first block driver with the highest probing score. 886 */ 887 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size, 888 const char *filename) 889 { 890 int score_max = 0, score; 891 BlockDriver *drv = NULL, *d; 892 893 QLIST_FOREACH(d, &bdrv_drivers, list) { 894 if (d->bdrv_probe) { 895 score = d->bdrv_probe(buf, buf_size, filename); 896 if (score > score_max) { 897 score_max = score; 898 drv = d; 899 } 900 } 901 } 902 903 return drv; 904 } 905 906 static int find_image_format(BlockBackend *file, const char *filename, 907 BlockDriver **pdrv, Error **errp) 908 { 909 BlockDriver *drv; 910 uint8_t buf[BLOCK_PROBE_BUF_SIZE]; 911 int ret = 0; 912 913 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */ 914 if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) { 915 *pdrv = &bdrv_raw; 916 return ret; 917 } 918 919 ret = blk_pread(file, 0, buf, sizeof(buf)); 920 if (ret < 0) { 921 error_setg_errno(errp, -ret, "Could not read image for determining its " 922 "format"); 923 *pdrv = NULL; 924 return ret; 925 } 926 927 drv = bdrv_probe_all(buf, ret, filename); 928 if (!drv) { 929 error_setg(errp, "Could not determine image format: No compatible " 930 "driver found"); 931 ret = -ENOENT; 932 } 933 *pdrv = drv; 934 return ret; 935 } 936 937 /** 938 * Set the current 'total_sectors' value 939 * Return 0 on success, -errno on error. 940 */ 941 int refresh_total_sectors(BlockDriverState *bs, int64_t hint) 942 { 943 BlockDriver *drv = bs->drv; 944 945 if (!drv) { 946 return -ENOMEDIUM; 947 } 948 949 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */ 950 if (bdrv_is_sg(bs)) 951 return 0; 952 953 /* query actual device if possible, otherwise just trust the hint */ 954 if (drv->bdrv_getlength) { 955 int64_t length = drv->bdrv_getlength(bs); 956 if (length < 0) { 957 return length; 958 } 959 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE); 960 } 961 962 bs->total_sectors = hint; 963 return 0; 964 } 965 966 /** 967 * Combines a QDict of new block driver @options with any missing options taken 968 * from @old_options, so that leaving out an option defaults to its old value. 969 */ 970 static void bdrv_join_options(BlockDriverState *bs, QDict *options, 971 QDict *old_options) 972 { 973 if (bs->drv && bs->drv->bdrv_join_options) { 974 bs->drv->bdrv_join_options(options, old_options); 975 } else { 976 qdict_join(options, old_options, false); 977 } 978 } 979 980 static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts, 981 int open_flags, 982 Error **errp) 983 { 984 Error *local_err = NULL; 985 char *value = qemu_opt_get_del(opts, "detect-zeroes"); 986 BlockdevDetectZeroesOptions detect_zeroes = 987 qapi_enum_parse(&BlockdevDetectZeroesOptions_lookup, value, 988 BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF, &local_err); 989 g_free(value); 990 if (local_err) { 991 error_propagate(errp, local_err); 992 return detect_zeroes; 993 } 994 995 if (detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP && 996 !(open_flags & BDRV_O_UNMAP)) 997 { 998 error_setg(errp, "setting detect-zeroes to unmap is not allowed " 999 "without setting discard operation to unmap"); 1000 } 1001 1002 return detect_zeroes; 1003 } 1004 1005 /** 1006 * Set open flags for aio engine 1007 * 1008 * Return 0 on success, -1 if the engine specified is invalid 1009 */ 1010 int bdrv_parse_aio(const char *mode, int *flags) 1011 { 1012 if (!strcmp(mode, "threads")) { 1013 /* do nothing, default */ 1014 } else if (!strcmp(mode, "native")) { 1015 *flags |= BDRV_O_NATIVE_AIO; 1016 #ifdef CONFIG_LINUX_IO_URING 1017 } else if (!strcmp(mode, "io_uring")) { 1018 *flags |= BDRV_O_IO_URING; 1019 #endif 1020 } else { 1021 return -1; 1022 } 1023 1024 return 0; 1025 } 1026 1027 /** 1028 * Set open flags for a given discard mode 1029 * 1030 * Return 0 on success, -1 if the discard mode was invalid. 1031 */ 1032 int bdrv_parse_discard_flags(const char *mode, int *flags) 1033 { 1034 *flags &= ~BDRV_O_UNMAP; 1035 1036 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) { 1037 /* do nothing */ 1038 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) { 1039 *flags |= BDRV_O_UNMAP; 1040 } else { 1041 return -1; 1042 } 1043 1044 return 0; 1045 } 1046 1047 /** 1048 * Set open flags for a given cache mode 1049 * 1050 * Return 0 on success, -1 if the cache mode was invalid. 1051 */ 1052 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough) 1053 { 1054 *flags &= ~BDRV_O_CACHE_MASK; 1055 1056 if (!strcmp(mode, "off") || !strcmp(mode, "none")) { 1057 *writethrough = false; 1058 *flags |= BDRV_O_NOCACHE; 1059 } else if (!strcmp(mode, "directsync")) { 1060 *writethrough = true; 1061 *flags |= BDRV_O_NOCACHE; 1062 } else if (!strcmp(mode, "writeback")) { 1063 *writethrough = false; 1064 } else if (!strcmp(mode, "unsafe")) { 1065 *writethrough = false; 1066 *flags |= BDRV_O_NO_FLUSH; 1067 } else if (!strcmp(mode, "writethrough")) { 1068 *writethrough = true; 1069 } else { 1070 return -1; 1071 } 1072 1073 return 0; 1074 } 1075 1076 static char *bdrv_child_get_parent_desc(BdrvChild *c) 1077 { 1078 BlockDriverState *parent = c->opaque; 1079 return g_strdup(bdrv_get_device_or_node_name(parent)); 1080 } 1081 1082 static void bdrv_child_cb_drained_begin(BdrvChild *child) 1083 { 1084 BlockDriverState *bs = child->opaque; 1085 bdrv_do_drained_begin_quiesce(bs, NULL, false); 1086 } 1087 1088 static bool bdrv_child_cb_drained_poll(BdrvChild *child) 1089 { 1090 BlockDriverState *bs = child->opaque; 1091 return bdrv_drain_poll(bs, false, NULL, false); 1092 } 1093 1094 static void bdrv_child_cb_drained_end(BdrvChild *child, 1095 int *drained_end_counter) 1096 { 1097 BlockDriverState *bs = child->opaque; 1098 bdrv_drained_end_no_poll(bs, drained_end_counter); 1099 } 1100 1101 static int bdrv_child_cb_inactivate(BdrvChild *child) 1102 { 1103 BlockDriverState *bs = child->opaque; 1104 assert(bs->open_flags & BDRV_O_INACTIVE); 1105 return 0; 1106 } 1107 1108 static bool bdrv_child_cb_can_set_aio_ctx(BdrvChild *child, AioContext *ctx, 1109 GSList **ignore, Error **errp) 1110 { 1111 BlockDriverState *bs = child->opaque; 1112 return bdrv_can_set_aio_context(bs, ctx, ignore, errp); 1113 } 1114 1115 static void bdrv_child_cb_set_aio_ctx(BdrvChild *child, AioContext *ctx, 1116 GSList **ignore) 1117 { 1118 BlockDriverState *bs = child->opaque; 1119 return bdrv_set_aio_context_ignore(bs, ctx, ignore); 1120 } 1121 1122 /* 1123 * Returns the options and flags that a temporary snapshot should get, based on 1124 * the originally requested flags (the originally requested image will have 1125 * flags like a backing file) 1126 */ 1127 static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options, 1128 int parent_flags, QDict *parent_options) 1129 { 1130 *child_flags = (parent_flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY; 1131 1132 /* For temporary files, unconditional cache=unsafe is fine */ 1133 qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off"); 1134 qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on"); 1135 1136 /* Copy the read-only and discard options from the parent */ 1137 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY); 1138 qdict_copy_default(child_options, parent_options, BDRV_OPT_DISCARD); 1139 1140 /* aio=native doesn't work for cache.direct=off, so disable it for the 1141 * temporary snapshot */ 1142 *child_flags &= ~BDRV_O_NATIVE_AIO; 1143 } 1144 1145 static void bdrv_backing_attach(BdrvChild *c) 1146 { 1147 BlockDriverState *parent = c->opaque; 1148 BlockDriverState *backing_hd = c->bs; 1149 1150 assert(!parent->backing_blocker); 1151 error_setg(&parent->backing_blocker, 1152 "node is used as backing hd of '%s'", 1153 bdrv_get_device_or_node_name(parent)); 1154 1155 bdrv_refresh_filename(backing_hd); 1156 1157 parent->open_flags &= ~BDRV_O_NO_BACKING; 1158 1159 bdrv_op_block_all(backing_hd, parent->backing_blocker); 1160 /* Otherwise we won't be able to commit or stream */ 1161 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_COMMIT_TARGET, 1162 parent->backing_blocker); 1163 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_STREAM, 1164 parent->backing_blocker); 1165 /* 1166 * We do backup in 3 ways: 1167 * 1. drive backup 1168 * The target bs is new opened, and the source is top BDS 1169 * 2. blockdev backup 1170 * Both the source and the target are top BDSes. 1171 * 3. internal backup(used for block replication) 1172 * Both the source and the target are backing file 1173 * 1174 * In case 1 and 2, neither the source nor the target is the backing file. 1175 * In case 3, we will block the top BDS, so there is only one block job 1176 * for the top BDS and its backing chain. 1177 */ 1178 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_SOURCE, 1179 parent->backing_blocker); 1180 bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET, 1181 parent->backing_blocker); 1182 } 1183 1184 static void bdrv_backing_detach(BdrvChild *c) 1185 { 1186 BlockDriverState *parent = c->opaque; 1187 1188 assert(parent->backing_blocker); 1189 bdrv_op_unblock_all(c->bs, parent->backing_blocker); 1190 error_free(parent->backing_blocker); 1191 parent->backing_blocker = NULL; 1192 } 1193 1194 static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base, 1195 const char *filename, Error **errp) 1196 { 1197 BlockDriverState *parent = c->opaque; 1198 bool read_only = bdrv_is_read_only(parent); 1199 int ret; 1200 1201 if (read_only) { 1202 ret = bdrv_reopen_set_read_only(parent, false, errp); 1203 if (ret < 0) { 1204 return ret; 1205 } 1206 } 1207 1208 ret = bdrv_change_backing_file(parent, filename, 1209 base->drv ? base->drv->format_name : "", 1210 false); 1211 if (ret < 0) { 1212 error_setg_errno(errp, -ret, "Could not update backing file link"); 1213 } 1214 1215 if (read_only) { 1216 bdrv_reopen_set_read_only(parent, true, NULL); 1217 } 1218 1219 return ret; 1220 } 1221 1222 /* 1223 * Returns the options and flags that a generic child of a BDS should 1224 * get, based on the given options and flags for the parent BDS. 1225 */ 1226 static void bdrv_inherited_options(BdrvChildRole role, bool parent_is_format, 1227 int *child_flags, QDict *child_options, 1228 int parent_flags, QDict *parent_options) 1229 { 1230 int flags = parent_flags; 1231 1232 /* 1233 * First, decide whether to set, clear, or leave BDRV_O_PROTOCOL. 1234 * Generally, the question to answer is: Should this child be 1235 * format-probed by default? 1236 */ 1237 1238 /* 1239 * Pure and non-filtered data children of non-format nodes should 1240 * be probed by default (even when the node itself has BDRV_O_PROTOCOL 1241 * set). This only affects a very limited set of drivers (namely 1242 * quorum and blkverify when this comment was written). 1243 * Force-clear BDRV_O_PROTOCOL then. 1244 */ 1245 if (!parent_is_format && 1246 (role & BDRV_CHILD_DATA) && 1247 !(role & (BDRV_CHILD_METADATA | BDRV_CHILD_FILTERED))) 1248 { 1249 flags &= ~BDRV_O_PROTOCOL; 1250 } 1251 1252 /* 1253 * All children of format nodes (except for COW children) and all 1254 * metadata children in general should never be format-probed. 1255 * Force-set BDRV_O_PROTOCOL then. 1256 */ 1257 if ((parent_is_format && !(role & BDRV_CHILD_COW)) || 1258 (role & BDRV_CHILD_METADATA)) 1259 { 1260 flags |= BDRV_O_PROTOCOL; 1261 } 1262 1263 /* 1264 * If the cache mode isn't explicitly set, inherit direct and no-flush from 1265 * the parent. 1266 */ 1267 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT); 1268 qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH); 1269 qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE); 1270 1271 if (role & BDRV_CHILD_COW) { 1272 /* backing files are opened read-only by default */ 1273 qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on"); 1274 qdict_set_default_str(child_options, BDRV_OPT_AUTO_READ_ONLY, "off"); 1275 } else { 1276 /* Inherit the read-only option from the parent if it's not set */ 1277 qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY); 1278 qdict_copy_default(child_options, parent_options, 1279 BDRV_OPT_AUTO_READ_ONLY); 1280 } 1281 1282 /* 1283 * bdrv_co_pdiscard() respects unmap policy for the parent, so we 1284 * can default to enable it on lower layers regardless of the 1285 * parent option. 1286 */ 1287 qdict_set_default_str(child_options, BDRV_OPT_DISCARD, "unmap"); 1288 1289 /* Clear flags that only apply to the top layer */ 1290 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ); 1291 1292 if (role & BDRV_CHILD_METADATA) { 1293 flags &= ~BDRV_O_NO_IO; 1294 } 1295 if (role & BDRV_CHILD_COW) { 1296 flags &= ~BDRV_O_TEMPORARY; 1297 } 1298 1299 *child_flags = flags; 1300 } 1301 1302 static void bdrv_child_cb_attach(BdrvChild *child) 1303 { 1304 BlockDriverState *bs = child->opaque; 1305 1306 if (child->role & BDRV_CHILD_COW) { 1307 bdrv_backing_attach(child); 1308 } 1309 1310 bdrv_apply_subtree_drain(child, bs); 1311 } 1312 1313 static void bdrv_child_cb_detach(BdrvChild *child) 1314 { 1315 BlockDriverState *bs = child->opaque; 1316 1317 if (child->role & BDRV_CHILD_COW) { 1318 bdrv_backing_detach(child); 1319 } 1320 1321 bdrv_unapply_subtree_drain(child, bs); 1322 } 1323 1324 static int bdrv_child_cb_update_filename(BdrvChild *c, BlockDriverState *base, 1325 const char *filename, Error **errp) 1326 { 1327 if (c->role & BDRV_CHILD_COW) { 1328 return bdrv_backing_update_filename(c, base, filename, errp); 1329 } 1330 return 0; 1331 } 1332 1333 const BdrvChildClass child_of_bds = { 1334 .parent_is_bds = true, 1335 .get_parent_desc = bdrv_child_get_parent_desc, 1336 .inherit_options = bdrv_inherited_options, 1337 .drained_begin = bdrv_child_cb_drained_begin, 1338 .drained_poll = bdrv_child_cb_drained_poll, 1339 .drained_end = bdrv_child_cb_drained_end, 1340 .attach = bdrv_child_cb_attach, 1341 .detach = bdrv_child_cb_detach, 1342 .inactivate = bdrv_child_cb_inactivate, 1343 .can_set_aio_ctx = bdrv_child_cb_can_set_aio_ctx, 1344 .set_aio_ctx = bdrv_child_cb_set_aio_ctx, 1345 .update_filename = bdrv_child_cb_update_filename, 1346 }; 1347 1348 static int bdrv_open_flags(BlockDriverState *bs, int flags) 1349 { 1350 int open_flags = flags; 1351 1352 /* 1353 * Clear flags that are internal to the block layer before opening the 1354 * image. 1355 */ 1356 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL); 1357 1358 return open_flags; 1359 } 1360 1361 static void update_flags_from_options(int *flags, QemuOpts *opts) 1362 { 1363 *flags &= ~(BDRV_O_CACHE_MASK | BDRV_O_RDWR | BDRV_O_AUTO_RDONLY); 1364 1365 if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_NO_FLUSH, false)) { 1366 *flags |= BDRV_O_NO_FLUSH; 1367 } 1368 1369 if (qemu_opt_get_bool_del(opts, BDRV_OPT_CACHE_DIRECT, false)) { 1370 *flags |= BDRV_O_NOCACHE; 1371 } 1372 1373 if (!qemu_opt_get_bool_del(opts, BDRV_OPT_READ_ONLY, false)) { 1374 *flags |= BDRV_O_RDWR; 1375 } 1376 1377 if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) { 1378 *flags |= BDRV_O_AUTO_RDONLY; 1379 } 1380 } 1381 1382 static void update_options_from_flags(QDict *options, int flags) 1383 { 1384 if (!qdict_haskey(options, BDRV_OPT_CACHE_DIRECT)) { 1385 qdict_put_bool(options, BDRV_OPT_CACHE_DIRECT, flags & BDRV_O_NOCACHE); 1386 } 1387 if (!qdict_haskey(options, BDRV_OPT_CACHE_NO_FLUSH)) { 1388 qdict_put_bool(options, BDRV_OPT_CACHE_NO_FLUSH, 1389 flags & BDRV_O_NO_FLUSH); 1390 } 1391 if (!qdict_haskey(options, BDRV_OPT_READ_ONLY)) { 1392 qdict_put_bool(options, BDRV_OPT_READ_ONLY, !(flags & BDRV_O_RDWR)); 1393 } 1394 if (!qdict_haskey(options, BDRV_OPT_AUTO_READ_ONLY)) { 1395 qdict_put_bool(options, BDRV_OPT_AUTO_READ_ONLY, 1396 flags & BDRV_O_AUTO_RDONLY); 1397 } 1398 } 1399 1400 static void bdrv_assign_node_name(BlockDriverState *bs, 1401 const char *node_name, 1402 Error **errp) 1403 { 1404 char *gen_node_name = NULL; 1405 1406 if (!node_name) { 1407 node_name = gen_node_name = id_generate(ID_BLOCK); 1408 } else if (!id_wellformed(node_name)) { 1409 /* 1410 * Check for empty string or invalid characters, but not if it is 1411 * generated (generated names use characters not available to the user) 1412 */ 1413 error_setg(errp, "Invalid node name"); 1414 return; 1415 } 1416 1417 /* takes care of avoiding namespaces collisions */ 1418 if (blk_by_name(node_name)) { 1419 error_setg(errp, "node-name=%s is conflicting with a device id", 1420 node_name); 1421 goto out; 1422 } 1423 1424 /* takes care of avoiding duplicates node names */ 1425 if (bdrv_find_node(node_name)) { 1426 error_setg(errp, "Duplicate node name"); 1427 goto out; 1428 } 1429 1430 /* Make sure that the node name isn't truncated */ 1431 if (strlen(node_name) >= sizeof(bs->node_name)) { 1432 error_setg(errp, "Node name too long"); 1433 goto out; 1434 } 1435 1436 /* copy node name into the bs and insert it into the graph list */ 1437 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name); 1438 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list); 1439 out: 1440 g_free(gen_node_name); 1441 } 1442 1443 static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv, 1444 const char *node_name, QDict *options, 1445 int open_flags, Error **errp) 1446 { 1447 Error *local_err = NULL; 1448 int i, ret; 1449 1450 bdrv_assign_node_name(bs, node_name, &local_err); 1451 if (local_err) { 1452 error_propagate(errp, local_err); 1453 return -EINVAL; 1454 } 1455 1456 bs->drv = drv; 1457 bs->read_only = !(bs->open_flags & BDRV_O_RDWR); 1458 bs->opaque = g_malloc0(drv->instance_size); 1459 1460 if (drv->bdrv_file_open) { 1461 assert(!drv->bdrv_needs_filename || bs->filename[0]); 1462 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err); 1463 } else if (drv->bdrv_open) { 1464 ret = drv->bdrv_open(bs, options, open_flags, &local_err); 1465 } else { 1466 ret = 0; 1467 } 1468 1469 if (ret < 0) { 1470 if (local_err) { 1471 error_propagate(errp, local_err); 1472 } else if (bs->filename[0]) { 1473 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename); 1474 } else { 1475 error_setg_errno(errp, -ret, "Could not open image"); 1476 } 1477 goto open_failed; 1478 } 1479 1480 ret = refresh_total_sectors(bs, bs->total_sectors); 1481 if (ret < 0) { 1482 error_setg_errno(errp, -ret, "Could not refresh total sector count"); 1483 return ret; 1484 } 1485 1486 bdrv_refresh_limits(bs, &local_err); 1487 if (local_err) { 1488 error_propagate(errp, local_err); 1489 return -EINVAL; 1490 } 1491 1492 assert(bdrv_opt_mem_align(bs) != 0); 1493 assert(bdrv_min_mem_align(bs) != 0); 1494 assert(is_power_of_2(bs->bl.request_alignment)); 1495 1496 for (i = 0; i < bs->quiesce_counter; i++) { 1497 if (drv->bdrv_co_drain_begin) { 1498 drv->bdrv_co_drain_begin(bs); 1499 } 1500 } 1501 1502 return 0; 1503 open_failed: 1504 bs->drv = NULL; 1505 if (bs->file != NULL) { 1506 bdrv_unref_child(bs, bs->file); 1507 bs->file = NULL; 1508 } 1509 g_free(bs->opaque); 1510 bs->opaque = NULL; 1511 return ret; 1512 } 1513 1514 BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name, 1515 int flags, Error **errp) 1516 { 1517 BlockDriverState *bs; 1518 int ret; 1519 1520 bs = bdrv_new(); 1521 bs->open_flags = flags; 1522 bs->explicit_options = qdict_new(); 1523 bs->options = qdict_new(); 1524 bs->opaque = NULL; 1525 1526 update_options_from_flags(bs->options, flags); 1527 1528 ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp); 1529 if (ret < 0) { 1530 qobject_unref(bs->explicit_options); 1531 bs->explicit_options = NULL; 1532 qobject_unref(bs->options); 1533 bs->options = NULL; 1534 bdrv_unref(bs); 1535 return NULL; 1536 } 1537 1538 return bs; 1539 } 1540 1541 QemuOptsList bdrv_runtime_opts = { 1542 .name = "bdrv_common", 1543 .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head), 1544 .desc = { 1545 { 1546 .name = "node-name", 1547 .type = QEMU_OPT_STRING, 1548 .help = "Node name of the block device node", 1549 }, 1550 { 1551 .name = "driver", 1552 .type = QEMU_OPT_STRING, 1553 .help = "Block driver to use for the node", 1554 }, 1555 { 1556 .name = BDRV_OPT_CACHE_DIRECT, 1557 .type = QEMU_OPT_BOOL, 1558 .help = "Bypass software writeback cache on the host", 1559 }, 1560 { 1561 .name = BDRV_OPT_CACHE_NO_FLUSH, 1562 .type = QEMU_OPT_BOOL, 1563 .help = "Ignore flush requests", 1564 }, 1565 { 1566 .name = BDRV_OPT_READ_ONLY, 1567 .type = QEMU_OPT_BOOL, 1568 .help = "Node is opened in read-only mode", 1569 }, 1570 { 1571 .name = BDRV_OPT_AUTO_READ_ONLY, 1572 .type = QEMU_OPT_BOOL, 1573 .help = "Node can become read-only if opening read-write fails", 1574 }, 1575 { 1576 .name = "detect-zeroes", 1577 .type = QEMU_OPT_STRING, 1578 .help = "try to optimize zero writes (off, on, unmap)", 1579 }, 1580 { 1581 .name = BDRV_OPT_DISCARD, 1582 .type = QEMU_OPT_STRING, 1583 .help = "discard operation (ignore/off, unmap/on)", 1584 }, 1585 { 1586 .name = BDRV_OPT_FORCE_SHARE, 1587 .type = QEMU_OPT_BOOL, 1588 .help = "always accept other writers (default: off)", 1589 }, 1590 { /* end of list */ } 1591 }, 1592 }; 1593 1594 QemuOptsList bdrv_create_opts_simple = { 1595 .name = "simple-create-opts", 1596 .head = QTAILQ_HEAD_INITIALIZER(bdrv_create_opts_simple.head), 1597 .desc = { 1598 { 1599 .name = BLOCK_OPT_SIZE, 1600 .type = QEMU_OPT_SIZE, 1601 .help = "Virtual disk size" 1602 }, 1603 { 1604 .name = BLOCK_OPT_PREALLOC, 1605 .type = QEMU_OPT_STRING, 1606 .help = "Preallocation mode (allowed values: off)" 1607 }, 1608 { /* end of list */ } 1609 } 1610 }; 1611 1612 /* 1613 * Common part for opening disk images and files 1614 * 1615 * Removes all processed options from *options. 1616 */ 1617 static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file, 1618 QDict *options, Error **errp) 1619 { 1620 int ret, open_flags; 1621 const char *filename; 1622 const char *driver_name = NULL; 1623 const char *node_name = NULL; 1624 const char *discard; 1625 QemuOpts *opts; 1626 BlockDriver *drv; 1627 Error *local_err = NULL; 1628 1629 assert(bs->file == NULL); 1630 assert(options != NULL && bs->options != options); 1631 1632 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort); 1633 if (!qemu_opts_absorb_qdict(opts, options, errp)) { 1634 ret = -EINVAL; 1635 goto fail_opts; 1636 } 1637 1638 update_flags_from_options(&bs->open_flags, opts); 1639 1640 driver_name = qemu_opt_get(opts, "driver"); 1641 drv = bdrv_find_format(driver_name); 1642 assert(drv != NULL); 1643 1644 bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false); 1645 1646 if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) { 1647 error_setg(errp, 1648 BDRV_OPT_FORCE_SHARE 1649 "=on can only be used with read-only images"); 1650 ret = -EINVAL; 1651 goto fail_opts; 1652 } 1653 1654 if (file != NULL) { 1655 bdrv_refresh_filename(blk_bs(file)); 1656 filename = blk_bs(file)->filename; 1657 } else { 1658 /* 1659 * Caution: while qdict_get_try_str() is fine, getting 1660 * non-string types would require more care. When @options 1661 * come from -blockdev or blockdev_add, its members are typed 1662 * according to the QAPI schema, but when they come from 1663 * -drive, they're all QString. 1664 */ 1665 filename = qdict_get_try_str(options, "filename"); 1666 } 1667 1668 if (drv->bdrv_needs_filename && (!filename || !filename[0])) { 1669 error_setg(errp, "The '%s' block driver requires a file name", 1670 drv->format_name); 1671 ret = -EINVAL; 1672 goto fail_opts; 1673 } 1674 1675 trace_bdrv_open_common(bs, filename ?: "", bs->open_flags, 1676 drv->format_name); 1677 1678 bs->read_only = !(bs->open_flags & BDRV_O_RDWR); 1679 1680 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) { 1681 if (!bs->read_only && bdrv_is_whitelisted(drv, true)) { 1682 ret = bdrv_apply_auto_read_only(bs, NULL, NULL); 1683 } else { 1684 ret = -ENOTSUP; 1685 } 1686 if (ret < 0) { 1687 error_setg(errp, 1688 !bs->read_only && bdrv_is_whitelisted(drv, true) 1689 ? "Driver '%s' can only be used for read-only devices" 1690 : "Driver '%s' is not whitelisted", 1691 drv->format_name); 1692 goto fail_opts; 1693 } 1694 } 1695 1696 /* bdrv_new() and bdrv_close() make it so */ 1697 assert(qatomic_read(&bs->copy_on_read) == 0); 1698 1699 if (bs->open_flags & BDRV_O_COPY_ON_READ) { 1700 if (!bs->read_only) { 1701 bdrv_enable_copy_on_read(bs); 1702 } else { 1703 error_setg(errp, "Can't use copy-on-read on read-only device"); 1704 ret = -EINVAL; 1705 goto fail_opts; 1706 } 1707 } 1708 1709 discard = qemu_opt_get(opts, BDRV_OPT_DISCARD); 1710 if (discard != NULL) { 1711 if (bdrv_parse_discard_flags(discard, &bs->open_flags) != 0) { 1712 error_setg(errp, "Invalid discard option"); 1713 ret = -EINVAL; 1714 goto fail_opts; 1715 } 1716 } 1717 1718 bs->detect_zeroes = 1719 bdrv_parse_detect_zeroes(opts, bs->open_flags, &local_err); 1720 if (local_err) { 1721 error_propagate(errp, local_err); 1722 ret = -EINVAL; 1723 goto fail_opts; 1724 } 1725 1726 if (filename != NULL) { 1727 pstrcpy(bs->filename, sizeof(bs->filename), filename); 1728 } else { 1729 bs->filename[0] = '\0'; 1730 } 1731 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename); 1732 1733 /* Open the image, either directly or using a protocol */ 1734 open_flags = bdrv_open_flags(bs, bs->open_flags); 1735 node_name = qemu_opt_get(opts, "node-name"); 1736 1737 assert(!drv->bdrv_file_open || file == NULL); 1738 ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp); 1739 if (ret < 0) { 1740 goto fail_opts; 1741 } 1742 1743 qemu_opts_del(opts); 1744 return 0; 1745 1746 fail_opts: 1747 qemu_opts_del(opts); 1748 return ret; 1749 } 1750 1751 static QDict *parse_json_filename(const char *filename, Error **errp) 1752 { 1753 QObject *options_obj; 1754 QDict *options; 1755 int ret; 1756 1757 ret = strstart(filename, "json:", &filename); 1758 assert(ret); 1759 1760 options_obj = qobject_from_json(filename, errp); 1761 if (!options_obj) { 1762 error_prepend(errp, "Could not parse the JSON options: "); 1763 return NULL; 1764 } 1765 1766 options = qobject_to(QDict, options_obj); 1767 if (!options) { 1768 qobject_unref(options_obj); 1769 error_setg(errp, "Invalid JSON object given"); 1770 return NULL; 1771 } 1772 1773 qdict_flatten(options); 1774 1775 return options; 1776 } 1777 1778 static void parse_json_protocol(QDict *options, const char **pfilename, 1779 Error **errp) 1780 { 1781 QDict *json_options; 1782 Error *local_err = NULL; 1783 1784 /* Parse json: pseudo-protocol */ 1785 if (!*pfilename || !g_str_has_prefix(*pfilename, "json:")) { 1786 return; 1787 } 1788 1789 json_options = parse_json_filename(*pfilename, &local_err); 1790 if (local_err) { 1791 error_propagate(errp, local_err); 1792 return; 1793 } 1794 1795 /* Options given in the filename have lower priority than options 1796 * specified directly */ 1797 qdict_join(options, json_options, false); 1798 qobject_unref(json_options); 1799 *pfilename = NULL; 1800 } 1801 1802 /* 1803 * Fills in default options for opening images and converts the legacy 1804 * filename/flags pair to option QDict entries. 1805 * The BDRV_O_PROTOCOL flag in *flags will be set or cleared accordingly if a 1806 * block driver has been specified explicitly. 1807 */ 1808 static int bdrv_fill_options(QDict **options, const char *filename, 1809 int *flags, Error **errp) 1810 { 1811 const char *drvname; 1812 bool protocol = *flags & BDRV_O_PROTOCOL; 1813 bool parse_filename = false; 1814 BlockDriver *drv = NULL; 1815 Error *local_err = NULL; 1816 1817 /* 1818 * Caution: while qdict_get_try_str() is fine, getting non-string 1819 * types would require more care. When @options come from 1820 * -blockdev or blockdev_add, its members are typed according to 1821 * the QAPI schema, but when they come from -drive, they're all 1822 * QString. 1823 */ 1824 drvname = qdict_get_try_str(*options, "driver"); 1825 if (drvname) { 1826 drv = bdrv_find_format(drvname); 1827 if (!drv) { 1828 error_setg(errp, "Unknown driver '%s'", drvname); 1829 return -ENOENT; 1830 } 1831 /* If the user has explicitly specified the driver, this choice should 1832 * override the BDRV_O_PROTOCOL flag */ 1833 protocol = drv->bdrv_file_open; 1834 } 1835 1836 if (protocol) { 1837 *flags |= BDRV_O_PROTOCOL; 1838 } else { 1839 *flags &= ~BDRV_O_PROTOCOL; 1840 } 1841 1842 /* Translate cache options from flags into options */ 1843 update_options_from_flags(*options, *flags); 1844 1845 /* Fetch the file name from the options QDict if necessary */ 1846 if (protocol && filename) { 1847 if (!qdict_haskey(*options, "filename")) { 1848 qdict_put_str(*options, "filename", filename); 1849 parse_filename = true; 1850 } else { 1851 error_setg(errp, "Can't specify 'file' and 'filename' options at " 1852 "the same time"); 1853 return -EINVAL; 1854 } 1855 } 1856 1857 /* Find the right block driver */ 1858 /* See cautionary note on accessing @options above */ 1859 filename = qdict_get_try_str(*options, "filename"); 1860 1861 if (!drvname && protocol) { 1862 if (filename) { 1863 drv = bdrv_find_protocol(filename, parse_filename, errp); 1864 if (!drv) { 1865 return -EINVAL; 1866 } 1867 1868 drvname = drv->format_name; 1869 qdict_put_str(*options, "driver", drvname); 1870 } else { 1871 error_setg(errp, "Must specify either driver or file"); 1872 return -EINVAL; 1873 } 1874 } 1875 1876 assert(drv || !protocol); 1877 1878 /* Driver-specific filename parsing */ 1879 if (drv && drv->bdrv_parse_filename && parse_filename) { 1880 drv->bdrv_parse_filename(filename, *options, &local_err); 1881 if (local_err) { 1882 error_propagate(errp, local_err); 1883 return -EINVAL; 1884 } 1885 1886 if (!drv->bdrv_needs_filename) { 1887 qdict_del(*options, "filename"); 1888 } 1889 } 1890 1891 return 0; 1892 } 1893 1894 static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q, 1895 uint64_t perm, uint64_t shared, 1896 GSList *ignore_children, 1897 bool *tighten_restrictions, Error **errp); 1898 static void bdrv_child_abort_perm_update(BdrvChild *c); 1899 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared); 1900 1901 typedef struct BlockReopenQueueEntry { 1902 bool prepared; 1903 bool perms_checked; 1904 BDRVReopenState state; 1905 QTAILQ_ENTRY(BlockReopenQueueEntry) entry; 1906 } BlockReopenQueueEntry; 1907 1908 /* 1909 * Return the flags that @bs will have after the reopens in @q have 1910 * successfully completed. If @q is NULL (or @bs is not contained in @q), 1911 * return the current flags. 1912 */ 1913 static int bdrv_reopen_get_flags(BlockReopenQueue *q, BlockDriverState *bs) 1914 { 1915 BlockReopenQueueEntry *entry; 1916 1917 if (q != NULL) { 1918 QTAILQ_FOREACH(entry, q, entry) { 1919 if (entry->state.bs == bs) { 1920 return entry->state.flags; 1921 } 1922 } 1923 } 1924 1925 return bs->open_flags; 1926 } 1927 1928 /* Returns whether the image file can be written to after the reopen queue @q 1929 * has been successfully applied, or right now if @q is NULL. */ 1930 static bool bdrv_is_writable_after_reopen(BlockDriverState *bs, 1931 BlockReopenQueue *q) 1932 { 1933 int flags = bdrv_reopen_get_flags(q, bs); 1934 1935 return (flags & (BDRV_O_RDWR | BDRV_O_INACTIVE)) == BDRV_O_RDWR; 1936 } 1937 1938 /* 1939 * Return whether the BDS can be written to. This is not necessarily 1940 * the same as !bdrv_is_read_only(bs), as inactivated images may not 1941 * be written to but do not count as read-only images. 1942 */ 1943 bool bdrv_is_writable(BlockDriverState *bs) 1944 { 1945 return bdrv_is_writable_after_reopen(bs, NULL); 1946 } 1947 1948 static void bdrv_child_perm(BlockDriverState *bs, BlockDriverState *child_bs, 1949 BdrvChild *c, BdrvChildRole role, 1950 BlockReopenQueue *reopen_queue, 1951 uint64_t parent_perm, uint64_t parent_shared, 1952 uint64_t *nperm, uint64_t *nshared) 1953 { 1954 assert(bs->drv && bs->drv->bdrv_child_perm); 1955 bs->drv->bdrv_child_perm(bs, c, role, reopen_queue, 1956 parent_perm, parent_shared, 1957 nperm, nshared); 1958 /* TODO Take force_share from reopen_queue */ 1959 if (child_bs && child_bs->force_share) { 1960 *nshared = BLK_PERM_ALL; 1961 } 1962 } 1963 1964 /* 1965 * Check whether permissions on this node can be changed in a way that 1966 * @cumulative_perms and @cumulative_shared_perms are the new cumulative 1967 * permissions of all its parents. This involves checking whether all necessary 1968 * permission changes to child nodes can be performed. 1969 * 1970 * Will set *tighten_restrictions to true if and only if new permissions have to 1971 * be taken or currently shared permissions are to be unshared. Otherwise, 1972 * errors are not fatal as long as the caller accepts that the restrictions 1973 * remain tighter than they need to be. The caller still has to abort the 1974 * transaction. 1975 * @tighten_restrictions cannot be used together with @q: When reopening, we may 1976 * encounter fatal errors even though no restrictions are to be tightened. For 1977 * example, changing a node from RW to RO will fail if the WRITE permission is 1978 * to be kept. 1979 * 1980 * A call to this function must always be followed by a call to bdrv_set_perm() 1981 * or bdrv_abort_perm_update(). 1982 */ 1983 static int bdrv_check_perm(BlockDriverState *bs, BlockReopenQueue *q, 1984 uint64_t cumulative_perms, 1985 uint64_t cumulative_shared_perms, 1986 GSList *ignore_children, 1987 bool *tighten_restrictions, Error **errp) 1988 { 1989 BlockDriver *drv = bs->drv; 1990 BdrvChild *c; 1991 int ret; 1992 1993 assert(!q || !tighten_restrictions); 1994 1995 if (tighten_restrictions) { 1996 uint64_t current_perms, current_shared; 1997 uint64_t added_perms, removed_shared_perms; 1998 1999 bdrv_get_cumulative_perm(bs, ¤t_perms, ¤t_shared); 2000 2001 added_perms = cumulative_perms & ~current_perms; 2002 removed_shared_perms = current_shared & ~cumulative_shared_perms; 2003 2004 *tighten_restrictions = added_perms || removed_shared_perms; 2005 } 2006 2007 /* Write permissions never work with read-only images */ 2008 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) && 2009 !bdrv_is_writable_after_reopen(bs, q)) 2010 { 2011 if (!bdrv_is_writable_after_reopen(bs, NULL)) { 2012 error_setg(errp, "Block node is read-only"); 2013 } else { 2014 uint64_t current_perms, current_shared; 2015 bdrv_get_cumulative_perm(bs, ¤t_perms, ¤t_shared); 2016 if (current_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) { 2017 error_setg(errp, "Cannot make block node read-only, there is " 2018 "a writer on it"); 2019 } else { 2020 error_setg(errp, "Cannot make block node read-only and create " 2021 "a writer on it"); 2022 } 2023 } 2024 2025 return -EPERM; 2026 } 2027 2028 /* 2029 * Unaligned requests will automatically be aligned to bl.request_alignment 2030 * and without RESIZE we can't extend requests to write to space beyond the 2031 * end of the image, so it's required that the image size is aligned. 2032 */ 2033 if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) && 2034 !(cumulative_perms & BLK_PERM_RESIZE)) 2035 { 2036 if ((bs->total_sectors * BDRV_SECTOR_SIZE) % bs->bl.request_alignment) { 2037 error_setg(errp, "Cannot get 'write' permission without 'resize': " 2038 "Image size is not a multiple of request " 2039 "alignment"); 2040 return -EPERM; 2041 } 2042 } 2043 2044 /* Check this node */ 2045 if (!drv) { 2046 return 0; 2047 } 2048 2049 if (drv->bdrv_check_perm) { 2050 return drv->bdrv_check_perm(bs, cumulative_perms, 2051 cumulative_shared_perms, errp); 2052 } 2053 2054 /* Drivers that never have children can omit .bdrv_child_perm() */ 2055 if (!drv->bdrv_child_perm) { 2056 assert(QLIST_EMPTY(&bs->children)); 2057 return 0; 2058 } 2059 2060 /* Check all children */ 2061 QLIST_FOREACH(c, &bs->children, next) { 2062 uint64_t cur_perm, cur_shared; 2063 bool child_tighten_restr; 2064 2065 bdrv_child_perm(bs, c->bs, c, c->role, q, 2066 cumulative_perms, cumulative_shared_perms, 2067 &cur_perm, &cur_shared); 2068 ret = bdrv_child_check_perm(c, q, cur_perm, cur_shared, ignore_children, 2069 tighten_restrictions ? &child_tighten_restr 2070 : NULL, 2071 errp); 2072 if (tighten_restrictions) { 2073 *tighten_restrictions |= child_tighten_restr; 2074 } 2075 if (ret < 0) { 2076 return ret; 2077 } 2078 } 2079 2080 return 0; 2081 } 2082 2083 /* 2084 * Notifies drivers that after a previous bdrv_check_perm() call, the 2085 * permission update is not performed and any preparations made for it (e.g. 2086 * taken file locks) need to be undone. 2087 * 2088 * This function recursively notifies all child nodes. 2089 */ 2090 static void bdrv_abort_perm_update(BlockDriverState *bs) 2091 { 2092 BlockDriver *drv = bs->drv; 2093 BdrvChild *c; 2094 2095 if (!drv) { 2096 return; 2097 } 2098 2099 if (drv->bdrv_abort_perm_update) { 2100 drv->bdrv_abort_perm_update(bs); 2101 } 2102 2103 QLIST_FOREACH(c, &bs->children, next) { 2104 bdrv_child_abort_perm_update(c); 2105 } 2106 } 2107 2108 static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms, 2109 uint64_t cumulative_shared_perms) 2110 { 2111 BlockDriver *drv = bs->drv; 2112 BdrvChild *c; 2113 2114 if (!drv) { 2115 return; 2116 } 2117 2118 /* Update this node */ 2119 if (drv->bdrv_set_perm) { 2120 drv->bdrv_set_perm(bs, cumulative_perms, cumulative_shared_perms); 2121 } 2122 2123 /* Drivers that never have children can omit .bdrv_child_perm() */ 2124 if (!drv->bdrv_child_perm) { 2125 assert(QLIST_EMPTY(&bs->children)); 2126 return; 2127 } 2128 2129 /* Update all children */ 2130 QLIST_FOREACH(c, &bs->children, next) { 2131 uint64_t cur_perm, cur_shared; 2132 bdrv_child_perm(bs, c->bs, c, c->role, NULL, 2133 cumulative_perms, cumulative_shared_perms, 2134 &cur_perm, &cur_shared); 2135 bdrv_child_set_perm(c, cur_perm, cur_shared); 2136 } 2137 } 2138 2139 void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm, 2140 uint64_t *shared_perm) 2141 { 2142 BdrvChild *c; 2143 uint64_t cumulative_perms = 0; 2144 uint64_t cumulative_shared_perms = BLK_PERM_ALL; 2145 2146 QLIST_FOREACH(c, &bs->parents, next_parent) { 2147 cumulative_perms |= c->perm; 2148 cumulative_shared_perms &= c->shared_perm; 2149 } 2150 2151 *perm = cumulative_perms; 2152 *shared_perm = cumulative_shared_perms; 2153 } 2154 2155 static char *bdrv_child_user_desc(BdrvChild *c) 2156 { 2157 if (c->klass->get_parent_desc) { 2158 return c->klass->get_parent_desc(c); 2159 } 2160 2161 return g_strdup("another user"); 2162 } 2163 2164 char *bdrv_perm_names(uint64_t perm) 2165 { 2166 struct perm_name { 2167 uint64_t perm; 2168 const char *name; 2169 } permissions[] = { 2170 { BLK_PERM_CONSISTENT_READ, "consistent read" }, 2171 { BLK_PERM_WRITE, "write" }, 2172 { BLK_PERM_WRITE_UNCHANGED, "write unchanged" }, 2173 { BLK_PERM_RESIZE, "resize" }, 2174 { BLK_PERM_GRAPH_MOD, "change children" }, 2175 { 0, NULL } 2176 }; 2177 2178 GString *result = g_string_sized_new(30); 2179 struct perm_name *p; 2180 2181 for (p = permissions; p->name; p++) { 2182 if (perm & p->perm) { 2183 if (result->len > 0) { 2184 g_string_append(result, ", "); 2185 } 2186 g_string_append(result, p->name); 2187 } 2188 } 2189 2190 return g_string_free(result, FALSE); 2191 } 2192 2193 /* 2194 * Checks whether a new reference to @bs can be added if the new user requires 2195 * @new_used_perm/@new_shared_perm as its permissions. If @ignore_children is 2196 * set, the BdrvChild objects in this list are ignored in the calculations; 2197 * this allows checking permission updates for an existing reference. 2198 * 2199 * See bdrv_check_perm() for the semantics of @tighten_restrictions. 2200 * 2201 * Needs to be followed by a call to either bdrv_set_perm() or 2202 * bdrv_abort_perm_update(). */ 2203 static int bdrv_check_update_perm(BlockDriverState *bs, BlockReopenQueue *q, 2204 uint64_t new_used_perm, 2205 uint64_t new_shared_perm, 2206 GSList *ignore_children, 2207 bool *tighten_restrictions, 2208 Error **errp) 2209 { 2210 BdrvChild *c; 2211 uint64_t cumulative_perms = new_used_perm; 2212 uint64_t cumulative_shared_perms = new_shared_perm; 2213 2214 assert(!q || !tighten_restrictions); 2215 2216 /* There is no reason why anyone couldn't tolerate write_unchanged */ 2217 assert(new_shared_perm & BLK_PERM_WRITE_UNCHANGED); 2218 2219 QLIST_FOREACH(c, &bs->parents, next_parent) { 2220 if (g_slist_find(ignore_children, c)) { 2221 continue; 2222 } 2223 2224 if ((new_used_perm & c->shared_perm) != new_used_perm) { 2225 char *user = bdrv_child_user_desc(c); 2226 char *perm_names = bdrv_perm_names(new_used_perm & ~c->shared_perm); 2227 2228 if (tighten_restrictions) { 2229 *tighten_restrictions = true; 2230 } 2231 2232 error_setg(errp, "Conflicts with use by %s as '%s', which does not " 2233 "allow '%s' on %s", 2234 user, c->name, perm_names, bdrv_get_node_name(c->bs)); 2235 g_free(user); 2236 g_free(perm_names); 2237 return -EPERM; 2238 } 2239 2240 if ((c->perm & new_shared_perm) != c->perm) { 2241 char *user = bdrv_child_user_desc(c); 2242 char *perm_names = bdrv_perm_names(c->perm & ~new_shared_perm); 2243 2244 if (tighten_restrictions) { 2245 *tighten_restrictions = true; 2246 } 2247 2248 error_setg(errp, "Conflicts with use by %s as '%s', which uses " 2249 "'%s' on %s", 2250 user, c->name, perm_names, bdrv_get_node_name(c->bs)); 2251 g_free(user); 2252 g_free(perm_names); 2253 return -EPERM; 2254 } 2255 2256 cumulative_perms |= c->perm; 2257 cumulative_shared_perms &= c->shared_perm; 2258 } 2259 2260 return bdrv_check_perm(bs, q, cumulative_perms, cumulative_shared_perms, 2261 ignore_children, tighten_restrictions, errp); 2262 } 2263 2264 /* Needs to be followed by a call to either bdrv_child_set_perm() or 2265 * bdrv_child_abort_perm_update(). */ 2266 static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q, 2267 uint64_t perm, uint64_t shared, 2268 GSList *ignore_children, 2269 bool *tighten_restrictions, Error **errp) 2270 { 2271 int ret; 2272 2273 ignore_children = g_slist_prepend(g_slist_copy(ignore_children), c); 2274 ret = bdrv_check_update_perm(c->bs, q, perm, shared, ignore_children, 2275 tighten_restrictions, errp); 2276 g_slist_free(ignore_children); 2277 2278 if (ret < 0) { 2279 return ret; 2280 } 2281 2282 if (!c->has_backup_perm) { 2283 c->has_backup_perm = true; 2284 c->backup_perm = c->perm; 2285 c->backup_shared_perm = c->shared_perm; 2286 } 2287 /* 2288 * Note: it's OK if c->has_backup_perm was already set, as we can find the 2289 * same child twice during check_perm procedure 2290 */ 2291 2292 c->perm = perm; 2293 c->shared_perm = shared; 2294 2295 return 0; 2296 } 2297 2298 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared) 2299 { 2300 uint64_t cumulative_perms, cumulative_shared_perms; 2301 2302 c->has_backup_perm = false; 2303 2304 c->perm = perm; 2305 c->shared_perm = shared; 2306 2307 bdrv_get_cumulative_perm(c->bs, &cumulative_perms, 2308 &cumulative_shared_perms); 2309 bdrv_set_perm(c->bs, cumulative_perms, cumulative_shared_perms); 2310 } 2311 2312 static void bdrv_child_abort_perm_update(BdrvChild *c) 2313 { 2314 if (c->has_backup_perm) { 2315 c->perm = c->backup_perm; 2316 c->shared_perm = c->backup_shared_perm; 2317 c->has_backup_perm = false; 2318 } 2319 2320 bdrv_abort_perm_update(c->bs); 2321 } 2322 2323 int bdrv_child_try_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared, 2324 Error **errp) 2325 { 2326 Error *local_err = NULL; 2327 int ret; 2328 bool tighten_restrictions; 2329 2330 ret = bdrv_child_check_perm(c, NULL, perm, shared, NULL, 2331 &tighten_restrictions, &local_err); 2332 if (ret < 0) { 2333 bdrv_child_abort_perm_update(c); 2334 if (tighten_restrictions) { 2335 error_propagate(errp, local_err); 2336 } else { 2337 /* 2338 * Our caller may intend to only loosen restrictions and 2339 * does not expect this function to fail. Errors are not 2340 * fatal in such a case, so we can just hide them from our 2341 * caller. 2342 */ 2343 error_free(local_err); 2344 ret = 0; 2345 } 2346 return ret; 2347 } 2348 2349 bdrv_child_set_perm(c, perm, shared); 2350 2351 return 0; 2352 } 2353 2354 int bdrv_child_refresh_perms(BlockDriverState *bs, BdrvChild *c, Error **errp) 2355 { 2356 uint64_t parent_perms, parent_shared; 2357 uint64_t perms, shared; 2358 2359 bdrv_get_cumulative_perm(bs, &parent_perms, &parent_shared); 2360 bdrv_child_perm(bs, c->bs, c, c->role, NULL, 2361 parent_perms, parent_shared, &perms, &shared); 2362 2363 return bdrv_child_try_set_perm(c, perms, shared, errp); 2364 } 2365 2366 /* 2367 * Default implementation for .bdrv_child_perm() for block filters: 2368 * Forward CONSISTENT_READ, WRITE, WRITE_UNCHANGED, and RESIZE to the 2369 * filtered child. 2370 */ 2371 static void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c, 2372 BdrvChildRole role, 2373 BlockReopenQueue *reopen_queue, 2374 uint64_t perm, uint64_t shared, 2375 uint64_t *nperm, uint64_t *nshared) 2376 { 2377 *nperm = perm & DEFAULT_PERM_PASSTHROUGH; 2378 *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED; 2379 } 2380 2381 static void bdrv_default_perms_for_cow(BlockDriverState *bs, BdrvChild *c, 2382 BdrvChildRole role, 2383 BlockReopenQueue *reopen_queue, 2384 uint64_t perm, uint64_t shared, 2385 uint64_t *nperm, uint64_t *nshared) 2386 { 2387 assert(role & BDRV_CHILD_COW); 2388 2389 /* 2390 * We want consistent read from backing files if the parent needs it. 2391 * No other operations are performed on backing files. 2392 */ 2393 perm &= BLK_PERM_CONSISTENT_READ; 2394 2395 /* 2396 * If the parent can deal with changing data, we're okay with a 2397 * writable and resizable backing file. 2398 * TODO Require !(perm & BLK_PERM_CONSISTENT_READ), too? 2399 */ 2400 if (shared & BLK_PERM_WRITE) { 2401 shared = BLK_PERM_WRITE | BLK_PERM_RESIZE; 2402 } else { 2403 shared = 0; 2404 } 2405 2406 shared |= BLK_PERM_CONSISTENT_READ | BLK_PERM_GRAPH_MOD | 2407 BLK_PERM_WRITE_UNCHANGED; 2408 2409 if (bs->open_flags & BDRV_O_INACTIVE) { 2410 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE; 2411 } 2412 2413 *nperm = perm; 2414 *nshared = shared; 2415 } 2416 2417 static void bdrv_default_perms_for_storage(BlockDriverState *bs, BdrvChild *c, 2418 BdrvChildRole role, 2419 BlockReopenQueue *reopen_queue, 2420 uint64_t perm, uint64_t shared, 2421 uint64_t *nperm, uint64_t *nshared) 2422 { 2423 int flags; 2424 2425 assert(role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA)); 2426 2427 flags = bdrv_reopen_get_flags(reopen_queue, bs); 2428 2429 /* 2430 * Apart from the modifications below, the same permissions are 2431 * forwarded and left alone as for filters 2432 */ 2433 bdrv_filter_default_perms(bs, c, role, reopen_queue, 2434 perm, shared, &perm, &shared); 2435 2436 if (role & BDRV_CHILD_METADATA) { 2437 /* Format drivers may touch metadata even if the guest doesn't write */ 2438 if (bdrv_is_writable_after_reopen(bs, reopen_queue)) { 2439 perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE; 2440 } 2441 2442 /* 2443 * bs->file always needs to be consistent because of the 2444 * metadata. We can never allow other users to resize or write 2445 * to it. 2446 */ 2447 if (!(flags & BDRV_O_NO_IO)) { 2448 perm |= BLK_PERM_CONSISTENT_READ; 2449 } 2450 shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE); 2451 } 2452 2453 if (role & BDRV_CHILD_DATA) { 2454 /* 2455 * Technically, everything in this block is a subset of the 2456 * BDRV_CHILD_METADATA path taken above, and so this could 2457 * be an "else if" branch. However, that is not obvious, and 2458 * this function is not performance critical, therefore we let 2459 * this be an independent "if". 2460 */ 2461 2462 /* 2463 * We cannot allow other users to resize the file because the 2464 * format driver might have some assumptions about the size 2465 * (e.g. because it is stored in metadata, or because the file 2466 * is split into fixed-size data files). 2467 */ 2468 shared &= ~BLK_PERM_RESIZE; 2469 2470 /* 2471 * WRITE_UNCHANGED often cannot be performed as such on the 2472 * data file. For example, the qcow2 driver may still need to 2473 * write copied clusters on copy-on-read. 2474 */ 2475 if (perm & BLK_PERM_WRITE_UNCHANGED) { 2476 perm |= BLK_PERM_WRITE; 2477 } 2478 2479 /* 2480 * If the data file is written to, the format driver may 2481 * expect to be able to resize it by writing beyond the EOF. 2482 */ 2483 if (perm & BLK_PERM_WRITE) { 2484 perm |= BLK_PERM_RESIZE; 2485 } 2486 } 2487 2488 if (bs->open_flags & BDRV_O_INACTIVE) { 2489 shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE; 2490 } 2491 2492 *nperm = perm; 2493 *nshared = shared; 2494 } 2495 2496 void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c, 2497 BdrvChildRole role, BlockReopenQueue *reopen_queue, 2498 uint64_t perm, uint64_t shared, 2499 uint64_t *nperm, uint64_t *nshared) 2500 { 2501 if (role & BDRV_CHILD_FILTERED) { 2502 assert(!(role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA | 2503 BDRV_CHILD_COW))); 2504 bdrv_filter_default_perms(bs, c, role, reopen_queue, 2505 perm, shared, nperm, nshared); 2506 } else if (role & BDRV_CHILD_COW) { 2507 assert(!(role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA))); 2508 bdrv_default_perms_for_cow(bs, c, role, reopen_queue, 2509 perm, shared, nperm, nshared); 2510 } else if (role & (BDRV_CHILD_METADATA | BDRV_CHILD_DATA)) { 2511 bdrv_default_perms_for_storage(bs, c, role, reopen_queue, 2512 perm, shared, nperm, nshared); 2513 } else { 2514 g_assert_not_reached(); 2515 } 2516 } 2517 2518 uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm) 2519 { 2520 static const uint64_t permissions[] = { 2521 [BLOCK_PERMISSION_CONSISTENT_READ] = BLK_PERM_CONSISTENT_READ, 2522 [BLOCK_PERMISSION_WRITE] = BLK_PERM_WRITE, 2523 [BLOCK_PERMISSION_WRITE_UNCHANGED] = BLK_PERM_WRITE_UNCHANGED, 2524 [BLOCK_PERMISSION_RESIZE] = BLK_PERM_RESIZE, 2525 [BLOCK_PERMISSION_GRAPH_MOD] = BLK_PERM_GRAPH_MOD, 2526 }; 2527 2528 QEMU_BUILD_BUG_ON(ARRAY_SIZE(permissions) != BLOCK_PERMISSION__MAX); 2529 QEMU_BUILD_BUG_ON(1UL << ARRAY_SIZE(permissions) != BLK_PERM_ALL + 1); 2530 2531 assert(qapi_perm < BLOCK_PERMISSION__MAX); 2532 2533 return permissions[qapi_perm]; 2534 } 2535 2536 static void bdrv_replace_child_noperm(BdrvChild *child, 2537 BlockDriverState *new_bs) 2538 { 2539 BlockDriverState *old_bs = child->bs; 2540 int new_bs_quiesce_counter; 2541 int drain_saldo; 2542 2543 assert(!child->frozen); 2544 2545 if (old_bs && new_bs) { 2546 assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs)); 2547 } 2548 2549 new_bs_quiesce_counter = (new_bs ? new_bs->quiesce_counter : 0); 2550 drain_saldo = new_bs_quiesce_counter - child->parent_quiesce_counter; 2551 2552 /* 2553 * If the new child node is drained but the old one was not, flush 2554 * all outstanding requests to the old child node. 2555 */ 2556 while (drain_saldo > 0 && child->klass->drained_begin) { 2557 bdrv_parent_drained_begin_single(child, true); 2558 drain_saldo--; 2559 } 2560 2561 if (old_bs) { 2562 /* Detach first so that the recursive drain sections coming from @child 2563 * are already gone and we only end the drain sections that came from 2564 * elsewhere. */ 2565 if (child->klass->detach) { 2566 child->klass->detach(child); 2567 } 2568 QLIST_REMOVE(child, next_parent); 2569 } 2570 2571 child->bs = new_bs; 2572 2573 if (new_bs) { 2574 QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent); 2575 2576 /* 2577 * Detaching the old node may have led to the new node's 2578 * quiesce_counter having been decreased. Not a problem, we 2579 * just need to recognize this here and then invoke 2580 * drained_end appropriately more often. 2581 */ 2582 assert(new_bs->quiesce_counter <= new_bs_quiesce_counter); 2583 drain_saldo += new_bs->quiesce_counter - new_bs_quiesce_counter; 2584 2585 /* Attach only after starting new drained sections, so that recursive 2586 * drain sections coming from @child don't get an extra .drained_begin 2587 * callback. */ 2588 if (child->klass->attach) { 2589 child->klass->attach(child); 2590 } 2591 } 2592 2593 /* 2594 * If the old child node was drained but the new one is not, allow 2595 * requests to come in only after the new node has been attached. 2596 */ 2597 while (drain_saldo < 0 && child->klass->drained_end) { 2598 bdrv_parent_drained_end_single(child); 2599 drain_saldo++; 2600 } 2601 } 2602 2603 /* 2604 * Updates @child to change its reference to point to @new_bs, including 2605 * checking and applying the necessary permission updates both to the old node 2606 * and to @new_bs. 2607 * 2608 * NULL is passed as @new_bs for removing the reference before freeing @child. 2609 * 2610 * If @new_bs is not NULL, bdrv_check_perm() must be called beforehand, as this 2611 * function uses bdrv_set_perm() to update the permissions according to the new 2612 * reference that @new_bs gets. 2613 * 2614 * Callers must ensure that child->frozen is false. 2615 */ 2616 static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs) 2617 { 2618 BlockDriverState *old_bs = child->bs; 2619 uint64_t perm, shared_perm; 2620 2621 /* Asserts that child->frozen == false */ 2622 bdrv_replace_child_noperm(child, new_bs); 2623 2624 /* 2625 * Start with the new node's permissions. If @new_bs is a (direct 2626 * or indirect) child of @old_bs, we must complete the permission 2627 * update on @new_bs before we loosen the restrictions on @old_bs. 2628 * Otherwise, bdrv_check_perm() on @old_bs would re-initiate 2629 * updating the permissions of @new_bs, and thus not purely loosen 2630 * restrictions. 2631 */ 2632 if (new_bs) { 2633 bdrv_get_cumulative_perm(new_bs, &perm, &shared_perm); 2634 bdrv_set_perm(new_bs, perm, shared_perm); 2635 } 2636 2637 if (old_bs) { 2638 /* Update permissions for old node. This is guaranteed to succeed 2639 * because we're just taking a parent away, so we're loosening 2640 * restrictions. */ 2641 bool tighten_restrictions; 2642 int ret; 2643 2644 bdrv_get_cumulative_perm(old_bs, &perm, &shared_perm); 2645 ret = bdrv_check_perm(old_bs, NULL, perm, shared_perm, NULL, 2646 &tighten_restrictions, NULL); 2647 assert(tighten_restrictions == false); 2648 if (ret < 0) { 2649 /* We only tried to loosen restrictions, so errors are not fatal */ 2650 bdrv_abort_perm_update(old_bs); 2651 } else { 2652 bdrv_set_perm(old_bs, perm, shared_perm); 2653 } 2654 2655 /* When the parent requiring a non-default AioContext is removed, the 2656 * node moves back to the main AioContext */ 2657 bdrv_try_set_aio_context(old_bs, qemu_get_aio_context(), NULL); 2658 } 2659 } 2660 2661 /* 2662 * This function steals the reference to child_bs from the caller. 2663 * That reference is later dropped by bdrv_root_unref_child(). 2664 * 2665 * On failure NULL is returned, errp is set and the reference to 2666 * child_bs is also dropped. 2667 * 2668 * The caller must hold the AioContext lock @child_bs, but not that of @ctx 2669 * (unless @child_bs is already in @ctx). 2670 */ 2671 BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs, 2672 const char *child_name, 2673 const BdrvChildClass *child_class, 2674 BdrvChildRole child_role, 2675 AioContext *ctx, 2676 uint64_t perm, uint64_t shared_perm, 2677 void *opaque, Error **errp) 2678 { 2679 BdrvChild *child; 2680 Error *local_err = NULL; 2681 int ret; 2682 2683 ret = bdrv_check_update_perm(child_bs, NULL, perm, shared_perm, NULL, NULL, 2684 errp); 2685 if (ret < 0) { 2686 bdrv_abort_perm_update(child_bs); 2687 bdrv_unref(child_bs); 2688 return NULL; 2689 } 2690 2691 child = g_new(BdrvChild, 1); 2692 *child = (BdrvChild) { 2693 .bs = NULL, 2694 .name = g_strdup(child_name), 2695 .klass = child_class, 2696 .role = child_role, 2697 .perm = perm, 2698 .shared_perm = shared_perm, 2699 .opaque = opaque, 2700 }; 2701 2702 /* If the AioContexts don't match, first try to move the subtree of 2703 * child_bs into the AioContext of the new parent. If this doesn't work, 2704 * try moving the parent into the AioContext of child_bs instead. */ 2705 if (bdrv_get_aio_context(child_bs) != ctx) { 2706 ret = bdrv_try_set_aio_context(child_bs, ctx, &local_err); 2707 if (ret < 0 && child_class->can_set_aio_ctx) { 2708 GSList *ignore = g_slist_prepend(NULL, child); 2709 ctx = bdrv_get_aio_context(child_bs); 2710 if (child_class->can_set_aio_ctx(child, ctx, &ignore, NULL)) { 2711 error_free(local_err); 2712 ret = 0; 2713 g_slist_free(ignore); 2714 ignore = g_slist_prepend(NULL, child); 2715 child_class->set_aio_ctx(child, ctx, &ignore); 2716 } 2717 g_slist_free(ignore); 2718 } 2719 if (ret < 0) { 2720 error_propagate(errp, local_err); 2721 g_free(child); 2722 bdrv_abort_perm_update(child_bs); 2723 bdrv_unref(child_bs); 2724 return NULL; 2725 } 2726 } 2727 2728 /* This performs the matching bdrv_set_perm() for the above check. */ 2729 bdrv_replace_child(child, child_bs); 2730 2731 return child; 2732 } 2733 2734 /* 2735 * This function transfers the reference to child_bs from the caller 2736 * to parent_bs. That reference is later dropped by parent_bs on 2737 * bdrv_close() or if someone calls bdrv_unref_child(). 2738 * 2739 * On failure NULL is returned, errp is set and the reference to 2740 * child_bs is also dropped. 2741 * 2742 * If @parent_bs and @child_bs are in different AioContexts, the caller must 2743 * hold the AioContext lock for @child_bs, but not for @parent_bs. 2744 */ 2745 BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs, 2746 BlockDriverState *child_bs, 2747 const char *child_name, 2748 const BdrvChildClass *child_class, 2749 BdrvChildRole child_role, 2750 Error **errp) 2751 { 2752 BdrvChild *child; 2753 uint64_t perm, shared_perm; 2754 2755 bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm); 2756 2757 assert(parent_bs->drv); 2758 bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL, 2759 perm, shared_perm, &perm, &shared_perm); 2760 2761 child = bdrv_root_attach_child(child_bs, child_name, child_class, 2762 child_role, bdrv_get_aio_context(parent_bs), 2763 perm, shared_perm, parent_bs, errp); 2764 if (child == NULL) { 2765 return NULL; 2766 } 2767 2768 QLIST_INSERT_HEAD(&parent_bs->children, child, next); 2769 return child; 2770 } 2771 2772 static void bdrv_detach_child(BdrvChild *child) 2773 { 2774 QLIST_SAFE_REMOVE(child, next); 2775 2776 bdrv_replace_child(child, NULL); 2777 2778 g_free(child->name); 2779 g_free(child); 2780 } 2781 2782 /* Callers must ensure that child->frozen is false. */ 2783 void bdrv_root_unref_child(BdrvChild *child) 2784 { 2785 BlockDriverState *child_bs; 2786 2787 child_bs = child->bs; 2788 bdrv_detach_child(child); 2789 bdrv_unref(child_bs); 2790 } 2791 2792 /** 2793 * Clear all inherits_from pointers from children and grandchildren of 2794 * @root that point to @root, where necessary. 2795 */ 2796 static void bdrv_unset_inherits_from(BlockDriverState *root, BdrvChild *child) 2797 { 2798 BdrvChild *c; 2799 2800 if (child->bs->inherits_from == root) { 2801 /* 2802 * Remove inherits_from only when the last reference between root and 2803 * child->bs goes away. 2804 */ 2805 QLIST_FOREACH(c, &root->children, next) { 2806 if (c != child && c->bs == child->bs) { 2807 break; 2808 } 2809 } 2810 if (c == NULL) { 2811 child->bs->inherits_from = NULL; 2812 } 2813 } 2814 2815 QLIST_FOREACH(c, &child->bs->children, next) { 2816 bdrv_unset_inherits_from(root, c); 2817 } 2818 } 2819 2820 /* Callers must ensure that child->frozen is false. */ 2821 void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child) 2822 { 2823 if (child == NULL) { 2824 return; 2825 } 2826 2827 bdrv_unset_inherits_from(parent, child); 2828 bdrv_root_unref_child(child); 2829 } 2830 2831 2832 static void bdrv_parent_cb_change_media(BlockDriverState *bs, bool load) 2833 { 2834 BdrvChild *c; 2835 QLIST_FOREACH(c, &bs->parents, next_parent) { 2836 if (c->klass->change_media) { 2837 c->klass->change_media(c, load); 2838 } 2839 } 2840 } 2841 2842 /* Return true if you can reach parent going through child->inherits_from 2843 * recursively. If parent or child are NULL, return false */ 2844 static bool bdrv_inherits_from_recursive(BlockDriverState *child, 2845 BlockDriverState *parent) 2846 { 2847 while (child && child != parent) { 2848 child = child->inherits_from; 2849 } 2850 2851 return child != NULL; 2852 } 2853 2854 /* 2855 * Return the BdrvChildRole for @bs's backing child. bs->backing is 2856 * mostly used for COW backing children (role = COW), but also for 2857 * filtered children (role = FILTERED | PRIMARY). 2858 */ 2859 static BdrvChildRole bdrv_backing_role(BlockDriverState *bs) 2860 { 2861 if (bs->drv && bs->drv->is_filter) { 2862 return BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY; 2863 } else { 2864 return BDRV_CHILD_COW; 2865 } 2866 } 2867 2868 /* 2869 * Sets the bs->backing link of a BDS. A new reference is created; callers 2870 * which don't need their own reference any more must call bdrv_unref(). 2871 */ 2872 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd, 2873 Error **errp) 2874 { 2875 bool update_inherits_from = bdrv_chain_contains(bs, backing_hd) && 2876 bdrv_inherits_from_recursive(backing_hd, bs); 2877 2878 if (bdrv_is_backing_chain_frozen(bs, child_bs(bs->backing), errp)) { 2879 return; 2880 } 2881 2882 if (backing_hd) { 2883 bdrv_ref(backing_hd); 2884 } 2885 2886 if (bs->backing) { 2887 /* Cannot be frozen, we checked that above */ 2888 bdrv_unref_child(bs, bs->backing); 2889 bs->backing = NULL; 2890 } 2891 2892 if (!backing_hd) { 2893 goto out; 2894 } 2895 2896 bs->backing = bdrv_attach_child(bs, backing_hd, "backing", &child_of_bds, 2897 bdrv_backing_role(bs), errp); 2898 /* If backing_hd was already part of bs's backing chain, and 2899 * inherits_from pointed recursively to bs then let's update it to 2900 * point directly to bs (else it will become NULL). */ 2901 if (bs->backing && update_inherits_from) { 2902 backing_hd->inherits_from = bs; 2903 } 2904 2905 out: 2906 bdrv_refresh_limits(bs, NULL); 2907 } 2908 2909 /* 2910 * Opens the backing file for a BlockDriverState if not yet open 2911 * 2912 * bdref_key specifies the key for the image's BlockdevRef in the options QDict. 2913 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict 2914 * itself, all options starting with "${bdref_key}." are considered part of the 2915 * BlockdevRef. 2916 * 2917 * TODO Can this be unified with bdrv_open_image()? 2918 */ 2919 int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options, 2920 const char *bdref_key, Error **errp) 2921 { 2922 char *backing_filename = NULL; 2923 char *bdref_key_dot; 2924 const char *reference = NULL; 2925 int ret = 0; 2926 bool implicit_backing = false; 2927 BlockDriverState *backing_hd; 2928 QDict *options; 2929 QDict *tmp_parent_options = NULL; 2930 Error *local_err = NULL; 2931 2932 if (bs->backing != NULL) { 2933 goto free_exit; 2934 } 2935 2936 /* NULL means an empty set of options */ 2937 if (parent_options == NULL) { 2938 tmp_parent_options = qdict_new(); 2939 parent_options = tmp_parent_options; 2940 } 2941 2942 bs->open_flags &= ~BDRV_O_NO_BACKING; 2943 2944 bdref_key_dot = g_strdup_printf("%s.", bdref_key); 2945 qdict_extract_subqdict(parent_options, &options, bdref_key_dot); 2946 g_free(bdref_key_dot); 2947 2948 /* 2949 * Caution: while qdict_get_try_str() is fine, getting non-string 2950 * types would require more care. When @parent_options come from 2951 * -blockdev or blockdev_add, its members are typed according to 2952 * the QAPI schema, but when they come from -drive, they're all 2953 * QString. 2954 */ 2955 reference = qdict_get_try_str(parent_options, bdref_key); 2956 if (reference || qdict_haskey(options, "file.filename")) { 2957 /* keep backing_filename NULL */ 2958 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) { 2959 qobject_unref(options); 2960 goto free_exit; 2961 } else { 2962 if (qdict_size(options) == 0) { 2963 /* If the user specifies options that do not modify the 2964 * backing file's behavior, we might still consider it the 2965 * implicit backing file. But it's easier this way, and 2966 * just specifying some of the backing BDS's options is 2967 * only possible with -drive anyway (otherwise the QAPI 2968 * schema forces the user to specify everything). */ 2969 implicit_backing = !strcmp(bs->auto_backing_file, bs->backing_file); 2970 } 2971 2972 backing_filename = bdrv_get_full_backing_filename(bs, &local_err); 2973 if (local_err) { 2974 ret = -EINVAL; 2975 error_propagate(errp, local_err); 2976 qobject_unref(options); 2977 goto free_exit; 2978 } 2979 } 2980 2981 if (!bs->drv || !bs->drv->supports_backing) { 2982 ret = -EINVAL; 2983 error_setg(errp, "Driver doesn't support backing files"); 2984 qobject_unref(options); 2985 goto free_exit; 2986 } 2987 2988 if (!reference && 2989 bs->backing_format[0] != '\0' && !qdict_haskey(options, "driver")) { 2990 qdict_put_str(options, "driver", bs->backing_format); 2991 } 2992 2993 backing_hd = bdrv_open_inherit(backing_filename, reference, options, 0, bs, 2994 &child_of_bds, bdrv_backing_role(bs), errp); 2995 if (!backing_hd) { 2996 bs->open_flags |= BDRV_O_NO_BACKING; 2997 error_prepend(errp, "Could not open backing file: "); 2998 ret = -EINVAL; 2999 goto free_exit; 3000 } 3001 3002 if (implicit_backing) { 3003 bdrv_refresh_filename(backing_hd); 3004 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), 3005 backing_hd->filename); 3006 } 3007 3008 /* Hook up the backing file link; drop our reference, bs owns the 3009 * backing_hd reference now */ 3010 bdrv_set_backing_hd(bs, backing_hd, &local_err); 3011 bdrv_unref(backing_hd); 3012 if (local_err) { 3013 error_propagate(errp, local_err); 3014 ret = -EINVAL; 3015 goto free_exit; 3016 } 3017 3018 qdict_del(parent_options, bdref_key); 3019 3020 free_exit: 3021 g_free(backing_filename); 3022 qobject_unref(tmp_parent_options); 3023 return ret; 3024 } 3025 3026 static BlockDriverState * 3027 bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key, 3028 BlockDriverState *parent, const BdrvChildClass *child_class, 3029 BdrvChildRole child_role, bool allow_none, Error **errp) 3030 { 3031 BlockDriverState *bs = NULL; 3032 QDict *image_options; 3033 char *bdref_key_dot; 3034 const char *reference; 3035 3036 assert(child_class != NULL); 3037 3038 bdref_key_dot = g_strdup_printf("%s.", bdref_key); 3039 qdict_extract_subqdict(options, &image_options, bdref_key_dot); 3040 g_free(bdref_key_dot); 3041 3042 /* 3043 * Caution: while qdict_get_try_str() is fine, getting non-string 3044 * types would require more care. When @options come from 3045 * -blockdev or blockdev_add, its members are typed according to 3046 * the QAPI schema, but when they come from -drive, they're all 3047 * QString. 3048 */ 3049 reference = qdict_get_try_str(options, bdref_key); 3050 if (!filename && !reference && !qdict_size(image_options)) { 3051 if (!allow_none) { 3052 error_setg(errp, "A block device must be specified for \"%s\"", 3053 bdref_key); 3054 } 3055 qobject_unref(image_options); 3056 goto done; 3057 } 3058 3059 bs = bdrv_open_inherit(filename, reference, image_options, 0, 3060 parent, child_class, child_role, errp); 3061 if (!bs) { 3062 goto done; 3063 } 3064 3065 done: 3066 qdict_del(options, bdref_key); 3067 return bs; 3068 } 3069 3070 /* 3071 * Opens a disk image whose options are given as BlockdevRef in another block 3072 * device's options. 3073 * 3074 * If allow_none is true, no image will be opened if filename is false and no 3075 * BlockdevRef is given. NULL will be returned, but errp remains unset. 3076 * 3077 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict. 3078 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict 3079 * itself, all options starting with "${bdref_key}." are considered part of the 3080 * BlockdevRef. 3081 * 3082 * The BlockdevRef will be removed from the options QDict. 3083 */ 3084 BdrvChild *bdrv_open_child(const char *filename, 3085 QDict *options, const char *bdref_key, 3086 BlockDriverState *parent, 3087 const BdrvChildClass *child_class, 3088 BdrvChildRole child_role, 3089 bool allow_none, Error **errp) 3090 { 3091 BlockDriverState *bs; 3092 3093 bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_class, 3094 child_role, allow_none, errp); 3095 if (bs == NULL) { 3096 return NULL; 3097 } 3098 3099 return bdrv_attach_child(parent, bs, bdref_key, child_class, child_role, 3100 errp); 3101 } 3102 3103 /* 3104 * TODO Future callers may need to specify parent/child_class in order for 3105 * option inheritance to work. Existing callers use it for the root node. 3106 */ 3107 BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp) 3108 { 3109 BlockDriverState *bs = NULL; 3110 QObject *obj = NULL; 3111 QDict *qdict = NULL; 3112 const char *reference = NULL; 3113 Visitor *v = NULL; 3114 3115 if (ref->type == QTYPE_QSTRING) { 3116 reference = ref->u.reference; 3117 } else { 3118 BlockdevOptions *options = &ref->u.definition; 3119 assert(ref->type == QTYPE_QDICT); 3120 3121 v = qobject_output_visitor_new(&obj); 3122 visit_type_BlockdevOptions(v, NULL, &options, &error_abort); 3123 visit_complete(v, &obj); 3124 3125 qdict = qobject_to(QDict, obj); 3126 qdict_flatten(qdict); 3127 3128 /* bdrv_open_inherit() defaults to the values in bdrv_flags (for 3129 * compatibility with other callers) rather than what we want as the 3130 * real defaults. Apply the defaults here instead. */ 3131 qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off"); 3132 qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off"); 3133 qdict_set_default_str(qdict, BDRV_OPT_READ_ONLY, "off"); 3134 qdict_set_default_str(qdict, BDRV_OPT_AUTO_READ_ONLY, "off"); 3135 3136 } 3137 3138 bs = bdrv_open_inherit(NULL, reference, qdict, 0, NULL, NULL, 0, errp); 3139 obj = NULL; 3140 qobject_unref(obj); 3141 visit_free(v); 3142 return bs; 3143 } 3144 3145 static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs, 3146 int flags, 3147 QDict *snapshot_options, 3148 Error **errp) 3149 { 3150 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */ 3151 char *tmp_filename = g_malloc0(PATH_MAX + 1); 3152 int64_t total_size; 3153 QemuOpts *opts = NULL; 3154 BlockDriverState *bs_snapshot = NULL; 3155 Error *local_err = NULL; 3156 int ret; 3157 3158 /* if snapshot, we create a temporary backing file and open it 3159 instead of opening 'filename' directly */ 3160 3161 /* Get the required size from the image */ 3162 total_size = bdrv_getlength(bs); 3163 if (total_size < 0) { 3164 error_setg_errno(errp, -total_size, "Could not get image size"); 3165 goto out; 3166 } 3167 3168 /* Create the temporary image */ 3169 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1); 3170 if (ret < 0) { 3171 error_setg_errno(errp, -ret, "Could not get temporary filename"); 3172 goto out; 3173 } 3174 3175 opts = qemu_opts_create(bdrv_qcow2.create_opts, NULL, 0, 3176 &error_abort); 3177 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size, &error_abort); 3178 ret = bdrv_create(&bdrv_qcow2, tmp_filename, opts, errp); 3179 qemu_opts_del(opts); 3180 if (ret < 0) { 3181 error_prepend(errp, "Could not create temporary overlay '%s': ", 3182 tmp_filename); 3183 goto out; 3184 } 3185 3186 /* Prepare options QDict for the temporary file */ 3187 qdict_put_str(snapshot_options, "file.driver", "file"); 3188 qdict_put_str(snapshot_options, "file.filename", tmp_filename); 3189 qdict_put_str(snapshot_options, "driver", "qcow2"); 3190 3191 bs_snapshot = bdrv_open(NULL, NULL, snapshot_options, flags, errp); 3192 snapshot_options = NULL; 3193 if (!bs_snapshot) { 3194 goto out; 3195 } 3196 3197 /* bdrv_append() consumes a strong reference to bs_snapshot 3198 * (i.e. it will call bdrv_unref() on it) even on error, so in 3199 * order to be able to return one, we have to increase 3200 * bs_snapshot's refcount here */ 3201 bdrv_ref(bs_snapshot); 3202 bdrv_append(bs_snapshot, bs, &local_err); 3203 if (local_err) { 3204 error_propagate(errp, local_err); 3205 bs_snapshot = NULL; 3206 goto out; 3207 } 3208 3209 out: 3210 qobject_unref(snapshot_options); 3211 g_free(tmp_filename); 3212 return bs_snapshot; 3213 } 3214 3215 /* 3216 * Opens a disk image (raw, qcow2, vmdk, ...) 3217 * 3218 * options is a QDict of options to pass to the block drivers, or NULL for an 3219 * empty set of options. The reference to the QDict belongs to the block layer 3220 * after the call (even on failure), so if the caller intends to reuse the 3221 * dictionary, it needs to use qobject_ref() before calling bdrv_open. 3222 * 3223 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there. 3224 * If it is not NULL, the referenced BDS will be reused. 3225 * 3226 * The reference parameter may be used to specify an existing block device which 3227 * should be opened. If specified, neither options nor a filename may be given, 3228 * nor can an existing BDS be reused (that is, *pbs has to be NULL). 3229 */ 3230 static BlockDriverState *bdrv_open_inherit(const char *filename, 3231 const char *reference, 3232 QDict *options, int flags, 3233 BlockDriverState *parent, 3234 const BdrvChildClass *child_class, 3235 BdrvChildRole child_role, 3236 Error **errp) 3237 { 3238 int ret; 3239 BlockBackend *file = NULL; 3240 BlockDriverState *bs; 3241 BlockDriver *drv = NULL; 3242 BdrvChild *child; 3243 const char *drvname; 3244 const char *backing; 3245 Error *local_err = NULL; 3246 QDict *snapshot_options = NULL; 3247 int snapshot_flags = 0; 3248 3249 assert(!child_class || !flags); 3250 assert(!child_class == !parent); 3251 3252 if (reference) { 3253 bool options_non_empty = options ? qdict_size(options) : false; 3254 qobject_unref(options); 3255 3256 if (filename || options_non_empty) { 3257 error_setg(errp, "Cannot reference an existing block device with " 3258 "additional options or a new filename"); 3259 return NULL; 3260 } 3261 3262 bs = bdrv_lookup_bs(reference, reference, errp); 3263 if (!bs) { 3264 return NULL; 3265 } 3266 3267 bdrv_ref(bs); 3268 return bs; 3269 } 3270 3271 bs = bdrv_new(); 3272 3273 /* NULL means an empty set of options */ 3274 if (options == NULL) { 3275 options = qdict_new(); 3276 } 3277 3278 /* json: syntax counts as explicit options, as if in the QDict */ 3279 parse_json_protocol(options, &filename, &local_err); 3280 if (local_err) { 3281 goto fail; 3282 } 3283 3284 bs->explicit_options = qdict_clone_shallow(options); 3285 3286 if (child_class) { 3287 bool parent_is_format; 3288 3289 if (parent->drv) { 3290 parent_is_format = parent->drv->is_format; 3291 } else { 3292 /* 3293 * parent->drv is not set yet because this node is opened for 3294 * (potential) format probing. That means that @parent is going 3295 * to be a format node. 3296 */ 3297 parent_is_format = true; 3298 } 3299 3300 bs->inherits_from = parent; 3301 child_class->inherit_options(child_role, parent_is_format, 3302 &flags, options, 3303 parent->open_flags, parent->options); 3304 } 3305 3306 ret = bdrv_fill_options(&options, filename, &flags, &local_err); 3307 if (ret < 0) { 3308 goto fail; 3309 } 3310 3311 /* 3312 * Set the BDRV_O_RDWR and BDRV_O_ALLOW_RDWR flags. 3313 * Caution: getting a boolean member of @options requires care. 3314 * When @options come from -blockdev or blockdev_add, members are 3315 * typed according to the QAPI schema, but when they come from 3316 * -drive, they're all QString. 3317 */ 3318 if (g_strcmp0(qdict_get_try_str(options, BDRV_OPT_READ_ONLY), "on") && 3319 !qdict_get_try_bool(options, BDRV_OPT_READ_ONLY, false)) { 3320 flags |= (BDRV_O_RDWR | BDRV_O_ALLOW_RDWR); 3321 } else { 3322 flags &= ~BDRV_O_RDWR; 3323 } 3324 3325 if (flags & BDRV_O_SNAPSHOT) { 3326 snapshot_options = qdict_new(); 3327 bdrv_temp_snapshot_options(&snapshot_flags, snapshot_options, 3328 flags, options); 3329 /* Let bdrv_backing_options() override "read-only" */ 3330 qdict_del(options, BDRV_OPT_READ_ONLY); 3331 bdrv_inherited_options(BDRV_CHILD_COW, true, 3332 &flags, options, flags, options); 3333 } 3334 3335 bs->open_flags = flags; 3336 bs->options = options; 3337 options = qdict_clone_shallow(options); 3338 3339 /* Find the right image format driver */ 3340 /* See cautionary note on accessing @options above */ 3341 drvname = qdict_get_try_str(options, "driver"); 3342 if (drvname) { 3343 drv = bdrv_find_format(drvname); 3344 if (!drv) { 3345 error_setg(errp, "Unknown driver: '%s'", drvname); 3346 goto fail; 3347 } 3348 } 3349 3350 assert(drvname || !(flags & BDRV_O_PROTOCOL)); 3351 3352 /* See cautionary note on accessing @options above */ 3353 backing = qdict_get_try_str(options, "backing"); 3354 if (qobject_to(QNull, qdict_get(options, "backing")) != NULL || 3355 (backing && *backing == '\0')) 3356 { 3357 if (backing) { 3358 warn_report("Use of \"backing\": \"\" is deprecated; " 3359 "use \"backing\": null instead"); 3360 } 3361 flags |= BDRV_O_NO_BACKING; 3362 qdict_del(bs->explicit_options, "backing"); 3363 qdict_del(bs->options, "backing"); 3364 qdict_del(options, "backing"); 3365 } 3366 3367 /* Open image file without format layer. This BlockBackend is only used for 3368 * probing, the block drivers will do their own bdrv_open_child() for the 3369 * same BDS, which is why we put the node name back into options. */ 3370 if ((flags & BDRV_O_PROTOCOL) == 0) { 3371 BlockDriverState *file_bs; 3372 3373 file_bs = bdrv_open_child_bs(filename, options, "file", bs, 3374 &child_of_bds, BDRV_CHILD_IMAGE, 3375 true, &local_err); 3376 if (local_err) { 3377 goto fail; 3378 } 3379 if (file_bs != NULL) { 3380 /* Not requesting BLK_PERM_CONSISTENT_READ because we're only 3381 * looking at the header to guess the image format. This works even 3382 * in cases where a guest would not see a consistent state. */ 3383 file = blk_new(bdrv_get_aio_context(file_bs), 0, BLK_PERM_ALL); 3384 blk_insert_bs(file, file_bs, &local_err); 3385 bdrv_unref(file_bs); 3386 if (local_err) { 3387 goto fail; 3388 } 3389 3390 qdict_put_str(options, "file", bdrv_get_node_name(file_bs)); 3391 } 3392 } 3393 3394 /* Image format probing */ 3395 bs->probed = !drv; 3396 if (!drv && file) { 3397 ret = find_image_format(file, filename, &drv, &local_err); 3398 if (ret < 0) { 3399 goto fail; 3400 } 3401 /* 3402 * This option update would logically belong in bdrv_fill_options(), 3403 * but we first need to open bs->file for the probing to work, while 3404 * opening bs->file already requires the (mostly) final set of options 3405 * so that cache mode etc. can be inherited. 3406 * 3407 * Adding the driver later is somewhat ugly, but it's not an option 3408 * that would ever be inherited, so it's correct. We just need to make 3409 * sure to update both bs->options (which has the full effective 3410 * options for bs) and options (which has file.* already removed). 3411 */ 3412 qdict_put_str(bs->options, "driver", drv->format_name); 3413 qdict_put_str(options, "driver", drv->format_name); 3414 } else if (!drv) { 3415 error_setg(errp, "Must specify either driver or file"); 3416 goto fail; 3417 } 3418 3419 /* BDRV_O_PROTOCOL must be set iff a protocol BDS is about to be created */ 3420 assert(!!(flags & BDRV_O_PROTOCOL) == !!drv->bdrv_file_open); 3421 /* file must be NULL if a protocol BDS is about to be created 3422 * (the inverse results in an error message from bdrv_open_common()) */ 3423 assert(!(flags & BDRV_O_PROTOCOL) || !file); 3424 3425 /* Open the image */ 3426 ret = bdrv_open_common(bs, file, options, &local_err); 3427 if (ret < 0) { 3428 goto fail; 3429 } 3430 3431 if (file) { 3432 blk_unref(file); 3433 file = NULL; 3434 } 3435 3436 /* If there is a backing file, use it */ 3437 if ((flags & BDRV_O_NO_BACKING) == 0) { 3438 ret = bdrv_open_backing_file(bs, options, "backing", &local_err); 3439 if (ret < 0) { 3440 goto close_and_fail; 3441 } 3442 } 3443 3444 /* Remove all children options and references 3445 * from bs->options and bs->explicit_options */ 3446 QLIST_FOREACH(child, &bs->children, next) { 3447 char *child_key_dot; 3448 child_key_dot = g_strdup_printf("%s.", child->name); 3449 qdict_extract_subqdict(bs->explicit_options, NULL, child_key_dot); 3450 qdict_extract_subqdict(bs->options, NULL, child_key_dot); 3451 qdict_del(bs->explicit_options, child->name); 3452 qdict_del(bs->options, child->name); 3453 g_free(child_key_dot); 3454 } 3455 3456 /* Check if any unknown options were used */ 3457 if (qdict_size(options) != 0) { 3458 const QDictEntry *entry = qdict_first(options); 3459 if (flags & BDRV_O_PROTOCOL) { 3460 error_setg(errp, "Block protocol '%s' doesn't support the option " 3461 "'%s'", drv->format_name, entry->key); 3462 } else { 3463 error_setg(errp, 3464 "Block format '%s' does not support the option '%s'", 3465 drv->format_name, entry->key); 3466 } 3467 3468 goto close_and_fail; 3469 } 3470 3471 bdrv_parent_cb_change_media(bs, true); 3472 3473 qobject_unref(options); 3474 options = NULL; 3475 3476 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the 3477 * temporary snapshot afterwards. */ 3478 if (snapshot_flags) { 3479 BlockDriverState *snapshot_bs; 3480 snapshot_bs = bdrv_append_temp_snapshot(bs, snapshot_flags, 3481 snapshot_options, &local_err); 3482 snapshot_options = NULL; 3483 if (local_err) { 3484 goto close_and_fail; 3485 } 3486 /* We are not going to return bs but the overlay on top of it 3487 * (snapshot_bs); thus, we have to drop the strong reference to bs 3488 * (which we obtained by calling bdrv_new()). bs will not be deleted, 3489 * though, because the overlay still has a reference to it. */ 3490 bdrv_unref(bs); 3491 bs = snapshot_bs; 3492 } 3493 3494 return bs; 3495 3496 fail: 3497 blk_unref(file); 3498 qobject_unref(snapshot_options); 3499 qobject_unref(bs->explicit_options); 3500 qobject_unref(bs->options); 3501 qobject_unref(options); 3502 bs->options = NULL; 3503 bs->explicit_options = NULL; 3504 bdrv_unref(bs); 3505 error_propagate(errp, local_err); 3506 return NULL; 3507 3508 close_and_fail: 3509 bdrv_unref(bs); 3510 qobject_unref(snapshot_options); 3511 qobject_unref(options); 3512 error_propagate(errp, local_err); 3513 return NULL; 3514 } 3515 3516 BlockDriverState *bdrv_open(const char *filename, const char *reference, 3517 QDict *options, int flags, Error **errp) 3518 { 3519 return bdrv_open_inherit(filename, reference, options, flags, NULL, 3520 NULL, 0, errp); 3521 } 3522 3523 /* Return true if the NULL-terminated @list contains @str */ 3524 static bool is_str_in_list(const char *str, const char *const *list) 3525 { 3526 if (str && list) { 3527 int i; 3528 for (i = 0; list[i] != NULL; i++) { 3529 if (!strcmp(str, list[i])) { 3530 return true; 3531 } 3532 } 3533 } 3534 return false; 3535 } 3536 3537 /* 3538 * Check that every option set in @bs->options is also set in 3539 * @new_opts. 3540 * 3541 * Options listed in the common_options list and in 3542 * @bs->drv->mutable_opts are skipped. 3543 * 3544 * Return 0 on success, otherwise return -EINVAL and set @errp. 3545 */ 3546 static int bdrv_reset_options_allowed(BlockDriverState *bs, 3547 const QDict *new_opts, Error **errp) 3548 { 3549 const QDictEntry *e; 3550 /* These options are common to all block drivers and are handled 3551 * in bdrv_reopen_prepare() so they can be left out of @new_opts */ 3552 const char *const common_options[] = { 3553 "node-name", "discard", "cache.direct", "cache.no-flush", 3554 "read-only", "auto-read-only", "detect-zeroes", NULL 3555 }; 3556 3557 for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) { 3558 if (!qdict_haskey(new_opts, e->key) && 3559 !is_str_in_list(e->key, common_options) && 3560 !is_str_in_list(e->key, bs->drv->mutable_opts)) { 3561 error_setg(errp, "Option '%s' cannot be reset " 3562 "to its default value", e->key); 3563 return -EINVAL; 3564 } 3565 } 3566 3567 return 0; 3568 } 3569 3570 /* 3571 * Returns true if @child can be reached recursively from @bs 3572 */ 3573 static bool bdrv_recurse_has_child(BlockDriverState *bs, 3574 BlockDriverState *child) 3575 { 3576 BdrvChild *c; 3577 3578 if (bs == child) { 3579 return true; 3580 } 3581 3582 QLIST_FOREACH(c, &bs->children, next) { 3583 if (bdrv_recurse_has_child(c->bs, child)) { 3584 return true; 3585 } 3586 } 3587 3588 return false; 3589 } 3590 3591 /* 3592 * Adds a BlockDriverState to a simple queue for an atomic, transactional 3593 * reopen of multiple devices. 3594 * 3595 * bs_queue can either be an existing BlockReopenQueue that has had QTAILQ_INIT 3596 * already performed, or alternatively may be NULL a new BlockReopenQueue will 3597 * be created and initialized. This newly created BlockReopenQueue should be 3598 * passed back in for subsequent calls that are intended to be of the same 3599 * atomic 'set'. 3600 * 3601 * bs is the BlockDriverState to add to the reopen queue. 3602 * 3603 * options contains the changed options for the associated bs 3604 * (the BlockReopenQueue takes ownership) 3605 * 3606 * flags contains the open flags for the associated bs 3607 * 3608 * returns a pointer to bs_queue, which is either the newly allocated 3609 * bs_queue, or the existing bs_queue being used. 3610 * 3611 * bs must be drained between bdrv_reopen_queue() and bdrv_reopen_multiple(). 3612 */ 3613 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue, 3614 BlockDriverState *bs, 3615 QDict *options, 3616 const BdrvChildClass *klass, 3617 BdrvChildRole role, 3618 bool parent_is_format, 3619 QDict *parent_options, 3620 int parent_flags, 3621 bool keep_old_opts) 3622 { 3623 assert(bs != NULL); 3624 3625 BlockReopenQueueEntry *bs_entry; 3626 BdrvChild *child; 3627 QDict *old_options, *explicit_options, *options_copy; 3628 int flags; 3629 QemuOpts *opts; 3630 3631 /* Make sure that the caller remembered to use a drained section. This is 3632 * important to avoid graph changes between the recursive queuing here and 3633 * bdrv_reopen_multiple(). */ 3634 assert(bs->quiesce_counter > 0); 3635 3636 if (bs_queue == NULL) { 3637 bs_queue = g_new0(BlockReopenQueue, 1); 3638 QTAILQ_INIT(bs_queue); 3639 } 3640 3641 if (!options) { 3642 options = qdict_new(); 3643 } 3644 3645 /* Check if this BlockDriverState is already in the queue */ 3646 QTAILQ_FOREACH(bs_entry, bs_queue, entry) { 3647 if (bs == bs_entry->state.bs) { 3648 break; 3649 } 3650 } 3651 3652 /* 3653 * Precedence of options: 3654 * 1. Explicitly passed in options (highest) 3655 * 2. Retained from explicitly set options of bs 3656 * 3. Inherited from parent node 3657 * 4. Retained from effective options of bs 3658 */ 3659 3660 /* Old explicitly set values (don't overwrite by inherited value) */ 3661 if (bs_entry || keep_old_opts) { 3662 old_options = qdict_clone_shallow(bs_entry ? 3663 bs_entry->state.explicit_options : 3664 bs->explicit_options); 3665 bdrv_join_options(bs, options, old_options); 3666 qobject_unref(old_options); 3667 } 3668 3669 explicit_options = qdict_clone_shallow(options); 3670 3671 /* Inherit from parent node */ 3672 if (parent_options) { 3673 flags = 0; 3674 klass->inherit_options(role, parent_is_format, &flags, options, 3675 parent_flags, parent_options); 3676 } else { 3677 flags = bdrv_get_flags(bs); 3678 } 3679 3680 if (keep_old_opts) { 3681 /* Old values are used for options that aren't set yet */ 3682 old_options = qdict_clone_shallow(bs->options); 3683 bdrv_join_options(bs, options, old_options); 3684 qobject_unref(old_options); 3685 } 3686 3687 /* We have the final set of options so let's update the flags */ 3688 options_copy = qdict_clone_shallow(options); 3689 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort); 3690 qemu_opts_absorb_qdict(opts, options_copy, NULL); 3691 update_flags_from_options(&flags, opts); 3692 qemu_opts_del(opts); 3693 qobject_unref(options_copy); 3694 3695 /* bdrv_open_inherit() sets and clears some additional flags internally */ 3696 flags &= ~BDRV_O_PROTOCOL; 3697 if (flags & BDRV_O_RDWR) { 3698 flags |= BDRV_O_ALLOW_RDWR; 3699 } 3700 3701 if (!bs_entry) { 3702 bs_entry = g_new0(BlockReopenQueueEntry, 1); 3703 QTAILQ_INSERT_TAIL(bs_queue, bs_entry, entry); 3704 } else { 3705 qobject_unref(bs_entry->state.options); 3706 qobject_unref(bs_entry->state.explicit_options); 3707 } 3708 3709 bs_entry->state.bs = bs; 3710 bs_entry->state.options = options; 3711 bs_entry->state.explicit_options = explicit_options; 3712 bs_entry->state.flags = flags; 3713 3714 /* This needs to be overwritten in bdrv_reopen_prepare() */ 3715 bs_entry->state.perm = UINT64_MAX; 3716 bs_entry->state.shared_perm = 0; 3717 3718 /* 3719 * If keep_old_opts is false then it means that unspecified 3720 * options must be reset to their original value. We don't allow 3721 * resetting 'backing' but we need to know if the option is 3722 * missing in order to decide if we have to return an error. 3723 */ 3724 if (!keep_old_opts) { 3725 bs_entry->state.backing_missing = 3726 !qdict_haskey(options, "backing") && 3727 !qdict_haskey(options, "backing.driver"); 3728 } 3729 3730 QLIST_FOREACH(child, &bs->children, next) { 3731 QDict *new_child_options = NULL; 3732 bool child_keep_old = keep_old_opts; 3733 3734 /* reopen can only change the options of block devices that were 3735 * implicitly created and inherited options. For other (referenced) 3736 * block devices, a syntax like "backing.foo" results in an error. */ 3737 if (child->bs->inherits_from != bs) { 3738 continue; 3739 } 3740 3741 /* Check if the options contain a child reference */ 3742 if (qdict_haskey(options, child->name)) { 3743 const char *childref = qdict_get_try_str(options, child->name); 3744 /* 3745 * The current child must not be reopened if the child 3746 * reference is null or points to a different node. 3747 */ 3748 if (g_strcmp0(childref, child->bs->node_name)) { 3749 continue; 3750 } 3751 /* 3752 * If the child reference points to the current child then 3753 * reopen it with its existing set of options (note that 3754 * it can still inherit new options from the parent). 3755 */ 3756 child_keep_old = true; 3757 } else { 3758 /* Extract child options ("child-name.*") */ 3759 char *child_key_dot = g_strdup_printf("%s.", child->name); 3760 qdict_extract_subqdict(explicit_options, NULL, child_key_dot); 3761 qdict_extract_subqdict(options, &new_child_options, child_key_dot); 3762 g_free(child_key_dot); 3763 } 3764 3765 bdrv_reopen_queue_child(bs_queue, child->bs, new_child_options, 3766 child->klass, child->role, bs->drv->is_format, 3767 options, flags, child_keep_old); 3768 } 3769 3770 return bs_queue; 3771 } 3772 3773 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue, 3774 BlockDriverState *bs, 3775 QDict *options, bool keep_old_opts) 3776 { 3777 return bdrv_reopen_queue_child(bs_queue, bs, options, NULL, 0, false, 3778 NULL, 0, keep_old_opts); 3779 } 3780 3781 /* 3782 * Reopen multiple BlockDriverStates atomically & transactionally. 3783 * 3784 * The queue passed in (bs_queue) must have been built up previous 3785 * via bdrv_reopen_queue(). 3786 * 3787 * Reopens all BDS specified in the queue, with the appropriate 3788 * flags. All devices are prepared for reopen, and failure of any 3789 * device will cause all device changes to be abandoned, and intermediate 3790 * data cleaned up. 3791 * 3792 * If all devices prepare successfully, then the changes are committed 3793 * to all devices. 3794 * 3795 * All affected nodes must be drained between bdrv_reopen_queue() and 3796 * bdrv_reopen_multiple(). 3797 */ 3798 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp) 3799 { 3800 int ret = -1; 3801 BlockReopenQueueEntry *bs_entry, *next; 3802 3803 assert(bs_queue != NULL); 3804 3805 QTAILQ_FOREACH(bs_entry, bs_queue, entry) { 3806 assert(bs_entry->state.bs->quiesce_counter > 0); 3807 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, errp)) { 3808 goto cleanup; 3809 } 3810 bs_entry->prepared = true; 3811 } 3812 3813 QTAILQ_FOREACH(bs_entry, bs_queue, entry) { 3814 BDRVReopenState *state = &bs_entry->state; 3815 ret = bdrv_check_perm(state->bs, bs_queue, state->perm, 3816 state->shared_perm, NULL, NULL, errp); 3817 if (ret < 0) { 3818 goto cleanup_perm; 3819 } 3820 /* Check if new_backing_bs would accept the new permissions */ 3821 if (state->replace_backing_bs && state->new_backing_bs) { 3822 uint64_t nperm, nshared; 3823 bdrv_child_perm(state->bs, state->new_backing_bs, 3824 NULL, bdrv_backing_role(state->bs), 3825 bs_queue, state->perm, state->shared_perm, 3826 &nperm, &nshared); 3827 ret = bdrv_check_update_perm(state->new_backing_bs, NULL, 3828 nperm, nshared, NULL, NULL, errp); 3829 if (ret < 0) { 3830 goto cleanup_perm; 3831 } 3832 } 3833 bs_entry->perms_checked = true; 3834 } 3835 3836 /* 3837 * If we reach this point, we have success and just need to apply the 3838 * changes. 3839 * 3840 * Reverse order is used to comfort qcow2 driver: on commit it need to write 3841 * IN_USE flag to the image, to mark bitmaps in the image as invalid. But 3842 * children are usually goes after parents in reopen-queue, so go from last 3843 * to first element. 3844 */ 3845 QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) { 3846 bdrv_reopen_commit(&bs_entry->state); 3847 } 3848 3849 ret = 0; 3850 cleanup_perm: 3851 QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) { 3852 BDRVReopenState *state = &bs_entry->state; 3853 3854 if (!bs_entry->perms_checked) { 3855 continue; 3856 } 3857 3858 if (ret == 0) { 3859 bdrv_set_perm(state->bs, state->perm, state->shared_perm); 3860 } else { 3861 bdrv_abort_perm_update(state->bs); 3862 if (state->replace_backing_bs && state->new_backing_bs) { 3863 bdrv_abort_perm_update(state->new_backing_bs); 3864 } 3865 } 3866 } 3867 3868 if (ret == 0) { 3869 QTAILQ_FOREACH_REVERSE(bs_entry, bs_queue, entry) { 3870 BlockDriverState *bs = bs_entry->state.bs; 3871 3872 if (bs->drv->bdrv_reopen_commit_post) 3873 bs->drv->bdrv_reopen_commit_post(&bs_entry->state); 3874 } 3875 } 3876 cleanup: 3877 QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) { 3878 if (ret) { 3879 if (bs_entry->prepared) { 3880 bdrv_reopen_abort(&bs_entry->state); 3881 } 3882 qobject_unref(bs_entry->state.explicit_options); 3883 qobject_unref(bs_entry->state.options); 3884 } 3885 if (bs_entry->state.new_backing_bs) { 3886 bdrv_unref(bs_entry->state.new_backing_bs); 3887 } 3888 g_free(bs_entry); 3889 } 3890 g_free(bs_queue); 3891 3892 return ret; 3893 } 3894 3895 int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only, 3896 Error **errp) 3897 { 3898 int ret; 3899 BlockReopenQueue *queue; 3900 QDict *opts = qdict_new(); 3901 3902 qdict_put_bool(opts, BDRV_OPT_READ_ONLY, read_only); 3903 3904 bdrv_subtree_drained_begin(bs); 3905 queue = bdrv_reopen_queue(NULL, bs, opts, true); 3906 ret = bdrv_reopen_multiple(queue, errp); 3907 bdrv_subtree_drained_end(bs); 3908 3909 return ret; 3910 } 3911 3912 static BlockReopenQueueEntry *find_parent_in_reopen_queue(BlockReopenQueue *q, 3913 BdrvChild *c) 3914 { 3915 BlockReopenQueueEntry *entry; 3916 3917 QTAILQ_FOREACH(entry, q, entry) { 3918 BlockDriverState *bs = entry->state.bs; 3919 BdrvChild *child; 3920 3921 QLIST_FOREACH(child, &bs->children, next) { 3922 if (child == c) { 3923 return entry; 3924 } 3925 } 3926 } 3927 3928 return NULL; 3929 } 3930 3931 static void bdrv_reopen_perm(BlockReopenQueue *q, BlockDriverState *bs, 3932 uint64_t *perm, uint64_t *shared) 3933 { 3934 BdrvChild *c; 3935 BlockReopenQueueEntry *parent; 3936 uint64_t cumulative_perms = 0; 3937 uint64_t cumulative_shared_perms = BLK_PERM_ALL; 3938 3939 QLIST_FOREACH(c, &bs->parents, next_parent) { 3940 parent = find_parent_in_reopen_queue(q, c); 3941 if (!parent) { 3942 cumulative_perms |= c->perm; 3943 cumulative_shared_perms &= c->shared_perm; 3944 } else { 3945 uint64_t nperm, nshared; 3946 3947 bdrv_child_perm(parent->state.bs, bs, c, c->role, q, 3948 parent->state.perm, parent->state.shared_perm, 3949 &nperm, &nshared); 3950 3951 cumulative_perms |= nperm; 3952 cumulative_shared_perms &= nshared; 3953 } 3954 } 3955 *perm = cumulative_perms; 3956 *shared = cumulative_shared_perms; 3957 } 3958 3959 static bool bdrv_reopen_can_attach(BlockDriverState *parent, 3960 BdrvChild *child, 3961 BlockDriverState *new_child, 3962 Error **errp) 3963 { 3964 AioContext *parent_ctx = bdrv_get_aio_context(parent); 3965 AioContext *child_ctx = bdrv_get_aio_context(new_child); 3966 GSList *ignore; 3967 bool ret; 3968 3969 ignore = g_slist_prepend(NULL, child); 3970 ret = bdrv_can_set_aio_context(new_child, parent_ctx, &ignore, NULL); 3971 g_slist_free(ignore); 3972 if (ret) { 3973 return ret; 3974 } 3975 3976 ignore = g_slist_prepend(NULL, child); 3977 ret = bdrv_can_set_aio_context(parent, child_ctx, &ignore, errp); 3978 g_slist_free(ignore); 3979 return ret; 3980 } 3981 3982 /* 3983 * Take a BDRVReopenState and check if the value of 'backing' in the 3984 * reopen_state->options QDict is valid or not. 3985 * 3986 * If 'backing' is missing from the QDict then return 0. 3987 * 3988 * If 'backing' contains the node name of the backing file of 3989 * reopen_state->bs then return 0. 3990 * 3991 * If 'backing' contains a different node name (or is null) then check 3992 * whether the current backing file can be replaced with the new one. 3993 * If that's the case then reopen_state->replace_backing_bs is set to 3994 * true and reopen_state->new_backing_bs contains a pointer to the new 3995 * backing BlockDriverState (or NULL). 3996 * 3997 * Return 0 on success, otherwise return < 0 and set @errp. 3998 */ 3999 static int bdrv_reopen_parse_backing(BDRVReopenState *reopen_state, 4000 Error **errp) 4001 { 4002 BlockDriverState *bs = reopen_state->bs; 4003 BlockDriverState *overlay_bs, *below_bs, *new_backing_bs; 4004 QObject *value; 4005 const char *str; 4006 4007 value = qdict_get(reopen_state->options, "backing"); 4008 if (value == NULL) { 4009 return 0; 4010 } 4011 4012 switch (qobject_type(value)) { 4013 case QTYPE_QNULL: 4014 new_backing_bs = NULL; 4015 break; 4016 case QTYPE_QSTRING: 4017 str = qobject_get_try_str(value); 4018 new_backing_bs = bdrv_lookup_bs(NULL, str, errp); 4019 if (new_backing_bs == NULL) { 4020 return -EINVAL; 4021 } else if (bdrv_recurse_has_child(new_backing_bs, bs)) { 4022 error_setg(errp, "Making '%s' a backing file of '%s' " 4023 "would create a cycle", str, bs->node_name); 4024 return -EINVAL; 4025 } 4026 break; 4027 default: 4028 /* 'backing' does not allow any other data type */ 4029 g_assert_not_reached(); 4030 } 4031 4032 /* 4033 * Check AioContext compatibility so that the bdrv_set_backing_hd() call in 4034 * bdrv_reopen_commit() won't fail. 4035 */ 4036 if (new_backing_bs) { 4037 if (!bdrv_reopen_can_attach(bs, bs->backing, new_backing_bs, errp)) { 4038 return -EINVAL; 4039 } 4040 } 4041 4042 /* 4043 * Ensure that @bs can really handle backing files, because we are 4044 * about to give it one (or swap the existing one) 4045 */ 4046 if (bs->drv->is_filter) { 4047 /* Filters always have a file or a backing child */ 4048 if (!bs->backing) { 4049 error_setg(errp, "'%s' is a %s filter node that does not support a " 4050 "backing child", bs->node_name, bs->drv->format_name); 4051 return -EINVAL; 4052 } 4053 } else if (!bs->drv->supports_backing) { 4054 error_setg(errp, "Driver '%s' of node '%s' does not support backing " 4055 "files", bs->drv->format_name, bs->node_name); 4056 return -EINVAL; 4057 } 4058 4059 /* 4060 * Find the "actual" backing file by skipping all links that point 4061 * to an implicit node, if any (e.g. a commit filter node). 4062 * We cannot use any of the bdrv_skip_*() functions here because 4063 * those return the first explicit node, while we are looking for 4064 * its overlay here. 4065 */ 4066 overlay_bs = bs; 4067 for (below_bs = bdrv_filter_or_cow_bs(overlay_bs); 4068 below_bs && below_bs->implicit; 4069 below_bs = bdrv_filter_or_cow_bs(overlay_bs)) 4070 { 4071 overlay_bs = below_bs; 4072 } 4073 4074 /* If we want to replace the backing file we need some extra checks */ 4075 if (new_backing_bs != bdrv_filter_or_cow_bs(overlay_bs)) { 4076 /* Check for implicit nodes between bs and its backing file */ 4077 if (bs != overlay_bs) { 4078 error_setg(errp, "Cannot change backing link if '%s' has " 4079 "an implicit backing file", bs->node_name); 4080 return -EPERM; 4081 } 4082 /* 4083 * Check if the backing link that we want to replace is frozen. 4084 * Note that 4085 * bdrv_filter_or_cow_child(overlay_bs) == overlay_bs->backing, 4086 * because we know that overlay_bs == bs, and that @bs 4087 * either is a filter that uses ->backing or a COW format BDS 4088 * with bs->drv->supports_backing == true. 4089 */ 4090 if (bdrv_is_backing_chain_frozen(overlay_bs, 4091 child_bs(overlay_bs->backing), errp)) 4092 { 4093 return -EPERM; 4094 } 4095 reopen_state->replace_backing_bs = true; 4096 if (new_backing_bs) { 4097 bdrv_ref(new_backing_bs); 4098 reopen_state->new_backing_bs = new_backing_bs; 4099 } 4100 } 4101 4102 return 0; 4103 } 4104 4105 /* 4106 * Prepares a BlockDriverState for reopen. All changes are staged in the 4107 * 'opaque' field of the BDRVReopenState, which is used and allocated by 4108 * the block driver layer .bdrv_reopen_prepare() 4109 * 4110 * bs is the BlockDriverState to reopen 4111 * flags are the new open flags 4112 * queue is the reopen queue 4113 * 4114 * Returns 0 on success, non-zero on error. On error errp will be set 4115 * as well. 4116 * 4117 * On failure, bdrv_reopen_abort() will be called to clean up any data. 4118 * It is the responsibility of the caller to then call the abort() or 4119 * commit() for any other BDS that have been left in a prepare() state 4120 * 4121 */ 4122 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, 4123 Error **errp) 4124 { 4125 int ret = -1; 4126 int old_flags; 4127 Error *local_err = NULL; 4128 BlockDriver *drv; 4129 QemuOpts *opts; 4130 QDict *orig_reopen_opts; 4131 char *discard = NULL; 4132 bool read_only; 4133 bool drv_prepared = false; 4134 4135 assert(reopen_state != NULL); 4136 assert(reopen_state->bs->drv != NULL); 4137 drv = reopen_state->bs->drv; 4138 4139 /* This function and each driver's bdrv_reopen_prepare() remove 4140 * entries from reopen_state->options as they are processed, so 4141 * we need to make a copy of the original QDict. */ 4142 orig_reopen_opts = qdict_clone_shallow(reopen_state->options); 4143 4144 /* Process generic block layer options */ 4145 opts = qemu_opts_create(&bdrv_runtime_opts, NULL, 0, &error_abort); 4146 if (!qemu_opts_absorb_qdict(opts, reopen_state->options, errp)) { 4147 ret = -EINVAL; 4148 goto error; 4149 } 4150 4151 /* This was already called in bdrv_reopen_queue_child() so the flags 4152 * are up-to-date. This time we simply want to remove the options from 4153 * QemuOpts in order to indicate that they have been processed. */ 4154 old_flags = reopen_state->flags; 4155 update_flags_from_options(&reopen_state->flags, opts); 4156 assert(old_flags == reopen_state->flags); 4157 4158 discard = qemu_opt_get_del(opts, BDRV_OPT_DISCARD); 4159 if (discard != NULL) { 4160 if (bdrv_parse_discard_flags(discard, &reopen_state->flags) != 0) { 4161 error_setg(errp, "Invalid discard option"); 4162 ret = -EINVAL; 4163 goto error; 4164 } 4165 } 4166 4167 reopen_state->detect_zeroes = 4168 bdrv_parse_detect_zeroes(opts, reopen_state->flags, &local_err); 4169 if (local_err) { 4170 error_propagate(errp, local_err); 4171 ret = -EINVAL; 4172 goto error; 4173 } 4174 4175 /* All other options (including node-name and driver) must be unchanged. 4176 * Put them back into the QDict, so that they are checked at the end 4177 * of this function. */ 4178 qemu_opts_to_qdict(opts, reopen_state->options); 4179 4180 /* If we are to stay read-only, do not allow permission change 4181 * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is 4182 * not set, or if the BDS still has copy_on_read enabled */ 4183 read_only = !(reopen_state->flags & BDRV_O_RDWR); 4184 ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err); 4185 if (local_err) { 4186 error_propagate(errp, local_err); 4187 goto error; 4188 } 4189 4190 /* Calculate required permissions after reopening */ 4191 bdrv_reopen_perm(queue, reopen_state->bs, 4192 &reopen_state->perm, &reopen_state->shared_perm); 4193 4194 ret = bdrv_flush(reopen_state->bs); 4195 if (ret) { 4196 error_setg_errno(errp, -ret, "Error flushing drive"); 4197 goto error; 4198 } 4199 4200 if (drv->bdrv_reopen_prepare) { 4201 /* 4202 * If a driver-specific option is missing, it means that we 4203 * should reset it to its default value. 4204 * But not all options allow that, so we need to check it first. 4205 */ 4206 ret = bdrv_reset_options_allowed(reopen_state->bs, 4207 reopen_state->options, errp); 4208 if (ret) { 4209 goto error; 4210 } 4211 4212 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err); 4213 if (ret) { 4214 if (local_err != NULL) { 4215 error_propagate(errp, local_err); 4216 } else { 4217 bdrv_refresh_filename(reopen_state->bs); 4218 error_setg(errp, "failed while preparing to reopen image '%s'", 4219 reopen_state->bs->filename); 4220 } 4221 goto error; 4222 } 4223 } else { 4224 /* It is currently mandatory to have a bdrv_reopen_prepare() 4225 * handler for each supported drv. */ 4226 error_setg(errp, "Block format '%s' used by node '%s' " 4227 "does not support reopening files", drv->format_name, 4228 bdrv_get_device_or_node_name(reopen_state->bs)); 4229 ret = -1; 4230 goto error; 4231 } 4232 4233 drv_prepared = true; 4234 4235 /* 4236 * We must provide the 'backing' option if the BDS has a backing 4237 * file or if the image file has a backing file name as part of 4238 * its metadata. Otherwise the 'backing' option can be omitted. 4239 */ 4240 if (drv->supports_backing && reopen_state->backing_missing && 4241 (reopen_state->bs->backing || reopen_state->bs->backing_file[0])) { 4242 error_setg(errp, "backing is missing for '%s'", 4243 reopen_state->bs->node_name); 4244 ret = -EINVAL; 4245 goto error; 4246 } 4247 4248 /* 4249 * Allow changing the 'backing' option. The new value can be 4250 * either a reference to an existing node (using its node name) 4251 * or NULL to simply detach the current backing file. 4252 */ 4253 ret = bdrv_reopen_parse_backing(reopen_state, errp); 4254 if (ret < 0) { 4255 goto error; 4256 } 4257 qdict_del(reopen_state->options, "backing"); 4258 4259 /* Options that are not handled are only okay if they are unchanged 4260 * compared to the old state. It is expected that some options are only 4261 * used for the initial open, but not reopen (e.g. filename) */ 4262 if (qdict_size(reopen_state->options)) { 4263 const QDictEntry *entry = qdict_first(reopen_state->options); 4264 4265 do { 4266 QObject *new = entry->value; 4267 QObject *old = qdict_get(reopen_state->bs->options, entry->key); 4268 4269 /* Allow child references (child_name=node_name) as long as they 4270 * point to the current child (i.e. everything stays the same). */ 4271 if (qobject_type(new) == QTYPE_QSTRING) { 4272 BdrvChild *child; 4273 QLIST_FOREACH(child, &reopen_state->bs->children, next) { 4274 if (!strcmp(child->name, entry->key)) { 4275 break; 4276 } 4277 } 4278 4279 if (child) { 4280 const char *str = qobject_get_try_str(new); 4281 if (!strcmp(child->bs->node_name, str)) { 4282 continue; /* Found child with this name, skip option */ 4283 } 4284 } 4285 } 4286 4287 /* 4288 * TODO: When using -drive to specify blockdev options, all values 4289 * will be strings; however, when using -blockdev, blockdev-add or 4290 * filenames using the json:{} pseudo-protocol, they will be 4291 * correctly typed. 4292 * In contrast, reopening options are (currently) always strings 4293 * (because you can only specify them through qemu-io; all other 4294 * callers do not specify any options). 4295 * Therefore, when using anything other than -drive to create a BDS, 4296 * this cannot detect non-string options as unchanged, because 4297 * qobject_is_equal() always returns false for objects of different 4298 * type. In the future, this should be remedied by correctly typing 4299 * all options. For now, this is not too big of an issue because 4300 * the user can simply omit options which cannot be changed anyway, 4301 * so they will stay unchanged. 4302 */ 4303 if (!qobject_is_equal(new, old)) { 4304 error_setg(errp, "Cannot change the option '%s'", entry->key); 4305 ret = -EINVAL; 4306 goto error; 4307 } 4308 } while ((entry = qdict_next(reopen_state->options, entry))); 4309 } 4310 4311 ret = 0; 4312 4313 /* Restore the original reopen_state->options QDict */ 4314 qobject_unref(reopen_state->options); 4315 reopen_state->options = qobject_ref(orig_reopen_opts); 4316 4317 error: 4318 if (ret < 0 && drv_prepared) { 4319 /* drv->bdrv_reopen_prepare() has succeeded, so we need to 4320 * call drv->bdrv_reopen_abort() before signaling an error 4321 * (bdrv_reopen_multiple() will not call bdrv_reopen_abort() 4322 * when the respective bdrv_reopen_prepare() has failed) */ 4323 if (drv->bdrv_reopen_abort) { 4324 drv->bdrv_reopen_abort(reopen_state); 4325 } 4326 } 4327 qemu_opts_del(opts); 4328 qobject_unref(orig_reopen_opts); 4329 g_free(discard); 4330 return ret; 4331 } 4332 4333 /* 4334 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and 4335 * makes them final by swapping the staging BlockDriverState contents into 4336 * the active BlockDriverState contents. 4337 */ 4338 void bdrv_reopen_commit(BDRVReopenState *reopen_state) 4339 { 4340 BlockDriver *drv; 4341 BlockDriverState *bs; 4342 BdrvChild *child; 4343 4344 assert(reopen_state != NULL); 4345 bs = reopen_state->bs; 4346 drv = bs->drv; 4347 assert(drv != NULL); 4348 4349 /* If there are any driver level actions to take */ 4350 if (drv->bdrv_reopen_commit) { 4351 drv->bdrv_reopen_commit(reopen_state); 4352 } 4353 4354 /* set BDS specific flags now */ 4355 qobject_unref(bs->explicit_options); 4356 qobject_unref(bs->options); 4357 4358 bs->explicit_options = reopen_state->explicit_options; 4359 bs->options = reopen_state->options; 4360 bs->open_flags = reopen_state->flags; 4361 bs->read_only = !(reopen_state->flags & BDRV_O_RDWR); 4362 bs->detect_zeroes = reopen_state->detect_zeroes; 4363 4364 if (reopen_state->replace_backing_bs) { 4365 qdict_del(bs->explicit_options, "backing"); 4366 qdict_del(bs->options, "backing"); 4367 } 4368 4369 /* Remove child references from bs->options and bs->explicit_options. 4370 * Child options were already removed in bdrv_reopen_queue_child() */ 4371 QLIST_FOREACH(child, &bs->children, next) { 4372 qdict_del(bs->explicit_options, child->name); 4373 qdict_del(bs->options, child->name); 4374 } 4375 4376 /* 4377 * Change the backing file if a new one was specified. We do this 4378 * after updating bs->options, so bdrv_refresh_filename() (called 4379 * from bdrv_set_backing_hd()) has the new values. 4380 */ 4381 if (reopen_state->replace_backing_bs) { 4382 BlockDriverState *old_backing_bs = child_bs(bs->backing); 4383 assert(!old_backing_bs || !old_backing_bs->implicit); 4384 /* Abort the permission update on the backing bs we're detaching */ 4385 if (old_backing_bs) { 4386 bdrv_abort_perm_update(old_backing_bs); 4387 } 4388 bdrv_set_backing_hd(bs, reopen_state->new_backing_bs, &error_abort); 4389 } 4390 4391 bdrv_refresh_limits(bs, NULL); 4392 } 4393 4394 /* 4395 * Abort the reopen, and delete and free the staged changes in 4396 * reopen_state 4397 */ 4398 void bdrv_reopen_abort(BDRVReopenState *reopen_state) 4399 { 4400 BlockDriver *drv; 4401 4402 assert(reopen_state != NULL); 4403 drv = reopen_state->bs->drv; 4404 assert(drv != NULL); 4405 4406 if (drv->bdrv_reopen_abort) { 4407 drv->bdrv_reopen_abort(reopen_state); 4408 } 4409 } 4410 4411 4412 static void bdrv_close(BlockDriverState *bs) 4413 { 4414 BdrvAioNotifier *ban, *ban_next; 4415 BdrvChild *child, *next; 4416 4417 assert(!bs->refcnt); 4418 4419 bdrv_drained_begin(bs); /* complete I/O */ 4420 bdrv_flush(bs); 4421 bdrv_drain(bs); /* in case flush left pending I/O */ 4422 4423 if (bs->drv) { 4424 if (bs->drv->bdrv_close) { 4425 /* Must unfreeze all children, so bdrv_unref_child() works */ 4426 bs->drv->bdrv_close(bs); 4427 } 4428 bs->drv = NULL; 4429 } 4430 4431 QLIST_FOREACH_SAFE(child, &bs->children, next, next) { 4432 bdrv_unref_child(bs, child); 4433 } 4434 4435 bs->backing = NULL; 4436 bs->file = NULL; 4437 g_free(bs->opaque); 4438 bs->opaque = NULL; 4439 qatomic_set(&bs->copy_on_read, 0); 4440 bs->backing_file[0] = '\0'; 4441 bs->backing_format[0] = '\0'; 4442 bs->total_sectors = 0; 4443 bs->encrypted = false; 4444 bs->sg = false; 4445 qobject_unref(bs->options); 4446 qobject_unref(bs->explicit_options); 4447 bs->options = NULL; 4448 bs->explicit_options = NULL; 4449 qobject_unref(bs->full_open_options); 4450 bs->full_open_options = NULL; 4451 4452 bdrv_release_named_dirty_bitmaps(bs); 4453 assert(QLIST_EMPTY(&bs->dirty_bitmaps)); 4454 4455 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { 4456 g_free(ban); 4457 } 4458 QLIST_INIT(&bs->aio_notifiers); 4459 bdrv_drained_end(bs); 4460 } 4461 4462 void bdrv_close_all(void) 4463 { 4464 assert(job_next(NULL) == NULL); 4465 nbd_export_close_all(); 4466 4467 /* Drop references from requests still in flight, such as canceled block 4468 * jobs whose AIO context has not been polled yet */ 4469 bdrv_drain_all(); 4470 4471 blk_remove_all_bs(); 4472 blockdev_close_all_bdrv_states(); 4473 4474 assert(QTAILQ_EMPTY(&all_bdrv_states)); 4475 } 4476 4477 static bool should_update_child(BdrvChild *c, BlockDriverState *to) 4478 { 4479 GQueue *queue; 4480 GHashTable *found; 4481 bool ret; 4482 4483 if (c->klass->stay_at_node) { 4484 return false; 4485 } 4486 4487 /* If the child @c belongs to the BDS @to, replacing the current 4488 * c->bs by @to would mean to create a loop. 4489 * 4490 * Such a case occurs when appending a BDS to a backing chain. 4491 * For instance, imagine the following chain: 4492 * 4493 * guest device -> node A -> further backing chain... 4494 * 4495 * Now we create a new BDS B which we want to put on top of this 4496 * chain, so we first attach A as its backing node: 4497 * 4498 * node B 4499 * | 4500 * v 4501 * guest device -> node A -> further backing chain... 4502 * 4503 * Finally we want to replace A by B. When doing that, we want to 4504 * replace all pointers to A by pointers to B -- except for the 4505 * pointer from B because (1) that would create a loop, and (2) 4506 * that pointer should simply stay intact: 4507 * 4508 * guest device -> node B 4509 * | 4510 * v 4511 * node A -> further backing chain... 4512 * 4513 * In general, when replacing a node A (c->bs) by a node B (@to), 4514 * if A is a child of B, that means we cannot replace A by B there 4515 * because that would create a loop. Silently detaching A from B 4516 * is also not really an option. So overall just leaving A in 4517 * place there is the most sensible choice. 4518 * 4519 * We would also create a loop in any cases where @c is only 4520 * indirectly referenced by @to. Prevent this by returning false 4521 * if @c is found (by breadth-first search) anywhere in the whole 4522 * subtree of @to. 4523 */ 4524 4525 ret = true; 4526 found = g_hash_table_new(NULL, NULL); 4527 g_hash_table_add(found, to); 4528 queue = g_queue_new(); 4529 g_queue_push_tail(queue, to); 4530 4531 while (!g_queue_is_empty(queue)) { 4532 BlockDriverState *v = g_queue_pop_head(queue); 4533 BdrvChild *c2; 4534 4535 QLIST_FOREACH(c2, &v->children, next) { 4536 if (c2 == c) { 4537 ret = false; 4538 break; 4539 } 4540 4541 if (g_hash_table_contains(found, c2->bs)) { 4542 continue; 4543 } 4544 4545 g_queue_push_tail(queue, c2->bs); 4546 g_hash_table_add(found, c2->bs); 4547 } 4548 } 4549 4550 g_queue_free(queue); 4551 g_hash_table_destroy(found); 4552 4553 return ret; 4554 } 4555 4556 void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to, 4557 Error **errp) 4558 { 4559 BdrvChild *c, *next; 4560 GSList *list = NULL, *p; 4561 uint64_t perm = 0, shared = BLK_PERM_ALL; 4562 int ret; 4563 4564 /* Make sure that @from doesn't go away until we have successfully attached 4565 * all of its parents to @to. */ 4566 bdrv_ref(from); 4567 4568 assert(qemu_get_current_aio_context() == qemu_get_aio_context()); 4569 assert(bdrv_get_aio_context(from) == bdrv_get_aio_context(to)); 4570 bdrv_drained_begin(from); 4571 4572 /* Put all parents into @list and calculate their cumulative permissions */ 4573 QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) { 4574 assert(c->bs == from); 4575 if (!should_update_child(c, to)) { 4576 continue; 4577 } 4578 if (c->frozen) { 4579 error_setg(errp, "Cannot change '%s' link to '%s'", 4580 c->name, from->node_name); 4581 goto out; 4582 } 4583 list = g_slist_prepend(list, c); 4584 perm |= c->perm; 4585 shared &= c->shared_perm; 4586 } 4587 4588 /* Check whether the required permissions can be granted on @to, ignoring 4589 * all BdrvChild in @list so that they can't block themselves. */ 4590 ret = bdrv_check_update_perm(to, NULL, perm, shared, list, NULL, errp); 4591 if (ret < 0) { 4592 bdrv_abort_perm_update(to); 4593 goto out; 4594 } 4595 4596 /* Now actually perform the change. We performed the permission check for 4597 * all elements of @list at once, so set the permissions all at once at the 4598 * very end. */ 4599 for (p = list; p != NULL; p = p->next) { 4600 c = p->data; 4601 4602 bdrv_ref(to); 4603 bdrv_replace_child_noperm(c, to); 4604 bdrv_unref(from); 4605 } 4606 4607 bdrv_get_cumulative_perm(to, &perm, &shared); 4608 bdrv_set_perm(to, perm, shared); 4609 4610 out: 4611 g_slist_free(list); 4612 bdrv_drained_end(from); 4613 bdrv_unref(from); 4614 } 4615 4616 /* 4617 * Add new bs contents at the top of an image chain while the chain is 4618 * live, while keeping required fields on the top layer. 4619 * 4620 * This will modify the BlockDriverState fields, and swap contents 4621 * between bs_new and bs_top. Both bs_new and bs_top are modified. 4622 * 4623 * bs_new must not be attached to a BlockBackend. 4624 * 4625 * This function does not create any image files. 4626 * 4627 * bdrv_append() takes ownership of a bs_new reference and unrefs it because 4628 * that's what the callers commonly need. bs_new will be referenced by the old 4629 * parents of bs_top after bdrv_append() returns. If the caller needs to keep a 4630 * reference of its own, it must call bdrv_ref(). 4631 */ 4632 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top, 4633 Error **errp) 4634 { 4635 Error *local_err = NULL; 4636 4637 bdrv_set_backing_hd(bs_new, bs_top, &local_err); 4638 if (local_err) { 4639 error_propagate(errp, local_err); 4640 goto out; 4641 } 4642 4643 bdrv_replace_node(bs_top, bs_new, &local_err); 4644 if (local_err) { 4645 error_propagate(errp, local_err); 4646 bdrv_set_backing_hd(bs_new, NULL, &error_abort); 4647 goto out; 4648 } 4649 4650 /* bs_new is now referenced by its new parents, we don't need the 4651 * additional reference any more. */ 4652 out: 4653 bdrv_unref(bs_new); 4654 } 4655 4656 static void bdrv_delete(BlockDriverState *bs) 4657 { 4658 assert(bdrv_op_blocker_is_empty(bs)); 4659 assert(!bs->refcnt); 4660 4661 /* remove from list, if necessary */ 4662 if (bs->node_name[0] != '\0') { 4663 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list); 4664 } 4665 QTAILQ_REMOVE(&all_bdrv_states, bs, bs_list); 4666 4667 bdrv_close(bs); 4668 4669 g_free(bs); 4670 } 4671 4672 /* 4673 * Run consistency checks on an image 4674 * 4675 * Returns 0 if the check could be completed (it doesn't mean that the image is 4676 * free of errors) or -errno when an internal error occurred. The results of the 4677 * check are stored in res. 4678 */ 4679 static int coroutine_fn bdrv_co_check(BlockDriverState *bs, 4680 BdrvCheckResult *res, BdrvCheckMode fix) 4681 { 4682 if (bs->drv == NULL) { 4683 return -ENOMEDIUM; 4684 } 4685 if (bs->drv->bdrv_co_check == NULL) { 4686 return -ENOTSUP; 4687 } 4688 4689 memset(res, 0, sizeof(*res)); 4690 return bs->drv->bdrv_co_check(bs, res, fix); 4691 } 4692 4693 typedef struct CheckCo { 4694 BlockDriverState *bs; 4695 BdrvCheckResult *res; 4696 BdrvCheckMode fix; 4697 int ret; 4698 } CheckCo; 4699 4700 static void coroutine_fn bdrv_check_co_entry(void *opaque) 4701 { 4702 CheckCo *cco = opaque; 4703 cco->ret = bdrv_co_check(cco->bs, cco->res, cco->fix); 4704 aio_wait_kick(); 4705 } 4706 4707 int bdrv_check(BlockDriverState *bs, 4708 BdrvCheckResult *res, BdrvCheckMode fix) 4709 { 4710 Coroutine *co; 4711 CheckCo cco = { 4712 .bs = bs, 4713 .res = res, 4714 .ret = -EINPROGRESS, 4715 .fix = fix, 4716 }; 4717 4718 if (qemu_in_coroutine()) { 4719 /* Fast-path if already in coroutine context */ 4720 bdrv_check_co_entry(&cco); 4721 } else { 4722 co = qemu_coroutine_create(bdrv_check_co_entry, &cco); 4723 bdrv_coroutine_enter(bs, co); 4724 BDRV_POLL_WHILE(bs, cco.ret == -EINPROGRESS); 4725 } 4726 4727 return cco.ret; 4728 } 4729 4730 /* 4731 * Return values: 4732 * 0 - success 4733 * -EINVAL - backing format specified, but no file 4734 * -ENOSPC - can't update the backing file because no space is left in the 4735 * image file header 4736 * -ENOTSUP - format driver doesn't support changing the backing file 4737 */ 4738 int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file, 4739 const char *backing_fmt, bool warn) 4740 { 4741 BlockDriver *drv = bs->drv; 4742 int ret; 4743 4744 if (!drv) { 4745 return -ENOMEDIUM; 4746 } 4747 4748 /* Backing file format doesn't make sense without a backing file */ 4749 if (backing_fmt && !backing_file) { 4750 return -EINVAL; 4751 } 4752 4753 if (warn && backing_file && !backing_fmt) { 4754 warn_report("Deprecated use of backing file without explicit " 4755 "backing format, use of this image requires " 4756 "potentially unsafe format probing"); 4757 } 4758 4759 if (drv->bdrv_change_backing_file != NULL) { 4760 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt); 4761 } else { 4762 ret = -ENOTSUP; 4763 } 4764 4765 if (ret == 0) { 4766 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); 4767 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); 4768 pstrcpy(bs->auto_backing_file, sizeof(bs->auto_backing_file), 4769 backing_file ?: ""); 4770 } 4771 return ret; 4772 } 4773 4774 /* 4775 * Finds the first non-filter node above bs in the chain between 4776 * active and bs. The returned node is either an immediate parent of 4777 * bs, or there are only filter nodes between the two. 4778 * 4779 * Returns NULL if bs is not found in active's image chain, 4780 * or if active == bs. 4781 * 4782 * Returns the bottommost base image if bs == NULL. 4783 */ 4784 BlockDriverState *bdrv_find_overlay(BlockDriverState *active, 4785 BlockDriverState *bs) 4786 { 4787 bs = bdrv_skip_filters(bs); 4788 active = bdrv_skip_filters(active); 4789 4790 while (active) { 4791 BlockDriverState *next = bdrv_backing_chain_next(active); 4792 if (bs == next) { 4793 return active; 4794 } 4795 active = next; 4796 } 4797 4798 return NULL; 4799 } 4800 4801 /* Given a BDS, searches for the base layer. */ 4802 BlockDriverState *bdrv_find_base(BlockDriverState *bs) 4803 { 4804 return bdrv_find_overlay(bs, NULL); 4805 } 4806 4807 /* 4808 * Return true if at least one of the COW (backing) and filter links 4809 * between @bs and @base is frozen. @errp is set if that's the case. 4810 * @base must be reachable from @bs, or NULL. 4811 */ 4812 bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base, 4813 Error **errp) 4814 { 4815 BlockDriverState *i; 4816 BdrvChild *child; 4817 4818 for (i = bs; i != base; i = child_bs(child)) { 4819 child = bdrv_filter_or_cow_child(i); 4820 4821 if (child && child->frozen) { 4822 error_setg(errp, "Cannot change '%s' link from '%s' to '%s'", 4823 child->name, i->node_name, child->bs->node_name); 4824 return true; 4825 } 4826 } 4827 4828 return false; 4829 } 4830 4831 /* 4832 * Freeze all COW (backing) and filter links between @bs and @base. 4833 * If any of the links is already frozen the operation is aborted and 4834 * none of the links are modified. 4835 * @base must be reachable from @bs, or NULL. 4836 * Returns 0 on success. On failure returns < 0 and sets @errp. 4837 */ 4838 int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base, 4839 Error **errp) 4840 { 4841 BlockDriverState *i; 4842 BdrvChild *child; 4843 4844 if (bdrv_is_backing_chain_frozen(bs, base, errp)) { 4845 return -EPERM; 4846 } 4847 4848 for (i = bs; i != base; i = child_bs(child)) { 4849 child = bdrv_filter_or_cow_child(i); 4850 if (child && child->bs->never_freeze) { 4851 error_setg(errp, "Cannot freeze '%s' link to '%s'", 4852 child->name, child->bs->node_name); 4853 return -EPERM; 4854 } 4855 } 4856 4857 for (i = bs; i != base; i = child_bs(child)) { 4858 child = bdrv_filter_or_cow_child(i); 4859 if (child) { 4860 child->frozen = true; 4861 } 4862 } 4863 4864 return 0; 4865 } 4866 4867 /* 4868 * Unfreeze all COW (backing) and filter links between @bs and @base. 4869 * The caller must ensure that all links are frozen before using this 4870 * function. 4871 * @base must be reachable from @bs, or NULL. 4872 */ 4873 void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base) 4874 { 4875 BlockDriverState *i; 4876 BdrvChild *child; 4877 4878 for (i = bs; i != base; i = child_bs(child)) { 4879 child = bdrv_filter_or_cow_child(i); 4880 if (child) { 4881 assert(child->frozen); 4882 child->frozen = false; 4883 } 4884 } 4885 } 4886 4887 /* 4888 * Drops images above 'base' up to and including 'top', and sets the image 4889 * above 'top' to have base as its backing file. 4890 * 4891 * Requires that the overlay to 'top' is opened r/w, so that the backing file 4892 * information in 'bs' can be properly updated. 4893 * 4894 * E.g., this will convert the following chain: 4895 * bottom <- base <- intermediate <- top <- active 4896 * 4897 * to 4898 * 4899 * bottom <- base <- active 4900 * 4901 * It is allowed for bottom==base, in which case it converts: 4902 * 4903 * base <- intermediate <- top <- active 4904 * 4905 * to 4906 * 4907 * base <- active 4908 * 4909 * If backing_file_str is non-NULL, it will be used when modifying top's 4910 * overlay image metadata. 4911 * 4912 * Error conditions: 4913 * if active == top, that is considered an error 4914 * 4915 */ 4916 int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base, 4917 const char *backing_file_str) 4918 { 4919 BlockDriverState *explicit_top = top; 4920 bool update_inherits_from; 4921 BdrvChild *c, *next; 4922 Error *local_err = NULL; 4923 int ret = -EIO; 4924 4925 bdrv_ref(top); 4926 bdrv_subtree_drained_begin(top); 4927 4928 if (!top->drv || !base->drv) { 4929 goto exit; 4930 } 4931 4932 /* Make sure that base is in the backing chain of top */ 4933 if (!bdrv_chain_contains(top, base)) { 4934 goto exit; 4935 } 4936 4937 /* This function changes all links that point to top and makes 4938 * them point to base. Check that none of them is frozen. */ 4939 QLIST_FOREACH(c, &top->parents, next_parent) { 4940 if (c->frozen) { 4941 goto exit; 4942 } 4943 } 4944 4945 /* If 'base' recursively inherits from 'top' then we should set 4946 * base->inherits_from to top->inherits_from after 'top' and all 4947 * other intermediate nodes have been dropped. 4948 * If 'top' is an implicit node (e.g. "commit_top") we should skip 4949 * it because no one inherits from it. We use explicit_top for that. */ 4950 explicit_top = bdrv_skip_implicit_filters(explicit_top); 4951 update_inherits_from = bdrv_inherits_from_recursive(base, explicit_top); 4952 4953 /* success - we can delete the intermediate states, and link top->base */ 4954 /* TODO Check graph modification op blockers (BLK_PERM_GRAPH_MOD) once 4955 * we've figured out how they should work. */ 4956 if (!backing_file_str) { 4957 bdrv_refresh_filename(base); 4958 backing_file_str = base->filename; 4959 } 4960 4961 QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) { 4962 /* Check whether we are allowed to switch c from top to base */ 4963 GSList *ignore_children = g_slist_prepend(NULL, c); 4964 ret = bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm, 4965 ignore_children, NULL, &local_err); 4966 g_slist_free(ignore_children); 4967 if (ret < 0) { 4968 error_report_err(local_err); 4969 goto exit; 4970 } 4971 4972 /* If so, update the backing file path in the image file */ 4973 if (c->klass->update_filename) { 4974 ret = c->klass->update_filename(c, base, backing_file_str, 4975 &local_err); 4976 if (ret < 0) { 4977 bdrv_abort_perm_update(base); 4978 error_report_err(local_err); 4979 goto exit; 4980 } 4981 } 4982 4983 /* 4984 * Do the actual switch in the in-memory graph. 4985 * Completes bdrv_check_update_perm() transaction internally. 4986 * c->frozen is false, we have checked that above. 4987 */ 4988 bdrv_ref(base); 4989 bdrv_replace_child(c, base); 4990 bdrv_unref(top); 4991 } 4992 4993 if (update_inherits_from) { 4994 base->inherits_from = explicit_top->inherits_from; 4995 } 4996 4997 ret = 0; 4998 exit: 4999 bdrv_subtree_drained_end(top); 5000 bdrv_unref(top); 5001 return ret; 5002 } 5003 5004 /** 5005 * Implementation of BlockDriver.bdrv_get_allocated_file_size() that 5006 * sums the size of all data-bearing children. (This excludes backing 5007 * children.) 5008 */ 5009 static int64_t bdrv_sum_allocated_file_size(BlockDriverState *bs) 5010 { 5011 BdrvChild *child; 5012 int64_t child_size, sum = 0; 5013 5014 QLIST_FOREACH(child, &bs->children, next) { 5015 if (child->role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA | 5016 BDRV_CHILD_FILTERED)) 5017 { 5018 child_size = bdrv_get_allocated_file_size(child->bs); 5019 if (child_size < 0) { 5020 return child_size; 5021 } 5022 sum += child_size; 5023 } 5024 } 5025 5026 return sum; 5027 } 5028 5029 /** 5030 * Length of a allocated file in bytes. Sparse files are counted by actual 5031 * allocated space. Return < 0 if error or unknown. 5032 */ 5033 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs) 5034 { 5035 BlockDriver *drv = bs->drv; 5036 if (!drv) { 5037 return -ENOMEDIUM; 5038 } 5039 if (drv->bdrv_get_allocated_file_size) { 5040 return drv->bdrv_get_allocated_file_size(bs); 5041 } 5042 5043 if (drv->bdrv_file_open) { 5044 /* 5045 * Protocol drivers default to -ENOTSUP (most of their data is 5046 * not stored in any of their children (if they even have any), 5047 * so there is no generic way to figure it out). 5048 */ 5049 return -ENOTSUP; 5050 } else if (drv->is_filter) { 5051 /* Filter drivers default to the size of their filtered child */ 5052 return bdrv_get_allocated_file_size(bdrv_filter_bs(bs)); 5053 } else { 5054 /* Other drivers default to summing their children's sizes */ 5055 return bdrv_sum_allocated_file_size(bs); 5056 } 5057 } 5058 5059 /* 5060 * bdrv_measure: 5061 * @drv: Format driver 5062 * @opts: Creation options for new image 5063 * @in_bs: Existing image containing data for new image (may be NULL) 5064 * @errp: Error object 5065 * Returns: A #BlockMeasureInfo (free using qapi_free_BlockMeasureInfo()) 5066 * or NULL on error 5067 * 5068 * Calculate file size required to create a new image. 5069 * 5070 * If @in_bs is given then space for allocated clusters and zero clusters 5071 * from that image are included in the calculation. If @opts contains a 5072 * backing file that is shared by @in_bs then backing clusters may be omitted 5073 * from the calculation. 5074 * 5075 * If @in_bs is NULL then the calculation includes no allocated clusters 5076 * unless a preallocation option is given in @opts. 5077 * 5078 * Note that @in_bs may use a different BlockDriver from @drv. 5079 * 5080 * If an error occurs the @errp pointer is set. 5081 */ 5082 BlockMeasureInfo *bdrv_measure(BlockDriver *drv, QemuOpts *opts, 5083 BlockDriverState *in_bs, Error **errp) 5084 { 5085 if (!drv->bdrv_measure) { 5086 error_setg(errp, "Block driver '%s' does not support size measurement", 5087 drv->format_name); 5088 return NULL; 5089 } 5090 5091 return drv->bdrv_measure(opts, in_bs, errp); 5092 } 5093 5094 /** 5095 * Return number of sectors on success, -errno on error. 5096 */ 5097 int64_t bdrv_nb_sectors(BlockDriverState *bs) 5098 { 5099 BlockDriver *drv = bs->drv; 5100 5101 if (!drv) 5102 return -ENOMEDIUM; 5103 5104 if (drv->has_variable_length) { 5105 int ret = refresh_total_sectors(bs, bs->total_sectors); 5106 if (ret < 0) { 5107 return ret; 5108 } 5109 } 5110 return bs->total_sectors; 5111 } 5112 5113 /** 5114 * Return length in bytes on success, -errno on error. 5115 * The length is always a multiple of BDRV_SECTOR_SIZE. 5116 */ 5117 int64_t bdrv_getlength(BlockDriverState *bs) 5118 { 5119 int64_t ret = bdrv_nb_sectors(bs); 5120 5121 ret = ret > INT64_MAX / BDRV_SECTOR_SIZE ? -EFBIG : ret; 5122 return ret < 0 ? ret : ret * BDRV_SECTOR_SIZE; 5123 } 5124 5125 /* return 0 as number of sectors if no device present or error */ 5126 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) 5127 { 5128 int64_t nb_sectors = bdrv_nb_sectors(bs); 5129 5130 *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors; 5131 } 5132 5133 bool bdrv_is_sg(BlockDriverState *bs) 5134 { 5135 return bs->sg; 5136 } 5137 5138 /** 5139 * Return whether the given node supports compressed writes. 5140 */ 5141 bool bdrv_supports_compressed_writes(BlockDriverState *bs) 5142 { 5143 BlockDriverState *filtered; 5144 5145 if (!bs->drv || !block_driver_can_compress(bs->drv)) { 5146 return false; 5147 } 5148 5149 filtered = bdrv_filter_bs(bs); 5150 if (filtered) { 5151 /* 5152 * Filters can only forward compressed writes, so we have to 5153 * check the child. 5154 */ 5155 return bdrv_supports_compressed_writes(filtered); 5156 } 5157 5158 return true; 5159 } 5160 5161 const char *bdrv_get_format_name(BlockDriverState *bs) 5162 { 5163 return bs->drv ? bs->drv->format_name : NULL; 5164 } 5165 5166 static int qsort_strcmp(const void *a, const void *b) 5167 { 5168 return strcmp(*(char *const *)a, *(char *const *)b); 5169 } 5170 5171 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 5172 void *opaque, bool read_only) 5173 { 5174 BlockDriver *drv; 5175 int count = 0; 5176 int i; 5177 const char **formats = NULL; 5178 5179 QLIST_FOREACH(drv, &bdrv_drivers, list) { 5180 if (drv->format_name) { 5181 bool found = false; 5182 int i = count; 5183 5184 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, read_only)) { 5185 continue; 5186 } 5187 5188 while (formats && i && !found) { 5189 found = !strcmp(formats[--i], drv->format_name); 5190 } 5191 5192 if (!found) { 5193 formats = g_renew(const char *, formats, count + 1); 5194 formats[count++] = drv->format_name; 5195 } 5196 } 5197 } 5198 5199 for (i = 0; i < (int)ARRAY_SIZE(block_driver_modules); i++) { 5200 const char *format_name = block_driver_modules[i].format_name; 5201 5202 if (format_name) { 5203 bool found = false; 5204 int j = count; 5205 5206 if (use_bdrv_whitelist && 5207 !bdrv_format_is_whitelisted(format_name, read_only)) { 5208 continue; 5209 } 5210 5211 while (formats && j && !found) { 5212 found = !strcmp(formats[--j], format_name); 5213 } 5214 5215 if (!found) { 5216 formats = g_renew(const char *, formats, count + 1); 5217 formats[count++] = format_name; 5218 } 5219 } 5220 } 5221 5222 qsort(formats, count, sizeof(formats[0]), qsort_strcmp); 5223 5224 for (i = 0; i < count; i++) { 5225 it(opaque, formats[i]); 5226 } 5227 5228 g_free(formats); 5229 } 5230 5231 /* This function is to find a node in the bs graph */ 5232 BlockDriverState *bdrv_find_node(const char *node_name) 5233 { 5234 BlockDriverState *bs; 5235 5236 assert(node_name); 5237 5238 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { 5239 if (!strcmp(node_name, bs->node_name)) { 5240 return bs; 5241 } 5242 } 5243 return NULL; 5244 } 5245 5246 /* Put this QMP function here so it can access the static graph_bdrv_states. */ 5247 BlockDeviceInfoList *bdrv_named_nodes_list(bool flat, 5248 Error **errp) 5249 { 5250 BlockDeviceInfoList *list, *entry; 5251 BlockDriverState *bs; 5252 5253 list = NULL; 5254 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { 5255 BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, flat, errp); 5256 if (!info) { 5257 qapi_free_BlockDeviceInfoList(list); 5258 return NULL; 5259 } 5260 entry = g_malloc0(sizeof(*entry)); 5261 entry->value = info; 5262 entry->next = list; 5263 list = entry; 5264 } 5265 5266 return list; 5267 } 5268 5269 #define QAPI_LIST_ADD(list, element) do { \ 5270 typeof(list) _tmp = g_new(typeof(*(list)), 1); \ 5271 _tmp->value = (element); \ 5272 _tmp->next = (list); \ 5273 (list) = _tmp; \ 5274 } while (0) 5275 5276 typedef struct XDbgBlockGraphConstructor { 5277 XDbgBlockGraph *graph; 5278 GHashTable *graph_nodes; 5279 } XDbgBlockGraphConstructor; 5280 5281 static XDbgBlockGraphConstructor *xdbg_graph_new(void) 5282 { 5283 XDbgBlockGraphConstructor *gr = g_new(XDbgBlockGraphConstructor, 1); 5284 5285 gr->graph = g_new0(XDbgBlockGraph, 1); 5286 gr->graph_nodes = g_hash_table_new(NULL, NULL); 5287 5288 return gr; 5289 } 5290 5291 static XDbgBlockGraph *xdbg_graph_finalize(XDbgBlockGraphConstructor *gr) 5292 { 5293 XDbgBlockGraph *graph = gr->graph; 5294 5295 g_hash_table_destroy(gr->graph_nodes); 5296 g_free(gr); 5297 5298 return graph; 5299 } 5300 5301 static uintptr_t xdbg_graph_node_num(XDbgBlockGraphConstructor *gr, void *node) 5302 { 5303 uintptr_t ret = (uintptr_t)g_hash_table_lookup(gr->graph_nodes, node); 5304 5305 if (ret != 0) { 5306 return ret; 5307 } 5308 5309 /* 5310 * Start counting from 1, not 0, because 0 interferes with not-found (NULL) 5311 * answer of g_hash_table_lookup. 5312 */ 5313 ret = g_hash_table_size(gr->graph_nodes) + 1; 5314 g_hash_table_insert(gr->graph_nodes, node, (void *)ret); 5315 5316 return ret; 5317 } 5318 5319 static void xdbg_graph_add_node(XDbgBlockGraphConstructor *gr, void *node, 5320 XDbgBlockGraphNodeType type, const char *name) 5321 { 5322 XDbgBlockGraphNode *n; 5323 5324 n = g_new0(XDbgBlockGraphNode, 1); 5325 5326 n->id = xdbg_graph_node_num(gr, node); 5327 n->type = type; 5328 n->name = g_strdup(name); 5329 5330 QAPI_LIST_ADD(gr->graph->nodes, n); 5331 } 5332 5333 static void xdbg_graph_add_edge(XDbgBlockGraphConstructor *gr, void *parent, 5334 const BdrvChild *child) 5335 { 5336 BlockPermission qapi_perm; 5337 XDbgBlockGraphEdge *edge; 5338 5339 edge = g_new0(XDbgBlockGraphEdge, 1); 5340 5341 edge->parent = xdbg_graph_node_num(gr, parent); 5342 edge->child = xdbg_graph_node_num(gr, child->bs); 5343 edge->name = g_strdup(child->name); 5344 5345 for (qapi_perm = 0; qapi_perm < BLOCK_PERMISSION__MAX; qapi_perm++) { 5346 uint64_t flag = bdrv_qapi_perm_to_blk_perm(qapi_perm); 5347 5348 if (flag & child->perm) { 5349 QAPI_LIST_ADD(edge->perm, qapi_perm); 5350 } 5351 if (flag & child->shared_perm) { 5352 QAPI_LIST_ADD(edge->shared_perm, qapi_perm); 5353 } 5354 } 5355 5356 QAPI_LIST_ADD(gr->graph->edges, edge); 5357 } 5358 5359 5360 XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp) 5361 { 5362 BlockBackend *blk; 5363 BlockJob *job; 5364 BlockDriverState *bs; 5365 BdrvChild *child; 5366 XDbgBlockGraphConstructor *gr = xdbg_graph_new(); 5367 5368 for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) { 5369 char *allocated_name = NULL; 5370 const char *name = blk_name(blk); 5371 5372 if (!*name) { 5373 name = allocated_name = blk_get_attached_dev_id(blk); 5374 } 5375 xdbg_graph_add_node(gr, blk, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_BACKEND, 5376 name); 5377 g_free(allocated_name); 5378 if (blk_root(blk)) { 5379 xdbg_graph_add_edge(gr, blk, blk_root(blk)); 5380 } 5381 } 5382 5383 for (job = block_job_next(NULL); job; job = block_job_next(job)) { 5384 GSList *el; 5385 5386 xdbg_graph_add_node(gr, job, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_JOB, 5387 job->job.id); 5388 for (el = job->nodes; el; el = el->next) { 5389 xdbg_graph_add_edge(gr, job, (BdrvChild *)el->data); 5390 } 5391 } 5392 5393 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { 5394 xdbg_graph_add_node(gr, bs, X_DBG_BLOCK_GRAPH_NODE_TYPE_BLOCK_DRIVER, 5395 bs->node_name); 5396 QLIST_FOREACH(child, &bs->children, next) { 5397 xdbg_graph_add_edge(gr, bs, child); 5398 } 5399 } 5400 5401 return xdbg_graph_finalize(gr); 5402 } 5403 5404 BlockDriverState *bdrv_lookup_bs(const char *device, 5405 const char *node_name, 5406 Error **errp) 5407 { 5408 BlockBackend *blk; 5409 BlockDriverState *bs; 5410 5411 if (device) { 5412 blk = blk_by_name(device); 5413 5414 if (blk) { 5415 bs = blk_bs(blk); 5416 if (!bs) { 5417 error_setg(errp, "Device '%s' has no medium", device); 5418 } 5419 5420 return bs; 5421 } 5422 } 5423 5424 if (node_name) { 5425 bs = bdrv_find_node(node_name); 5426 5427 if (bs) { 5428 return bs; 5429 } 5430 } 5431 5432 error_setg(errp, "Cannot find device=%s nor node_name=%s", 5433 device ? device : "", 5434 node_name ? node_name : ""); 5435 return NULL; 5436 } 5437 5438 /* If 'base' is in the same chain as 'top', return true. Otherwise, 5439 * return false. If either argument is NULL, return false. */ 5440 bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base) 5441 { 5442 while (top && top != base) { 5443 top = bdrv_filter_or_cow_bs(top); 5444 } 5445 5446 return top != NULL; 5447 } 5448 5449 BlockDriverState *bdrv_next_node(BlockDriverState *bs) 5450 { 5451 if (!bs) { 5452 return QTAILQ_FIRST(&graph_bdrv_states); 5453 } 5454 return QTAILQ_NEXT(bs, node_list); 5455 } 5456 5457 BlockDriverState *bdrv_next_all_states(BlockDriverState *bs) 5458 { 5459 if (!bs) { 5460 return QTAILQ_FIRST(&all_bdrv_states); 5461 } 5462 return QTAILQ_NEXT(bs, bs_list); 5463 } 5464 5465 const char *bdrv_get_node_name(const BlockDriverState *bs) 5466 { 5467 return bs->node_name; 5468 } 5469 5470 const char *bdrv_get_parent_name(const BlockDriverState *bs) 5471 { 5472 BdrvChild *c; 5473 const char *name; 5474 5475 /* If multiple parents have a name, just pick the first one. */ 5476 QLIST_FOREACH(c, &bs->parents, next_parent) { 5477 if (c->klass->get_name) { 5478 name = c->klass->get_name(c); 5479 if (name && *name) { 5480 return name; 5481 } 5482 } 5483 } 5484 5485 return NULL; 5486 } 5487 5488 /* TODO check what callers really want: bs->node_name or blk_name() */ 5489 const char *bdrv_get_device_name(const BlockDriverState *bs) 5490 { 5491 return bdrv_get_parent_name(bs) ?: ""; 5492 } 5493 5494 /* This can be used to identify nodes that might not have a device 5495 * name associated. Since node and device names live in the same 5496 * namespace, the result is unambiguous. The exception is if both are 5497 * absent, then this returns an empty (non-null) string. */ 5498 const char *bdrv_get_device_or_node_name(const BlockDriverState *bs) 5499 { 5500 return bdrv_get_parent_name(bs) ?: bs->node_name; 5501 } 5502 5503 int bdrv_get_flags(BlockDriverState *bs) 5504 { 5505 return bs->open_flags; 5506 } 5507 5508 int bdrv_has_zero_init_1(BlockDriverState *bs) 5509 { 5510 return 1; 5511 } 5512 5513 int bdrv_has_zero_init(BlockDriverState *bs) 5514 { 5515 BlockDriverState *filtered; 5516 5517 if (!bs->drv) { 5518 return 0; 5519 } 5520 5521 /* If BS is a copy on write image, it is initialized to 5522 the contents of the base image, which may not be zeroes. */ 5523 if (bdrv_cow_child(bs)) { 5524 return 0; 5525 } 5526 if (bs->drv->bdrv_has_zero_init) { 5527 return bs->drv->bdrv_has_zero_init(bs); 5528 } 5529 5530 filtered = bdrv_filter_bs(bs); 5531 if (filtered) { 5532 return bdrv_has_zero_init(filtered); 5533 } 5534 5535 /* safe default */ 5536 return 0; 5537 } 5538 5539 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs) 5540 { 5541 if (!(bs->open_flags & BDRV_O_UNMAP)) { 5542 return false; 5543 } 5544 5545 return bs->supported_zero_flags & BDRV_REQ_MAY_UNMAP; 5546 } 5547 5548 void bdrv_get_backing_filename(BlockDriverState *bs, 5549 char *filename, int filename_size) 5550 { 5551 pstrcpy(filename, filename_size, bs->backing_file); 5552 } 5553 5554 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 5555 { 5556 BlockDriver *drv = bs->drv; 5557 /* if bs->drv == NULL, bs is closed, so there's nothing to do here */ 5558 if (!drv) { 5559 return -ENOMEDIUM; 5560 } 5561 if (!drv->bdrv_get_info) { 5562 BlockDriverState *filtered = bdrv_filter_bs(bs); 5563 if (filtered) { 5564 return bdrv_get_info(filtered, bdi); 5565 } 5566 return -ENOTSUP; 5567 } 5568 memset(bdi, 0, sizeof(*bdi)); 5569 return drv->bdrv_get_info(bs, bdi); 5570 } 5571 5572 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs, 5573 Error **errp) 5574 { 5575 BlockDriver *drv = bs->drv; 5576 if (drv && drv->bdrv_get_specific_info) { 5577 return drv->bdrv_get_specific_info(bs, errp); 5578 } 5579 return NULL; 5580 } 5581 5582 BlockStatsSpecific *bdrv_get_specific_stats(BlockDriverState *bs) 5583 { 5584 BlockDriver *drv = bs->drv; 5585 if (!drv || !drv->bdrv_get_specific_stats) { 5586 return NULL; 5587 } 5588 return drv->bdrv_get_specific_stats(bs); 5589 } 5590 5591 void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event) 5592 { 5593 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) { 5594 return; 5595 } 5596 5597 bs->drv->bdrv_debug_event(bs, event); 5598 } 5599 5600 static BlockDriverState *bdrv_find_debug_node(BlockDriverState *bs) 5601 { 5602 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) { 5603 bs = bdrv_primary_bs(bs); 5604 } 5605 5606 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) { 5607 assert(bs->drv->bdrv_debug_remove_breakpoint); 5608 return bs; 5609 } 5610 5611 return NULL; 5612 } 5613 5614 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event, 5615 const char *tag) 5616 { 5617 bs = bdrv_find_debug_node(bs); 5618 if (bs) { 5619 return bs->drv->bdrv_debug_breakpoint(bs, event, tag); 5620 } 5621 5622 return -ENOTSUP; 5623 } 5624 5625 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag) 5626 { 5627 bs = bdrv_find_debug_node(bs); 5628 if (bs) { 5629 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag); 5630 } 5631 5632 return -ENOTSUP; 5633 } 5634 5635 int bdrv_debug_resume(BlockDriverState *bs, const char *tag) 5636 { 5637 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) { 5638 bs = bdrv_primary_bs(bs); 5639 } 5640 5641 if (bs && bs->drv && bs->drv->bdrv_debug_resume) { 5642 return bs->drv->bdrv_debug_resume(bs, tag); 5643 } 5644 5645 return -ENOTSUP; 5646 } 5647 5648 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag) 5649 { 5650 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) { 5651 bs = bdrv_primary_bs(bs); 5652 } 5653 5654 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) { 5655 return bs->drv->bdrv_debug_is_suspended(bs, tag); 5656 } 5657 5658 return false; 5659 } 5660 5661 /* backing_file can either be relative, or absolute, or a protocol. If it is 5662 * relative, it must be relative to the chain. So, passing in bs->filename 5663 * from a BDS as backing_file should not be done, as that may be relative to 5664 * the CWD rather than the chain. */ 5665 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, 5666 const char *backing_file) 5667 { 5668 char *filename_full = NULL; 5669 char *backing_file_full = NULL; 5670 char *filename_tmp = NULL; 5671 int is_protocol = 0; 5672 bool filenames_refreshed = false; 5673 BlockDriverState *curr_bs = NULL; 5674 BlockDriverState *retval = NULL; 5675 BlockDriverState *bs_below; 5676 5677 if (!bs || !bs->drv || !backing_file) { 5678 return NULL; 5679 } 5680 5681 filename_full = g_malloc(PATH_MAX); 5682 backing_file_full = g_malloc(PATH_MAX); 5683 5684 is_protocol = path_has_protocol(backing_file); 5685 5686 /* 5687 * Being largely a legacy function, skip any filters here 5688 * (because filters do not have normal filenames, so they cannot 5689 * match anyway; and allowing json:{} filenames is a bit out of 5690 * scope). 5691 */ 5692 for (curr_bs = bdrv_skip_filters(bs); 5693 bdrv_cow_child(curr_bs) != NULL; 5694 curr_bs = bs_below) 5695 { 5696 bs_below = bdrv_backing_chain_next(curr_bs); 5697 5698 if (bdrv_backing_overridden(curr_bs)) { 5699 /* 5700 * If the backing file was overridden, we can only compare 5701 * directly against the backing node's filename. 5702 */ 5703 5704 if (!filenames_refreshed) { 5705 /* 5706 * This will automatically refresh all of the 5707 * filenames in the rest of the backing chain, so we 5708 * only need to do this once. 5709 */ 5710 bdrv_refresh_filename(bs_below); 5711 filenames_refreshed = true; 5712 } 5713 5714 if (strcmp(backing_file, bs_below->filename) == 0) { 5715 retval = bs_below; 5716 break; 5717 } 5718 } else if (is_protocol || path_has_protocol(curr_bs->backing_file)) { 5719 /* 5720 * If either of the filename paths is actually a protocol, then 5721 * compare unmodified paths; otherwise make paths relative. 5722 */ 5723 char *backing_file_full_ret; 5724 5725 if (strcmp(backing_file, curr_bs->backing_file) == 0) { 5726 retval = bs_below; 5727 break; 5728 } 5729 /* Also check against the full backing filename for the image */ 5730 backing_file_full_ret = bdrv_get_full_backing_filename(curr_bs, 5731 NULL); 5732 if (backing_file_full_ret) { 5733 bool equal = strcmp(backing_file, backing_file_full_ret) == 0; 5734 g_free(backing_file_full_ret); 5735 if (equal) { 5736 retval = bs_below; 5737 break; 5738 } 5739 } 5740 } else { 5741 /* If not an absolute filename path, make it relative to the current 5742 * image's filename path */ 5743 filename_tmp = bdrv_make_absolute_filename(curr_bs, backing_file, 5744 NULL); 5745 /* We are going to compare canonicalized absolute pathnames */ 5746 if (!filename_tmp || !realpath(filename_tmp, filename_full)) { 5747 g_free(filename_tmp); 5748 continue; 5749 } 5750 g_free(filename_tmp); 5751 5752 /* We need to make sure the backing filename we are comparing against 5753 * is relative to the current image filename (or absolute) */ 5754 filename_tmp = bdrv_get_full_backing_filename(curr_bs, NULL); 5755 if (!filename_tmp || !realpath(filename_tmp, backing_file_full)) { 5756 g_free(filename_tmp); 5757 continue; 5758 } 5759 g_free(filename_tmp); 5760 5761 if (strcmp(backing_file_full, filename_full) == 0) { 5762 retval = bs_below; 5763 break; 5764 } 5765 } 5766 } 5767 5768 g_free(filename_full); 5769 g_free(backing_file_full); 5770 return retval; 5771 } 5772 5773 void bdrv_init(void) 5774 { 5775 module_call_init(MODULE_INIT_BLOCK); 5776 } 5777 5778 void bdrv_init_with_whitelist(void) 5779 { 5780 use_bdrv_whitelist = 1; 5781 bdrv_init(); 5782 } 5783 5784 static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, 5785 Error **errp) 5786 { 5787 BdrvChild *child, *parent; 5788 uint64_t perm, shared_perm; 5789 Error *local_err = NULL; 5790 int ret; 5791 BdrvDirtyBitmap *bm; 5792 5793 if (!bs->drv) { 5794 return; 5795 } 5796 5797 QLIST_FOREACH(child, &bs->children, next) { 5798 bdrv_co_invalidate_cache(child->bs, &local_err); 5799 if (local_err) { 5800 error_propagate(errp, local_err); 5801 return; 5802 } 5803 } 5804 5805 /* 5806 * Update permissions, they may differ for inactive nodes. 5807 * 5808 * Note that the required permissions of inactive images are always a 5809 * subset of the permissions required after activating the image. This 5810 * allows us to just get the permissions upfront without restricting 5811 * drv->bdrv_invalidate_cache(). 5812 * 5813 * It also means that in error cases, we don't have to try and revert to 5814 * the old permissions (which is an operation that could fail, too). We can 5815 * just keep the extended permissions for the next time that an activation 5816 * of the image is tried. 5817 */ 5818 if (bs->open_flags & BDRV_O_INACTIVE) { 5819 bs->open_flags &= ~BDRV_O_INACTIVE; 5820 bdrv_get_cumulative_perm(bs, &perm, &shared_perm); 5821 ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, errp); 5822 if (ret < 0) { 5823 bs->open_flags |= BDRV_O_INACTIVE; 5824 return; 5825 } 5826 bdrv_set_perm(bs, perm, shared_perm); 5827 5828 if (bs->drv->bdrv_co_invalidate_cache) { 5829 bs->drv->bdrv_co_invalidate_cache(bs, &local_err); 5830 if (local_err) { 5831 bs->open_flags |= BDRV_O_INACTIVE; 5832 error_propagate(errp, local_err); 5833 return; 5834 } 5835 } 5836 5837 FOR_EACH_DIRTY_BITMAP(bs, bm) { 5838 bdrv_dirty_bitmap_skip_store(bm, false); 5839 } 5840 5841 ret = refresh_total_sectors(bs, bs->total_sectors); 5842 if (ret < 0) { 5843 bs->open_flags |= BDRV_O_INACTIVE; 5844 error_setg_errno(errp, -ret, "Could not refresh total sector count"); 5845 return; 5846 } 5847 } 5848 5849 QLIST_FOREACH(parent, &bs->parents, next_parent) { 5850 if (parent->klass->activate) { 5851 parent->klass->activate(parent, &local_err); 5852 if (local_err) { 5853 bs->open_flags |= BDRV_O_INACTIVE; 5854 error_propagate(errp, local_err); 5855 return; 5856 } 5857 } 5858 } 5859 } 5860 5861 typedef struct InvalidateCacheCo { 5862 BlockDriverState *bs; 5863 Error **errp; 5864 bool done; 5865 } InvalidateCacheCo; 5866 5867 static void coroutine_fn bdrv_invalidate_cache_co_entry(void *opaque) 5868 { 5869 InvalidateCacheCo *ico = opaque; 5870 bdrv_co_invalidate_cache(ico->bs, ico->errp); 5871 ico->done = true; 5872 aio_wait_kick(); 5873 } 5874 5875 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 5876 { 5877 Coroutine *co; 5878 InvalidateCacheCo ico = { 5879 .bs = bs, 5880 .done = false, 5881 .errp = errp 5882 }; 5883 5884 if (qemu_in_coroutine()) { 5885 /* Fast-path if already in coroutine context */ 5886 bdrv_invalidate_cache_co_entry(&ico); 5887 } else { 5888 co = qemu_coroutine_create(bdrv_invalidate_cache_co_entry, &ico); 5889 bdrv_coroutine_enter(bs, co); 5890 BDRV_POLL_WHILE(bs, !ico.done); 5891 } 5892 } 5893 5894 void bdrv_invalidate_cache_all(Error **errp) 5895 { 5896 BlockDriverState *bs; 5897 Error *local_err = NULL; 5898 BdrvNextIterator it; 5899 5900 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { 5901 AioContext *aio_context = bdrv_get_aio_context(bs); 5902 5903 aio_context_acquire(aio_context); 5904 bdrv_invalidate_cache(bs, &local_err); 5905 aio_context_release(aio_context); 5906 if (local_err) { 5907 error_propagate(errp, local_err); 5908 bdrv_next_cleanup(&it); 5909 return; 5910 } 5911 } 5912 } 5913 5914 static bool bdrv_has_bds_parent(BlockDriverState *bs, bool only_active) 5915 { 5916 BdrvChild *parent; 5917 5918 QLIST_FOREACH(parent, &bs->parents, next_parent) { 5919 if (parent->klass->parent_is_bds) { 5920 BlockDriverState *parent_bs = parent->opaque; 5921 if (!only_active || !(parent_bs->open_flags & BDRV_O_INACTIVE)) { 5922 return true; 5923 } 5924 } 5925 } 5926 5927 return false; 5928 } 5929 5930 static int bdrv_inactivate_recurse(BlockDriverState *bs) 5931 { 5932 BdrvChild *child, *parent; 5933 bool tighten_restrictions; 5934 uint64_t perm, shared_perm; 5935 int ret; 5936 5937 if (!bs->drv) { 5938 return -ENOMEDIUM; 5939 } 5940 5941 /* Make sure that we don't inactivate a child before its parent. 5942 * It will be covered by recursion from the yet active parent. */ 5943 if (bdrv_has_bds_parent(bs, true)) { 5944 return 0; 5945 } 5946 5947 assert(!(bs->open_flags & BDRV_O_INACTIVE)); 5948 5949 /* Inactivate this node */ 5950 if (bs->drv->bdrv_inactivate) { 5951 ret = bs->drv->bdrv_inactivate(bs); 5952 if (ret < 0) { 5953 return ret; 5954 } 5955 } 5956 5957 QLIST_FOREACH(parent, &bs->parents, next_parent) { 5958 if (parent->klass->inactivate) { 5959 ret = parent->klass->inactivate(parent); 5960 if (ret < 0) { 5961 return ret; 5962 } 5963 } 5964 } 5965 5966 bs->open_flags |= BDRV_O_INACTIVE; 5967 5968 /* Update permissions, they may differ for inactive nodes */ 5969 bdrv_get_cumulative_perm(bs, &perm, &shared_perm); 5970 ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, 5971 &tighten_restrictions, NULL); 5972 assert(tighten_restrictions == false); 5973 if (ret < 0) { 5974 /* We only tried to loosen restrictions, so errors are not fatal */ 5975 bdrv_abort_perm_update(bs); 5976 } else { 5977 bdrv_set_perm(bs, perm, shared_perm); 5978 } 5979 5980 5981 /* Recursively inactivate children */ 5982 QLIST_FOREACH(child, &bs->children, next) { 5983 ret = bdrv_inactivate_recurse(child->bs); 5984 if (ret < 0) { 5985 return ret; 5986 } 5987 } 5988 5989 return 0; 5990 } 5991 5992 int bdrv_inactivate_all(void) 5993 { 5994 BlockDriverState *bs = NULL; 5995 BdrvNextIterator it; 5996 int ret = 0; 5997 GSList *aio_ctxs = NULL, *ctx; 5998 5999 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { 6000 AioContext *aio_context = bdrv_get_aio_context(bs); 6001 6002 if (!g_slist_find(aio_ctxs, aio_context)) { 6003 aio_ctxs = g_slist_prepend(aio_ctxs, aio_context); 6004 aio_context_acquire(aio_context); 6005 } 6006 } 6007 6008 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { 6009 /* Nodes with BDS parents are covered by recursion from the last 6010 * parent that gets inactivated. Don't inactivate them a second 6011 * time if that has already happened. */ 6012 if (bdrv_has_bds_parent(bs, false)) { 6013 continue; 6014 } 6015 ret = bdrv_inactivate_recurse(bs); 6016 if (ret < 0) { 6017 bdrv_next_cleanup(&it); 6018 goto out; 6019 } 6020 } 6021 6022 out: 6023 for (ctx = aio_ctxs; ctx != NULL; ctx = ctx->next) { 6024 AioContext *aio_context = ctx->data; 6025 aio_context_release(aio_context); 6026 } 6027 g_slist_free(aio_ctxs); 6028 6029 return ret; 6030 } 6031 6032 /**************************************************************/ 6033 /* removable device support */ 6034 6035 /** 6036 * Return TRUE if the media is present 6037 */ 6038 bool bdrv_is_inserted(BlockDriverState *bs) 6039 { 6040 BlockDriver *drv = bs->drv; 6041 BdrvChild *child; 6042 6043 if (!drv) { 6044 return false; 6045 } 6046 if (drv->bdrv_is_inserted) { 6047 return drv->bdrv_is_inserted(bs); 6048 } 6049 QLIST_FOREACH(child, &bs->children, next) { 6050 if (!bdrv_is_inserted(child->bs)) { 6051 return false; 6052 } 6053 } 6054 return true; 6055 } 6056 6057 /** 6058 * If eject_flag is TRUE, eject the media. Otherwise, close the tray 6059 */ 6060 void bdrv_eject(BlockDriverState *bs, bool eject_flag) 6061 { 6062 BlockDriver *drv = bs->drv; 6063 6064 if (drv && drv->bdrv_eject) { 6065 drv->bdrv_eject(bs, eject_flag); 6066 } 6067 } 6068 6069 /** 6070 * Lock or unlock the media (if it is locked, the user won't be able 6071 * to eject it manually). 6072 */ 6073 void bdrv_lock_medium(BlockDriverState *bs, bool locked) 6074 { 6075 BlockDriver *drv = bs->drv; 6076 6077 trace_bdrv_lock_medium(bs, locked); 6078 6079 if (drv && drv->bdrv_lock_medium) { 6080 drv->bdrv_lock_medium(bs, locked); 6081 } 6082 } 6083 6084 /* Get a reference to bs */ 6085 void bdrv_ref(BlockDriverState *bs) 6086 { 6087 bs->refcnt++; 6088 } 6089 6090 /* Release a previously grabbed reference to bs. 6091 * If after releasing, reference count is zero, the BlockDriverState is 6092 * deleted. */ 6093 void bdrv_unref(BlockDriverState *bs) 6094 { 6095 if (!bs) { 6096 return; 6097 } 6098 assert(bs->refcnt > 0); 6099 if (--bs->refcnt == 0) { 6100 bdrv_delete(bs); 6101 } 6102 } 6103 6104 struct BdrvOpBlocker { 6105 Error *reason; 6106 QLIST_ENTRY(BdrvOpBlocker) list; 6107 }; 6108 6109 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) 6110 { 6111 BdrvOpBlocker *blocker; 6112 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 6113 if (!QLIST_EMPTY(&bs->op_blockers[op])) { 6114 blocker = QLIST_FIRST(&bs->op_blockers[op]); 6115 error_propagate_prepend(errp, error_copy(blocker->reason), 6116 "Node '%s' is busy: ", 6117 bdrv_get_device_or_node_name(bs)); 6118 return true; 6119 } 6120 return false; 6121 } 6122 6123 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason) 6124 { 6125 BdrvOpBlocker *blocker; 6126 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 6127 6128 blocker = g_new0(BdrvOpBlocker, 1); 6129 blocker->reason = reason; 6130 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list); 6131 } 6132 6133 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason) 6134 { 6135 BdrvOpBlocker *blocker, *next; 6136 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 6137 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) { 6138 if (blocker->reason == reason) { 6139 QLIST_REMOVE(blocker, list); 6140 g_free(blocker); 6141 } 6142 } 6143 } 6144 6145 void bdrv_op_block_all(BlockDriverState *bs, Error *reason) 6146 { 6147 int i; 6148 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 6149 bdrv_op_block(bs, i, reason); 6150 } 6151 } 6152 6153 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason) 6154 { 6155 int i; 6156 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 6157 bdrv_op_unblock(bs, i, reason); 6158 } 6159 } 6160 6161 bool bdrv_op_blocker_is_empty(BlockDriverState *bs) 6162 { 6163 int i; 6164 6165 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 6166 if (!QLIST_EMPTY(&bs->op_blockers[i])) { 6167 return false; 6168 } 6169 } 6170 return true; 6171 } 6172 6173 void bdrv_img_create(const char *filename, const char *fmt, 6174 const char *base_filename, const char *base_fmt, 6175 char *options, uint64_t img_size, int flags, bool quiet, 6176 Error **errp) 6177 { 6178 QemuOptsList *create_opts = NULL; 6179 QemuOpts *opts = NULL; 6180 const char *backing_fmt, *backing_file; 6181 int64_t size; 6182 BlockDriver *drv, *proto_drv; 6183 Error *local_err = NULL; 6184 int ret = 0; 6185 6186 /* Find driver and parse its options */ 6187 drv = bdrv_find_format(fmt); 6188 if (!drv) { 6189 error_setg(errp, "Unknown file format '%s'", fmt); 6190 return; 6191 } 6192 6193 proto_drv = bdrv_find_protocol(filename, true, errp); 6194 if (!proto_drv) { 6195 return; 6196 } 6197 6198 if (!drv->create_opts) { 6199 error_setg(errp, "Format driver '%s' does not support image creation", 6200 drv->format_name); 6201 return; 6202 } 6203 6204 if (!proto_drv->create_opts) { 6205 error_setg(errp, "Protocol driver '%s' does not support image creation", 6206 proto_drv->format_name); 6207 return; 6208 } 6209 6210 /* Create parameter list */ 6211 create_opts = qemu_opts_append(create_opts, drv->create_opts); 6212 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); 6213 6214 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 6215 6216 /* Parse -o options */ 6217 if (options) { 6218 if (!qemu_opts_do_parse(opts, options, NULL, errp)) { 6219 goto out; 6220 } 6221 } 6222 6223 if (!qemu_opt_get(opts, BLOCK_OPT_SIZE)) { 6224 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort); 6225 } else if (img_size != UINT64_C(-1)) { 6226 error_setg(errp, "The image size must be specified only once"); 6227 goto out; 6228 } 6229 6230 if (base_filename) { 6231 if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, 6232 NULL)) { 6233 error_setg(errp, "Backing file not supported for file format '%s'", 6234 fmt); 6235 goto out; 6236 } 6237 } 6238 6239 if (base_fmt) { 6240 if (!qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt, NULL)) { 6241 error_setg(errp, "Backing file format not supported for file " 6242 "format '%s'", fmt); 6243 goto out; 6244 } 6245 } 6246 6247 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE); 6248 if (backing_file) { 6249 if (!strcmp(filename, backing_file)) { 6250 error_setg(errp, "Error: Trying to create an image with the " 6251 "same filename as the backing file"); 6252 goto out; 6253 } 6254 if (backing_file[0] == '\0') { 6255 error_setg(errp, "Expected backing file name, got empty string"); 6256 goto out; 6257 } 6258 } 6259 6260 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT); 6261 6262 /* The size for the image must always be specified, unless we have a backing 6263 * file and we have not been forbidden from opening it. */ 6264 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, img_size); 6265 if (backing_file && !(flags & BDRV_O_NO_BACKING)) { 6266 BlockDriverState *bs; 6267 char *full_backing; 6268 int back_flags; 6269 QDict *backing_options = NULL; 6270 6271 full_backing = 6272 bdrv_get_full_backing_filename_from_filename(filename, backing_file, 6273 &local_err); 6274 if (local_err) { 6275 goto out; 6276 } 6277 assert(full_backing); 6278 6279 /* backing files always opened read-only */ 6280 back_flags = flags; 6281 back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); 6282 6283 backing_options = qdict_new(); 6284 if (backing_fmt) { 6285 qdict_put_str(backing_options, "driver", backing_fmt); 6286 } 6287 qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true); 6288 6289 bs = bdrv_open(full_backing, NULL, backing_options, back_flags, 6290 &local_err); 6291 g_free(full_backing); 6292 if (!bs) { 6293 error_append_hint(&local_err, "Could not open backing image.\n"); 6294 goto out; 6295 } else { 6296 if (!backing_fmt) { 6297 warn_report("Deprecated use of backing file without explicit " 6298 "backing format (detected format of %s)", 6299 bs->drv->format_name); 6300 if (bs->drv != &bdrv_raw) { 6301 /* 6302 * A probe of raw deserves the most attention: 6303 * leaving the backing format out of the image 6304 * will ensure bs->probed is set (ensuring we 6305 * don't accidentally commit into the backing 6306 * file), and allow more spots to warn the users 6307 * to fix their toolchain when opening this image 6308 * later. For other images, we can safely record 6309 * the format that we probed. 6310 */ 6311 backing_fmt = bs->drv->format_name; 6312 qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, backing_fmt, 6313 NULL); 6314 } 6315 } 6316 if (size == -1) { 6317 /* Opened BS, have no size */ 6318 size = bdrv_getlength(bs); 6319 if (size < 0) { 6320 error_setg_errno(errp, -size, "Could not get size of '%s'", 6321 backing_file); 6322 bdrv_unref(bs); 6323 goto out; 6324 } 6325 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort); 6326 } 6327 bdrv_unref(bs); 6328 } 6329 /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */ 6330 } else if (backing_file && !backing_fmt) { 6331 warn_report("Deprecated use of unopened backing file without " 6332 "explicit backing format, use of this image requires " 6333 "potentially unsafe format probing"); 6334 } 6335 6336 if (size == -1) { 6337 error_setg(errp, "Image creation needs a size parameter"); 6338 goto out; 6339 } 6340 6341 if (!quiet) { 6342 printf("Formatting '%s', fmt=%s ", filename, fmt); 6343 qemu_opts_print(opts, " "); 6344 puts(""); 6345 fflush(stdout); 6346 } 6347 6348 ret = bdrv_create(drv, filename, opts, &local_err); 6349 6350 if (ret == -EFBIG) { 6351 /* This is generally a better message than whatever the driver would 6352 * deliver (especially because of the cluster_size_hint), since that 6353 * is most probably not much different from "image too large". */ 6354 const char *cluster_size_hint = ""; 6355 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) { 6356 cluster_size_hint = " (try using a larger cluster size)"; 6357 } 6358 error_setg(errp, "The image size is too large for file format '%s'" 6359 "%s", fmt, cluster_size_hint); 6360 error_free(local_err); 6361 local_err = NULL; 6362 } 6363 6364 out: 6365 qemu_opts_del(opts); 6366 qemu_opts_free(create_opts); 6367 error_propagate(errp, local_err); 6368 } 6369 6370 AioContext *bdrv_get_aio_context(BlockDriverState *bs) 6371 { 6372 return bs ? bs->aio_context : qemu_get_aio_context(); 6373 } 6374 6375 void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co) 6376 { 6377 aio_co_enter(bdrv_get_aio_context(bs), co); 6378 } 6379 6380 static void bdrv_do_remove_aio_context_notifier(BdrvAioNotifier *ban) 6381 { 6382 QLIST_REMOVE(ban, list); 6383 g_free(ban); 6384 } 6385 6386 static void bdrv_detach_aio_context(BlockDriverState *bs) 6387 { 6388 BdrvAioNotifier *baf, *baf_tmp; 6389 6390 assert(!bs->walking_aio_notifiers); 6391 bs->walking_aio_notifiers = true; 6392 QLIST_FOREACH_SAFE(baf, &bs->aio_notifiers, list, baf_tmp) { 6393 if (baf->deleted) { 6394 bdrv_do_remove_aio_context_notifier(baf); 6395 } else { 6396 baf->detach_aio_context(baf->opaque); 6397 } 6398 } 6399 /* Never mind iterating again to check for ->deleted. bdrv_close() will 6400 * remove remaining aio notifiers if we aren't called again. 6401 */ 6402 bs->walking_aio_notifiers = false; 6403 6404 if (bs->drv && bs->drv->bdrv_detach_aio_context) { 6405 bs->drv->bdrv_detach_aio_context(bs); 6406 } 6407 6408 if (bs->quiesce_counter) { 6409 aio_enable_external(bs->aio_context); 6410 } 6411 bs->aio_context = NULL; 6412 } 6413 6414 static void bdrv_attach_aio_context(BlockDriverState *bs, 6415 AioContext *new_context) 6416 { 6417 BdrvAioNotifier *ban, *ban_tmp; 6418 6419 if (bs->quiesce_counter) { 6420 aio_disable_external(new_context); 6421 } 6422 6423 bs->aio_context = new_context; 6424 6425 if (bs->drv && bs->drv->bdrv_attach_aio_context) { 6426 bs->drv->bdrv_attach_aio_context(bs, new_context); 6427 } 6428 6429 assert(!bs->walking_aio_notifiers); 6430 bs->walking_aio_notifiers = true; 6431 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_tmp) { 6432 if (ban->deleted) { 6433 bdrv_do_remove_aio_context_notifier(ban); 6434 } else { 6435 ban->attached_aio_context(new_context, ban->opaque); 6436 } 6437 } 6438 bs->walking_aio_notifiers = false; 6439 } 6440 6441 /* 6442 * Changes the AioContext used for fd handlers, timers, and BHs by this 6443 * BlockDriverState and all its children and parents. 6444 * 6445 * Must be called from the main AioContext. 6446 * 6447 * The caller must own the AioContext lock for the old AioContext of bs, but it 6448 * must not own the AioContext lock for new_context (unless new_context is the 6449 * same as the current context of bs). 6450 * 6451 * @ignore will accumulate all visited BdrvChild object. The caller is 6452 * responsible for freeing the list afterwards. 6453 */ 6454 void bdrv_set_aio_context_ignore(BlockDriverState *bs, 6455 AioContext *new_context, GSList **ignore) 6456 { 6457 AioContext *old_context = bdrv_get_aio_context(bs); 6458 BdrvChild *child; 6459 6460 g_assert(qemu_get_current_aio_context() == qemu_get_aio_context()); 6461 6462 if (old_context == new_context) { 6463 return; 6464 } 6465 6466 bdrv_drained_begin(bs); 6467 6468 QLIST_FOREACH(child, &bs->children, next) { 6469 if (g_slist_find(*ignore, child)) { 6470 continue; 6471 } 6472 *ignore = g_slist_prepend(*ignore, child); 6473 bdrv_set_aio_context_ignore(child->bs, new_context, ignore); 6474 } 6475 QLIST_FOREACH(child, &bs->parents, next_parent) { 6476 if (g_slist_find(*ignore, child)) { 6477 continue; 6478 } 6479 assert(child->klass->set_aio_ctx); 6480 *ignore = g_slist_prepend(*ignore, child); 6481 child->klass->set_aio_ctx(child, new_context, ignore); 6482 } 6483 6484 bdrv_detach_aio_context(bs); 6485 6486 /* Acquire the new context, if necessary */ 6487 if (qemu_get_aio_context() != new_context) { 6488 aio_context_acquire(new_context); 6489 } 6490 6491 bdrv_attach_aio_context(bs, new_context); 6492 6493 /* 6494 * If this function was recursively called from 6495 * bdrv_set_aio_context_ignore(), there may be nodes in the 6496 * subtree that have not yet been moved to the new AioContext. 6497 * Release the old one so bdrv_drained_end() can poll them. 6498 */ 6499 if (qemu_get_aio_context() != old_context) { 6500 aio_context_release(old_context); 6501 } 6502 6503 bdrv_drained_end(bs); 6504 6505 if (qemu_get_aio_context() != old_context) { 6506 aio_context_acquire(old_context); 6507 } 6508 if (qemu_get_aio_context() != new_context) { 6509 aio_context_release(new_context); 6510 } 6511 } 6512 6513 static bool bdrv_parent_can_set_aio_context(BdrvChild *c, AioContext *ctx, 6514 GSList **ignore, Error **errp) 6515 { 6516 if (g_slist_find(*ignore, c)) { 6517 return true; 6518 } 6519 *ignore = g_slist_prepend(*ignore, c); 6520 6521 /* 6522 * A BdrvChildClass that doesn't handle AioContext changes cannot 6523 * tolerate any AioContext changes 6524 */ 6525 if (!c->klass->can_set_aio_ctx) { 6526 char *user = bdrv_child_user_desc(c); 6527 error_setg(errp, "Changing iothreads is not supported by %s", user); 6528 g_free(user); 6529 return false; 6530 } 6531 if (!c->klass->can_set_aio_ctx(c, ctx, ignore, errp)) { 6532 assert(!errp || *errp); 6533 return false; 6534 } 6535 return true; 6536 } 6537 6538 bool bdrv_child_can_set_aio_context(BdrvChild *c, AioContext *ctx, 6539 GSList **ignore, Error **errp) 6540 { 6541 if (g_slist_find(*ignore, c)) { 6542 return true; 6543 } 6544 *ignore = g_slist_prepend(*ignore, c); 6545 return bdrv_can_set_aio_context(c->bs, ctx, ignore, errp); 6546 } 6547 6548 /* @ignore will accumulate all visited BdrvChild object. The caller is 6549 * responsible for freeing the list afterwards. */ 6550 bool bdrv_can_set_aio_context(BlockDriverState *bs, AioContext *ctx, 6551 GSList **ignore, Error **errp) 6552 { 6553 BdrvChild *c; 6554 6555 if (bdrv_get_aio_context(bs) == ctx) { 6556 return true; 6557 } 6558 6559 QLIST_FOREACH(c, &bs->parents, next_parent) { 6560 if (!bdrv_parent_can_set_aio_context(c, ctx, ignore, errp)) { 6561 return false; 6562 } 6563 } 6564 QLIST_FOREACH(c, &bs->children, next) { 6565 if (!bdrv_child_can_set_aio_context(c, ctx, ignore, errp)) { 6566 return false; 6567 } 6568 } 6569 6570 return true; 6571 } 6572 6573 int bdrv_child_try_set_aio_context(BlockDriverState *bs, AioContext *ctx, 6574 BdrvChild *ignore_child, Error **errp) 6575 { 6576 GSList *ignore; 6577 bool ret; 6578 6579 ignore = ignore_child ? g_slist_prepend(NULL, ignore_child) : NULL; 6580 ret = bdrv_can_set_aio_context(bs, ctx, &ignore, errp); 6581 g_slist_free(ignore); 6582 6583 if (!ret) { 6584 return -EPERM; 6585 } 6586 6587 ignore = ignore_child ? g_slist_prepend(NULL, ignore_child) : NULL; 6588 bdrv_set_aio_context_ignore(bs, ctx, &ignore); 6589 g_slist_free(ignore); 6590 6591 return 0; 6592 } 6593 6594 int bdrv_try_set_aio_context(BlockDriverState *bs, AioContext *ctx, 6595 Error **errp) 6596 { 6597 return bdrv_child_try_set_aio_context(bs, ctx, NULL, errp); 6598 } 6599 6600 void bdrv_add_aio_context_notifier(BlockDriverState *bs, 6601 void (*attached_aio_context)(AioContext *new_context, void *opaque), 6602 void (*detach_aio_context)(void *opaque), void *opaque) 6603 { 6604 BdrvAioNotifier *ban = g_new(BdrvAioNotifier, 1); 6605 *ban = (BdrvAioNotifier){ 6606 .attached_aio_context = attached_aio_context, 6607 .detach_aio_context = detach_aio_context, 6608 .opaque = opaque 6609 }; 6610 6611 QLIST_INSERT_HEAD(&bs->aio_notifiers, ban, list); 6612 } 6613 6614 void bdrv_remove_aio_context_notifier(BlockDriverState *bs, 6615 void (*attached_aio_context)(AioContext *, 6616 void *), 6617 void (*detach_aio_context)(void *), 6618 void *opaque) 6619 { 6620 BdrvAioNotifier *ban, *ban_next; 6621 6622 QLIST_FOREACH_SAFE(ban, &bs->aio_notifiers, list, ban_next) { 6623 if (ban->attached_aio_context == attached_aio_context && 6624 ban->detach_aio_context == detach_aio_context && 6625 ban->opaque == opaque && 6626 ban->deleted == false) 6627 { 6628 if (bs->walking_aio_notifiers) { 6629 ban->deleted = true; 6630 } else { 6631 bdrv_do_remove_aio_context_notifier(ban); 6632 } 6633 return; 6634 } 6635 } 6636 6637 abort(); 6638 } 6639 6640 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts, 6641 BlockDriverAmendStatusCB *status_cb, void *cb_opaque, 6642 bool force, 6643 Error **errp) 6644 { 6645 if (!bs->drv) { 6646 error_setg(errp, "Node is ejected"); 6647 return -ENOMEDIUM; 6648 } 6649 if (!bs->drv->bdrv_amend_options) { 6650 error_setg(errp, "Block driver '%s' does not support option amendment", 6651 bs->drv->format_name); 6652 return -ENOTSUP; 6653 } 6654 return bs->drv->bdrv_amend_options(bs, opts, status_cb, 6655 cb_opaque, force, errp); 6656 } 6657 6658 /* 6659 * This function checks whether the given @to_replace is allowed to be 6660 * replaced by a node that always shows the same data as @bs. This is 6661 * used for example to verify whether the mirror job can replace 6662 * @to_replace by the target mirrored from @bs. 6663 * To be replaceable, @bs and @to_replace may either be guaranteed to 6664 * always show the same data (because they are only connected through 6665 * filters), or some driver may allow replacing one of its children 6666 * because it can guarantee that this child's data is not visible at 6667 * all (for example, for dissenting quorum children that have no other 6668 * parents). 6669 */ 6670 bool bdrv_recurse_can_replace(BlockDriverState *bs, 6671 BlockDriverState *to_replace) 6672 { 6673 BlockDriverState *filtered; 6674 6675 if (!bs || !bs->drv) { 6676 return false; 6677 } 6678 6679 if (bs == to_replace) { 6680 return true; 6681 } 6682 6683 /* See what the driver can do */ 6684 if (bs->drv->bdrv_recurse_can_replace) { 6685 return bs->drv->bdrv_recurse_can_replace(bs, to_replace); 6686 } 6687 6688 /* For filters without an own implementation, we can recurse on our own */ 6689 filtered = bdrv_filter_bs(bs); 6690 if (filtered) { 6691 return bdrv_recurse_can_replace(filtered, to_replace); 6692 } 6693 6694 /* Safe default */ 6695 return false; 6696 } 6697 6698 /* 6699 * Check whether the given @node_name can be replaced by a node that 6700 * has the same data as @parent_bs. If so, return @node_name's BDS; 6701 * NULL otherwise. 6702 * 6703 * @node_name must be a (recursive) *child of @parent_bs (or this 6704 * function will return NULL). 6705 * 6706 * The result (whether the node can be replaced or not) is only valid 6707 * for as long as no graph or permission changes occur. 6708 */ 6709 BlockDriverState *check_to_replace_node(BlockDriverState *parent_bs, 6710 const char *node_name, Error **errp) 6711 { 6712 BlockDriverState *to_replace_bs = bdrv_find_node(node_name); 6713 AioContext *aio_context; 6714 6715 if (!to_replace_bs) { 6716 error_setg(errp, "Node name '%s' not found", node_name); 6717 return NULL; 6718 } 6719 6720 aio_context = bdrv_get_aio_context(to_replace_bs); 6721 aio_context_acquire(aio_context); 6722 6723 if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) { 6724 to_replace_bs = NULL; 6725 goto out; 6726 } 6727 6728 /* We don't want arbitrary node of the BDS chain to be replaced only the top 6729 * most non filter in order to prevent data corruption. 6730 * Another benefit is that this tests exclude backing files which are 6731 * blocked by the backing blockers. 6732 */ 6733 if (!bdrv_recurse_can_replace(parent_bs, to_replace_bs)) { 6734 error_setg(errp, "Cannot replace '%s' by a node mirrored from '%s', " 6735 "because it cannot be guaranteed that doing so would not " 6736 "lead to an abrupt change of visible data", 6737 node_name, parent_bs->node_name); 6738 to_replace_bs = NULL; 6739 goto out; 6740 } 6741 6742 out: 6743 aio_context_release(aio_context); 6744 return to_replace_bs; 6745 } 6746 6747 /** 6748 * Iterates through the list of runtime option keys that are said to 6749 * be "strong" for a BDS. An option is called "strong" if it changes 6750 * a BDS's data. For example, the null block driver's "size" and 6751 * "read-zeroes" options are strong, but its "latency-ns" option is 6752 * not. 6753 * 6754 * If a key returned by this function ends with a dot, all options 6755 * starting with that prefix are strong. 6756 */ 6757 static const char *const *strong_options(BlockDriverState *bs, 6758 const char *const *curopt) 6759 { 6760 static const char *const global_options[] = { 6761 "driver", "filename", NULL 6762 }; 6763 6764 if (!curopt) { 6765 return &global_options[0]; 6766 } 6767 6768 curopt++; 6769 if (curopt == &global_options[ARRAY_SIZE(global_options) - 1] && bs->drv) { 6770 curopt = bs->drv->strong_runtime_opts; 6771 } 6772 6773 return (curopt && *curopt) ? curopt : NULL; 6774 } 6775 6776 /** 6777 * Copies all strong runtime options from bs->options to the given 6778 * QDict. The set of strong option keys is determined by invoking 6779 * strong_options(). 6780 * 6781 * Returns true iff any strong option was present in bs->options (and 6782 * thus copied to the target QDict) with the exception of "filename" 6783 * and "driver". The caller is expected to use this value to decide 6784 * whether the existence of strong options prevents the generation of 6785 * a plain filename. 6786 */ 6787 static bool append_strong_runtime_options(QDict *d, BlockDriverState *bs) 6788 { 6789 bool found_any = false; 6790 const char *const *option_name = NULL; 6791 6792 if (!bs->drv) { 6793 return false; 6794 } 6795 6796 while ((option_name = strong_options(bs, option_name))) { 6797 bool option_given = false; 6798 6799 assert(strlen(*option_name) > 0); 6800 if ((*option_name)[strlen(*option_name) - 1] != '.') { 6801 QObject *entry = qdict_get(bs->options, *option_name); 6802 if (!entry) { 6803 continue; 6804 } 6805 6806 qdict_put_obj(d, *option_name, qobject_ref(entry)); 6807 option_given = true; 6808 } else { 6809 const QDictEntry *entry; 6810 for (entry = qdict_first(bs->options); entry; 6811 entry = qdict_next(bs->options, entry)) 6812 { 6813 if (strstart(qdict_entry_key(entry), *option_name, NULL)) { 6814 qdict_put_obj(d, qdict_entry_key(entry), 6815 qobject_ref(qdict_entry_value(entry))); 6816 option_given = true; 6817 } 6818 } 6819 } 6820 6821 /* While "driver" and "filename" need to be included in a JSON filename, 6822 * their existence does not prohibit generation of a plain filename. */ 6823 if (!found_any && option_given && 6824 strcmp(*option_name, "driver") && strcmp(*option_name, "filename")) 6825 { 6826 found_any = true; 6827 } 6828 } 6829 6830 if (!qdict_haskey(d, "driver")) { 6831 /* Drivers created with bdrv_new_open_driver() may not have a 6832 * @driver option. Add it here. */ 6833 qdict_put_str(d, "driver", bs->drv->format_name); 6834 } 6835 6836 return found_any; 6837 } 6838 6839 /* Note: This function may return false positives; it may return true 6840 * even if opening the backing file specified by bs's image header 6841 * would result in exactly bs->backing. */ 6842 bool bdrv_backing_overridden(BlockDriverState *bs) 6843 { 6844 if (bs->backing) { 6845 return strcmp(bs->auto_backing_file, 6846 bs->backing->bs->filename); 6847 } else { 6848 /* No backing BDS, so if the image header reports any backing 6849 * file, it must have been suppressed */ 6850 return bs->auto_backing_file[0] != '\0'; 6851 } 6852 } 6853 6854 /* Updates the following BDS fields: 6855 * - exact_filename: A filename which may be used for opening a block device 6856 * which (mostly) equals the given BDS (even without any 6857 * other options; so reading and writing must return the same 6858 * results, but caching etc. may be different) 6859 * - full_open_options: Options which, when given when opening a block device 6860 * (without a filename), result in a BDS (mostly) 6861 * equalling the given one 6862 * - filename: If exact_filename is set, it is copied here. Otherwise, 6863 * full_open_options is converted to a JSON object, prefixed with 6864 * "json:" (for use through the JSON pseudo protocol) and put here. 6865 */ 6866 void bdrv_refresh_filename(BlockDriverState *bs) 6867 { 6868 BlockDriver *drv = bs->drv; 6869 BdrvChild *child; 6870 BlockDriverState *primary_child_bs; 6871 QDict *opts; 6872 bool backing_overridden; 6873 bool generate_json_filename; /* Whether our default implementation should 6874 fill exact_filename (false) or not (true) */ 6875 6876 if (!drv) { 6877 return; 6878 } 6879 6880 /* This BDS's file name may depend on any of its children's file names, so 6881 * refresh those first */ 6882 QLIST_FOREACH(child, &bs->children, next) { 6883 bdrv_refresh_filename(child->bs); 6884 } 6885 6886 if (bs->implicit) { 6887 /* For implicit nodes, just copy everything from the single child */ 6888 child = QLIST_FIRST(&bs->children); 6889 assert(QLIST_NEXT(child, next) == NULL); 6890 6891 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), 6892 child->bs->exact_filename); 6893 pstrcpy(bs->filename, sizeof(bs->filename), child->bs->filename); 6894 6895 qobject_unref(bs->full_open_options); 6896 bs->full_open_options = qobject_ref(child->bs->full_open_options); 6897 6898 return; 6899 } 6900 6901 backing_overridden = bdrv_backing_overridden(bs); 6902 6903 if (bs->open_flags & BDRV_O_NO_IO) { 6904 /* Without I/O, the backing file does not change anything. 6905 * Therefore, in such a case (primarily qemu-img), we can 6906 * pretend the backing file has not been overridden even if 6907 * it technically has been. */ 6908 backing_overridden = false; 6909 } 6910 6911 /* Gather the options QDict */ 6912 opts = qdict_new(); 6913 generate_json_filename = append_strong_runtime_options(opts, bs); 6914 generate_json_filename |= backing_overridden; 6915 6916 if (drv->bdrv_gather_child_options) { 6917 /* Some block drivers may not want to present all of their children's 6918 * options, or name them differently from BdrvChild.name */ 6919 drv->bdrv_gather_child_options(bs, opts, backing_overridden); 6920 } else { 6921 QLIST_FOREACH(child, &bs->children, next) { 6922 if (child == bs->backing && !backing_overridden) { 6923 /* We can skip the backing BDS if it has not been overridden */ 6924 continue; 6925 } 6926 6927 qdict_put(opts, child->name, 6928 qobject_ref(child->bs->full_open_options)); 6929 } 6930 6931 if (backing_overridden && !bs->backing) { 6932 /* Force no backing file */ 6933 qdict_put_null(opts, "backing"); 6934 } 6935 } 6936 6937 qobject_unref(bs->full_open_options); 6938 bs->full_open_options = opts; 6939 6940 primary_child_bs = bdrv_primary_bs(bs); 6941 6942 if (drv->bdrv_refresh_filename) { 6943 /* Obsolete information is of no use here, so drop the old file name 6944 * information before refreshing it */ 6945 bs->exact_filename[0] = '\0'; 6946 6947 drv->bdrv_refresh_filename(bs); 6948 } else if (primary_child_bs) { 6949 /* 6950 * Try to reconstruct valid information from the underlying 6951 * file -- this only works for format nodes (filter nodes 6952 * cannot be probed and as such must be selected by the user 6953 * either through an options dict, or through a special 6954 * filename which the filter driver must construct in its 6955 * .bdrv_refresh_filename() implementation). 6956 */ 6957 6958 bs->exact_filename[0] = '\0'; 6959 6960 /* 6961 * We can use the underlying file's filename if: 6962 * - it has a filename, 6963 * - the current BDS is not a filter, 6964 * - the file is a protocol BDS, and 6965 * - opening that file (as this BDS's format) will automatically create 6966 * the BDS tree we have right now, that is: 6967 * - the user did not significantly change this BDS's behavior with 6968 * some explicit (strong) options 6969 * - no non-file child of this BDS has been overridden by the user 6970 * Both of these conditions are represented by generate_json_filename. 6971 */ 6972 if (primary_child_bs->exact_filename[0] && 6973 primary_child_bs->drv->bdrv_file_open && 6974 !drv->is_filter && !generate_json_filename) 6975 { 6976 strcpy(bs->exact_filename, primary_child_bs->exact_filename); 6977 } 6978 } 6979 6980 if (bs->exact_filename[0]) { 6981 pstrcpy(bs->filename, sizeof(bs->filename), bs->exact_filename); 6982 } else { 6983 QString *json = qobject_to_json(QOBJECT(bs->full_open_options)); 6984 if (snprintf(bs->filename, sizeof(bs->filename), "json:%s", 6985 qstring_get_str(json)) >= sizeof(bs->filename)) { 6986 /* Give user a hint if we truncated things. */ 6987 strcpy(bs->filename + sizeof(bs->filename) - 4, "..."); 6988 } 6989 qobject_unref(json); 6990 } 6991 } 6992 6993 char *bdrv_dirname(BlockDriverState *bs, Error **errp) 6994 { 6995 BlockDriver *drv = bs->drv; 6996 BlockDriverState *child_bs; 6997 6998 if (!drv) { 6999 error_setg(errp, "Node '%s' is ejected", bs->node_name); 7000 return NULL; 7001 } 7002 7003 if (drv->bdrv_dirname) { 7004 return drv->bdrv_dirname(bs, errp); 7005 } 7006 7007 child_bs = bdrv_primary_bs(bs); 7008 if (child_bs) { 7009 return bdrv_dirname(child_bs, errp); 7010 } 7011 7012 bdrv_refresh_filename(bs); 7013 if (bs->exact_filename[0] != '\0') { 7014 return path_combine(bs->exact_filename, ""); 7015 } 7016 7017 error_setg(errp, "Cannot generate a base directory for %s nodes", 7018 drv->format_name); 7019 return NULL; 7020 } 7021 7022 /* 7023 * Hot add/remove a BDS's child. So the user can take a child offline when 7024 * it is broken and take a new child online 7025 */ 7026 void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs, 7027 Error **errp) 7028 { 7029 7030 if (!parent_bs->drv || !parent_bs->drv->bdrv_add_child) { 7031 error_setg(errp, "The node %s does not support adding a child", 7032 bdrv_get_device_or_node_name(parent_bs)); 7033 return; 7034 } 7035 7036 if (!QLIST_EMPTY(&child_bs->parents)) { 7037 error_setg(errp, "The node %s already has a parent", 7038 child_bs->node_name); 7039 return; 7040 } 7041 7042 parent_bs->drv->bdrv_add_child(parent_bs, child_bs, errp); 7043 } 7044 7045 void bdrv_del_child(BlockDriverState *parent_bs, BdrvChild *child, Error **errp) 7046 { 7047 BdrvChild *tmp; 7048 7049 if (!parent_bs->drv || !parent_bs->drv->bdrv_del_child) { 7050 error_setg(errp, "The node %s does not support removing a child", 7051 bdrv_get_device_or_node_name(parent_bs)); 7052 return; 7053 } 7054 7055 QLIST_FOREACH(tmp, &parent_bs->children, next) { 7056 if (tmp == child) { 7057 break; 7058 } 7059 } 7060 7061 if (!tmp) { 7062 error_setg(errp, "The node %s does not have a child named %s", 7063 bdrv_get_device_or_node_name(parent_bs), 7064 bdrv_get_device_or_node_name(child->bs)); 7065 return; 7066 } 7067 7068 parent_bs->drv->bdrv_del_child(parent_bs, child, errp); 7069 } 7070 7071 int bdrv_make_empty(BdrvChild *c, Error **errp) 7072 { 7073 BlockDriver *drv = c->bs->drv; 7074 int ret; 7075 7076 assert(c->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)); 7077 7078 if (!drv->bdrv_make_empty) { 7079 error_setg(errp, "%s does not support emptying nodes", 7080 drv->format_name); 7081 return -ENOTSUP; 7082 } 7083 7084 ret = drv->bdrv_make_empty(c->bs); 7085 if (ret < 0) { 7086 error_setg_errno(errp, -ret, "Failed to empty %s", 7087 c->bs->filename); 7088 return ret; 7089 } 7090 7091 return 0; 7092 } 7093 7094 /* 7095 * Return the child that @bs acts as an overlay for, and from which data may be 7096 * copied in COW or COR operations. Usually this is the backing file. 7097 */ 7098 BdrvChild *bdrv_cow_child(BlockDriverState *bs) 7099 { 7100 if (!bs || !bs->drv) { 7101 return NULL; 7102 } 7103 7104 if (bs->drv->is_filter) { 7105 return NULL; 7106 } 7107 7108 if (!bs->backing) { 7109 return NULL; 7110 } 7111 7112 assert(bs->backing->role & BDRV_CHILD_COW); 7113 return bs->backing; 7114 } 7115 7116 /* 7117 * If @bs acts as a filter for exactly one of its children, return 7118 * that child. 7119 */ 7120 BdrvChild *bdrv_filter_child(BlockDriverState *bs) 7121 { 7122 BdrvChild *c; 7123 7124 if (!bs || !bs->drv) { 7125 return NULL; 7126 } 7127 7128 if (!bs->drv->is_filter) { 7129 return NULL; 7130 } 7131 7132 /* Only one of @backing or @file may be used */ 7133 assert(!(bs->backing && bs->file)); 7134 7135 c = bs->backing ?: bs->file; 7136 if (!c) { 7137 return NULL; 7138 } 7139 7140 assert(c->role & BDRV_CHILD_FILTERED); 7141 return c; 7142 } 7143 7144 /* 7145 * Return either the result of bdrv_cow_child() or bdrv_filter_child(), 7146 * whichever is non-NULL. 7147 * 7148 * Return NULL if both are NULL. 7149 */ 7150 BdrvChild *bdrv_filter_or_cow_child(BlockDriverState *bs) 7151 { 7152 BdrvChild *cow_child = bdrv_cow_child(bs); 7153 BdrvChild *filter_child = bdrv_filter_child(bs); 7154 7155 /* Filter nodes cannot have COW backing files */ 7156 assert(!(cow_child && filter_child)); 7157 7158 return cow_child ?: filter_child; 7159 } 7160 7161 /* 7162 * Return the primary child of this node: For filters, that is the 7163 * filtered child. For other nodes, that is usually the child storing 7164 * metadata. 7165 * (A generally more helpful description is that this is (usually) the 7166 * child that has the same filename as @bs.) 7167 * 7168 * Drivers do not necessarily have a primary child; for example quorum 7169 * does not. 7170 */ 7171 BdrvChild *bdrv_primary_child(BlockDriverState *bs) 7172 { 7173 BdrvChild *c, *found = NULL; 7174 7175 QLIST_FOREACH(c, &bs->children, next) { 7176 if (c->role & BDRV_CHILD_PRIMARY) { 7177 assert(!found); 7178 found = c; 7179 } 7180 } 7181 7182 return found; 7183 } 7184 7185 static BlockDriverState *bdrv_do_skip_filters(BlockDriverState *bs, 7186 bool stop_on_explicit_filter) 7187 { 7188 BdrvChild *c; 7189 7190 if (!bs) { 7191 return NULL; 7192 } 7193 7194 while (!(stop_on_explicit_filter && !bs->implicit)) { 7195 c = bdrv_filter_child(bs); 7196 if (!c) { 7197 /* 7198 * A filter that is embedded in a working block graph must 7199 * have a child. Assert this here so this function does 7200 * not return a filter node that is not expected by the 7201 * caller. 7202 */ 7203 assert(!bs->drv || !bs->drv->is_filter); 7204 break; 7205 } 7206 bs = c->bs; 7207 } 7208 /* 7209 * Note that this treats nodes with bs->drv == NULL as not being 7210 * filters (bs->drv == NULL should be replaced by something else 7211 * anyway). 7212 * The advantage of this behavior is that this function will thus 7213 * always return a non-NULL value (given a non-NULL @bs). 7214 */ 7215 7216 return bs; 7217 } 7218 7219 /* 7220 * Return the first BDS that has not been added implicitly or that 7221 * does not have a filtered child down the chain starting from @bs 7222 * (including @bs itself). 7223 */ 7224 BlockDriverState *bdrv_skip_implicit_filters(BlockDriverState *bs) 7225 { 7226 return bdrv_do_skip_filters(bs, true); 7227 } 7228 7229 /* 7230 * Return the first BDS that does not have a filtered child down the 7231 * chain starting from @bs (including @bs itself). 7232 */ 7233 BlockDriverState *bdrv_skip_filters(BlockDriverState *bs) 7234 { 7235 return bdrv_do_skip_filters(bs, false); 7236 } 7237 7238 /* 7239 * For a backing chain, return the first non-filter backing image of 7240 * the first non-filter image. 7241 */ 7242 BlockDriverState *bdrv_backing_chain_next(BlockDriverState *bs) 7243 { 7244 return bdrv_skip_filters(bdrv_cow_bs(bdrv_skip_filters(bs))); 7245 } 7246