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