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