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 "qjson.h" 31 #include "qemu-coroutine.h" 32 #include "qmp-commands.h" 33 #include "qemu-timer.h" 34 35 #ifdef CONFIG_BSD 36 #include <sys/types.h> 37 #include <sys/stat.h> 38 #include <sys/ioctl.h> 39 #include <sys/queue.h> 40 #ifndef __DragonFly__ 41 #include <sys/disk.h> 42 #endif 43 #endif 44 45 #ifdef _WIN32 46 #include <windows.h> 47 #endif 48 49 #define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ 50 51 typedef enum { 52 BDRV_REQ_COPY_ON_READ = 0x1, 53 BDRV_REQ_ZERO_WRITE = 0x2, 54 } BdrvRequestFlags; 55 56 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load); 57 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, 58 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 59 BlockDriverCompletionFunc *cb, void *opaque); 60 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, 61 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 62 BlockDriverCompletionFunc *cb, void *opaque); 63 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs, 64 int64_t sector_num, int nb_sectors, 65 QEMUIOVector *iov); 66 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs, 67 int64_t sector_num, int nb_sectors, 68 QEMUIOVector *iov); 69 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, 70 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, 71 BdrvRequestFlags flags); 72 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, 73 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, 74 BdrvRequestFlags flags); 75 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, 76 int64_t sector_num, 77 QEMUIOVector *qiov, 78 int nb_sectors, 79 BlockDriverCompletionFunc *cb, 80 void *opaque, 81 bool is_write); 82 static void coroutine_fn bdrv_co_do_rw(void *opaque); 83 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, 84 int64_t sector_num, int nb_sectors); 85 86 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors, 87 bool is_write, double elapsed_time, uint64_t *wait); 88 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write, 89 double elapsed_time, uint64_t *wait); 90 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors, 91 bool is_write, int64_t *wait); 92 93 static QTAILQ_HEAD(, BlockDriverState) bdrv_states = 94 QTAILQ_HEAD_INITIALIZER(bdrv_states); 95 96 static QLIST_HEAD(, BlockDriver) bdrv_drivers = 97 QLIST_HEAD_INITIALIZER(bdrv_drivers); 98 99 /* The device to use for VM snapshots */ 100 static BlockDriverState *bs_snapshots; 101 102 /* If non-zero, use only whitelisted block drivers */ 103 static int use_bdrv_whitelist; 104 105 #ifdef _WIN32 106 static int is_windows_drive_prefix(const char *filename) 107 { 108 return (((filename[0] >= 'a' && filename[0] <= 'z') || 109 (filename[0] >= 'A' && filename[0] <= 'Z')) && 110 filename[1] == ':'); 111 } 112 113 int is_windows_drive(const char *filename) 114 { 115 if (is_windows_drive_prefix(filename) && 116 filename[2] == '\0') 117 return 1; 118 if (strstart(filename, "\\\\.\\", NULL) || 119 strstart(filename, "//./", NULL)) 120 return 1; 121 return 0; 122 } 123 #endif 124 125 /* throttling disk I/O limits */ 126 void bdrv_io_limits_disable(BlockDriverState *bs) 127 { 128 bs->io_limits_enabled = false; 129 130 while (qemu_co_queue_next(&bs->throttled_reqs)); 131 132 if (bs->block_timer) { 133 qemu_del_timer(bs->block_timer); 134 qemu_free_timer(bs->block_timer); 135 bs->block_timer = NULL; 136 } 137 138 bs->slice_start = 0; 139 bs->slice_end = 0; 140 bs->slice_time = 0; 141 memset(&bs->io_base, 0, sizeof(bs->io_base)); 142 } 143 144 static void bdrv_block_timer(void *opaque) 145 { 146 BlockDriverState *bs = opaque; 147 148 qemu_co_queue_next(&bs->throttled_reqs); 149 } 150 151 void bdrv_io_limits_enable(BlockDriverState *bs) 152 { 153 qemu_co_queue_init(&bs->throttled_reqs); 154 bs->block_timer = qemu_new_timer_ns(vm_clock, bdrv_block_timer, bs); 155 bs->slice_time = 5 * BLOCK_IO_SLICE_TIME; 156 bs->slice_start = qemu_get_clock_ns(vm_clock); 157 bs->slice_end = bs->slice_start + bs->slice_time; 158 memset(&bs->io_base, 0, sizeof(bs->io_base)); 159 bs->io_limits_enabled = true; 160 } 161 162 bool bdrv_io_limits_enabled(BlockDriverState *bs) 163 { 164 BlockIOLimit *io_limits = &bs->io_limits; 165 return io_limits->bps[BLOCK_IO_LIMIT_READ] 166 || io_limits->bps[BLOCK_IO_LIMIT_WRITE] 167 || io_limits->bps[BLOCK_IO_LIMIT_TOTAL] 168 || io_limits->iops[BLOCK_IO_LIMIT_READ] 169 || io_limits->iops[BLOCK_IO_LIMIT_WRITE] 170 || io_limits->iops[BLOCK_IO_LIMIT_TOTAL]; 171 } 172 173 static void bdrv_io_limits_intercept(BlockDriverState *bs, 174 bool is_write, int nb_sectors) 175 { 176 int64_t wait_time = -1; 177 178 if (!qemu_co_queue_empty(&bs->throttled_reqs)) { 179 qemu_co_queue_wait(&bs->throttled_reqs); 180 } 181 182 /* In fact, we hope to keep each request's timing, in FIFO mode. The next 183 * throttled requests will not be dequeued until the current request is 184 * allowed to be serviced. So if the current request still exceeds the 185 * limits, it will be inserted to the head. All requests followed it will 186 * be still in throttled_reqs queue. 187 */ 188 189 while (bdrv_exceed_io_limits(bs, nb_sectors, is_write, &wait_time)) { 190 qemu_mod_timer(bs->block_timer, 191 wait_time + qemu_get_clock_ns(vm_clock)); 192 qemu_co_queue_wait_insert_head(&bs->throttled_reqs); 193 } 194 195 qemu_co_queue_next(&bs->throttled_reqs); 196 } 197 198 /* check if the path starts with "<protocol>:" */ 199 static int path_has_protocol(const char *path) 200 { 201 #ifdef _WIN32 202 if (is_windows_drive(path) || 203 is_windows_drive_prefix(path)) { 204 return 0; 205 } 206 #endif 207 208 return strchr(path, ':') != NULL; 209 } 210 211 int path_is_absolute(const char *path) 212 { 213 const char *p; 214 #ifdef _WIN32 215 /* specific case for names like: "\\.\d:" */ 216 if (*path == '/' || *path == '\\') 217 return 1; 218 #endif 219 p = strchr(path, ':'); 220 if (p) 221 p++; 222 else 223 p = path; 224 #ifdef _WIN32 225 return (*p == '/' || *p == '\\'); 226 #else 227 return (*p == '/'); 228 #endif 229 } 230 231 /* if filename is absolute, just copy it to dest. Otherwise, build a 232 path to it by considering it is relative to base_path. URL are 233 supported. */ 234 void path_combine(char *dest, int dest_size, 235 const char *base_path, 236 const char *filename) 237 { 238 const char *p, *p1; 239 int len; 240 241 if (dest_size <= 0) 242 return; 243 if (path_is_absolute(filename)) { 244 pstrcpy(dest, dest_size, filename); 245 } else { 246 p = strchr(base_path, ':'); 247 if (p) 248 p++; 249 else 250 p = base_path; 251 p1 = strrchr(base_path, '/'); 252 #ifdef _WIN32 253 { 254 const char *p2; 255 p2 = strrchr(base_path, '\\'); 256 if (!p1 || p2 > p1) 257 p1 = p2; 258 } 259 #endif 260 if (p1) 261 p1++; 262 else 263 p1 = base_path; 264 if (p1 > p) 265 p = p1; 266 len = p - base_path; 267 if (len > dest_size - 1) 268 len = dest_size - 1; 269 memcpy(dest, base_path, len); 270 dest[len] = '\0'; 271 pstrcat(dest, dest_size, filename); 272 } 273 } 274 275 void bdrv_register(BlockDriver *bdrv) 276 { 277 /* Block drivers without coroutine functions need emulation */ 278 if (!bdrv->bdrv_co_readv) { 279 bdrv->bdrv_co_readv = bdrv_co_readv_em; 280 bdrv->bdrv_co_writev = bdrv_co_writev_em; 281 282 /* bdrv_co_readv_em()/brdv_co_writev_em() work in terms of aio, so if 283 * the block driver lacks aio we need to emulate that too. 284 */ 285 if (!bdrv->bdrv_aio_readv) { 286 /* add AIO emulation layer */ 287 bdrv->bdrv_aio_readv = bdrv_aio_readv_em; 288 bdrv->bdrv_aio_writev = bdrv_aio_writev_em; 289 } 290 } 291 292 QLIST_INSERT_HEAD(&bdrv_drivers, bdrv, list); 293 } 294 295 /* create a new block device (by default it is empty) */ 296 BlockDriverState *bdrv_new(const char *device_name) 297 { 298 BlockDriverState *bs; 299 300 bs = g_malloc0(sizeof(BlockDriverState)); 301 pstrcpy(bs->device_name, sizeof(bs->device_name), device_name); 302 if (device_name[0] != '\0') { 303 QTAILQ_INSERT_TAIL(&bdrv_states, bs, list); 304 } 305 bdrv_iostatus_disable(bs); 306 return bs; 307 } 308 309 BlockDriver *bdrv_find_format(const char *format_name) 310 { 311 BlockDriver *drv1; 312 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 313 if (!strcmp(drv1->format_name, format_name)) { 314 return drv1; 315 } 316 } 317 return NULL; 318 } 319 320 static int bdrv_is_whitelisted(BlockDriver *drv) 321 { 322 static const char *whitelist[] = { 323 CONFIG_BDRV_WHITELIST 324 }; 325 const char **p; 326 327 if (!whitelist[0]) 328 return 1; /* no whitelist, anything goes */ 329 330 for (p = whitelist; *p; p++) { 331 if (!strcmp(drv->format_name, *p)) { 332 return 1; 333 } 334 } 335 return 0; 336 } 337 338 BlockDriver *bdrv_find_whitelisted_format(const char *format_name) 339 { 340 BlockDriver *drv = bdrv_find_format(format_name); 341 return drv && bdrv_is_whitelisted(drv) ? drv : NULL; 342 } 343 344 typedef struct CreateCo { 345 BlockDriver *drv; 346 char *filename; 347 QEMUOptionParameter *options; 348 int ret; 349 } CreateCo; 350 351 static void coroutine_fn bdrv_create_co_entry(void *opaque) 352 { 353 CreateCo *cco = opaque; 354 assert(cco->drv); 355 356 cco->ret = cco->drv->bdrv_create(cco->filename, cco->options); 357 } 358 359 int bdrv_create(BlockDriver *drv, const char* filename, 360 QEMUOptionParameter *options) 361 { 362 int ret; 363 364 Coroutine *co; 365 CreateCo cco = { 366 .drv = drv, 367 .filename = g_strdup(filename), 368 .options = options, 369 .ret = NOT_DONE, 370 }; 371 372 if (!drv->bdrv_create) { 373 return -ENOTSUP; 374 } 375 376 if (qemu_in_coroutine()) { 377 /* Fast-path if already in coroutine context */ 378 bdrv_create_co_entry(&cco); 379 } else { 380 co = qemu_coroutine_create(bdrv_create_co_entry); 381 qemu_coroutine_enter(co, &cco); 382 while (cco.ret == NOT_DONE) { 383 qemu_aio_wait(); 384 } 385 } 386 387 ret = cco.ret; 388 g_free(cco.filename); 389 390 return ret; 391 } 392 393 int bdrv_create_file(const char* filename, QEMUOptionParameter *options) 394 { 395 BlockDriver *drv; 396 397 drv = bdrv_find_protocol(filename); 398 if (drv == NULL) { 399 return -ENOENT; 400 } 401 402 return bdrv_create(drv, filename, options); 403 } 404 405 #ifdef _WIN32 406 void get_tmp_filename(char *filename, int size) 407 { 408 char temp_dir[MAX_PATH]; 409 410 GetTempPath(MAX_PATH, temp_dir); 411 GetTempFileName(temp_dir, "qem", 0, filename); 412 } 413 #else 414 void get_tmp_filename(char *filename, int size) 415 { 416 int fd; 417 const char *tmpdir; 418 /* XXX: race condition possible */ 419 tmpdir = getenv("TMPDIR"); 420 if (!tmpdir) 421 tmpdir = "/tmp"; 422 snprintf(filename, size, "%s/vl.XXXXXX", tmpdir); 423 fd = mkstemp(filename); 424 close(fd); 425 } 426 #endif 427 428 /* 429 * Detect host devices. By convention, /dev/cdrom[N] is always 430 * recognized as a host CDROM. 431 */ 432 static BlockDriver *find_hdev_driver(const char *filename) 433 { 434 int score_max = 0, score; 435 BlockDriver *drv = NULL, *d; 436 437 QLIST_FOREACH(d, &bdrv_drivers, list) { 438 if (d->bdrv_probe_device) { 439 score = d->bdrv_probe_device(filename); 440 if (score > score_max) { 441 score_max = score; 442 drv = d; 443 } 444 } 445 } 446 447 return drv; 448 } 449 450 BlockDriver *bdrv_find_protocol(const char *filename) 451 { 452 BlockDriver *drv1; 453 char protocol[128]; 454 int len; 455 const char *p; 456 457 /* TODO Drivers without bdrv_file_open must be specified explicitly */ 458 459 /* 460 * XXX(hch): we really should not let host device detection 461 * override an explicit protocol specification, but moving this 462 * later breaks access to device names with colons in them. 463 * Thanks to the brain-dead persistent naming schemes on udev- 464 * based Linux systems those actually are quite common. 465 */ 466 drv1 = find_hdev_driver(filename); 467 if (drv1) { 468 return drv1; 469 } 470 471 if (!path_has_protocol(filename)) { 472 return bdrv_find_format("file"); 473 } 474 p = strchr(filename, ':'); 475 assert(p != NULL); 476 len = p - filename; 477 if (len > sizeof(protocol) - 1) 478 len = sizeof(protocol) - 1; 479 memcpy(protocol, filename, len); 480 protocol[len] = '\0'; 481 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 482 if (drv1->protocol_name && 483 !strcmp(drv1->protocol_name, protocol)) { 484 return drv1; 485 } 486 } 487 return NULL; 488 } 489 490 static int find_image_format(const char *filename, BlockDriver **pdrv) 491 { 492 int ret, score, score_max; 493 BlockDriver *drv1, *drv; 494 uint8_t buf[2048]; 495 BlockDriverState *bs; 496 497 ret = bdrv_file_open(&bs, filename, 0); 498 if (ret < 0) { 499 *pdrv = NULL; 500 return ret; 501 } 502 503 /* Return the raw BlockDriver * to scsi-generic devices or empty drives */ 504 if (bs->sg || !bdrv_is_inserted(bs)) { 505 bdrv_delete(bs); 506 drv = bdrv_find_format("raw"); 507 if (!drv) { 508 ret = -ENOENT; 509 } 510 *pdrv = drv; 511 return ret; 512 } 513 514 ret = bdrv_pread(bs, 0, buf, sizeof(buf)); 515 bdrv_delete(bs); 516 if (ret < 0) { 517 *pdrv = NULL; 518 return ret; 519 } 520 521 score_max = 0; 522 drv = NULL; 523 QLIST_FOREACH(drv1, &bdrv_drivers, list) { 524 if (drv1->bdrv_probe) { 525 score = drv1->bdrv_probe(buf, ret, filename); 526 if (score > score_max) { 527 score_max = score; 528 drv = drv1; 529 } 530 } 531 } 532 if (!drv) { 533 ret = -ENOENT; 534 } 535 *pdrv = drv; 536 return ret; 537 } 538 539 /** 540 * Set the current 'total_sectors' value 541 */ 542 static int refresh_total_sectors(BlockDriverState *bs, int64_t hint) 543 { 544 BlockDriver *drv = bs->drv; 545 546 /* Do not attempt drv->bdrv_getlength() on scsi-generic devices */ 547 if (bs->sg) 548 return 0; 549 550 /* query actual device if possible, otherwise just trust the hint */ 551 if (drv->bdrv_getlength) { 552 int64_t length = drv->bdrv_getlength(bs); 553 if (length < 0) { 554 return length; 555 } 556 hint = length >> BDRV_SECTOR_BITS; 557 } 558 559 bs->total_sectors = hint; 560 return 0; 561 } 562 563 /** 564 * Set open flags for a given cache mode 565 * 566 * Return 0 on success, -1 if the cache mode was invalid. 567 */ 568 int bdrv_parse_cache_flags(const char *mode, int *flags) 569 { 570 *flags &= ~BDRV_O_CACHE_MASK; 571 572 if (!strcmp(mode, "off") || !strcmp(mode, "none")) { 573 *flags |= BDRV_O_NOCACHE | BDRV_O_CACHE_WB; 574 } else if (!strcmp(mode, "directsync")) { 575 *flags |= BDRV_O_NOCACHE; 576 } else if (!strcmp(mode, "writeback")) { 577 *flags |= BDRV_O_CACHE_WB; 578 } else if (!strcmp(mode, "unsafe")) { 579 *flags |= BDRV_O_CACHE_WB; 580 *flags |= BDRV_O_NO_FLUSH; 581 } else if (!strcmp(mode, "writethrough")) { 582 /* this is the default */ 583 } else { 584 return -1; 585 } 586 587 return 0; 588 } 589 590 /** 591 * The copy-on-read flag is actually a reference count so multiple users may 592 * use the feature without worrying about clobbering its previous state. 593 * Copy-on-read stays enabled until all users have called to disable it. 594 */ 595 void bdrv_enable_copy_on_read(BlockDriverState *bs) 596 { 597 bs->copy_on_read++; 598 } 599 600 void bdrv_disable_copy_on_read(BlockDriverState *bs) 601 { 602 assert(bs->copy_on_read > 0); 603 bs->copy_on_read--; 604 } 605 606 /* 607 * Common part for opening disk images and files 608 */ 609 static int bdrv_open_common(BlockDriverState *bs, const char *filename, 610 int flags, BlockDriver *drv) 611 { 612 int ret, open_flags; 613 614 assert(drv != NULL); 615 616 trace_bdrv_open_common(bs, filename, flags, drv->format_name); 617 618 bs->file = NULL; 619 bs->total_sectors = 0; 620 bs->encrypted = 0; 621 bs->valid_key = 0; 622 bs->sg = 0; 623 bs->open_flags = flags; 624 bs->growable = 0; 625 bs->buffer_alignment = 512; 626 627 assert(bs->copy_on_read == 0); /* bdrv_new() and bdrv_close() make it so */ 628 if ((flags & BDRV_O_RDWR) && (flags & BDRV_O_COPY_ON_READ)) { 629 bdrv_enable_copy_on_read(bs); 630 } 631 632 pstrcpy(bs->filename, sizeof(bs->filename), filename); 633 bs->backing_file[0] = '\0'; 634 635 if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv)) { 636 return -ENOTSUP; 637 } 638 639 bs->drv = drv; 640 bs->opaque = g_malloc0(drv->instance_size); 641 642 bs->enable_write_cache = !!(flags & BDRV_O_CACHE_WB); 643 644 /* 645 * Clear flags that are internal to the block layer before opening the 646 * image. 647 */ 648 open_flags = flags & ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); 649 650 /* 651 * Snapshots should be writable. 652 */ 653 if (bs->is_temporary) { 654 open_flags |= BDRV_O_RDWR; 655 } 656 657 bs->keep_read_only = bs->read_only = !(open_flags & BDRV_O_RDWR); 658 659 /* Open the image, either directly or using a protocol */ 660 if (drv->bdrv_file_open) { 661 ret = drv->bdrv_file_open(bs, filename, open_flags); 662 } else { 663 ret = bdrv_file_open(&bs->file, filename, open_flags); 664 if (ret >= 0) { 665 ret = drv->bdrv_open(bs, open_flags); 666 } 667 } 668 669 if (ret < 0) { 670 goto free_and_fail; 671 } 672 673 ret = refresh_total_sectors(bs, bs->total_sectors); 674 if (ret < 0) { 675 goto free_and_fail; 676 } 677 678 #ifndef _WIN32 679 if (bs->is_temporary) { 680 unlink(filename); 681 } 682 #endif 683 return 0; 684 685 free_and_fail: 686 if (bs->file) { 687 bdrv_delete(bs->file); 688 bs->file = NULL; 689 } 690 g_free(bs->opaque); 691 bs->opaque = NULL; 692 bs->drv = NULL; 693 return ret; 694 } 695 696 /* 697 * Opens a file using a protocol (file, host_device, nbd, ...) 698 */ 699 int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags) 700 { 701 BlockDriverState *bs; 702 BlockDriver *drv; 703 int ret; 704 705 drv = bdrv_find_protocol(filename); 706 if (!drv) { 707 return -ENOENT; 708 } 709 710 bs = bdrv_new(""); 711 ret = bdrv_open_common(bs, filename, flags, drv); 712 if (ret < 0) { 713 bdrv_delete(bs); 714 return ret; 715 } 716 bs->growable = 1; 717 *pbs = bs; 718 return 0; 719 } 720 721 /* 722 * Opens a disk image (raw, qcow2, vmdk, ...) 723 */ 724 int bdrv_open(BlockDriverState *bs, const char *filename, int flags, 725 BlockDriver *drv) 726 { 727 int ret; 728 char tmp_filename[PATH_MAX]; 729 730 if (flags & BDRV_O_SNAPSHOT) { 731 BlockDriverState *bs1; 732 int64_t total_size; 733 int is_protocol = 0; 734 BlockDriver *bdrv_qcow2; 735 QEMUOptionParameter *options; 736 char backing_filename[PATH_MAX]; 737 738 /* if snapshot, we create a temporary backing file and open it 739 instead of opening 'filename' directly */ 740 741 /* if there is a backing file, use it */ 742 bs1 = bdrv_new(""); 743 ret = bdrv_open(bs1, filename, 0, drv); 744 if (ret < 0) { 745 bdrv_delete(bs1); 746 return ret; 747 } 748 total_size = bdrv_getlength(bs1) & BDRV_SECTOR_MASK; 749 750 if (bs1->drv && bs1->drv->protocol_name) 751 is_protocol = 1; 752 753 bdrv_delete(bs1); 754 755 get_tmp_filename(tmp_filename, sizeof(tmp_filename)); 756 757 /* Real path is meaningless for protocols */ 758 if (is_protocol) 759 snprintf(backing_filename, sizeof(backing_filename), 760 "%s", filename); 761 else if (!realpath(filename, backing_filename)) 762 return -errno; 763 764 bdrv_qcow2 = bdrv_find_format("qcow2"); 765 options = parse_option_parameters("", bdrv_qcow2->create_options, NULL); 766 767 set_option_parameter_int(options, BLOCK_OPT_SIZE, total_size); 768 set_option_parameter(options, BLOCK_OPT_BACKING_FILE, backing_filename); 769 if (drv) { 770 set_option_parameter(options, BLOCK_OPT_BACKING_FMT, 771 drv->format_name); 772 } 773 774 ret = bdrv_create(bdrv_qcow2, tmp_filename, options); 775 free_option_parameters(options); 776 if (ret < 0) { 777 return ret; 778 } 779 780 filename = tmp_filename; 781 drv = bdrv_qcow2; 782 bs->is_temporary = 1; 783 } 784 785 /* Find the right image format driver */ 786 if (!drv) { 787 ret = find_image_format(filename, &drv); 788 } 789 790 if (!drv) { 791 goto unlink_and_fail; 792 } 793 794 /* Open the image */ 795 ret = bdrv_open_common(bs, filename, flags, drv); 796 if (ret < 0) { 797 goto unlink_and_fail; 798 } 799 800 /* If there is a backing file, use it */ 801 if ((flags & BDRV_O_NO_BACKING) == 0 && bs->backing_file[0] != '\0') { 802 char backing_filename[PATH_MAX]; 803 int back_flags; 804 BlockDriver *back_drv = NULL; 805 806 bs->backing_hd = bdrv_new(""); 807 808 if (path_has_protocol(bs->backing_file)) { 809 pstrcpy(backing_filename, sizeof(backing_filename), 810 bs->backing_file); 811 } else { 812 path_combine(backing_filename, sizeof(backing_filename), 813 filename, bs->backing_file); 814 } 815 816 if (bs->backing_format[0] != '\0') { 817 back_drv = bdrv_find_format(bs->backing_format); 818 } 819 820 /* backing files always opened read-only */ 821 back_flags = 822 flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING); 823 824 ret = bdrv_open(bs->backing_hd, backing_filename, back_flags, back_drv); 825 if (ret < 0) { 826 bdrv_close(bs); 827 return ret; 828 } 829 if (bs->is_temporary) { 830 bs->backing_hd->keep_read_only = !(flags & BDRV_O_RDWR); 831 } else { 832 /* base image inherits from "parent" */ 833 bs->backing_hd->keep_read_only = bs->keep_read_only; 834 } 835 } 836 837 if (!bdrv_key_required(bs)) { 838 bdrv_dev_change_media_cb(bs, true); 839 } 840 841 /* throttling disk I/O limits */ 842 if (bs->io_limits_enabled) { 843 bdrv_io_limits_enable(bs); 844 } 845 846 return 0; 847 848 unlink_and_fail: 849 if (bs->is_temporary) { 850 unlink(filename); 851 } 852 return ret; 853 } 854 855 void bdrv_close(BlockDriverState *bs) 856 { 857 bdrv_flush(bs); 858 if (bs->drv) { 859 if (bs->job) { 860 block_job_cancel_sync(bs->job); 861 } 862 bdrv_drain_all(); 863 864 if (bs == bs_snapshots) { 865 bs_snapshots = NULL; 866 } 867 if (bs->backing_hd) { 868 bdrv_delete(bs->backing_hd); 869 bs->backing_hd = NULL; 870 } 871 bs->drv->bdrv_close(bs); 872 g_free(bs->opaque); 873 #ifdef _WIN32 874 if (bs->is_temporary) { 875 unlink(bs->filename); 876 } 877 #endif 878 bs->opaque = NULL; 879 bs->drv = NULL; 880 bs->copy_on_read = 0; 881 882 if (bs->file != NULL) { 883 bdrv_close(bs->file); 884 } 885 886 bdrv_dev_change_media_cb(bs, false); 887 } 888 889 /*throttling disk I/O limits*/ 890 if (bs->io_limits_enabled) { 891 bdrv_io_limits_disable(bs); 892 } 893 } 894 895 void bdrv_close_all(void) 896 { 897 BlockDriverState *bs; 898 899 QTAILQ_FOREACH(bs, &bdrv_states, list) { 900 bdrv_close(bs); 901 } 902 } 903 904 /* 905 * Wait for pending requests to complete across all BlockDriverStates 906 * 907 * This function does not flush data to disk, use bdrv_flush_all() for that 908 * after calling this function. 909 * 910 * Note that completion of an asynchronous I/O operation can trigger any 911 * number of other I/O operations on other devices---for example a coroutine 912 * can be arbitrarily complex and a constant flow of I/O can come until the 913 * coroutine is complete. Because of this, it is not possible to have a 914 * function to drain a single device's I/O queue. 915 */ 916 void bdrv_drain_all(void) 917 { 918 BlockDriverState *bs; 919 bool busy; 920 921 do { 922 busy = qemu_aio_wait(); 923 924 /* FIXME: We do not have timer support here, so this is effectively 925 * a busy wait. 926 */ 927 QTAILQ_FOREACH(bs, &bdrv_states, list) { 928 if (!qemu_co_queue_empty(&bs->throttled_reqs)) { 929 qemu_co_queue_restart_all(&bs->throttled_reqs); 930 busy = true; 931 } 932 } 933 } while (busy); 934 935 /* If requests are still pending there is a bug somewhere */ 936 QTAILQ_FOREACH(bs, &bdrv_states, list) { 937 assert(QLIST_EMPTY(&bs->tracked_requests)); 938 assert(qemu_co_queue_empty(&bs->throttled_reqs)); 939 } 940 } 941 942 /* make a BlockDriverState anonymous by removing from bdrv_state list. 943 Also, NULL terminate the device_name to prevent double remove */ 944 void bdrv_make_anon(BlockDriverState *bs) 945 { 946 if (bs->device_name[0] != '\0') { 947 QTAILQ_REMOVE(&bdrv_states, bs, list); 948 } 949 bs->device_name[0] = '\0'; 950 } 951 952 /* 953 * Add new bs contents at the top of an image chain while the chain is 954 * live, while keeping required fields on the top layer. 955 * 956 * This will modify the BlockDriverState fields, and swap contents 957 * between bs_new and bs_top. Both bs_new and bs_top are modified. 958 * 959 * bs_new is required to be anonymous. 960 * 961 * This function does not create any image files. 962 */ 963 void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top) 964 { 965 BlockDriverState tmp; 966 967 /* bs_new must be anonymous */ 968 assert(bs_new->device_name[0] == '\0'); 969 970 tmp = *bs_new; 971 972 /* there are some fields that need to stay on the top layer: */ 973 974 /* dev info */ 975 tmp.dev_ops = bs_top->dev_ops; 976 tmp.dev_opaque = bs_top->dev_opaque; 977 tmp.dev = bs_top->dev; 978 tmp.buffer_alignment = bs_top->buffer_alignment; 979 tmp.copy_on_read = bs_top->copy_on_read; 980 981 /* i/o timing parameters */ 982 tmp.slice_time = bs_top->slice_time; 983 tmp.slice_start = bs_top->slice_start; 984 tmp.slice_end = bs_top->slice_end; 985 tmp.io_limits = bs_top->io_limits; 986 tmp.io_base = bs_top->io_base; 987 tmp.throttled_reqs = bs_top->throttled_reqs; 988 tmp.block_timer = bs_top->block_timer; 989 tmp.io_limits_enabled = bs_top->io_limits_enabled; 990 991 /* geometry */ 992 tmp.cyls = bs_top->cyls; 993 tmp.heads = bs_top->heads; 994 tmp.secs = bs_top->secs; 995 tmp.translation = bs_top->translation; 996 997 /* r/w error */ 998 tmp.on_read_error = bs_top->on_read_error; 999 tmp.on_write_error = bs_top->on_write_error; 1000 1001 /* i/o status */ 1002 tmp.iostatus_enabled = bs_top->iostatus_enabled; 1003 tmp.iostatus = bs_top->iostatus; 1004 1005 /* keep the same entry in bdrv_states */ 1006 pstrcpy(tmp.device_name, sizeof(tmp.device_name), bs_top->device_name); 1007 tmp.list = bs_top->list; 1008 1009 /* The contents of 'tmp' will become bs_top, as we are 1010 * swapping bs_new and bs_top contents. */ 1011 tmp.backing_hd = bs_new; 1012 pstrcpy(tmp.backing_file, sizeof(tmp.backing_file), bs_top->filename); 1013 bdrv_get_format(bs_top, tmp.backing_format, sizeof(tmp.backing_format)); 1014 1015 /* swap contents of the fixed new bs and the current top */ 1016 *bs_new = *bs_top; 1017 *bs_top = tmp; 1018 1019 /* device_name[] was carried over from the old bs_top. bs_new 1020 * shouldn't be in bdrv_states, so we need to make device_name[] 1021 * reflect the anonymity of bs_new 1022 */ 1023 bs_new->device_name[0] = '\0'; 1024 1025 /* clear the copied fields in the new backing file */ 1026 bdrv_detach_dev(bs_new, bs_new->dev); 1027 1028 qemu_co_queue_init(&bs_new->throttled_reqs); 1029 memset(&bs_new->io_base, 0, sizeof(bs_new->io_base)); 1030 memset(&bs_new->io_limits, 0, sizeof(bs_new->io_limits)); 1031 bdrv_iostatus_disable(bs_new); 1032 1033 /* we don't use bdrv_io_limits_disable() for this, because we don't want 1034 * to affect or delete the block_timer, as it has been moved to bs_top */ 1035 bs_new->io_limits_enabled = false; 1036 bs_new->block_timer = NULL; 1037 bs_new->slice_time = 0; 1038 bs_new->slice_start = 0; 1039 bs_new->slice_end = 0; 1040 } 1041 1042 void bdrv_delete(BlockDriverState *bs) 1043 { 1044 assert(!bs->dev); 1045 assert(!bs->job); 1046 assert(!bs->in_use); 1047 1048 /* remove from list, if necessary */ 1049 bdrv_make_anon(bs); 1050 1051 bdrv_close(bs); 1052 if (bs->file != NULL) { 1053 bdrv_delete(bs->file); 1054 } 1055 1056 assert(bs != bs_snapshots); 1057 g_free(bs); 1058 } 1059 1060 int bdrv_attach_dev(BlockDriverState *bs, void *dev) 1061 /* TODO change to DeviceState *dev when all users are qdevified */ 1062 { 1063 if (bs->dev) { 1064 return -EBUSY; 1065 } 1066 bs->dev = dev; 1067 bdrv_iostatus_reset(bs); 1068 return 0; 1069 } 1070 1071 /* TODO qdevified devices don't use this, remove when devices are qdevified */ 1072 void bdrv_attach_dev_nofail(BlockDriverState *bs, void *dev) 1073 { 1074 if (bdrv_attach_dev(bs, dev) < 0) { 1075 abort(); 1076 } 1077 } 1078 1079 void bdrv_detach_dev(BlockDriverState *bs, void *dev) 1080 /* TODO change to DeviceState *dev when all users are qdevified */ 1081 { 1082 assert(bs->dev == dev); 1083 bs->dev = NULL; 1084 bs->dev_ops = NULL; 1085 bs->dev_opaque = NULL; 1086 bs->buffer_alignment = 512; 1087 } 1088 1089 /* TODO change to return DeviceState * when all users are qdevified */ 1090 void *bdrv_get_attached_dev(BlockDriverState *bs) 1091 { 1092 return bs->dev; 1093 } 1094 1095 void bdrv_set_dev_ops(BlockDriverState *bs, const BlockDevOps *ops, 1096 void *opaque) 1097 { 1098 bs->dev_ops = ops; 1099 bs->dev_opaque = opaque; 1100 if (bdrv_dev_has_removable_media(bs) && bs == bs_snapshots) { 1101 bs_snapshots = NULL; 1102 } 1103 } 1104 1105 void bdrv_emit_qmp_error_event(const BlockDriverState *bdrv, 1106 BlockQMPEventAction action, int is_read) 1107 { 1108 QObject *data; 1109 const char *action_str; 1110 1111 switch (action) { 1112 case BDRV_ACTION_REPORT: 1113 action_str = "report"; 1114 break; 1115 case BDRV_ACTION_IGNORE: 1116 action_str = "ignore"; 1117 break; 1118 case BDRV_ACTION_STOP: 1119 action_str = "stop"; 1120 break; 1121 default: 1122 abort(); 1123 } 1124 1125 data = qobject_from_jsonf("{ 'device': %s, 'action': %s, 'operation': %s }", 1126 bdrv->device_name, 1127 action_str, 1128 is_read ? "read" : "write"); 1129 monitor_protocol_event(QEVENT_BLOCK_IO_ERROR, data); 1130 1131 qobject_decref(data); 1132 } 1133 1134 static void bdrv_emit_qmp_eject_event(BlockDriverState *bs, bool ejected) 1135 { 1136 QObject *data; 1137 1138 data = qobject_from_jsonf("{ 'device': %s, 'tray-open': %i }", 1139 bdrv_get_device_name(bs), ejected); 1140 monitor_protocol_event(QEVENT_DEVICE_TRAY_MOVED, data); 1141 1142 qobject_decref(data); 1143 } 1144 1145 static void bdrv_dev_change_media_cb(BlockDriverState *bs, bool load) 1146 { 1147 if (bs->dev_ops && bs->dev_ops->change_media_cb) { 1148 bool tray_was_closed = !bdrv_dev_is_tray_open(bs); 1149 bs->dev_ops->change_media_cb(bs->dev_opaque, load); 1150 if (tray_was_closed) { 1151 /* tray open */ 1152 bdrv_emit_qmp_eject_event(bs, true); 1153 } 1154 if (load) { 1155 /* tray close */ 1156 bdrv_emit_qmp_eject_event(bs, false); 1157 } 1158 } 1159 } 1160 1161 bool bdrv_dev_has_removable_media(BlockDriverState *bs) 1162 { 1163 return !bs->dev || (bs->dev_ops && bs->dev_ops->change_media_cb); 1164 } 1165 1166 void bdrv_dev_eject_request(BlockDriverState *bs, bool force) 1167 { 1168 if (bs->dev_ops && bs->dev_ops->eject_request_cb) { 1169 bs->dev_ops->eject_request_cb(bs->dev_opaque, force); 1170 } 1171 } 1172 1173 bool bdrv_dev_is_tray_open(BlockDriverState *bs) 1174 { 1175 if (bs->dev_ops && bs->dev_ops->is_tray_open) { 1176 return bs->dev_ops->is_tray_open(bs->dev_opaque); 1177 } 1178 return false; 1179 } 1180 1181 static void bdrv_dev_resize_cb(BlockDriverState *bs) 1182 { 1183 if (bs->dev_ops && bs->dev_ops->resize_cb) { 1184 bs->dev_ops->resize_cb(bs->dev_opaque); 1185 } 1186 } 1187 1188 bool bdrv_dev_is_medium_locked(BlockDriverState *bs) 1189 { 1190 if (bs->dev_ops && bs->dev_ops->is_medium_locked) { 1191 return bs->dev_ops->is_medium_locked(bs->dev_opaque); 1192 } 1193 return false; 1194 } 1195 1196 /* 1197 * Run consistency checks on an image 1198 * 1199 * Returns 0 if the check could be completed (it doesn't mean that the image is 1200 * free of errors) or -errno when an internal error occurred. The results of the 1201 * check are stored in res. 1202 */ 1203 int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res) 1204 { 1205 if (bs->drv->bdrv_check == NULL) { 1206 return -ENOTSUP; 1207 } 1208 1209 memset(res, 0, sizeof(*res)); 1210 return bs->drv->bdrv_check(bs, res); 1211 } 1212 1213 #define COMMIT_BUF_SECTORS 2048 1214 1215 /* commit COW file into the raw image */ 1216 int bdrv_commit(BlockDriverState *bs) 1217 { 1218 BlockDriver *drv = bs->drv; 1219 BlockDriver *backing_drv; 1220 int64_t sector, total_sectors; 1221 int n, ro, open_flags; 1222 int ret = 0, rw_ret = 0; 1223 uint8_t *buf; 1224 char filename[1024]; 1225 BlockDriverState *bs_rw, *bs_ro; 1226 1227 if (!drv) 1228 return -ENOMEDIUM; 1229 1230 if (!bs->backing_hd) { 1231 return -ENOTSUP; 1232 } 1233 1234 if (bs->backing_hd->keep_read_only) { 1235 return -EACCES; 1236 } 1237 1238 if (bdrv_in_use(bs) || bdrv_in_use(bs->backing_hd)) { 1239 return -EBUSY; 1240 } 1241 1242 backing_drv = bs->backing_hd->drv; 1243 ro = bs->backing_hd->read_only; 1244 strncpy(filename, bs->backing_hd->filename, sizeof(filename)); 1245 open_flags = bs->backing_hd->open_flags; 1246 1247 if (ro) { 1248 /* re-open as RW */ 1249 bdrv_delete(bs->backing_hd); 1250 bs->backing_hd = NULL; 1251 bs_rw = bdrv_new(""); 1252 rw_ret = bdrv_open(bs_rw, filename, open_flags | BDRV_O_RDWR, 1253 backing_drv); 1254 if (rw_ret < 0) { 1255 bdrv_delete(bs_rw); 1256 /* try to re-open read-only */ 1257 bs_ro = bdrv_new(""); 1258 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, 1259 backing_drv); 1260 if (ret < 0) { 1261 bdrv_delete(bs_ro); 1262 /* drive not functional anymore */ 1263 bs->drv = NULL; 1264 return ret; 1265 } 1266 bs->backing_hd = bs_ro; 1267 return rw_ret; 1268 } 1269 bs->backing_hd = bs_rw; 1270 } 1271 1272 total_sectors = bdrv_getlength(bs) >> BDRV_SECTOR_BITS; 1273 buf = g_malloc(COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE); 1274 1275 for (sector = 0; sector < total_sectors; sector += n) { 1276 if (bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n)) { 1277 1278 if (bdrv_read(bs, sector, buf, n) != 0) { 1279 ret = -EIO; 1280 goto ro_cleanup; 1281 } 1282 1283 if (bdrv_write(bs->backing_hd, sector, buf, n) != 0) { 1284 ret = -EIO; 1285 goto ro_cleanup; 1286 } 1287 } 1288 } 1289 1290 if (drv->bdrv_make_empty) { 1291 ret = drv->bdrv_make_empty(bs); 1292 bdrv_flush(bs); 1293 } 1294 1295 /* 1296 * Make sure all data we wrote to the backing device is actually 1297 * stable on disk. 1298 */ 1299 if (bs->backing_hd) 1300 bdrv_flush(bs->backing_hd); 1301 1302 ro_cleanup: 1303 g_free(buf); 1304 1305 if (ro) { 1306 /* re-open as RO */ 1307 bdrv_delete(bs->backing_hd); 1308 bs->backing_hd = NULL; 1309 bs_ro = bdrv_new(""); 1310 ret = bdrv_open(bs_ro, filename, open_flags & ~BDRV_O_RDWR, 1311 backing_drv); 1312 if (ret < 0) { 1313 bdrv_delete(bs_ro); 1314 /* drive not functional anymore */ 1315 bs->drv = NULL; 1316 return ret; 1317 } 1318 bs->backing_hd = bs_ro; 1319 bs->backing_hd->keep_read_only = 0; 1320 } 1321 1322 return ret; 1323 } 1324 1325 int bdrv_commit_all(void) 1326 { 1327 BlockDriverState *bs; 1328 1329 QTAILQ_FOREACH(bs, &bdrv_states, list) { 1330 int ret = bdrv_commit(bs); 1331 if (ret < 0) { 1332 return ret; 1333 } 1334 } 1335 return 0; 1336 } 1337 1338 struct BdrvTrackedRequest { 1339 BlockDriverState *bs; 1340 int64_t sector_num; 1341 int nb_sectors; 1342 bool is_write; 1343 QLIST_ENTRY(BdrvTrackedRequest) list; 1344 Coroutine *co; /* owner, used for deadlock detection */ 1345 CoQueue wait_queue; /* coroutines blocked on this request */ 1346 }; 1347 1348 /** 1349 * Remove an active request from the tracked requests list 1350 * 1351 * This function should be called when a tracked request is completing. 1352 */ 1353 static void tracked_request_end(BdrvTrackedRequest *req) 1354 { 1355 QLIST_REMOVE(req, list); 1356 qemu_co_queue_restart_all(&req->wait_queue); 1357 } 1358 1359 /** 1360 * Add an active request to the tracked requests list 1361 */ 1362 static void tracked_request_begin(BdrvTrackedRequest *req, 1363 BlockDriverState *bs, 1364 int64_t sector_num, 1365 int nb_sectors, bool is_write) 1366 { 1367 *req = (BdrvTrackedRequest){ 1368 .bs = bs, 1369 .sector_num = sector_num, 1370 .nb_sectors = nb_sectors, 1371 .is_write = is_write, 1372 .co = qemu_coroutine_self(), 1373 }; 1374 1375 qemu_co_queue_init(&req->wait_queue); 1376 1377 QLIST_INSERT_HEAD(&bs->tracked_requests, req, list); 1378 } 1379 1380 /** 1381 * Round a region to cluster boundaries 1382 */ 1383 static void round_to_clusters(BlockDriverState *bs, 1384 int64_t sector_num, int nb_sectors, 1385 int64_t *cluster_sector_num, 1386 int *cluster_nb_sectors) 1387 { 1388 BlockDriverInfo bdi; 1389 1390 if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) { 1391 *cluster_sector_num = sector_num; 1392 *cluster_nb_sectors = nb_sectors; 1393 } else { 1394 int64_t c = bdi.cluster_size / BDRV_SECTOR_SIZE; 1395 *cluster_sector_num = QEMU_ALIGN_DOWN(sector_num, c); 1396 *cluster_nb_sectors = QEMU_ALIGN_UP(sector_num - *cluster_sector_num + 1397 nb_sectors, c); 1398 } 1399 } 1400 1401 static bool tracked_request_overlaps(BdrvTrackedRequest *req, 1402 int64_t sector_num, int nb_sectors) { 1403 /* aaaa bbbb */ 1404 if (sector_num >= req->sector_num + req->nb_sectors) { 1405 return false; 1406 } 1407 /* bbbb aaaa */ 1408 if (req->sector_num >= sector_num + nb_sectors) { 1409 return false; 1410 } 1411 return true; 1412 } 1413 1414 static void coroutine_fn wait_for_overlapping_requests(BlockDriverState *bs, 1415 int64_t sector_num, int nb_sectors) 1416 { 1417 BdrvTrackedRequest *req; 1418 int64_t cluster_sector_num; 1419 int cluster_nb_sectors; 1420 bool retry; 1421 1422 /* If we touch the same cluster it counts as an overlap. This guarantees 1423 * that allocating writes will be serialized and not race with each other 1424 * for the same cluster. For example, in copy-on-read it ensures that the 1425 * CoR read and write operations are atomic and guest writes cannot 1426 * interleave between them. 1427 */ 1428 round_to_clusters(bs, sector_num, nb_sectors, 1429 &cluster_sector_num, &cluster_nb_sectors); 1430 1431 do { 1432 retry = false; 1433 QLIST_FOREACH(req, &bs->tracked_requests, list) { 1434 if (tracked_request_overlaps(req, cluster_sector_num, 1435 cluster_nb_sectors)) { 1436 /* Hitting this means there was a reentrant request, for 1437 * example, a block driver issuing nested requests. This must 1438 * never happen since it means deadlock. 1439 */ 1440 assert(qemu_coroutine_self() != req->co); 1441 1442 qemu_co_queue_wait(&req->wait_queue); 1443 retry = true; 1444 break; 1445 } 1446 } 1447 } while (retry); 1448 } 1449 1450 /* 1451 * Return values: 1452 * 0 - success 1453 * -EINVAL - backing format specified, but no file 1454 * -ENOSPC - can't update the backing file because no space is left in the 1455 * image file header 1456 * -ENOTSUP - format driver doesn't support changing the backing file 1457 */ 1458 int bdrv_change_backing_file(BlockDriverState *bs, 1459 const char *backing_file, const char *backing_fmt) 1460 { 1461 BlockDriver *drv = bs->drv; 1462 1463 /* Backing file format doesn't make sense without a backing file */ 1464 if (backing_fmt && !backing_file) { 1465 return -EINVAL; 1466 } 1467 1468 if (drv->bdrv_change_backing_file != NULL) { 1469 return drv->bdrv_change_backing_file(bs, backing_file, backing_fmt); 1470 } else { 1471 return -ENOTSUP; 1472 } 1473 } 1474 1475 static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, 1476 size_t size) 1477 { 1478 int64_t len; 1479 1480 if (!bdrv_is_inserted(bs)) 1481 return -ENOMEDIUM; 1482 1483 if (bs->growable) 1484 return 0; 1485 1486 len = bdrv_getlength(bs); 1487 1488 if (offset < 0) 1489 return -EIO; 1490 1491 if ((offset > len) || (len - offset < size)) 1492 return -EIO; 1493 1494 return 0; 1495 } 1496 1497 static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num, 1498 int nb_sectors) 1499 { 1500 return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE, 1501 nb_sectors * BDRV_SECTOR_SIZE); 1502 } 1503 1504 typedef struct RwCo { 1505 BlockDriverState *bs; 1506 int64_t sector_num; 1507 int nb_sectors; 1508 QEMUIOVector *qiov; 1509 bool is_write; 1510 int ret; 1511 } RwCo; 1512 1513 static void coroutine_fn bdrv_rw_co_entry(void *opaque) 1514 { 1515 RwCo *rwco = opaque; 1516 1517 if (!rwco->is_write) { 1518 rwco->ret = bdrv_co_do_readv(rwco->bs, rwco->sector_num, 1519 rwco->nb_sectors, rwco->qiov, 0); 1520 } else { 1521 rwco->ret = bdrv_co_do_writev(rwco->bs, rwco->sector_num, 1522 rwco->nb_sectors, rwco->qiov, 0); 1523 } 1524 } 1525 1526 /* 1527 * Process a synchronous request using coroutines 1528 */ 1529 static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf, 1530 int nb_sectors, bool is_write) 1531 { 1532 QEMUIOVector qiov; 1533 struct iovec iov = { 1534 .iov_base = (void *)buf, 1535 .iov_len = nb_sectors * BDRV_SECTOR_SIZE, 1536 }; 1537 Coroutine *co; 1538 RwCo rwco = { 1539 .bs = bs, 1540 .sector_num = sector_num, 1541 .nb_sectors = nb_sectors, 1542 .qiov = &qiov, 1543 .is_write = is_write, 1544 .ret = NOT_DONE, 1545 }; 1546 1547 qemu_iovec_init_external(&qiov, &iov, 1); 1548 1549 /** 1550 * In sync call context, when the vcpu is blocked, this throttling timer 1551 * will not fire; so the I/O throttling function has to be disabled here 1552 * if it has been enabled. 1553 */ 1554 if (bs->io_limits_enabled) { 1555 fprintf(stderr, "Disabling I/O throttling on '%s' due " 1556 "to synchronous I/O.\n", bdrv_get_device_name(bs)); 1557 bdrv_io_limits_disable(bs); 1558 } 1559 1560 if (qemu_in_coroutine()) { 1561 /* Fast-path if already in coroutine context */ 1562 bdrv_rw_co_entry(&rwco); 1563 } else { 1564 co = qemu_coroutine_create(bdrv_rw_co_entry); 1565 qemu_coroutine_enter(co, &rwco); 1566 while (rwco.ret == NOT_DONE) { 1567 qemu_aio_wait(); 1568 } 1569 } 1570 return rwco.ret; 1571 } 1572 1573 /* return < 0 if error. See bdrv_write() for the return codes */ 1574 int bdrv_read(BlockDriverState *bs, int64_t sector_num, 1575 uint8_t *buf, int nb_sectors) 1576 { 1577 return bdrv_rw_co(bs, sector_num, buf, nb_sectors, false); 1578 } 1579 1580 static void set_dirty_bitmap(BlockDriverState *bs, int64_t sector_num, 1581 int nb_sectors, int dirty) 1582 { 1583 int64_t start, end; 1584 unsigned long val, idx, bit; 1585 1586 start = sector_num / BDRV_SECTORS_PER_DIRTY_CHUNK; 1587 end = (sector_num + nb_sectors - 1) / BDRV_SECTORS_PER_DIRTY_CHUNK; 1588 1589 for (; start <= end; start++) { 1590 idx = start / (sizeof(unsigned long) * 8); 1591 bit = start % (sizeof(unsigned long) * 8); 1592 val = bs->dirty_bitmap[idx]; 1593 if (dirty) { 1594 if (!(val & (1UL << bit))) { 1595 bs->dirty_count++; 1596 val |= 1UL << bit; 1597 } 1598 } else { 1599 if (val & (1UL << bit)) { 1600 bs->dirty_count--; 1601 val &= ~(1UL << bit); 1602 } 1603 } 1604 bs->dirty_bitmap[idx] = val; 1605 } 1606 } 1607 1608 /* Return < 0 if error. Important errors are: 1609 -EIO generic I/O error (may happen for all errors) 1610 -ENOMEDIUM No media inserted. 1611 -EINVAL Invalid sector number or nb_sectors 1612 -EACCES Trying to write a read-only device 1613 */ 1614 int bdrv_write(BlockDriverState *bs, int64_t sector_num, 1615 const uint8_t *buf, int nb_sectors) 1616 { 1617 return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true); 1618 } 1619 1620 int bdrv_pread(BlockDriverState *bs, int64_t offset, 1621 void *buf, int count1) 1622 { 1623 uint8_t tmp_buf[BDRV_SECTOR_SIZE]; 1624 int len, nb_sectors, count; 1625 int64_t sector_num; 1626 int ret; 1627 1628 count = count1; 1629 /* first read to align to sector start */ 1630 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1); 1631 if (len > count) 1632 len = count; 1633 sector_num = offset >> BDRV_SECTOR_BITS; 1634 if (len > 0) { 1635 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) 1636 return ret; 1637 memcpy(buf, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), len); 1638 count -= len; 1639 if (count == 0) 1640 return count1; 1641 sector_num++; 1642 buf += len; 1643 } 1644 1645 /* read the sectors "in place" */ 1646 nb_sectors = count >> BDRV_SECTOR_BITS; 1647 if (nb_sectors > 0) { 1648 if ((ret = bdrv_read(bs, sector_num, buf, nb_sectors)) < 0) 1649 return ret; 1650 sector_num += nb_sectors; 1651 len = nb_sectors << BDRV_SECTOR_BITS; 1652 buf += len; 1653 count -= len; 1654 } 1655 1656 /* add data from the last sector */ 1657 if (count > 0) { 1658 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) 1659 return ret; 1660 memcpy(buf, tmp_buf, count); 1661 } 1662 return count1; 1663 } 1664 1665 int bdrv_pwrite(BlockDriverState *bs, int64_t offset, 1666 const void *buf, int count1) 1667 { 1668 uint8_t tmp_buf[BDRV_SECTOR_SIZE]; 1669 int len, nb_sectors, count; 1670 int64_t sector_num; 1671 int ret; 1672 1673 count = count1; 1674 /* first write to align to sector start */ 1675 len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1); 1676 if (len > count) 1677 len = count; 1678 sector_num = offset >> BDRV_SECTOR_BITS; 1679 if (len > 0) { 1680 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) 1681 return ret; 1682 memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len); 1683 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0) 1684 return ret; 1685 count -= len; 1686 if (count == 0) 1687 return count1; 1688 sector_num++; 1689 buf += len; 1690 } 1691 1692 /* write the sectors "in place" */ 1693 nb_sectors = count >> BDRV_SECTOR_BITS; 1694 if (nb_sectors > 0) { 1695 if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0) 1696 return ret; 1697 sector_num += nb_sectors; 1698 len = nb_sectors << BDRV_SECTOR_BITS; 1699 buf += len; 1700 count -= len; 1701 } 1702 1703 /* add data from the last sector */ 1704 if (count > 0) { 1705 if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0) 1706 return ret; 1707 memcpy(tmp_buf, buf, count); 1708 if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0) 1709 return ret; 1710 } 1711 return count1; 1712 } 1713 1714 /* 1715 * Writes to the file and ensures that no writes are reordered across this 1716 * request (acts as a barrier) 1717 * 1718 * Returns 0 on success, -errno in error cases. 1719 */ 1720 int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset, 1721 const void *buf, int count) 1722 { 1723 int ret; 1724 1725 ret = bdrv_pwrite(bs, offset, buf, count); 1726 if (ret < 0) { 1727 return ret; 1728 } 1729 1730 /* No flush needed for cache modes that use O_DSYNC */ 1731 if ((bs->open_flags & BDRV_O_CACHE_WB) != 0) { 1732 bdrv_flush(bs); 1733 } 1734 1735 return 0; 1736 } 1737 1738 static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs, 1739 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov) 1740 { 1741 /* Perform I/O through a temporary buffer so that users who scribble over 1742 * their read buffer while the operation is in progress do not end up 1743 * modifying the image file. This is critical for zero-copy guest I/O 1744 * where anything might happen inside guest memory. 1745 */ 1746 void *bounce_buffer; 1747 1748 BlockDriver *drv = bs->drv; 1749 struct iovec iov; 1750 QEMUIOVector bounce_qiov; 1751 int64_t cluster_sector_num; 1752 int cluster_nb_sectors; 1753 size_t skip_bytes; 1754 int ret; 1755 1756 /* Cover entire cluster so no additional backing file I/O is required when 1757 * allocating cluster in the image file. 1758 */ 1759 round_to_clusters(bs, sector_num, nb_sectors, 1760 &cluster_sector_num, &cluster_nb_sectors); 1761 1762 trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, 1763 cluster_sector_num, cluster_nb_sectors); 1764 1765 iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE; 1766 iov.iov_base = bounce_buffer = qemu_blockalign(bs, iov.iov_len); 1767 qemu_iovec_init_external(&bounce_qiov, &iov, 1); 1768 1769 ret = drv->bdrv_co_readv(bs, cluster_sector_num, cluster_nb_sectors, 1770 &bounce_qiov); 1771 if (ret < 0) { 1772 goto err; 1773 } 1774 1775 if (drv->bdrv_co_write_zeroes && 1776 buffer_is_zero(bounce_buffer, iov.iov_len)) { 1777 ret = bdrv_co_do_write_zeroes(bs, cluster_sector_num, 1778 cluster_nb_sectors); 1779 } else { 1780 ret = drv->bdrv_co_writev(bs, cluster_sector_num, cluster_nb_sectors, 1781 &bounce_qiov); 1782 } 1783 1784 if (ret < 0) { 1785 /* It might be okay to ignore write errors for guest requests. If this 1786 * is a deliberate copy-on-read then we don't want to ignore the error. 1787 * Simply report it in all cases. 1788 */ 1789 goto err; 1790 } 1791 1792 skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE; 1793 qemu_iovec_from_buffer(qiov, bounce_buffer + skip_bytes, 1794 nb_sectors * BDRV_SECTOR_SIZE); 1795 1796 err: 1797 qemu_vfree(bounce_buffer); 1798 return ret; 1799 } 1800 1801 /* 1802 * Handle a read request in coroutine context 1803 */ 1804 static int coroutine_fn bdrv_co_do_readv(BlockDriverState *bs, 1805 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, 1806 BdrvRequestFlags flags) 1807 { 1808 BlockDriver *drv = bs->drv; 1809 BdrvTrackedRequest req; 1810 int ret; 1811 1812 if (!drv) { 1813 return -ENOMEDIUM; 1814 } 1815 if (bdrv_check_request(bs, sector_num, nb_sectors)) { 1816 return -EIO; 1817 } 1818 1819 /* throttling disk read I/O */ 1820 if (bs->io_limits_enabled) { 1821 bdrv_io_limits_intercept(bs, false, nb_sectors); 1822 } 1823 1824 if (bs->copy_on_read) { 1825 flags |= BDRV_REQ_COPY_ON_READ; 1826 } 1827 if (flags & BDRV_REQ_COPY_ON_READ) { 1828 bs->copy_on_read_in_flight++; 1829 } 1830 1831 if (bs->copy_on_read_in_flight) { 1832 wait_for_overlapping_requests(bs, sector_num, nb_sectors); 1833 } 1834 1835 tracked_request_begin(&req, bs, sector_num, nb_sectors, false); 1836 1837 if (flags & BDRV_REQ_COPY_ON_READ) { 1838 int pnum; 1839 1840 ret = bdrv_co_is_allocated(bs, sector_num, nb_sectors, &pnum); 1841 if (ret < 0) { 1842 goto out; 1843 } 1844 1845 if (!ret || pnum != nb_sectors) { 1846 ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov); 1847 goto out; 1848 } 1849 } 1850 1851 ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov); 1852 1853 out: 1854 tracked_request_end(&req); 1855 1856 if (flags & BDRV_REQ_COPY_ON_READ) { 1857 bs->copy_on_read_in_flight--; 1858 } 1859 1860 return ret; 1861 } 1862 1863 int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num, 1864 int nb_sectors, QEMUIOVector *qiov) 1865 { 1866 trace_bdrv_co_readv(bs, sector_num, nb_sectors); 1867 1868 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 0); 1869 } 1870 1871 int coroutine_fn bdrv_co_copy_on_readv(BlockDriverState *bs, 1872 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov) 1873 { 1874 trace_bdrv_co_copy_on_readv(bs, sector_num, nb_sectors); 1875 1876 return bdrv_co_do_readv(bs, sector_num, nb_sectors, qiov, 1877 BDRV_REQ_COPY_ON_READ); 1878 } 1879 1880 static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs, 1881 int64_t sector_num, int nb_sectors) 1882 { 1883 BlockDriver *drv = bs->drv; 1884 QEMUIOVector qiov; 1885 struct iovec iov; 1886 int ret; 1887 1888 /* TODO Emulate only part of misaligned requests instead of letting block 1889 * drivers return -ENOTSUP and emulate everything */ 1890 1891 /* First try the efficient write zeroes operation */ 1892 if (drv->bdrv_co_write_zeroes) { 1893 ret = drv->bdrv_co_write_zeroes(bs, sector_num, nb_sectors); 1894 if (ret != -ENOTSUP) { 1895 return ret; 1896 } 1897 } 1898 1899 /* Fall back to bounce buffer if write zeroes is unsupported */ 1900 iov.iov_len = nb_sectors * BDRV_SECTOR_SIZE; 1901 iov.iov_base = qemu_blockalign(bs, iov.iov_len); 1902 memset(iov.iov_base, 0, iov.iov_len); 1903 qemu_iovec_init_external(&qiov, &iov, 1); 1904 1905 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, &qiov); 1906 1907 qemu_vfree(iov.iov_base); 1908 return ret; 1909 } 1910 1911 /* 1912 * Handle a write request in coroutine context 1913 */ 1914 static int coroutine_fn bdrv_co_do_writev(BlockDriverState *bs, 1915 int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, 1916 BdrvRequestFlags flags) 1917 { 1918 BlockDriver *drv = bs->drv; 1919 BdrvTrackedRequest req; 1920 int ret; 1921 1922 if (!bs->drv) { 1923 return -ENOMEDIUM; 1924 } 1925 if (bs->read_only) { 1926 return -EACCES; 1927 } 1928 if (bdrv_check_request(bs, sector_num, nb_sectors)) { 1929 return -EIO; 1930 } 1931 1932 /* throttling disk write I/O */ 1933 if (bs->io_limits_enabled) { 1934 bdrv_io_limits_intercept(bs, true, nb_sectors); 1935 } 1936 1937 if (bs->copy_on_read_in_flight) { 1938 wait_for_overlapping_requests(bs, sector_num, nb_sectors); 1939 } 1940 1941 tracked_request_begin(&req, bs, sector_num, nb_sectors, true); 1942 1943 if (flags & BDRV_REQ_ZERO_WRITE) { 1944 ret = bdrv_co_do_write_zeroes(bs, sector_num, nb_sectors); 1945 } else { 1946 ret = drv->bdrv_co_writev(bs, sector_num, nb_sectors, qiov); 1947 } 1948 1949 if (bs->dirty_bitmap) { 1950 set_dirty_bitmap(bs, sector_num, nb_sectors, 1); 1951 } 1952 1953 if (bs->wr_highest_sector < sector_num + nb_sectors - 1) { 1954 bs->wr_highest_sector = sector_num + nb_sectors - 1; 1955 } 1956 1957 tracked_request_end(&req); 1958 1959 return ret; 1960 } 1961 1962 int coroutine_fn bdrv_co_writev(BlockDriverState *bs, int64_t sector_num, 1963 int nb_sectors, QEMUIOVector *qiov) 1964 { 1965 trace_bdrv_co_writev(bs, sector_num, nb_sectors); 1966 1967 return bdrv_co_do_writev(bs, sector_num, nb_sectors, qiov, 0); 1968 } 1969 1970 int coroutine_fn bdrv_co_write_zeroes(BlockDriverState *bs, 1971 int64_t sector_num, int nb_sectors) 1972 { 1973 trace_bdrv_co_write_zeroes(bs, sector_num, nb_sectors); 1974 1975 return bdrv_co_do_writev(bs, sector_num, nb_sectors, NULL, 1976 BDRV_REQ_ZERO_WRITE); 1977 } 1978 1979 /** 1980 * Truncate file to 'offset' bytes (needed only for file protocols) 1981 */ 1982 int bdrv_truncate(BlockDriverState *bs, int64_t offset) 1983 { 1984 BlockDriver *drv = bs->drv; 1985 int ret; 1986 if (!drv) 1987 return -ENOMEDIUM; 1988 if (!drv->bdrv_truncate) 1989 return -ENOTSUP; 1990 if (bs->read_only) 1991 return -EACCES; 1992 if (bdrv_in_use(bs)) 1993 return -EBUSY; 1994 ret = drv->bdrv_truncate(bs, offset); 1995 if (ret == 0) { 1996 ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS); 1997 bdrv_dev_resize_cb(bs); 1998 } 1999 return ret; 2000 } 2001 2002 /** 2003 * Length of a allocated file in bytes. Sparse files are counted by actual 2004 * allocated space. Return < 0 if error or unknown. 2005 */ 2006 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs) 2007 { 2008 BlockDriver *drv = bs->drv; 2009 if (!drv) { 2010 return -ENOMEDIUM; 2011 } 2012 if (drv->bdrv_get_allocated_file_size) { 2013 return drv->bdrv_get_allocated_file_size(bs); 2014 } 2015 if (bs->file) { 2016 return bdrv_get_allocated_file_size(bs->file); 2017 } 2018 return -ENOTSUP; 2019 } 2020 2021 /** 2022 * Length of a file in bytes. Return < 0 if error or unknown. 2023 */ 2024 int64_t bdrv_getlength(BlockDriverState *bs) 2025 { 2026 BlockDriver *drv = bs->drv; 2027 if (!drv) 2028 return -ENOMEDIUM; 2029 2030 if (bs->growable || bdrv_dev_has_removable_media(bs)) { 2031 if (drv->bdrv_getlength) { 2032 return drv->bdrv_getlength(bs); 2033 } 2034 } 2035 return bs->total_sectors * BDRV_SECTOR_SIZE; 2036 } 2037 2038 /* return 0 as number of sectors if no device present or error */ 2039 void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr) 2040 { 2041 int64_t length; 2042 length = bdrv_getlength(bs); 2043 if (length < 0) 2044 length = 0; 2045 else 2046 length = length >> BDRV_SECTOR_BITS; 2047 *nb_sectors_ptr = length; 2048 } 2049 2050 struct partition { 2051 uint8_t boot_ind; /* 0x80 - active */ 2052 uint8_t head; /* starting head */ 2053 uint8_t sector; /* starting sector */ 2054 uint8_t cyl; /* starting cylinder */ 2055 uint8_t sys_ind; /* What partition type */ 2056 uint8_t end_head; /* end head */ 2057 uint8_t end_sector; /* end sector */ 2058 uint8_t end_cyl; /* end cylinder */ 2059 uint32_t start_sect; /* starting sector counting from 0 */ 2060 uint32_t nr_sects; /* nr of sectors in partition */ 2061 } QEMU_PACKED; 2062 2063 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */ 2064 static int guess_disk_lchs(BlockDriverState *bs, 2065 int *pcylinders, int *pheads, int *psectors) 2066 { 2067 uint8_t buf[BDRV_SECTOR_SIZE]; 2068 int ret, i, heads, sectors, cylinders; 2069 struct partition *p; 2070 uint32_t nr_sects; 2071 uint64_t nb_sectors; 2072 bool enabled; 2073 2074 bdrv_get_geometry(bs, &nb_sectors); 2075 2076 /** 2077 * The function will be invoked during startup not only in sync I/O mode, 2078 * but also in async I/O mode. So the I/O throttling function has to 2079 * be disabled temporarily here, not permanently. 2080 */ 2081 enabled = bs->io_limits_enabled; 2082 bs->io_limits_enabled = false; 2083 ret = bdrv_read(bs, 0, buf, 1); 2084 bs->io_limits_enabled = enabled; 2085 if (ret < 0) 2086 return -1; 2087 /* test msdos magic */ 2088 if (buf[510] != 0x55 || buf[511] != 0xaa) 2089 return -1; 2090 for(i = 0; i < 4; i++) { 2091 p = ((struct partition *)(buf + 0x1be)) + i; 2092 nr_sects = le32_to_cpu(p->nr_sects); 2093 if (nr_sects && p->end_head) { 2094 /* We make the assumption that the partition terminates on 2095 a cylinder boundary */ 2096 heads = p->end_head + 1; 2097 sectors = p->end_sector & 63; 2098 if (sectors == 0) 2099 continue; 2100 cylinders = nb_sectors / (heads * sectors); 2101 if (cylinders < 1 || cylinders > 16383) 2102 continue; 2103 *pheads = heads; 2104 *psectors = sectors; 2105 *pcylinders = cylinders; 2106 #if 0 2107 printf("guessed geometry: LCHS=%d %d %d\n", 2108 cylinders, heads, sectors); 2109 #endif 2110 return 0; 2111 } 2112 } 2113 return -1; 2114 } 2115 2116 void bdrv_guess_geometry(BlockDriverState *bs, int *pcyls, int *pheads, int *psecs) 2117 { 2118 int translation, lba_detected = 0; 2119 int cylinders, heads, secs; 2120 uint64_t nb_sectors; 2121 2122 /* if a geometry hint is available, use it */ 2123 bdrv_get_geometry(bs, &nb_sectors); 2124 bdrv_get_geometry_hint(bs, &cylinders, &heads, &secs); 2125 translation = bdrv_get_translation_hint(bs); 2126 if (cylinders != 0) { 2127 *pcyls = cylinders; 2128 *pheads = heads; 2129 *psecs = secs; 2130 } else { 2131 if (guess_disk_lchs(bs, &cylinders, &heads, &secs) == 0) { 2132 if (heads > 16) { 2133 /* if heads > 16, it means that a BIOS LBA 2134 translation was active, so the default 2135 hardware geometry is OK */ 2136 lba_detected = 1; 2137 goto default_geometry; 2138 } else { 2139 *pcyls = cylinders; 2140 *pheads = heads; 2141 *psecs = secs; 2142 /* disable any translation to be in sync with 2143 the logical geometry */ 2144 if (translation == BIOS_ATA_TRANSLATION_AUTO) { 2145 bdrv_set_translation_hint(bs, 2146 BIOS_ATA_TRANSLATION_NONE); 2147 } 2148 } 2149 } else { 2150 default_geometry: 2151 /* if no geometry, use a standard physical disk geometry */ 2152 cylinders = nb_sectors / (16 * 63); 2153 2154 if (cylinders > 16383) 2155 cylinders = 16383; 2156 else if (cylinders < 2) 2157 cylinders = 2; 2158 *pcyls = cylinders; 2159 *pheads = 16; 2160 *psecs = 63; 2161 if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) { 2162 if ((*pcyls * *pheads) <= 131072) { 2163 bdrv_set_translation_hint(bs, 2164 BIOS_ATA_TRANSLATION_LARGE); 2165 } else { 2166 bdrv_set_translation_hint(bs, 2167 BIOS_ATA_TRANSLATION_LBA); 2168 } 2169 } 2170 } 2171 bdrv_set_geometry_hint(bs, *pcyls, *pheads, *psecs); 2172 } 2173 } 2174 2175 void bdrv_set_geometry_hint(BlockDriverState *bs, 2176 int cyls, int heads, int secs) 2177 { 2178 bs->cyls = cyls; 2179 bs->heads = heads; 2180 bs->secs = secs; 2181 } 2182 2183 void bdrv_set_translation_hint(BlockDriverState *bs, int translation) 2184 { 2185 bs->translation = translation; 2186 } 2187 2188 void bdrv_get_geometry_hint(BlockDriverState *bs, 2189 int *pcyls, int *pheads, int *psecs) 2190 { 2191 *pcyls = bs->cyls; 2192 *pheads = bs->heads; 2193 *psecs = bs->secs; 2194 } 2195 2196 /* throttling disk io limits */ 2197 void bdrv_set_io_limits(BlockDriverState *bs, 2198 BlockIOLimit *io_limits) 2199 { 2200 bs->io_limits = *io_limits; 2201 bs->io_limits_enabled = bdrv_io_limits_enabled(bs); 2202 } 2203 2204 /* Recognize floppy formats */ 2205 typedef struct FDFormat { 2206 FDriveType drive; 2207 uint8_t last_sect; 2208 uint8_t max_track; 2209 uint8_t max_head; 2210 FDriveRate rate; 2211 } FDFormat; 2212 2213 static const FDFormat fd_formats[] = { 2214 /* First entry is default format */ 2215 /* 1.44 MB 3"1/2 floppy disks */ 2216 { FDRIVE_DRV_144, 18, 80, 1, FDRIVE_RATE_500K, }, 2217 { FDRIVE_DRV_144, 20, 80, 1, FDRIVE_RATE_500K, }, 2218 { FDRIVE_DRV_144, 21, 80, 1, FDRIVE_RATE_500K, }, 2219 { FDRIVE_DRV_144, 21, 82, 1, FDRIVE_RATE_500K, }, 2220 { FDRIVE_DRV_144, 21, 83, 1, FDRIVE_RATE_500K, }, 2221 { FDRIVE_DRV_144, 22, 80, 1, FDRIVE_RATE_500K, }, 2222 { FDRIVE_DRV_144, 23, 80, 1, FDRIVE_RATE_500K, }, 2223 { FDRIVE_DRV_144, 24, 80, 1, FDRIVE_RATE_500K, }, 2224 /* 2.88 MB 3"1/2 floppy disks */ 2225 { FDRIVE_DRV_288, 36, 80, 1, FDRIVE_RATE_1M, }, 2226 { FDRIVE_DRV_288, 39, 80, 1, FDRIVE_RATE_1M, }, 2227 { FDRIVE_DRV_288, 40, 80, 1, FDRIVE_RATE_1M, }, 2228 { FDRIVE_DRV_288, 44, 80, 1, FDRIVE_RATE_1M, }, 2229 { FDRIVE_DRV_288, 48, 80, 1, FDRIVE_RATE_1M, }, 2230 /* 720 kB 3"1/2 floppy disks */ 2231 { FDRIVE_DRV_144, 9, 80, 1, FDRIVE_RATE_250K, }, 2232 { FDRIVE_DRV_144, 10, 80, 1, FDRIVE_RATE_250K, }, 2233 { FDRIVE_DRV_144, 10, 82, 1, FDRIVE_RATE_250K, }, 2234 { FDRIVE_DRV_144, 10, 83, 1, FDRIVE_RATE_250K, }, 2235 { FDRIVE_DRV_144, 13, 80, 1, FDRIVE_RATE_250K, }, 2236 { FDRIVE_DRV_144, 14, 80, 1, FDRIVE_RATE_250K, }, 2237 /* 1.2 MB 5"1/4 floppy disks */ 2238 { FDRIVE_DRV_120, 15, 80, 1, FDRIVE_RATE_500K, }, 2239 { FDRIVE_DRV_120, 18, 80, 1, FDRIVE_RATE_500K, }, 2240 { FDRIVE_DRV_120, 18, 82, 1, FDRIVE_RATE_500K, }, 2241 { FDRIVE_DRV_120, 18, 83, 1, FDRIVE_RATE_500K, }, 2242 { FDRIVE_DRV_120, 20, 80, 1, FDRIVE_RATE_500K, }, 2243 /* 720 kB 5"1/4 floppy disks */ 2244 { FDRIVE_DRV_120, 9, 80, 1, FDRIVE_RATE_250K, }, 2245 { FDRIVE_DRV_120, 11, 80, 1, FDRIVE_RATE_250K, }, 2246 /* 360 kB 5"1/4 floppy disks */ 2247 { FDRIVE_DRV_120, 9, 40, 1, FDRIVE_RATE_300K, }, 2248 { FDRIVE_DRV_120, 9, 40, 0, FDRIVE_RATE_300K, }, 2249 { FDRIVE_DRV_120, 10, 41, 1, FDRIVE_RATE_300K, }, 2250 { FDRIVE_DRV_120, 10, 42, 1, FDRIVE_RATE_300K, }, 2251 /* 320 kB 5"1/4 floppy disks */ 2252 { FDRIVE_DRV_120, 8, 40, 1, FDRIVE_RATE_250K, }, 2253 { FDRIVE_DRV_120, 8, 40, 0, FDRIVE_RATE_250K, }, 2254 /* 360 kB must match 5"1/4 better than 3"1/2... */ 2255 { FDRIVE_DRV_144, 9, 80, 0, FDRIVE_RATE_250K, }, 2256 /* end */ 2257 { FDRIVE_DRV_NONE, -1, -1, 0, 0, }, 2258 }; 2259 2260 void bdrv_get_floppy_geometry_hint(BlockDriverState *bs, int *nb_heads, 2261 int *max_track, int *last_sect, 2262 FDriveType drive_in, FDriveType *drive, 2263 FDriveRate *rate) 2264 { 2265 const FDFormat *parse; 2266 uint64_t nb_sectors, size; 2267 int i, first_match, match; 2268 2269 bdrv_get_geometry_hint(bs, nb_heads, max_track, last_sect); 2270 if (*nb_heads != 0 && *max_track != 0 && *last_sect != 0) { 2271 /* User defined disk */ 2272 *rate = FDRIVE_RATE_500K; 2273 } else { 2274 bdrv_get_geometry(bs, &nb_sectors); 2275 match = -1; 2276 first_match = -1; 2277 for (i = 0; ; i++) { 2278 parse = &fd_formats[i]; 2279 if (parse->drive == FDRIVE_DRV_NONE) { 2280 break; 2281 } 2282 if (drive_in == parse->drive || 2283 drive_in == FDRIVE_DRV_NONE) { 2284 size = (parse->max_head + 1) * parse->max_track * 2285 parse->last_sect; 2286 if (nb_sectors == size) { 2287 match = i; 2288 break; 2289 } 2290 if (first_match == -1) { 2291 first_match = i; 2292 } 2293 } 2294 } 2295 if (match == -1) { 2296 if (first_match == -1) { 2297 match = 1; 2298 } else { 2299 match = first_match; 2300 } 2301 parse = &fd_formats[match]; 2302 } 2303 *nb_heads = parse->max_head + 1; 2304 *max_track = parse->max_track; 2305 *last_sect = parse->last_sect; 2306 *drive = parse->drive; 2307 *rate = parse->rate; 2308 } 2309 } 2310 2311 int bdrv_get_translation_hint(BlockDriverState *bs) 2312 { 2313 return bs->translation; 2314 } 2315 2316 void bdrv_set_on_error(BlockDriverState *bs, BlockErrorAction on_read_error, 2317 BlockErrorAction on_write_error) 2318 { 2319 bs->on_read_error = on_read_error; 2320 bs->on_write_error = on_write_error; 2321 } 2322 2323 BlockErrorAction bdrv_get_on_error(BlockDriverState *bs, int is_read) 2324 { 2325 return is_read ? bs->on_read_error : bs->on_write_error; 2326 } 2327 2328 int bdrv_is_read_only(BlockDriverState *bs) 2329 { 2330 return bs->read_only; 2331 } 2332 2333 int bdrv_is_sg(BlockDriverState *bs) 2334 { 2335 return bs->sg; 2336 } 2337 2338 int bdrv_enable_write_cache(BlockDriverState *bs) 2339 { 2340 return bs->enable_write_cache; 2341 } 2342 2343 int bdrv_is_encrypted(BlockDriverState *bs) 2344 { 2345 if (bs->backing_hd && bs->backing_hd->encrypted) 2346 return 1; 2347 return bs->encrypted; 2348 } 2349 2350 int bdrv_key_required(BlockDriverState *bs) 2351 { 2352 BlockDriverState *backing_hd = bs->backing_hd; 2353 2354 if (backing_hd && backing_hd->encrypted && !backing_hd->valid_key) 2355 return 1; 2356 return (bs->encrypted && !bs->valid_key); 2357 } 2358 2359 int bdrv_set_key(BlockDriverState *bs, const char *key) 2360 { 2361 int ret; 2362 if (bs->backing_hd && bs->backing_hd->encrypted) { 2363 ret = bdrv_set_key(bs->backing_hd, key); 2364 if (ret < 0) 2365 return ret; 2366 if (!bs->encrypted) 2367 return 0; 2368 } 2369 if (!bs->encrypted) { 2370 return -EINVAL; 2371 } else if (!bs->drv || !bs->drv->bdrv_set_key) { 2372 return -ENOMEDIUM; 2373 } 2374 ret = bs->drv->bdrv_set_key(bs, key); 2375 if (ret < 0) { 2376 bs->valid_key = 0; 2377 } else if (!bs->valid_key) { 2378 bs->valid_key = 1; 2379 /* call the change callback now, we skipped it on open */ 2380 bdrv_dev_change_media_cb(bs, true); 2381 } 2382 return ret; 2383 } 2384 2385 void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size) 2386 { 2387 if (!bs->drv) { 2388 buf[0] = '\0'; 2389 } else { 2390 pstrcpy(buf, buf_size, bs->drv->format_name); 2391 } 2392 } 2393 2394 void bdrv_iterate_format(void (*it)(void *opaque, const char *name), 2395 void *opaque) 2396 { 2397 BlockDriver *drv; 2398 2399 QLIST_FOREACH(drv, &bdrv_drivers, list) { 2400 it(opaque, drv->format_name); 2401 } 2402 } 2403 2404 BlockDriverState *bdrv_find(const char *name) 2405 { 2406 BlockDriverState *bs; 2407 2408 QTAILQ_FOREACH(bs, &bdrv_states, list) { 2409 if (!strcmp(name, bs->device_name)) { 2410 return bs; 2411 } 2412 } 2413 return NULL; 2414 } 2415 2416 BlockDriverState *bdrv_next(BlockDriverState *bs) 2417 { 2418 if (!bs) { 2419 return QTAILQ_FIRST(&bdrv_states); 2420 } 2421 return QTAILQ_NEXT(bs, list); 2422 } 2423 2424 void bdrv_iterate(void (*it)(void *opaque, BlockDriverState *bs), void *opaque) 2425 { 2426 BlockDriverState *bs; 2427 2428 QTAILQ_FOREACH(bs, &bdrv_states, list) { 2429 it(opaque, bs); 2430 } 2431 } 2432 2433 const char *bdrv_get_device_name(BlockDriverState *bs) 2434 { 2435 return bs->device_name; 2436 } 2437 2438 void bdrv_flush_all(void) 2439 { 2440 BlockDriverState *bs; 2441 2442 QTAILQ_FOREACH(bs, &bdrv_states, list) { 2443 bdrv_flush(bs); 2444 } 2445 } 2446 2447 int bdrv_has_zero_init(BlockDriverState *bs) 2448 { 2449 assert(bs->drv); 2450 2451 if (bs->drv->bdrv_has_zero_init) { 2452 return bs->drv->bdrv_has_zero_init(bs); 2453 } 2454 2455 return 1; 2456 } 2457 2458 typedef struct BdrvCoIsAllocatedData { 2459 BlockDriverState *bs; 2460 int64_t sector_num; 2461 int nb_sectors; 2462 int *pnum; 2463 int ret; 2464 bool done; 2465 } BdrvCoIsAllocatedData; 2466 2467 /* 2468 * Returns true iff the specified sector is present in the disk image. Drivers 2469 * not implementing the functionality are assumed to not support backing files, 2470 * hence all their sectors are reported as allocated. 2471 * 2472 * If 'sector_num' is beyond the end of the disk image the return value is 0 2473 * and 'pnum' is set to 0. 2474 * 2475 * 'pnum' is set to the number of sectors (including and immediately following 2476 * the specified sector) that are known to be in the same 2477 * allocated/unallocated state. 2478 * 2479 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes 2480 * beyond the end of the disk image it will be clamped. 2481 */ 2482 int coroutine_fn bdrv_co_is_allocated(BlockDriverState *bs, int64_t sector_num, 2483 int nb_sectors, int *pnum) 2484 { 2485 int64_t n; 2486 2487 if (sector_num >= bs->total_sectors) { 2488 *pnum = 0; 2489 return 0; 2490 } 2491 2492 n = bs->total_sectors - sector_num; 2493 if (n < nb_sectors) { 2494 nb_sectors = n; 2495 } 2496 2497 if (!bs->drv->bdrv_co_is_allocated) { 2498 *pnum = nb_sectors; 2499 return 1; 2500 } 2501 2502 return bs->drv->bdrv_co_is_allocated(bs, sector_num, nb_sectors, pnum); 2503 } 2504 2505 /* Coroutine wrapper for bdrv_is_allocated() */ 2506 static void coroutine_fn bdrv_is_allocated_co_entry(void *opaque) 2507 { 2508 BdrvCoIsAllocatedData *data = opaque; 2509 BlockDriverState *bs = data->bs; 2510 2511 data->ret = bdrv_co_is_allocated(bs, data->sector_num, data->nb_sectors, 2512 data->pnum); 2513 data->done = true; 2514 } 2515 2516 /* 2517 * Synchronous wrapper around bdrv_co_is_allocated(). 2518 * 2519 * See bdrv_co_is_allocated() for details. 2520 */ 2521 int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors, 2522 int *pnum) 2523 { 2524 Coroutine *co; 2525 BdrvCoIsAllocatedData data = { 2526 .bs = bs, 2527 .sector_num = sector_num, 2528 .nb_sectors = nb_sectors, 2529 .pnum = pnum, 2530 .done = false, 2531 }; 2532 2533 co = qemu_coroutine_create(bdrv_is_allocated_co_entry); 2534 qemu_coroutine_enter(co, &data); 2535 while (!data.done) { 2536 qemu_aio_wait(); 2537 } 2538 return data.ret; 2539 } 2540 2541 BlockInfoList *qmp_query_block(Error **errp) 2542 { 2543 BlockInfoList *head = NULL, *cur_item = NULL; 2544 BlockDriverState *bs; 2545 2546 QTAILQ_FOREACH(bs, &bdrv_states, list) { 2547 BlockInfoList *info = g_malloc0(sizeof(*info)); 2548 2549 info->value = g_malloc0(sizeof(*info->value)); 2550 info->value->device = g_strdup(bs->device_name); 2551 info->value->type = g_strdup("unknown"); 2552 info->value->locked = bdrv_dev_is_medium_locked(bs); 2553 info->value->removable = bdrv_dev_has_removable_media(bs); 2554 2555 if (bdrv_dev_has_removable_media(bs)) { 2556 info->value->has_tray_open = true; 2557 info->value->tray_open = bdrv_dev_is_tray_open(bs); 2558 } 2559 2560 if (bdrv_iostatus_is_enabled(bs)) { 2561 info->value->has_io_status = true; 2562 info->value->io_status = bs->iostatus; 2563 } 2564 2565 if (bs->drv) { 2566 info->value->has_inserted = true; 2567 info->value->inserted = g_malloc0(sizeof(*info->value->inserted)); 2568 info->value->inserted->file = g_strdup(bs->filename); 2569 info->value->inserted->ro = bs->read_only; 2570 info->value->inserted->drv = g_strdup(bs->drv->format_name); 2571 info->value->inserted->encrypted = bs->encrypted; 2572 if (bs->backing_file[0]) { 2573 info->value->inserted->has_backing_file = true; 2574 info->value->inserted->backing_file = g_strdup(bs->backing_file); 2575 } 2576 2577 if (bs->io_limits_enabled) { 2578 info->value->inserted->bps = 2579 bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]; 2580 info->value->inserted->bps_rd = 2581 bs->io_limits.bps[BLOCK_IO_LIMIT_READ]; 2582 info->value->inserted->bps_wr = 2583 bs->io_limits.bps[BLOCK_IO_LIMIT_WRITE]; 2584 info->value->inserted->iops = 2585 bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]; 2586 info->value->inserted->iops_rd = 2587 bs->io_limits.iops[BLOCK_IO_LIMIT_READ]; 2588 info->value->inserted->iops_wr = 2589 bs->io_limits.iops[BLOCK_IO_LIMIT_WRITE]; 2590 } 2591 } 2592 2593 /* XXX: waiting for the qapi to support GSList */ 2594 if (!cur_item) { 2595 head = cur_item = info; 2596 } else { 2597 cur_item->next = info; 2598 cur_item = info; 2599 } 2600 } 2601 2602 return head; 2603 } 2604 2605 /* Consider exposing this as a full fledged QMP command */ 2606 static BlockStats *qmp_query_blockstat(const BlockDriverState *bs, Error **errp) 2607 { 2608 BlockStats *s; 2609 2610 s = g_malloc0(sizeof(*s)); 2611 2612 if (bs->device_name[0]) { 2613 s->has_device = true; 2614 s->device = g_strdup(bs->device_name); 2615 } 2616 2617 s->stats = g_malloc0(sizeof(*s->stats)); 2618 s->stats->rd_bytes = bs->nr_bytes[BDRV_ACCT_READ]; 2619 s->stats->wr_bytes = bs->nr_bytes[BDRV_ACCT_WRITE]; 2620 s->stats->rd_operations = bs->nr_ops[BDRV_ACCT_READ]; 2621 s->stats->wr_operations = bs->nr_ops[BDRV_ACCT_WRITE]; 2622 s->stats->wr_highest_offset = bs->wr_highest_sector * BDRV_SECTOR_SIZE; 2623 s->stats->flush_operations = bs->nr_ops[BDRV_ACCT_FLUSH]; 2624 s->stats->wr_total_time_ns = bs->total_time_ns[BDRV_ACCT_WRITE]; 2625 s->stats->rd_total_time_ns = bs->total_time_ns[BDRV_ACCT_READ]; 2626 s->stats->flush_total_time_ns = bs->total_time_ns[BDRV_ACCT_FLUSH]; 2627 2628 if (bs->file) { 2629 s->has_parent = true; 2630 s->parent = qmp_query_blockstat(bs->file, NULL); 2631 } 2632 2633 return s; 2634 } 2635 2636 BlockStatsList *qmp_query_blockstats(Error **errp) 2637 { 2638 BlockStatsList *head = NULL, *cur_item = NULL; 2639 BlockDriverState *bs; 2640 2641 QTAILQ_FOREACH(bs, &bdrv_states, list) { 2642 BlockStatsList *info = g_malloc0(sizeof(*info)); 2643 info->value = qmp_query_blockstat(bs, NULL); 2644 2645 /* XXX: waiting for the qapi to support GSList */ 2646 if (!cur_item) { 2647 head = cur_item = info; 2648 } else { 2649 cur_item->next = info; 2650 cur_item = info; 2651 } 2652 } 2653 2654 return head; 2655 } 2656 2657 const char *bdrv_get_encrypted_filename(BlockDriverState *bs) 2658 { 2659 if (bs->backing_hd && bs->backing_hd->encrypted) 2660 return bs->backing_file; 2661 else if (bs->encrypted) 2662 return bs->filename; 2663 else 2664 return NULL; 2665 } 2666 2667 void bdrv_get_backing_filename(BlockDriverState *bs, 2668 char *filename, int filename_size) 2669 { 2670 pstrcpy(filename, filename_size, bs->backing_file); 2671 } 2672 2673 int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 2674 const uint8_t *buf, int nb_sectors) 2675 { 2676 BlockDriver *drv = bs->drv; 2677 if (!drv) 2678 return -ENOMEDIUM; 2679 if (!drv->bdrv_write_compressed) 2680 return -ENOTSUP; 2681 if (bdrv_check_request(bs, sector_num, nb_sectors)) 2682 return -EIO; 2683 2684 if (bs->dirty_bitmap) { 2685 set_dirty_bitmap(bs, sector_num, nb_sectors, 1); 2686 } 2687 2688 return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors); 2689 } 2690 2691 int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 2692 { 2693 BlockDriver *drv = bs->drv; 2694 if (!drv) 2695 return -ENOMEDIUM; 2696 if (!drv->bdrv_get_info) 2697 return -ENOTSUP; 2698 memset(bdi, 0, sizeof(*bdi)); 2699 return drv->bdrv_get_info(bs, bdi); 2700 } 2701 2702 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf, 2703 int64_t pos, int size) 2704 { 2705 BlockDriver *drv = bs->drv; 2706 if (!drv) 2707 return -ENOMEDIUM; 2708 if (drv->bdrv_save_vmstate) 2709 return drv->bdrv_save_vmstate(bs, buf, pos, size); 2710 if (bs->file) 2711 return bdrv_save_vmstate(bs->file, buf, pos, size); 2712 return -ENOTSUP; 2713 } 2714 2715 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf, 2716 int64_t pos, int size) 2717 { 2718 BlockDriver *drv = bs->drv; 2719 if (!drv) 2720 return -ENOMEDIUM; 2721 if (drv->bdrv_load_vmstate) 2722 return drv->bdrv_load_vmstate(bs, buf, pos, size); 2723 if (bs->file) 2724 return bdrv_load_vmstate(bs->file, buf, pos, size); 2725 return -ENOTSUP; 2726 } 2727 2728 void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event) 2729 { 2730 BlockDriver *drv = bs->drv; 2731 2732 if (!drv || !drv->bdrv_debug_event) { 2733 return; 2734 } 2735 2736 return drv->bdrv_debug_event(bs, event); 2737 2738 } 2739 2740 /**************************************************************/ 2741 /* handling of snapshots */ 2742 2743 int bdrv_can_snapshot(BlockDriverState *bs) 2744 { 2745 BlockDriver *drv = bs->drv; 2746 if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) { 2747 return 0; 2748 } 2749 2750 if (!drv->bdrv_snapshot_create) { 2751 if (bs->file != NULL) { 2752 return bdrv_can_snapshot(bs->file); 2753 } 2754 return 0; 2755 } 2756 2757 return 1; 2758 } 2759 2760 int bdrv_is_snapshot(BlockDriverState *bs) 2761 { 2762 return !!(bs->open_flags & BDRV_O_SNAPSHOT); 2763 } 2764 2765 BlockDriverState *bdrv_snapshots(void) 2766 { 2767 BlockDriverState *bs; 2768 2769 if (bs_snapshots) { 2770 return bs_snapshots; 2771 } 2772 2773 bs = NULL; 2774 while ((bs = bdrv_next(bs))) { 2775 if (bdrv_can_snapshot(bs)) { 2776 bs_snapshots = bs; 2777 return bs; 2778 } 2779 } 2780 return NULL; 2781 } 2782 2783 int bdrv_snapshot_create(BlockDriverState *bs, 2784 QEMUSnapshotInfo *sn_info) 2785 { 2786 BlockDriver *drv = bs->drv; 2787 if (!drv) 2788 return -ENOMEDIUM; 2789 if (drv->bdrv_snapshot_create) 2790 return drv->bdrv_snapshot_create(bs, sn_info); 2791 if (bs->file) 2792 return bdrv_snapshot_create(bs->file, sn_info); 2793 return -ENOTSUP; 2794 } 2795 2796 int bdrv_snapshot_goto(BlockDriverState *bs, 2797 const char *snapshot_id) 2798 { 2799 BlockDriver *drv = bs->drv; 2800 int ret, open_ret; 2801 2802 if (!drv) 2803 return -ENOMEDIUM; 2804 if (drv->bdrv_snapshot_goto) 2805 return drv->bdrv_snapshot_goto(bs, snapshot_id); 2806 2807 if (bs->file) { 2808 drv->bdrv_close(bs); 2809 ret = bdrv_snapshot_goto(bs->file, snapshot_id); 2810 open_ret = drv->bdrv_open(bs, bs->open_flags); 2811 if (open_ret < 0) { 2812 bdrv_delete(bs->file); 2813 bs->drv = NULL; 2814 return open_ret; 2815 } 2816 return ret; 2817 } 2818 2819 return -ENOTSUP; 2820 } 2821 2822 int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id) 2823 { 2824 BlockDriver *drv = bs->drv; 2825 if (!drv) 2826 return -ENOMEDIUM; 2827 if (drv->bdrv_snapshot_delete) 2828 return drv->bdrv_snapshot_delete(bs, snapshot_id); 2829 if (bs->file) 2830 return bdrv_snapshot_delete(bs->file, snapshot_id); 2831 return -ENOTSUP; 2832 } 2833 2834 int bdrv_snapshot_list(BlockDriverState *bs, 2835 QEMUSnapshotInfo **psn_info) 2836 { 2837 BlockDriver *drv = bs->drv; 2838 if (!drv) 2839 return -ENOMEDIUM; 2840 if (drv->bdrv_snapshot_list) 2841 return drv->bdrv_snapshot_list(bs, psn_info); 2842 if (bs->file) 2843 return bdrv_snapshot_list(bs->file, psn_info); 2844 return -ENOTSUP; 2845 } 2846 2847 int bdrv_snapshot_load_tmp(BlockDriverState *bs, 2848 const char *snapshot_name) 2849 { 2850 BlockDriver *drv = bs->drv; 2851 if (!drv) { 2852 return -ENOMEDIUM; 2853 } 2854 if (!bs->read_only) { 2855 return -EINVAL; 2856 } 2857 if (drv->bdrv_snapshot_load_tmp) { 2858 return drv->bdrv_snapshot_load_tmp(bs, snapshot_name); 2859 } 2860 return -ENOTSUP; 2861 } 2862 2863 BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, 2864 const char *backing_file) 2865 { 2866 if (!bs->drv) { 2867 return NULL; 2868 } 2869 2870 if (bs->backing_hd) { 2871 if (strcmp(bs->backing_file, backing_file) == 0) { 2872 return bs->backing_hd; 2873 } else { 2874 return bdrv_find_backing_image(bs->backing_hd, backing_file); 2875 } 2876 } 2877 2878 return NULL; 2879 } 2880 2881 #define NB_SUFFIXES 4 2882 2883 char *get_human_readable_size(char *buf, int buf_size, int64_t size) 2884 { 2885 static const char suffixes[NB_SUFFIXES] = "KMGT"; 2886 int64_t base; 2887 int i; 2888 2889 if (size <= 999) { 2890 snprintf(buf, buf_size, "%" PRId64, size); 2891 } else { 2892 base = 1024; 2893 for(i = 0; i < NB_SUFFIXES; i++) { 2894 if (size < (10 * base)) { 2895 snprintf(buf, buf_size, "%0.1f%c", 2896 (double)size / base, 2897 suffixes[i]); 2898 break; 2899 } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) { 2900 snprintf(buf, buf_size, "%" PRId64 "%c", 2901 ((size + (base >> 1)) / base), 2902 suffixes[i]); 2903 break; 2904 } 2905 base = base * 1024; 2906 } 2907 } 2908 return buf; 2909 } 2910 2911 char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn) 2912 { 2913 char buf1[128], date_buf[128], clock_buf[128]; 2914 #ifdef _WIN32 2915 struct tm *ptm; 2916 #else 2917 struct tm tm; 2918 #endif 2919 time_t ti; 2920 int64_t secs; 2921 2922 if (!sn) { 2923 snprintf(buf, buf_size, 2924 "%-10s%-20s%7s%20s%15s", 2925 "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK"); 2926 } else { 2927 ti = sn->date_sec; 2928 #ifdef _WIN32 2929 ptm = localtime(&ti); 2930 strftime(date_buf, sizeof(date_buf), 2931 "%Y-%m-%d %H:%M:%S", ptm); 2932 #else 2933 localtime_r(&ti, &tm); 2934 strftime(date_buf, sizeof(date_buf), 2935 "%Y-%m-%d %H:%M:%S", &tm); 2936 #endif 2937 secs = sn->vm_clock_nsec / 1000000000; 2938 snprintf(clock_buf, sizeof(clock_buf), 2939 "%02d:%02d:%02d.%03d", 2940 (int)(secs / 3600), 2941 (int)((secs / 60) % 60), 2942 (int)(secs % 60), 2943 (int)((sn->vm_clock_nsec / 1000000) % 1000)); 2944 snprintf(buf, buf_size, 2945 "%-10s%-20s%7s%20s%15s", 2946 sn->id_str, sn->name, 2947 get_human_readable_size(buf1, sizeof(buf1), sn->vm_state_size), 2948 date_buf, 2949 clock_buf); 2950 } 2951 return buf; 2952 } 2953 2954 /**************************************************************/ 2955 /* async I/Os */ 2956 2957 BlockDriverAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num, 2958 QEMUIOVector *qiov, int nb_sectors, 2959 BlockDriverCompletionFunc *cb, void *opaque) 2960 { 2961 trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque); 2962 2963 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 2964 cb, opaque, false); 2965 } 2966 2967 BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num, 2968 QEMUIOVector *qiov, int nb_sectors, 2969 BlockDriverCompletionFunc *cb, void *opaque) 2970 { 2971 trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque); 2972 2973 return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 2974 cb, opaque, true); 2975 } 2976 2977 2978 typedef struct MultiwriteCB { 2979 int error; 2980 int num_requests; 2981 int num_callbacks; 2982 struct { 2983 BlockDriverCompletionFunc *cb; 2984 void *opaque; 2985 QEMUIOVector *free_qiov; 2986 } callbacks[]; 2987 } MultiwriteCB; 2988 2989 static void multiwrite_user_cb(MultiwriteCB *mcb) 2990 { 2991 int i; 2992 2993 for (i = 0; i < mcb->num_callbacks; i++) { 2994 mcb->callbacks[i].cb(mcb->callbacks[i].opaque, mcb->error); 2995 if (mcb->callbacks[i].free_qiov) { 2996 qemu_iovec_destroy(mcb->callbacks[i].free_qiov); 2997 } 2998 g_free(mcb->callbacks[i].free_qiov); 2999 } 3000 } 3001 3002 static void multiwrite_cb(void *opaque, int ret) 3003 { 3004 MultiwriteCB *mcb = opaque; 3005 3006 trace_multiwrite_cb(mcb, ret); 3007 3008 if (ret < 0 && !mcb->error) { 3009 mcb->error = ret; 3010 } 3011 3012 mcb->num_requests--; 3013 if (mcb->num_requests == 0) { 3014 multiwrite_user_cb(mcb); 3015 g_free(mcb); 3016 } 3017 } 3018 3019 static int multiwrite_req_compare(const void *a, const void *b) 3020 { 3021 const BlockRequest *req1 = a, *req2 = b; 3022 3023 /* 3024 * Note that we can't simply subtract req2->sector from req1->sector 3025 * here as that could overflow the return value. 3026 */ 3027 if (req1->sector > req2->sector) { 3028 return 1; 3029 } else if (req1->sector < req2->sector) { 3030 return -1; 3031 } else { 3032 return 0; 3033 } 3034 } 3035 3036 /* 3037 * Takes a bunch of requests and tries to merge them. Returns the number of 3038 * requests that remain after merging. 3039 */ 3040 static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs, 3041 int num_reqs, MultiwriteCB *mcb) 3042 { 3043 int i, outidx; 3044 3045 // Sort requests by start sector 3046 qsort(reqs, num_reqs, sizeof(*reqs), &multiwrite_req_compare); 3047 3048 // Check if adjacent requests touch the same clusters. If so, combine them, 3049 // filling up gaps with zero sectors. 3050 outidx = 0; 3051 for (i = 1; i < num_reqs; i++) { 3052 int merge = 0; 3053 int64_t oldreq_last = reqs[outidx].sector + reqs[outidx].nb_sectors; 3054 3055 // Handle exactly sequential writes and overlapping writes. 3056 if (reqs[i].sector <= oldreq_last) { 3057 merge = 1; 3058 } 3059 3060 if (reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1 > IOV_MAX) { 3061 merge = 0; 3062 } 3063 3064 if (merge) { 3065 size_t size; 3066 QEMUIOVector *qiov = g_malloc0(sizeof(*qiov)); 3067 qemu_iovec_init(qiov, 3068 reqs[outidx].qiov->niov + reqs[i].qiov->niov + 1); 3069 3070 // Add the first request to the merged one. If the requests are 3071 // overlapping, drop the last sectors of the first request. 3072 size = (reqs[i].sector - reqs[outidx].sector) << 9; 3073 qemu_iovec_concat(qiov, reqs[outidx].qiov, size); 3074 3075 // We should need to add any zeros between the two requests 3076 assert (reqs[i].sector <= oldreq_last); 3077 3078 // Add the second request 3079 qemu_iovec_concat(qiov, reqs[i].qiov, reqs[i].qiov->size); 3080 3081 reqs[outidx].nb_sectors = qiov->size >> 9; 3082 reqs[outidx].qiov = qiov; 3083 3084 mcb->callbacks[i].free_qiov = reqs[outidx].qiov; 3085 } else { 3086 outidx++; 3087 reqs[outidx].sector = reqs[i].sector; 3088 reqs[outidx].nb_sectors = reqs[i].nb_sectors; 3089 reqs[outidx].qiov = reqs[i].qiov; 3090 } 3091 } 3092 3093 return outidx + 1; 3094 } 3095 3096 /* 3097 * Submit multiple AIO write requests at once. 3098 * 3099 * On success, the function returns 0 and all requests in the reqs array have 3100 * been submitted. In error case this function returns -1, and any of the 3101 * requests may or may not be submitted yet. In particular, this means that the 3102 * callback will be called for some of the requests, for others it won't. The 3103 * caller must check the error field of the BlockRequest to wait for the right 3104 * callbacks (if error != 0, no callback will be called). 3105 * 3106 * The implementation may modify the contents of the reqs array, e.g. to merge 3107 * requests. However, the fields opaque and error are left unmodified as they 3108 * are used to signal failure for a single request to the caller. 3109 */ 3110 int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs) 3111 { 3112 MultiwriteCB *mcb; 3113 int i; 3114 3115 /* don't submit writes if we don't have a medium */ 3116 if (bs->drv == NULL) { 3117 for (i = 0; i < num_reqs; i++) { 3118 reqs[i].error = -ENOMEDIUM; 3119 } 3120 return -1; 3121 } 3122 3123 if (num_reqs == 0) { 3124 return 0; 3125 } 3126 3127 // Create MultiwriteCB structure 3128 mcb = g_malloc0(sizeof(*mcb) + num_reqs * sizeof(*mcb->callbacks)); 3129 mcb->num_requests = 0; 3130 mcb->num_callbacks = num_reqs; 3131 3132 for (i = 0; i < num_reqs; i++) { 3133 mcb->callbacks[i].cb = reqs[i].cb; 3134 mcb->callbacks[i].opaque = reqs[i].opaque; 3135 } 3136 3137 // Check for mergable requests 3138 num_reqs = multiwrite_merge(bs, reqs, num_reqs, mcb); 3139 3140 trace_bdrv_aio_multiwrite(mcb, mcb->num_callbacks, num_reqs); 3141 3142 /* Run the aio requests. */ 3143 mcb->num_requests = num_reqs; 3144 for (i = 0; i < num_reqs; i++) { 3145 bdrv_aio_writev(bs, reqs[i].sector, reqs[i].qiov, 3146 reqs[i].nb_sectors, multiwrite_cb, mcb); 3147 } 3148 3149 return 0; 3150 } 3151 3152 void bdrv_aio_cancel(BlockDriverAIOCB *acb) 3153 { 3154 acb->pool->cancel(acb); 3155 } 3156 3157 /* block I/O throttling */ 3158 static bool bdrv_exceed_bps_limits(BlockDriverState *bs, int nb_sectors, 3159 bool is_write, double elapsed_time, uint64_t *wait) 3160 { 3161 uint64_t bps_limit = 0; 3162 double bytes_limit, bytes_base, bytes_res; 3163 double slice_time, wait_time; 3164 3165 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) { 3166 bps_limit = bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]; 3167 } else if (bs->io_limits.bps[is_write]) { 3168 bps_limit = bs->io_limits.bps[is_write]; 3169 } else { 3170 if (wait) { 3171 *wait = 0; 3172 } 3173 3174 return false; 3175 } 3176 3177 slice_time = bs->slice_end - bs->slice_start; 3178 slice_time /= (NANOSECONDS_PER_SECOND); 3179 bytes_limit = bps_limit * slice_time; 3180 bytes_base = bs->nr_bytes[is_write] - bs->io_base.bytes[is_write]; 3181 if (bs->io_limits.bps[BLOCK_IO_LIMIT_TOTAL]) { 3182 bytes_base += bs->nr_bytes[!is_write] - bs->io_base.bytes[!is_write]; 3183 } 3184 3185 /* bytes_base: the bytes of data which have been read/written; and 3186 * it is obtained from the history statistic info. 3187 * bytes_res: the remaining bytes of data which need to be read/written. 3188 * (bytes_base + bytes_res) / bps_limit: used to calcuate 3189 * the total time for completing reading/writting all data. 3190 */ 3191 bytes_res = (unsigned) nb_sectors * BDRV_SECTOR_SIZE; 3192 3193 if (bytes_base + bytes_res <= bytes_limit) { 3194 if (wait) { 3195 *wait = 0; 3196 } 3197 3198 return false; 3199 } 3200 3201 /* Calc approx time to dispatch */ 3202 wait_time = (bytes_base + bytes_res) / bps_limit - elapsed_time; 3203 3204 /* When the I/O rate at runtime exceeds the limits, 3205 * bs->slice_end need to be extended in order that the current statistic 3206 * info can be kept until the timer fire, so it is increased and tuned 3207 * based on the result of experiment. 3208 */ 3209 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10; 3210 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME; 3211 if (wait) { 3212 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10; 3213 } 3214 3215 return true; 3216 } 3217 3218 static bool bdrv_exceed_iops_limits(BlockDriverState *bs, bool is_write, 3219 double elapsed_time, uint64_t *wait) 3220 { 3221 uint64_t iops_limit = 0; 3222 double ios_limit, ios_base; 3223 double slice_time, wait_time; 3224 3225 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) { 3226 iops_limit = bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]; 3227 } else if (bs->io_limits.iops[is_write]) { 3228 iops_limit = bs->io_limits.iops[is_write]; 3229 } else { 3230 if (wait) { 3231 *wait = 0; 3232 } 3233 3234 return false; 3235 } 3236 3237 slice_time = bs->slice_end - bs->slice_start; 3238 slice_time /= (NANOSECONDS_PER_SECOND); 3239 ios_limit = iops_limit * slice_time; 3240 ios_base = bs->nr_ops[is_write] - bs->io_base.ios[is_write]; 3241 if (bs->io_limits.iops[BLOCK_IO_LIMIT_TOTAL]) { 3242 ios_base += bs->nr_ops[!is_write] - bs->io_base.ios[!is_write]; 3243 } 3244 3245 if (ios_base + 1 <= ios_limit) { 3246 if (wait) { 3247 *wait = 0; 3248 } 3249 3250 return false; 3251 } 3252 3253 /* Calc approx time to dispatch */ 3254 wait_time = (ios_base + 1) / iops_limit; 3255 if (wait_time > elapsed_time) { 3256 wait_time = wait_time - elapsed_time; 3257 } else { 3258 wait_time = 0; 3259 } 3260 3261 bs->slice_time = wait_time * BLOCK_IO_SLICE_TIME * 10; 3262 bs->slice_end += bs->slice_time - 3 * BLOCK_IO_SLICE_TIME; 3263 if (wait) { 3264 *wait = wait_time * BLOCK_IO_SLICE_TIME * 10; 3265 } 3266 3267 return true; 3268 } 3269 3270 static bool bdrv_exceed_io_limits(BlockDriverState *bs, int nb_sectors, 3271 bool is_write, int64_t *wait) 3272 { 3273 int64_t now, max_wait; 3274 uint64_t bps_wait = 0, iops_wait = 0; 3275 double elapsed_time; 3276 int bps_ret, iops_ret; 3277 3278 now = qemu_get_clock_ns(vm_clock); 3279 if ((bs->slice_start < now) 3280 && (bs->slice_end > now)) { 3281 bs->slice_end = now + bs->slice_time; 3282 } else { 3283 bs->slice_time = 5 * BLOCK_IO_SLICE_TIME; 3284 bs->slice_start = now; 3285 bs->slice_end = now + bs->slice_time; 3286 3287 bs->io_base.bytes[is_write] = bs->nr_bytes[is_write]; 3288 bs->io_base.bytes[!is_write] = bs->nr_bytes[!is_write]; 3289 3290 bs->io_base.ios[is_write] = bs->nr_ops[is_write]; 3291 bs->io_base.ios[!is_write] = bs->nr_ops[!is_write]; 3292 } 3293 3294 elapsed_time = now - bs->slice_start; 3295 elapsed_time /= (NANOSECONDS_PER_SECOND); 3296 3297 bps_ret = bdrv_exceed_bps_limits(bs, nb_sectors, 3298 is_write, elapsed_time, &bps_wait); 3299 iops_ret = bdrv_exceed_iops_limits(bs, is_write, 3300 elapsed_time, &iops_wait); 3301 if (bps_ret || iops_ret) { 3302 max_wait = bps_wait > iops_wait ? bps_wait : iops_wait; 3303 if (wait) { 3304 *wait = max_wait; 3305 } 3306 3307 now = qemu_get_clock_ns(vm_clock); 3308 if (bs->slice_end < now + max_wait) { 3309 bs->slice_end = now + max_wait; 3310 } 3311 3312 return true; 3313 } 3314 3315 if (wait) { 3316 *wait = 0; 3317 } 3318 3319 return false; 3320 } 3321 3322 /**************************************************************/ 3323 /* async block device emulation */ 3324 3325 typedef struct BlockDriverAIOCBSync { 3326 BlockDriverAIOCB common; 3327 QEMUBH *bh; 3328 int ret; 3329 /* vector translation state */ 3330 QEMUIOVector *qiov; 3331 uint8_t *bounce; 3332 int is_write; 3333 } BlockDriverAIOCBSync; 3334 3335 static void bdrv_aio_cancel_em(BlockDriverAIOCB *blockacb) 3336 { 3337 BlockDriverAIOCBSync *acb = 3338 container_of(blockacb, BlockDriverAIOCBSync, common); 3339 qemu_bh_delete(acb->bh); 3340 acb->bh = NULL; 3341 qemu_aio_release(acb); 3342 } 3343 3344 static AIOPool bdrv_em_aio_pool = { 3345 .aiocb_size = sizeof(BlockDriverAIOCBSync), 3346 .cancel = bdrv_aio_cancel_em, 3347 }; 3348 3349 static void bdrv_aio_bh_cb(void *opaque) 3350 { 3351 BlockDriverAIOCBSync *acb = opaque; 3352 3353 if (!acb->is_write) 3354 qemu_iovec_from_buffer(acb->qiov, acb->bounce, acb->qiov->size); 3355 qemu_vfree(acb->bounce); 3356 acb->common.cb(acb->common.opaque, acb->ret); 3357 qemu_bh_delete(acb->bh); 3358 acb->bh = NULL; 3359 qemu_aio_release(acb); 3360 } 3361 3362 static BlockDriverAIOCB *bdrv_aio_rw_vector(BlockDriverState *bs, 3363 int64_t sector_num, 3364 QEMUIOVector *qiov, 3365 int nb_sectors, 3366 BlockDriverCompletionFunc *cb, 3367 void *opaque, 3368 int is_write) 3369 3370 { 3371 BlockDriverAIOCBSync *acb; 3372 3373 acb = qemu_aio_get(&bdrv_em_aio_pool, bs, cb, opaque); 3374 acb->is_write = is_write; 3375 acb->qiov = qiov; 3376 acb->bounce = qemu_blockalign(bs, qiov->size); 3377 acb->bh = qemu_bh_new(bdrv_aio_bh_cb, acb); 3378 3379 if (is_write) { 3380 qemu_iovec_to_buffer(acb->qiov, acb->bounce); 3381 acb->ret = bs->drv->bdrv_write(bs, sector_num, acb->bounce, nb_sectors); 3382 } else { 3383 acb->ret = bs->drv->bdrv_read(bs, sector_num, acb->bounce, nb_sectors); 3384 } 3385 3386 qemu_bh_schedule(acb->bh); 3387 3388 return &acb->common; 3389 } 3390 3391 static BlockDriverAIOCB *bdrv_aio_readv_em(BlockDriverState *bs, 3392 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 3393 BlockDriverCompletionFunc *cb, void *opaque) 3394 { 3395 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 0); 3396 } 3397 3398 static BlockDriverAIOCB *bdrv_aio_writev_em(BlockDriverState *bs, 3399 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, 3400 BlockDriverCompletionFunc *cb, void *opaque) 3401 { 3402 return bdrv_aio_rw_vector(bs, sector_num, qiov, nb_sectors, cb, opaque, 1); 3403 } 3404 3405 3406 typedef struct BlockDriverAIOCBCoroutine { 3407 BlockDriverAIOCB common; 3408 BlockRequest req; 3409 bool is_write; 3410 QEMUBH* bh; 3411 } BlockDriverAIOCBCoroutine; 3412 3413 static void bdrv_aio_co_cancel_em(BlockDriverAIOCB *blockacb) 3414 { 3415 qemu_aio_flush(); 3416 } 3417 3418 static AIOPool bdrv_em_co_aio_pool = { 3419 .aiocb_size = sizeof(BlockDriverAIOCBCoroutine), 3420 .cancel = bdrv_aio_co_cancel_em, 3421 }; 3422 3423 static void bdrv_co_em_bh(void *opaque) 3424 { 3425 BlockDriverAIOCBCoroutine *acb = opaque; 3426 3427 acb->common.cb(acb->common.opaque, acb->req.error); 3428 qemu_bh_delete(acb->bh); 3429 qemu_aio_release(acb); 3430 } 3431 3432 /* Invoke bdrv_co_do_readv/bdrv_co_do_writev */ 3433 static void coroutine_fn bdrv_co_do_rw(void *opaque) 3434 { 3435 BlockDriverAIOCBCoroutine *acb = opaque; 3436 BlockDriverState *bs = acb->common.bs; 3437 3438 if (!acb->is_write) { 3439 acb->req.error = bdrv_co_do_readv(bs, acb->req.sector, 3440 acb->req.nb_sectors, acb->req.qiov, 0); 3441 } else { 3442 acb->req.error = bdrv_co_do_writev(bs, acb->req.sector, 3443 acb->req.nb_sectors, acb->req.qiov, 0); 3444 } 3445 3446 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb); 3447 qemu_bh_schedule(acb->bh); 3448 } 3449 3450 static BlockDriverAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs, 3451 int64_t sector_num, 3452 QEMUIOVector *qiov, 3453 int nb_sectors, 3454 BlockDriverCompletionFunc *cb, 3455 void *opaque, 3456 bool is_write) 3457 { 3458 Coroutine *co; 3459 BlockDriverAIOCBCoroutine *acb; 3460 3461 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque); 3462 acb->req.sector = sector_num; 3463 acb->req.nb_sectors = nb_sectors; 3464 acb->req.qiov = qiov; 3465 acb->is_write = is_write; 3466 3467 co = qemu_coroutine_create(bdrv_co_do_rw); 3468 qemu_coroutine_enter(co, acb); 3469 3470 return &acb->common; 3471 } 3472 3473 static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque) 3474 { 3475 BlockDriverAIOCBCoroutine *acb = opaque; 3476 BlockDriverState *bs = acb->common.bs; 3477 3478 acb->req.error = bdrv_co_flush(bs); 3479 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb); 3480 qemu_bh_schedule(acb->bh); 3481 } 3482 3483 BlockDriverAIOCB *bdrv_aio_flush(BlockDriverState *bs, 3484 BlockDriverCompletionFunc *cb, void *opaque) 3485 { 3486 trace_bdrv_aio_flush(bs, opaque); 3487 3488 Coroutine *co; 3489 BlockDriverAIOCBCoroutine *acb; 3490 3491 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque); 3492 co = qemu_coroutine_create(bdrv_aio_flush_co_entry); 3493 qemu_coroutine_enter(co, acb); 3494 3495 return &acb->common; 3496 } 3497 3498 static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque) 3499 { 3500 BlockDriverAIOCBCoroutine *acb = opaque; 3501 BlockDriverState *bs = acb->common.bs; 3502 3503 acb->req.error = bdrv_co_discard(bs, acb->req.sector, acb->req.nb_sectors); 3504 acb->bh = qemu_bh_new(bdrv_co_em_bh, acb); 3505 qemu_bh_schedule(acb->bh); 3506 } 3507 3508 BlockDriverAIOCB *bdrv_aio_discard(BlockDriverState *bs, 3509 int64_t sector_num, int nb_sectors, 3510 BlockDriverCompletionFunc *cb, void *opaque) 3511 { 3512 Coroutine *co; 3513 BlockDriverAIOCBCoroutine *acb; 3514 3515 trace_bdrv_aio_discard(bs, sector_num, nb_sectors, opaque); 3516 3517 acb = qemu_aio_get(&bdrv_em_co_aio_pool, bs, cb, opaque); 3518 acb->req.sector = sector_num; 3519 acb->req.nb_sectors = nb_sectors; 3520 co = qemu_coroutine_create(bdrv_aio_discard_co_entry); 3521 qemu_coroutine_enter(co, acb); 3522 3523 return &acb->common; 3524 } 3525 3526 void bdrv_init(void) 3527 { 3528 module_call_init(MODULE_INIT_BLOCK); 3529 } 3530 3531 void bdrv_init_with_whitelist(void) 3532 { 3533 use_bdrv_whitelist = 1; 3534 bdrv_init(); 3535 } 3536 3537 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs, 3538 BlockDriverCompletionFunc *cb, void *opaque) 3539 { 3540 BlockDriverAIOCB *acb; 3541 3542 if (pool->free_aiocb) { 3543 acb = pool->free_aiocb; 3544 pool->free_aiocb = acb->next; 3545 } else { 3546 acb = g_malloc0(pool->aiocb_size); 3547 acb->pool = pool; 3548 } 3549 acb->bs = bs; 3550 acb->cb = cb; 3551 acb->opaque = opaque; 3552 return acb; 3553 } 3554 3555 void qemu_aio_release(void *p) 3556 { 3557 BlockDriverAIOCB *acb = (BlockDriverAIOCB *)p; 3558 AIOPool *pool = acb->pool; 3559 acb->next = pool->free_aiocb; 3560 pool->free_aiocb = acb; 3561 } 3562 3563 /**************************************************************/ 3564 /* Coroutine block device emulation */ 3565 3566 typedef struct CoroutineIOCompletion { 3567 Coroutine *coroutine; 3568 int ret; 3569 } CoroutineIOCompletion; 3570 3571 static void bdrv_co_io_em_complete(void *opaque, int ret) 3572 { 3573 CoroutineIOCompletion *co = opaque; 3574 3575 co->ret = ret; 3576 qemu_coroutine_enter(co->coroutine, NULL); 3577 } 3578 3579 static int coroutine_fn bdrv_co_io_em(BlockDriverState *bs, int64_t sector_num, 3580 int nb_sectors, QEMUIOVector *iov, 3581 bool is_write) 3582 { 3583 CoroutineIOCompletion co = { 3584 .coroutine = qemu_coroutine_self(), 3585 }; 3586 BlockDriverAIOCB *acb; 3587 3588 if (is_write) { 3589 acb = bs->drv->bdrv_aio_writev(bs, sector_num, iov, nb_sectors, 3590 bdrv_co_io_em_complete, &co); 3591 } else { 3592 acb = bs->drv->bdrv_aio_readv(bs, sector_num, iov, nb_sectors, 3593 bdrv_co_io_em_complete, &co); 3594 } 3595 3596 trace_bdrv_co_io_em(bs, sector_num, nb_sectors, is_write, acb); 3597 if (!acb) { 3598 return -EIO; 3599 } 3600 qemu_coroutine_yield(); 3601 3602 return co.ret; 3603 } 3604 3605 static int coroutine_fn bdrv_co_readv_em(BlockDriverState *bs, 3606 int64_t sector_num, int nb_sectors, 3607 QEMUIOVector *iov) 3608 { 3609 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, false); 3610 } 3611 3612 static int coroutine_fn bdrv_co_writev_em(BlockDriverState *bs, 3613 int64_t sector_num, int nb_sectors, 3614 QEMUIOVector *iov) 3615 { 3616 return bdrv_co_io_em(bs, sector_num, nb_sectors, iov, true); 3617 } 3618 3619 static void coroutine_fn bdrv_flush_co_entry(void *opaque) 3620 { 3621 RwCo *rwco = opaque; 3622 3623 rwco->ret = bdrv_co_flush(rwco->bs); 3624 } 3625 3626 int coroutine_fn bdrv_co_flush(BlockDriverState *bs) 3627 { 3628 int ret; 3629 3630 if (!bs || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) { 3631 return 0; 3632 } 3633 3634 /* Write back cached data to the OS even with cache=unsafe */ 3635 if (bs->drv->bdrv_co_flush_to_os) { 3636 ret = bs->drv->bdrv_co_flush_to_os(bs); 3637 if (ret < 0) { 3638 return ret; 3639 } 3640 } 3641 3642 /* But don't actually force it to the disk with cache=unsafe */ 3643 if (bs->open_flags & BDRV_O_NO_FLUSH) { 3644 return 0; 3645 } 3646 3647 if (bs->drv->bdrv_co_flush_to_disk) { 3648 ret = bs->drv->bdrv_co_flush_to_disk(bs); 3649 } else if (bs->drv->bdrv_aio_flush) { 3650 BlockDriverAIOCB *acb; 3651 CoroutineIOCompletion co = { 3652 .coroutine = qemu_coroutine_self(), 3653 }; 3654 3655 acb = bs->drv->bdrv_aio_flush(bs, bdrv_co_io_em_complete, &co); 3656 if (acb == NULL) { 3657 ret = -EIO; 3658 } else { 3659 qemu_coroutine_yield(); 3660 ret = co.ret; 3661 } 3662 } else { 3663 /* 3664 * Some block drivers always operate in either writethrough or unsafe 3665 * mode and don't support bdrv_flush therefore. Usually qemu doesn't 3666 * know how the server works (because the behaviour is hardcoded or 3667 * depends on server-side configuration), so we can't ensure that 3668 * everything is safe on disk. Returning an error doesn't work because 3669 * that would break guests even if the server operates in writethrough 3670 * mode. 3671 * 3672 * Let's hope the user knows what he's doing. 3673 */ 3674 ret = 0; 3675 } 3676 if (ret < 0) { 3677 return ret; 3678 } 3679 3680 /* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH 3681 * in the case of cache=unsafe, so there are no useless flushes. 3682 */ 3683 return bdrv_co_flush(bs->file); 3684 } 3685 3686 void bdrv_invalidate_cache(BlockDriverState *bs) 3687 { 3688 if (bs->drv && bs->drv->bdrv_invalidate_cache) { 3689 bs->drv->bdrv_invalidate_cache(bs); 3690 } 3691 } 3692 3693 void bdrv_invalidate_cache_all(void) 3694 { 3695 BlockDriverState *bs; 3696 3697 QTAILQ_FOREACH(bs, &bdrv_states, list) { 3698 bdrv_invalidate_cache(bs); 3699 } 3700 } 3701 3702 void bdrv_clear_incoming_migration_all(void) 3703 { 3704 BlockDriverState *bs; 3705 3706 QTAILQ_FOREACH(bs, &bdrv_states, list) { 3707 bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING); 3708 } 3709 } 3710 3711 int bdrv_flush(BlockDriverState *bs) 3712 { 3713 Coroutine *co; 3714 RwCo rwco = { 3715 .bs = bs, 3716 .ret = NOT_DONE, 3717 }; 3718 3719 if (qemu_in_coroutine()) { 3720 /* Fast-path if already in coroutine context */ 3721 bdrv_flush_co_entry(&rwco); 3722 } else { 3723 co = qemu_coroutine_create(bdrv_flush_co_entry); 3724 qemu_coroutine_enter(co, &rwco); 3725 while (rwco.ret == NOT_DONE) { 3726 qemu_aio_wait(); 3727 } 3728 } 3729 3730 return rwco.ret; 3731 } 3732 3733 static void coroutine_fn bdrv_discard_co_entry(void *opaque) 3734 { 3735 RwCo *rwco = opaque; 3736 3737 rwco->ret = bdrv_co_discard(rwco->bs, rwco->sector_num, rwco->nb_sectors); 3738 } 3739 3740 int coroutine_fn bdrv_co_discard(BlockDriverState *bs, int64_t sector_num, 3741 int nb_sectors) 3742 { 3743 if (!bs->drv) { 3744 return -ENOMEDIUM; 3745 } else if (bdrv_check_request(bs, sector_num, nb_sectors)) { 3746 return -EIO; 3747 } else if (bs->read_only) { 3748 return -EROFS; 3749 } else if (bs->drv->bdrv_co_discard) { 3750 return bs->drv->bdrv_co_discard(bs, sector_num, nb_sectors); 3751 } else if (bs->drv->bdrv_aio_discard) { 3752 BlockDriverAIOCB *acb; 3753 CoroutineIOCompletion co = { 3754 .coroutine = qemu_coroutine_self(), 3755 }; 3756 3757 acb = bs->drv->bdrv_aio_discard(bs, sector_num, nb_sectors, 3758 bdrv_co_io_em_complete, &co); 3759 if (acb == NULL) { 3760 return -EIO; 3761 } else { 3762 qemu_coroutine_yield(); 3763 return co.ret; 3764 } 3765 } else { 3766 return 0; 3767 } 3768 } 3769 3770 int bdrv_discard(BlockDriverState *bs, int64_t sector_num, int nb_sectors) 3771 { 3772 Coroutine *co; 3773 RwCo rwco = { 3774 .bs = bs, 3775 .sector_num = sector_num, 3776 .nb_sectors = nb_sectors, 3777 .ret = NOT_DONE, 3778 }; 3779 3780 if (qemu_in_coroutine()) { 3781 /* Fast-path if already in coroutine context */ 3782 bdrv_discard_co_entry(&rwco); 3783 } else { 3784 co = qemu_coroutine_create(bdrv_discard_co_entry); 3785 qemu_coroutine_enter(co, &rwco); 3786 while (rwco.ret == NOT_DONE) { 3787 qemu_aio_wait(); 3788 } 3789 } 3790 3791 return rwco.ret; 3792 } 3793 3794 /**************************************************************/ 3795 /* removable device support */ 3796 3797 /** 3798 * Return TRUE if the media is present 3799 */ 3800 int bdrv_is_inserted(BlockDriverState *bs) 3801 { 3802 BlockDriver *drv = bs->drv; 3803 3804 if (!drv) 3805 return 0; 3806 if (!drv->bdrv_is_inserted) 3807 return 1; 3808 return drv->bdrv_is_inserted(bs); 3809 } 3810 3811 /** 3812 * Return whether the media changed since the last call to this 3813 * function, or -ENOTSUP if we don't know. Most drivers don't know. 3814 */ 3815 int bdrv_media_changed(BlockDriverState *bs) 3816 { 3817 BlockDriver *drv = bs->drv; 3818 3819 if (drv && drv->bdrv_media_changed) { 3820 return drv->bdrv_media_changed(bs); 3821 } 3822 return -ENOTSUP; 3823 } 3824 3825 /** 3826 * If eject_flag is TRUE, eject the media. Otherwise, close the tray 3827 */ 3828 void bdrv_eject(BlockDriverState *bs, bool eject_flag) 3829 { 3830 BlockDriver *drv = bs->drv; 3831 3832 if (drv && drv->bdrv_eject) { 3833 drv->bdrv_eject(bs, eject_flag); 3834 } 3835 3836 if (bs->device_name[0] != '\0') { 3837 bdrv_emit_qmp_eject_event(bs, eject_flag); 3838 } 3839 } 3840 3841 /** 3842 * Lock or unlock the media (if it is locked, the user won't be able 3843 * to eject it manually). 3844 */ 3845 void bdrv_lock_medium(BlockDriverState *bs, bool locked) 3846 { 3847 BlockDriver *drv = bs->drv; 3848 3849 trace_bdrv_lock_medium(bs, locked); 3850 3851 if (drv && drv->bdrv_lock_medium) { 3852 drv->bdrv_lock_medium(bs, locked); 3853 } 3854 } 3855 3856 /* needed for generic scsi interface */ 3857 3858 int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf) 3859 { 3860 BlockDriver *drv = bs->drv; 3861 3862 if (drv && drv->bdrv_ioctl) 3863 return drv->bdrv_ioctl(bs, req, buf); 3864 return -ENOTSUP; 3865 } 3866 3867 BlockDriverAIOCB *bdrv_aio_ioctl(BlockDriverState *bs, 3868 unsigned long int req, void *buf, 3869 BlockDriverCompletionFunc *cb, void *opaque) 3870 { 3871 BlockDriver *drv = bs->drv; 3872 3873 if (drv && drv->bdrv_aio_ioctl) 3874 return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque); 3875 return NULL; 3876 } 3877 3878 void bdrv_set_buffer_alignment(BlockDriverState *bs, int align) 3879 { 3880 bs->buffer_alignment = align; 3881 } 3882 3883 void *qemu_blockalign(BlockDriverState *bs, size_t size) 3884 { 3885 return qemu_memalign((bs && bs->buffer_alignment) ? bs->buffer_alignment : 512, size); 3886 } 3887 3888 void bdrv_set_dirty_tracking(BlockDriverState *bs, int enable) 3889 { 3890 int64_t bitmap_size; 3891 3892 bs->dirty_count = 0; 3893 if (enable) { 3894 if (!bs->dirty_bitmap) { 3895 bitmap_size = (bdrv_getlength(bs) >> BDRV_SECTOR_BITS) + 3896 BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1; 3897 bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8; 3898 3899 bs->dirty_bitmap = g_malloc0(bitmap_size); 3900 } 3901 } else { 3902 if (bs->dirty_bitmap) { 3903 g_free(bs->dirty_bitmap); 3904 bs->dirty_bitmap = NULL; 3905 } 3906 } 3907 } 3908 3909 int bdrv_get_dirty(BlockDriverState *bs, int64_t sector) 3910 { 3911 int64_t chunk = sector / (int64_t)BDRV_SECTORS_PER_DIRTY_CHUNK; 3912 3913 if (bs->dirty_bitmap && 3914 (sector << BDRV_SECTOR_BITS) < bdrv_getlength(bs)) { 3915 return !!(bs->dirty_bitmap[chunk / (sizeof(unsigned long) * 8)] & 3916 (1UL << (chunk % (sizeof(unsigned long) * 8)))); 3917 } else { 3918 return 0; 3919 } 3920 } 3921 3922 void bdrv_reset_dirty(BlockDriverState *bs, int64_t cur_sector, 3923 int nr_sectors) 3924 { 3925 set_dirty_bitmap(bs, cur_sector, nr_sectors, 0); 3926 } 3927 3928 int64_t bdrv_get_dirty_count(BlockDriverState *bs) 3929 { 3930 return bs->dirty_count; 3931 } 3932 3933 void bdrv_set_in_use(BlockDriverState *bs, int in_use) 3934 { 3935 assert(bs->in_use != in_use); 3936 bs->in_use = in_use; 3937 } 3938 3939 int bdrv_in_use(BlockDriverState *bs) 3940 { 3941 return bs->in_use; 3942 } 3943 3944 void bdrv_iostatus_enable(BlockDriverState *bs) 3945 { 3946 bs->iostatus_enabled = true; 3947 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK; 3948 } 3949 3950 /* The I/O status is only enabled if the drive explicitly 3951 * enables it _and_ the VM is configured to stop on errors */ 3952 bool bdrv_iostatus_is_enabled(const BlockDriverState *bs) 3953 { 3954 return (bs->iostatus_enabled && 3955 (bs->on_write_error == BLOCK_ERR_STOP_ENOSPC || 3956 bs->on_write_error == BLOCK_ERR_STOP_ANY || 3957 bs->on_read_error == BLOCK_ERR_STOP_ANY)); 3958 } 3959 3960 void bdrv_iostatus_disable(BlockDriverState *bs) 3961 { 3962 bs->iostatus_enabled = false; 3963 } 3964 3965 void bdrv_iostatus_reset(BlockDriverState *bs) 3966 { 3967 if (bdrv_iostatus_is_enabled(bs)) { 3968 bs->iostatus = BLOCK_DEVICE_IO_STATUS_OK; 3969 } 3970 } 3971 3972 /* XXX: Today this is set by device models because it makes the implementation 3973 quite simple. However, the block layer knows about the error, so it's 3974 possible to implement this without device models being involved */ 3975 void bdrv_iostatus_set_err(BlockDriverState *bs, int error) 3976 { 3977 if (bdrv_iostatus_is_enabled(bs) && 3978 bs->iostatus == BLOCK_DEVICE_IO_STATUS_OK) { 3979 assert(error >= 0); 3980 bs->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE : 3981 BLOCK_DEVICE_IO_STATUS_FAILED; 3982 } 3983 } 3984 3985 void 3986 bdrv_acct_start(BlockDriverState *bs, BlockAcctCookie *cookie, int64_t bytes, 3987 enum BlockAcctType type) 3988 { 3989 assert(type < BDRV_MAX_IOTYPE); 3990 3991 cookie->bytes = bytes; 3992 cookie->start_time_ns = get_clock(); 3993 cookie->type = type; 3994 } 3995 3996 void 3997 bdrv_acct_done(BlockDriverState *bs, BlockAcctCookie *cookie) 3998 { 3999 assert(cookie->type < BDRV_MAX_IOTYPE); 4000 4001 bs->nr_bytes[cookie->type] += cookie->bytes; 4002 bs->nr_ops[cookie->type]++; 4003 bs->total_time_ns[cookie->type] += get_clock() - cookie->start_time_ns; 4004 } 4005 4006 int bdrv_img_create(const char *filename, const char *fmt, 4007 const char *base_filename, const char *base_fmt, 4008 char *options, uint64_t img_size, int flags) 4009 { 4010 QEMUOptionParameter *param = NULL, *create_options = NULL; 4011 QEMUOptionParameter *backing_fmt, *backing_file, *size; 4012 BlockDriverState *bs = NULL; 4013 BlockDriver *drv, *proto_drv; 4014 BlockDriver *backing_drv = NULL; 4015 int ret = 0; 4016 4017 /* Find driver and parse its options */ 4018 drv = bdrv_find_format(fmt); 4019 if (!drv) { 4020 error_report("Unknown file format '%s'", fmt); 4021 ret = -EINVAL; 4022 goto out; 4023 } 4024 4025 proto_drv = bdrv_find_protocol(filename); 4026 if (!proto_drv) { 4027 error_report("Unknown protocol '%s'", filename); 4028 ret = -EINVAL; 4029 goto out; 4030 } 4031 4032 create_options = append_option_parameters(create_options, 4033 drv->create_options); 4034 create_options = append_option_parameters(create_options, 4035 proto_drv->create_options); 4036 4037 /* Create parameter list with default values */ 4038 param = parse_option_parameters("", create_options, param); 4039 4040 set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size); 4041 4042 /* Parse -o options */ 4043 if (options) { 4044 param = parse_option_parameters(options, create_options, param); 4045 if (param == NULL) { 4046 error_report("Invalid options for file format '%s'.", fmt); 4047 ret = -EINVAL; 4048 goto out; 4049 } 4050 } 4051 4052 if (base_filename) { 4053 if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE, 4054 base_filename)) { 4055 error_report("Backing file not supported for file format '%s'", 4056 fmt); 4057 ret = -EINVAL; 4058 goto out; 4059 } 4060 } 4061 4062 if (base_fmt) { 4063 if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) { 4064 error_report("Backing file format not supported for file " 4065 "format '%s'", fmt); 4066 ret = -EINVAL; 4067 goto out; 4068 } 4069 } 4070 4071 backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE); 4072 if (backing_file && backing_file->value.s) { 4073 if (!strcmp(filename, backing_file->value.s)) { 4074 error_report("Error: Trying to create an image with the " 4075 "same filename as the backing file"); 4076 ret = -EINVAL; 4077 goto out; 4078 } 4079 } 4080 4081 backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT); 4082 if (backing_fmt && backing_fmt->value.s) { 4083 backing_drv = bdrv_find_format(backing_fmt->value.s); 4084 if (!backing_drv) { 4085 error_report("Unknown backing file format '%s'", 4086 backing_fmt->value.s); 4087 ret = -EINVAL; 4088 goto out; 4089 } 4090 } 4091 4092 // The size for the image must always be specified, with one exception: 4093 // If we are using a backing file, we can obtain the size from there 4094 size = get_option_parameter(param, BLOCK_OPT_SIZE); 4095 if (size && size->value.n == -1) { 4096 if (backing_file && backing_file->value.s) { 4097 uint64_t size; 4098 char buf[32]; 4099 4100 bs = bdrv_new(""); 4101 4102 ret = bdrv_open(bs, backing_file->value.s, flags, backing_drv); 4103 if (ret < 0) { 4104 error_report("Could not open '%s'", backing_file->value.s); 4105 goto out; 4106 } 4107 bdrv_get_geometry(bs, &size); 4108 size *= 512; 4109 4110 snprintf(buf, sizeof(buf), "%" PRId64, size); 4111 set_option_parameter(param, BLOCK_OPT_SIZE, buf); 4112 } else { 4113 error_report("Image creation needs a size parameter"); 4114 ret = -EINVAL; 4115 goto out; 4116 } 4117 } 4118 4119 printf("Formatting '%s', fmt=%s ", filename, fmt); 4120 print_option_parameters(param); 4121 puts(""); 4122 4123 ret = bdrv_create(drv, filename, param); 4124 4125 if (ret < 0) { 4126 if (ret == -ENOTSUP) { 4127 error_report("Formatting or formatting option not supported for " 4128 "file format '%s'", fmt); 4129 } else if (ret == -EFBIG) { 4130 error_report("The image size is too large for file format '%s'", 4131 fmt); 4132 } else { 4133 error_report("%s: error while creating %s: %s", filename, fmt, 4134 strerror(-ret)); 4135 } 4136 } 4137 4138 out: 4139 free_option_parameters(create_options); 4140 free_option_parameters(param); 4141 4142 if (bs) { 4143 bdrv_delete(bs); 4144 } 4145 4146 return ret; 4147 } 4148 4149 void *block_job_create(const BlockJobType *job_type, BlockDriverState *bs, 4150 int64_t speed, BlockDriverCompletionFunc *cb, 4151 void *opaque, Error **errp) 4152 { 4153 BlockJob *job; 4154 4155 if (bs->job || bdrv_in_use(bs)) { 4156 error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs)); 4157 return NULL; 4158 } 4159 bdrv_set_in_use(bs, 1); 4160 4161 job = g_malloc0(job_type->instance_size); 4162 job->job_type = job_type; 4163 job->bs = bs; 4164 job->cb = cb; 4165 job->opaque = opaque; 4166 bs->job = job; 4167 4168 /* Only set speed when necessary to avoid NotSupported error */ 4169 if (speed != 0) { 4170 Error *local_err = NULL; 4171 4172 block_job_set_speed(job, speed, &local_err); 4173 if (error_is_set(&local_err)) { 4174 bs->job = NULL; 4175 g_free(job); 4176 bdrv_set_in_use(bs, 0); 4177 error_propagate(errp, local_err); 4178 return NULL; 4179 } 4180 } 4181 return job; 4182 } 4183 4184 void block_job_complete(BlockJob *job, int ret) 4185 { 4186 BlockDriverState *bs = job->bs; 4187 4188 assert(bs->job == job); 4189 job->cb(job->opaque, ret); 4190 bs->job = NULL; 4191 g_free(job); 4192 bdrv_set_in_use(bs, 0); 4193 } 4194 4195 void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp) 4196 { 4197 Error *local_err = NULL; 4198 4199 if (!job->job_type->set_speed) { 4200 error_set(errp, QERR_NOT_SUPPORTED); 4201 return; 4202 } 4203 job->job_type->set_speed(job, speed, &local_err); 4204 if (error_is_set(&local_err)) { 4205 error_propagate(errp, local_err); 4206 return; 4207 } 4208 4209 job->speed = speed; 4210 } 4211 4212 void block_job_cancel(BlockJob *job) 4213 { 4214 job->cancelled = true; 4215 } 4216 4217 bool block_job_is_cancelled(BlockJob *job) 4218 { 4219 return job->cancelled; 4220 } 4221 4222 void block_job_cancel_sync(BlockJob *job) 4223 { 4224 BlockDriverState *bs = job->bs; 4225 4226 assert(bs->job == job); 4227 block_job_cancel(job); 4228 while (bs->job != NULL && bs->job->busy) { 4229 qemu_aio_wait(); 4230 } 4231 } 4232