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