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