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