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