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 "monitor.h" 28 #include "block_int.h" 29 #include "module.h" 30 #include "qemu-objects.h" 31 32 #ifdef CONFIG_BSD 33 #include <sys/types.h> 34 #include <sys/stat.h> 35 #include <sys/ioctl.h> 36 #include <sys/queue.h> 37 #ifndef __DragonFly__ 38 #include <sys/disk.h> 39 #endif 40 #endif 41 42 #ifdef _WIN32 43 #include <windows.h> 44 #endif 45 46 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, 47 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 48 BlockDriverCompletionFunc *cb, void *opaque); 49 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, 50 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 51 BlockDriverCompletionFunc *cb, void *opaque); 52 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs, 53 BlockDriverCompletionFunc *cb, void *opaque); 54 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs, 55 BlockDriverCompletionFunc *cb, void *opaque); 56 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, 57 uint8_t *buf, int nb_sectors); 58 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num, 59 const uint8_t *buf, int nb_sectors); 60 61 static QTAILQ_HEAD(, BlockDriverState) bdrv_states = 62 QTAILQ_HEAD_INITIALIZER(bdrv_states); 63 64 static QLIST_HEAD(, BlockDriver) bdrv_drivers = 65 QLIST_HEAD_INITIALIZER(bdrv_drivers); 66 67 /* The device to use for VM snapshots */ 68 static BlockDriverState *bs_snapshots; 69 70 /* If non-zero, use only whitelisted block drivers */ 71 static int use_bdrv_whitelist; 72 73 int path_is_absolute(const char *path) 74 { 75 const char *p; 76 #ifdef _WIN32 77 /* specific case for names like: "\\.\d:" */ 78 if (*path == '/' || *path == '\\') 79 return 1; 80 #endif 81 p = strchr(path, ':'); 82 if (p) 83 p++; 84 else 85 p = path; 86 #ifdef _WIN32 87 return (*p == '/' || *p == '\\'); 88 #else 89 return (*p == '/'); 90 #endif 91 } 92 93 /* if filename is absolute, just copy it to dest. Otherwise, build a 94 path to it by considering it is relative to base_path. URL are 95 supported. */ 96 void path_combine(char *dest, int dest_size, 97 const char *base_path, 98 const char *filename) 99 { 100 const char *p, *p1; 101 int len; 102 103 if (dest_size <= 0) 104 return; 105 if (path_is_absolute(filename)) { 106 pstrcpy(dest, dest_size, filename); 107 } else { 108 p = strchr(base_path, ':'); 109 if (p) 110 p++; 111 else 112 p = base_path; 113 p1 = strrchr(base_path, '/'); 114 #ifdef _WIN32 115 { 116 const char *p2; 117 p2 = strrchr(base_path, '\\'); 118 if (!p1 || p2 > p1) 119 p1 = p2; 120 } 121 #endif 122 if (p1) 123 p1++; 124 else 125 p1 = base_path; 126 if (p1 > p) 127 p = p1; 128 len = p - base_path; 129 if (len > dest_size - 1) 130 len = dest_size - 1; 131 memcpy(dest, base_path, len); 132 dest[len] = '\0'; 133 pstrcat(dest, dest_size, filename); 134 } 135 } 136 137 void bdrv_register(BlockDriver *bdrv) 138 { 139 if (!bdrv->bdrv_aio_readv) { 140 /* add AIO emulation layer */ 141 bdrv->bdrv_aio_readv = bdrv_aio_readv_em; 142 bdrv->bdrv_aio_writev = bdrv_aio_writev_em; 143 } else if (!bdrv->bdrv_read) { 144 /* add synchronous IO emulation layer */ 145 bdrv->bdrv_read = bdrv_read_em; 146 bdrv->bdrv_write = bdrv_write_em; 147 } 148 149 if (!bdrv->bdrv_aio_flush) 150 bdrv->bdrv_aio_flush = bdrv_aio_flush_em; 151 152 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list); 153 } 154 155 /* create a new block device (by default it is empty) */ 156 BlockDriverState *bdrv_new(const char *device_name) 157 { 158 BlockDriverState *bs; 159 160 bs = qemu_mallocz(sizeof(BlockDriverState)); 161 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name); 162 if (device_name[0] != '\0') { 163 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list); 164 } 165 return bs; 166 } 167 168 BlockDriver *bdrv_find_format(const char *format_name) 169 { 170 BlockDriver *drv1; 171 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 172 if (!strcmp(drv1->format_name, format_name)) { 173 return drv1; 174 } 175 } 176 return NULL; 177 } 178 179 static int bdrv_is_whitelisted(BlockDriver *drv) 180 { 181 static const char *whitelist[] = { 182 CONFIG_BDRV_WHITELIST 183 }; 184 const char **p; 185 186 if (!whitelist[0]) 187 return 1; /* no whitelist, anything goes */ 188 189 for (p = whitelist; *p; p++) { 190 if (!strcmp(drv->format_name, *p)) { 191 return 1; 192 } 193 } 194 return 0; 195 } 196 197 BlockDriver *bdrv_find_whitelisted_format(const char *format_name) 198 { 199 BlockDriver *drv = bdrv_find_format(format_name); 200 return drv && bdrv_is_whitelisted(drv) ? drv : NULL; 201 } 202 203 int bdrv_create(BlockDriver *drv, const char* filename, 204 QEMUOptionParameter *options) 205 { 206 if (!drv->bdrv_create) 207 return -ENOTSUP; 208 209 return drv->bdrv_create(filename, options); 210 } 211 212 int bdrv_create_file(const char* filename, QEMUOptionParameter *options) 213 { 214 BlockDriver *drv; 215 216 drv = bdrv_find_protocol(filename); 217 if (drv == NULL) { 218 drv = bdrv_find_format("file"); 219 } 220 221 return bdrv_create(drv, filename, options); 222 } 223 224 #ifdef _WIN32 225 void get_tmp_filename(char *filename, int size) 226 { 227 char temp_dir[MAX_PATH]; 228 229 GetTempPath(MAX_PATH, temp_dir); 230 GetTempFileName(temp_dir, "qem", 0, filename); 231 } 232 #else 233 void get_tmp_filename(char *filename, int size) 234 { 235 int fd; 236 const char *tmpdir; 237 /* XXX: race condition possible */ 238 tmpdir = getenv("TMPDIR"); 239 if (!tmpdir) 240 tmpdir = "/tmp"; 241 snprintf(filename, size, "%s/vl.XXXXXX", tmpdir); 242 fd = mkstemp(filename); 243 close(fd); 244 } 245 #endif 246 247 #ifdef _WIN32 248 static int is_windows_drive_prefix(const char *filename) 249 { 250 return (((filename[0] >= 'a' && filename[0] <= 'z') || 251 (filename[0] >= 'A' && filename[0] <= 'Z')) && 252 filename[1] == ':'); 253 } 254 255 int is_windows_drive(const char *filename) 256 { 257 if (is_windows_drive_prefix(filename) && 258 filename[2] == '\0') 259 return 1; 260 if (strstart(filename, "\\\\.\\", NULL) || 261 strstart(filename, "//./", NULL)) 262 return 1; 263 return 0; 264 } 265 #endif 266 267 /* 268 * Detect host devices. By convention, /dev/cdrom[N] is always 269 * recognized as a host CDROM. 270 */ 271 static BlockDriver *find_hdev_driver(const char *filename) 272 { 273 int score_max = 0, score; 274 BlockDriver *drv = NULL, *d; 275 276 QLIST_FOREACH(d, &bdrv_drivers, list) { 277 if (d->bdrv_probe_device) { 278 score = d->bdrv_probe_device(filename); 279 if (score > score_max) { 280 score_max = score; 281 drv = d; 282 } 283 } 284 } 285 286 return drv; 287 } 288 289 BlockDriver *bdrv_find_protocol(const char *filename) 290 { 291 BlockDriver *drv1; 292 char protocol[128]; 293 int len; 294 const char *p; 295 296 /* TODO Drivers without bdrv_file_open must be specified explicitly */ 297 298 /* 299 * XXX(hch): we really should not let host device detection 300 * override an explicit protocol specification, but moving this 301 * later breaks access to device names with colons in them. 302 * Thanks to the brain-dead persistent naming schemes on udev- 303 * based Linux systems those actually are quite common. 304 */ 305 drv1 = find_hdev_driver(filename); 306 if (drv1) { 307 return drv1; 308 } 309 310 #ifdef _WIN32 311 if (is_windows_drive(filename) || 312 is_windows_drive_prefix(filename)) 313 return bdrv_find_format("file"); 314 #endif 315 316 p = strchr(filename, ':'); 317 if (!p) { 318 return bdrv_find_format("file"); 319 } 320 len = p - filename; 321 if (len > sizeof(protocol) - 1) 322 len = sizeof(protocol) - 1; 323 memcpy(protocol, filename, len); 324 protocol[len] = '\0'; 325 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 326 if (drv1->protocol_name && 327 !strcmp(drv1->protocol_name, protocol)) { 328 return drv1; 329 } 330 } 331 return NULL; 332 } 333 334 static int find_image_format(const char *filename, BlockDriver **pdrv) 335 { 336 int ret, score, score_max; 337 BlockDriver *drv1, *drv; 338 uint8_t buf[2048]; 339 BlockDriverState *bs; 340 341 ret = bdrv_file_open(&bs, filename, 0); 342 if (ret < 0) { 343 *pdrv = NULL; 344 return ret; 345 } 346 347 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */ 348 if (bs->sg || !bdrv_is_inserted(bs)) { 349 bdrv_delete(bs); 350 drv = bdrv_find_format("raw"); 351 if (!drv) { 352 ret = -ENOENT; 353 } 354 *pdrv = drv; 355 return ret; 356 } 357 358 ret = bdrv_pread(bs, 0, buf, sizeof(buf)); 359 bdrv_delete(bs); 360 if (ret < 0) { 361 *pdrv = NULL; 362 return ret; 363 } 364 365 score_max = 0; 366 drv = NULL; 367 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 368 if (drv1->bdrv_probe) { 369 score = drv1->bdrv_probe(buf, ret, filename); 370 if (score > score_max) { 371 score_max = score; 372 drv = drv1; 373 } 374 } 375 } 376 if (!drv) { 377 ret = -ENOENT; 378 } 379 *pdrv = drv; 380 return ret; 381 } 382 383 /** 384 * Set the current 'total_sectors' value 385 */ 386 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint) 387 { 388 BlockDriver *drv = bs->drv; 389 390 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */ 391 if (bs->sg) 392 return 0; 393 394 /* query actual device if possible, otherwise just trust the hint */ 395 if (drv->bdrv_getlength) { 396 int64_t length = drv->bdrv_getlength(bs); 397 if (length < 0) { 398 return length; 399 } 400 hint = length >> BDRV_SECTOR_BITS; 401 } 402 403 bs->total_sectors = hint; 404 return 0; 405 } 406 407 /* 408 * Common part for opening disk images and files 409 */ 410 static int bdrv_open_common(BlockDriverState *bs, const char *filename, 411 int flags, BlockDriver *drv) 412 { 413 int ret, open_flags; 414 415 assert(drv != NULL); 416 417 bs->file = NULL; 418 bs->total_sectors = 0; 419 bs->encrypted = 0; 420 bs->valid_key = 0; 421 bs->open_flags = flags; 422 /* buffer_alignment defaulted to 512, drivers can change this value */ 423 bs->buffer_alignment = 512; 424 425 pstrcpy(bs->filename, sizeof(bs->filename), filename); 426 427 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) { 428 return -ENOTSUP; 429 } 430 431 bs->drv = drv; 432 bs->opaque = qemu_mallocz(drv->instance_size); 433 434 /* 435 * Yes, BDRV_O_NOCACHE aka O_DIRECT means we have to present a 436 * write cache to the guest. We do need the fdatasync to flush 437 * out transactions for block allocations, and we maybe have a 438 * volatile write cache in our backing device to deal with. 439 */ 440 if (flags & (BDRV_O_CACHE_WB|BDRV_O_NOCACHE)) 441 bs->enable_write_cache = 1; 442 443 /* 444 * Clear flags that are internal to the block layer before opening the 445 * image. 446 */ 447 open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); 448 449 /* 450 * Snapshots should be writeable. 451 */ 452 if (bs->is_temporary) { 453 open_flags |= BDRV_O_RDWR; 454 } 455 456 /* Open the image, either directly or using a protocol */ 457 if (drv->bdrv_file_open) { 458 ret = drv->bdrv_file_open(bs, filename, open_flags); 459 } else { 460 ret = bdrv_file_open(&bs->file, filename, open_flags); 461 if (ret >= 0) { 462 ret = drv->bdrv_open(bs, open_flags); 463 } 464 } 465 466 if (ret < 0) { 467 goto free_and_fail; 468 } 469 470 bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR); 471 472 ret = refresh_total_sectors(bs, bs->total_sectors); 473 if (ret < 0) { 474 goto free_and_fail; 475 } 476 477 #ifndef _WIN32 478 if (bs->is_temporary) { 479 unlink(filename); 480 } 481 #endif 482 return 0; 483 484 free_and_fail: 485 if (bs->file) { 486 bdrv_delete(bs->file); 487 bs->file = NULL; 488 } 489 qemu_free(bs->opaque); 490 bs->opaque = NULL; 491 bs->drv = NULL; 492 return ret; 493 } 494 495 /* 496 * Opens a file using a protocol (file, host_device, nbd, ...) 497 */ 498 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags) 499 { 500 BlockDriverState *bs; 501 BlockDriver *drv; 502 int ret; 503 504 drv = bdrv_find_protocol(filename); 505 if (!drv) { 506 return -ENOENT; 507 } 508 509 bs = bdrv_new(""); 510 ret = bdrv_open_common(bs, filename, flags, drv); 511 if (ret < 0) { 512 bdrv_delete(bs); 513 return ret; 514 } 515 bs->growable = 1; 516 *pbs = bs; 517 return 0; 518 } 519 520 /* 521 * Opens a disk image (raw, qcow2, vmdk, ...) 522 */ 523 int bdrv_open(BlockDriverState *bs, const char *filename, int flags, 524 BlockDriver *drv) 525 { 526 int ret; 527 528 if (flags & BDRV_O_SNAPSHOT) { 529 BlockDriverState *bs1; 530 int64_t total_size; 531 int is_protocol = 0; 532 BlockDriver *bdrv_qcow2; 533 QEMUOptionParameter *options; 534 char tmp_filename[PATH_MAX]; 535 char backing_filename[PATH_MAX]; 536 537 /* if snapshot, we create a temporary backing file and open it 538 instead of opening 'filename' directly */ 539 540 /* if there is a backing file, use it */ 541 bs1 = bdrv_new(""); 542 ret = bdrv_open(bs1, filename, 0, drv); 543 if (ret < 0) { 544 bdrv_delete(bs1); 545 return ret; 546 } 547 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK; 548 549 if (bs1->drv && bs1->drv->protocol_name) 550 is_protocol = 1; 551 552 bdrv_delete(bs1); 553 554 get_tmp_filename(tmp_filename, sizeof(tmp_filename)); 555 556 /* Real path is meaningless for protocols */ 557 if (is_protocol) 558 snprintf(backing_filename, sizeof(backing_filename), 559 "%s", filename); 560 else if (!realpath(filename, backing_filename)) 561 return -errno; 562 563 bdrv_qcow2 = bdrv_find_format("qcow2"); 564 options = parse_option_parameters("", bdrv_qcow2->create_options, NULL); 565 566 set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size); 567 set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename); 568 if (drv) { 569 set_option_parameter(options, BLOCK_OPT_BACKING_FMT, 570 drv->format_name); 571 } 572 573 ret = bdrv_create(bdrv_qcow2, tmp_filename, options); 574 free_option_parameters(options); 575 if (ret < 0) { 576 return ret; 577 } 578 579 filename = tmp_filename; 580 drv = bdrv_qcow2; 581 bs->is_temporary = 1; 582 } 583 584 /* Find the right image format driver */ 585 if (!drv) { 586 ret = find_image_format(filename, &drv); 587 } 588 589 if (!drv) { 590 goto unlink_and_fail; 591 } 592 593 /* Open the image */ 594 ret = bdrv_open_common(bs, filename, flags, drv); 595 if (ret < 0) { 596 goto unlink_and_fail; 597 } 598 599 /* If there is a backing file, use it */ 600 if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') { 601 char backing_filename[PATH_MAX]; 602 int back_flags; 603 BlockDriver *back_drv = NULL; 604 605 bs->backing_hd = bdrv_new(""); 606 path_combine(backing_filename, sizeof(backing_filename), 607 filename, bs->backing_file); 608 if (bs->backing_format[0] != '\0') 609 back_drv = bdrv_find_format(bs->backing_format); 610 611 /* backing files always opened read-only */ 612 back_flags = 613 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); 614 615 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv); 616 if (ret < 0) { 617 bdrv_close(bs); 618 return ret; 619 } 620 if (bs->is_temporary) { 621 bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR); 622 } else { 623 /* base image inherits from "parent" */ 624 bs->backing_hd->keep_read_only = bs->keep_read_only; 625 } 626 } 627 628 if (!bdrv_key_required(bs)) { 629 /* call the change callback */ 630 bs->media_changed = 1; 631 if (bs->change_cb) 632 bs->change_cb(bs->change_opaque); 633 } 634 635 return 0; 636 637 unlink_and_fail: 638 if (bs->is_temporary) { 639 unlink(filename); 640 } 641 return ret; 642 } 643 644 void bdrv_close(BlockDriverState *bs) 645 { 646 if (bs->drv) { 647 if (bs == bs_snapshots) { 648 bs_snapshots = NULL; 649 } 650 if (bs->backing_hd) { 651 bdrv_delete(bs->backing_hd); 652 bs->backing_hd = NULL; 653 } 654 bs->drv->bdrv_close(bs); 655 qemu_free(bs->opaque); 656 #ifdef _WIN32 657 if (bs->is_temporary) { 658 unlink(bs->filename); 659 } 660 #endif 661 bs->opaque = NULL; 662 bs->drv = NULL; 663 664 if (bs->file != NULL) { 665 bdrv_close(bs->file); 666 } 667 668 /* call the change callback */ 669 bs->media_changed = 1; 670 if (bs->change_cb) 671 bs->change_cb(bs->change_opaque); 672 } 673 } 674 675 void bdrv_close_all(void) 676 { 677 BlockDriverState *bs; 678 679 QTAILQ_FOREACH(bs, &bdrv_states, list) { 680 bdrv_close(bs); 681 } 682 } 683 684 void bdrv_delete(BlockDriverState *bs) 685 { 686 assert(!bs->peer); 687 688 /* remove from list, if necessary */ 689 if (bs->device_name[0] != '\0') { 690 QTAILQ_REMOVE(&bdrv_states, bs, list); 691 } 692 693 bdrv_close(bs); 694 if (bs->file != NULL) { 695 bdrv_delete(bs->file); 696 } 697 698 assert(bs != bs_snapshots); 699 qemu_free(bs); 700 } 701 702 int bdrv_attach(BlockDriverState *bs, DeviceState *qdev) 703 { 704 if (bs->peer) { 705 return -EBUSY; 706 } 707 bs->peer = qdev; 708 return 0; 709 } 710 711 void bdrv_detach(BlockDriverState *bs, DeviceState *qdev) 712 { 713 assert(bs->peer == qdev); 714 bs->peer = NULL; 715 } 716 717 DeviceState *bdrv_get_attached(BlockDriverState *bs) 718 { 719 return bs->peer; 720 } 721 722 /* 723 * Run consistency checks on an image 724 * 725 * Returns 0 if the check could be completed (it doesn't mean that the image is 726 * free of errors) or -errno when an internal error occured. The results of the 727 * check are stored in res. 728 */ 729 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res) 730 { 731 if (bs->drv->bdrv_check == NULL) { 732 return -ENOTSUP; 733 } 734 735 memset(res, 0, sizeof(*res)); 736 return bs->drv->bdrv_check(bs, res); 737 } 738 739 #define COMMIT_BUF_SECTORS 2048 740 741 /* commit COW file into the raw image */ 742 int bdrv_commit(BlockDriverState *bs) 743 { 744 BlockDriver *drv = bs->drv; 745 BlockDriver *backing_drv; 746 int64_t sector, total_sectors; 747 int n, ro, open_flags; 748 int ret = 0, rw_ret = 0; 749 uint8_t *buf; 750 char filename[1024]; 751 BlockDriverState *bs_rw, *bs_ro; 752 753 if (!drv) 754 return -ENOMEDIUM; 755 756 if (!bs->backing_hd) { 757 return -ENOTSUP; 758 } 759 760 if (bs->backing_hd->keep_read_only) { 761 return -EACCES; 762 } 763 764 backing_drv = bs->backing_hd->drv; 765 ro = bs->backing_hd->read_only; 766 strncpy(filename, bs->backing_hd->filename, sizeof(filename)); 767 open_flags = bs->backing_hd->open_flags; 768 769 if (ro) { 770 /* re-open as RW */ 771 bdrv_delete(bs->backing_hd); 772 bs->backing_hd = NULL; 773 bs_rw = bdrv_new(""); 774 rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR, 775 backing_drv); 776 if (rw_ret < 0) { 777 bdrv_delete(bs_rw); 778 /* try to re-open read-only */ 779 bs_ro = bdrv_new(""); 780 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, 781 backing_drv); 782 if (ret < 0) { 783 bdrv_delete(bs_ro); 784 /* drive not functional anymore */ 785 bs->drv = NULL; 786 return ret; 787 } 788 bs->backing_hd = bs_ro; 789 return rw_ret; 790 } 791 bs->backing_hd = bs_rw; 792 } 793 794 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS; 795 buf = qemu_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE); 796 797 for (sector = 0; sector < total_sectors; sector += n) { 798 if (drv->bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) { 799 800 if (bdrv_read(bs, sector, buf, n) != 0) { 801 ret = -EIO; 802 goto ro_cleanup; 803 } 804 805 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) { 806 ret = -EIO; 807 goto ro_cleanup; 808 } 809 } 810 } 811 812 if (drv->bdrv_make_empty) { 813 ret = drv->bdrv_make_empty(bs); 814 bdrv_flush(bs); 815 } 816 817 /* 818 * Make sure all data we wrote to the backing device is actually 819 * stable on disk. 820 */ 821 if (bs->backing_hd) 822 bdrv_flush(bs->backing_hd); 823 824 ro_cleanup: 825 qemu_free(buf); 826 827 if (ro) { 828 /* re-open as RO */ 829 bdrv_delete(bs->backing_hd); 830 bs->backing_hd = NULL; 831 bs_ro = bdrv_new(""); 832 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, 833 backing_drv); 834 if (ret < 0) { 835 bdrv_delete(bs_ro); 836 /* drive not functional anymore */ 837 bs->drv = NULL; 838 return ret; 839 } 840 bs->backing_hd = bs_ro; 841 bs->backing_hd->keep_read_only = 0; 842 } 843 844 return ret; 845 } 846 847 void bdrv_commit_all(void) 848 { 849 BlockDriverState *bs; 850 851 QTAILQ_FOREACH(bs, &bdrv_states, list) { 852 bdrv_commit(bs); 853 } 854 } 855 856 /* 857 * Return values: 858 * 0 - success 859 * -EINVAL - backing format specified, but no file 860 * -ENOSPC - can't update the backing file because no space is left in the 861 * image file header 862 * -ENOTSUP - format driver doesn't support changing the backing file 863 */ 864 int bdrv_change_backing_file(BlockDriverState *bs, 865 const char *backing_file, const char *backing_fmt) 866 { 867 BlockDriver *drv = bs->drv; 868 869 if (drv->bdrv_change_backing_file != NULL) { 870 return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt); 871 } else { 872 return -ENOTSUP; 873 } 874 } 875 876 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, 877 size_t size) 878 { 879 int64_t len; 880 881 if (!bdrv_is_inserted(bs)) 882 return -ENOMEDIUM; 883 884 if (bs->growable) 885 return 0; 886 887 len = bdrv_getlength(bs); 888 889 if (offset < 0) 890 return -EIO; 891 892 if ((offset > len) || (len - offset < size)) 893 return -EIO; 894 895 return 0; 896 } 897 898 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num, 899 int nb_sectors) 900 { 901 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE, 902 nb_sectors * BDRV_SECTOR_SIZE); 903 } 904 905 /* return < 0 if error. See bdrv_write() for the return codes */ 906 int bdrv_read(BlockDriverState *bs, int64_t sector_num, 907 uint8_t *buf, int nb_sectors) 908 { 909 BlockDriver *drv = bs->drv; 910 911 if (!drv) 912 return -ENOMEDIUM; 913 if (bdrv_check_request(bs, sector_num, nb_sectors)) 914 return -EIO; 915 916 return drv->bdrv_read(bs, sector_num, buf, nb_sectors); 917 } 918 919 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num, 920 int nb_sectors, int dirty) 921 { 922 int64_t start, end; 923 unsigned long val, idx, bit; 924 925 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK; 926 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK; 927 928 for (; start <= end; start++) { 929 idx = start / (sizeof(unsigned long) * 8); 930 bit = start % (sizeof(unsigned long) * 8); 931 val = bs->dirty_bitmap[idx]; 932 if (dirty) { 933 if (!(val & (1 << bit))) { 934 bs->dirty_count++; 935 val |= 1 << bit; 936 } 937 } else { 938 if (val & (1 << bit)) { 939 bs->dirty_count--; 940 val &= ~(1 << bit); 941 } 942 } 943 bs->dirty_bitmap[idx] = val; 944 } 945 } 946 947 /* Return < 0 if error. Important errors are: 948 -EIO generic I/O error (may happen for all errors) 949 -ENOMEDIUM No media inserted. 950 -EINVAL Invalid sector number or nb_sectors 951 -EACCES Trying to write a read-only device 952 */ 953 int bdrv_write(BlockDriverState *bs, int64_t sector_num, 954 const uint8_t *buf, int nb_sectors) 955 { 956 BlockDriver *drv = bs->drv; 957 if (!bs->drv) 958 return -ENOMEDIUM; 959 if (bs->read_only) 960 return -EACCES; 961 if (bdrv_check_request(bs, sector_num, nb_sectors)) 962 return -EIO; 963 964 if (bs->dirty_bitmap) { 965 set_dirty_bitmap(bs, sector_num, nb_sectors, 1); 966 } 967 968 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) { 969 bs->wr_highest_sector = sector_num + nb_sectors - 1; 970 } 971 972 return drv->bdrv_write(bs, sector_num, buf, nb_sectors); 973 } 974 975 int bdrv_pread(BlockDriverState *bs, int64_t offset, 976 void *buf, int count1) 977 { 978 uint8_t tmp_buf[BDRV_SECTOR_SIZE]; 979 int len, nb_sectors, count; 980 int64_t sector_num; 981 int ret; 982 983 count = count1; 984 /* first read to align to sector start */ 985 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1); 986 if (len > count) 987 len = count; 988 sector_num = offset >> BDRV_SECTOR_BITS; 989 if (len > 0) { 990 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) 991 return ret; 992 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len); 993 count -= len; 994 if (count == 0) 995 return count1; 996 sector_num++; 997 buf += len; 998 } 999 1000 /* read the sectors "in place" */ 1001 nb_sectors = count >> BDRV_SECTOR_BITS; 1002 if (nb_sectors > 0) { 1003 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0) 1004 return ret; 1005 sector_num += nb_sectors; 1006 len = nb_sectors << BDRV_SECTOR_BITS; 1007 buf += len; 1008 count -= len; 1009 } 1010 1011 /* add data from the last sector */ 1012 if (count > 0) { 1013 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) 1014 return ret; 1015 memcpy(buf, tmp_buf, count); 1016 } 1017 return count1; 1018 } 1019 1020 int bdrv_pwrite(BlockDriverState *bs, int64_t offset, 1021 const void *buf, int count1) 1022 { 1023 uint8_t tmp_buf[BDRV_SECTOR_SIZE]; 1024 int len, nb_sectors, count; 1025 int64_t sector_num; 1026 int ret; 1027 1028 count = count1; 1029 /* first write to align to sector start */ 1030 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1); 1031 if (len > count) 1032 len = count; 1033 sector_num = offset >> BDRV_SECTOR_BITS; 1034 if (len > 0) { 1035 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) 1036 return ret; 1037 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len); 1038 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0) 1039 return ret; 1040 count -= len; 1041 if (count == 0) 1042 return count1; 1043 sector_num++; 1044 buf += len; 1045 } 1046 1047 /* write the sectors "in place" */ 1048 nb_sectors = count >> BDRV_SECTOR_BITS; 1049 if (nb_sectors > 0) { 1050 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0) 1051 return ret; 1052 sector_num += nb_sectors; 1053 len = nb_sectors << BDRV_SECTOR_BITS; 1054 buf += len; 1055 count -= len; 1056 } 1057 1058 /* add data from the last sector */ 1059 if (count > 0) { 1060 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) 1061 return ret; 1062 memcpy(tmp_buf, buf, count); 1063 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0) 1064 return ret; 1065 } 1066 return count1; 1067 } 1068 1069 /* 1070 * Writes to the file and ensures that no writes are reordered across this 1071 * request (acts as a barrier) 1072 * 1073 * Returns 0 on success, -errno in error cases. 1074 */ 1075 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset, 1076 const void *buf, int count) 1077 { 1078 int ret; 1079 1080 ret = bdrv_pwrite(bs, offset, buf, count); 1081 if (ret < 0) { 1082 return ret; 1083 } 1084 1085 /* No flush needed for cache=writethrough, it uses O_DSYNC */ 1086 if ((bs->open_flags & BDRV_O_CACHE_MASK) != 0) { 1087 bdrv_flush(bs); 1088 } 1089 1090 return 0; 1091 } 1092 1093 /* 1094 * Writes to the file and ensures that no writes are reordered across this 1095 * request (acts as a barrier) 1096 * 1097 * Returns 0 on success, -errno in error cases. 1098 */ 1099 int bdrv_write_sync(BlockDriverState *bs, int64_t sector_num, 1100 const uint8_t *buf, int nb_sectors) 1101 { 1102 return bdrv_pwrite_sync(bs, BDRV_SECTOR_SIZE * sector_num, 1103 buf, BDRV_SECTOR_SIZE * nb_sectors); 1104 } 1105 1106 /** 1107 * Truncate file to 'offset' bytes (needed only for file protocols) 1108 */ 1109 int bdrv_truncate(BlockDriverState *bs, int64_t offset) 1110 { 1111 BlockDriver *drv = bs->drv; 1112 int ret; 1113 if (!drv) 1114 return -ENOMEDIUM; 1115 if (!drv->bdrv_truncate) 1116 return -ENOTSUP; 1117 if (bs->read_only) 1118 return -EACCES; 1119 ret = drv->bdrv_truncate(bs, offset); 1120 if (ret == 0) { 1121 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS); 1122 } 1123 return ret; 1124 } 1125 1126 /** 1127 * Length of a file in bytes. Return < 0 if error or unknown. 1128 */ 1129 int64_t bdrv_getlength(BlockDriverState *bs) 1130 { 1131 BlockDriver *drv = bs->drv; 1132 if (!drv) 1133 return -ENOMEDIUM; 1134 1135 /* Fixed size devices use the total_sectors value for speed instead of 1136 issuing a length query (like lseek) on each call. Also, legacy block 1137 drivers don't provide a bdrv_getlength function and must use 1138 total_sectors. */ 1139 if (!bs->growable || !drv->bdrv_getlength) { 1140 return bs->total_sectors * BDRV_SECTOR_SIZE; 1141 } 1142 return drv->bdrv_getlength(bs); 1143 } 1144 1145 /* return 0 as number of sectors if no device present or error */ 1146 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) 1147 { 1148 int64_t length; 1149 length = bdrv_getlength(bs); 1150 if (length < 0) 1151 length = 0; 1152 else 1153 length = length >> BDRV_SECTOR_BITS; 1154 *nb_sectors_ptr = length; 1155 } 1156 1157 struct partition { 1158 uint8_t boot_ind; /* 0x80 - active */ 1159 uint8_t head; /* starting head */ 1160 uint8_t sector; /* starting sector */ 1161 uint8_t cyl; /* starting cylinder */ 1162 uint8_t sys_ind; /* What partition type */ 1163 uint8_t end_head; /* end head */ 1164 uint8_t end_sector; /* end sector */ 1165 uint8_t end_cyl; /* end cylinder */ 1166 uint32_t start_sect; /* starting sector counting from 0 */ 1167 uint32_t nr_sects; /* nr of sectors in partition */ 1168 } __attribute__((packed)); 1169 1170 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */ 1171 static int guess_disk_lchs(BlockDriverState *bs, 1172 int *pcylinders, int *pheads, int *psectors) 1173 { 1174 uint8_t buf[BDRV_SECTOR_SIZE]; 1175 int ret, i, heads, sectors, cylinders; 1176 struct partition *p; 1177 uint32_t nr_sects; 1178 uint64_t nb_sectors; 1179 1180 bdrv_get_geometry(bs, &nb_sectors); 1181 1182 ret = bdrv_read(bs, 0, buf, 1); 1183 if (ret < 0) 1184 return -1; 1185 /* test msdos magic */ 1186 if (buf[510] != 0x55 || buf[511] != 0xaa) 1187 return -1; 1188 for(i = 0; i < 4; i++) { 1189 p = ((struct partition *)(buf + 0x1be)) + i; 1190 nr_sects = le32_to_cpu(p->nr_sects); 1191 if (nr_sects && p->end_head) { 1192 /* We make the assumption that the partition terminates on 1193 a cylinder boundary */ 1194 heads = p->end_head + 1; 1195 sectors = p->end_sector & 63; 1196 if (sectors == 0) 1197 continue; 1198 cylinders = nb_sectors / (heads * sectors); 1199 if (cylinders < 1 || cylinders > 16383) 1200 continue; 1201 *pheads = heads; 1202 *psectors = sectors; 1203 *pcylinders = cylinders; 1204 #if 0 1205 printf("guessed geometry: LCHS=%d %d %d\n", 1206 cylinders, heads, sectors); 1207 #endif 1208 return 0; 1209 } 1210 } 1211 return -1; 1212 } 1213 1214 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs) 1215 { 1216 int translation, lba_detected = 0; 1217 int cylinders, heads, secs; 1218 uint64_t nb_sectors; 1219 1220 /* if a geometry hint is available, use it */ 1221 bdrv_get_geometry(bs, &nb_sectors); 1222 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs); 1223 translation = bdrv_get_translation_hint(bs); 1224 if (cylinders != 0) { 1225 *pcyls = cylinders; 1226 *pheads = heads; 1227 *psecs = secs; 1228 } else { 1229 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) { 1230 if (heads > 16) { 1231 /* if heads > 16, it means that a BIOS LBA 1232 translation was active, so the default 1233 hardware geometry is OK */ 1234 lba_detected = 1; 1235 goto default_geometry; 1236 } else { 1237 *pcyls = cylinders; 1238 *pheads = heads; 1239 *psecs = secs; 1240 /* disable any translation to be in sync with 1241 the logical geometry */ 1242 if (translation == BIOS_ATA_TRANSLATION_AUTO) { 1243 bdrv_set_translation_hint(bs, 1244 BIOS_ATA_TRANSLATION_NONE); 1245 } 1246 } 1247 } else { 1248 default_geometry: 1249 /* if no geometry, use a standard physical disk geometry */ 1250 cylinders = nb_sectors / (16 * 63); 1251 1252 if (cylinders > 16383) 1253 cylinders = 16383; 1254 else if (cylinders < 2) 1255 cylinders = 2; 1256 *pcyls = cylinders; 1257 *pheads = 16; 1258 *psecs = 63; 1259 if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) { 1260 if ((*pcyls * *pheads) <= 131072) { 1261 bdrv_set_translation_hint(bs, 1262 BIOS_ATA_TRANSLATION_LARGE); 1263 } else { 1264 bdrv_set_translation_hint(bs, 1265 BIOS_ATA_TRANSLATION_LBA); 1266 } 1267 } 1268 } 1269 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs); 1270 } 1271 } 1272 1273 void bdrv_set_geometry_hint(BlockDriverState *bs, 1274 int cyls, int heads, int secs) 1275 { 1276 bs->cyls = cyls; 1277 bs->heads = heads; 1278 bs->secs = secs; 1279 } 1280 1281 void bdrv_set_type_hint(BlockDriverState *bs, int type) 1282 { 1283 bs->type = type; 1284 bs->removable = ((type == BDRV_TYPE_CDROM || 1285 type == BDRV_TYPE_FLOPPY)); 1286 } 1287 1288 void bdrv_set_translation_hint(BlockDriverState *bs, int translation) 1289 { 1290 bs->translation = translation; 1291 } 1292 1293 void bdrv_get_geometry_hint(BlockDriverState *bs, 1294 int *pcyls, int *pheads, int *psecs) 1295 { 1296 *pcyls = bs->cyls; 1297 *pheads = bs->heads; 1298 *psecs = bs->secs; 1299 } 1300 1301 int bdrv_get_type_hint(BlockDriverState *bs) 1302 { 1303 return bs->type; 1304 } 1305 1306 int bdrv_get_translation_hint(BlockDriverState *bs) 1307 { 1308 return bs->translation; 1309 } 1310 1311 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error, 1312 BlockErrorAction on_write_error) 1313 { 1314 bs->on_read_error = on_read_error; 1315 bs->on_write_error = on_write_error; 1316 } 1317 1318 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read) 1319 { 1320 return is_read ? bs->on_read_error : bs->on_write_error; 1321 } 1322 1323 void bdrv_set_removable(BlockDriverState *bs, int removable) 1324 { 1325 bs->removable = removable; 1326 if (removable && bs == bs_snapshots) { 1327 bs_snapshots = NULL; 1328 } 1329 } 1330 1331 int bdrv_is_removable(BlockDriverState *bs) 1332 { 1333 return bs->removable; 1334 } 1335 1336 int bdrv_is_read_only(BlockDriverState *bs) 1337 { 1338 return bs->read_only; 1339 } 1340 1341 int bdrv_is_sg(BlockDriverState *bs) 1342 { 1343 return bs->sg; 1344 } 1345 1346 int bdrv_enable_write_cache(BlockDriverState *bs) 1347 { 1348 return bs->enable_write_cache; 1349 } 1350 1351 /* XXX: no longer used */ 1352 void bdrv_set_change_cb(BlockDriverState *bs, 1353 void (*change_cb)(void *opaque), void *opaque) 1354 { 1355 bs->change_cb = change_cb; 1356 bs->change_opaque = opaque; 1357 } 1358 1359 int bdrv_is_encrypted(BlockDriverState *bs) 1360 { 1361 if (bs->backing_hd && bs->backing_hd->encrypted) 1362 return 1; 1363 return bs->encrypted; 1364 } 1365 1366 int bdrv_key_required(BlockDriverState *bs) 1367 { 1368 BlockDriverState *backing_hd = bs->backing_hd; 1369 1370 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key) 1371 return 1; 1372 return (bs->encrypted && !bs->valid_key); 1373 } 1374 1375 int bdrv_set_key(BlockDriverState *bs, const char *key) 1376 { 1377 int ret; 1378 if (bs->backing_hd && bs->backing_hd->encrypted) { 1379 ret = bdrv_set_key(bs->backing_hd, key); 1380 if (ret < 0) 1381 return ret; 1382 if (!bs->encrypted) 1383 return 0; 1384 } 1385 if (!bs->encrypted) { 1386 return -EINVAL; 1387 } else if (!bs->drv || !bs->drv->bdrv_set_key) { 1388 return -ENOMEDIUM; 1389 } 1390 ret = bs->drv->bdrv_set_key(bs, key); 1391 if (ret < 0) { 1392 bs->valid_key = 0; 1393 } else if (!bs->valid_key) { 1394 bs->valid_key = 1; 1395 /* call the change callback now, we skipped it on open */ 1396 bs->media_changed = 1; 1397 if (bs->change_cb) 1398 bs->change_cb(bs->change_opaque); 1399 } 1400 return ret; 1401 } 1402 1403 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size) 1404 { 1405 if (!bs->drv) { 1406 buf[0] = '\0'; 1407 } else { 1408 pstrcpy(buf, buf_size, bs->drv->format_name); 1409 } 1410 } 1411 1412 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 1413 void *opaque) 1414 { 1415 BlockDriver *drv; 1416 1417 QLIST_FOREACH(drv, &bdrv_drivers, list) { 1418 it(opaque, drv->format_name); 1419 } 1420 } 1421 1422 BlockDriverState *bdrv_find(const char *name) 1423 { 1424 BlockDriverState *bs; 1425 1426 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1427 if (!strcmp(name, bs->device_name)) { 1428 return bs; 1429 } 1430 } 1431 return NULL; 1432 } 1433 1434 BlockDriverState *bdrv_next(BlockDriverState *bs) 1435 { 1436 if (!bs) { 1437 return QTAILQ_FIRST(&bdrv_states); 1438 } 1439 return QTAILQ_NEXT(bs, list); 1440 } 1441 1442 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque) 1443 { 1444 BlockDriverState *bs; 1445 1446 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1447 it(opaque, bs); 1448 } 1449 } 1450 1451 const char *bdrv_get_device_name(BlockDriverState *bs) 1452 { 1453 return bs->device_name; 1454 } 1455 1456 void bdrv_flush(BlockDriverState *bs) 1457 { 1458 if (bs->open_flags & BDRV_O_NO_FLUSH) { 1459 return; 1460 } 1461 1462 if (bs->drv && bs->drv->bdrv_flush) 1463 bs->drv->bdrv_flush(bs); 1464 } 1465 1466 void bdrv_flush_all(void) 1467 { 1468 BlockDriverState *bs; 1469 1470 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1471 if (bs->drv && !bdrv_is_read_only(bs) && 1472 (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) { 1473 bdrv_flush(bs); 1474 } 1475 } 1476 } 1477 1478 int bdrv_has_zero_init(BlockDriverState *bs) 1479 { 1480 assert(bs->drv); 1481 1482 if (bs->drv->bdrv_has_zero_init) { 1483 return bs->drv->bdrv_has_zero_init(bs); 1484 } 1485 1486 return 1; 1487 } 1488 1489 /* 1490 * Returns true iff the specified sector is present in the disk image. Drivers 1491 * not implementing the functionality are assumed to not support backing files, 1492 * hence all their sectors are reported as allocated. 1493 * 1494 * 'pnum' is set to the number of sectors (including and immediately following 1495 * the specified sector) that are known to be in the same 1496 * allocated/unallocated state. 1497 * 1498 * 'nb_sectors' is the max value 'pnum' should be set to. 1499 */ 1500 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors, 1501 int *pnum) 1502 { 1503 int64_t n; 1504 if (!bs->drv->bdrv_is_allocated) { 1505 if (sector_num >= bs->total_sectors) { 1506 *pnum = 0; 1507 return 0; 1508 } 1509 n = bs->total_sectors - sector_num; 1510 *pnum = (n < nb_sectors) ? (n) : (nb_sectors); 1511 return 1; 1512 } 1513 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum); 1514 } 1515 1516 void bdrv_mon_event(const BlockDriverState *bdrv, 1517 BlockMonEventAction action, int is_read) 1518 { 1519 QObject *data; 1520 const char *action_str; 1521 1522 switch (action) { 1523 case BDRV_ACTION_REPORT: 1524 action_str = "report"; 1525 break; 1526 case BDRV_ACTION_IGNORE: 1527 action_str = "ignore"; 1528 break; 1529 case BDRV_ACTION_STOP: 1530 action_str = "stop"; 1531 break; 1532 default: 1533 abort(); 1534 } 1535 1536 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }", 1537 bdrv->device_name, 1538 action_str, 1539 is_read ? "read" : "write"); 1540 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data); 1541 1542 qobject_decref(data); 1543 } 1544 1545 static void bdrv_print_dict(QObject *obj, void *opaque) 1546 { 1547 QDict *bs_dict; 1548 Monitor *mon = opaque; 1549 1550 bs_dict = qobject_to_qdict(obj); 1551 1552 monitor_printf(mon, "%s: type=%s removable=%d", 1553 qdict_get_str(bs_dict, "device"), 1554 qdict_get_str(bs_dict, "type"), 1555 qdict_get_bool(bs_dict, "removable")); 1556 1557 if (qdict_get_bool(bs_dict, "removable")) { 1558 monitor_printf(mon, " locked=%d", qdict_get_bool(bs_dict, "locked")); 1559 } 1560 1561 if (qdict_haskey(bs_dict, "inserted")) { 1562 QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted")); 1563 1564 monitor_printf(mon, " file="); 1565 monitor_print_filename(mon, qdict_get_str(qdict, "file")); 1566 if (qdict_haskey(qdict, "backing_file")) { 1567 monitor_printf(mon, " backing_file="); 1568 monitor_print_filename(mon, qdict_get_str(qdict, "backing_file")); 1569 } 1570 monitor_printf(mon, " ro=%d drv=%s encrypted=%d", 1571 qdict_get_bool(qdict, "ro"), 1572 qdict_get_str(qdict, "drv"), 1573 qdict_get_bool(qdict, "encrypted")); 1574 } else { 1575 monitor_printf(mon, " [not inserted]"); 1576 } 1577 1578 monitor_printf(mon, "\n"); 1579 } 1580 1581 void bdrv_info_print(Monitor *mon, const QObject *data) 1582 { 1583 qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon); 1584 } 1585 1586 void bdrv_info(Monitor *mon, QObject **ret_data) 1587 { 1588 QList *bs_list; 1589 BlockDriverState *bs; 1590 1591 bs_list = qlist_new(); 1592 1593 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1594 QObject *bs_obj; 1595 const char *type = "unknown"; 1596 1597 switch(bs->type) { 1598 case BDRV_TYPE_HD: 1599 type = "hd"; 1600 break; 1601 case BDRV_TYPE_CDROM: 1602 type = "cdrom"; 1603 break; 1604 case BDRV_TYPE_FLOPPY: 1605 type = "floppy"; 1606 break; 1607 } 1608 1609 bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, " 1610 "'removable': %i, 'locked': %i }", 1611 bs->device_name, type, bs->removable, 1612 bs->locked); 1613 1614 if (bs->drv) { 1615 QObject *obj; 1616 QDict *bs_dict = qobject_to_qdict(bs_obj); 1617 1618 obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, " 1619 "'encrypted': %i }", 1620 bs->filename, bs->read_only, 1621 bs->drv->format_name, 1622 bdrv_is_encrypted(bs)); 1623 if (bs->backing_file[0] != '\0') { 1624 QDict *qdict = qobject_to_qdict(obj); 1625 qdict_put(qdict, "backing_file", 1626 qstring_from_str(bs->backing_file)); 1627 } 1628 1629 qdict_put_obj(bs_dict, "inserted", obj); 1630 } 1631 qlist_append_obj(bs_list, bs_obj); 1632 } 1633 1634 *ret_data = QOBJECT(bs_list); 1635 } 1636 1637 static void bdrv_stats_iter(QObject *data, void *opaque) 1638 { 1639 QDict *qdict; 1640 Monitor *mon = opaque; 1641 1642 qdict = qobject_to_qdict(data); 1643 monitor_printf(mon, "%s:", qdict_get_str(qdict, "device")); 1644 1645 qdict = qobject_to_qdict(qdict_get(qdict, "stats")); 1646 monitor_printf(mon, " rd_bytes=%" PRId64 1647 " wr_bytes=%" PRId64 1648 " rd_operations=%" PRId64 1649 " wr_operations=%" PRId64 1650 "\n", 1651 qdict_get_int(qdict, "rd_bytes"), 1652 qdict_get_int(qdict, "wr_bytes"), 1653 qdict_get_int(qdict, "rd_operations"), 1654 qdict_get_int(qdict, "wr_operations")); 1655 } 1656 1657 void bdrv_stats_print(Monitor *mon, const QObject *data) 1658 { 1659 qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon); 1660 } 1661 1662 static QObject* bdrv_info_stats_bs(BlockDriverState *bs) 1663 { 1664 QObject *res; 1665 QDict *dict; 1666 1667 res = qobject_from_jsonf("{ 'stats': {" 1668 "'rd_bytes': %" PRId64 "," 1669 "'wr_bytes': %" PRId64 "," 1670 "'rd_operations': %" PRId64 "," 1671 "'wr_operations': %" PRId64 "," 1672 "'wr_highest_offset': %" PRId64 1673 "} }", 1674 bs->rd_bytes, bs->wr_bytes, 1675 bs->rd_ops, bs->wr_ops, 1676 bs->wr_highest_sector * 1677 (uint64_t)BDRV_SECTOR_SIZE); 1678 dict = qobject_to_qdict(res); 1679 1680 if (*bs->device_name) { 1681 qdict_put(dict, "device", qstring_from_str(bs->device_name)); 1682 } 1683 1684 if (bs->file) { 1685 QObject *parent = bdrv_info_stats_bs(bs->file); 1686 qdict_put_obj(dict, "parent", parent); 1687 } 1688 1689 return res; 1690 } 1691 1692 void bdrv_info_stats(Monitor *mon, QObject **ret_data) 1693 { 1694 QObject *obj; 1695 QList *devices; 1696 BlockDriverState *bs; 1697 1698 devices = qlist_new(); 1699 1700 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1701 obj = bdrv_info_stats_bs(bs); 1702 qlist_append_obj(devices, obj); 1703 } 1704 1705 *ret_data = QOBJECT(devices); 1706 } 1707 1708 const char *bdrv_get_encrypted_filename(BlockDriverState *bs) 1709 { 1710 if (bs->backing_hd && bs->backing_hd->encrypted) 1711 return bs->backing_file; 1712 else if (bs->encrypted) 1713 return bs->filename; 1714 else 1715 return NULL; 1716 } 1717 1718 void bdrv_get_backing_filename(BlockDriverState *bs, 1719 char *filename, int filename_size) 1720 { 1721 if (!bs->backing_file) { 1722 pstrcpy(filename, filename_size, ""); 1723 } else { 1724 pstrcpy(filename, filename_size, bs->backing_file); 1725 } 1726 } 1727 1728 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 1729 const uint8_t *buf, int nb_sectors) 1730 { 1731 BlockDriver *drv = bs->drv; 1732 if (!drv) 1733 return -ENOMEDIUM; 1734 if (!drv->bdrv_write_compressed) 1735 return -ENOTSUP; 1736 if (bdrv_check_request(bs, sector_num, nb_sectors)) 1737 return -EIO; 1738 1739 if (bs->dirty_bitmap) { 1740 set_dirty_bitmap(bs, sector_num, nb_sectors, 1); 1741 } 1742 1743 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors); 1744 } 1745 1746 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 1747 { 1748 BlockDriver *drv = bs->drv; 1749 if (!drv) 1750 return -ENOMEDIUM; 1751 if (!drv->bdrv_get_info) 1752 return -ENOTSUP; 1753 memset(bdi, 0, sizeof(*bdi)); 1754 return drv->bdrv_get_info(bs, bdi); 1755 } 1756 1757 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf, 1758 int64_t pos, int size) 1759 { 1760 BlockDriver *drv = bs->drv; 1761 if (!drv) 1762 return -ENOMEDIUM; 1763 if (drv->bdrv_save_vmstate) 1764 return drv->bdrv_save_vmstate(bs, buf, pos, size); 1765 if (bs->file) 1766 return bdrv_save_vmstate(bs->file, buf, pos, size); 1767 return -ENOTSUP; 1768 } 1769 1770 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf, 1771 int64_t pos, int size) 1772 { 1773 BlockDriver *drv = bs->drv; 1774 if (!drv) 1775 return -ENOMEDIUM; 1776 if (drv->bdrv_load_vmstate) 1777 return drv->bdrv_load_vmstate(bs, buf, pos, size); 1778 if (bs->file) 1779 return bdrv_load_vmstate(bs->file, buf, pos, size); 1780 return -ENOTSUP; 1781 } 1782 1783 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event) 1784 { 1785 BlockDriver *drv = bs->drv; 1786 1787 if (!drv || !drv->bdrv_debug_event) { 1788 return; 1789 } 1790 1791 return drv->bdrv_debug_event(bs, event); 1792 1793 } 1794 1795 /**************************************************************/ 1796 /* handling of snapshots */ 1797 1798 int bdrv_can_snapshot(BlockDriverState *bs) 1799 { 1800 BlockDriver *drv = bs->drv; 1801 if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) { 1802 return 0; 1803 } 1804 1805 if (!drv->bdrv_snapshot_create) { 1806 if (bs->file != NULL) { 1807 return bdrv_can_snapshot(bs->file); 1808 } 1809 return 0; 1810 } 1811 1812 return 1; 1813 } 1814 1815 int bdrv_is_snapshot(BlockDriverState *bs) 1816 { 1817 return !!(bs->open_flags & BDRV_O_SNAPSHOT); 1818 } 1819 1820 BlockDriverState *bdrv_snapshots(void) 1821 { 1822 BlockDriverState *bs; 1823 1824 if (bs_snapshots) { 1825 return bs_snapshots; 1826 } 1827 1828 bs = NULL; 1829 while ((bs = bdrv_next(bs))) { 1830 if (bdrv_can_snapshot(bs)) { 1831 bs_snapshots = bs; 1832 return bs; 1833 } 1834 } 1835 return NULL; 1836 } 1837 1838 int bdrv_snapshot_create(BlockDriverState *bs, 1839 QEMUSnapshotInfo *sn_info) 1840 { 1841 BlockDriver *drv = bs->drv; 1842 if (!drv) 1843 return -ENOMEDIUM; 1844 if (drv->bdrv_snapshot_create) 1845 return drv->bdrv_snapshot_create(bs, sn_info); 1846 if (bs->file) 1847 return bdrv_snapshot_create(bs->file, sn_info); 1848 return -ENOTSUP; 1849 } 1850 1851 int bdrv_snapshot_goto(BlockDriverState *bs, 1852 const char *snapshot_id) 1853 { 1854 BlockDriver *drv = bs->drv; 1855 int ret, open_ret; 1856 1857 if (!drv) 1858 return -ENOMEDIUM; 1859 if (drv->bdrv_snapshot_goto) 1860 return drv->bdrv_snapshot_goto(bs, snapshot_id); 1861 1862 if (bs->file) { 1863 drv->bdrv_close(bs); 1864 ret = bdrv_snapshot_goto(bs->file, snapshot_id); 1865 open_ret = drv->bdrv_open(bs, bs->open_flags); 1866 if (open_ret < 0) { 1867 bdrv_delete(bs->file); 1868 bs->drv = NULL; 1869 return open_ret; 1870 } 1871 return ret; 1872 } 1873 1874 return -ENOTSUP; 1875 } 1876 1877 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id) 1878 { 1879 BlockDriver *drv = bs->drv; 1880 if (!drv) 1881 return -ENOMEDIUM; 1882 if (drv->bdrv_snapshot_delete) 1883 return drv->bdrv_snapshot_delete(bs, snapshot_id); 1884 if (bs->file) 1885 return bdrv_snapshot_delete(bs->file, snapshot_id); 1886 return -ENOTSUP; 1887 } 1888 1889 int bdrv_snapshot_list(BlockDriverState *bs, 1890 QEMUSnapshotInfo **psn_info) 1891 { 1892 BlockDriver *drv = bs->drv; 1893 if (!drv) 1894 return -ENOMEDIUM; 1895 if (drv->bdrv_snapshot_list) 1896 return drv->bdrv_snapshot_list(bs, psn_info); 1897 if (bs->file) 1898 return bdrv_snapshot_list(bs->file, psn_info); 1899 return -ENOTSUP; 1900 } 1901 1902 int bdrv_snapshot_load_tmp(BlockDriverState *bs, 1903 const char *snapshot_name) 1904 { 1905 BlockDriver *drv = bs->drv; 1906 if (!drv) { 1907 return -ENOMEDIUM; 1908 } 1909 if (!bs->read_only) { 1910 return -EINVAL; 1911 } 1912 if (drv->bdrv_snapshot_load_tmp) { 1913 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name); 1914 } 1915 return -ENOTSUP; 1916 } 1917 1918 #define NB_SUFFIXES 4 1919 1920 char *get_human_readable_size(char *buf, int buf_size, int64_t size) 1921 { 1922 static const char suffixes[NB_SUFFIXES] = "KMGT"; 1923 int64_t base; 1924 int i; 1925 1926 if (size <= 999) { 1927 snprintf(buf, buf_size, "%" PRId64, size); 1928 } else { 1929 base = 1024; 1930 for(i = 0; i < NB_SUFFIXES; i++) { 1931 if (size < (10 * base)) { 1932 snprintf(buf, buf_size, "%0.1f%c", 1933 (double)size / base, 1934 suffixes[i]); 1935 break; 1936 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) { 1937 snprintf(buf, buf_size, "%" PRId64 "%c", 1938 ((size + (base >> 1)) / base), 1939 suffixes[i]); 1940 break; 1941 } 1942 base = base * 1024; 1943 } 1944 } 1945 return buf; 1946 } 1947 1948 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn) 1949 { 1950 char buf1[128], date_buf[128], clock_buf[128]; 1951 #ifdef _WIN32 1952 struct tm *ptm; 1953 #else 1954 struct tm tm; 1955 #endif 1956 time_t ti; 1957 int64_t secs; 1958 1959 if (!sn) { 1960 snprintf(buf, buf_size, 1961 "%-10s%-20s%7s%20s%15s", 1962 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK"); 1963 } else { 1964 ti = sn->date_sec; 1965 #ifdef _WIN32 1966 ptm = localtime(&ti); 1967 strftime(date_buf, sizeof(date_buf), 1968 "%Y-%m-%d %H:%M:%S", ptm); 1969 #else 1970 localtime_r(&ti, &tm); 1971 strftime(date_buf, sizeof(date_buf), 1972 "%Y-%m-%d %H:%M:%S", &tm); 1973 #endif 1974 secs = sn->vm_clock_nsec / 1000000000; 1975 snprintf(clock_buf, sizeof(clock_buf), 1976 "%02d:%02d:%02d.%03d", 1977 (int)(secs / 3600), 1978 (int)((secs / 60) % 60), 1979 (int)(secs % 60), 1980 (int)((sn->vm_clock_nsec / 1000000) % 1000)); 1981 snprintf(buf, buf_size, 1982 "%-10s%-20s%7s%20s%15s", 1983 sn->id_str, sn->name, 1984 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size), 1985 date_buf, 1986 clock_buf); 1987 } 1988 return buf; 1989 } 1990 1991 1992 /**************************************************************/ 1993 /* async I/Os */ 1994 1995 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, 1996 QEMUIOVector *qiov, int nb_sectors, 1997 BlockDriverCompletionFunc *cb, void *opaque) 1998 { 1999 BlockDriver *drv = bs->drv; 2000 BlockDriverAIOCB *ret; 2001 2002 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque); 2003 2004 if (!drv) 2005 return NULL; 2006 if (bdrv_check_request(bs, sector_num, nb_sectors)) 2007 return NULL; 2008 2009 ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors, 2010 cb, opaque); 2011 2012 if (ret) { 2013 /* Update stats even though technically transfer has not happened. */ 2014 bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE; 2015 bs->rd_ops ++; 2016 } 2017 2018 return ret; 2019 } 2020 2021 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, 2022 QEMUIOVector *qiov, int nb_sectors, 2023 BlockDriverCompletionFunc *cb, void *opaque) 2024 { 2025 BlockDriver *drv = bs->drv; 2026 BlockDriverAIOCB *ret; 2027 2028 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque); 2029 2030 if (!drv) 2031 return NULL; 2032 if (bs->read_only) 2033 return NULL; 2034 if (bdrv_check_request(bs, sector_num, nb_sectors)) 2035 return NULL; 2036 2037 if (bs->dirty_bitmap) { 2038 set_dirty_bitmap(bs, sector_num, nb_sectors, 1); 2039 } 2040 2041 ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors, 2042 cb, opaque); 2043 2044 if (ret) { 2045 /* Update stats even though technically transfer has not happened. */ 2046 bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE; 2047 bs->wr_ops ++; 2048 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) { 2049 bs->wr_highest_sector = sector_num + nb_sectors - 1; 2050 } 2051 } 2052 2053 return ret; 2054 } 2055 2056 2057 typedef struct MultiwriteCB { 2058 int error; 2059 int num_requests; 2060 int num_callbacks; 2061 struct { 2062 BlockDriverCompletionFunc *cb; 2063 void *opaque; 2064 QEMUIOVector *free_qiov; 2065 void *free_buf; 2066 } callbacks[]; 2067 } MultiwriteCB; 2068 2069 static void multiwrite_user_cb(MultiwriteCB *mcb) 2070 { 2071 int i; 2072 2073 for (i = 0; i < mcb->num_callbacks; i++) { 2074 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error); 2075 if (mcb->callbacks[i].free_qiov) { 2076 qemu_iovec_destroy(mcb->callbacks[i].free_qiov); 2077 } 2078 qemu_free(mcb->callbacks[i].free_qiov); 2079 qemu_vfree(mcb->callbacks[i].free_buf); 2080 } 2081 } 2082 2083 static void multiwrite_cb(void *opaque, int ret) 2084 { 2085 MultiwriteCB *mcb = opaque; 2086 2087 trace_multiwrite_cb(mcb, ret); 2088 2089 if (ret < 0 && !mcb->error) { 2090 mcb->error = ret; 2091 } 2092 2093 mcb->num_requests--; 2094 if (mcb->num_requests == 0) { 2095 multiwrite_user_cb(mcb); 2096 qemu_free(mcb); 2097 } 2098 } 2099 2100 static int multiwrite_req_compare(const void *a, const void *b) 2101 { 2102 const BlockRequest *req1 = a, *req2 = b; 2103 2104 /* 2105 * Note that we can't simply subtract req2->sector from req1->sector 2106 * here as that could overflow the return value. 2107 */ 2108 if (req1->sector > req2->sector) { 2109 return 1; 2110 } else if (req1->sector < req2->sector) { 2111 return -1; 2112 } else { 2113 return 0; 2114 } 2115 } 2116 2117 /* 2118 * Takes a bunch of requests and tries to merge them. Returns the number of 2119 * requests that remain after merging. 2120 */ 2121 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs, 2122 int num_reqs, MultiwriteCB *mcb) 2123 { 2124 int i, outidx; 2125 2126 // Sort requests by start sector 2127 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare); 2128 2129 // Check if adjacent requests touch the same clusters. If so, combine them, 2130 // filling up gaps with zero sectors. 2131 outidx = 0; 2132 for (i = 1; i < num_reqs; i++) { 2133 int merge = 0; 2134 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors; 2135 2136 // This handles the cases that are valid for all block drivers, namely 2137 // exactly sequential writes and overlapping writes. 2138 if (reqs[i].sector <= oldreq_last) { 2139 merge = 1; 2140 } 2141 2142 // The block driver may decide that it makes sense to combine requests 2143 // even if there is a gap of some sectors between them. In this case, 2144 // the gap is filled with zeros (therefore only applicable for yet 2145 // unused space in format like qcow2). 2146 if (!merge && bs->drv->bdrv_merge_requests) { 2147 merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]); 2148 } 2149 2150 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) { 2151 merge = 0; 2152 } 2153 2154 if (merge) { 2155 size_t size; 2156 QEMUIOVector *qiov = qemu_mallocz(sizeof(*qiov)); 2157 qemu_iovec_init(qiov, 2158 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1); 2159 2160 // Add the first request to the merged one. If the requests are 2161 // overlapping, drop the last sectors of the first request. 2162 size = (reqs[i].sector - reqs[outidx].sector) << 9; 2163 qemu_iovec_concat(qiov, reqs[outidx].qiov, size); 2164 2165 // We might need to add some zeros between the two requests 2166 if (reqs[i].sector > oldreq_last) { 2167 size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9; 2168 uint8_t *buf = qemu_blockalign(bs, zero_bytes); 2169 memset(buf, 0, zero_bytes); 2170 qemu_iovec_add(qiov, buf, zero_bytes); 2171 mcb->callbacks[i].free_buf = buf; 2172 } 2173 2174 // Add the second request 2175 qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size); 2176 2177 reqs[outidx].nb_sectors = qiov->size >> 9; 2178 reqs[outidx].qiov = qiov; 2179 2180 mcb->callbacks[i].free_qiov = reqs[outidx].qiov; 2181 } else { 2182 outidx++; 2183 reqs[outidx].sector = reqs[i].sector; 2184 reqs[outidx].nb_sectors = reqs[i].nb_sectors; 2185 reqs[outidx].qiov = reqs[i].qiov; 2186 } 2187 } 2188 2189 return outidx + 1; 2190 } 2191 2192 /* 2193 * Submit multiple AIO write requests at once. 2194 * 2195 * On success, the function returns 0 and all requests in the reqs array have 2196 * been submitted. In error case this function returns -1, and any of the 2197 * requests may or may not be submitted yet. In particular, this means that the 2198 * callback will be called for some of the requests, for others it won't. The 2199 * caller must check the error field of the BlockRequest to wait for the right 2200 * callbacks (if error != 0, no callback will be called). 2201 * 2202 * The implementation may modify the contents of the reqs array, e.g. to merge 2203 * requests. However, the fields opaque and error are left unmodified as they 2204 * are used to signal failure for a single request to the caller. 2205 */ 2206 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs) 2207 { 2208 BlockDriverAIOCB *acb; 2209 MultiwriteCB *mcb; 2210 int i; 2211 2212 if (num_reqs == 0) { 2213 return 0; 2214 } 2215 2216 // Create MultiwriteCB structure 2217 mcb = qemu_mallocz(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks)); 2218 mcb->num_requests = 0; 2219 mcb->num_callbacks = num_reqs; 2220 2221 for (i = 0; i < num_reqs; i++) { 2222 mcb->callbacks[i].cb = reqs[i].cb; 2223 mcb->callbacks[i].opaque = reqs[i].opaque; 2224 } 2225 2226 // Check for mergable requests 2227 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb); 2228 2229 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs); 2230 2231 /* 2232 * Run the aio requests. As soon as one request can't be submitted 2233 * successfully, fail all requests that are not yet submitted (we must 2234 * return failure for all requests anyway) 2235 * 2236 * num_requests cannot be set to the right value immediately: If 2237 * bdrv_aio_writev fails for some request, num_requests would be too high 2238 * and therefore multiwrite_cb() would never recognize the multiwrite 2239 * request as completed. We also cannot use the loop variable i to set it 2240 * when the first request fails because the callback may already have been 2241 * called for previously submitted requests. Thus, num_requests must be 2242 * incremented for each request that is submitted. 2243 * 2244 * The problem that callbacks may be called early also means that we need 2245 * to take care that num_requests doesn't become 0 before all requests are 2246 * submitted - multiwrite_cb() would consider the multiwrite request 2247 * completed. A dummy request that is "completed" by a manual call to 2248 * multiwrite_cb() takes care of this. 2249 */ 2250 mcb->num_requests = 1; 2251 2252 // Run the aio requests 2253 for (i = 0; i < num_reqs; i++) { 2254 mcb->num_requests++; 2255 acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov, 2256 reqs[i].nb_sectors, multiwrite_cb, mcb); 2257 2258 if (acb == NULL) { 2259 // We can only fail the whole thing if no request has been 2260 // submitted yet. Otherwise we'll wait for the submitted AIOs to 2261 // complete and report the error in the callback. 2262 if (i == 0) { 2263 trace_bdrv_aio_multiwrite_earlyfail(mcb); 2264 goto fail; 2265 } else { 2266 trace_bdrv_aio_multiwrite_latefail(mcb, i); 2267 multiwrite_cb(mcb, -EIO); 2268 break; 2269 } 2270 } 2271 } 2272 2273 /* Complete the dummy request */ 2274 multiwrite_cb(mcb, 0); 2275 2276 return 0; 2277 2278 fail: 2279 for (i = 0; i < mcb->num_callbacks; i++) { 2280 reqs[i].error = -EIO; 2281 } 2282 qemu_free(mcb); 2283 return -1; 2284 } 2285 2286 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, 2287 BlockDriverCompletionFunc *cb, void *opaque) 2288 { 2289 BlockDriver *drv = bs->drv; 2290 2291 if (bs->open_flags & BDRV_O_NO_FLUSH) { 2292 return bdrv_aio_noop_em(bs, cb, opaque); 2293 } 2294 2295 if (!drv) 2296 return NULL; 2297 return drv->bdrv_aio_flush(bs, cb, opaque); 2298 } 2299 2300 void bdrv_aio_cancel(BlockDriverAIOCB *acb) 2301 { 2302 acb->pool->cancel(acb); 2303 } 2304 2305 2306 /**************************************************************/ 2307 /* async block device emulation */ 2308 2309 typedef struct BlockDriverAIOCBSync { 2310 BlockDriverAIOCB common; 2311 QEMUBH *bh; 2312 int ret; 2313 /* vector translation state */ 2314 QEMUIOVector *qiov; 2315 uint8_t *bounce; 2316 int is_write; 2317 } BlockDriverAIOCBSync; 2318 2319 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb) 2320 { 2321 BlockDriverAIOCBSync *acb = 2322 container_of(blockacb, BlockDriverAIOCBSync, common); 2323 qemu_bh_delete(acb->bh); 2324 acb->bh = NULL; 2325 qemu_aio_release(acb); 2326 } 2327 2328 static AIOPool bdrv_em_aio_pool = { 2329 .aiocb_size = sizeof(BlockDriverAIOCBSync), 2330 .cancel = bdrv_aio_cancel_em, 2331 }; 2332 2333 static void bdrv_aio_bh_cb(void *opaque) 2334 { 2335 BlockDriverAIOCBSync *acb = opaque; 2336 2337 if (!acb->is_write) 2338 qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size); 2339 qemu_vfree(acb->bounce); 2340 acb->common.cb(acb->common.opaque, acb->ret); 2341 qemu_bh_delete(acb->bh); 2342 acb->bh = NULL; 2343 qemu_aio_release(acb); 2344 } 2345 2346 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, 2347 int64_t sector_num, 2348 QEMUIOVector *qiov, 2349 int nb_sectors, 2350 BlockDriverCompletionFunc *cb, 2351 void *opaque, 2352 int is_write) 2353 2354 { 2355 BlockDriverAIOCBSync *acb; 2356 2357 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque); 2358 acb->is_write = is_write; 2359 acb->qiov = qiov; 2360 acb->bounce = qemu_blockalign(bs, qiov->size); 2361 2362 if (!acb->bh) 2363 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb); 2364 2365 if (is_write) { 2366 qemu_iovec_to_buffer(acb->qiov, acb->bounce); 2367 acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors); 2368 } else { 2369 acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors); 2370 } 2371 2372 qemu_bh_schedule(acb->bh); 2373 2374 return &acb->common; 2375 } 2376 2377 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, 2378 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 2379 BlockDriverCompletionFunc *cb, void *opaque) 2380 { 2381 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); 2382 } 2383 2384 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, 2385 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 2386 BlockDriverCompletionFunc *cb, void *opaque) 2387 { 2388 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); 2389 } 2390 2391 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs, 2392 BlockDriverCompletionFunc *cb, void *opaque) 2393 { 2394 BlockDriverAIOCBSync *acb; 2395 2396 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque); 2397 acb->is_write = 1; /* don't bounce in the completion hadler */ 2398 acb->qiov = NULL; 2399 acb->bounce = NULL; 2400 acb->ret = 0; 2401 2402 if (!acb->bh) 2403 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb); 2404 2405 bdrv_flush(bs); 2406 qemu_bh_schedule(acb->bh); 2407 return &acb->common; 2408 } 2409 2410 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs, 2411 BlockDriverCompletionFunc *cb, void *opaque) 2412 { 2413 BlockDriverAIOCBSync *acb; 2414 2415 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque); 2416 acb->is_write = 1; /* don't bounce in the completion handler */ 2417 acb->qiov = NULL; 2418 acb->bounce = NULL; 2419 acb->ret = 0; 2420 2421 if (!acb->bh) { 2422 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb); 2423 } 2424 2425 qemu_bh_schedule(acb->bh); 2426 return &acb->common; 2427 } 2428 2429 /**************************************************************/ 2430 /* sync block device emulation */ 2431 2432 static void bdrv_rw_em_cb(void *opaque, int ret) 2433 { 2434 *(int *)opaque = ret; 2435 } 2436 2437 #define NOT_DONE 0x7fffffff 2438 2439 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, 2440 uint8_t *buf, int nb_sectors) 2441 { 2442 int async_ret; 2443 BlockDriverAIOCB *acb; 2444 struct iovec iov; 2445 QEMUIOVector qiov; 2446 2447 async_context_push(); 2448 2449 async_ret = NOT_DONE; 2450 iov.iov_base = (void *)buf; 2451 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE; 2452 qemu_iovec_init_external(&qiov, &iov, 1); 2453 acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors, 2454 bdrv_rw_em_cb, &async_ret); 2455 if (acb == NULL) { 2456 async_ret = -1; 2457 goto fail; 2458 } 2459 2460 while (async_ret == NOT_DONE) { 2461 qemu_aio_wait(); 2462 } 2463 2464 2465 fail: 2466 async_context_pop(); 2467 return async_ret; 2468 } 2469 2470 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num, 2471 const uint8_t *buf, int nb_sectors) 2472 { 2473 int async_ret; 2474 BlockDriverAIOCB *acb; 2475 struct iovec iov; 2476 QEMUIOVector qiov; 2477 2478 async_context_push(); 2479 2480 async_ret = NOT_DONE; 2481 iov.iov_base = (void *)buf; 2482 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE; 2483 qemu_iovec_init_external(&qiov, &iov, 1); 2484 acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors, 2485 bdrv_rw_em_cb, &async_ret); 2486 if (acb == NULL) { 2487 async_ret = -1; 2488 goto fail; 2489 } 2490 while (async_ret == NOT_DONE) { 2491 qemu_aio_wait(); 2492 } 2493 2494 fail: 2495 async_context_pop(); 2496 return async_ret; 2497 } 2498 2499 void bdrv_init(void) 2500 { 2501 module_call_init(MODULE_INIT_BLOCK); 2502 } 2503 2504 void bdrv_init_with_whitelist(void) 2505 { 2506 use_bdrv_whitelist = 1; 2507 bdrv_init(); 2508 } 2509 2510 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs, 2511 BlockDriverCompletionFunc *cb, void *opaque) 2512 { 2513 BlockDriverAIOCB *acb; 2514 2515 if (pool->free_aiocb) { 2516 acb = pool->free_aiocb; 2517 pool->free_aiocb = acb->next; 2518 } else { 2519 acb = qemu_mallocz(pool->aiocb_size); 2520 acb->pool = pool; 2521 } 2522 acb->bs = bs; 2523 acb->cb = cb; 2524 acb->opaque = opaque; 2525 return acb; 2526 } 2527 2528 void qemu_aio_release(void *p) 2529 { 2530 BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p; 2531 AIOPool *pool = acb->pool; 2532 acb->next = pool->free_aiocb; 2533 pool->free_aiocb = acb; 2534 } 2535 2536 /**************************************************************/ 2537 /* removable device support */ 2538 2539 /** 2540 * Return TRUE if the media is present 2541 */ 2542 int bdrv_is_inserted(BlockDriverState *bs) 2543 { 2544 BlockDriver *drv = bs->drv; 2545 int ret; 2546 if (!drv) 2547 return 0; 2548 if (!drv->bdrv_is_inserted) 2549 return !bs->tray_open; 2550 ret = drv->bdrv_is_inserted(bs); 2551 return ret; 2552 } 2553 2554 /** 2555 * Return TRUE if the media changed since the last call to this 2556 * function. It is currently only used for floppy disks 2557 */ 2558 int bdrv_media_changed(BlockDriverState *bs) 2559 { 2560 BlockDriver *drv = bs->drv; 2561 int ret; 2562 2563 if (!drv || !drv->bdrv_media_changed) 2564 ret = -ENOTSUP; 2565 else 2566 ret = drv->bdrv_media_changed(bs); 2567 if (ret == -ENOTSUP) 2568 ret = bs->media_changed; 2569 bs->media_changed = 0; 2570 return ret; 2571 } 2572 2573 /** 2574 * If eject_flag is TRUE, eject the media. Otherwise, close the tray 2575 */ 2576 int bdrv_eject(BlockDriverState *bs, int eject_flag) 2577 { 2578 BlockDriver *drv = bs->drv; 2579 int ret; 2580 2581 if (bs->locked) { 2582 return -EBUSY; 2583 } 2584 2585 if (!drv || !drv->bdrv_eject) { 2586 ret = -ENOTSUP; 2587 } else { 2588 ret = drv->bdrv_eject(bs, eject_flag); 2589 } 2590 if (ret == -ENOTSUP) { 2591 ret = 0; 2592 } 2593 if (ret >= 0) { 2594 bs->tray_open = eject_flag; 2595 } 2596 2597 return ret; 2598 } 2599 2600 int bdrv_is_locked(BlockDriverState *bs) 2601 { 2602 return bs->locked; 2603 } 2604 2605 /** 2606 * Lock or unlock the media (if it is locked, the user won't be able 2607 * to eject it manually). 2608 */ 2609 void bdrv_set_locked(BlockDriverState *bs, int locked) 2610 { 2611 BlockDriver *drv = bs->drv; 2612 2613 bs->locked = locked; 2614 if (drv && drv->bdrv_set_locked) { 2615 drv->bdrv_set_locked(bs, locked); 2616 } 2617 } 2618 2619 /* needed for generic scsi interface */ 2620 2621 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) 2622 { 2623 BlockDriver *drv = bs->drv; 2624 2625 if (drv && drv->bdrv_ioctl) 2626 return drv->bdrv_ioctl(bs, req, buf); 2627 return -ENOTSUP; 2628 } 2629 2630 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, 2631 unsigned long int req, void *buf, 2632 BlockDriverCompletionFunc *cb, void *opaque) 2633 { 2634 BlockDriver *drv = bs->drv; 2635 2636 if (drv && drv->bdrv_aio_ioctl) 2637 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque); 2638 return NULL; 2639 } 2640 2641 2642 2643 void *qemu_blockalign(BlockDriverState *bs, size_t size) 2644 { 2645 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size); 2646 } 2647 2648 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable) 2649 { 2650 int64_t bitmap_size; 2651 2652 bs->dirty_count = 0; 2653 if (enable) { 2654 if (!bs->dirty_bitmap) { 2655 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) + 2656 BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1; 2657 bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8; 2658 2659 bs->dirty_bitmap = qemu_mallocz(bitmap_size); 2660 } 2661 } else { 2662 if (bs->dirty_bitmap) { 2663 qemu_free(bs->dirty_bitmap); 2664 bs->dirty_bitmap = NULL; 2665 } 2666 } 2667 } 2668 2669 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector) 2670 { 2671 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK; 2672 2673 if (bs->dirty_bitmap && 2674 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) { 2675 return bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] & 2676 (1 << (chunk % (sizeof(unsigned long) * 8))); 2677 } else { 2678 return 0; 2679 } 2680 } 2681 2682 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, 2683 int nr_sectors) 2684 { 2685 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0); 2686 } 2687 2688 int64_t bdrv_get_dirty_count(BlockDriverState *bs) 2689 { 2690 return bs->dirty_count; 2691 } 2692