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