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); 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); 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 ret = drv->bdrv_truncate(bs, offset); 1136 if (ret == 0) { 1137 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS); 1138 } 1139 return ret; 1140 } 1141 1142 /** 1143 * Length of a file in bytes. Return < 0 if error or unknown. 1144 */ 1145 int64_t bdrv_getlength(BlockDriverState *bs) 1146 { 1147 BlockDriver *drv = bs->drv; 1148 if (!drv) 1149 return -ENOMEDIUM; 1150 1151 /* Fixed size devices use the total_sectors value for speed instead of 1152 issuing a length query (like lseek) on each call. Also, legacy block 1153 drivers don't provide a bdrv_getlength function and must use 1154 total_sectors. */ 1155 if (!bs->growable || !drv->bdrv_getlength) { 1156 return bs->total_sectors * BDRV_SECTOR_SIZE; 1157 } 1158 return drv->bdrv_getlength(bs); 1159 } 1160 1161 /* return 0 as number of sectors if no device present or error */ 1162 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) 1163 { 1164 int64_t length; 1165 length = bdrv_getlength(bs); 1166 if (length < 0) 1167 length = 0; 1168 else 1169 length = length >> BDRV_SECTOR_BITS; 1170 *nb_sectors_ptr = length; 1171 } 1172 1173 struct partition { 1174 uint8_t boot_ind; /* 0x80 - active */ 1175 uint8_t head; /* starting head */ 1176 uint8_t sector; /* starting sector */ 1177 uint8_t cyl; /* starting cylinder */ 1178 uint8_t sys_ind; /* What partition type */ 1179 uint8_t end_head; /* end head */ 1180 uint8_t end_sector; /* end sector */ 1181 uint8_t end_cyl; /* end cylinder */ 1182 uint32_t start_sect; /* starting sector counting from 0 */ 1183 uint32_t nr_sects; /* nr of sectors in partition */ 1184 } __attribute__((packed)); 1185 1186 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */ 1187 static int guess_disk_lchs(BlockDriverState *bs, 1188 int *pcylinders, int *pheads, int *psectors) 1189 { 1190 uint8_t buf[BDRV_SECTOR_SIZE]; 1191 int ret, i, heads, sectors, cylinders; 1192 struct partition *p; 1193 uint32_t nr_sects; 1194 uint64_t nb_sectors; 1195 1196 bdrv_get_geometry(bs, &nb_sectors); 1197 1198 ret = bdrv_read(bs, 0, buf, 1); 1199 if (ret < 0) 1200 return -1; 1201 /* test msdos magic */ 1202 if (buf[510] != 0x55 || buf[511] != 0xaa) 1203 return -1; 1204 for(i = 0; i < 4; i++) { 1205 p = ((struct partition *)(buf + 0x1be)) + i; 1206 nr_sects = le32_to_cpu(p->nr_sects); 1207 if (nr_sects && p->end_head) { 1208 /* We make the assumption that the partition terminates on 1209 a cylinder boundary */ 1210 heads = p->end_head + 1; 1211 sectors = p->end_sector & 63; 1212 if (sectors == 0) 1213 continue; 1214 cylinders = nb_sectors / (heads * sectors); 1215 if (cylinders < 1 || cylinders > 16383) 1216 continue; 1217 *pheads = heads; 1218 *psectors = sectors; 1219 *pcylinders = cylinders; 1220 #if 0 1221 printf("guessed geometry: LCHS=%d %d %d\n", 1222 cylinders, heads, sectors); 1223 #endif 1224 return 0; 1225 } 1226 } 1227 return -1; 1228 } 1229 1230 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs) 1231 { 1232 int translation, lba_detected = 0; 1233 int cylinders, heads, secs; 1234 uint64_t nb_sectors; 1235 1236 /* if a geometry hint is available, use it */ 1237 bdrv_get_geometry(bs, &nb_sectors); 1238 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs); 1239 translation = bdrv_get_translation_hint(bs); 1240 if (cylinders != 0) { 1241 *pcyls = cylinders; 1242 *pheads = heads; 1243 *psecs = secs; 1244 } else { 1245 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) { 1246 if (heads > 16) { 1247 /* if heads > 16, it means that a BIOS LBA 1248 translation was active, so the default 1249 hardware geometry is OK */ 1250 lba_detected = 1; 1251 goto default_geometry; 1252 } else { 1253 *pcyls = cylinders; 1254 *pheads = heads; 1255 *psecs = secs; 1256 /* disable any translation to be in sync with 1257 the logical geometry */ 1258 if (translation == BIOS_ATA_TRANSLATION_AUTO) { 1259 bdrv_set_translation_hint(bs, 1260 BIOS_ATA_TRANSLATION_NONE); 1261 } 1262 } 1263 } else { 1264 default_geometry: 1265 /* if no geometry, use a standard physical disk geometry */ 1266 cylinders = nb_sectors / (16 * 63); 1267 1268 if (cylinders > 16383) 1269 cylinders = 16383; 1270 else if (cylinders < 2) 1271 cylinders = 2; 1272 *pcyls = cylinders; 1273 *pheads = 16; 1274 *psecs = 63; 1275 if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) { 1276 if ((*pcyls * *pheads) <= 131072) { 1277 bdrv_set_translation_hint(bs, 1278 BIOS_ATA_TRANSLATION_LARGE); 1279 } else { 1280 bdrv_set_translation_hint(bs, 1281 BIOS_ATA_TRANSLATION_LBA); 1282 } 1283 } 1284 } 1285 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs); 1286 } 1287 } 1288 1289 void bdrv_set_geometry_hint(BlockDriverState *bs, 1290 int cyls, int heads, int secs) 1291 { 1292 bs->cyls = cyls; 1293 bs->heads = heads; 1294 bs->secs = secs; 1295 } 1296 1297 void bdrv_set_type_hint(BlockDriverState *bs, int type) 1298 { 1299 bs->type = type; 1300 bs->removable = ((type == BDRV_TYPE_CDROM || 1301 type == BDRV_TYPE_FLOPPY)); 1302 } 1303 1304 void bdrv_set_translation_hint(BlockDriverState *bs, int translation) 1305 { 1306 bs->translation = translation; 1307 } 1308 1309 void bdrv_get_geometry_hint(BlockDriverState *bs, 1310 int *pcyls, int *pheads, int *psecs) 1311 { 1312 *pcyls = bs->cyls; 1313 *pheads = bs->heads; 1314 *psecs = bs->secs; 1315 } 1316 1317 int bdrv_get_type_hint(BlockDriverState *bs) 1318 { 1319 return bs->type; 1320 } 1321 1322 int bdrv_get_translation_hint(BlockDriverState *bs) 1323 { 1324 return bs->translation; 1325 } 1326 1327 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error, 1328 BlockErrorAction on_write_error) 1329 { 1330 bs->on_read_error = on_read_error; 1331 bs->on_write_error = on_write_error; 1332 } 1333 1334 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read) 1335 { 1336 return is_read ? bs->on_read_error : bs->on_write_error; 1337 } 1338 1339 void bdrv_set_removable(BlockDriverState *bs, int removable) 1340 { 1341 bs->removable = removable; 1342 if (removable && bs == bs_snapshots) { 1343 bs_snapshots = NULL; 1344 } 1345 } 1346 1347 int bdrv_is_removable(BlockDriverState *bs) 1348 { 1349 return bs->removable; 1350 } 1351 1352 int bdrv_is_read_only(BlockDriverState *bs) 1353 { 1354 return bs->read_only; 1355 } 1356 1357 int bdrv_is_sg(BlockDriverState *bs) 1358 { 1359 return bs->sg; 1360 } 1361 1362 int bdrv_enable_write_cache(BlockDriverState *bs) 1363 { 1364 return bs->enable_write_cache; 1365 } 1366 1367 /* XXX: no longer used */ 1368 void bdrv_set_change_cb(BlockDriverState *bs, 1369 void (*change_cb)(void *opaque), void *opaque) 1370 { 1371 bs->change_cb = change_cb; 1372 bs->change_opaque = opaque; 1373 } 1374 1375 int bdrv_is_encrypted(BlockDriverState *bs) 1376 { 1377 if (bs->backing_hd && bs->backing_hd->encrypted) 1378 return 1; 1379 return bs->encrypted; 1380 } 1381 1382 int bdrv_key_required(BlockDriverState *bs) 1383 { 1384 BlockDriverState *backing_hd = bs->backing_hd; 1385 1386 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key) 1387 return 1; 1388 return (bs->encrypted && !bs->valid_key); 1389 } 1390 1391 int bdrv_set_key(BlockDriverState *bs, const char *key) 1392 { 1393 int ret; 1394 if (bs->backing_hd && bs->backing_hd->encrypted) { 1395 ret = bdrv_set_key(bs->backing_hd, key); 1396 if (ret < 0) 1397 return ret; 1398 if (!bs->encrypted) 1399 return 0; 1400 } 1401 if (!bs->encrypted) { 1402 return -EINVAL; 1403 } else if (!bs->drv || !bs->drv->bdrv_set_key) { 1404 return -ENOMEDIUM; 1405 } 1406 ret = bs->drv->bdrv_set_key(bs, key); 1407 if (ret < 0) { 1408 bs->valid_key = 0; 1409 } else if (!bs->valid_key) { 1410 bs->valid_key = 1; 1411 /* call the change callback now, we skipped it on open */ 1412 bs->media_changed = 1; 1413 if (bs->change_cb) 1414 bs->change_cb(bs->change_opaque); 1415 } 1416 return ret; 1417 } 1418 1419 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size) 1420 { 1421 if (!bs->drv) { 1422 buf[0] = '\0'; 1423 } else { 1424 pstrcpy(buf, buf_size, bs->drv->format_name); 1425 } 1426 } 1427 1428 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 1429 void *opaque) 1430 { 1431 BlockDriver *drv; 1432 1433 QLIST_FOREACH(drv, &bdrv_drivers, list) { 1434 it(opaque, drv->format_name); 1435 } 1436 } 1437 1438 BlockDriverState *bdrv_find(const char *name) 1439 { 1440 BlockDriverState *bs; 1441 1442 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1443 if (!strcmp(name, bs->device_name)) { 1444 return bs; 1445 } 1446 } 1447 return NULL; 1448 } 1449 1450 BlockDriverState *bdrv_next(BlockDriverState *bs) 1451 { 1452 if (!bs) { 1453 return QTAILQ_FIRST(&bdrv_states); 1454 } 1455 return QTAILQ_NEXT(bs, list); 1456 } 1457 1458 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque) 1459 { 1460 BlockDriverState *bs; 1461 1462 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1463 it(opaque, bs); 1464 } 1465 } 1466 1467 const char *bdrv_get_device_name(BlockDriverState *bs) 1468 { 1469 return bs->device_name; 1470 } 1471 1472 int bdrv_flush(BlockDriverState *bs) 1473 { 1474 if (bs->open_flags & BDRV_O_NO_FLUSH) { 1475 return 0; 1476 } 1477 1478 if (bs->drv && bs->drv->bdrv_flush) { 1479 return bs->drv->bdrv_flush(bs); 1480 } 1481 1482 /* 1483 * Some block drivers always operate in either writethrough or unsafe mode 1484 * and don't support bdrv_flush therefore. Usually qemu doesn't know how 1485 * the server works (because the behaviour is hardcoded or depends on 1486 * server-side configuration), so we can't ensure that everything is safe 1487 * on disk. Returning an error doesn't work because that would break guests 1488 * even if the server operates in writethrough mode. 1489 * 1490 * Let's hope the user knows what he's doing. 1491 */ 1492 return 0; 1493 } 1494 1495 void bdrv_flush_all(void) 1496 { 1497 BlockDriverState *bs; 1498 1499 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1500 if (bs->drv && !bdrv_is_read_only(bs) && 1501 (!bdrv_is_removable(bs) || bdrv_is_inserted(bs))) { 1502 bdrv_flush(bs); 1503 } 1504 } 1505 } 1506 1507 int bdrv_has_zero_init(BlockDriverState *bs) 1508 { 1509 assert(bs->drv); 1510 1511 if (bs->drv->bdrv_has_zero_init) { 1512 return bs->drv->bdrv_has_zero_init(bs); 1513 } 1514 1515 return 1; 1516 } 1517 1518 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors) 1519 { 1520 if (!bs->drv) { 1521 return -ENOMEDIUM; 1522 } 1523 if (!bs->drv->bdrv_discard) { 1524 return 0; 1525 } 1526 return bs->drv->bdrv_discard(bs, sector_num, nb_sectors); 1527 } 1528 1529 /* 1530 * Returns true iff the specified sector is present in the disk image. Drivers 1531 * not implementing the functionality are assumed to not support backing files, 1532 * hence all their sectors are reported as allocated. 1533 * 1534 * 'pnum' is set to the number of sectors (including and immediately following 1535 * the specified sector) that are known to be in the same 1536 * allocated/unallocated state. 1537 * 1538 * 'nb_sectors' is the max value 'pnum' should be set to. 1539 */ 1540 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors, 1541 int *pnum) 1542 { 1543 int64_t n; 1544 if (!bs->drv->bdrv_is_allocated) { 1545 if (sector_num >= bs->total_sectors) { 1546 *pnum = 0; 1547 return 0; 1548 } 1549 n = bs->total_sectors - sector_num; 1550 *pnum = (n < nb_sectors) ? (n) : (nb_sectors); 1551 return 1; 1552 } 1553 return bs->drv->bdrv_is_allocated(bs, sector_num, nb_sectors, pnum); 1554 } 1555 1556 void bdrv_mon_event(const BlockDriverState *bdrv, 1557 BlockMonEventAction action, int is_read) 1558 { 1559 QObject *data; 1560 const char *action_str; 1561 1562 switch (action) { 1563 case BDRV_ACTION_REPORT: 1564 action_str = "report"; 1565 break; 1566 case BDRV_ACTION_IGNORE: 1567 action_str = "ignore"; 1568 break; 1569 case BDRV_ACTION_STOP: 1570 action_str = "stop"; 1571 break; 1572 default: 1573 abort(); 1574 } 1575 1576 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }", 1577 bdrv->device_name, 1578 action_str, 1579 is_read ? "read" : "write"); 1580 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data); 1581 1582 qobject_decref(data); 1583 } 1584 1585 static void bdrv_print_dict(QObject *obj, void *opaque) 1586 { 1587 QDict *bs_dict; 1588 Monitor *mon = opaque; 1589 1590 bs_dict = qobject_to_qdict(obj); 1591 1592 monitor_printf(mon, "%s: type=%s removable=%d", 1593 qdict_get_str(bs_dict, "device"), 1594 qdict_get_str(bs_dict, "type"), 1595 qdict_get_bool(bs_dict, "removable")); 1596 1597 if (qdict_get_bool(bs_dict, "removable")) { 1598 monitor_printf(mon, " locked=%d", qdict_get_bool(bs_dict, "locked")); 1599 } 1600 1601 if (qdict_haskey(bs_dict, "inserted")) { 1602 QDict *qdict = qobject_to_qdict(qdict_get(bs_dict, "inserted")); 1603 1604 monitor_printf(mon, " file="); 1605 monitor_print_filename(mon, qdict_get_str(qdict, "file")); 1606 if (qdict_haskey(qdict, "backing_file")) { 1607 monitor_printf(mon, " backing_file="); 1608 monitor_print_filename(mon, qdict_get_str(qdict, "backing_file")); 1609 } 1610 monitor_printf(mon, " ro=%d drv=%s encrypted=%d", 1611 qdict_get_bool(qdict, "ro"), 1612 qdict_get_str(qdict, "drv"), 1613 qdict_get_bool(qdict, "encrypted")); 1614 } else { 1615 monitor_printf(mon, " [not inserted]"); 1616 } 1617 1618 monitor_printf(mon, "\n"); 1619 } 1620 1621 void bdrv_info_print(Monitor *mon, const QObject *data) 1622 { 1623 qlist_iter(qobject_to_qlist(data), bdrv_print_dict, mon); 1624 } 1625 1626 void bdrv_info(Monitor *mon, QObject **ret_data) 1627 { 1628 QList *bs_list; 1629 BlockDriverState *bs; 1630 1631 bs_list = qlist_new(); 1632 1633 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1634 QObject *bs_obj; 1635 const char *type = "unknown"; 1636 1637 switch(bs->type) { 1638 case BDRV_TYPE_HD: 1639 type = "hd"; 1640 break; 1641 case BDRV_TYPE_CDROM: 1642 type = "cdrom"; 1643 break; 1644 case BDRV_TYPE_FLOPPY: 1645 type = "floppy"; 1646 break; 1647 } 1648 1649 bs_obj = qobject_from_jsonf("{ 'device': %s, 'type': %s, " 1650 "'removable': %i, 'locked': %i }", 1651 bs->device_name, type, bs->removable, 1652 bs->locked); 1653 1654 if (bs->drv) { 1655 QObject *obj; 1656 QDict *bs_dict = qobject_to_qdict(bs_obj); 1657 1658 obj = qobject_from_jsonf("{ 'file': %s, 'ro': %i, 'drv': %s, " 1659 "'encrypted': %i }", 1660 bs->filename, bs->read_only, 1661 bs->drv->format_name, 1662 bdrv_is_encrypted(bs)); 1663 if (bs->backing_file[0] != '\0') { 1664 QDict *qdict = qobject_to_qdict(obj); 1665 qdict_put(qdict, "backing_file", 1666 qstring_from_str(bs->backing_file)); 1667 } 1668 1669 qdict_put_obj(bs_dict, "inserted", obj); 1670 } 1671 qlist_append_obj(bs_list, bs_obj); 1672 } 1673 1674 *ret_data = QOBJECT(bs_list); 1675 } 1676 1677 static void bdrv_stats_iter(QObject *data, void *opaque) 1678 { 1679 QDict *qdict; 1680 Monitor *mon = opaque; 1681 1682 qdict = qobject_to_qdict(data); 1683 monitor_printf(mon, "%s:", qdict_get_str(qdict, "device")); 1684 1685 qdict = qobject_to_qdict(qdict_get(qdict, "stats")); 1686 monitor_printf(mon, " rd_bytes=%" PRId64 1687 " wr_bytes=%" PRId64 1688 " rd_operations=%" PRId64 1689 " wr_operations=%" PRId64 1690 "\n", 1691 qdict_get_int(qdict, "rd_bytes"), 1692 qdict_get_int(qdict, "wr_bytes"), 1693 qdict_get_int(qdict, "rd_operations"), 1694 qdict_get_int(qdict, "wr_operations")); 1695 } 1696 1697 void bdrv_stats_print(Monitor *mon, const QObject *data) 1698 { 1699 qlist_iter(qobject_to_qlist(data), bdrv_stats_iter, mon); 1700 } 1701 1702 static QObject* bdrv_info_stats_bs(BlockDriverState *bs) 1703 { 1704 QObject *res; 1705 QDict *dict; 1706 1707 res = qobject_from_jsonf("{ 'stats': {" 1708 "'rd_bytes': %" PRId64 "," 1709 "'wr_bytes': %" PRId64 "," 1710 "'rd_operations': %" PRId64 "," 1711 "'wr_operations': %" PRId64 "," 1712 "'wr_highest_offset': %" PRId64 1713 "} }", 1714 bs->rd_bytes, bs->wr_bytes, 1715 bs->rd_ops, bs->wr_ops, 1716 bs->wr_highest_sector * 1717 (uint64_t)BDRV_SECTOR_SIZE); 1718 dict = qobject_to_qdict(res); 1719 1720 if (*bs->device_name) { 1721 qdict_put(dict, "device", qstring_from_str(bs->device_name)); 1722 } 1723 1724 if (bs->file) { 1725 QObject *parent = bdrv_info_stats_bs(bs->file); 1726 qdict_put_obj(dict, "parent", parent); 1727 } 1728 1729 return res; 1730 } 1731 1732 void bdrv_info_stats(Monitor *mon, QObject **ret_data) 1733 { 1734 QObject *obj; 1735 QList *devices; 1736 BlockDriverState *bs; 1737 1738 devices = qlist_new(); 1739 1740 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1741 obj = bdrv_info_stats_bs(bs); 1742 qlist_append_obj(devices, obj); 1743 } 1744 1745 *ret_data = QOBJECT(devices); 1746 } 1747 1748 const char *bdrv_get_encrypted_filename(BlockDriverState *bs) 1749 { 1750 if (bs->backing_hd && bs->backing_hd->encrypted) 1751 return bs->backing_file; 1752 else if (bs->encrypted) 1753 return bs->filename; 1754 else 1755 return NULL; 1756 } 1757 1758 void bdrv_get_backing_filename(BlockDriverState *bs, 1759 char *filename, int filename_size) 1760 { 1761 if (!bs->backing_file) { 1762 pstrcpy(filename, filename_size, ""); 1763 } else { 1764 pstrcpy(filename, filename_size, bs->backing_file); 1765 } 1766 } 1767 1768 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 1769 const uint8_t *buf, int nb_sectors) 1770 { 1771 BlockDriver *drv = bs->drv; 1772 if (!drv) 1773 return -ENOMEDIUM; 1774 if (!drv->bdrv_write_compressed) 1775 return -ENOTSUP; 1776 if (bdrv_check_request(bs, sector_num, nb_sectors)) 1777 return -EIO; 1778 1779 if (bs->dirty_bitmap) { 1780 set_dirty_bitmap(bs, sector_num, nb_sectors, 1); 1781 } 1782 1783 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors); 1784 } 1785 1786 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 1787 { 1788 BlockDriver *drv = bs->drv; 1789 if (!drv) 1790 return -ENOMEDIUM; 1791 if (!drv->bdrv_get_info) 1792 return -ENOTSUP; 1793 memset(bdi, 0, sizeof(*bdi)); 1794 return drv->bdrv_get_info(bs, bdi); 1795 } 1796 1797 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf, 1798 int64_t pos, int size) 1799 { 1800 BlockDriver *drv = bs->drv; 1801 if (!drv) 1802 return -ENOMEDIUM; 1803 if (drv->bdrv_save_vmstate) 1804 return drv->bdrv_save_vmstate(bs, buf, pos, size); 1805 if (bs->file) 1806 return bdrv_save_vmstate(bs->file, buf, pos, size); 1807 return -ENOTSUP; 1808 } 1809 1810 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf, 1811 int64_t pos, int size) 1812 { 1813 BlockDriver *drv = bs->drv; 1814 if (!drv) 1815 return -ENOMEDIUM; 1816 if (drv->bdrv_load_vmstate) 1817 return drv->bdrv_load_vmstate(bs, buf, pos, size); 1818 if (bs->file) 1819 return bdrv_load_vmstate(bs->file, buf, pos, size); 1820 return -ENOTSUP; 1821 } 1822 1823 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event) 1824 { 1825 BlockDriver *drv = bs->drv; 1826 1827 if (!drv || !drv->bdrv_debug_event) { 1828 return; 1829 } 1830 1831 return drv->bdrv_debug_event(bs, event); 1832 1833 } 1834 1835 /**************************************************************/ 1836 /* handling of snapshots */ 1837 1838 int bdrv_can_snapshot(BlockDriverState *bs) 1839 { 1840 BlockDriver *drv = bs->drv; 1841 if (!drv || bdrv_is_removable(bs) || bdrv_is_read_only(bs)) { 1842 return 0; 1843 } 1844 1845 if (!drv->bdrv_snapshot_create) { 1846 if (bs->file != NULL) { 1847 return bdrv_can_snapshot(bs->file); 1848 } 1849 return 0; 1850 } 1851 1852 return 1; 1853 } 1854 1855 int bdrv_is_snapshot(BlockDriverState *bs) 1856 { 1857 return !!(bs->open_flags & BDRV_O_SNAPSHOT); 1858 } 1859 1860 BlockDriverState *bdrv_snapshots(void) 1861 { 1862 BlockDriverState *bs; 1863 1864 if (bs_snapshots) { 1865 return bs_snapshots; 1866 } 1867 1868 bs = NULL; 1869 while ((bs = bdrv_next(bs))) { 1870 if (bdrv_can_snapshot(bs)) { 1871 bs_snapshots = bs; 1872 return bs; 1873 } 1874 } 1875 return NULL; 1876 } 1877 1878 int bdrv_snapshot_create(BlockDriverState *bs, 1879 QEMUSnapshotInfo *sn_info) 1880 { 1881 BlockDriver *drv = bs->drv; 1882 if (!drv) 1883 return -ENOMEDIUM; 1884 if (drv->bdrv_snapshot_create) 1885 return drv->bdrv_snapshot_create(bs, sn_info); 1886 if (bs->file) 1887 return bdrv_snapshot_create(bs->file, sn_info); 1888 return -ENOTSUP; 1889 } 1890 1891 int bdrv_snapshot_goto(BlockDriverState *bs, 1892 const char *snapshot_id) 1893 { 1894 BlockDriver *drv = bs->drv; 1895 int ret, open_ret; 1896 1897 if (!drv) 1898 return -ENOMEDIUM; 1899 if (drv->bdrv_snapshot_goto) 1900 return drv->bdrv_snapshot_goto(bs, snapshot_id); 1901 1902 if (bs->file) { 1903 drv->bdrv_close(bs); 1904 ret = bdrv_snapshot_goto(bs->file, snapshot_id); 1905 open_ret = drv->bdrv_open(bs, bs->open_flags); 1906 if (open_ret < 0) { 1907 bdrv_delete(bs->file); 1908 bs->drv = NULL; 1909 return open_ret; 1910 } 1911 return ret; 1912 } 1913 1914 return -ENOTSUP; 1915 } 1916 1917 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id) 1918 { 1919 BlockDriver *drv = bs->drv; 1920 if (!drv) 1921 return -ENOMEDIUM; 1922 if (drv->bdrv_snapshot_delete) 1923 return drv->bdrv_snapshot_delete(bs, snapshot_id); 1924 if (bs->file) 1925 return bdrv_snapshot_delete(bs->file, snapshot_id); 1926 return -ENOTSUP; 1927 } 1928 1929 int bdrv_snapshot_list(BlockDriverState *bs, 1930 QEMUSnapshotInfo **psn_info) 1931 { 1932 BlockDriver *drv = bs->drv; 1933 if (!drv) 1934 return -ENOMEDIUM; 1935 if (drv->bdrv_snapshot_list) 1936 return drv->bdrv_snapshot_list(bs, psn_info); 1937 if (bs->file) 1938 return bdrv_snapshot_list(bs->file, psn_info); 1939 return -ENOTSUP; 1940 } 1941 1942 int bdrv_snapshot_load_tmp(BlockDriverState *bs, 1943 const char *snapshot_name) 1944 { 1945 BlockDriver *drv = bs->drv; 1946 if (!drv) { 1947 return -ENOMEDIUM; 1948 } 1949 if (!bs->read_only) { 1950 return -EINVAL; 1951 } 1952 if (drv->bdrv_snapshot_load_tmp) { 1953 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name); 1954 } 1955 return -ENOTSUP; 1956 } 1957 1958 #define NB_SUFFIXES 4 1959 1960 char *get_human_readable_size(char *buf, int buf_size, int64_t size) 1961 { 1962 static const char suffixes[NB_SUFFIXES] = "KMGT"; 1963 int64_t base; 1964 int i; 1965 1966 if (size <= 999) { 1967 snprintf(buf, buf_size, "%" PRId64, size); 1968 } else { 1969 base = 1024; 1970 for(i = 0; i < NB_SUFFIXES; i++) { 1971 if (size < (10 * base)) { 1972 snprintf(buf, buf_size, "%0.1f%c", 1973 (double)size / base, 1974 suffixes[i]); 1975 break; 1976 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) { 1977 snprintf(buf, buf_size, "%" PRId64 "%c", 1978 ((size + (base >> 1)) / base), 1979 suffixes[i]); 1980 break; 1981 } 1982 base = base * 1024; 1983 } 1984 } 1985 return buf; 1986 } 1987 1988 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn) 1989 { 1990 char buf1[128], date_buf[128], clock_buf[128]; 1991 #ifdef _WIN32 1992 struct tm *ptm; 1993 #else 1994 struct tm tm; 1995 #endif 1996 time_t ti; 1997 int64_t secs; 1998 1999 if (!sn) { 2000 snprintf(buf, buf_size, 2001 "%-10s%-20s%7s%20s%15s", 2002 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK"); 2003 } else { 2004 ti = sn->date_sec; 2005 #ifdef _WIN32 2006 ptm = localtime(&ti); 2007 strftime(date_buf, sizeof(date_buf), 2008 "%Y-%m-%d %H:%M:%S", ptm); 2009 #else 2010 localtime_r(&ti, &tm); 2011 strftime(date_buf, sizeof(date_buf), 2012 "%Y-%m-%d %H:%M:%S", &tm); 2013 #endif 2014 secs = sn->vm_clock_nsec / 1000000000; 2015 snprintf(clock_buf, sizeof(clock_buf), 2016 "%02d:%02d:%02d.%03d", 2017 (int)(secs / 3600), 2018 (int)((secs / 60) % 60), 2019 (int)(secs % 60), 2020 (int)((sn->vm_clock_nsec / 1000000) % 1000)); 2021 snprintf(buf, buf_size, 2022 "%-10s%-20s%7s%20s%15s", 2023 sn->id_str, sn->name, 2024 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size), 2025 date_buf, 2026 clock_buf); 2027 } 2028 return buf; 2029 } 2030 2031 2032 /**************************************************************/ 2033 /* async I/Os */ 2034 2035 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, 2036 QEMUIOVector *qiov, int nb_sectors, 2037 BlockDriverCompletionFunc *cb, void *opaque) 2038 { 2039 BlockDriver *drv = bs->drv; 2040 BlockDriverAIOCB *ret; 2041 2042 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque); 2043 2044 if (!drv) 2045 return NULL; 2046 if (bdrv_check_request(bs, sector_num, nb_sectors)) 2047 return NULL; 2048 2049 ret = drv->bdrv_aio_readv(bs, sector_num, qiov, nb_sectors, 2050 cb, opaque); 2051 2052 if (ret) { 2053 /* Update stats even though technically transfer has not happened. */ 2054 bs->rd_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE; 2055 bs->rd_ops ++; 2056 } 2057 2058 return ret; 2059 } 2060 2061 typedef struct BlockCompleteData { 2062 BlockDriverCompletionFunc *cb; 2063 void *opaque; 2064 BlockDriverState *bs; 2065 int64_t sector_num; 2066 int nb_sectors; 2067 } BlockCompleteData; 2068 2069 static void block_complete_cb(void *opaque, int ret) 2070 { 2071 BlockCompleteData *b = opaque; 2072 2073 if (b->bs->dirty_bitmap) { 2074 set_dirty_bitmap(b->bs, b->sector_num, b->nb_sectors, 1); 2075 } 2076 b->cb(b->opaque, ret); 2077 qemu_free(b); 2078 } 2079 2080 static BlockCompleteData *blk_dirty_cb_alloc(BlockDriverState *bs, 2081 int64_t sector_num, 2082 int nb_sectors, 2083 BlockDriverCompletionFunc *cb, 2084 void *opaque) 2085 { 2086 BlockCompleteData *blkdata = qemu_mallocz(sizeof(BlockCompleteData)); 2087 2088 blkdata->bs = bs; 2089 blkdata->cb = cb; 2090 blkdata->opaque = opaque; 2091 blkdata->sector_num = sector_num; 2092 blkdata->nb_sectors = nb_sectors; 2093 2094 return blkdata; 2095 } 2096 2097 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, 2098 QEMUIOVector *qiov, int nb_sectors, 2099 BlockDriverCompletionFunc *cb, void *opaque) 2100 { 2101 BlockDriver *drv = bs->drv; 2102 BlockDriverAIOCB *ret; 2103 BlockCompleteData *blk_cb_data; 2104 2105 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque); 2106 2107 if (!drv) 2108 return NULL; 2109 if (bs->read_only) 2110 return NULL; 2111 if (bdrv_check_request(bs, sector_num, nb_sectors)) 2112 return NULL; 2113 2114 if (bs->dirty_bitmap) { 2115 blk_cb_data = blk_dirty_cb_alloc(bs, sector_num, nb_sectors, cb, 2116 opaque); 2117 cb = &block_complete_cb; 2118 opaque = blk_cb_data; 2119 } 2120 2121 ret = drv->bdrv_aio_writev(bs, sector_num, qiov, nb_sectors, 2122 cb, opaque); 2123 2124 if (ret) { 2125 /* Update stats even though technically transfer has not happened. */ 2126 bs->wr_bytes += (unsigned) nb_sectors * BDRV_SECTOR_SIZE; 2127 bs->wr_ops ++; 2128 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) { 2129 bs->wr_highest_sector = sector_num + nb_sectors - 1; 2130 } 2131 } 2132 2133 return ret; 2134 } 2135 2136 2137 typedef struct MultiwriteCB { 2138 int error; 2139 int num_requests; 2140 int num_callbacks; 2141 struct { 2142 BlockDriverCompletionFunc *cb; 2143 void *opaque; 2144 QEMUIOVector *free_qiov; 2145 void *free_buf; 2146 } callbacks[]; 2147 } MultiwriteCB; 2148 2149 static void multiwrite_user_cb(MultiwriteCB *mcb) 2150 { 2151 int i; 2152 2153 for (i = 0; i < mcb->num_callbacks; i++) { 2154 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error); 2155 if (mcb->callbacks[i].free_qiov) { 2156 qemu_iovec_destroy(mcb->callbacks[i].free_qiov); 2157 } 2158 qemu_free(mcb->callbacks[i].free_qiov); 2159 qemu_vfree(mcb->callbacks[i].free_buf); 2160 } 2161 } 2162 2163 static void multiwrite_cb(void *opaque, int ret) 2164 { 2165 MultiwriteCB *mcb = opaque; 2166 2167 trace_multiwrite_cb(mcb, ret); 2168 2169 if (ret < 0 && !mcb->error) { 2170 mcb->error = ret; 2171 } 2172 2173 mcb->num_requests--; 2174 if (mcb->num_requests == 0) { 2175 multiwrite_user_cb(mcb); 2176 qemu_free(mcb); 2177 } 2178 } 2179 2180 static int multiwrite_req_compare(const void *a, const void *b) 2181 { 2182 const BlockRequest *req1 = a, *req2 = b; 2183 2184 /* 2185 * Note that we can't simply subtract req2->sector from req1->sector 2186 * here as that could overflow the return value. 2187 */ 2188 if (req1->sector > req2->sector) { 2189 return 1; 2190 } else if (req1->sector < req2->sector) { 2191 return -1; 2192 } else { 2193 return 0; 2194 } 2195 } 2196 2197 /* 2198 * Takes a bunch of requests and tries to merge them. Returns the number of 2199 * requests that remain after merging. 2200 */ 2201 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs, 2202 int num_reqs, MultiwriteCB *mcb) 2203 { 2204 int i, outidx; 2205 2206 // Sort requests by start sector 2207 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare); 2208 2209 // Check if adjacent requests touch the same clusters. If so, combine them, 2210 // filling up gaps with zero sectors. 2211 outidx = 0; 2212 for (i = 1; i < num_reqs; i++) { 2213 int merge = 0; 2214 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors; 2215 2216 // This handles the cases that are valid for all block drivers, namely 2217 // exactly sequential writes and overlapping writes. 2218 if (reqs[i].sector <= oldreq_last) { 2219 merge = 1; 2220 } 2221 2222 // The block driver may decide that it makes sense to combine requests 2223 // even if there is a gap of some sectors between them. In this case, 2224 // the gap is filled with zeros (therefore only applicable for yet 2225 // unused space in format like qcow2). 2226 if (!merge && bs->drv->bdrv_merge_requests) { 2227 merge = bs->drv->bdrv_merge_requests(bs, &reqs[outidx], &reqs[i]); 2228 } 2229 2230 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) { 2231 merge = 0; 2232 } 2233 2234 if (merge) { 2235 size_t size; 2236 QEMUIOVector *qiov = qemu_mallocz(sizeof(*qiov)); 2237 qemu_iovec_init(qiov, 2238 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1); 2239 2240 // Add the first request to the merged one. If the requests are 2241 // overlapping, drop the last sectors of the first request. 2242 size = (reqs[i].sector - reqs[outidx].sector) << 9; 2243 qemu_iovec_concat(qiov, reqs[outidx].qiov, size); 2244 2245 // We might need to add some zeros between the two requests 2246 if (reqs[i].sector > oldreq_last) { 2247 size_t zero_bytes = (reqs[i].sector - oldreq_last) << 9; 2248 uint8_t *buf = qemu_blockalign(bs, zero_bytes); 2249 memset(buf, 0, zero_bytes); 2250 qemu_iovec_add(qiov, buf, zero_bytes); 2251 mcb->callbacks[i].free_buf = buf; 2252 } 2253 2254 // Add the second request 2255 qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size); 2256 2257 reqs[outidx].nb_sectors = qiov->size >> 9; 2258 reqs[outidx].qiov = qiov; 2259 2260 mcb->callbacks[i].free_qiov = reqs[outidx].qiov; 2261 } else { 2262 outidx++; 2263 reqs[outidx].sector = reqs[i].sector; 2264 reqs[outidx].nb_sectors = reqs[i].nb_sectors; 2265 reqs[outidx].qiov = reqs[i].qiov; 2266 } 2267 } 2268 2269 return outidx + 1; 2270 } 2271 2272 /* 2273 * Submit multiple AIO write requests at once. 2274 * 2275 * On success, the function returns 0 and all requests in the reqs array have 2276 * been submitted. In error case this function returns -1, and any of the 2277 * requests may or may not be submitted yet. In particular, this means that the 2278 * callback will be called for some of the requests, for others it won't. The 2279 * caller must check the error field of the BlockRequest to wait for the right 2280 * callbacks (if error != 0, no callback will be called). 2281 * 2282 * The implementation may modify the contents of the reqs array, e.g. to merge 2283 * requests. However, the fields opaque and error are left unmodified as they 2284 * are used to signal failure for a single request to the caller. 2285 */ 2286 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs) 2287 { 2288 BlockDriverAIOCB *acb; 2289 MultiwriteCB *mcb; 2290 int i; 2291 2292 if (num_reqs == 0) { 2293 return 0; 2294 } 2295 2296 // Create MultiwriteCB structure 2297 mcb = qemu_mallocz(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks)); 2298 mcb->num_requests = 0; 2299 mcb->num_callbacks = num_reqs; 2300 2301 for (i = 0; i < num_reqs; i++) { 2302 mcb->callbacks[i].cb = reqs[i].cb; 2303 mcb->callbacks[i].opaque = reqs[i].opaque; 2304 } 2305 2306 // Check for mergable requests 2307 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb); 2308 2309 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs); 2310 2311 /* 2312 * Run the aio requests. As soon as one request can't be submitted 2313 * successfully, fail all requests that are not yet submitted (we must 2314 * return failure for all requests anyway) 2315 * 2316 * num_requests cannot be set to the right value immediately: If 2317 * bdrv_aio_writev fails for some request, num_requests would be too high 2318 * and therefore multiwrite_cb() would never recognize the multiwrite 2319 * request as completed. We also cannot use the loop variable i to set it 2320 * when the first request fails because the callback may already have been 2321 * called for previously submitted requests. Thus, num_requests must be 2322 * incremented for each request that is submitted. 2323 * 2324 * The problem that callbacks may be called early also means that we need 2325 * to take care that num_requests doesn't become 0 before all requests are 2326 * submitted - multiwrite_cb() would consider the multiwrite request 2327 * completed. A dummy request that is "completed" by a manual call to 2328 * multiwrite_cb() takes care of this. 2329 */ 2330 mcb->num_requests = 1; 2331 2332 // Run the aio requests 2333 for (i = 0; i < num_reqs; i++) { 2334 mcb->num_requests++; 2335 acb = bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov, 2336 reqs[i].nb_sectors, multiwrite_cb, mcb); 2337 2338 if (acb == NULL) { 2339 // We can only fail the whole thing if no request has been 2340 // submitted yet. Otherwise we'll wait for the submitted AIOs to 2341 // complete and report the error in the callback. 2342 if (i == 0) { 2343 trace_bdrv_aio_multiwrite_earlyfail(mcb); 2344 goto fail; 2345 } else { 2346 trace_bdrv_aio_multiwrite_latefail(mcb, i); 2347 multiwrite_cb(mcb, -EIO); 2348 break; 2349 } 2350 } 2351 } 2352 2353 /* Complete the dummy request */ 2354 multiwrite_cb(mcb, 0); 2355 2356 return 0; 2357 2358 fail: 2359 for (i = 0; i < mcb->num_callbacks; i++) { 2360 reqs[i].error = -EIO; 2361 } 2362 qemu_free(mcb); 2363 return -1; 2364 } 2365 2366 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, 2367 BlockDriverCompletionFunc *cb, void *opaque) 2368 { 2369 BlockDriver *drv = bs->drv; 2370 2371 if (bs->open_flags & BDRV_O_NO_FLUSH) { 2372 return bdrv_aio_noop_em(bs, cb, opaque); 2373 } 2374 2375 if (!drv) 2376 return NULL; 2377 return drv->bdrv_aio_flush(bs, cb, opaque); 2378 } 2379 2380 void bdrv_aio_cancel(BlockDriverAIOCB *acb) 2381 { 2382 acb->pool->cancel(acb); 2383 } 2384 2385 2386 /**************************************************************/ 2387 /* async block device emulation */ 2388 2389 typedef struct BlockDriverAIOCBSync { 2390 BlockDriverAIOCB common; 2391 QEMUBH *bh; 2392 int ret; 2393 /* vector translation state */ 2394 QEMUIOVector *qiov; 2395 uint8_t *bounce; 2396 int is_write; 2397 } BlockDriverAIOCBSync; 2398 2399 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb) 2400 { 2401 BlockDriverAIOCBSync *acb = 2402 container_of(blockacb, BlockDriverAIOCBSync, common); 2403 qemu_bh_delete(acb->bh); 2404 acb->bh = NULL; 2405 qemu_aio_release(acb); 2406 } 2407 2408 static AIOPool bdrv_em_aio_pool = { 2409 .aiocb_size = sizeof(BlockDriverAIOCBSync), 2410 .cancel = bdrv_aio_cancel_em, 2411 }; 2412 2413 static void bdrv_aio_bh_cb(void *opaque) 2414 { 2415 BlockDriverAIOCBSync *acb = opaque; 2416 2417 if (!acb->is_write) 2418 qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size); 2419 qemu_vfree(acb->bounce); 2420 acb->common.cb(acb->common.opaque, acb->ret); 2421 qemu_bh_delete(acb->bh); 2422 acb->bh = NULL; 2423 qemu_aio_release(acb); 2424 } 2425 2426 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, 2427 int64_t sector_num, 2428 QEMUIOVector *qiov, 2429 int nb_sectors, 2430 BlockDriverCompletionFunc *cb, 2431 void *opaque, 2432 int is_write) 2433 2434 { 2435 BlockDriverAIOCBSync *acb; 2436 2437 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque); 2438 acb->is_write = is_write; 2439 acb->qiov = qiov; 2440 acb->bounce = qemu_blockalign(bs, qiov->size); 2441 2442 if (!acb->bh) 2443 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb); 2444 2445 if (is_write) { 2446 qemu_iovec_to_buffer(acb->qiov, acb->bounce); 2447 acb->ret = bdrv_write(bs, sector_num, acb->bounce, nb_sectors); 2448 } else { 2449 acb->ret = bdrv_read(bs, sector_num, acb->bounce, nb_sectors); 2450 } 2451 2452 qemu_bh_schedule(acb->bh); 2453 2454 return &acb->common; 2455 } 2456 2457 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, 2458 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 2459 BlockDriverCompletionFunc *cb, void *opaque) 2460 { 2461 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); 2462 } 2463 2464 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, 2465 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 2466 BlockDriverCompletionFunc *cb, void *opaque) 2467 { 2468 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); 2469 } 2470 2471 static BlockDriverAIOCB *bdrv_aio_flush_em(BlockDriverState *bs, 2472 BlockDriverCompletionFunc *cb, void *opaque) 2473 { 2474 BlockDriverAIOCBSync *acb; 2475 2476 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque); 2477 acb->is_write = 1; /* don't bounce in the completion hadler */ 2478 acb->qiov = NULL; 2479 acb->bounce = NULL; 2480 acb->ret = 0; 2481 2482 if (!acb->bh) 2483 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb); 2484 2485 bdrv_flush(bs); 2486 qemu_bh_schedule(acb->bh); 2487 return &acb->common; 2488 } 2489 2490 static BlockDriverAIOCB *bdrv_aio_noop_em(BlockDriverState *bs, 2491 BlockDriverCompletionFunc *cb, void *opaque) 2492 { 2493 BlockDriverAIOCBSync *acb; 2494 2495 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque); 2496 acb->is_write = 1; /* don't bounce in the completion handler */ 2497 acb->qiov = NULL; 2498 acb->bounce = NULL; 2499 acb->ret = 0; 2500 2501 if (!acb->bh) { 2502 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb); 2503 } 2504 2505 qemu_bh_schedule(acb->bh); 2506 return &acb->common; 2507 } 2508 2509 /**************************************************************/ 2510 /* sync block device emulation */ 2511 2512 static void bdrv_rw_em_cb(void *opaque, int ret) 2513 { 2514 *(int *)opaque = ret; 2515 } 2516 2517 #define NOT_DONE 0x7fffffff 2518 2519 static int bdrv_read_em(BlockDriverState *bs, int64_t sector_num, 2520 uint8_t *buf, int nb_sectors) 2521 { 2522 int async_ret; 2523 BlockDriverAIOCB *acb; 2524 struct iovec iov; 2525 QEMUIOVector qiov; 2526 2527 async_context_push(); 2528 2529 async_ret = NOT_DONE; 2530 iov.iov_base = (void *)buf; 2531 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE; 2532 qemu_iovec_init_external(&qiov, &iov, 1); 2533 acb = bdrv_aio_readv(bs, sector_num, &qiov, nb_sectors, 2534 bdrv_rw_em_cb, &async_ret); 2535 if (acb == NULL) { 2536 async_ret = -1; 2537 goto fail; 2538 } 2539 2540 while (async_ret == NOT_DONE) { 2541 qemu_aio_wait(); 2542 } 2543 2544 2545 fail: 2546 async_context_pop(); 2547 return async_ret; 2548 } 2549 2550 static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num, 2551 const uint8_t *buf, int nb_sectors) 2552 { 2553 int async_ret; 2554 BlockDriverAIOCB *acb; 2555 struct iovec iov; 2556 QEMUIOVector qiov; 2557 2558 async_context_push(); 2559 2560 async_ret = NOT_DONE; 2561 iov.iov_base = (void *)buf; 2562 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE; 2563 qemu_iovec_init_external(&qiov, &iov, 1); 2564 acb = bdrv_aio_writev(bs, sector_num, &qiov, nb_sectors, 2565 bdrv_rw_em_cb, &async_ret); 2566 if (acb == NULL) { 2567 async_ret = -1; 2568 goto fail; 2569 } 2570 while (async_ret == NOT_DONE) { 2571 qemu_aio_wait(); 2572 } 2573 2574 fail: 2575 async_context_pop(); 2576 return async_ret; 2577 } 2578 2579 void bdrv_init(void) 2580 { 2581 module_call_init(MODULE_INIT_BLOCK); 2582 } 2583 2584 void bdrv_init_with_whitelist(void) 2585 { 2586 use_bdrv_whitelist = 1; 2587 bdrv_init(); 2588 } 2589 2590 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs, 2591 BlockDriverCompletionFunc *cb, void *opaque) 2592 { 2593 BlockDriverAIOCB *acb; 2594 2595 if (pool->free_aiocb) { 2596 acb = pool->free_aiocb; 2597 pool->free_aiocb = acb->next; 2598 } else { 2599 acb = qemu_mallocz(pool->aiocb_size); 2600 acb->pool = pool; 2601 } 2602 acb->bs = bs; 2603 acb->cb = cb; 2604 acb->opaque = opaque; 2605 return acb; 2606 } 2607 2608 void qemu_aio_release(void *p) 2609 { 2610 BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p; 2611 AIOPool *pool = acb->pool; 2612 acb->next = pool->free_aiocb; 2613 pool->free_aiocb = acb; 2614 } 2615 2616 /**************************************************************/ 2617 /* removable device support */ 2618 2619 /** 2620 * Return TRUE if the media is present 2621 */ 2622 int bdrv_is_inserted(BlockDriverState *bs) 2623 { 2624 BlockDriver *drv = bs->drv; 2625 int ret; 2626 if (!drv) 2627 return 0; 2628 if (!drv->bdrv_is_inserted) 2629 return !bs->tray_open; 2630 ret = drv->bdrv_is_inserted(bs); 2631 return ret; 2632 } 2633 2634 /** 2635 * Return TRUE if the media changed since the last call to this 2636 * function. It is currently only used for floppy disks 2637 */ 2638 int bdrv_media_changed(BlockDriverState *bs) 2639 { 2640 BlockDriver *drv = bs->drv; 2641 int ret; 2642 2643 if (!drv || !drv->bdrv_media_changed) 2644 ret = -ENOTSUP; 2645 else 2646 ret = drv->bdrv_media_changed(bs); 2647 if (ret == -ENOTSUP) 2648 ret = bs->media_changed; 2649 bs->media_changed = 0; 2650 return ret; 2651 } 2652 2653 /** 2654 * If eject_flag is TRUE, eject the media. Otherwise, close the tray 2655 */ 2656 int bdrv_eject(BlockDriverState *bs, int eject_flag) 2657 { 2658 BlockDriver *drv = bs->drv; 2659 int ret; 2660 2661 if (bs->locked) { 2662 return -EBUSY; 2663 } 2664 2665 if (!drv || !drv->bdrv_eject) { 2666 ret = -ENOTSUP; 2667 } else { 2668 ret = drv->bdrv_eject(bs, eject_flag); 2669 } 2670 if (ret == -ENOTSUP) { 2671 ret = 0; 2672 } 2673 if (ret >= 0) { 2674 bs->tray_open = eject_flag; 2675 } 2676 2677 return ret; 2678 } 2679 2680 int bdrv_is_locked(BlockDriverState *bs) 2681 { 2682 return bs->locked; 2683 } 2684 2685 /** 2686 * Lock or unlock the media (if it is locked, the user won't be able 2687 * to eject it manually). 2688 */ 2689 void bdrv_set_locked(BlockDriverState *bs, int locked) 2690 { 2691 BlockDriver *drv = bs->drv; 2692 2693 bs->locked = locked; 2694 if (drv && drv->bdrv_set_locked) { 2695 drv->bdrv_set_locked(bs, locked); 2696 } 2697 } 2698 2699 /* needed for generic scsi interface */ 2700 2701 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) 2702 { 2703 BlockDriver *drv = bs->drv; 2704 2705 if (drv && drv->bdrv_ioctl) 2706 return drv->bdrv_ioctl(bs, req, buf); 2707 return -ENOTSUP; 2708 } 2709 2710 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, 2711 unsigned long int req, void *buf, 2712 BlockDriverCompletionFunc *cb, void *opaque) 2713 { 2714 BlockDriver *drv = bs->drv; 2715 2716 if (drv && drv->bdrv_aio_ioctl) 2717 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque); 2718 return NULL; 2719 } 2720 2721 2722 2723 void *qemu_blockalign(BlockDriverState *bs, size_t size) 2724 { 2725 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size); 2726 } 2727 2728 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable) 2729 { 2730 int64_t bitmap_size; 2731 2732 bs->dirty_count = 0; 2733 if (enable) { 2734 if (!bs->dirty_bitmap) { 2735 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) + 2736 BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1; 2737 bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8; 2738 2739 bs->dirty_bitmap = qemu_mallocz(bitmap_size); 2740 } 2741 } else { 2742 if (bs->dirty_bitmap) { 2743 qemu_free(bs->dirty_bitmap); 2744 bs->dirty_bitmap = NULL; 2745 } 2746 } 2747 } 2748 2749 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector) 2750 { 2751 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK; 2752 2753 if (bs->dirty_bitmap && 2754 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) { 2755 return !!(bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] & 2756 (1UL << (chunk % (sizeof(unsigned long) * 8)))); 2757 } else { 2758 return 0; 2759 } 2760 } 2761 2762 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, 2763 int nr_sectors) 2764 { 2765 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0); 2766 } 2767 2768 int64_t bdrv_get_dirty_count(BlockDriverState *bs) 2769 { 2770 return bs->dirty_count; 2771 } 2772 2773 int bdrv_img_create(const char *filename, const char *fmt, 2774 const char *base_filename, const char *base_fmt, 2775 char *options, uint64_t img_size, int flags) 2776 { 2777 QEMUOptionParameter *param = NULL, *create_options = NULL; 2778 QEMUOptionParameter *backing_fmt, *backing_file; 2779 BlockDriverState *bs = NULL; 2780 BlockDriver *drv, *proto_drv; 2781 int ret = 0; 2782 2783 /* Find driver and parse its options */ 2784 drv = bdrv_find_format(fmt); 2785 if (!drv) { 2786 error_report("Unknown file format '%s'", fmt); 2787 ret = -EINVAL; 2788 goto out; 2789 } 2790 2791 proto_drv = bdrv_find_protocol(filename); 2792 if (!proto_drv) { 2793 error_report("Unknown protocol '%s'", filename); 2794 ret = -EINVAL; 2795 goto out; 2796 } 2797 2798 create_options = append_option_parameters(create_options, 2799 drv->create_options); 2800 create_options = append_option_parameters(create_options, 2801 proto_drv->create_options); 2802 2803 /* Create parameter list with default values */ 2804 param = parse_option_parameters("", create_options, param); 2805 2806 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size); 2807 2808 /* Parse -o options */ 2809 if (options) { 2810 param = parse_option_parameters(options, create_options, param); 2811 if (param == NULL) { 2812 error_report("Invalid options for file format '%s'.", fmt); 2813 ret = -EINVAL; 2814 goto out; 2815 } 2816 } 2817 2818 if (base_filename) { 2819 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE, 2820 base_filename)) { 2821 error_report("Backing file not supported for file format '%s'", 2822 fmt); 2823 ret = -EINVAL; 2824 goto out; 2825 } 2826 } 2827 2828 if (base_fmt) { 2829 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) { 2830 error_report("Backing file format not supported for file " 2831 "format '%s'", fmt); 2832 ret = -EINVAL; 2833 goto out; 2834 } 2835 } 2836 2837 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE); 2838 if (backing_file && backing_file->value.s) { 2839 if (!strcmp(filename, backing_file->value.s)) { 2840 error_report("Error: Trying to create an image with the " 2841 "same filename as the backing file"); 2842 ret = -EINVAL; 2843 goto out; 2844 } 2845 } 2846 2847 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT); 2848 if (backing_fmt && backing_fmt->value.s) { 2849 if (!bdrv_find_format(backing_fmt->value.s)) { 2850 error_report("Unknown backing file format '%s'", 2851 backing_fmt->value.s); 2852 ret = -EINVAL; 2853 goto out; 2854 } 2855 } 2856 2857 // The size for the image must always be specified, with one exception: 2858 // If we are using a backing file, we can obtain the size from there 2859 if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == -1) { 2860 if (backing_file && backing_file->value.s) { 2861 uint64_t size; 2862 const char *fmt = NULL; 2863 char buf[32]; 2864 2865 if (backing_fmt && backing_fmt->value.s) { 2866 fmt = backing_fmt->value.s; 2867 } 2868 2869 bs = bdrv_new(""); 2870 2871 ret = bdrv_open(bs, backing_file->value.s, flags, drv); 2872 if (ret < 0) { 2873 error_report("Could not open '%s'", filename); 2874 goto out; 2875 } 2876 bdrv_get_geometry(bs, &size); 2877 size *= 512; 2878 2879 snprintf(buf, sizeof(buf), "%" PRId64, size); 2880 set_option_parameter(param, BLOCK_OPT_SIZE, buf); 2881 } else { 2882 error_report("Image creation needs a size parameter"); 2883 ret = -EINVAL; 2884 goto out; 2885 } 2886 } 2887 2888 printf("Formatting '%s', fmt=%s ", filename, fmt); 2889 print_option_parameters(param); 2890 puts(""); 2891 2892 ret = bdrv_create(drv, filename, param); 2893 2894 if (ret < 0) { 2895 if (ret == -ENOTSUP) { 2896 error_report("Formatting or formatting option not supported for " 2897 "file format '%s'", fmt); 2898 } else if (ret == -EFBIG) { 2899 error_report("The image size is too large for file format '%s'", 2900 fmt); 2901 } else { 2902 error_report("%s: error while creating %s: %s", filename, fmt, 2903 strerror(-ret)); 2904 } 2905 } 2906 2907 out: 2908 free_option_parameters(create_options); 2909 free_option_parameters(param); 2910 2911 if (bs) { 2912 bdrv_delete(bs); 2913 } 2914 2915 return ret; 2916 } 2917