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/sysemu.h" 32 #include "qemu/notify.h" 33 #include "block/coroutine.h" 34 #include "block/qapi.h" 35 #include "qmp-commands.h" 36 #include "qemu/timer.h" 37 #include "qapi-event.h" 38 39 #ifdef CONFIG_BSD 40 #include <sys/types.h> 41 #include <sys/stat.h> 42 #include <sys/ioctl.h> 43 #include <sys/queue.h> 44 #ifndef __DragonFly__ 45 #include <sys/disk.h> 46 #endif 47 #endif 48 49 #ifdef _WIN32 50 #include <windows.h> 51 #endif 52 53 struct BdrvDirtyBitmap { 54 HBitmap *bitmap; 55 QLIST_ENTRY(BdrvDirtyBitmap) list; 56 }; 57 58 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ 59 60 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load); 61 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, 62 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 63 BlockDriverCompletionFunc *cb, void *opaque); 64 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, 65 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 66 BlockDriverCompletionFunc *cb, void *opaque); 67 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs, 68 int64_t sector_num, int nb_sectors, 69 QEMUIOVector *iov); 70 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs, 71 int64_t sector_num, int nb_sectors, 72 QEMUIOVector *iov); 73 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs, 74 int64_t offset, unsigned int bytes, QEMUIOVector *qiov, 75 BdrvRequestFlags flags); 76 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, 77 int64_t offset, unsigned int bytes, QEMUIOVector *qiov, 78 BdrvRequestFlags flags); 79 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, 80 int64_t sector_num, 81 QEMUIOVector *qiov, 82 int nb_sectors, 83 BdrvRequestFlags flags, 84 BlockDriverCompletionFunc *cb, 85 void *opaque, 86 bool is_write); 87 static void coroutine_fn bdrv_co_do_rw(void *opaque); 88 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, 89 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags); 90 91 static QTAILQ_HEAD(, BlockDriverState) bdrv_states = 92 QTAILQ_HEAD_INITIALIZER(bdrv_states); 93 94 static QTAILQ_HEAD(, BlockDriverState) graph_bdrv_states = 95 QTAILQ_HEAD_INITIALIZER(graph_bdrv_states); 96 97 static QLIST_HEAD(, BlockDriver) bdrv_drivers = 98 QLIST_HEAD_INITIALIZER(bdrv_drivers); 99 100 /* If non-zero, use only whitelisted block drivers */ 101 static int use_bdrv_whitelist; 102 103 #ifdef _WIN32 104 static int is_windows_drive_prefix(const char *filename) 105 { 106 return (((filename[0] >= 'a' && filename[0] <= 'z') || 107 (filename[0] >= 'A' && filename[0] <= 'Z')) && 108 filename[1] == ':'); 109 } 110 111 int is_windows_drive(const char *filename) 112 { 113 if (is_windows_drive_prefix(filename) && 114 filename[2] == '\0') 115 return 1; 116 if (strstart(filename, "\\\\.\\", NULL) || 117 strstart(filename, "//./", NULL)) 118 return 1; 119 return 0; 120 } 121 #endif 122 123 /* throttling disk I/O limits */ 124 void bdrv_set_io_limits(BlockDriverState *bs, 125 ThrottleConfig *cfg) 126 { 127 int i; 128 129 throttle_config(&bs->throttle_state, cfg); 130 131 for (i = 0; i < 2; i++) { 132 qemu_co_enter_next(&bs->throttled_reqs[i]); 133 } 134 } 135 136 /* this function drain all the throttled IOs */ 137 static bool bdrv_start_throttled_reqs(BlockDriverState *bs) 138 { 139 bool drained = false; 140 bool enabled = bs->io_limits_enabled; 141 int i; 142 143 bs->io_limits_enabled = false; 144 145 for (i = 0; i < 2; i++) { 146 while (qemu_co_enter_next(&bs->throttled_reqs[i])) { 147 drained = true; 148 } 149 } 150 151 bs->io_limits_enabled = enabled; 152 153 return drained; 154 } 155 156 void bdrv_io_limits_disable(BlockDriverState *bs) 157 { 158 bs->io_limits_enabled = false; 159 160 bdrv_start_throttled_reqs(bs); 161 162 throttle_destroy(&bs->throttle_state); 163 } 164 165 static void bdrv_throttle_read_timer_cb(void *opaque) 166 { 167 BlockDriverState *bs = opaque; 168 qemu_co_enter_next(&bs->throttled_reqs[0]); 169 } 170 171 static void bdrv_throttle_write_timer_cb(void *opaque) 172 { 173 BlockDriverState *bs = opaque; 174 qemu_co_enter_next(&bs->throttled_reqs[1]); 175 } 176 177 /* should be called before bdrv_set_io_limits if a limit is set */ 178 void bdrv_io_limits_enable(BlockDriverState *bs) 179 { 180 assert(!bs->io_limits_enabled); 181 throttle_init(&bs->throttle_state, 182 bdrv_get_aio_context(bs), 183 QEMU_CLOCK_VIRTUAL, 184 bdrv_throttle_read_timer_cb, 185 bdrv_throttle_write_timer_cb, 186 bs); 187 bs->io_limits_enabled = true; 188 } 189 190 /* This function makes an IO wait if needed 191 * 192 * @nb_sectors: the number of sectors of the IO 193 * @is_write: is the IO a write 194 */ 195 static void bdrv_io_limits_intercept(BlockDriverState *bs, 196 unsigned int bytes, 197 bool is_write) 198 { 199 /* does this io must wait */ 200 bool must_wait = throttle_schedule_timer(&bs->throttle_state, is_write); 201 202 /* if must wait or any request of this type throttled queue the IO */ 203 if (must_wait || 204 !qemu_co_queue_empty(&bs->throttled_reqs[is_write])) { 205 qemu_co_queue_wait(&bs->throttled_reqs[is_write]); 206 } 207 208 /* the IO will be executed, do the accounting */ 209 throttle_account(&bs->throttle_state, is_write, bytes); 210 211 212 /* if the next request must wait -> do nothing */ 213 if (throttle_schedule_timer(&bs->throttle_state, is_write)) { 214 return; 215 } 216 217 /* else queue next request for execution */ 218 qemu_co_queue_next(&bs->throttled_reqs[is_write]); 219 } 220 221 size_t bdrv_opt_mem_align(BlockDriverState *bs) 222 { 223 if (!bs || !bs->drv) { 224 /* 4k should be on the safe side */ 225 return 4096; 226 } 227 228 return bs->bl.opt_mem_alignment; 229 } 230 231 /* check if the path starts with "<protocol>:" */ 232 static int path_has_protocol(const char *path) 233 { 234 const char *p; 235 236 #ifdef _WIN32 237 if (is_windows_drive(path) || 238 is_windows_drive_prefix(path)) { 239 return 0; 240 } 241 p = path + strcspn(path, ":/\\"); 242 #else 243 p = path + strcspn(path, ":/"); 244 #endif 245 246 return *p == ':'; 247 } 248 249 int path_is_absolute(const char *path) 250 { 251 #ifdef _WIN32 252 /* specific case for names like: "\\.\d:" */ 253 if (is_windows_drive(path) || is_windows_drive_prefix(path)) { 254 return 1; 255 } 256 return (*path == '/' || *path == '\\'); 257 #else 258 return (*path == '/'); 259 #endif 260 } 261 262 /* if filename is absolute, just copy it to dest. Otherwise, build a 263 path to it by considering it is relative to base_path. URL are 264 supported. */ 265 void path_combine(char *dest, int dest_size, 266 const char *base_path, 267 const char *filename) 268 { 269 const char *p, *p1; 270 int len; 271 272 if (dest_size <= 0) 273 return; 274 if (path_is_absolute(filename)) { 275 pstrcpy(dest, dest_size, filename); 276 } else { 277 p = strchr(base_path, ':'); 278 if (p) 279 p++; 280 else 281 p = base_path; 282 p1 = strrchr(base_path, '/'); 283 #ifdef _WIN32 284 { 285 const char *p2; 286 p2 = strrchr(base_path, '\\'); 287 if (!p1 || p2 > p1) 288 p1 = p2; 289 } 290 #endif 291 if (p1) 292 p1++; 293 else 294 p1 = base_path; 295 if (p1 > p) 296 p = p1; 297 len = p - base_path; 298 if (len > dest_size - 1) 299 len = dest_size - 1; 300 memcpy(dest, base_path, len); 301 dest[len] = '\0'; 302 pstrcat(dest, dest_size, filename); 303 } 304 } 305 306 void bdrv_get_full_backing_filename(BlockDriverState *bs, char *dest, size_t sz) 307 { 308 if (bs->backing_file[0] == '\0' || path_has_protocol(bs->backing_file)) { 309 pstrcpy(dest, sz, bs->backing_file); 310 } else { 311 path_combine(dest, sz, bs->filename, bs->backing_file); 312 } 313 } 314 315 void bdrv_register(BlockDriver *bdrv) 316 { 317 /* Block drivers without coroutine functions need emulation */ 318 if (!bdrv->bdrv_co_readv) { 319 bdrv->bdrv_co_readv = bdrv_co_readv_em; 320 bdrv->bdrv_co_writev = bdrv_co_writev_em; 321 322 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if 323 * the block driver lacks aio we need to emulate that too. 324 */ 325 if (!bdrv->bdrv_aio_readv) { 326 /* add AIO emulation layer */ 327 bdrv->bdrv_aio_readv = bdrv_aio_readv_em; 328 bdrv->bdrv_aio_writev = bdrv_aio_writev_em; 329 } 330 } 331 332 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list); 333 } 334 335 /* create a new block device (by default it is empty) */ 336 BlockDriverState *bdrv_new(const char *device_name, Error **errp) 337 { 338 BlockDriverState *bs; 339 int i; 340 341 if (bdrv_find(device_name)) { 342 error_setg(errp, "Device with id '%s' already exists", 343 device_name); 344 return NULL; 345 } 346 if (bdrv_find_node(device_name)) { 347 error_setg(errp, "Device with node-name '%s' already exists", 348 device_name); 349 return NULL; 350 } 351 352 bs = g_malloc0(sizeof(BlockDriverState)); 353 QLIST_INIT(&bs->dirty_bitmaps); 354 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name); 355 if (device_name[0] != '\0') { 356 QTAILQ_INSERT_TAIL(&bdrv_states, bs, device_list); 357 } 358 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 359 QLIST_INIT(&bs->op_blockers[i]); 360 } 361 bdrv_iostatus_disable(bs); 362 notifier_list_init(&bs->close_notifiers); 363 notifier_with_return_list_init(&bs->before_write_notifiers); 364 qemu_co_queue_init(&bs->throttled_reqs[0]); 365 qemu_co_queue_init(&bs->throttled_reqs[1]); 366 bs->refcnt = 1; 367 bs->aio_context = qemu_get_aio_context(); 368 369 return bs; 370 } 371 372 void bdrv_add_close_notifier(BlockDriverState *bs, Notifier *notify) 373 { 374 notifier_list_add(&bs->close_notifiers, notify); 375 } 376 377 BlockDriver *bdrv_find_format(const char *format_name) 378 { 379 BlockDriver *drv1; 380 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 381 if (!strcmp(drv1->format_name, format_name)) { 382 return drv1; 383 } 384 } 385 return NULL; 386 } 387 388 static int bdrv_is_whitelisted(BlockDriver *drv, bool read_only) 389 { 390 static const char *whitelist_rw[] = { 391 CONFIG_BDRV_RW_WHITELIST 392 }; 393 static const char *whitelist_ro[] = { 394 CONFIG_BDRV_RO_WHITELIST 395 }; 396 const char **p; 397 398 if (!whitelist_rw[0] && !whitelist_ro[0]) { 399 return 1; /* no whitelist, anything goes */ 400 } 401 402 for (p = whitelist_rw; *p; p++) { 403 if (!strcmp(drv->format_name, *p)) { 404 return 1; 405 } 406 } 407 if (read_only) { 408 for (p = whitelist_ro; *p; p++) { 409 if (!strcmp(drv->format_name, *p)) { 410 return 1; 411 } 412 } 413 } 414 return 0; 415 } 416 417 BlockDriver *bdrv_find_whitelisted_format(const char *format_name, 418 bool read_only) 419 { 420 BlockDriver *drv = bdrv_find_format(format_name); 421 return drv && bdrv_is_whitelisted(drv, read_only) ? drv : NULL; 422 } 423 424 typedef struct CreateCo { 425 BlockDriver *drv; 426 char *filename; 427 QemuOpts *opts; 428 int ret; 429 Error *err; 430 } CreateCo; 431 432 static void coroutine_fn bdrv_create_co_entry(void *opaque) 433 { 434 Error *local_err = NULL; 435 int ret; 436 437 CreateCo *cco = opaque; 438 assert(cco->drv); 439 440 ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err); 441 if (local_err) { 442 error_propagate(&cco->err, local_err); 443 } 444 cco->ret = ret; 445 } 446 447 int bdrv_create(BlockDriver *drv, const char* filename, 448 QemuOpts *opts, Error **errp) 449 { 450 int ret; 451 452 Coroutine *co; 453 CreateCo cco = { 454 .drv = drv, 455 .filename = g_strdup(filename), 456 .opts = opts, 457 .ret = NOT_DONE, 458 .err = NULL, 459 }; 460 461 if (!drv->bdrv_create) { 462 error_setg(errp, "Driver '%s' does not support image creation", drv->format_name); 463 ret = -ENOTSUP; 464 goto out; 465 } 466 467 if (qemu_in_coroutine()) { 468 /* Fast-path if already in coroutine context */ 469 bdrv_create_co_entry(&cco); 470 } else { 471 co = qemu_coroutine_create(bdrv_create_co_entry); 472 qemu_coroutine_enter(co, &cco); 473 while (cco.ret == NOT_DONE) { 474 qemu_aio_wait(); 475 } 476 } 477 478 ret = cco.ret; 479 if (ret < 0) { 480 if (cco.err) { 481 error_propagate(errp, cco.err); 482 } else { 483 error_setg_errno(errp, -ret, "Could not create image"); 484 } 485 } 486 487 out: 488 g_free(cco.filename); 489 return ret; 490 } 491 492 int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp) 493 { 494 BlockDriver *drv; 495 Error *local_err = NULL; 496 int ret; 497 498 drv = bdrv_find_protocol(filename, true); 499 if (drv == NULL) { 500 error_setg(errp, "Could not find protocol for file '%s'", filename); 501 return -ENOENT; 502 } 503 504 ret = bdrv_create(drv, filename, opts, &local_err); 505 if (local_err) { 506 error_propagate(errp, local_err); 507 } 508 return ret; 509 } 510 511 int bdrv_refresh_limits(BlockDriverState *bs) 512 { 513 BlockDriver *drv = bs->drv; 514 515 memset(&bs->bl, 0, sizeof(bs->bl)); 516 517 if (!drv) { 518 return 0; 519 } 520 521 /* Take some limits from the children as a default */ 522 if (bs->file) { 523 bdrv_refresh_limits(bs->file); 524 bs->bl.opt_transfer_length = bs->file->bl.opt_transfer_length; 525 bs->bl.opt_mem_alignment = bs->file->bl.opt_mem_alignment; 526 } else { 527 bs->bl.opt_mem_alignment = 512; 528 } 529 530 if (bs->backing_hd) { 531 bdrv_refresh_limits(bs->backing_hd); 532 bs->bl.opt_transfer_length = 533 MAX(bs->bl.opt_transfer_length, 534 bs->backing_hd->bl.opt_transfer_length); 535 bs->bl.opt_mem_alignment = 536 MAX(bs->bl.opt_mem_alignment, 537 bs->backing_hd->bl.opt_mem_alignment); 538 } 539 540 /* Then let the driver override it */ 541 if (drv->bdrv_refresh_limits) { 542 return drv->bdrv_refresh_limits(bs); 543 } 544 545 return 0; 546 } 547 548 /* 549 * Create a uniquely-named empty temporary file. 550 * Return 0 upon success, otherwise a negative errno value. 551 */ 552 int get_tmp_filename(char *filename, int size) 553 { 554 #ifdef _WIN32 555 char temp_dir[MAX_PATH]; 556 /* GetTempFileName requires that its output buffer (4th param) 557 have length MAX_PATH or greater. */ 558 assert(size >= MAX_PATH); 559 return (GetTempPath(MAX_PATH, temp_dir) 560 && GetTempFileName(temp_dir, "qem", 0, filename) 561 ? 0 : -GetLastError()); 562 #else 563 int fd; 564 const char *tmpdir; 565 tmpdir = getenv("TMPDIR"); 566 if (!tmpdir) { 567 tmpdir = "/var/tmp"; 568 } 569 if (snprintf(filename, size, "%s/vl.XXXXXX", tmpdir) >= size) { 570 return -EOVERFLOW; 571 } 572 fd = mkstemp(filename); 573 if (fd < 0) { 574 return -errno; 575 } 576 if (close(fd) != 0) { 577 unlink(filename); 578 return -errno; 579 } 580 return 0; 581 #endif 582 } 583 584 /* 585 * Detect host devices. By convention, /dev/cdrom[N] is always 586 * recognized as a host CDROM. 587 */ 588 static BlockDriver *find_hdev_driver(const char *filename) 589 { 590 int score_max = 0, score; 591 BlockDriver *drv = NULL, *d; 592 593 QLIST_FOREACH(d, &bdrv_drivers, list) { 594 if (d->bdrv_probe_device) { 595 score = d->bdrv_probe_device(filename); 596 if (score > score_max) { 597 score_max = score; 598 drv = d; 599 } 600 } 601 } 602 603 return drv; 604 } 605 606 BlockDriver *bdrv_find_protocol(const char *filename, 607 bool allow_protocol_prefix) 608 { 609 BlockDriver *drv1; 610 char protocol[128]; 611 int len; 612 const char *p; 613 614 /* TODO Drivers without bdrv_file_open must be specified explicitly */ 615 616 /* 617 * XXX(hch): we really should not let host device detection 618 * override an explicit protocol specification, but moving this 619 * later breaks access to device names with colons in them. 620 * Thanks to the brain-dead persistent naming schemes on udev- 621 * based Linux systems those actually are quite common. 622 */ 623 drv1 = find_hdev_driver(filename); 624 if (drv1) { 625 return drv1; 626 } 627 628 if (!path_has_protocol(filename) || !allow_protocol_prefix) { 629 return bdrv_find_format("file"); 630 } 631 632 p = strchr(filename, ':'); 633 assert(p != NULL); 634 len = p - filename; 635 if (len > sizeof(protocol) - 1) 636 len = sizeof(protocol) - 1; 637 memcpy(protocol, filename, len); 638 protocol[len] = '\0'; 639 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 640 if (drv1->protocol_name && 641 !strcmp(drv1->protocol_name, protocol)) { 642 return drv1; 643 } 644 } 645 return NULL; 646 } 647 648 static int find_image_format(BlockDriverState *bs, const char *filename, 649 BlockDriver **pdrv, Error **errp) 650 { 651 int score, score_max; 652 BlockDriver *drv1, *drv; 653 uint8_t buf[2048]; 654 int ret = 0; 655 656 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */ 657 if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) { 658 drv = bdrv_find_format("raw"); 659 if (!drv) { 660 error_setg(errp, "Could not find raw image format"); 661 ret = -ENOENT; 662 } 663 *pdrv = drv; 664 return ret; 665 } 666 667 ret = bdrv_pread(bs, 0, buf, sizeof(buf)); 668 if (ret < 0) { 669 error_setg_errno(errp, -ret, "Could not read image for determining its " 670 "format"); 671 *pdrv = NULL; 672 return ret; 673 } 674 675 score_max = 0; 676 drv = NULL; 677 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 678 if (drv1->bdrv_probe) { 679 score = drv1->bdrv_probe(buf, ret, filename); 680 if (score > score_max) { 681 score_max = score; 682 drv = drv1; 683 } 684 } 685 } 686 if (!drv) { 687 error_setg(errp, "Could not determine image format: No compatible " 688 "driver found"); 689 ret = -ENOENT; 690 } 691 *pdrv = drv; 692 return ret; 693 } 694 695 /** 696 * Set the current 'total_sectors' value 697 */ 698 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint) 699 { 700 BlockDriver *drv = bs->drv; 701 702 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */ 703 if (bs->sg) 704 return 0; 705 706 /* query actual device if possible, otherwise just trust the hint */ 707 if (drv->bdrv_getlength) { 708 int64_t length = drv->bdrv_getlength(bs); 709 if (length < 0) { 710 return length; 711 } 712 hint = DIV_ROUND_UP(length, BDRV_SECTOR_SIZE); 713 } 714 715 bs->total_sectors = hint; 716 return 0; 717 } 718 719 /** 720 * Set open flags for a given discard mode 721 * 722 * Return 0 on success, -1 if the discard mode was invalid. 723 */ 724 int bdrv_parse_discard_flags(const char *mode, int *flags) 725 { 726 *flags &= ~BDRV_O_UNMAP; 727 728 if (!strcmp(mode, "off") || !strcmp(mode, "ignore")) { 729 /* do nothing */ 730 } else if (!strcmp(mode, "on") || !strcmp(mode, "unmap")) { 731 *flags |= BDRV_O_UNMAP; 732 } else { 733 return -1; 734 } 735 736 return 0; 737 } 738 739 /** 740 * Set open flags for a given cache mode 741 * 742 * Return 0 on success, -1 if the cache mode was invalid. 743 */ 744 int bdrv_parse_cache_flags(const char *mode, int *flags) 745 { 746 *flags &= ~BDRV_O_CACHE_MASK; 747 748 if (!strcmp(mode, "off") || !strcmp(mode, "none")) { 749 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB; 750 } else if (!strcmp(mode, "directsync")) { 751 *flags |= BDRV_O_NOCACHE; 752 } else if (!strcmp(mode, "writeback")) { 753 *flags |= BDRV_O_CACHE_WB; 754 } else if (!strcmp(mode, "unsafe")) { 755 *flags |= BDRV_O_CACHE_WB; 756 *flags |= BDRV_O_NO_FLUSH; 757 } else if (!strcmp(mode, "writethrough")) { 758 /* this is the default */ 759 } else { 760 return -1; 761 } 762 763 return 0; 764 } 765 766 /** 767 * The copy-on-read flag is actually a reference count so multiple users may 768 * use the feature without worrying about clobbering its previous state. 769 * Copy-on-read stays enabled until all users have called to disable it. 770 */ 771 void bdrv_enable_copy_on_read(BlockDriverState *bs) 772 { 773 bs->copy_on_read++; 774 } 775 776 void bdrv_disable_copy_on_read(BlockDriverState *bs) 777 { 778 assert(bs->copy_on_read > 0); 779 bs->copy_on_read--; 780 } 781 782 /* 783 * Returns the flags that a temporary snapshot should get, based on the 784 * originally requested flags (the originally requested image will have flags 785 * like a backing file) 786 */ 787 static int bdrv_temp_snapshot_flags(int flags) 788 { 789 return (flags & ~BDRV_O_SNAPSHOT) | BDRV_O_TEMPORARY; 790 } 791 792 /* 793 * Returns the flags that bs->file should get, based on the given flags for 794 * the parent BDS 795 */ 796 static int bdrv_inherited_flags(int flags) 797 { 798 /* Enable protocol handling, disable format probing for bs->file */ 799 flags |= BDRV_O_PROTOCOL; 800 801 /* Our block drivers take care to send flushes and respect unmap policy, 802 * so we can enable both unconditionally on lower layers. */ 803 flags |= BDRV_O_CACHE_WB | BDRV_O_UNMAP; 804 805 /* Clear flags that only apply to the top layer */ 806 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ); 807 808 return flags; 809 } 810 811 /* 812 * Returns the flags that bs->backing_hd should get, based on the given flags 813 * for the parent BDS 814 */ 815 static int bdrv_backing_flags(int flags) 816 { 817 /* backing files always opened read-only */ 818 flags &= ~(BDRV_O_RDWR | BDRV_O_COPY_ON_READ); 819 820 /* snapshot=on is handled on the top layer */ 821 flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_TEMPORARY); 822 823 return flags; 824 } 825 826 static int bdrv_open_flags(BlockDriverState *bs, int flags) 827 { 828 int open_flags = flags | BDRV_O_CACHE_WB; 829 830 /* 831 * Clear flags that are internal to the block layer before opening the 832 * image. 833 */ 834 open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL); 835 836 /* 837 * Snapshots should be writable. 838 */ 839 if (flags & BDRV_O_TEMPORARY) { 840 open_flags |= BDRV_O_RDWR; 841 } 842 843 return open_flags; 844 } 845 846 static void bdrv_assign_node_name(BlockDriverState *bs, 847 const char *node_name, 848 Error **errp) 849 { 850 if (!node_name) { 851 return; 852 } 853 854 /* empty string node name is invalid */ 855 if (node_name[0] == '\0') { 856 error_setg(errp, "Empty node name"); 857 return; 858 } 859 860 /* takes care of avoiding namespaces collisions */ 861 if (bdrv_find(node_name)) { 862 error_setg(errp, "node-name=%s is conflicting with a device id", 863 node_name); 864 return; 865 } 866 867 /* takes care of avoiding duplicates node names */ 868 if (bdrv_find_node(node_name)) { 869 error_setg(errp, "Duplicate node name"); 870 return; 871 } 872 873 /* copy node name into the bs and insert it into the graph list */ 874 pstrcpy(bs->node_name, sizeof(bs->node_name), node_name); 875 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs, node_list); 876 } 877 878 /* 879 * Common part for opening disk images and files 880 * 881 * Removes all processed options from *options. 882 */ 883 static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, 884 QDict *options, int flags, BlockDriver *drv, Error **errp) 885 { 886 int ret, open_flags; 887 const char *filename; 888 const char *node_name = NULL; 889 Error *local_err = NULL; 890 891 assert(drv != NULL); 892 assert(bs->file == NULL); 893 assert(options != NULL && bs->options != options); 894 895 if (file != NULL) { 896 filename = file->filename; 897 } else { 898 filename = qdict_get_try_str(options, "filename"); 899 } 900 901 if (drv->bdrv_needs_filename && !filename) { 902 error_setg(errp, "The '%s' block driver requires a file name", 903 drv->format_name); 904 return -EINVAL; 905 } 906 907 trace_bdrv_open_common(bs, filename ?: "", flags, drv->format_name); 908 909 node_name = qdict_get_try_str(options, "node-name"); 910 bdrv_assign_node_name(bs, node_name, &local_err); 911 if (local_err) { 912 error_propagate(errp, local_err); 913 return -EINVAL; 914 } 915 qdict_del(options, "node-name"); 916 917 /* bdrv_open() with directly using a protocol as drv. This layer is already 918 * opened, so assign it to bs (while file becomes a closed BlockDriverState) 919 * and return immediately. */ 920 if (file != NULL && drv->bdrv_file_open) { 921 bdrv_swap(file, bs); 922 return 0; 923 } 924 925 bs->open_flags = flags; 926 bs->guest_block_size = 512; 927 bs->request_alignment = 512; 928 bs->zero_beyond_eof = true; 929 open_flags = bdrv_open_flags(bs, flags); 930 bs->read_only = !(open_flags & BDRV_O_RDWR); 931 bs->growable = !!(flags & BDRV_O_PROTOCOL); 932 933 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) { 934 error_setg(errp, 935 !bs->read_only && bdrv_is_whitelisted(drv, true) 936 ? "Driver '%s' can only be used for read-only devices" 937 : "Driver '%s' is not whitelisted", 938 drv->format_name); 939 return -ENOTSUP; 940 } 941 942 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */ 943 if (flags & BDRV_O_COPY_ON_READ) { 944 if (!bs->read_only) { 945 bdrv_enable_copy_on_read(bs); 946 } else { 947 error_setg(errp, "Can't use copy-on-read on read-only device"); 948 return -EINVAL; 949 } 950 } 951 952 if (filename != NULL) { 953 pstrcpy(bs->filename, sizeof(bs->filename), filename); 954 } else { 955 bs->filename[0] = '\0'; 956 } 957 958 bs->drv = drv; 959 bs->opaque = g_malloc0(drv->instance_size); 960 961 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB); 962 963 /* Open the image, either directly or using a protocol */ 964 if (drv->bdrv_file_open) { 965 assert(file == NULL); 966 assert(!drv->bdrv_needs_filename || filename != NULL); 967 ret = drv->bdrv_file_open(bs, options, open_flags, &local_err); 968 } else { 969 if (file == NULL) { 970 error_setg(errp, "Can't use '%s' as a block driver for the " 971 "protocol level", drv->format_name); 972 ret = -EINVAL; 973 goto free_and_fail; 974 } 975 bs->file = file; 976 ret = drv->bdrv_open(bs, options, open_flags, &local_err); 977 } 978 979 if (ret < 0) { 980 if (local_err) { 981 error_propagate(errp, local_err); 982 } else if (bs->filename[0]) { 983 error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename); 984 } else { 985 error_setg_errno(errp, -ret, "Could not open image"); 986 } 987 goto free_and_fail; 988 } 989 990 ret = refresh_total_sectors(bs, bs->total_sectors); 991 if (ret < 0) { 992 error_setg_errno(errp, -ret, "Could not refresh total sector count"); 993 goto free_and_fail; 994 } 995 996 bdrv_refresh_limits(bs); 997 assert(bdrv_opt_mem_align(bs) != 0); 998 assert((bs->request_alignment != 0) || bs->sg); 999 return 0; 1000 1001 free_and_fail: 1002 bs->file = NULL; 1003 g_free(bs->opaque); 1004 bs->opaque = NULL; 1005 bs->drv = NULL; 1006 return ret; 1007 } 1008 1009 static QDict *parse_json_filename(const char *filename, Error **errp) 1010 { 1011 QObject *options_obj; 1012 QDict *options; 1013 int ret; 1014 1015 ret = strstart(filename, "json:", &filename); 1016 assert(ret); 1017 1018 options_obj = qobject_from_json(filename); 1019 if (!options_obj) { 1020 error_setg(errp, "Could not parse the JSON options"); 1021 return NULL; 1022 } 1023 1024 if (qobject_type(options_obj) != QTYPE_QDICT) { 1025 qobject_decref(options_obj); 1026 error_setg(errp, "Invalid JSON object given"); 1027 return NULL; 1028 } 1029 1030 options = qobject_to_qdict(options_obj); 1031 qdict_flatten(options); 1032 1033 return options; 1034 } 1035 1036 /* 1037 * Fills in default options for opening images and converts the legacy 1038 * filename/flags pair to option QDict entries. 1039 */ 1040 static int bdrv_fill_options(QDict **options, const char **pfilename, int flags, 1041 BlockDriver *drv, Error **errp) 1042 { 1043 const char *filename = *pfilename; 1044 const char *drvname; 1045 bool protocol = flags & BDRV_O_PROTOCOL; 1046 bool parse_filename = false; 1047 Error *local_err = NULL; 1048 1049 /* Parse json: pseudo-protocol */ 1050 if (filename && g_str_has_prefix(filename, "json:")) { 1051 QDict *json_options = parse_json_filename(filename, &local_err); 1052 if (local_err) { 1053 error_propagate(errp, local_err); 1054 return -EINVAL; 1055 } 1056 1057 /* Options given in the filename have lower priority than options 1058 * specified directly */ 1059 qdict_join(*options, json_options, false); 1060 QDECREF(json_options); 1061 *pfilename = filename = NULL; 1062 } 1063 1064 /* Fetch the file name from the options QDict if necessary */ 1065 if (protocol && filename) { 1066 if (!qdict_haskey(*options, "filename")) { 1067 qdict_put(*options, "filename", qstring_from_str(filename)); 1068 parse_filename = true; 1069 } else { 1070 error_setg(errp, "Can't specify 'file' and 'filename' options at " 1071 "the same time"); 1072 return -EINVAL; 1073 } 1074 } 1075 1076 /* Find the right block driver */ 1077 filename = qdict_get_try_str(*options, "filename"); 1078 drvname = qdict_get_try_str(*options, "driver"); 1079 1080 if (drv) { 1081 if (drvname) { 1082 error_setg(errp, "Driver specified twice"); 1083 return -EINVAL; 1084 } 1085 drvname = drv->format_name; 1086 qdict_put(*options, "driver", qstring_from_str(drvname)); 1087 } else { 1088 if (!drvname && protocol) { 1089 if (filename) { 1090 drv = bdrv_find_protocol(filename, parse_filename); 1091 if (!drv) { 1092 error_setg(errp, "Unknown protocol"); 1093 return -EINVAL; 1094 } 1095 1096 drvname = drv->format_name; 1097 qdict_put(*options, "driver", qstring_from_str(drvname)); 1098 } else { 1099 error_setg(errp, "Must specify either driver or file"); 1100 return -EINVAL; 1101 } 1102 } else if (drvname) { 1103 drv = bdrv_find_format(drvname); 1104 if (!drv) { 1105 error_setg(errp, "Unknown driver '%s'", drvname); 1106 return -ENOENT; 1107 } 1108 } 1109 } 1110 1111 assert(drv || !protocol); 1112 1113 /* Driver-specific filename parsing */ 1114 if (drv && drv->bdrv_parse_filename && parse_filename) { 1115 drv->bdrv_parse_filename(filename, *options, &local_err); 1116 if (local_err) { 1117 error_propagate(errp, local_err); 1118 return -EINVAL; 1119 } 1120 1121 if (!drv->bdrv_needs_filename) { 1122 qdict_del(*options, "filename"); 1123 } 1124 } 1125 1126 return 0; 1127 } 1128 1129 void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd) 1130 { 1131 1132 if (bs->backing_hd) { 1133 assert(bs->backing_blocker); 1134 bdrv_op_unblock_all(bs->backing_hd, bs->backing_blocker); 1135 } else if (backing_hd) { 1136 error_setg(&bs->backing_blocker, 1137 "device is used as backing hd of '%s'", 1138 bs->device_name); 1139 } 1140 1141 bs->backing_hd = backing_hd; 1142 if (!backing_hd) { 1143 error_free(bs->backing_blocker); 1144 bs->backing_blocker = NULL; 1145 goto out; 1146 } 1147 bs->open_flags &= ~BDRV_O_NO_BACKING; 1148 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_hd->filename); 1149 pstrcpy(bs->backing_format, sizeof(bs->backing_format), 1150 backing_hd->drv ? backing_hd->drv->format_name : ""); 1151 1152 bdrv_op_block_all(bs->backing_hd, bs->backing_blocker); 1153 /* Otherwise we won't be able to commit due to check in bdrv_commit */ 1154 bdrv_op_unblock(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, 1155 bs->backing_blocker); 1156 out: 1157 bdrv_refresh_limits(bs); 1158 } 1159 1160 /* 1161 * Opens the backing file for a BlockDriverState if not yet open 1162 * 1163 * options is a QDict of options to pass to the block drivers, or NULL for an 1164 * empty set of options. The reference to the QDict is transferred to this 1165 * function (even on failure), so if the caller intends to reuse the dictionary, 1166 * it needs to use QINCREF() before calling bdrv_file_open. 1167 */ 1168 int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp) 1169 { 1170 char *backing_filename = g_malloc0(PATH_MAX); 1171 int ret = 0; 1172 BlockDriver *back_drv = NULL; 1173 BlockDriverState *backing_hd; 1174 Error *local_err = NULL; 1175 1176 if (bs->backing_hd != NULL) { 1177 QDECREF(options); 1178 goto free_exit; 1179 } 1180 1181 /* NULL means an empty set of options */ 1182 if (options == NULL) { 1183 options = qdict_new(); 1184 } 1185 1186 bs->open_flags &= ~BDRV_O_NO_BACKING; 1187 if (qdict_haskey(options, "file.filename")) { 1188 backing_filename[0] = '\0'; 1189 } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) { 1190 QDECREF(options); 1191 goto free_exit; 1192 } else { 1193 bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX); 1194 } 1195 1196 if (!bs->drv || !bs->drv->supports_backing) { 1197 ret = -EINVAL; 1198 error_setg(errp, "Driver doesn't support backing files"); 1199 QDECREF(options); 1200 goto free_exit; 1201 } 1202 1203 backing_hd = bdrv_new("", errp); 1204 1205 if (bs->backing_format[0] != '\0') { 1206 back_drv = bdrv_find_format(bs->backing_format); 1207 } 1208 1209 assert(bs->backing_hd == NULL); 1210 ret = bdrv_open(&backing_hd, 1211 *backing_filename ? backing_filename : NULL, NULL, options, 1212 bdrv_backing_flags(bs->open_flags), back_drv, &local_err); 1213 if (ret < 0) { 1214 bdrv_unref(backing_hd); 1215 backing_hd = NULL; 1216 bs->open_flags |= BDRV_O_NO_BACKING; 1217 error_setg(errp, "Could not open backing file: %s", 1218 error_get_pretty(local_err)); 1219 error_free(local_err); 1220 goto free_exit; 1221 } 1222 bdrv_set_backing_hd(bs, backing_hd); 1223 1224 free_exit: 1225 g_free(backing_filename); 1226 return ret; 1227 } 1228 1229 /* 1230 * Opens a disk image whose options are given as BlockdevRef in another block 1231 * device's options. 1232 * 1233 * If allow_none is true, no image will be opened if filename is false and no 1234 * BlockdevRef is given. *pbs will remain unchanged and 0 will be returned. 1235 * 1236 * bdrev_key specifies the key for the image's BlockdevRef in the options QDict. 1237 * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict 1238 * itself, all options starting with "${bdref_key}." are considered part of the 1239 * BlockdevRef. 1240 * 1241 * The BlockdevRef will be removed from the options QDict. 1242 * 1243 * To conform with the behavior of bdrv_open(), *pbs has to be NULL. 1244 */ 1245 int bdrv_open_image(BlockDriverState **pbs, const char *filename, 1246 QDict *options, const char *bdref_key, int flags, 1247 bool allow_none, Error **errp) 1248 { 1249 QDict *image_options; 1250 int ret; 1251 char *bdref_key_dot; 1252 const char *reference; 1253 1254 assert(pbs); 1255 assert(*pbs == NULL); 1256 1257 bdref_key_dot = g_strdup_printf("%s.", bdref_key); 1258 qdict_extract_subqdict(options, &image_options, bdref_key_dot); 1259 g_free(bdref_key_dot); 1260 1261 reference = qdict_get_try_str(options, bdref_key); 1262 if (!filename && !reference && !qdict_size(image_options)) { 1263 if (allow_none) { 1264 ret = 0; 1265 } else { 1266 error_setg(errp, "A block device must be specified for \"%s\"", 1267 bdref_key); 1268 ret = -EINVAL; 1269 } 1270 QDECREF(image_options); 1271 goto done; 1272 } 1273 1274 ret = bdrv_open(pbs, filename, reference, image_options, flags, NULL, errp); 1275 1276 done: 1277 qdict_del(options, bdref_key); 1278 return ret; 1279 } 1280 1281 void bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp) 1282 { 1283 /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */ 1284 char *tmp_filename = g_malloc0(PATH_MAX + 1); 1285 int64_t total_size; 1286 BlockDriver *bdrv_qcow2; 1287 QemuOpts *opts = NULL; 1288 QDict *snapshot_options; 1289 BlockDriverState *bs_snapshot; 1290 Error *local_err; 1291 int ret; 1292 1293 /* if snapshot, we create a temporary backing file and open it 1294 instead of opening 'filename' directly */ 1295 1296 /* Get the required size from the image */ 1297 total_size = bdrv_getlength(bs); 1298 if (total_size < 0) { 1299 error_setg_errno(errp, -total_size, "Could not get image size"); 1300 goto out; 1301 } 1302 total_size &= BDRV_SECTOR_MASK; 1303 1304 /* Create the temporary image */ 1305 ret = get_tmp_filename(tmp_filename, PATH_MAX + 1); 1306 if (ret < 0) { 1307 error_setg_errno(errp, -ret, "Could not get temporary filename"); 1308 goto out; 1309 } 1310 1311 bdrv_qcow2 = bdrv_find_format("qcow2"); 1312 opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0, 1313 &error_abort); 1314 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size); 1315 ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err); 1316 qemu_opts_del(opts); 1317 if (ret < 0) { 1318 error_setg_errno(errp, -ret, "Could not create temporary overlay " 1319 "'%s': %s", tmp_filename, 1320 error_get_pretty(local_err)); 1321 error_free(local_err); 1322 goto out; 1323 } 1324 1325 /* Prepare a new options QDict for the temporary file */ 1326 snapshot_options = qdict_new(); 1327 qdict_put(snapshot_options, "file.driver", 1328 qstring_from_str("file")); 1329 qdict_put(snapshot_options, "file.filename", 1330 qstring_from_str(tmp_filename)); 1331 1332 bs_snapshot = bdrv_new("", &error_abort); 1333 1334 ret = bdrv_open(&bs_snapshot, NULL, NULL, snapshot_options, 1335 flags, bdrv_qcow2, &local_err); 1336 if (ret < 0) { 1337 error_propagate(errp, local_err); 1338 goto out; 1339 } 1340 1341 bdrv_append(bs_snapshot, bs); 1342 1343 out: 1344 g_free(tmp_filename); 1345 } 1346 1347 /* 1348 * Opens a disk image (raw, qcow2, vmdk, ...) 1349 * 1350 * options is a QDict of options to pass to the block drivers, or NULL for an 1351 * empty set of options. The reference to the QDict belongs to the block layer 1352 * after the call (even on failure), so if the caller intends to reuse the 1353 * dictionary, it needs to use QINCREF() before calling bdrv_open. 1354 * 1355 * If *pbs is NULL, a new BDS will be created with a pointer to it stored there. 1356 * If it is not NULL, the referenced BDS will be reused. 1357 * 1358 * The reference parameter may be used to specify an existing block device which 1359 * should be opened. If specified, neither options nor a filename may be given, 1360 * nor can an existing BDS be reused (that is, *pbs has to be NULL). 1361 */ 1362 int bdrv_open(BlockDriverState **pbs, const char *filename, 1363 const char *reference, QDict *options, int flags, 1364 BlockDriver *drv, Error **errp) 1365 { 1366 int ret; 1367 BlockDriverState *file = NULL, *bs; 1368 const char *drvname; 1369 Error *local_err = NULL; 1370 int snapshot_flags = 0; 1371 1372 assert(pbs); 1373 1374 if (reference) { 1375 bool options_non_empty = options ? qdict_size(options) : false; 1376 QDECREF(options); 1377 1378 if (*pbs) { 1379 error_setg(errp, "Cannot reuse an existing BDS when referencing " 1380 "another block device"); 1381 return -EINVAL; 1382 } 1383 1384 if (filename || options_non_empty) { 1385 error_setg(errp, "Cannot reference an existing block device with " 1386 "additional options or a new filename"); 1387 return -EINVAL; 1388 } 1389 1390 bs = bdrv_lookup_bs(reference, reference, errp); 1391 if (!bs) { 1392 return -ENODEV; 1393 } 1394 bdrv_ref(bs); 1395 *pbs = bs; 1396 return 0; 1397 } 1398 1399 if (*pbs) { 1400 bs = *pbs; 1401 } else { 1402 bs = bdrv_new("", &error_abort); 1403 } 1404 1405 /* NULL means an empty set of options */ 1406 if (options == NULL) { 1407 options = qdict_new(); 1408 } 1409 1410 ret = bdrv_fill_options(&options, &filename, flags, drv, &local_err); 1411 if (local_err) { 1412 goto fail; 1413 } 1414 1415 /* Find the right image format driver */ 1416 drv = NULL; 1417 drvname = qdict_get_try_str(options, "driver"); 1418 if (drvname) { 1419 drv = bdrv_find_format(drvname); 1420 qdict_del(options, "driver"); 1421 if (!drv) { 1422 error_setg(errp, "Unknown driver: '%s'", drvname); 1423 ret = -EINVAL; 1424 goto fail; 1425 } 1426 } 1427 1428 assert(drvname || !(flags & BDRV_O_PROTOCOL)); 1429 if (drv && !drv->bdrv_file_open) { 1430 /* If the user explicitly wants a format driver here, we'll need to add 1431 * another layer for the protocol in bs->file */ 1432 flags &= ~BDRV_O_PROTOCOL; 1433 } 1434 1435 bs->options = options; 1436 options = qdict_clone_shallow(options); 1437 1438 /* Open image file without format layer */ 1439 if ((flags & BDRV_O_PROTOCOL) == 0) { 1440 if (flags & BDRV_O_RDWR) { 1441 flags |= BDRV_O_ALLOW_RDWR; 1442 } 1443 if (flags & BDRV_O_SNAPSHOT) { 1444 snapshot_flags = bdrv_temp_snapshot_flags(flags); 1445 flags = bdrv_backing_flags(flags); 1446 } 1447 1448 assert(file == NULL); 1449 ret = bdrv_open_image(&file, filename, options, "file", 1450 bdrv_inherited_flags(flags), 1451 true, &local_err); 1452 if (ret < 0) { 1453 goto fail; 1454 } 1455 } 1456 1457 /* Image format probing */ 1458 if (!drv && file) { 1459 ret = find_image_format(file, filename, &drv, &local_err); 1460 if (ret < 0) { 1461 goto fail; 1462 } 1463 } else if (!drv) { 1464 error_setg(errp, "Must specify either driver or file"); 1465 ret = -EINVAL; 1466 goto fail; 1467 } 1468 1469 /* Open the image */ 1470 ret = bdrv_open_common(bs, file, options, flags, drv, &local_err); 1471 if (ret < 0) { 1472 goto fail; 1473 } 1474 1475 if (file && (bs->file != file)) { 1476 bdrv_unref(file); 1477 file = NULL; 1478 } 1479 1480 /* If there is a backing file, use it */ 1481 if ((flags & BDRV_O_NO_BACKING) == 0) { 1482 QDict *backing_options; 1483 1484 qdict_extract_subqdict(options, &backing_options, "backing."); 1485 ret = bdrv_open_backing_file(bs, backing_options, &local_err); 1486 if (ret < 0) { 1487 goto close_and_fail; 1488 } 1489 } 1490 1491 /* For snapshot=on, create a temporary qcow2 overlay. bs points to the 1492 * temporary snapshot afterwards. */ 1493 if (snapshot_flags) { 1494 bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err); 1495 if (local_err) { 1496 error_propagate(errp, local_err); 1497 goto close_and_fail; 1498 } 1499 } 1500 1501 /* Check if any unknown options were used */ 1502 if (options && (qdict_size(options) != 0)) { 1503 const QDictEntry *entry = qdict_first(options); 1504 if (flags & BDRV_O_PROTOCOL) { 1505 error_setg(errp, "Block protocol '%s' doesn't support the option " 1506 "'%s'", drv->format_name, entry->key); 1507 } else { 1508 error_setg(errp, "Block format '%s' used by device '%s' doesn't " 1509 "support the option '%s'", drv->format_name, 1510 bs->device_name, entry->key); 1511 } 1512 1513 ret = -EINVAL; 1514 goto close_and_fail; 1515 } 1516 1517 if (!bdrv_key_required(bs)) { 1518 bdrv_dev_change_media_cb(bs, true); 1519 } else if (!runstate_check(RUN_STATE_PRELAUNCH) 1520 && !runstate_check(RUN_STATE_INMIGRATE) 1521 && !runstate_check(RUN_STATE_PAUSED)) { /* HACK */ 1522 error_setg(errp, 1523 "Guest must be stopped for opening of encrypted image"); 1524 ret = -EBUSY; 1525 goto close_and_fail; 1526 } 1527 1528 QDECREF(options); 1529 *pbs = bs; 1530 return 0; 1531 1532 fail: 1533 if (file != NULL) { 1534 bdrv_unref(file); 1535 } 1536 QDECREF(bs->options); 1537 QDECREF(options); 1538 bs->options = NULL; 1539 if (!*pbs) { 1540 /* If *pbs is NULL, a new BDS has been created in this function and 1541 needs to be freed now. Otherwise, it does not need to be closed, 1542 since it has not really been opened yet. */ 1543 bdrv_unref(bs); 1544 } 1545 if (local_err) { 1546 error_propagate(errp, local_err); 1547 } 1548 return ret; 1549 1550 close_and_fail: 1551 /* See fail path, but now the BDS has to be always closed */ 1552 if (*pbs) { 1553 bdrv_close(bs); 1554 } else { 1555 bdrv_unref(bs); 1556 } 1557 QDECREF(options); 1558 if (local_err) { 1559 error_propagate(errp, local_err); 1560 } 1561 return ret; 1562 } 1563 1564 typedef struct BlockReopenQueueEntry { 1565 bool prepared; 1566 BDRVReopenState state; 1567 QSIMPLEQ_ENTRY(BlockReopenQueueEntry) entry; 1568 } BlockReopenQueueEntry; 1569 1570 /* 1571 * Adds a BlockDriverState to a simple queue for an atomic, transactional 1572 * reopen of multiple devices. 1573 * 1574 * bs_queue can either be an existing BlockReopenQueue that has had QSIMPLE_INIT 1575 * already performed, or alternatively may be NULL a new BlockReopenQueue will 1576 * be created and initialized. This newly created BlockReopenQueue should be 1577 * passed back in for subsequent calls that are intended to be of the same 1578 * atomic 'set'. 1579 * 1580 * bs is the BlockDriverState to add to the reopen queue. 1581 * 1582 * flags contains the open flags for the associated bs 1583 * 1584 * returns a pointer to bs_queue, which is either the newly allocated 1585 * bs_queue, or the existing bs_queue being used. 1586 * 1587 */ 1588 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue, 1589 BlockDriverState *bs, int flags) 1590 { 1591 assert(bs != NULL); 1592 1593 BlockReopenQueueEntry *bs_entry; 1594 if (bs_queue == NULL) { 1595 bs_queue = g_new0(BlockReopenQueue, 1); 1596 QSIMPLEQ_INIT(bs_queue); 1597 } 1598 1599 /* bdrv_open() masks this flag out */ 1600 flags &= ~BDRV_O_PROTOCOL; 1601 1602 if (bs->file) { 1603 bdrv_reopen_queue(bs_queue, bs->file, bdrv_inherited_flags(flags)); 1604 } 1605 1606 bs_entry = g_new0(BlockReopenQueueEntry, 1); 1607 QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry); 1608 1609 bs_entry->state.bs = bs; 1610 bs_entry->state.flags = flags; 1611 1612 return bs_queue; 1613 } 1614 1615 /* 1616 * Reopen multiple BlockDriverStates atomically & transactionally. 1617 * 1618 * The queue passed in (bs_queue) must have been built up previous 1619 * via bdrv_reopen_queue(). 1620 * 1621 * Reopens all BDS specified in the queue, with the appropriate 1622 * flags. All devices are prepared for reopen, and failure of any 1623 * device will cause all device changes to be abandonded, and intermediate 1624 * data cleaned up. 1625 * 1626 * If all devices prepare successfully, then the changes are committed 1627 * to all devices. 1628 * 1629 */ 1630 int bdrv_reopen_multiple(BlockReopenQueue *bs_queue, Error **errp) 1631 { 1632 int ret = -1; 1633 BlockReopenQueueEntry *bs_entry, *next; 1634 Error *local_err = NULL; 1635 1636 assert(bs_queue != NULL); 1637 1638 bdrv_drain_all(); 1639 1640 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) { 1641 if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) { 1642 error_propagate(errp, local_err); 1643 goto cleanup; 1644 } 1645 bs_entry->prepared = true; 1646 } 1647 1648 /* If we reach this point, we have success and just need to apply the 1649 * changes 1650 */ 1651 QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) { 1652 bdrv_reopen_commit(&bs_entry->state); 1653 } 1654 1655 ret = 0; 1656 1657 cleanup: 1658 QSIMPLEQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) { 1659 if (ret && bs_entry->prepared) { 1660 bdrv_reopen_abort(&bs_entry->state); 1661 } 1662 g_free(bs_entry); 1663 } 1664 g_free(bs_queue); 1665 return ret; 1666 } 1667 1668 1669 /* Reopen a single BlockDriverState with the specified flags. */ 1670 int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp) 1671 { 1672 int ret = -1; 1673 Error *local_err = NULL; 1674 BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, bdrv_flags); 1675 1676 ret = bdrv_reopen_multiple(queue, &local_err); 1677 if (local_err != NULL) { 1678 error_propagate(errp, local_err); 1679 } 1680 return ret; 1681 } 1682 1683 1684 /* 1685 * Prepares a BlockDriverState for reopen. All changes are staged in the 1686 * 'opaque' field of the BDRVReopenState, which is used and allocated by 1687 * the block driver layer .bdrv_reopen_prepare() 1688 * 1689 * bs is the BlockDriverState to reopen 1690 * flags are the new open flags 1691 * queue is the reopen queue 1692 * 1693 * Returns 0 on success, non-zero on error. On error errp will be set 1694 * as well. 1695 * 1696 * On failure, bdrv_reopen_abort() will be called to clean up any data. 1697 * It is the responsibility of the caller to then call the abort() or 1698 * commit() for any other BDS that have been left in a prepare() state 1699 * 1700 */ 1701 int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, 1702 Error **errp) 1703 { 1704 int ret = -1; 1705 Error *local_err = NULL; 1706 BlockDriver *drv; 1707 1708 assert(reopen_state != NULL); 1709 assert(reopen_state->bs->drv != NULL); 1710 drv = reopen_state->bs->drv; 1711 1712 /* if we are to stay read-only, do not allow permission change 1713 * to r/w */ 1714 if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) && 1715 reopen_state->flags & BDRV_O_RDWR) { 1716 error_set(errp, QERR_DEVICE_IS_READ_ONLY, 1717 reopen_state->bs->device_name); 1718 goto error; 1719 } 1720 1721 1722 ret = bdrv_flush(reopen_state->bs); 1723 if (ret) { 1724 error_set(errp, ERROR_CLASS_GENERIC_ERROR, "Error (%s) flushing drive", 1725 strerror(-ret)); 1726 goto error; 1727 } 1728 1729 if (drv->bdrv_reopen_prepare) { 1730 ret = drv->bdrv_reopen_prepare(reopen_state, queue, &local_err); 1731 if (ret) { 1732 if (local_err != NULL) { 1733 error_propagate(errp, local_err); 1734 } else { 1735 error_setg(errp, "failed while preparing to reopen image '%s'", 1736 reopen_state->bs->filename); 1737 } 1738 goto error; 1739 } 1740 } else { 1741 /* It is currently mandatory to have a bdrv_reopen_prepare() 1742 * handler for each supported drv. */ 1743 error_set(errp, QERR_BLOCK_FORMAT_FEATURE_NOT_SUPPORTED, 1744 drv->format_name, reopen_state->bs->device_name, 1745 "reopening of file"); 1746 ret = -1; 1747 goto error; 1748 } 1749 1750 ret = 0; 1751 1752 error: 1753 return ret; 1754 } 1755 1756 /* 1757 * Takes the staged changes for the reopen from bdrv_reopen_prepare(), and 1758 * makes them final by swapping the staging BlockDriverState contents into 1759 * the active BlockDriverState contents. 1760 */ 1761 void bdrv_reopen_commit(BDRVReopenState *reopen_state) 1762 { 1763 BlockDriver *drv; 1764 1765 assert(reopen_state != NULL); 1766 drv = reopen_state->bs->drv; 1767 assert(drv != NULL); 1768 1769 /* If there are any driver level actions to take */ 1770 if (drv->bdrv_reopen_commit) { 1771 drv->bdrv_reopen_commit(reopen_state); 1772 } 1773 1774 /* set BDS specific flags now */ 1775 reopen_state->bs->open_flags = reopen_state->flags; 1776 reopen_state->bs->enable_write_cache = !!(reopen_state->flags & 1777 BDRV_O_CACHE_WB); 1778 reopen_state->bs->read_only = !(reopen_state->flags & BDRV_O_RDWR); 1779 1780 bdrv_refresh_limits(reopen_state->bs); 1781 } 1782 1783 /* 1784 * Abort the reopen, and delete and free the staged changes in 1785 * reopen_state 1786 */ 1787 void bdrv_reopen_abort(BDRVReopenState *reopen_state) 1788 { 1789 BlockDriver *drv; 1790 1791 assert(reopen_state != NULL); 1792 drv = reopen_state->bs->drv; 1793 assert(drv != NULL); 1794 1795 if (drv->bdrv_reopen_abort) { 1796 drv->bdrv_reopen_abort(reopen_state); 1797 } 1798 } 1799 1800 1801 void bdrv_close(BlockDriverState *bs) 1802 { 1803 if (bs->job) { 1804 block_job_cancel_sync(bs->job); 1805 } 1806 bdrv_drain_all(); /* complete I/O */ 1807 bdrv_flush(bs); 1808 bdrv_drain_all(); /* in case flush left pending I/O */ 1809 notifier_list_notify(&bs->close_notifiers, bs); 1810 1811 if (bs->drv) { 1812 if (bs->backing_hd) { 1813 BlockDriverState *backing_hd = bs->backing_hd; 1814 bdrv_set_backing_hd(bs, NULL); 1815 bdrv_unref(backing_hd); 1816 } 1817 bs->drv->bdrv_close(bs); 1818 g_free(bs->opaque); 1819 bs->opaque = NULL; 1820 bs->drv = NULL; 1821 bs->copy_on_read = 0; 1822 bs->backing_file[0] = '\0'; 1823 bs->backing_format[0] = '\0'; 1824 bs->total_sectors = 0; 1825 bs->encrypted = 0; 1826 bs->valid_key = 0; 1827 bs->sg = 0; 1828 bs->growable = 0; 1829 bs->zero_beyond_eof = false; 1830 QDECREF(bs->options); 1831 bs->options = NULL; 1832 1833 if (bs->file != NULL) { 1834 bdrv_unref(bs->file); 1835 bs->file = NULL; 1836 } 1837 } 1838 1839 bdrv_dev_change_media_cb(bs, false); 1840 1841 /*throttling disk I/O limits*/ 1842 if (bs->io_limits_enabled) { 1843 bdrv_io_limits_disable(bs); 1844 } 1845 } 1846 1847 void bdrv_close_all(void) 1848 { 1849 BlockDriverState *bs; 1850 1851 QTAILQ_FOREACH(bs, &bdrv_states, device_list) { 1852 AioContext *aio_context = bdrv_get_aio_context(bs); 1853 1854 aio_context_acquire(aio_context); 1855 bdrv_close(bs); 1856 aio_context_release(aio_context); 1857 } 1858 } 1859 1860 /* Check if any requests are in-flight (including throttled requests) */ 1861 static bool bdrv_requests_pending(BlockDriverState *bs) 1862 { 1863 if (!QLIST_EMPTY(&bs->tracked_requests)) { 1864 return true; 1865 } 1866 if (!qemu_co_queue_empty(&bs->throttled_reqs[0])) { 1867 return true; 1868 } 1869 if (!qemu_co_queue_empty(&bs->throttled_reqs[1])) { 1870 return true; 1871 } 1872 if (bs->file && bdrv_requests_pending(bs->file)) { 1873 return true; 1874 } 1875 if (bs->backing_hd && bdrv_requests_pending(bs->backing_hd)) { 1876 return true; 1877 } 1878 return false; 1879 } 1880 1881 /* 1882 * Wait for pending requests to complete across all BlockDriverStates 1883 * 1884 * This function does not flush data to disk, use bdrv_flush_all() for that 1885 * after calling this function. 1886 * 1887 * Note that completion of an asynchronous I/O operation can trigger any 1888 * number of other I/O operations on other devices---for example a coroutine 1889 * can be arbitrarily complex and a constant flow of I/O can come until the 1890 * coroutine is complete. Because of this, it is not possible to have a 1891 * function to drain a single device's I/O queue. 1892 */ 1893 void bdrv_drain_all(void) 1894 { 1895 /* Always run first iteration so any pending completion BHs run */ 1896 bool busy = true; 1897 BlockDriverState *bs; 1898 1899 while (busy) { 1900 busy = false; 1901 1902 QTAILQ_FOREACH(bs, &bdrv_states, device_list) { 1903 AioContext *aio_context = bdrv_get_aio_context(bs); 1904 bool bs_busy; 1905 1906 aio_context_acquire(aio_context); 1907 bdrv_start_throttled_reqs(bs); 1908 bs_busy = bdrv_requests_pending(bs); 1909 bs_busy |= aio_poll(aio_context, bs_busy); 1910 aio_context_release(aio_context); 1911 1912 busy |= bs_busy; 1913 } 1914 } 1915 } 1916 1917 /* make a BlockDriverState anonymous by removing from bdrv_state and 1918 * graph_bdrv_state list. 1919 Also, NULL terminate the device_name to prevent double remove */ 1920 void bdrv_make_anon(BlockDriverState *bs) 1921 { 1922 if (bs->device_name[0] != '\0') { 1923 QTAILQ_REMOVE(&bdrv_states, bs, device_list); 1924 } 1925 bs->device_name[0] = '\0'; 1926 if (bs->node_name[0] != '\0') { 1927 QTAILQ_REMOVE(&graph_bdrv_states, bs, node_list); 1928 } 1929 bs->node_name[0] = '\0'; 1930 } 1931 1932 static void bdrv_rebind(BlockDriverState *bs) 1933 { 1934 if (bs->drv && bs->drv->bdrv_rebind) { 1935 bs->drv->bdrv_rebind(bs); 1936 } 1937 } 1938 1939 static void bdrv_move_feature_fields(BlockDriverState *bs_dest, 1940 BlockDriverState *bs_src) 1941 { 1942 /* move some fields that need to stay attached to the device */ 1943 1944 /* dev info */ 1945 bs_dest->dev_ops = bs_src->dev_ops; 1946 bs_dest->dev_opaque = bs_src->dev_opaque; 1947 bs_dest->dev = bs_src->dev; 1948 bs_dest->guest_block_size = bs_src->guest_block_size; 1949 bs_dest->copy_on_read = bs_src->copy_on_read; 1950 1951 bs_dest->enable_write_cache = bs_src->enable_write_cache; 1952 1953 /* i/o throttled req */ 1954 memcpy(&bs_dest->throttle_state, 1955 &bs_src->throttle_state, 1956 sizeof(ThrottleState)); 1957 bs_dest->throttled_reqs[0] = bs_src->throttled_reqs[0]; 1958 bs_dest->throttled_reqs[1] = bs_src->throttled_reqs[1]; 1959 bs_dest->io_limits_enabled = bs_src->io_limits_enabled; 1960 1961 /* r/w error */ 1962 bs_dest->on_read_error = bs_src->on_read_error; 1963 bs_dest->on_write_error = bs_src->on_write_error; 1964 1965 /* i/o status */ 1966 bs_dest->iostatus_enabled = bs_src->iostatus_enabled; 1967 bs_dest->iostatus = bs_src->iostatus; 1968 1969 /* dirty bitmap */ 1970 bs_dest->dirty_bitmaps = bs_src->dirty_bitmaps; 1971 1972 /* reference count */ 1973 bs_dest->refcnt = bs_src->refcnt; 1974 1975 /* job */ 1976 bs_dest->job = bs_src->job; 1977 1978 /* keep the same entry in bdrv_states */ 1979 pstrcpy(bs_dest->device_name, sizeof(bs_dest->device_name), 1980 bs_src->device_name); 1981 bs_dest->device_list = bs_src->device_list; 1982 memcpy(bs_dest->op_blockers, bs_src->op_blockers, 1983 sizeof(bs_dest->op_blockers)); 1984 } 1985 1986 /* 1987 * Swap bs contents for two image chains while they are live, 1988 * while keeping required fields on the BlockDriverState that is 1989 * actually attached to a device. 1990 * 1991 * This will modify the BlockDriverState fields, and swap contents 1992 * between bs_new and bs_old. Both bs_new and bs_old are modified. 1993 * 1994 * bs_new is required to be anonymous. 1995 * 1996 * This function does not create any image files. 1997 */ 1998 void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) 1999 { 2000 BlockDriverState tmp; 2001 2002 /* The code needs to swap the node_name but simply swapping node_list won't 2003 * work so first remove the nodes from the graph list, do the swap then 2004 * insert them back if needed. 2005 */ 2006 if (bs_new->node_name[0] != '\0') { 2007 QTAILQ_REMOVE(&graph_bdrv_states, bs_new, node_list); 2008 } 2009 if (bs_old->node_name[0] != '\0') { 2010 QTAILQ_REMOVE(&graph_bdrv_states, bs_old, node_list); 2011 } 2012 2013 /* bs_new must be anonymous and shouldn't have anything fancy enabled */ 2014 assert(bs_new->device_name[0] == '\0'); 2015 assert(QLIST_EMPTY(&bs_new->dirty_bitmaps)); 2016 assert(bs_new->job == NULL); 2017 assert(bs_new->dev == NULL); 2018 assert(bs_new->io_limits_enabled == false); 2019 assert(!throttle_have_timer(&bs_new->throttle_state)); 2020 2021 tmp = *bs_new; 2022 *bs_new = *bs_old; 2023 *bs_old = tmp; 2024 2025 /* there are some fields that should not be swapped, move them back */ 2026 bdrv_move_feature_fields(&tmp, bs_old); 2027 bdrv_move_feature_fields(bs_old, bs_new); 2028 bdrv_move_feature_fields(bs_new, &tmp); 2029 2030 /* bs_new shouldn't be in bdrv_states even after the swap! */ 2031 assert(bs_new->device_name[0] == '\0'); 2032 2033 /* Check a few fields that should remain attached to the device */ 2034 assert(bs_new->dev == NULL); 2035 assert(bs_new->job == NULL); 2036 assert(bs_new->io_limits_enabled == false); 2037 assert(!throttle_have_timer(&bs_new->throttle_state)); 2038 2039 /* insert the nodes back into the graph node list if needed */ 2040 if (bs_new->node_name[0] != '\0') { 2041 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_new, node_list); 2042 } 2043 if (bs_old->node_name[0] != '\0') { 2044 QTAILQ_INSERT_TAIL(&graph_bdrv_states, bs_old, node_list); 2045 } 2046 2047 bdrv_rebind(bs_new); 2048 bdrv_rebind(bs_old); 2049 } 2050 2051 /* 2052 * Add new bs contents at the top of an image chain while the chain is 2053 * live, while keeping required fields on the top layer. 2054 * 2055 * This will modify the BlockDriverState fields, and swap contents 2056 * between bs_new and bs_top. Both bs_new and bs_top are modified. 2057 * 2058 * bs_new is required to be anonymous. 2059 * 2060 * This function does not create any image files. 2061 */ 2062 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top) 2063 { 2064 bdrv_swap(bs_new, bs_top); 2065 2066 /* The contents of 'tmp' will become bs_top, as we are 2067 * swapping bs_new and bs_top contents. */ 2068 bdrv_set_backing_hd(bs_top, bs_new); 2069 } 2070 2071 static void bdrv_delete(BlockDriverState *bs) 2072 { 2073 assert(!bs->dev); 2074 assert(!bs->job); 2075 assert(bdrv_op_blocker_is_empty(bs)); 2076 assert(!bs->refcnt); 2077 assert(QLIST_EMPTY(&bs->dirty_bitmaps)); 2078 2079 bdrv_close(bs); 2080 2081 /* remove from list, if necessary */ 2082 bdrv_make_anon(bs); 2083 2084 g_free(bs); 2085 } 2086 2087 int bdrv_attach_dev(BlockDriverState *bs, void *dev) 2088 /* TODO change to DeviceState *dev when all users are qdevified */ 2089 { 2090 if (bs->dev) { 2091 return -EBUSY; 2092 } 2093 bs->dev = dev; 2094 bdrv_iostatus_reset(bs); 2095 return 0; 2096 } 2097 2098 /* TODO qdevified devices don't use this, remove when devices are qdevified */ 2099 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev) 2100 { 2101 if (bdrv_attach_dev(bs, dev) < 0) { 2102 abort(); 2103 } 2104 } 2105 2106 void bdrv_detach_dev(BlockDriverState *bs, void *dev) 2107 /* TODO change to DeviceState *dev when all users are qdevified */ 2108 { 2109 assert(bs->dev == dev); 2110 bs->dev = NULL; 2111 bs->dev_ops = NULL; 2112 bs->dev_opaque = NULL; 2113 bs->guest_block_size = 512; 2114 } 2115 2116 /* TODO change to return DeviceState * when all users are qdevified */ 2117 void *bdrv_get_attached_dev(BlockDriverState *bs) 2118 { 2119 return bs->dev; 2120 } 2121 2122 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops, 2123 void *opaque) 2124 { 2125 bs->dev_ops = ops; 2126 bs->dev_opaque = opaque; 2127 } 2128 2129 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load) 2130 { 2131 if (bs->dev_ops && bs->dev_ops->change_media_cb) { 2132 bool tray_was_closed = !bdrv_dev_is_tray_open(bs); 2133 bs->dev_ops->change_media_cb(bs->dev_opaque, load); 2134 if (tray_was_closed) { 2135 /* tray open */ 2136 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), 2137 true, &error_abort); 2138 } 2139 if (load) { 2140 /* tray close */ 2141 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), 2142 false, &error_abort); 2143 } 2144 } 2145 } 2146 2147 bool bdrv_dev_has_removable_media(BlockDriverState *bs) 2148 { 2149 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb); 2150 } 2151 2152 void bdrv_dev_eject_request(BlockDriverState *bs, bool force) 2153 { 2154 if (bs->dev_ops && bs->dev_ops->eject_request_cb) { 2155 bs->dev_ops->eject_request_cb(bs->dev_opaque, force); 2156 } 2157 } 2158 2159 bool bdrv_dev_is_tray_open(BlockDriverState *bs) 2160 { 2161 if (bs->dev_ops && bs->dev_ops->is_tray_open) { 2162 return bs->dev_ops->is_tray_open(bs->dev_opaque); 2163 } 2164 return false; 2165 } 2166 2167 static void bdrv_dev_resize_cb(BlockDriverState *bs) 2168 { 2169 if (bs->dev_ops && bs->dev_ops->resize_cb) { 2170 bs->dev_ops->resize_cb(bs->dev_opaque); 2171 } 2172 } 2173 2174 bool bdrv_dev_is_medium_locked(BlockDriverState *bs) 2175 { 2176 if (bs->dev_ops && bs->dev_ops->is_medium_locked) { 2177 return bs->dev_ops->is_medium_locked(bs->dev_opaque); 2178 } 2179 return false; 2180 } 2181 2182 /* 2183 * Run consistency checks on an image 2184 * 2185 * Returns 0 if the check could be completed (it doesn't mean that the image is 2186 * free of errors) or -errno when an internal error occurred. The results of the 2187 * check are stored in res. 2188 */ 2189 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix) 2190 { 2191 if (bs->drv->bdrv_check == NULL) { 2192 return -ENOTSUP; 2193 } 2194 2195 memset(res, 0, sizeof(*res)); 2196 return bs->drv->bdrv_check(bs, res, fix); 2197 } 2198 2199 #define COMMIT_BUF_SECTORS 2048 2200 2201 /* commit COW file into the raw image */ 2202 int bdrv_commit(BlockDriverState *bs) 2203 { 2204 BlockDriver *drv = bs->drv; 2205 int64_t sector, total_sectors, length, backing_length; 2206 int n, ro, open_flags; 2207 int ret = 0; 2208 uint8_t *buf = NULL; 2209 char filename[PATH_MAX]; 2210 2211 if (!drv) 2212 return -ENOMEDIUM; 2213 2214 if (!bs->backing_hd) { 2215 return -ENOTSUP; 2216 } 2217 2218 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT, NULL) || 2219 bdrv_op_is_blocked(bs->backing_hd, BLOCK_OP_TYPE_COMMIT, NULL)) { 2220 return -EBUSY; 2221 } 2222 2223 ro = bs->backing_hd->read_only; 2224 /* Use pstrcpy (not strncpy): filename must be NUL-terminated. */ 2225 pstrcpy(filename, sizeof(filename), bs->backing_hd->filename); 2226 open_flags = bs->backing_hd->open_flags; 2227 2228 if (ro) { 2229 if (bdrv_reopen(bs->backing_hd, open_flags | BDRV_O_RDWR, NULL)) { 2230 return -EACCES; 2231 } 2232 } 2233 2234 length = bdrv_getlength(bs); 2235 if (length < 0) { 2236 ret = length; 2237 goto ro_cleanup; 2238 } 2239 2240 backing_length = bdrv_getlength(bs->backing_hd); 2241 if (backing_length < 0) { 2242 ret = backing_length; 2243 goto ro_cleanup; 2244 } 2245 2246 /* If our top snapshot is larger than the backing file image, 2247 * grow the backing file image if possible. If not possible, 2248 * we must return an error */ 2249 if (length > backing_length) { 2250 ret = bdrv_truncate(bs->backing_hd, length); 2251 if (ret < 0) { 2252 goto ro_cleanup; 2253 } 2254 } 2255 2256 total_sectors = length >> BDRV_SECTOR_BITS; 2257 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE); 2258 2259 for (sector = 0; sector < total_sectors; sector += n) { 2260 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n); 2261 if (ret < 0) { 2262 goto ro_cleanup; 2263 } 2264 if (ret) { 2265 ret = bdrv_read(bs, sector, buf, n); 2266 if (ret < 0) { 2267 goto ro_cleanup; 2268 } 2269 2270 ret = bdrv_write(bs->backing_hd, sector, buf, n); 2271 if (ret < 0) { 2272 goto ro_cleanup; 2273 } 2274 } 2275 } 2276 2277 if (drv->bdrv_make_empty) { 2278 ret = drv->bdrv_make_empty(bs); 2279 if (ret < 0) { 2280 goto ro_cleanup; 2281 } 2282 bdrv_flush(bs); 2283 } 2284 2285 /* 2286 * Make sure all data we wrote to the backing device is actually 2287 * stable on disk. 2288 */ 2289 if (bs->backing_hd) { 2290 bdrv_flush(bs->backing_hd); 2291 } 2292 2293 ret = 0; 2294 ro_cleanup: 2295 g_free(buf); 2296 2297 if (ro) { 2298 /* ignoring error return here */ 2299 bdrv_reopen(bs->backing_hd, open_flags & ~BDRV_O_RDWR, NULL); 2300 } 2301 2302 return ret; 2303 } 2304 2305 int bdrv_commit_all(void) 2306 { 2307 BlockDriverState *bs; 2308 2309 QTAILQ_FOREACH(bs, &bdrv_states, device_list) { 2310 AioContext *aio_context = bdrv_get_aio_context(bs); 2311 2312 aio_context_acquire(aio_context); 2313 if (bs->drv && bs->backing_hd) { 2314 int ret = bdrv_commit(bs); 2315 if (ret < 0) { 2316 aio_context_release(aio_context); 2317 return ret; 2318 } 2319 } 2320 aio_context_release(aio_context); 2321 } 2322 return 0; 2323 } 2324 2325 /** 2326 * Remove an active request from the tracked requests list 2327 * 2328 * This function should be called when a tracked request is completing. 2329 */ 2330 static void tracked_request_end(BdrvTrackedRequest *req) 2331 { 2332 if (req->serialising) { 2333 req->bs->serialising_in_flight--; 2334 } 2335 2336 QLIST_REMOVE(req, list); 2337 qemu_co_queue_restart_all(&req->wait_queue); 2338 } 2339 2340 /** 2341 * Add an active request to the tracked requests list 2342 */ 2343 static void tracked_request_begin(BdrvTrackedRequest *req, 2344 BlockDriverState *bs, 2345 int64_t offset, 2346 unsigned int bytes, bool is_write) 2347 { 2348 *req = (BdrvTrackedRequest){ 2349 .bs = bs, 2350 .offset = offset, 2351 .bytes = bytes, 2352 .is_write = is_write, 2353 .co = qemu_coroutine_self(), 2354 .serialising = false, 2355 .overlap_offset = offset, 2356 .overlap_bytes = bytes, 2357 }; 2358 2359 qemu_co_queue_init(&req->wait_queue); 2360 2361 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list); 2362 } 2363 2364 static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align) 2365 { 2366 int64_t overlap_offset = req->offset & ~(align - 1); 2367 unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align) 2368 - overlap_offset; 2369 2370 if (!req->serialising) { 2371 req->bs->serialising_in_flight++; 2372 req->serialising = true; 2373 } 2374 2375 req->overlap_offset = MIN(req->overlap_offset, overlap_offset); 2376 req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes); 2377 } 2378 2379 /** 2380 * Round a region to cluster boundaries 2381 */ 2382 void bdrv_round_to_clusters(BlockDriverState *bs, 2383 int64_t sector_num, int nb_sectors, 2384 int64_t *cluster_sector_num, 2385 int *cluster_nb_sectors) 2386 { 2387 BlockDriverInfo bdi; 2388 2389 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) { 2390 *cluster_sector_num = sector_num; 2391 *cluster_nb_sectors = nb_sectors; 2392 } else { 2393 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE; 2394 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c); 2395 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num + 2396 nb_sectors, c); 2397 } 2398 } 2399 2400 static int bdrv_get_cluster_size(BlockDriverState *bs) 2401 { 2402 BlockDriverInfo bdi; 2403 int ret; 2404 2405 ret = bdrv_get_info(bs, &bdi); 2406 if (ret < 0 || bdi.cluster_size == 0) { 2407 return bs->request_alignment; 2408 } else { 2409 return bdi.cluster_size; 2410 } 2411 } 2412 2413 static bool tracked_request_overlaps(BdrvTrackedRequest *req, 2414 int64_t offset, unsigned int bytes) 2415 { 2416 /* aaaa bbbb */ 2417 if (offset >= req->overlap_offset + req->overlap_bytes) { 2418 return false; 2419 } 2420 /* bbbb aaaa */ 2421 if (req->overlap_offset >= offset + bytes) { 2422 return false; 2423 } 2424 return true; 2425 } 2426 2427 static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self) 2428 { 2429 BlockDriverState *bs = self->bs; 2430 BdrvTrackedRequest *req; 2431 bool retry; 2432 bool waited = false; 2433 2434 if (!bs->serialising_in_flight) { 2435 return false; 2436 } 2437 2438 do { 2439 retry = false; 2440 QLIST_FOREACH(req, &bs->tracked_requests, list) { 2441 if (req == self || (!req->serialising && !self->serialising)) { 2442 continue; 2443 } 2444 if (tracked_request_overlaps(req, self->overlap_offset, 2445 self->overlap_bytes)) 2446 { 2447 /* Hitting this means there was a reentrant request, for 2448 * example, a block driver issuing nested requests. This must 2449 * never happen since it means deadlock. 2450 */ 2451 assert(qemu_coroutine_self() != req->co); 2452 2453 /* If the request is already (indirectly) waiting for us, or 2454 * will wait for us as soon as it wakes up, then just go on 2455 * (instead of producing a deadlock in the former case). */ 2456 if (!req->waiting_for) { 2457 self->waiting_for = req; 2458 qemu_co_queue_wait(&req->wait_queue); 2459 self->waiting_for = NULL; 2460 retry = true; 2461 waited = true; 2462 break; 2463 } 2464 } 2465 } 2466 } while (retry); 2467 2468 return waited; 2469 } 2470 2471 /* 2472 * Return values: 2473 * 0 - success 2474 * -EINVAL - backing format specified, but no file 2475 * -ENOSPC - can't update the backing file because no space is left in the 2476 * image file header 2477 * -ENOTSUP - format driver doesn't support changing the backing file 2478 */ 2479 int bdrv_change_backing_file(BlockDriverState *bs, 2480 const char *backing_file, const char *backing_fmt) 2481 { 2482 BlockDriver *drv = bs->drv; 2483 int ret; 2484 2485 /* Backing file format doesn't make sense without a backing file */ 2486 if (backing_fmt && !backing_file) { 2487 return -EINVAL; 2488 } 2489 2490 if (drv->bdrv_change_backing_file != NULL) { 2491 ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt); 2492 } else { 2493 ret = -ENOTSUP; 2494 } 2495 2496 if (ret == 0) { 2497 pstrcpy(bs->backing_file, sizeof(bs->backing_file), backing_file ?: ""); 2498 pstrcpy(bs->backing_format, sizeof(bs->backing_format), backing_fmt ?: ""); 2499 } 2500 return ret; 2501 } 2502 2503 /* 2504 * Finds the image layer in the chain that has 'bs' as its backing file. 2505 * 2506 * active is the current topmost image. 2507 * 2508 * Returns NULL if bs is not found in active's image chain, 2509 * or if active == bs. 2510 */ 2511 BlockDriverState *bdrv_find_overlay(BlockDriverState *active, 2512 BlockDriverState *bs) 2513 { 2514 BlockDriverState *overlay = NULL; 2515 BlockDriverState *intermediate; 2516 2517 assert(active != NULL); 2518 assert(bs != NULL); 2519 2520 /* if bs is the same as active, then by definition it has no overlay 2521 */ 2522 if (active == bs) { 2523 return NULL; 2524 } 2525 2526 intermediate = active; 2527 while (intermediate->backing_hd) { 2528 if (intermediate->backing_hd == bs) { 2529 overlay = intermediate; 2530 break; 2531 } 2532 intermediate = intermediate->backing_hd; 2533 } 2534 2535 return overlay; 2536 } 2537 2538 typedef struct BlkIntermediateStates { 2539 BlockDriverState *bs; 2540 QSIMPLEQ_ENTRY(BlkIntermediateStates) entry; 2541 } BlkIntermediateStates; 2542 2543 2544 /* 2545 * Drops images above 'base' up to and including 'top', and sets the image 2546 * above 'top' to have base as its backing file. 2547 * 2548 * Requires that the overlay to 'top' is opened r/w, so that the backing file 2549 * information in 'bs' can be properly updated. 2550 * 2551 * E.g., this will convert the following chain: 2552 * bottom <- base <- intermediate <- top <- active 2553 * 2554 * to 2555 * 2556 * bottom <- base <- active 2557 * 2558 * It is allowed for bottom==base, in which case it converts: 2559 * 2560 * base <- intermediate <- top <- active 2561 * 2562 * to 2563 * 2564 * base <- active 2565 * 2566 * Error conditions: 2567 * if active == top, that is considered an error 2568 * 2569 */ 2570 int bdrv_drop_intermediate(BlockDriverState *active, BlockDriverState *top, 2571 BlockDriverState *base) 2572 { 2573 BlockDriverState *intermediate; 2574 BlockDriverState *base_bs = NULL; 2575 BlockDriverState *new_top_bs = NULL; 2576 BlkIntermediateStates *intermediate_state, *next; 2577 int ret = -EIO; 2578 2579 QSIMPLEQ_HEAD(states_to_delete, BlkIntermediateStates) states_to_delete; 2580 QSIMPLEQ_INIT(&states_to_delete); 2581 2582 if (!top->drv || !base->drv) { 2583 goto exit; 2584 } 2585 2586 new_top_bs = bdrv_find_overlay(active, top); 2587 2588 if (new_top_bs == NULL) { 2589 /* we could not find the image above 'top', this is an error */ 2590 goto exit; 2591 } 2592 2593 /* special case of new_top_bs->backing_hd already pointing to base - nothing 2594 * to do, no intermediate images */ 2595 if (new_top_bs->backing_hd == base) { 2596 ret = 0; 2597 goto exit; 2598 } 2599 2600 intermediate = top; 2601 2602 /* now we will go down through the list, and add each BDS we find 2603 * into our deletion queue, until we hit the 'base' 2604 */ 2605 while (intermediate) { 2606 intermediate_state = g_malloc0(sizeof(BlkIntermediateStates)); 2607 intermediate_state->bs = intermediate; 2608 QSIMPLEQ_INSERT_TAIL(&states_to_delete, intermediate_state, entry); 2609 2610 if (intermediate->backing_hd == base) { 2611 base_bs = intermediate->backing_hd; 2612 break; 2613 } 2614 intermediate = intermediate->backing_hd; 2615 } 2616 if (base_bs == NULL) { 2617 /* something went wrong, we did not end at the base. safely 2618 * unravel everything, and exit with error */ 2619 goto exit; 2620 } 2621 2622 /* success - we can delete the intermediate states, and link top->base */ 2623 ret = bdrv_change_backing_file(new_top_bs, base_bs->filename, 2624 base_bs->drv ? base_bs->drv->format_name : ""); 2625 if (ret) { 2626 goto exit; 2627 } 2628 bdrv_set_backing_hd(new_top_bs, base_bs); 2629 2630 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) { 2631 /* so that bdrv_close() does not recursively close the chain */ 2632 bdrv_set_backing_hd(intermediate_state->bs, NULL); 2633 bdrv_unref(intermediate_state->bs); 2634 } 2635 ret = 0; 2636 2637 exit: 2638 QSIMPLEQ_FOREACH_SAFE(intermediate_state, &states_to_delete, entry, next) { 2639 g_free(intermediate_state); 2640 } 2641 return ret; 2642 } 2643 2644 2645 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, 2646 size_t size) 2647 { 2648 int64_t len; 2649 2650 if (size > INT_MAX) { 2651 return -EIO; 2652 } 2653 2654 if (!bdrv_is_inserted(bs)) 2655 return -ENOMEDIUM; 2656 2657 if (bs->growable) 2658 return 0; 2659 2660 len = bdrv_getlength(bs); 2661 2662 if (offset < 0) 2663 return -EIO; 2664 2665 if ((offset > len) || (len - offset < size)) 2666 return -EIO; 2667 2668 return 0; 2669 } 2670 2671 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num, 2672 int nb_sectors) 2673 { 2674 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) { 2675 return -EIO; 2676 } 2677 2678 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE, 2679 nb_sectors * BDRV_SECTOR_SIZE); 2680 } 2681 2682 typedef struct RwCo { 2683 BlockDriverState *bs; 2684 int64_t offset; 2685 QEMUIOVector *qiov; 2686 bool is_write; 2687 int ret; 2688 BdrvRequestFlags flags; 2689 } RwCo; 2690 2691 static void coroutine_fn bdrv_rw_co_entry(void *opaque) 2692 { 2693 RwCo *rwco = opaque; 2694 2695 if (!rwco->is_write) { 2696 rwco->ret = bdrv_co_do_preadv(rwco->bs, rwco->offset, 2697 rwco->qiov->size, rwco->qiov, 2698 rwco->flags); 2699 } else { 2700 rwco->ret = bdrv_co_do_pwritev(rwco->bs, rwco->offset, 2701 rwco->qiov->size, rwco->qiov, 2702 rwco->flags); 2703 } 2704 } 2705 2706 /* 2707 * Process a vectored synchronous request using coroutines 2708 */ 2709 static int bdrv_prwv_co(BlockDriverState *bs, int64_t offset, 2710 QEMUIOVector *qiov, bool is_write, 2711 BdrvRequestFlags flags) 2712 { 2713 Coroutine *co; 2714 RwCo rwco = { 2715 .bs = bs, 2716 .offset = offset, 2717 .qiov = qiov, 2718 .is_write = is_write, 2719 .ret = NOT_DONE, 2720 .flags = flags, 2721 }; 2722 2723 /** 2724 * In sync call context, when the vcpu is blocked, this throttling timer 2725 * will not fire; so the I/O throttling function has to be disabled here 2726 * if it has been enabled. 2727 */ 2728 if (bs->io_limits_enabled) { 2729 fprintf(stderr, "Disabling I/O throttling on '%s' due " 2730 "to synchronous I/O.\n", bdrv_get_device_name(bs)); 2731 bdrv_io_limits_disable(bs); 2732 } 2733 2734 if (qemu_in_coroutine()) { 2735 /* Fast-path if already in coroutine context */ 2736 bdrv_rw_co_entry(&rwco); 2737 } else { 2738 AioContext *aio_context = bdrv_get_aio_context(bs); 2739 2740 co = qemu_coroutine_create(bdrv_rw_co_entry); 2741 qemu_coroutine_enter(co, &rwco); 2742 while (rwco.ret == NOT_DONE) { 2743 aio_poll(aio_context, true); 2744 } 2745 } 2746 return rwco.ret; 2747 } 2748 2749 /* 2750 * Process a synchronous request using coroutines 2751 */ 2752 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, 2753 int nb_sectors, bool is_write, BdrvRequestFlags flags) 2754 { 2755 QEMUIOVector qiov; 2756 struct iovec iov = { 2757 .iov_base = (void *)buf, 2758 .iov_len = nb_sectors * BDRV_SECTOR_SIZE, 2759 }; 2760 2761 if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) { 2762 return -EINVAL; 2763 } 2764 2765 qemu_iovec_init_external(&qiov, &iov, 1); 2766 return bdrv_prwv_co(bs, sector_num << BDRV_SECTOR_BITS, 2767 &qiov, is_write, flags); 2768 } 2769 2770 /* return < 0 if error. See bdrv_write() for the return codes */ 2771 int bdrv_read(BlockDriverState *bs, int64_t sector_num, 2772 uint8_t *buf, int nb_sectors) 2773 { 2774 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false, 0); 2775 } 2776 2777 /* Just like bdrv_read(), but with I/O throttling temporarily disabled */ 2778 int bdrv_read_unthrottled(BlockDriverState *bs, int64_t sector_num, 2779 uint8_t *buf, int nb_sectors) 2780 { 2781 bool enabled; 2782 int ret; 2783 2784 enabled = bs->io_limits_enabled; 2785 bs->io_limits_enabled = false; 2786 ret = bdrv_read(bs, sector_num, buf, nb_sectors); 2787 bs->io_limits_enabled = enabled; 2788 return ret; 2789 } 2790 2791 /* Return < 0 if error. Important errors are: 2792 -EIO generic I/O error (may happen for all errors) 2793 -ENOMEDIUM No media inserted. 2794 -EINVAL Invalid sector number or nb_sectors 2795 -EACCES Trying to write a read-only device 2796 */ 2797 int bdrv_write(BlockDriverState *bs, int64_t sector_num, 2798 const uint8_t *buf, int nb_sectors) 2799 { 2800 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true, 0); 2801 } 2802 2803 int bdrv_write_zeroes(BlockDriverState *bs, int64_t sector_num, 2804 int nb_sectors, BdrvRequestFlags flags) 2805 { 2806 return bdrv_rw_co(bs, sector_num, NULL, nb_sectors, true, 2807 BDRV_REQ_ZERO_WRITE | flags); 2808 } 2809 2810 /* 2811 * Completely zero out a block device with the help of bdrv_write_zeroes. 2812 * The operation is sped up by checking the block status and only writing 2813 * zeroes to the device if they currently do not return zeroes. Optional 2814 * flags are passed through to bdrv_write_zeroes (e.g. BDRV_REQ_MAY_UNMAP). 2815 * 2816 * Returns < 0 on error, 0 on success. For error codes see bdrv_write(). 2817 */ 2818 int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags) 2819 { 2820 int64_t target_size; 2821 int64_t ret, nb_sectors, sector_num = 0; 2822 int n; 2823 2824 target_size = bdrv_getlength(bs); 2825 if (target_size < 0) { 2826 return target_size; 2827 } 2828 target_size /= BDRV_SECTOR_SIZE; 2829 2830 for (;;) { 2831 nb_sectors = target_size - sector_num; 2832 if (nb_sectors <= 0) { 2833 return 0; 2834 } 2835 if (nb_sectors > INT_MAX) { 2836 nb_sectors = INT_MAX; 2837 } 2838 ret = bdrv_get_block_status(bs, sector_num, nb_sectors, &n); 2839 if (ret < 0) { 2840 error_report("error getting block status at sector %" PRId64 ": %s", 2841 sector_num, strerror(-ret)); 2842 return ret; 2843 } 2844 if (ret & BDRV_BLOCK_ZERO) { 2845 sector_num += n; 2846 continue; 2847 } 2848 ret = bdrv_write_zeroes(bs, sector_num, n, flags); 2849 if (ret < 0) { 2850 error_report("error writing zeroes at sector %" PRId64 ": %s", 2851 sector_num, strerror(-ret)); 2852 return ret; 2853 } 2854 sector_num += n; 2855 } 2856 } 2857 2858 int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes) 2859 { 2860 QEMUIOVector qiov; 2861 struct iovec iov = { 2862 .iov_base = (void *)buf, 2863 .iov_len = bytes, 2864 }; 2865 int ret; 2866 2867 if (bytes < 0) { 2868 return -EINVAL; 2869 } 2870 2871 qemu_iovec_init_external(&qiov, &iov, 1); 2872 ret = bdrv_prwv_co(bs, offset, &qiov, false, 0); 2873 if (ret < 0) { 2874 return ret; 2875 } 2876 2877 return bytes; 2878 } 2879 2880 int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov) 2881 { 2882 int ret; 2883 2884 ret = bdrv_prwv_co(bs, offset, qiov, true, 0); 2885 if (ret < 0) { 2886 return ret; 2887 } 2888 2889 return qiov->size; 2890 } 2891 2892 int bdrv_pwrite(BlockDriverState *bs, int64_t offset, 2893 const void *buf, int bytes) 2894 { 2895 QEMUIOVector qiov; 2896 struct iovec iov = { 2897 .iov_base = (void *) buf, 2898 .iov_len = bytes, 2899 }; 2900 2901 if (bytes < 0) { 2902 return -EINVAL; 2903 } 2904 2905 qemu_iovec_init_external(&qiov, &iov, 1); 2906 return bdrv_pwritev(bs, offset, &qiov); 2907 } 2908 2909 /* 2910 * Writes to the file and ensures that no writes are reordered across this 2911 * request (acts as a barrier) 2912 * 2913 * Returns 0 on success, -errno in error cases. 2914 */ 2915 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset, 2916 const void *buf, int count) 2917 { 2918 int ret; 2919 2920 ret = bdrv_pwrite(bs, offset, buf, count); 2921 if (ret < 0) { 2922 return ret; 2923 } 2924 2925 /* No flush needed for cache modes that already do it */ 2926 if (bs->enable_write_cache) { 2927 bdrv_flush(bs); 2928 } 2929 2930 return 0; 2931 } 2932 2933 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs, 2934 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov) 2935 { 2936 /* Perform I/O through a temporary buffer so that users who scribble over 2937 * their read buffer while the operation is in progress do not end up 2938 * modifying the image file. This is critical for zero-copy guest I/O 2939 * where anything might happen inside guest memory. 2940 */ 2941 void *bounce_buffer; 2942 2943 BlockDriver *drv = bs->drv; 2944 struct iovec iov; 2945 QEMUIOVector bounce_qiov; 2946 int64_t cluster_sector_num; 2947 int cluster_nb_sectors; 2948 size_t skip_bytes; 2949 int ret; 2950 2951 /* Cover entire cluster so no additional backing file I/O is required when 2952 * allocating cluster in the image file. 2953 */ 2954 bdrv_round_to_clusters(bs, sector_num, nb_sectors, 2955 &cluster_sector_num, &cluster_nb_sectors); 2956 2957 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, 2958 cluster_sector_num, cluster_nb_sectors); 2959 2960 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE; 2961 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len); 2962 qemu_iovec_init_external(&bounce_qiov, &iov, 1); 2963 2964 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors, 2965 &bounce_qiov); 2966 if (ret < 0) { 2967 goto err; 2968 } 2969 2970 if (drv->bdrv_co_write_zeroes && 2971 buffer_is_zero(bounce_buffer, iov.iov_len)) { 2972 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num, 2973 cluster_nb_sectors, 0); 2974 } else { 2975 /* This does not change the data on the disk, it is not necessary 2976 * to flush even in cache=writethrough mode. 2977 */ 2978 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors, 2979 &bounce_qiov); 2980 } 2981 2982 if (ret < 0) { 2983 /* It might be okay to ignore write errors for guest requests. If this 2984 * is a deliberate copy-on-read then we don't want to ignore the error. 2985 * Simply report it in all cases. 2986 */ 2987 goto err; 2988 } 2989 2990 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE; 2991 qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes, 2992 nb_sectors * BDRV_SECTOR_SIZE); 2993 2994 err: 2995 qemu_vfree(bounce_buffer); 2996 return ret; 2997 } 2998 2999 /* 3000 * Forwards an already correctly aligned request to the BlockDriver. This 3001 * handles copy on read and zeroing after EOF; any other features must be 3002 * implemented by the caller. 3003 */ 3004 static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, 3005 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes, 3006 int64_t align, QEMUIOVector *qiov, int flags) 3007 { 3008 BlockDriver *drv = bs->drv; 3009 int ret; 3010 3011 int64_t sector_num = offset >> BDRV_SECTOR_BITS; 3012 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS; 3013 3014 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); 3015 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0); 3016 3017 /* Handle Copy on Read and associated serialisation */ 3018 if (flags & BDRV_REQ_COPY_ON_READ) { 3019 /* If we touch the same cluster it counts as an overlap. This 3020 * guarantees that allocating writes will be serialized and not race 3021 * with each other for the same cluster. For example, in copy-on-read 3022 * it ensures that the CoR read and write operations are atomic and 3023 * guest writes cannot interleave between them. */ 3024 mark_request_serialising(req, bdrv_get_cluster_size(bs)); 3025 } 3026 3027 wait_serialising_requests(req); 3028 3029 if (flags & BDRV_REQ_COPY_ON_READ) { 3030 int pnum; 3031 3032 ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum); 3033 if (ret < 0) { 3034 goto out; 3035 } 3036 3037 if (!ret || pnum != nb_sectors) { 3038 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov); 3039 goto out; 3040 } 3041 } 3042 3043 /* Forward the request to the BlockDriver */ 3044 if (!(bs->zero_beyond_eof && bs->growable)) { 3045 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov); 3046 } else { 3047 /* Read zeros after EOF of growable BDSes */ 3048 int64_t len, total_sectors, max_nb_sectors; 3049 3050 len = bdrv_getlength(bs); 3051 if (len < 0) { 3052 ret = len; 3053 goto out; 3054 } 3055 3056 total_sectors = DIV_ROUND_UP(len, BDRV_SECTOR_SIZE); 3057 max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num), 3058 align >> BDRV_SECTOR_BITS); 3059 if (max_nb_sectors > 0) { 3060 ret = drv->bdrv_co_readv(bs, sector_num, 3061 MIN(nb_sectors, max_nb_sectors), qiov); 3062 } else { 3063 ret = 0; 3064 } 3065 3066 /* Reading beyond end of file is supposed to produce zeroes */ 3067 if (ret == 0 && total_sectors < sector_num + nb_sectors) { 3068 uint64_t offset = MAX(0, total_sectors - sector_num); 3069 uint64_t bytes = (sector_num + nb_sectors - offset) * 3070 BDRV_SECTOR_SIZE; 3071 qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes); 3072 } 3073 } 3074 3075 out: 3076 return ret; 3077 } 3078 3079 /* 3080 * Handle a read request in coroutine context 3081 */ 3082 static int coroutine_fn bdrv_co_do_preadv(BlockDriverState *bs, 3083 int64_t offset, unsigned int bytes, QEMUIOVector *qiov, 3084 BdrvRequestFlags flags) 3085 { 3086 BlockDriver *drv = bs->drv; 3087 BdrvTrackedRequest req; 3088 3089 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */ 3090 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment); 3091 uint8_t *head_buf = NULL; 3092 uint8_t *tail_buf = NULL; 3093 QEMUIOVector local_qiov; 3094 bool use_local_qiov = false; 3095 int ret; 3096 3097 if (!drv) { 3098 return -ENOMEDIUM; 3099 } 3100 if (bdrv_check_byte_request(bs, offset, bytes)) { 3101 return -EIO; 3102 } 3103 3104 if (bs->copy_on_read) { 3105 flags |= BDRV_REQ_COPY_ON_READ; 3106 } 3107 3108 /* throttling disk I/O */ 3109 if (bs->io_limits_enabled) { 3110 bdrv_io_limits_intercept(bs, bytes, false); 3111 } 3112 3113 /* Align read if necessary by padding qiov */ 3114 if (offset & (align - 1)) { 3115 head_buf = qemu_blockalign(bs, align); 3116 qemu_iovec_init(&local_qiov, qiov->niov + 2); 3117 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1)); 3118 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size); 3119 use_local_qiov = true; 3120 3121 bytes += offset & (align - 1); 3122 offset = offset & ~(align - 1); 3123 } 3124 3125 if ((offset + bytes) & (align - 1)) { 3126 if (!use_local_qiov) { 3127 qemu_iovec_init(&local_qiov, qiov->niov + 1); 3128 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size); 3129 use_local_qiov = true; 3130 } 3131 tail_buf = qemu_blockalign(bs, align); 3132 qemu_iovec_add(&local_qiov, tail_buf, 3133 align - ((offset + bytes) & (align - 1))); 3134 3135 bytes = ROUND_UP(bytes, align); 3136 } 3137 3138 tracked_request_begin(&req, bs, offset, bytes, false); 3139 ret = bdrv_aligned_preadv(bs, &req, offset, bytes, align, 3140 use_local_qiov ? &local_qiov : qiov, 3141 flags); 3142 tracked_request_end(&req); 3143 3144 if (use_local_qiov) { 3145 qemu_iovec_destroy(&local_qiov); 3146 qemu_vfree(head_buf); 3147 qemu_vfree(tail_buf); 3148 } 3149 3150 return ret; 3151 } 3152 3153 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, 3154 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, 3155 BdrvRequestFlags flags) 3156 { 3157 if (nb_sectors < 0 || nb_sectors > (UINT_MAX >> BDRV_SECTOR_BITS)) { 3158 return -EINVAL; 3159 } 3160 3161 return bdrv_co_do_preadv(bs, sector_num << BDRV_SECTOR_BITS, 3162 nb_sectors << BDRV_SECTOR_BITS, qiov, flags); 3163 } 3164 3165 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num, 3166 int nb_sectors, QEMUIOVector *qiov) 3167 { 3168 trace_bdrv_co_readv(bs, sector_num, nb_sectors); 3169 3170 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0); 3171 } 3172 3173 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs, 3174 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov) 3175 { 3176 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors); 3177 3178 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 3179 BDRV_REQ_COPY_ON_READ); 3180 } 3181 3182 /* if no limit is specified in the BlockLimits use a default 3183 * of 32768 512-byte sectors (16 MiB) per request. 3184 */ 3185 #define MAX_WRITE_ZEROES_DEFAULT 32768 3186 3187 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, 3188 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags) 3189 { 3190 BlockDriver *drv = bs->drv; 3191 QEMUIOVector qiov; 3192 struct iovec iov = {0}; 3193 int ret = 0; 3194 3195 int max_write_zeroes = bs->bl.max_write_zeroes ? 3196 bs->bl.max_write_zeroes : MAX_WRITE_ZEROES_DEFAULT; 3197 3198 while (nb_sectors > 0 && !ret) { 3199 int num = nb_sectors; 3200 3201 /* Align request. Block drivers can expect the "bulk" of the request 3202 * to be aligned. 3203 */ 3204 if (bs->bl.write_zeroes_alignment 3205 && num > bs->bl.write_zeroes_alignment) { 3206 if (sector_num % bs->bl.write_zeroes_alignment != 0) { 3207 /* Make a small request up to the first aligned sector. */ 3208 num = bs->bl.write_zeroes_alignment; 3209 num -= sector_num % bs->bl.write_zeroes_alignment; 3210 } else if ((sector_num + num) % bs->bl.write_zeroes_alignment != 0) { 3211 /* Shorten the request to the last aligned sector. num cannot 3212 * underflow because num > bs->bl.write_zeroes_alignment. 3213 */ 3214 num -= (sector_num + num) % bs->bl.write_zeroes_alignment; 3215 } 3216 } 3217 3218 /* limit request size */ 3219 if (num > max_write_zeroes) { 3220 num = max_write_zeroes; 3221 } 3222 3223 ret = -ENOTSUP; 3224 /* First try the efficient write zeroes operation */ 3225 if (drv->bdrv_co_write_zeroes) { 3226 ret = drv->bdrv_co_write_zeroes(bs, sector_num, num, flags); 3227 } 3228 3229 if (ret == -ENOTSUP) { 3230 /* Fall back to bounce buffer if write zeroes is unsupported */ 3231 iov.iov_len = num * BDRV_SECTOR_SIZE; 3232 if (iov.iov_base == NULL) { 3233 iov.iov_base = qemu_blockalign(bs, num * BDRV_SECTOR_SIZE); 3234 memset(iov.iov_base, 0, num * BDRV_SECTOR_SIZE); 3235 } 3236 qemu_iovec_init_external(&qiov, &iov, 1); 3237 3238 ret = drv->bdrv_co_writev(bs, sector_num, num, &qiov); 3239 3240 /* Keep bounce buffer around if it is big enough for all 3241 * all future requests. 3242 */ 3243 if (num < max_write_zeroes) { 3244 qemu_vfree(iov.iov_base); 3245 iov.iov_base = NULL; 3246 } 3247 } 3248 3249 sector_num += num; 3250 nb_sectors -= num; 3251 } 3252 3253 qemu_vfree(iov.iov_base); 3254 return ret; 3255 } 3256 3257 /* 3258 * Forwards an already correctly aligned write request to the BlockDriver. 3259 */ 3260 static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, 3261 BdrvTrackedRequest *req, int64_t offset, unsigned int bytes, 3262 QEMUIOVector *qiov, int flags) 3263 { 3264 BlockDriver *drv = bs->drv; 3265 bool waited; 3266 int ret; 3267 3268 int64_t sector_num = offset >> BDRV_SECTOR_BITS; 3269 unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS; 3270 3271 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0); 3272 assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0); 3273 3274 waited = wait_serialising_requests(req); 3275 assert(!waited || !req->serialising); 3276 assert(req->overlap_offset <= offset); 3277 assert(offset + bytes <= req->overlap_offset + req->overlap_bytes); 3278 3279 ret = notifier_with_return_list_notify(&bs->before_write_notifiers, req); 3280 3281 if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF && 3282 !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_write_zeroes && 3283 qemu_iovec_is_zero(qiov)) { 3284 flags |= BDRV_REQ_ZERO_WRITE; 3285 if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) { 3286 flags |= BDRV_REQ_MAY_UNMAP; 3287 } 3288 } 3289 3290 if (ret < 0) { 3291 /* Do nothing, write notifier decided to fail this request */ 3292 } else if (flags & BDRV_REQ_ZERO_WRITE) { 3293 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_ZERO); 3294 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors, flags); 3295 } else { 3296 BLKDBG_EVENT(bs, BLKDBG_PWRITEV); 3297 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov); 3298 } 3299 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_DONE); 3300 3301 if (ret == 0 && !bs->enable_write_cache) { 3302 ret = bdrv_co_flush(bs); 3303 } 3304 3305 bdrv_set_dirty(bs, sector_num, nb_sectors); 3306 3307 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) { 3308 bs->wr_highest_sector = sector_num + nb_sectors - 1; 3309 } 3310 if (bs->growable && ret >= 0) { 3311 bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors); 3312 } 3313 3314 return ret; 3315 } 3316 3317 /* 3318 * Handle a write request in coroutine context 3319 */ 3320 static int coroutine_fn bdrv_co_do_pwritev(BlockDriverState *bs, 3321 int64_t offset, unsigned int bytes, QEMUIOVector *qiov, 3322 BdrvRequestFlags flags) 3323 { 3324 BdrvTrackedRequest req; 3325 /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */ 3326 uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment); 3327 uint8_t *head_buf = NULL; 3328 uint8_t *tail_buf = NULL; 3329 QEMUIOVector local_qiov; 3330 bool use_local_qiov = false; 3331 int ret; 3332 3333 if (!bs->drv) { 3334 return -ENOMEDIUM; 3335 } 3336 if (bs->read_only) { 3337 return -EACCES; 3338 } 3339 if (bdrv_check_byte_request(bs, offset, bytes)) { 3340 return -EIO; 3341 } 3342 3343 /* throttling disk I/O */ 3344 if (bs->io_limits_enabled) { 3345 bdrv_io_limits_intercept(bs, bytes, true); 3346 } 3347 3348 /* 3349 * Align write if necessary by performing a read-modify-write cycle. 3350 * Pad qiov with the read parts and be sure to have a tracked request not 3351 * only for bdrv_aligned_pwritev, but also for the reads of the RMW cycle. 3352 */ 3353 tracked_request_begin(&req, bs, offset, bytes, true); 3354 3355 if (offset & (align - 1)) { 3356 QEMUIOVector head_qiov; 3357 struct iovec head_iov; 3358 3359 mark_request_serialising(&req, align); 3360 wait_serialising_requests(&req); 3361 3362 head_buf = qemu_blockalign(bs, align); 3363 head_iov = (struct iovec) { 3364 .iov_base = head_buf, 3365 .iov_len = align, 3366 }; 3367 qemu_iovec_init_external(&head_qiov, &head_iov, 1); 3368 3369 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_HEAD); 3370 ret = bdrv_aligned_preadv(bs, &req, offset & ~(align - 1), align, 3371 align, &head_qiov, 0); 3372 if (ret < 0) { 3373 goto fail; 3374 } 3375 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD); 3376 3377 qemu_iovec_init(&local_qiov, qiov->niov + 2); 3378 qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1)); 3379 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size); 3380 use_local_qiov = true; 3381 3382 bytes += offset & (align - 1); 3383 offset = offset & ~(align - 1); 3384 } 3385 3386 if ((offset + bytes) & (align - 1)) { 3387 QEMUIOVector tail_qiov; 3388 struct iovec tail_iov; 3389 size_t tail_bytes; 3390 bool waited; 3391 3392 mark_request_serialising(&req, align); 3393 waited = wait_serialising_requests(&req); 3394 assert(!waited || !use_local_qiov); 3395 3396 tail_buf = qemu_blockalign(bs, align); 3397 tail_iov = (struct iovec) { 3398 .iov_base = tail_buf, 3399 .iov_len = align, 3400 }; 3401 qemu_iovec_init_external(&tail_qiov, &tail_iov, 1); 3402 3403 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_TAIL); 3404 ret = bdrv_aligned_preadv(bs, &req, (offset + bytes) & ~(align - 1), align, 3405 align, &tail_qiov, 0); 3406 if (ret < 0) { 3407 goto fail; 3408 } 3409 BLKDBG_EVENT(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL); 3410 3411 if (!use_local_qiov) { 3412 qemu_iovec_init(&local_qiov, qiov->niov + 1); 3413 qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size); 3414 use_local_qiov = true; 3415 } 3416 3417 tail_bytes = (offset + bytes) & (align - 1); 3418 qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes); 3419 3420 bytes = ROUND_UP(bytes, align); 3421 } 3422 3423 ret = bdrv_aligned_pwritev(bs, &req, offset, bytes, 3424 use_local_qiov ? &local_qiov : qiov, 3425 flags); 3426 3427 fail: 3428 tracked_request_end(&req); 3429 3430 if (use_local_qiov) { 3431 qemu_iovec_destroy(&local_qiov); 3432 } 3433 qemu_vfree(head_buf); 3434 qemu_vfree(tail_buf); 3435 3436 return ret; 3437 } 3438 3439 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, 3440 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, 3441 BdrvRequestFlags flags) 3442 { 3443 if (nb_sectors < 0 || nb_sectors > (INT_MAX >> BDRV_SECTOR_BITS)) { 3444 return -EINVAL; 3445 } 3446 3447 return bdrv_co_do_pwritev(bs, sector_num << BDRV_SECTOR_BITS, 3448 nb_sectors << BDRV_SECTOR_BITS, qiov, flags); 3449 } 3450 3451 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num, 3452 int nb_sectors, QEMUIOVector *qiov) 3453 { 3454 trace_bdrv_co_writev(bs, sector_num, nb_sectors); 3455 3456 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0); 3457 } 3458 3459 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, 3460 int64_t sector_num, int nb_sectors, 3461 BdrvRequestFlags flags) 3462 { 3463 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors, flags); 3464 3465 if (!(bs->open_flags & BDRV_O_UNMAP)) { 3466 flags &= ~BDRV_REQ_MAY_UNMAP; 3467 } 3468 3469 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL, 3470 BDRV_REQ_ZERO_WRITE | flags); 3471 } 3472 3473 /** 3474 * Truncate file to 'offset' bytes (needed only for file protocols) 3475 */ 3476 int bdrv_truncate(BlockDriverState *bs, int64_t offset) 3477 { 3478 BlockDriver *drv = bs->drv; 3479 int ret; 3480 if (!drv) 3481 return -ENOMEDIUM; 3482 if (!drv->bdrv_truncate) 3483 return -ENOTSUP; 3484 if (bs->read_only) 3485 return -EACCES; 3486 3487 ret = drv->bdrv_truncate(bs, offset); 3488 if (ret == 0) { 3489 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS); 3490 bdrv_dev_resize_cb(bs); 3491 } 3492 return ret; 3493 } 3494 3495 /** 3496 * Length of a allocated file in bytes. Sparse files are counted by actual 3497 * allocated space. Return < 0 if error or unknown. 3498 */ 3499 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs) 3500 { 3501 BlockDriver *drv = bs->drv; 3502 if (!drv) { 3503 return -ENOMEDIUM; 3504 } 3505 if (drv->bdrv_get_allocated_file_size) { 3506 return drv->bdrv_get_allocated_file_size(bs); 3507 } 3508 if (bs->file) { 3509 return bdrv_get_allocated_file_size(bs->file); 3510 } 3511 return -ENOTSUP; 3512 } 3513 3514 /** 3515 * Length of a file in bytes. Return < 0 if error or unknown. 3516 */ 3517 int64_t bdrv_getlength(BlockDriverState *bs) 3518 { 3519 BlockDriver *drv = bs->drv; 3520 if (!drv) 3521 return -ENOMEDIUM; 3522 3523 if (drv->has_variable_length) { 3524 int ret = refresh_total_sectors(bs, bs->total_sectors); 3525 if (ret < 0) { 3526 return ret; 3527 } 3528 } 3529 return bs->total_sectors * BDRV_SECTOR_SIZE; 3530 } 3531 3532 /* return 0 as number of sectors if no device present or error */ 3533 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) 3534 { 3535 int64_t length; 3536 length = bdrv_getlength(bs); 3537 if (length < 0) 3538 length = 0; 3539 else 3540 length = length >> BDRV_SECTOR_BITS; 3541 *nb_sectors_ptr = length; 3542 } 3543 3544 void bdrv_set_on_error(BlockDriverState *bs, BlockdevOnError on_read_error, 3545 BlockdevOnError on_write_error) 3546 { 3547 bs->on_read_error = on_read_error; 3548 bs->on_write_error = on_write_error; 3549 } 3550 3551 BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read) 3552 { 3553 return is_read ? bs->on_read_error : bs->on_write_error; 3554 } 3555 3556 BlockErrorAction bdrv_get_error_action(BlockDriverState *bs, bool is_read, int error) 3557 { 3558 BlockdevOnError on_err = is_read ? bs->on_read_error : bs->on_write_error; 3559 3560 switch (on_err) { 3561 case BLOCKDEV_ON_ERROR_ENOSPC: 3562 return (error == ENOSPC) ? 3563 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT; 3564 case BLOCKDEV_ON_ERROR_STOP: 3565 return BLOCK_ERROR_ACTION_STOP; 3566 case BLOCKDEV_ON_ERROR_REPORT: 3567 return BLOCK_ERROR_ACTION_REPORT; 3568 case BLOCKDEV_ON_ERROR_IGNORE: 3569 return BLOCK_ERROR_ACTION_IGNORE; 3570 default: 3571 abort(); 3572 } 3573 } 3574 3575 /* This is done by device models because, while the block layer knows 3576 * about the error, it does not know whether an operation comes from 3577 * the device or the block layer (from a job, for example). 3578 */ 3579 void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action, 3580 bool is_read, int error) 3581 { 3582 assert(error >= 0); 3583 3584 if (action == BLOCK_ERROR_ACTION_STOP) { 3585 /* First set the iostatus, so that "info block" returns an iostatus 3586 * that matches the events raised so far (an additional error iostatus 3587 * is fine, but not a lost one). 3588 */ 3589 bdrv_iostatus_set_err(bs, error); 3590 3591 /* Then raise the request to stop the VM and the event. 3592 * qemu_system_vmstop_request_prepare has two effects. First, 3593 * it ensures that the STOP event always comes after the 3594 * BLOCK_IO_ERROR event. Second, it ensures that even if management 3595 * can observe the STOP event and do a "cont" before the STOP 3596 * event is issued, the VM will not stop. In this case, vm_start() 3597 * also ensures that the STOP/RESUME pair of events is emitted. 3598 */ 3599 qemu_system_vmstop_request_prepare(); 3600 qapi_event_send_block_io_error(bdrv_get_device_name(bs), 3601 is_read ? IO_OPERATION_TYPE_READ : 3602 IO_OPERATION_TYPE_WRITE, 3603 action, &error_abort); 3604 qemu_system_vmstop_request(RUN_STATE_IO_ERROR); 3605 } else { 3606 qapi_event_send_block_io_error(bdrv_get_device_name(bs), 3607 is_read ? IO_OPERATION_TYPE_READ : 3608 IO_OPERATION_TYPE_WRITE, 3609 action, &error_abort); 3610 } 3611 } 3612 3613 int bdrv_is_read_only(BlockDriverState *bs) 3614 { 3615 return bs->read_only; 3616 } 3617 3618 int bdrv_is_sg(BlockDriverState *bs) 3619 { 3620 return bs->sg; 3621 } 3622 3623 int bdrv_enable_write_cache(BlockDriverState *bs) 3624 { 3625 return bs->enable_write_cache; 3626 } 3627 3628 void bdrv_set_enable_write_cache(BlockDriverState *bs, bool wce) 3629 { 3630 bs->enable_write_cache = wce; 3631 3632 /* so a reopen() will preserve wce */ 3633 if (wce) { 3634 bs->open_flags |= BDRV_O_CACHE_WB; 3635 } else { 3636 bs->open_flags &= ~BDRV_O_CACHE_WB; 3637 } 3638 } 3639 3640 int bdrv_is_encrypted(BlockDriverState *bs) 3641 { 3642 if (bs->backing_hd && bs->backing_hd->encrypted) 3643 return 1; 3644 return bs->encrypted; 3645 } 3646 3647 int bdrv_key_required(BlockDriverState *bs) 3648 { 3649 BlockDriverState *backing_hd = bs->backing_hd; 3650 3651 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key) 3652 return 1; 3653 return (bs->encrypted && !bs->valid_key); 3654 } 3655 3656 int bdrv_set_key(BlockDriverState *bs, const char *key) 3657 { 3658 int ret; 3659 if (bs->backing_hd && bs->backing_hd->encrypted) { 3660 ret = bdrv_set_key(bs->backing_hd, key); 3661 if (ret < 0) 3662 return ret; 3663 if (!bs->encrypted) 3664 return 0; 3665 } 3666 if (!bs->encrypted) { 3667 return -EINVAL; 3668 } else if (!bs->drv || !bs->drv->bdrv_set_key) { 3669 return -ENOMEDIUM; 3670 } 3671 ret = bs->drv->bdrv_set_key(bs, key); 3672 if (ret < 0) { 3673 bs->valid_key = 0; 3674 } else if (!bs->valid_key) { 3675 bs->valid_key = 1; 3676 /* call the change callback now, we skipped it on open */ 3677 bdrv_dev_change_media_cb(bs, true); 3678 } 3679 return ret; 3680 } 3681 3682 const char *bdrv_get_format_name(BlockDriverState *bs) 3683 { 3684 return bs->drv ? bs->drv->format_name : NULL; 3685 } 3686 3687 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 3688 void *opaque) 3689 { 3690 BlockDriver *drv; 3691 int count = 0; 3692 const char **formats = NULL; 3693 3694 QLIST_FOREACH(drv, &bdrv_drivers, list) { 3695 if (drv->format_name) { 3696 bool found = false; 3697 int i = count; 3698 while (formats && i && !found) { 3699 found = !strcmp(formats[--i], drv->format_name); 3700 } 3701 3702 if (!found) { 3703 formats = g_realloc(formats, (count + 1) * sizeof(char *)); 3704 formats[count++] = drv->format_name; 3705 it(opaque, drv->format_name); 3706 } 3707 } 3708 } 3709 g_free(formats); 3710 } 3711 3712 /* This function is to find block backend bs */ 3713 BlockDriverState *bdrv_find(const char *name) 3714 { 3715 BlockDriverState *bs; 3716 3717 QTAILQ_FOREACH(bs, &bdrv_states, device_list) { 3718 if (!strcmp(name, bs->device_name)) { 3719 return bs; 3720 } 3721 } 3722 return NULL; 3723 } 3724 3725 /* This function is to find a node in the bs graph */ 3726 BlockDriverState *bdrv_find_node(const char *node_name) 3727 { 3728 BlockDriverState *bs; 3729 3730 assert(node_name); 3731 3732 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { 3733 if (!strcmp(node_name, bs->node_name)) { 3734 return bs; 3735 } 3736 } 3737 return NULL; 3738 } 3739 3740 /* Put this QMP function here so it can access the static graph_bdrv_states. */ 3741 BlockDeviceInfoList *bdrv_named_nodes_list(void) 3742 { 3743 BlockDeviceInfoList *list, *entry; 3744 BlockDriverState *bs; 3745 3746 list = NULL; 3747 QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) { 3748 entry = g_malloc0(sizeof(*entry)); 3749 entry->value = bdrv_block_device_info(bs); 3750 entry->next = list; 3751 list = entry; 3752 } 3753 3754 return list; 3755 } 3756 3757 BlockDriverState *bdrv_lookup_bs(const char *device, 3758 const char *node_name, 3759 Error **errp) 3760 { 3761 BlockDriverState *bs = NULL; 3762 3763 if (device) { 3764 bs = bdrv_find(device); 3765 3766 if (bs) { 3767 return bs; 3768 } 3769 } 3770 3771 if (node_name) { 3772 bs = bdrv_find_node(node_name); 3773 3774 if (bs) { 3775 return bs; 3776 } 3777 } 3778 3779 error_setg(errp, "Cannot find device=%s nor node_name=%s", 3780 device ? device : "", 3781 node_name ? node_name : ""); 3782 return NULL; 3783 } 3784 3785 BlockDriverState *bdrv_next(BlockDriverState *bs) 3786 { 3787 if (!bs) { 3788 return QTAILQ_FIRST(&bdrv_states); 3789 } 3790 return QTAILQ_NEXT(bs, device_list); 3791 } 3792 3793 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque) 3794 { 3795 BlockDriverState *bs; 3796 3797 QTAILQ_FOREACH(bs, &bdrv_states, device_list) { 3798 it(opaque, bs); 3799 } 3800 } 3801 3802 const char *bdrv_get_device_name(BlockDriverState *bs) 3803 { 3804 return bs->device_name; 3805 } 3806 3807 int bdrv_get_flags(BlockDriverState *bs) 3808 { 3809 return bs->open_flags; 3810 } 3811 3812 int bdrv_flush_all(void) 3813 { 3814 BlockDriverState *bs; 3815 int result = 0; 3816 3817 QTAILQ_FOREACH(bs, &bdrv_states, device_list) { 3818 AioContext *aio_context = bdrv_get_aio_context(bs); 3819 int ret; 3820 3821 aio_context_acquire(aio_context); 3822 ret = bdrv_flush(bs); 3823 if (ret < 0 && !result) { 3824 result = ret; 3825 } 3826 aio_context_release(aio_context); 3827 } 3828 3829 return result; 3830 } 3831 3832 int bdrv_has_zero_init_1(BlockDriverState *bs) 3833 { 3834 return 1; 3835 } 3836 3837 int bdrv_has_zero_init(BlockDriverState *bs) 3838 { 3839 assert(bs->drv); 3840 3841 /* If BS is a copy on write image, it is initialized to 3842 the contents of the base image, which may not be zeroes. */ 3843 if (bs->backing_hd) { 3844 return 0; 3845 } 3846 if (bs->drv->bdrv_has_zero_init) { 3847 return bs->drv->bdrv_has_zero_init(bs); 3848 } 3849 3850 /* safe default */ 3851 return 0; 3852 } 3853 3854 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs) 3855 { 3856 BlockDriverInfo bdi; 3857 3858 if (bs->backing_hd) { 3859 return false; 3860 } 3861 3862 if (bdrv_get_info(bs, &bdi) == 0) { 3863 return bdi.unallocated_blocks_are_zero; 3864 } 3865 3866 return false; 3867 } 3868 3869 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs) 3870 { 3871 BlockDriverInfo bdi; 3872 3873 if (bs->backing_hd || !(bs->open_flags & BDRV_O_UNMAP)) { 3874 return false; 3875 } 3876 3877 if (bdrv_get_info(bs, &bdi) == 0) { 3878 return bdi.can_write_zeroes_with_unmap; 3879 } 3880 3881 return false; 3882 } 3883 3884 typedef struct BdrvCoGetBlockStatusData { 3885 BlockDriverState *bs; 3886 BlockDriverState *base; 3887 int64_t sector_num; 3888 int nb_sectors; 3889 int *pnum; 3890 int64_t ret; 3891 bool done; 3892 } BdrvCoGetBlockStatusData; 3893 3894 /* 3895 * Returns true iff the specified sector is present in the disk image. Drivers 3896 * not implementing the functionality are assumed to not support backing files, 3897 * hence all their sectors are reported as allocated. 3898 * 3899 * If 'sector_num' is beyond the end of the disk image the return value is 0 3900 * and 'pnum' is set to 0. 3901 * 3902 * 'pnum' is set to the number of sectors (including and immediately following 3903 * the specified sector) that are known to be in the same 3904 * allocated/unallocated state. 3905 * 3906 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes 3907 * beyond the end of the disk image it will be clamped. 3908 */ 3909 static int64_t coroutine_fn bdrv_co_get_block_status(BlockDriverState *bs, 3910 int64_t sector_num, 3911 int nb_sectors, int *pnum) 3912 { 3913 int64_t length; 3914 int64_t n; 3915 int64_t ret, ret2; 3916 3917 length = bdrv_getlength(bs); 3918 if (length < 0) { 3919 return length; 3920 } 3921 3922 if (sector_num >= (length >> BDRV_SECTOR_BITS)) { 3923 *pnum = 0; 3924 return 0; 3925 } 3926 3927 n = bs->total_sectors - sector_num; 3928 if (n < nb_sectors) { 3929 nb_sectors = n; 3930 } 3931 3932 if (!bs->drv->bdrv_co_get_block_status) { 3933 *pnum = nb_sectors; 3934 ret = BDRV_BLOCK_DATA | BDRV_BLOCK_ALLOCATED; 3935 if (bs->drv->protocol_name) { 3936 ret |= BDRV_BLOCK_OFFSET_VALID | (sector_num * BDRV_SECTOR_SIZE); 3937 } 3938 return ret; 3939 } 3940 3941 ret = bs->drv->bdrv_co_get_block_status(bs, sector_num, nb_sectors, pnum); 3942 if (ret < 0) { 3943 *pnum = 0; 3944 return ret; 3945 } 3946 3947 if (ret & BDRV_BLOCK_RAW) { 3948 assert(ret & BDRV_BLOCK_OFFSET_VALID); 3949 return bdrv_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS, 3950 *pnum, pnum); 3951 } 3952 3953 if (ret & (BDRV_BLOCK_DATA | BDRV_BLOCK_ZERO)) { 3954 ret |= BDRV_BLOCK_ALLOCATED; 3955 } 3956 3957 if (!(ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO)) { 3958 if (bdrv_unallocated_blocks_are_zero(bs)) { 3959 ret |= BDRV_BLOCK_ZERO; 3960 } else if (bs->backing_hd) { 3961 BlockDriverState *bs2 = bs->backing_hd; 3962 int64_t length2 = bdrv_getlength(bs2); 3963 if (length2 >= 0 && sector_num >= (length2 >> BDRV_SECTOR_BITS)) { 3964 ret |= BDRV_BLOCK_ZERO; 3965 } 3966 } 3967 } 3968 3969 if (bs->file && 3970 (ret & BDRV_BLOCK_DATA) && !(ret & BDRV_BLOCK_ZERO) && 3971 (ret & BDRV_BLOCK_OFFSET_VALID)) { 3972 ret2 = bdrv_co_get_block_status(bs->file, ret >> BDRV_SECTOR_BITS, 3973 *pnum, pnum); 3974 if (ret2 >= 0) { 3975 /* Ignore errors. This is just providing extra information, it 3976 * is useful but not necessary. 3977 */ 3978 ret |= (ret2 & BDRV_BLOCK_ZERO); 3979 } 3980 } 3981 3982 return ret; 3983 } 3984 3985 /* Coroutine wrapper for bdrv_get_block_status() */ 3986 static void coroutine_fn bdrv_get_block_status_co_entry(void *opaque) 3987 { 3988 BdrvCoGetBlockStatusData *data = opaque; 3989 BlockDriverState *bs = data->bs; 3990 3991 data->ret = bdrv_co_get_block_status(bs, data->sector_num, data->nb_sectors, 3992 data->pnum); 3993 data->done = true; 3994 } 3995 3996 /* 3997 * Synchronous wrapper around bdrv_co_get_block_status(). 3998 * 3999 * See bdrv_co_get_block_status() for details. 4000 */ 4001 int64_t bdrv_get_block_status(BlockDriverState *bs, int64_t sector_num, 4002 int nb_sectors, int *pnum) 4003 { 4004 Coroutine *co; 4005 BdrvCoGetBlockStatusData data = { 4006 .bs = bs, 4007 .sector_num = sector_num, 4008 .nb_sectors = nb_sectors, 4009 .pnum = pnum, 4010 .done = false, 4011 }; 4012 4013 if (qemu_in_coroutine()) { 4014 /* Fast-path if already in coroutine context */ 4015 bdrv_get_block_status_co_entry(&data); 4016 } else { 4017 AioContext *aio_context = bdrv_get_aio_context(bs); 4018 4019 co = qemu_coroutine_create(bdrv_get_block_status_co_entry); 4020 qemu_coroutine_enter(co, &data); 4021 while (!data.done) { 4022 aio_poll(aio_context, true); 4023 } 4024 } 4025 return data.ret; 4026 } 4027 4028 int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, 4029 int nb_sectors, int *pnum) 4030 { 4031 int64_t ret = bdrv_get_block_status(bs, sector_num, nb_sectors, pnum); 4032 if (ret < 0) { 4033 return ret; 4034 } 4035 return (ret & BDRV_BLOCK_ALLOCATED); 4036 } 4037 4038 /* 4039 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP] 4040 * 4041 * Return true if the given sector is allocated in any image between 4042 * BASE and TOP (inclusive). BASE can be NULL to check if the given 4043 * sector is allocated in any image of the chain. Return false otherwise. 4044 * 4045 * 'pnum' is set to the number of sectors (including and immediately following 4046 * the specified sector) that are known to be in the same 4047 * allocated/unallocated state. 4048 * 4049 */ 4050 int bdrv_is_allocated_above(BlockDriverState *top, 4051 BlockDriverState *base, 4052 int64_t sector_num, 4053 int nb_sectors, int *pnum) 4054 { 4055 BlockDriverState *intermediate; 4056 int ret, n = nb_sectors; 4057 4058 intermediate = top; 4059 while (intermediate && intermediate != base) { 4060 int pnum_inter; 4061 ret = bdrv_is_allocated(intermediate, sector_num, nb_sectors, 4062 &pnum_inter); 4063 if (ret < 0) { 4064 return ret; 4065 } else if (ret) { 4066 *pnum = pnum_inter; 4067 return 1; 4068 } 4069 4070 /* 4071 * [sector_num, nb_sectors] is unallocated on top but intermediate 4072 * might have 4073 * 4074 * [sector_num+x, nr_sectors] allocated. 4075 */ 4076 if (n > pnum_inter && 4077 (intermediate == top || 4078 sector_num + pnum_inter < intermediate->total_sectors)) { 4079 n = pnum_inter; 4080 } 4081 4082 intermediate = intermediate->backing_hd; 4083 } 4084 4085 *pnum = n; 4086 return 0; 4087 } 4088 4089 const char *bdrv_get_encrypted_filename(BlockDriverState *bs) 4090 { 4091 if (bs->backing_hd && bs->backing_hd->encrypted) 4092 return bs->backing_file; 4093 else if (bs->encrypted) 4094 return bs->filename; 4095 else 4096 return NULL; 4097 } 4098 4099 void bdrv_get_backing_filename(BlockDriverState *bs, 4100 char *filename, int filename_size) 4101 { 4102 pstrcpy(filename, filename_size, bs->backing_file); 4103 } 4104 4105 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 4106 const uint8_t *buf, int nb_sectors) 4107 { 4108 BlockDriver *drv = bs->drv; 4109 if (!drv) 4110 return -ENOMEDIUM; 4111 if (!drv->bdrv_write_compressed) 4112 return -ENOTSUP; 4113 if (bdrv_check_request(bs, sector_num, nb_sectors)) 4114 return -EIO; 4115 4116 assert(QLIST_EMPTY(&bs->dirty_bitmaps)); 4117 4118 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors); 4119 } 4120 4121 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 4122 { 4123 BlockDriver *drv = bs->drv; 4124 if (!drv) 4125 return -ENOMEDIUM; 4126 if (!drv->bdrv_get_info) 4127 return -ENOTSUP; 4128 memset(bdi, 0, sizeof(*bdi)); 4129 return drv->bdrv_get_info(bs, bdi); 4130 } 4131 4132 ImageInfoSpecific *bdrv_get_specific_info(BlockDriverState *bs) 4133 { 4134 BlockDriver *drv = bs->drv; 4135 if (drv && drv->bdrv_get_specific_info) { 4136 return drv->bdrv_get_specific_info(bs); 4137 } 4138 return NULL; 4139 } 4140 4141 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf, 4142 int64_t pos, int size) 4143 { 4144 QEMUIOVector qiov; 4145 struct iovec iov = { 4146 .iov_base = (void *) buf, 4147 .iov_len = size, 4148 }; 4149 4150 qemu_iovec_init_external(&qiov, &iov, 1); 4151 return bdrv_writev_vmstate(bs, &qiov, pos); 4152 } 4153 4154 int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos) 4155 { 4156 BlockDriver *drv = bs->drv; 4157 4158 if (!drv) { 4159 return -ENOMEDIUM; 4160 } else if (drv->bdrv_save_vmstate) { 4161 return drv->bdrv_save_vmstate(bs, qiov, pos); 4162 } else if (bs->file) { 4163 return bdrv_writev_vmstate(bs->file, qiov, pos); 4164 } 4165 4166 return -ENOTSUP; 4167 } 4168 4169 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf, 4170 int64_t pos, int size) 4171 { 4172 BlockDriver *drv = bs->drv; 4173 if (!drv) 4174 return -ENOMEDIUM; 4175 if (drv->bdrv_load_vmstate) 4176 return drv->bdrv_load_vmstate(bs, buf, pos, size); 4177 if (bs->file) 4178 return bdrv_load_vmstate(bs->file, buf, pos, size); 4179 return -ENOTSUP; 4180 } 4181 4182 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event) 4183 { 4184 if (!bs || !bs->drv || !bs->drv->bdrv_debug_event) { 4185 return; 4186 } 4187 4188 bs->drv->bdrv_debug_event(bs, event); 4189 } 4190 4191 int bdrv_debug_breakpoint(BlockDriverState *bs, const char *event, 4192 const char *tag) 4193 { 4194 while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) { 4195 bs = bs->file; 4196 } 4197 4198 if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) { 4199 return bs->drv->bdrv_debug_breakpoint(bs, event, tag); 4200 } 4201 4202 return -ENOTSUP; 4203 } 4204 4205 int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag) 4206 { 4207 while (bs && bs->drv && !bs->drv->bdrv_debug_remove_breakpoint) { 4208 bs = bs->file; 4209 } 4210 4211 if (bs && bs->drv && bs->drv->bdrv_debug_remove_breakpoint) { 4212 return bs->drv->bdrv_debug_remove_breakpoint(bs, tag); 4213 } 4214 4215 return -ENOTSUP; 4216 } 4217 4218 int bdrv_debug_resume(BlockDriverState *bs, const char *tag) 4219 { 4220 while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) { 4221 bs = bs->file; 4222 } 4223 4224 if (bs && bs->drv && bs->drv->bdrv_debug_resume) { 4225 return bs->drv->bdrv_debug_resume(bs, tag); 4226 } 4227 4228 return -ENOTSUP; 4229 } 4230 4231 bool bdrv_debug_is_suspended(BlockDriverState *bs, const char *tag) 4232 { 4233 while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) { 4234 bs = bs->file; 4235 } 4236 4237 if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) { 4238 return bs->drv->bdrv_debug_is_suspended(bs, tag); 4239 } 4240 4241 return false; 4242 } 4243 4244 int bdrv_is_snapshot(BlockDriverState *bs) 4245 { 4246 return !!(bs->open_flags & BDRV_O_SNAPSHOT); 4247 } 4248 4249 /* backing_file can either be relative, or absolute, or a protocol. If it is 4250 * relative, it must be relative to the chain. So, passing in bs->filename 4251 * from a BDS as backing_file should not be done, as that may be relative to 4252 * the CWD rather than the chain. */ 4253 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, 4254 const char *backing_file) 4255 { 4256 char *filename_full = NULL; 4257 char *backing_file_full = NULL; 4258 char *filename_tmp = NULL; 4259 int is_protocol = 0; 4260 BlockDriverState *curr_bs = NULL; 4261 BlockDriverState *retval = NULL; 4262 4263 if (!bs || !bs->drv || !backing_file) { 4264 return NULL; 4265 } 4266 4267 filename_full = g_malloc(PATH_MAX); 4268 backing_file_full = g_malloc(PATH_MAX); 4269 filename_tmp = g_malloc(PATH_MAX); 4270 4271 is_protocol = path_has_protocol(backing_file); 4272 4273 for (curr_bs = bs; curr_bs->backing_hd; curr_bs = curr_bs->backing_hd) { 4274 4275 /* If either of the filename paths is actually a protocol, then 4276 * compare unmodified paths; otherwise make paths relative */ 4277 if (is_protocol || path_has_protocol(curr_bs->backing_file)) { 4278 if (strcmp(backing_file, curr_bs->backing_file) == 0) { 4279 retval = curr_bs->backing_hd; 4280 break; 4281 } 4282 } else { 4283 /* If not an absolute filename path, make it relative to the current 4284 * image's filename path */ 4285 path_combine(filename_tmp, PATH_MAX, curr_bs->filename, 4286 backing_file); 4287 4288 /* We are going to compare absolute pathnames */ 4289 if (!realpath(filename_tmp, filename_full)) { 4290 continue; 4291 } 4292 4293 /* We need to make sure the backing filename we are comparing against 4294 * is relative to the current image filename (or absolute) */ 4295 path_combine(filename_tmp, PATH_MAX, curr_bs->filename, 4296 curr_bs->backing_file); 4297 4298 if (!realpath(filename_tmp, backing_file_full)) { 4299 continue; 4300 } 4301 4302 if (strcmp(backing_file_full, filename_full) == 0) { 4303 retval = curr_bs->backing_hd; 4304 break; 4305 } 4306 } 4307 } 4308 4309 g_free(filename_full); 4310 g_free(backing_file_full); 4311 g_free(filename_tmp); 4312 return retval; 4313 } 4314 4315 int bdrv_get_backing_file_depth(BlockDriverState *bs) 4316 { 4317 if (!bs->drv) { 4318 return 0; 4319 } 4320 4321 if (!bs->backing_hd) { 4322 return 0; 4323 } 4324 4325 return 1 + bdrv_get_backing_file_depth(bs->backing_hd); 4326 } 4327 4328 BlockDriverState *bdrv_find_base(BlockDriverState *bs) 4329 { 4330 BlockDriverState *curr_bs = NULL; 4331 4332 if (!bs) { 4333 return NULL; 4334 } 4335 4336 curr_bs = bs; 4337 4338 while (curr_bs->backing_hd) { 4339 curr_bs = curr_bs->backing_hd; 4340 } 4341 return curr_bs; 4342 } 4343 4344 /**************************************************************/ 4345 /* async I/Os */ 4346 4347 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, 4348 QEMUIOVector *qiov, int nb_sectors, 4349 BlockDriverCompletionFunc *cb, void *opaque) 4350 { 4351 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque); 4352 4353 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0, 4354 cb, opaque, false); 4355 } 4356 4357 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, 4358 QEMUIOVector *qiov, int nb_sectors, 4359 BlockDriverCompletionFunc *cb, void *opaque) 4360 { 4361 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque); 4362 4363 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0, 4364 cb, opaque, true); 4365 } 4366 4367 BlockDriverAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs, 4368 int64_t sector_num, int nb_sectors, BdrvRequestFlags flags, 4369 BlockDriverCompletionFunc *cb, void *opaque) 4370 { 4371 trace_bdrv_aio_write_zeroes(bs, sector_num, nb_sectors, flags, opaque); 4372 4373 return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors, 4374 BDRV_REQ_ZERO_WRITE | flags, 4375 cb, opaque, true); 4376 } 4377 4378 4379 typedef struct MultiwriteCB { 4380 int error; 4381 int num_requests; 4382 int num_callbacks; 4383 struct { 4384 BlockDriverCompletionFunc *cb; 4385 void *opaque; 4386 QEMUIOVector *free_qiov; 4387 } callbacks[]; 4388 } MultiwriteCB; 4389 4390 static void multiwrite_user_cb(MultiwriteCB *mcb) 4391 { 4392 int i; 4393 4394 for (i = 0; i < mcb->num_callbacks; i++) { 4395 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error); 4396 if (mcb->callbacks[i].free_qiov) { 4397 qemu_iovec_destroy(mcb->callbacks[i].free_qiov); 4398 } 4399 g_free(mcb->callbacks[i].free_qiov); 4400 } 4401 } 4402 4403 static void multiwrite_cb(void *opaque, int ret) 4404 { 4405 MultiwriteCB *mcb = opaque; 4406 4407 trace_multiwrite_cb(mcb, ret); 4408 4409 if (ret < 0 && !mcb->error) { 4410 mcb->error = ret; 4411 } 4412 4413 mcb->num_requests--; 4414 if (mcb->num_requests == 0) { 4415 multiwrite_user_cb(mcb); 4416 g_free(mcb); 4417 } 4418 } 4419 4420 static int multiwrite_req_compare(const void *a, const void *b) 4421 { 4422 const BlockRequest *req1 = a, *req2 = b; 4423 4424 /* 4425 * Note that we can't simply subtract req2->sector from req1->sector 4426 * here as that could overflow the return value. 4427 */ 4428 if (req1->sector > req2->sector) { 4429 return 1; 4430 } else if (req1->sector < req2->sector) { 4431 return -1; 4432 } else { 4433 return 0; 4434 } 4435 } 4436 4437 /* 4438 * Takes a bunch of requests and tries to merge them. Returns the number of 4439 * requests that remain after merging. 4440 */ 4441 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs, 4442 int num_reqs, MultiwriteCB *mcb) 4443 { 4444 int i, outidx; 4445 4446 // Sort requests by start sector 4447 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare); 4448 4449 // Check if adjacent requests touch the same clusters. If so, combine them, 4450 // filling up gaps with zero sectors. 4451 outidx = 0; 4452 for (i = 1; i < num_reqs; i++) { 4453 int merge = 0; 4454 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors; 4455 4456 // Handle exactly sequential writes and overlapping writes. 4457 if (reqs[i].sector <= oldreq_last) { 4458 merge = 1; 4459 } 4460 4461 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) { 4462 merge = 0; 4463 } 4464 4465 if (merge) { 4466 size_t size; 4467 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov)); 4468 qemu_iovec_init(qiov, 4469 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1); 4470 4471 // Add the first request to the merged one. If the requests are 4472 // overlapping, drop the last sectors of the first request. 4473 size = (reqs[i].sector - reqs[outidx].sector) << 9; 4474 qemu_iovec_concat(qiov, reqs[outidx].qiov, 0, size); 4475 4476 // We should need to add any zeros between the two requests 4477 assert (reqs[i].sector <= oldreq_last); 4478 4479 // Add the second request 4480 qemu_iovec_concat(qiov, reqs[i].qiov, 0, reqs[i].qiov->size); 4481 4482 reqs[outidx].nb_sectors = qiov->size >> 9; 4483 reqs[outidx].qiov = qiov; 4484 4485 mcb->callbacks[i].free_qiov = reqs[outidx].qiov; 4486 } else { 4487 outidx++; 4488 reqs[outidx].sector = reqs[i].sector; 4489 reqs[outidx].nb_sectors = reqs[i].nb_sectors; 4490 reqs[outidx].qiov = reqs[i].qiov; 4491 } 4492 } 4493 4494 return outidx + 1; 4495 } 4496 4497 /* 4498 * Submit multiple AIO write requests at once. 4499 * 4500 * On success, the function returns 0 and all requests in the reqs array have 4501 * been submitted. In error case this function returns -1, and any of the 4502 * requests may or may not be submitted yet. In particular, this means that the 4503 * callback will be called for some of the requests, for others it won't. The 4504 * caller must check the error field of the BlockRequest to wait for the right 4505 * callbacks (if error != 0, no callback will be called). 4506 * 4507 * The implementation may modify the contents of the reqs array, e.g. to merge 4508 * requests. However, the fields opaque and error are left unmodified as they 4509 * are used to signal failure for a single request to the caller. 4510 */ 4511 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs) 4512 { 4513 MultiwriteCB *mcb; 4514 int i; 4515 4516 /* don't submit writes if we don't have a medium */ 4517 if (bs->drv == NULL) { 4518 for (i = 0; i < num_reqs; i++) { 4519 reqs[i].error = -ENOMEDIUM; 4520 } 4521 return -1; 4522 } 4523 4524 if (num_reqs == 0) { 4525 return 0; 4526 } 4527 4528 // Create MultiwriteCB structure 4529 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks)); 4530 mcb->num_requests = 0; 4531 mcb->num_callbacks = num_reqs; 4532 4533 for (i = 0; i < num_reqs; i++) { 4534 mcb->callbacks[i].cb = reqs[i].cb; 4535 mcb->callbacks[i].opaque = reqs[i].opaque; 4536 } 4537 4538 // Check for mergable requests 4539 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb); 4540 4541 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs); 4542 4543 /* Run the aio requests. */ 4544 mcb->num_requests = num_reqs; 4545 for (i = 0; i < num_reqs; i++) { 4546 bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov, 4547 reqs[i].nb_sectors, reqs[i].flags, 4548 multiwrite_cb, mcb, 4549 true); 4550 } 4551 4552 return 0; 4553 } 4554 4555 void bdrv_aio_cancel(BlockDriverAIOCB *acb) 4556 { 4557 acb->aiocb_info->cancel(acb); 4558 } 4559 4560 /**************************************************************/ 4561 /* async block device emulation */ 4562 4563 typedef struct BlockDriverAIOCBSync { 4564 BlockDriverAIOCB common; 4565 QEMUBH *bh; 4566 int ret; 4567 /* vector translation state */ 4568 QEMUIOVector *qiov; 4569 uint8_t *bounce; 4570 int is_write; 4571 } BlockDriverAIOCBSync; 4572 4573 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb) 4574 { 4575 BlockDriverAIOCBSync *acb = 4576 container_of(blockacb, BlockDriverAIOCBSync, common); 4577 qemu_bh_delete(acb->bh); 4578 acb->bh = NULL; 4579 qemu_aio_release(acb); 4580 } 4581 4582 static const AIOCBInfo bdrv_em_aiocb_info = { 4583 .aiocb_size = sizeof(BlockDriverAIOCBSync), 4584 .cancel = bdrv_aio_cancel_em, 4585 }; 4586 4587 static void bdrv_aio_bh_cb(void *opaque) 4588 { 4589 BlockDriverAIOCBSync *acb = opaque; 4590 4591 if (!acb->is_write) 4592 qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size); 4593 qemu_vfree(acb->bounce); 4594 acb->common.cb(acb->common.opaque, acb->ret); 4595 qemu_bh_delete(acb->bh); 4596 acb->bh = NULL; 4597 qemu_aio_release(acb); 4598 } 4599 4600 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, 4601 int64_t sector_num, 4602 QEMUIOVector *qiov, 4603 int nb_sectors, 4604 BlockDriverCompletionFunc *cb, 4605 void *opaque, 4606 int is_write) 4607 4608 { 4609 BlockDriverAIOCBSync *acb; 4610 4611 acb = qemu_aio_get(&bdrv_em_aiocb_info, bs, cb, opaque); 4612 acb->is_write = is_write; 4613 acb->qiov = qiov; 4614 acb->bounce = qemu_blockalign(bs, qiov->size); 4615 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_aio_bh_cb, acb); 4616 4617 if (is_write) { 4618 qemu_iovec_to_buf(acb->qiov, 0, acb->bounce, qiov->size); 4619 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors); 4620 } else { 4621 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors); 4622 } 4623 4624 qemu_bh_schedule(acb->bh); 4625 4626 return &acb->common; 4627 } 4628 4629 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, 4630 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 4631 BlockDriverCompletionFunc *cb, void *opaque) 4632 { 4633 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); 4634 } 4635 4636 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, 4637 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 4638 BlockDriverCompletionFunc *cb, void *opaque) 4639 { 4640 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); 4641 } 4642 4643 4644 typedef struct BlockDriverAIOCBCoroutine { 4645 BlockDriverAIOCB common; 4646 BlockRequest req; 4647 bool is_write; 4648 bool *done; 4649 QEMUBH* bh; 4650 } BlockDriverAIOCBCoroutine; 4651 4652 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb) 4653 { 4654 AioContext *aio_context = bdrv_get_aio_context(blockacb->bs); 4655 BlockDriverAIOCBCoroutine *acb = 4656 container_of(blockacb, BlockDriverAIOCBCoroutine, common); 4657 bool done = false; 4658 4659 acb->done = &done; 4660 while (!done) { 4661 aio_poll(aio_context, true); 4662 } 4663 } 4664 4665 static const AIOCBInfo bdrv_em_co_aiocb_info = { 4666 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine), 4667 .cancel = bdrv_aio_co_cancel_em, 4668 }; 4669 4670 static void bdrv_co_em_bh(void *opaque) 4671 { 4672 BlockDriverAIOCBCoroutine *acb = opaque; 4673 4674 acb->common.cb(acb->common.opaque, acb->req.error); 4675 4676 if (acb->done) { 4677 *acb->done = true; 4678 } 4679 4680 qemu_bh_delete(acb->bh); 4681 qemu_aio_release(acb); 4682 } 4683 4684 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */ 4685 static void coroutine_fn bdrv_co_do_rw(void *opaque) 4686 { 4687 BlockDriverAIOCBCoroutine *acb = opaque; 4688 BlockDriverState *bs = acb->common.bs; 4689 4690 if (!acb->is_write) { 4691 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector, 4692 acb->req.nb_sectors, acb->req.qiov, acb->req.flags); 4693 } else { 4694 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector, 4695 acb->req.nb_sectors, acb->req.qiov, acb->req.flags); 4696 } 4697 4698 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb); 4699 qemu_bh_schedule(acb->bh); 4700 } 4701 4702 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, 4703 int64_t sector_num, 4704 QEMUIOVector *qiov, 4705 int nb_sectors, 4706 BdrvRequestFlags flags, 4707 BlockDriverCompletionFunc *cb, 4708 void *opaque, 4709 bool is_write) 4710 { 4711 Coroutine *co; 4712 BlockDriverAIOCBCoroutine *acb; 4713 4714 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque); 4715 acb->req.sector = sector_num; 4716 acb->req.nb_sectors = nb_sectors; 4717 acb->req.qiov = qiov; 4718 acb->req.flags = flags; 4719 acb->is_write = is_write; 4720 acb->done = NULL; 4721 4722 co = qemu_coroutine_create(bdrv_co_do_rw); 4723 qemu_coroutine_enter(co, acb); 4724 4725 return &acb->common; 4726 } 4727 4728 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque) 4729 { 4730 BlockDriverAIOCBCoroutine *acb = opaque; 4731 BlockDriverState *bs = acb->common.bs; 4732 4733 acb->req.error = bdrv_co_flush(bs); 4734 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb); 4735 qemu_bh_schedule(acb->bh); 4736 } 4737 4738 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, 4739 BlockDriverCompletionFunc *cb, void *opaque) 4740 { 4741 trace_bdrv_aio_flush(bs, opaque); 4742 4743 Coroutine *co; 4744 BlockDriverAIOCBCoroutine *acb; 4745 4746 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque); 4747 acb->done = NULL; 4748 4749 co = qemu_coroutine_create(bdrv_aio_flush_co_entry); 4750 qemu_coroutine_enter(co, acb); 4751 4752 return &acb->common; 4753 } 4754 4755 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque) 4756 { 4757 BlockDriverAIOCBCoroutine *acb = opaque; 4758 BlockDriverState *bs = acb->common.bs; 4759 4760 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors); 4761 acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb); 4762 qemu_bh_schedule(acb->bh); 4763 } 4764 4765 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs, 4766 int64_t sector_num, int nb_sectors, 4767 BlockDriverCompletionFunc *cb, void *opaque) 4768 { 4769 Coroutine *co; 4770 BlockDriverAIOCBCoroutine *acb; 4771 4772 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque); 4773 4774 acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque); 4775 acb->req.sector = sector_num; 4776 acb->req.nb_sectors = nb_sectors; 4777 acb->done = NULL; 4778 co = qemu_coroutine_create(bdrv_aio_discard_co_entry); 4779 qemu_coroutine_enter(co, acb); 4780 4781 return &acb->common; 4782 } 4783 4784 void bdrv_init(void) 4785 { 4786 module_call_init(MODULE_INIT_BLOCK); 4787 } 4788 4789 void bdrv_init_with_whitelist(void) 4790 { 4791 use_bdrv_whitelist = 1; 4792 bdrv_init(); 4793 } 4794 4795 void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, 4796 BlockDriverCompletionFunc *cb, void *opaque) 4797 { 4798 BlockDriverAIOCB *acb; 4799 4800 acb = g_slice_alloc(aiocb_info->aiocb_size); 4801 acb->aiocb_info = aiocb_info; 4802 acb->bs = bs; 4803 acb->cb = cb; 4804 acb->opaque = opaque; 4805 return acb; 4806 } 4807 4808 void qemu_aio_release(void *p) 4809 { 4810 BlockDriverAIOCB *acb = p; 4811 g_slice_free1(acb->aiocb_info->aiocb_size, acb); 4812 } 4813 4814 /**************************************************************/ 4815 /* Coroutine block device emulation */ 4816 4817 typedef struct CoroutineIOCompletion { 4818 Coroutine *coroutine; 4819 int ret; 4820 } CoroutineIOCompletion; 4821 4822 static void bdrv_co_io_em_complete(void *opaque, int ret) 4823 { 4824 CoroutineIOCompletion *co = opaque; 4825 4826 co->ret = ret; 4827 qemu_coroutine_enter(co->coroutine, NULL); 4828 } 4829 4830 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num, 4831 int nb_sectors, QEMUIOVector *iov, 4832 bool is_write) 4833 { 4834 CoroutineIOCompletion co = { 4835 .coroutine = qemu_coroutine_self(), 4836 }; 4837 BlockDriverAIOCB *acb; 4838 4839 if (is_write) { 4840 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors, 4841 bdrv_co_io_em_complete, &co); 4842 } else { 4843 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors, 4844 bdrv_co_io_em_complete, &co); 4845 } 4846 4847 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb); 4848 if (!acb) { 4849 return -EIO; 4850 } 4851 qemu_coroutine_yield(); 4852 4853 return co.ret; 4854 } 4855 4856 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs, 4857 int64_t sector_num, int nb_sectors, 4858 QEMUIOVector *iov) 4859 { 4860 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false); 4861 } 4862 4863 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs, 4864 int64_t sector_num, int nb_sectors, 4865 QEMUIOVector *iov) 4866 { 4867 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true); 4868 } 4869 4870 static void coroutine_fn bdrv_flush_co_entry(void *opaque) 4871 { 4872 RwCo *rwco = opaque; 4873 4874 rwco->ret = bdrv_co_flush(rwco->bs); 4875 } 4876 4877 int coroutine_fn bdrv_co_flush(BlockDriverState *bs) 4878 { 4879 int ret; 4880 4881 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) { 4882 return 0; 4883 } 4884 4885 /* Write back cached data to the OS even with cache=unsafe */ 4886 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_OS); 4887 if (bs->drv->bdrv_co_flush_to_os) { 4888 ret = bs->drv->bdrv_co_flush_to_os(bs); 4889 if (ret < 0) { 4890 return ret; 4891 } 4892 } 4893 4894 /* But don't actually force it to the disk with cache=unsafe */ 4895 if (bs->open_flags & BDRV_O_NO_FLUSH) { 4896 goto flush_parent; 4897 } 4898 4899 BLKDBG_EVENT(bs->file, BLKDBG_FLUSH_TO_DISK); 4900 if (bs->drv->bdrv_co_flush_to_disk) { 4901 ret = bs->drv->bdrv_co_flush_to_disk(bs); 4902 } else if (bs->drv->bdrv_aio_flush) { 4903 BlockDriverAIOCB *acb; 4904 CoroutineIOCompletion co = { 4905 .coroutine = qemu_coroutine_self(), 4906 }; 4907 4908 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co); 4909 if (acb == NULL) { 4910 ret = -EIO; 4911 } else { 4912 qemu_coroutine_yield(); 4913 ret = co.ret; 4914 } 4915 } else { 4916 /* 4917 * Some block drivers always operate in either writethrough or unsafe 4918 * mode and don't support bdrv_flush therefore. Usually qemu doesn't 4919 * know how the server works (because the behaviour is hardcoded or 4920 * depends on server-side configuration), so we can't ensure that 4921 * everything is safe on disk. Returning an error doesn't work because 4922 * that would break guests even if the server operates in writethrough 4923 * mode. 4924 * 4925 * Let's hope the user knows what he's doing. 4926 */ 4927 ret = 0; 4928 } 4929 if (ret < 0) { 4930 return ret; 4931 } 4932 4933 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH 4934 * in the case of cache=unsafe, so there are no useless flushes. 4935 */ 4936 flush_parent: 4937 return bdrv_co_flush(bs->file); 4938 } 4939 4940 void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 4941 { 4942 Error *local_err = NULL; 4943 int ret; 4944 4945 if (!bs->drv) { 4946 return; 4947 } 4948 4949 if (bs->drv->bdrv_invalidate_cache) { 4950 bs->drv->bdrv_invalidate_cache(bs, &local_err); 4951 } else if (bs->file) { 4952 bdrv_invalidate_cache(bs->file, &local_err); 4953 } 4954 if (local_err) { 4955 error_propagate(errp, local_err); 4956 return; 4957 } 4958 4959 ret = refresh_total_sectors(bs, bs->total_sectors); 4960 if (ret < 0) { 4961 error_setg_errno(errp, -ret, "Could not refresh total sector count"); 4962 return; 4963 } 4964 } 4965 4966 void bdrv_invalidate_cache_all(Error **errp) 4967 { 4968 BlockDriverState *bs; 4969 Error *local_err = NULL; 4970 4971 QTAILQ_FOREACH(bs, &bdrv_states, device_list) { 4972 AioContext *aio_context = bdrv_get_aio_context(bs); 4973 4974 aio_context_acquire(aio_context); 4975 bdrv_invalidate_cache(bs, &local_err); 4976 aio_context_release(aio_context); 4977 if (local_err) { 4978 error_propagate(errp, local_err); 4979 return; 4980 } 4981 } 4982 } 4983 4984 void bdrv_clear_incoming_migration_all(void) 4985 { 4986 BlockDriverState *bs; 4987 4988 QTAILQ_FOREACH(bs, &bdrv_states, device_list) { 4989 AioContext *aio_context = bdrv_get_aio_context(bs); 4990 4991 aio_context_acquire(aio_context); 4992 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING); 4993 aio_context_release(aio_context); 4994 } 4995 } 4996 4997 int bdrv_flush(BlockDriverState *bs) 4998 { 4999 Coroutine *co; 5000 RwCo rwco = { 5001 .bs = bs, 5002 .ret = NOT_DONE, 5003 }; 5004 5005 if (qemu_in_coroutine()) { 5006 /* Fast-path if already in coroutine context */ 5007 bdrv_flush_co_entry(&rwco); 5008 } else { 5009 AioContext *aio_context = bdrv_get_aio_context(bs); 5010 5011 co = qemu_coroutine_create(bdrv_flush_co_entry); 5012 qemu_coroutine_enter(co, &rwco); 5013 while (rwco.ret == NOT_DONE) { 5014 aio_poll(aio_context, true); 5015 } 5016 } 5017 5018 return rwco.ret; 5019 } 5020 5021 typedef struct DiscardCo { 5022 BlockDriverState *bs; 5023 int64_t sector_num; 5024 int nb_sectors; 5025 int ret; 5026 } DiscardCo; 5027 static void coroutine_fn bdrv_discard_co_entry(void *opaque) 5028 { 5029 DiscardCo *rwco = opaque; 5030 5031 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors); 5032 } 5033 5034 /* if no limit is specified in the BlockLimits use a default 5035 * of 32768 512-byte sectors (16 MiB) per request. 5036 */ 5037 #define MAX_DISCARD_DEFAULT 32768 5038 5039 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, 5040 int nb_sectors) 5041 { 5042 int max_discard; 5043 5044 if (!bs->drv) { 5045 return -ENOMEDIUM; 5046 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) { 5047 return -EIO; 5048 } else if (bs->read_only) { 5049 return -EROFS; 5050 } 5051 5052 bdrv_reset_dirty(bs, sector_num, nb_sectors); 5053 5054 /* Do nothing if disabled. */ 5055 if (!(bs->open_flags & BDRV_O_UNMAP)) { 5056 return 0; 5057 } 5058 5059 if (!bs->drv->bdrv_co_discard && !bs->drv->bdrv_aio_discard) { 5060 return 0; 5061 } 5062 5063 max_discard = bs->bl.max_discard ? bs->bl.max_discard : MAX_DISCARD_DEFAULT; 5064 while (nb_sectors > 0) { 5065 int ret; 5066 int num = nb_sectors; 5067 5068 /* align request */ 5069 if (bs->bl.discard_alignment && 5070 num >= bs->bl.discard_alignment && 5071 sector_num % bs->bl.discard_alignment) { 5072 if (num > bs->bl.discard_alignment) { 5073 num = bs->bl.discard_alignment; 5074 } 5075 num -= sector_num % bs->bl.discard_alignment; 5076 } 5077 5078 /* limit request size */ 5079 if (num > max_discard) { 5080 num = max_discard; 5081 } 5082 5083 if (bs->drv->bdrv_co_discard) { 5084 ret = bs->drv->bdrv_co_discard(bs, sector_num, num); 5085 } else { 5086 BlockDriverAIOCB *acb; 5087 CoroutineIOCompletion co = { 5088 .coroutine = qemu_coroutine_self(), 5089 }; 5090 5091 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors, 5092 bdrv_co_io_em_complete, &co); 5093 if (acb == NULL) { 5094 return -EIO; 5095 } else { 5096 qemu_coroutine_yield(); 5097 ret = co.ret; 5098 } 5099 } 5100 if (ret && ret != -ENOTSUP) { 5101 return ret; 5102 } 5103 5104 sector_num += num; 5105 nb_sectors -= num; 5106 } 5107 return 0; 5108 } 5109 5110 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors) 5111 { 5112 Coroutine *co; 5113 DiscardCo rwco = { 5114 .bs = bs, 5115 .sector_num = sector_num, 5116 .nb_sectors = nb_sectors, 5117 .ret = NOT_DONE, 5118 }; 5119 5120 if (qemu_in_coroutine()) { 5121 /* Fast-path if already in coroutine context */ 5122 bdrv_discard_co_entry(&rwco); 5123 } else { 5124 AioContext *aio_context = bdrv_get_aio_context(bs); 5125 5126 co = qemu_coroutine_create(bdrv_discard_co_entry); 5127 qemu_coroutine_enter(co, &rwco); 5128 while (rwco.ret == NOT_DONE) { 5129 aio_poll(aio_context, true); 5130 } 5131 } 5132 5133 return rwco.ret; 5134 } 5135 5136 /**************************************************************/ 5137 /* removable device support */ 5138 5139 /** 5140 * Return TRUE if the media is present 5141 */ 5142 int bdrv_is_inserted(BlockDriverState *bs) 5143 { 5144 BlockDriver *drv = bs->drv; 5145 5146 if (!drv) 5147 return 0; 5148 if (!drv->bdrv_is_inserted) 5149 return 1; 5150 return drv->bdrv_is_inserted(bs); 5151 } 5152 5153 /** 5154 * Return whether the media changed since the last call to this 5155 * function, or -ENOTSUP if we don't know. Most drivers don't know. 5156 */ 5157 int bdrv_media_changed(BlockDriverState *bs) 5158 { 5159 BlockDriver *drv = bs->drv; 5160 5161 if (drv && drv->bdrv_media_changed) { 5162 return drv->bdrv_media_changed(bs); 5163 } 5164 return -ENOTSUP; 5165 } 5166 5167 /** 5168 * If eject_flag is TRUE, eject the media. Otherwise, close the tray 5169 */ 5170 void bdrv_eject(BlockDriverState *bs, bool eject_flag) 5171 { 5172 BlockDriver *drv = bs->drv; 5173 5174 if (drv && drv->bdrv_eject) { 5175 drv->bdrv_eject(bs, eject_flag); 5176 } 5177 5178 if (bs->device_name[0] != '\0') { 5179 qapi_event_send_device_tray_moved(bdrv_get_device_name(bs), 5180 eject_flag, &error_abort); 5181 } 5182 } 5183 5184 /** 5185 * Lock or unlock the media (if it is locked, the user won't be able 5186 * to eject it manually). 5187 */ 5188 void bdrv_lock_medium(BlockDriverState *bs, bool locked) 5189 { 5190 BlockDriver *drv = bs->drv; 5191 5192 trace_bdrv_lock_medium(bs, locked); 5193 5194 if (drv && drv->bdrv_lock_medium) { 5195 drv->bdrv_lock_medium(bs, locked); 5196 } 5197 } 5198 5199 /* needed for generic scsi interface */ 5200 5201 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) 5202 { 5203 BlockDriver *drv = bs->drv; 5204 5205 if (drv && drv->bdrv_ioctl) 5206 return drv->bdrv_ioctl(bs, req, buf); 5207 return -ENOTSUP; 5208 } 5209 5210 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, 5211 unsigned long int req, void *buf, 5212 BlockDriverCompletionFunc *cb, void *opaque) 5213 { 5214 BlockDriver *drv = bs->drv; 5215 5216 if (drv && drv->bdrv_aio_ioctl) 5217 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque); 5218 return NULL; 5219 } 5220 5221 void bdrv_set_guest_block_size(BlockDriverState *bs, int align) 5222 { 5223 bs->guest_block_size = align; 5224 } 5225 5226 void *qemu_blockalign(BlockDriverState *bs, size_t size) 5227 { 5228 return qemu_memalign(bdrv_opt_mem_align(bs), size); 5229 } 5230 5231 /* 5232 * Check if all memory in this vector is sector aligned. 5233 */ 5234 bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov) 5235 { 5236 int i; 5237 size_t alignment = bdrv_opt_mem_align(bs); 5238 5239 for (i = 0; i < qiov->niov; i++) { 5240 if ((uintptr_t) qiov->iov[i].iov_base % alignment) { 5241 return false; 5242 } 5243 if (qiov->iov[i].iov_len % alignment) { 5244 return false; 5245 } 5246 } 5247 5248 return true; 5249 } 5250 5251 BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity, 5252 Error **errp) 5253 { 5254 int64_t bitmap_size; 5255 BdrvDirtyBitmap *bitmap; 5256 5257 assert((granularity & (granularity - 1)) == 0); 5258 5259 granularity >>= BDRV_SECTOR_BITS; 5260 assert(granularity); 5261 bitmap_size = bdrv_getlength(bs); 5262 if (bitmap_size < 0) { 5263 error_setg_errno(errp, -bitmap_size, "could not get length of device"); 5264 errno = -bitmap_size; 5265 return NULL; 5266 } 5267 bitmap_size >>= BDRV_SECTOR_BITS; 5268 bitmap = g_malloc0(sizeof(BdrvDirtyBitmap)); 5269 bitmap->bitmap = hbitmap_alloc(bitmap_size, ffs(granularity) - 1); 5270 QLIST_INSERT_HEAD(&bs->dirty_bitmaps, bitmap, list); 5271 return bitmap; 5272 } 5273 5274 void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap) 5275 { 5276 BdrvDirtyBitmap *bm, *next; 5277 QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) { 5278 if (bm == bitmap) { 5279 QLIST_REMOVE(bitmap, list); 5280 hbitmap_free(bitmap->bitmap); 5281 g_free(bitmap); 5282 return; 5283 } 5284 } 5285 } 5286 5287 BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs) 5288 { 5289 BdrvDirtyBitmap *bm; 5290 BlockDirtyInfoList *list = NULL; 5291 BlockDirtyInfoList **plist = &list; 5292 5293 QLIST_FOREACH(bm, &bs->dirty_bitmaps, list) { 5294 BlockDirtyInfo *info = g_malloc0(sizeof(BlockDirtyInfo)); 5295 BlockDirtyInfoList *entry = g_malloc0(sizeof(BlockDirtyInfoList)); 5296 info->count = bdrv_get_dirty_count(bs, bm); 5297 info->granularity = 5298 ((int64_t) BDRV_SECTOR_SIZE << hbitmap_granularity(bm->bitmap)); 5299 entry->value = info; 5300 *plist = entry; 5301 plist = &entry->next; 5302 } 5303 5304 return list; 5305 } 5306 5307 int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector) 5308 { 5309 if (bitmap) { 5310 return hbitmap_get(bitmap->bitmap, sector); 5311 } else { 5312 return 0; 5313 } 5314 } 5315 5316 void bdrv_dirty_iter_init(BlockDriverState *bs, 5317 BdrvDirtyBitmap *bitmap, HBitmapIter *hbi) 5318 { 5319 hbitmap_iter_init(hbi, bitmap->bitmap, 0); 5320 } 5321 5322 void bdrv_set_dirty(BlockDriverState *bs, int64_t cur_sector, 5323 int nr_sectors) 5324 { 5325 BdrvDirtyBitmap *bitmap; 5326 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) { 5327 hbitmap_set(bitmap->bitmap, cur_sector, nr_sectors); 5328 } 5329 } 5330 5331 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, int nr_sectors) 5332 { 5333 BdrvDirtyBitmap *bitmap; 5334 QLIST_FOREACH(bitmap, &bs->dirty_bitmaps, list) { 5335 hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors); 5336 } 5337 } 5338 5339 int64_t bdrv_get_dirty_count(BlockDriverState *bs, BdrvDirtyBitmap *bitmap) 5340 { 5341 return hbitmap_count(bitmap->bitmap); 5342 } 5343 5344 /* Get a reference to bs */ 5345 void bdrv_ref(BlockDriverState *bs) 5346 { 5347 bs->refcnt++; 5348 } 5349 5350 /* Release a previously grabbed reference to bs. 5351 * If after releasing, reference count is zero, the BlockDriverState is 5352 * deleted. */ 5353 void bdrv_unref(BlockDriverState *bs) 5354 { 5355 assert(bs->refcnt > 0); 5356 if (--bs->refcnt == 0) { 5357 bdrv_delete(bs); 5358 } 5359 } 5360 5361 struct BdrvOpBlocker { 5362 Error *reason; 5363 QLIST_ENTRY(BdrvOpBlocker) list; 5364 }; 5365 5366 bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp) 5367 { 5368 BdrvOpBlocker *blocker; 5369 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 5370 if (!QLIST_EMPTY(&bs->op_blockers[op])) { 5371 blocker = QLIST_FIRST(&bs->op_blockers[op]); 5372 if (errp) { 5373 error_setg(errp, "Device '%s' is busy: %s", 5374 bs->device_name, error_get_pretty(blocker->reason)); 5375 } 5376 return true; 5377 } 5378 return false; 5379 } 5380 5381 void bdrv_op_block(BlockDriverState *bs, BlockOpType op, Error *reason) 5382 { 5383 BdrvOpBlocker *blocker; 5384 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 5385 5386 blocker = g_malloc0(sizeof(BdrvOpBlocker)); 5387 blocker->reason = reason; 5388 QLIST_INSERT_HEAD(&bs->op_blockers[op], blocker, list); 5389 } 5390 5391 void bdrv_op_unblock(BlockDriverState *bs, BlockOpType op, Error *reason) 5392 { 5393 BdrvOpBlocker *blocker, *next; 5394 assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX); 5395 QLIST_FOREACH_SAFE(blocker, &bs->op_blockers[op], list, next) { 5396 if (blocker->reason == reason) { 5397 QLIST_REMOVE(blocker, list); 5398 g_free(blocker); 5399 } 5400 } 5401 } 5402 5403 void bdrv_op_block_all(BlockDriverState *bs, Error *reason) 5404 { 5405 int i; 5406 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 5407 bdrv_op_block(bs, i, reason); 5408 } 5409 } 5410 5411 void bdrv_op_unblock_all(BlockDriverState *bs, Error *reason) 5412 { 5413 int i; 5414 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 5415 bdrv_op_unblock(bs, i, reason); 5416 } 5417 } 5418 5419 bool bdrv_op_blocker_is_empty(BlockDriverState *bs) 5420 { 5421 int i; 5422 5423 for (i = 0; i < BLOCK_OP_TYPE_MAX; i++) { 5424 if (!QLIST_EMPTY(&bs->op_blockers[i])) { 5425 return false; 5426 } 5427 } 5428 return true; 5429 } 5430 5431 void bdrv_iostatus_enable(BlockDriverState *bs) 5432 { 5433 bs->iostatus_enabled = true; 5434 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK; 5435 } 5436 5437 /* The I/O status is only enabled if the drive explicitly 5438 * enables it _and_ the VM is configured to stop on errors */ 5439 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs) 5440 { 5441 return (bs->iostatus_enabled && 5442 (bs->on_write_error == BLOCKDEV_ON_ERROR_ENOSPC || 5443 bs->on_write_error == BLOCKDEV_ON_ERROR_STOP || 5444 bs->on_read_error == BLOCKDEV_ON_ERROR_STOP)); 5445 } 5446 5447 void bdrv_iostatus_disable(BlockDriverState *bs) 5448 { 5449 bs->iostatus_enabled = false; 5450 } 5451 5452 void bdrv_iostatus_reset(BlockDriverState *bs) 5453 { 5454 if (bdrv_iostatus_is_enabled(bs)) { 5455 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK; 5456 if (bs->job) { 5457 block_job_iostatus_reset(bs->job); 5458 } 5459 } 5460 } 5461 5462 void bdrv_iostatus_set_err(BlockDriverState *bs, int error) 5463 { 5464 assert(bdrv_iostatus_is_enabled(bs)); 5465 if (bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) { 5466 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE : 5467 BLOCK_DEVICE_IO_STATUS_FAILED; 5468 } 5469 } 5470 5471 void 5472 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes, 5473 enum BlockAcctType type) 5474 { 5475 assert(type < BDRV_MAX_IOTYPE); 5476 5477 cookie->bytes = bytes; 5478 cookie->start_time_ns = get_clock(); 5479 cookie->type = type; 5480 } 5481 5482 void 5483 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie) 5484 { 5485 assert(cookie->type < BDRV_MAX_IOTYPE); 5486 5487 bs->nr_bytes[cookie->type] += cookie->bytes; 5488 bs->nr_ops[cookie->type]++; 5489 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns; 5490 } 5491 5492 void bdrv_img_create(const char *filename, const char *fmt, 5493 const char *base_filename, const char *base_fmt, 5494 char *options, uint64_t img_size, int flags, 5495 Error **errp, bool quiet) 5496 { 5497 QemuOptsList *create_opts = NULL; 5498 QemuOpts *opts = NULL; 5499 const char *backing_fmt, *backing_file; 5500 int64_t size; 5501 BlockDriver *drv, *proto_drv; 5502 BlockDriver *backing_drv = NULL; 5503 Error *local_err = NULL; 5504 int ret = 0; 5505 5506 /* Find driver and parse its options */ 5507 drv = bdrv_find_format(fmt); 5508 if (!drv) { 5509 error_setg(errp, "Unknown file format '%s'", fmt); 5510 return; 5511 } 5512 5513 proto_drv = bdrv_find_protocol(filename, true); 5514 if (!proto_drv) { 5515 error_setg(errp, "Unknown protocol '%s'", filename); 5516 return; 5517 } 5518 5519 create_opts = qemu_opts_append(create_opts, drv->create_opts); 5520 create_opts = qemu_opts_append(create_opts, proto_drv->create_opts); 5521 5522 /* Create parameter list with default values */ 5523 opts = qemu_opts_create(create_opts, NULL, 0, &error_abort); 5524 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size); 5525 5526 /* Parse -o options */ 5527 if (options) { 5528 if (qemu_opts_do_parse(opts, options, NULL) != 0) { 5529 error_setg(errp, "Invalid options for file format '%s'", fmt); 5530 goto out; 5531 } 5532 } 5533 5534 if (base_filename) { 5535 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) { 5536 error_setg(errp, "Backing file not supported for file format '%s'", 5537 fmt); 5538 goto out; 5539 } 5540 } 5541 5542 if (base_fmt) { 5543 if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) { 5544 error_setg(errp, "Backing file format not supported for file " 5545 "format '%s'", fmt); 5546 goto out; 5547 } 5548 } 5549 5550 backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE); 5551 if (backing_file) { 5552 if (!strcmp(filename, backing_file)) { 5553 error_setg(errp, "Error: Trying to create an image with the " 5554 "same filename as the backing file"); 5555 goto out; 5556 } 5557 } 5558 5559 backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT); 5560 if (backing_fmt) { 5561 backing_drv = bdrv_find_format(backing_fmt); 5562 if (!backing_drv) { 5563 error_setg(errp, "Unknown backing file format '%s'", 5564 backing_fmt); 5565 goto out; 5566 } 5567 } 5568 5569 // The size for the image must always be specified, with one exception: 5570 // If we are using a backing file, we can obtain the size from there 5571 size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0); 5572 if (size == -1) { 5573 if (backing_file) { 5574 BlockDriverState *bs; 5575 uint64_t size; 5576 int back_flags; 5577 5578 /* backing files always opened read-only */ 5579 back_flags = 5580 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); 5581 5582 bs = NULL; 5583 ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags, 5584 backing_drv, &local_err); 5585 if (ret < 0) { 5586 error_setg_errno(errp, -ret, "Could not open '%s': %s", 5587 backing_file, 5588 error_get_pretty(local_err)); 5589 error_free(local_err); 5590 local_err = NULL; 5591 goto out; 5592 } 5593 bdrv_get_geometry(bs, &size); 5594 size *= 512; 5595 5596 qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size); 5597 5598 bdrv_unref(bs); 5599 } else { 5600 error_setg(errp, "Image creation needs a size parameter"); 5601 goto out; 5602 } 5603 } 5604 5605 if (!quiet) { 5606 printf("Formatting '%s', fmt=%s ", filename, fmt); 5607 qemu_opts_print(opts); 5608 puts(""); 5609 } 5610 5611 ret = bdrv_create(drv, filename, opts, &local_err); 5612 5613 if (ret == -EFBIG) { 5614 /* This is generally a better message than whatever the driver would 5615 * deliver (especially because of the cluster_size_hint), since that 5616 * is most probably not much different from "image too large". */ 5617 const char *cluster_size_hint = ""; 5618 if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) { 5619 cluster_size_hint = " (try using a larger cluster size)"; 5620 } 5621 error_setg(errp, "The image size is too large for file format '%s'" 5622 "%s", fmt, cluster_size_hint); 5623 error_free(local_err); 5624 local_err = NULL; 5625 } 5626 5627 out: 5628 qemu_opts_del(opts); 5629 qemu_opts_free(create_opts); 5630 if (local_err) { 5631 error_propagate(errp, local_err); 5632 } 5633 } 5634 5635 AioContext *bdrv_get_aio_context(BlockDriverState *bs) 5636 { 5637 return bs->aio_context; 5638 } 5639 5640 void bdrv_detach_aio_context(BlockDriverState *bs) 5641 { 5642 if (!bs->drv) { 5643 return; 5644 } 5645 5646 if (bs->io_limits_enabled) { 5647 throttle_detach_aio_context(&bs->throttle_state); 5648 } 5649 if (bs->drv->bdrv_detach_aio_context) { 5650 bs->drv->bdrv_detach_aio_context(bs); 5651 } 5652 if (bs->file) { 5653 bdrv_detach_aio_context(bs->file); 5654 } 5655 if (bs->backing_hd) { 5656 bdrv_detach_aio_context(bs->backing_hd); 5657 } 5658 5659 bs->aio_context = NULL; 5660 } 5661 5662 void bdrv_attach_aio_context(BlockDriverState *bs, 5663 AioContext *new_context) 5664 { 5665 if (!bs->drv) { 5666 return; 5667 } 5668 5669 bs->aio_context = new_context; 5670 5671 if (bs->backing_hd) { 5672 bdrv_attach_aio_context(bs->backing_hd, new_context); 5673 } 5674 if (bs->file) { 5675 bdrv_attach_aio_context(bs->file, new_context); 5676 } 5677 if (bs->drv->bdrv_attach_aio_context) { 5678 bs->drv->bdrv_attach_aio_context(bs, new_context); 5679 } 5680 if (bs->io_limits_enabled) { 5681 throttle_attach_aio_context(&bs->throttle_state, new_context); 5682 } 5683 } 5684 5685 void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context) 5686 { 5687 bdrv_drain_all(); /* ensure there are no in-flight requests */ 5688 5689 bdrv_detach_aio_context(bs); 5690 5691 /* This function executes in the old AioContext so acquire the new one in 5692 * case it runs in a different thread. 5693 */ 5694 aio_context_acquire(new_context); 5695 bdrv_attach_aio_context(bs, new_context); 5696 aio_context_release(new_context); 5697 } 5698 5699 void bdrv_add_before_write_notifier(BlockDriverState *bs, 5700 NotifierWithReturn *notifier) 5701 { 5702 notifier_with_return_list_add(&bs->before_write_notifiers, notifier); 5703 } 5704 5705 int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts) 5706 { 5707 if (!bs->drv->bdrv_amend_options) { 5708 return -ENOTSUP; 5709 } 5710 return bs->drv->bdrv_amend_options(bs, opts); 5711 } 5712 5713 /* This function will be called by the bdrv_recurse_is_first_non_filter method 5714 * of block filter and by bdrv_is_first_non_filter. 5715 * It is used to test if the given bs is the candidate or recurse more in the 5716 * node graph. 5717 */ 5718 bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs, 5719 BlockDriverState *candidate) 5720 { 5721 /* return false if basic checks fails */ 5722 if (!bs || !bs->drv) { 5723 return false; 5724 } 5725 5726 /* the code reached a non block filter driver -> check if the bs is 5727 * the same as the candidate. It's the recursion termination condition. 5728 */ 5729 if (!bs->drv->is_filter) { 5730 return bs == candidate; 5731 } 5732 /* Down this path the driver is a block filter driver */ 5733 5734 /* If the block filter recursion method is defined use it to recurse down 5735 * the node graph. 5736 */ 5737 if (bs->drv->bdrv_recurse_is_first_non_filter) { 5738 return bs->drv->bdrv_recurse_is_first_non_filter(bs, candidate); 5739 } 5740 5741 /* the driver is a block filter but don't allow to recurse -> return false 5742 */ 5743 return false; 5744 } 5745 5746 /* This function checks if the candidate is the first non filter bs down it's 5747 * bs chain. Since we don't have pointers to parents it explore all bs chains 5748 * from the top. Some filters can choose not to pass down the recursion. 5749 */ 5750 bool bdrv_is_first_non_filter(BlockDriverState *candidate) 5751 { 5752 BlockDriverState *bs; 5753 5754 /* walk down the bs forest recursively */ 5755 QTAILQ_FOREACH(bs, &bdrv_states, device_list) { 5756 bool perm; 5757 5758 /* try to recurse in this top level bs */ 5759 perm = bdrv_recurse_is_first_non_filter(bs, candidate); 5760 5761 /* candidate is the first non filter */ 5762 if (perm) { 5763 return true; 5764 } 5765 } 5766 5767 return false; 5768 } 5769