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