1 /* 2 * Block driver for RAW files (posix) 3 * 4 * Copyright (c) 2006 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 25 #include "qemu/osdep.h" 26 #include "qapi/error.h" 27 #include "qemu/cutils.h" 28 #include "qemu/error-report.h" 29 #include "block/block_int.h" 30 #include "qemu/module.h" 31 #include "qemu/option.h" 32 #include "trace.h" 33 #include "block/thread-pool.h" 34 #include "qemu/iov.h" 35 #include "block/raw-aio.h" 36 #include "qapi/qmp/qdict.h" 37 #include "qapi/qmp/qstring.h" 38 39 #include "scsi/pr-manager.h" 40 #include "scsi/constants.h" 41 42 #if defined(__APPLE__) && (__MACH__) 43 #include <paths.h> 44 #include <sys/param.h> 45 #include <IOKit/IOKitLib.h> 46 #include <IOKit/IOBSD.h> 47 #include <IOKit/storage/IOMediaBSDClient.h> 48 #include <IOKit/storage/IOMedia.h> 49 #include <IOKit/storage/IOCDMedia.h> 50 //#include <IOKit/storage/IOCDTypes.h> 51 #include <IOKit/storage/IODVDMedia.h> 52 #include <CoreFoundation/CoreFoundation.h> 53 #endif 54 55 #ifdef __sun__ 56 #define _POSIX_PTHREAD_SEMANTICS 1 57 #include <sys/dkio.h> 58 #endif 59 #ifdef __linux__ 60 #include <sys/ioctl.h> 61 #include <sys/param.h> 62 #include <sys/syscall.h> 63 #include <linux/cdrom.h> 64 #include <linux/fd.h> 65 #include <linux/fs.h> 66 #include <linux/hdreg.h> 67 #include <scsi/sg.h> 68 #ifdef __s390__ 69 #include <asm/dasd.h> 70 #endif 71 #ifndef FS_NOCOW_FL 72 #define FS_NOCOW_FL 0x00800000 /* Do not cow file */ 73 #endif 74 #endif 75 #if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE) 76 #include <linux/falloc.h> 77 #endif 78 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) 79 #include <sys/disk.h> 80 #include <sys/cdio.h> 81 #endif 82 83 #ifdef __OpenBSD__ 84 #include <sys/ioctl.h> 85 #include <sys/disklabel.h> 86 #include <sys/dkio.h> 87 #endif 88 89 #ifdef __NetBSD__ 90 #include <sys/ioctl.h> 91 #include <sys/disklabel.h> 92 #include <sys/dkio.h> 93 #include <sys/disk.h> 94 #endif 95 96 #ifdef __DragonFly__ 97 #include <sys/ioctl.h> 98 #include <sys/diskslice.h> 99 #endif 100 101 #ifdef CONFIG_XFS 102 #include <xfs/xfs.h> 103 #endif 104 105 //#define DEBUG_BLOCK 106 107 #ifdef DEBUG_BLOCK 108 # define DEBUG_BLOCK_PRINT 1 109 #else 110 # define DEBUG_BLOCK_PRINT 0 111 #endif 112 #define DPRINTF(fmt, ...) \ 113 do { \ 114 if (DEBUG_BLOCK_PRINT) { \ 115 printf(fmt, ## __VA_ARGS__); \ 116 } \ 117 } while (0) 118 119 /* OS X does not have O_DSYNC */ 120 #ifndef O_DSYNC 121 #ifdef O_SYNC 122 #define O_DSYNC O_SYNC 123 #elif defined(O_FSYNC) 124 #define O_DSYNC O_FSYNC 125 #endif 126 #endif 127 128 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */ 129 #ifndef O_DIRECT 130 #define O_DIRECT O_DSYNC 131 #endif 132 133 #define FTYPE_FILE 0 134 #define FTYPE_CD 1 135 136 #define MAX_BLOCKSIZE 4096 137 138 /* Posix file locking bytes. Libvirt takes byte 0, we start from higher bytes, 139 * leaving a few more bytes for its future use. */ 140 #define RAW_LOCK_PERM_BASE 100 141 #define RAW_LOCK_SHARED_BASE 200 142 143 typedef struct BDRVRawState { 144 int fd; 145 int lock_fd; 146 bool use_lock; 147 int type; 148 int open_flags; 149 size_t buf_align; 150 151 /* The current permissions. */ 152 uint64_t perm; 153 uint64_t shared_perm; 154 155 #ifdef CONFIG_XFS 156 bool is_xfs:1; 157 #endif 158 bool has_discard:1; 159 bool has_write_zeroes:1; 160 bool discard_zeroes:1; 161 bool use_linux_aio:1; 162 bool page_cache_inconsistent:1; 163 bool has_fallocate; 164 bool needs_alignment; 165 bool check_cache_dropped; 166 167 PRManager *pr_mgr; 168 } BDRVRawState; 169 170 typedef struct BDRVRawReopenState { 171 int fd; 172 int open_flags; 173 bool check_cache_dropped; 174 } BDRVRawReopenState; 175 176 static int fd_open(BlockDriverState *bs); 177 static int64_t raw_getlength(BlockDriverState *bs); 178 179 typedef struct RawPosixAIOData { 180 BlockDriverState *bs; 181 int aio_fildes; 182 union { 183 struct iovec *aio_iov; 184 void *aio_ioctl_buf; 185 }; 186 int aio_niov; 187 uint64_t aio_nbytes; 188 #define aio_ioctl_cmd aio_nbytes /* for QEMU_AIO_IOCTL */ 189 off_t aio_offset; 190 int aio_type; 191 union { 192 struct { 193 int aio_fd2; 194 off_t aio_offset2; 195 }; 196 struct { 197 PreallocMode prealloc; 198 Error **errp; 199 }; 200 }; 201 } RawPosixAIOData; 202 203 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 204 static int cdrom_reopen(BlockDriverState *bs); 205 #endif 206 207 #if defined(__NetBSD__) 208 static int raw_normalize_devicepath(const char **filename) 209 { 210 static char namebuf[PATH_MAX]; 211 const char *dp, *fname; 212 struct stat sb; 213 214 fname = *filename; 215 dp = strrchr(fname, '/'); 216 if (lstat(fname, &sb) < 0) { 217 fprintf(stderr, "%s: stat failed: %s\n", 218 fname, strerror(errno)); 219 return -errno; 220 } 221 222 if (!S_ISBLK(sb.st_mode)) { 223 return 0; 224 } 225 226 if (dp == NULL) { 227 snprintf(namebuf, PATH_MAX, "r%s", fname); 228 } else { 229 snprintf(namebuf, PATH_MAX, "%.*s/r%s", 230 (int)(dp - fname), fname, dp + 1); 231 } 232 fprintf(stderr, "%s is a block device", fname); 233 *filename = namebuf; 234 fprintf(stderr, ", using %s\n", *filename); 235 236 return 0; 237 } 238 #else 239 static int raw_normalize_devicepath(const char **filename) 240 { 241 return 0; 242 } 243 #endif 244 245 /* 246 * Get logical block size via ioctl. On success store it in @sector_size_p. 247 */ 248 static int probe_logical_blocksize(int fd, unsigned int *sector_size_p) 249 { 250 unsigned int sector_size; 251 bool success = false; 252 int i; 253 254 errno = ENOTSUP; 255 static const unsigned long ioctl_list[] = { 256 #ifdef BLKSSZGET 257 BLKSSZGET, 258 #endif 259 #ifdef DKIOCGETBLOCKSIZE 260 DKIOCGETBLOCKSIZE, 261 #endif 262 #ifdef DIOCGSECTORSIZE 263 DIOCGSECTORSIZE, 264 #endif 265 }; 266 267 /* Try a few ioctls to get the right size */ 268 for (i = 0; i < (int)ARRAY_SIZE(ioctl_list); i++) { 269 if (ioctl(fd, ioctl_list[i], §or_size) >= 0) { 270 *sector_size_p = sector_size; 271 success = true; 272 } 273 } 274 275 return success ? 0 : -errno; 276 } 277 278 /** 279 * Get physical block size of @fd. 280 * On success, store it in @blk_size and return 0. 281 * On failure, return -errno. 282 */ 283 static int probe_physical_blocksize(int fd, unsigned int *blk_size) 284 { 285 #ifdef BLKPBSZGET 286 if (ioctl(fd, BLKPBSZGET, blk_size) < 0) { 287 return -errno; 288 } 289 return 0; 290 #else 291 return -ENOTSUP; 292 #endif 293 } 294 295 /* Check if read is allowed with given memory buffer and length. 296 * 297 * This function is used to check O_DIRECT memory buffer and request alignment. 298 */ 299 static bool raw_is_io_aligned(int fd, void *buf, size_t len) 300 { 301 ssize_t ret = pread(fd, buf, len, 0); 302 303 if (ret >= 0) { 304 return true; 305 } 306 307 #ifdef __linux__ 308 /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads. Ignore 309 * other errors (e.g. real I/O error), which could happen on a failed 310 * drive, since we only care about probing alignment. 311 */ 312 if (errno != EINVAL) { 313 return true; 314 } 315 #endif 316 317 return false; 318 } 319 320 static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp) 321 { 322 BDRVRawState *s = bs->opaque; 323 char *buf; 324 size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize()); 325 326 /* For SCSI generic devices the alignment is not really used. 327 With buffered I/O, we don't have any restrictions. */ 328 if (bdrv_is_sg(bs) || !s->needs_alignment) { 329 bs->bl.request_alignment = 1; 330 s->buf_align = 1; 331 return; 332 } 333 334 bs->bl.request_alignment = 0; 335 s->buf_align = 0; 336 /* Let's try to use the logical blocksize for the alignment. */ 337 if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) { 338 bs->bl.request_alignment = 0; 339 } 340 #ifdef CONFIG_XFS 341 if (s->is_xfs) { 342 struct dioattr da; 343 if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) { 344 bs->bl.request_alignment = da.d_miniosz; 345 /* The kernel returns wrong information for d_mem */ 346 /* s->buf_align = da.d_mem; */ 347 } 348 } 349 #endif 350 351 /* If we could not get the sizes so far, we can only guess them */ 352 if (!s->buf_align) { 353 size_t align; 354 buf = qemu_memalign(max_align, 2 * max_align); 355 for (align = 512; align <= max_align; align <<= 1) { 356 if (raw_is_io_aligned(fd, buf + align, max_align)) { 357 s->buf_align = align; 358 break; 359 } 360 } 361 qemu_vfree(buf); 362 } 363 364 if (!bs->bl.request_alignment) { 365 size_t align; 366 buf = qemu_memalign(s->buf_align, max_align); 367 for (align = 512; align <= max_align; align <<= 1) { 368 if (raw_is_io_aligned(fd, buf, align)) { 369 bs->bl.request_alignment = align; 370 break; 371 } 372 } 373 qemu_vfree(buf); 374 } 375 376 if (!s->buf_align || !bs->bl.request_alignment) { 377 error_setg(errp, "Could not find working O_DIRECT alignment"); 378 error_append_hint(errp, "Try cache.direct=off\n"); 379 } 380 } 381 382 static void raw_parse_flags(int bdrv_flags, int *open_flags) 383 { 384 assert(open_flags != NULL); 385 386 *open_flags |= O_BINARY; 387 *open_flags &= ~O_ACCMODE; 388 if (bdrv_flags & BDRV_O_RDWR) { 389 *open_flags |= O_RDWR; 390 } else { 391 *open_flags |= O_RDONLY; 392 } 393 394 /* Use O_DSYNC for write-through caching, no flags for write-back caching, 395 * and O_DIRECT for no caching. */ 396 if ((bdrv_flags & BDRV_O_NOCACHE)) { 397 *open_flags |= O_DIRECT; 398 } 399 } 400 401 static void raw_parse_filename(const char *filename, QDict *options, 402 Error **errp) 403 { 404 bdrv_parse_filename_strip_prefix(filename, "file:", options); 405 } 406 407 static QemuOptsList raw_runtime_opts = { 408 .name = "raw", 409 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head), 410 .desc = { 411 { 412 .name = "filename", 413 .type = QEMU_OPT_STRING, 414 .help = "File name of the image", 415 }, 416 { 417 .name = "aio", 418 .type = QEMU_OPT_STRING, 419 .help = "host AIO implementation (threads, native)", 420 }, 421 { 422 .name = "locking", 423 .type = QEMU_OPT_STRING, 424 .help = "file locking mode (on/off/auto, default: auto)", 425 }, 426 { 427 .name = "pr-manager", 428 .type = QEMU_OPT_STRING, 429 .help = "id of persistent reservation manager object (default: none)", 430 }, 431 { 432 .name = "x-check-cache-dropped", 433 .type = QEMU_OPT_BOOL, 434 .help = "check that page cache was dropped on live migration (default: off)" 435 }, 436 { /* end of list */ } 437 }, 438 }; 439 440 static int raw_open_common(BlockDriverState *bs, QDict *options, 441 int bdrv_flags, int open_flags, 442 bool device, Error **errp) 443 { 444 BDRVRawState *s = bs->opaque; 445 QemuOpts *opts; 446 Error *local_err = NULL; 447 const char *filename = NULL; 448 const char *str; 449 BlockdevAioOptions aio, aio_default; 450 int fd, ret; 451 struct stat st; 452 OnOffAuto locking; 453 454 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort); 455 qemu_opts_absorb_qdict(opts, options, &local_err); 456 if (local_err) { 457 error_propagate(errp, local_err); 458 ret = -EINVAL; 459 goto fail; 460 } 461 462 filename = qemu_opt_get(opts, "filename"); 463 464 ret = raw_normalize_devicepath(&filename); 465 if (ret != 0) { 466 error_setg_errno(errp, -ret, "Could not normalize device path"); 467 goto fail; 468 } 469 470 aio_default = (bdrv_flags & BDRV_O_NATIVE_AIO) 471 ? BLOCKDEV_AIO_OPTIONS_NATIVE 472 : BLOCKDEV_AIO_OPTIONS_THREADS; 473 aio = qapi_enum_parse(&BlockdevAioOptions_lookup, 474 qemu_opt_get(opts, "aio"), 475 aio_default, &local_err); 476 if (local_err) { 477 error_propagate(errp, local_err); 478 ret = -EINVAL; 479 goto fail; 480 } 481 s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE); 482 483 locking = qapi_enum_parse(&OnOffAuto_lookup, 484 qemu_opt_get(opts, "locking"), 485 ON_OFF_AUTO_AUTO, &local_err); 486 if (local_err) { 487 error_propagate(errp, local_err); 488 ret = -EINVAL; 489 goto fail; 490 } 491 switch (locking) { 492 case ON_OFF_AUTO_ON: 493 s->use_lock = true; 494 if (!qemu_has_ofd_lock()) { 495 fprintf(stderr, 496 "File lock requested but OFD locking syscall is " 497 "unavailable, falling back to POSIX file locks.\n" 498 "Due to the implementation, locks can be lost " 499 "unexpectedly.\n"); 500 } 501 break; 502 case ON_OFF_AUTO_OFF: 503 s->use_lock = false; 504 break; 505 case ON_OFF_AUTO_AUTO: 506 s->use_lock = qemu_has_ofd_lock(); 507 break; 508 default: 509 abort(); 510 } 511 512 str = qemu_opt_get(opts, "pr-manager"); 513 if (str) { 514 s->pr_mgr = pr_manager_lookup(str, &local_err); 515 if (local_err) { 516 error_propagate(errp, local_err); 517 ret = -EINVAL; 518 goto fail; 519 } 520 } 521 522 s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped", 523 false); 524 525 s->open_flags = open_flags; 526 raw_parse_flags(bdrv_flags, &s->open_flags); 527 528 s->fd = -1; 529 fd = qemu_open(filename, s->open_flags, 0644); 530 ret = fd < 0 ? -errno : 0; 531 532 if (ret == -EACCES || ret == -EROFS) { 533 /* Try to degrade to read-only, but if it doesn't work, still use the 534 * normal error message. */ 535 if (bdrv_apply_auto_read_only(bs, NULL, NULL) == 0) { 536 bdrv_flags &= ~BDRV_O_RDWR; 537 raw_parse_flags(bdrv_flags, &s->open_flags); 538 assert(!(s->open_flags & O_CREAT)); 539 fd = qemu_open(filename, s->open_flags); 540 ret = fd < 0 ? -errno : 0; 541 } 542 } 543 544 if (ret < 0) { 545 error_setg_errno(errp, -ret, "Could not open '%s'", filename); 546 if (ret == -EROFS) { 547 ret = -EACCES; 548 } 549 goto fail; 550 } 551 s->fd = fd; 552 553 s->lock_fd = -1; 554 if (s->use_lock) { 555 fd = qemu_open(filename, s->open_flags); 556 if (fd < 0) { 557 ret = -errno; 558 error_setg_errno(errp, errno, "Could not open '%s' for locking", 559 filename); 560 qemu_close(s->fd); 561 goto fail; 562 } 563 s->lock_fd = fd; 564 } 565 s->perm = 0; 566 s->shared_perm = BLK_PERM_ALL; 567 568 #ifdef CONFIG_LINUX_AIO 569 /* Currently Linux does AIO only for files opened with O_DIRECT */ 570 if (s->use_linux_aio) { 571 if (!(s->open_flags & O_DIRECT)) { 572 error_setg(errp, "aio=native was specified, but it requires " 573 "cache.direct=on, which was not specified."); 574 ret = -EINVAL; 575 goto fail; 576 } 577 if (!aio_setup_linux_aio(bdrv_get_aio_context(bs), errp)) { 578 error_prepend(errp, "Unable to use native AIO: "); 579 goto fail; 580 } 581 } 582 #else 583 if (s->use_linux_aio) { 584 error_setg(errp, "aio=native was specified, but is not supported " 585 "in this build."); 586 ret = -EINVAL; 587 goto fail; 588 } 589 #endif /* !defined(CONFIG_LINUX_AIO) */ 590 591 s->has_discard = true; 592 s->has_write_zeroes = true; 593 if ((bs->open_flags & BDRV_O_NOCACHE) != 0) { 594 s->needs_alignment = true; 595 } 596 597 if (fstat(s->fd, &st) < 0) { 598 ret = -errno; 599 error_setg_errno(errp, errno, "Could not stat file"); 600 goto fail; 601 } 602 603 if (!device) { 604 if (S_ISBLK(st.st_mode)) { 605 warn_report("Opening a block device as a file using the '%s' " 606 "driver is deprecated", bs->drv->format_name); 607 } else if (S_ISCHR(st.st_mode)) { 608 warn_report("Opening a character device as a file using the '%s' " 609 "driver is deprecated", bs->drv->format_name); 610 } else if (!S_ISREG(st.st_mode)) { 611 error_setg(errp, "A regular file was expected by the '%s' driver, " 612 "but something else was given", bs->drv->format_name); 613 ret = -EINVAL; 614 goto fail; 615 } else { 616 s->discard_zeroes = true; 617 s->has_fallocate = true; 618 } 619 } else { 620 if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) { 621 error_setg(errp, "'%s' driver expects either " 622 "a character or block device", bs->drv->format_name); 623 ret = -EINVAL; 624 goto fail; 625 } 626 } 627 628 if (S_ISBLK(st.st_mode)) { 629 #ifdef BLKDISCARDZEROES 630 unsigned int arg; 631 if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) { 632 s->discard_zeroes = true; 633 } 634 #endif 635 #ifdef __linux__ 636 /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache. Do 637 * not rely on the contents of discarded blocks unless using O_DIRECT. 638 * Same for BLKZEROOUT. 639 */ 640 if (!(bs->open_flags & BDRV_O_NOCACHE)) { 641 s->discard_zeroes = false; 642 s->has_write_zeroes = false; 643 } 644 #endif 645 } 646 #ifdef __FreeBSD__ 647 if (S_ISCHR(st.st_mode)) { 648 /* 649 * The file is a char device (disk), which on FreeBSD isn't behind 650 * a pager, so force all requests to be aligned. This is needed 651 * so QEMU makes sure all IO operations on the device are aligned 652 * to sector size, or else FreeBSD will reject them with EINVAL. 653 */ 654 s->needs_alignment = true; 655 } 656 #endif 657 658 #ifdef CONFIG_XFS 659 if (platform_test_xfs_fd(s->fd)) { 660 s->is_xfs = true; 661 } 662 #endif 663 664 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP; 665 ret = 0; 666 fail: 667 if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) { 668 unlink(filename); 669 } 670 qemu_opts_del(opts); 671 return ret; 672 } 673 674 static int raw_open(BlockDriverState *bs, QDict *options, int flags, 675 Error **errp) 676 { 677 BDRVRawState *s = bs->opaque; 678 679 s->type = FTYPE_FILE; 680 return raw_open_common(bs, options, flags, 0, false, errp); 681 } 682 683 typedef enum { 684 RAW_PL_PREPARE, 685 RAW_PL_COMMIT, 686 RAW_PL_ABORT, 687 } RawPermLockOp; 688 689 #define PERM_FOREACH(i) \ 690 for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++) 691 692 /* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the 693 * file; if @unlock == true, also unlock the unneeded bytes. 694 * @shared_perm_lock_bits is the mask of all permissions that are NOT shared. 695 */ 696 static int raw_apply_lock_bytes(int fd, 697 uint64_t perm_lock_bits, 698 uint64_t shared_perm_lock_bits, 699 bool unlock, Error **errp) 700 { 701 int ret; 702 int i; 703 704 PERM_FOREACH(i) { 705 int off = RAW_LOCK_PERM_BASE + i; 706 if (perm_lock_bits & (1ULL << i)) { 707 ret = qemu_lock_fd(fd, off, 1, false); 708 if (ret) { 709 error_setg(errp, "Failed to lock byte %d", off); 710 return ret; 711 } 712 } else if (unlock) { 713 ret = qemu_unlock_fd(fd, off, 1); 714 if (ret) { 715 error_setg(errp, "Failed to unlock byte %d", off); 716 return ret; 717 } 718 } 719 } 720 PERM_FOREACH(i) { 721 int off = RAW_LOCK_SHARED_BASE + i; 722 if (shared_perm_lock_bits & (1ULL << i)) { 723 ret = qemu_lock_fd(fd, off, 1, false); 724 if (ret) { 725 error_setg(errp, "Failed to lock byte %d", off); 726 return ret; 727 } 728 } else if (unlock) { 729 ret = qemu_unlock_fd(fd, off, 1); 730 if (ret) { 731 error_setg(errp, "Failed to unlock byte %d", off); 732 return ret; 733 } 734 } 735 } 736 return 0; 737 } 738 739 /* Check "unshared" bytes implied by @perm and ~@shared_perm in the file. */ 740 static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm, 741 Error **errp) 742 { 743 int ret; 744 int i; 745 746 PERM_FOREACH(i) { 747 int off = RAW_LOCK_SHARED_BASE + i; 748 uint64_t p = 1ULL << i; 749 if (perm & p) { 750 ret = qemu_lock_fd_test(fd, off, 1, true); 751 if (ret) { 752 char *perm_name = bdrv_perm_names(p); 753 error_setg(errp, 754 "Failed to get \"%s\" lock", 755 perm_name); 756 g_free(perm_name); 757 return ret; 758 } 759 } 760 } 761 PERM_FOREACH(i) { 762 int off = RAW_LOCK_PERM_BASE + i; 763 uint64_t p = 1ULL << i; 764 if (!(shared_perm & p)) { 765 ret = qemu_lock_fd_test(fd, off, 1, true); 766 if (ret) { 767 char *perm_name = bdrv_perm_names(p); 768 error_setg(errp, 769 "Failed to get shared \"%s\" lock", 770 perm_name); 771 g_free(perm_name); 772 return ret; 773 } 774 } 775 } 776 return 0; 777 } 778 779 static int raw_handle_perm_lock(BlockDriverState *bs, 780 RawPermLockOp op, 781 uint64_t new_perm, uint64_t new_shared, 782 Error **errp) 783 { 784 BDRVRawState *s = bs->opaque; 785 int ret = 0; 786 Error *local_err = NULL; 787 788 if (!s->use_lock) { 789 return 0; 790 } 791 792 if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) { 793 return 0; 794 } 795 796 assert(s->lock_fd > 0); 797 798 switch (op) { 799 case RAW_PL_PREPARE: 800 ret = raw_apply_lock_bytes(s->lock_fd, s->perm | new_perm, 801 ~s->shared_perm | ~new_shared, 802 false, errp); 803 if (!ret) { 804 ret = raw_check_lock_bytes(s->lock_fd, new_perm, new_shared, errp); 805 if (!ret) { 806 return 0; 807 } 808 error_append_hint(errp, 809 "Is another process using the image [%s]?\n", 810 bs->filename); 811 } 812 op = RAW_PL_ABORT; 813 /* fall through to unlock bytes. */ 814 case RAW_PL_ABORT: 815 raw_apply_lock_bytes(s->lock_fd, s->perm, ~s->shared_perm, 816 true, &local_err); 817 if (local_err) { 818 /* Theoretically the above call only unlocks bytes and it cannot 819 * fail. Something weird happened, report it. 820 */ 821 error_report_err(local_err); 822 } 823 break; 824 case RAW_PL_COMMIT: 825 raw_apply_lock_bytes(s->lock_fd, new_perm, ~new_shared, 826 true, &local_err); 827 if (local_err) { 828 /* Theoretically the above call only unlocks bytes and it cannot 829 * fail. Something weird happened, report it. 830 */ 831 error_report_err(local_err); 832 } 833 break; 834 } 835 return ret; 836 } 837 838 static int raw_reopen_prepare(BDRVReopenState *state, 839 BlockReopenQueue *queue, Error **errp) 840 { 841 BDRVRawState *s; 842 BDRVRawReopenState *rs; 843 QemuOpts *opts; 844 int ret = 0; 845 Error *local_err = NULL; 846 847 assert(state != NULL); 848 assert(state->bs != NULL); 849 850 s = state->bs->opaque; 851 852 state->opaque = g_new0(BDRVRawReopenState, 1); 853 rs = state->opaque; 854 rs->fd = -1; 855 856 /* Handle options changes */ 857 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort); 858 qemu_opts_absorb_qdict(opts, state->options, &local_err); 859 if (local_err) { 860 error_propagate(errp, local_err); 861 ret = -EINVAL; 862 goto out; 863 } 864 865 rs->check_cache_dropped = 866 qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false); 867 868 /* This driver's reopen function doesn't currently allow changing 869 * other options, so let's put them back in the original QDict and 870 * bdrv_reopen_prepare() will detect changes and complain. */ 871 qemu_opts_to_qdict(opts, state->options); 872 873 if (s->type == FTYPE_CD) { 874 rs->open_flags |= O_NONBLOCK; 875 } 876 877 raw_parse_flags(state->flags, &rs->open_flags); 878 879 int fcntl_flags = O_APPEND | O_NONBLOCK; 880 #ifdef O_NOATIME 881 fcntl_flags |= O_NOATIME; 882 #endif 883 884 #ifdef O_ASYNC 885 /* Not all operating systems have O_ASYNC, and those that don't 886 * will not let us track the state into rs->open_flags (typically 887 * you achieve the same effect with an ioctl, for example I_SETSIG 888 * on Solaris). But we do not use O_ASYNC, so that's fine. 889 */ 890 assert((s->open_flags & O_ASYNC) == 0); 891 #endif 892 893 if ((rs->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) { 894 /* dup the original fd */ 895 rs->fd = qemu_dup(s->fd); 896 if (rs->fd >= 0) { 897 ret = fcntl_setfl(rs->fd, rs->open_flags); 898 if (ret) { 899 qemu_close(rs->fd); 900 rs->fd = -1; 901 } 902 } 903 } 904 905 /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */ 906 if (rs->fd == -1) { 907 const char *normalized_filename = state->bs->filename; 908 ret = raw_normalize_devicepath(&normalized_filename); 909 if (ret < 0) { 910 error_setg_errno(errp, -ret, "Could not normalize device path"); 911 } else { 912 assert(!(rs->open_flags & O_CREAT)); 913 rs->fd = qemu_open(normalized_filename, rs->open_flags); 914 if (rs->fd == -1) { 915 error_setg_errno(errp, errno, "Could not reopen file"); 916 ret = -1; 917 } 918 } 919 } 920 921 /* Fail already reopen_prepare() if we can't get a working O_DIRECT 922 * alignment with the new fd. */ 923 if (rs->fd != -1) { 924 raw_probe_alignment(state->bs, rs->fd, &local_err); 925 if (local_err) { 926 qemu_close(rs->fd); 927 rs->fd = -1; 928 error_propagate(errp, local_err); 929 ret = -EINVAL; 930 } 931 } 932 933 out: 934 qemu_opts_del(opts); 935 return ret; 936 } 937 938 static void raw_reopen_commit(BDRVReopenState *state) 939 { 940 BDRVRawReopenState *rs = state->opaque; 941 BDRVRawState *s = state->bs->opaque; 942 943 s->check_cache_dropped = rs->check_cache_dropped; 944 s->open_flags = rs->open_flags; 945 946 qemu_close(s->fd); 947 s->fd = rs->fd; 948 949 g_free(state->opaque); 950 state->opaque = NULL; 951 } 952 953 954 static void raw_reopen_abort(BDRVReopenState *state) 955 { 956 BDRVRawReopenState *rs = state->opaque; 957 958 /* nothing to do if NULL, we didn't get far enough */ 959 if (rs == NULL) { 960 return; 961 } 962 963 if (rs->fd >= 0) { 964 qemu_close(rs->fd); 965 rs->fd = -1; 966 } 967 g_free(state->opaque); 968 state->opaque = NULL; 969 } 970 971 static int hdev_get_max_transfer_length(BlockDriverState *bs, int fd) 972 { 973 #ifdef BLKSECTGET 974 int max_bytes = 0; 975 short max_sectors = 0; 976 if (bs->sg && ioctl(fd, BLKSECTGET, &max_bytes) == 0) { 977 return max_bytes; 978 } else if (!bs->sg && ioctl(fd, BLKSECTGET, &max_sectors) == 0) { 979 return max_sectors << BDRV_SECTOR_BITS; 980 } else { 981 return -errno; 982 } 983 #else 984 return -ENOSYS; 985 #endif 986 } 987 988 static int hdev_get_max_segments(const struct stat *st) 989 { 990 #ifdef CONFIG_LINUX 991 char buf[32]; 992 const char *end; 993 char *sysfspath; 994 int ret; 995 int fd = -1; 996 long max_segments; 997 998 sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments", 999 major(st->st_rdev), minor(st->st_rdev)); 1000 fd = open(sysfspath, O_RDONLY); 1001 if (fd == -1) { 1002 ret = -errno; 1003 goto out; 1004 } 1005 do { 1006 ret = read(fd, buf, sizeof(buf) - 1); 1007 } while (ret == -1 && errno == EINTR); 1008 if (ret < 0) { 1009 ret = -errno; 1010 goto out; 1011 } else if (ret == 0) { 1012 ret = -EIO; 1013 goto out; 1014 } 1015 buf[ret] = 0; 1016 /* The file is ended with '\n', pass 'end' to accept that. */ 1017 ret = qemu_strtol(buf, &end, 10, &max_segments); 1018 if (ret == 0 && end && *end == '\n') { 1019 ret = max_segments; 1020 } 1021 1022 out: 1023 if (fd != -1) { 1024 close(fd); 1025 } 1026 g_free(sysfspath); 1027 return ret; 1028 #else 1029 return -ENOTSUP; 1030 #endif 1031 } 1032 1033 static void raw_refresh_limits(BlockDriverState *bs, Error **errp) 1034 { 1035 BDRVRawState *s = bs->opaque; 1036 struct stat st; 1037 1038 if (!fstat(s->fd, &st)) { 1039 if (S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode)) { 1040 int ret = hdev_get_max_transfer_length(bs, s->fd); 1041 if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) { 1042 bs->bl.max_transfer = pow2floor(ret); 1043 } 1044 ret = hdev_get_max_segments(&st); 1045 if (ret > 0) { 1046 bs->bl.max_transfer = MIN(bs->bl.max_transfer, 1047 ret * getpagesize()); 1048 } 1049 } 1050 } 1051 1052 raw_probe_alignment(bs, s->fd, errp); 1053 bs->bl.min_mem_alignment = s->buf_align; 1054 bs->bl.opt_mem_alignment = MAX(s->buf_align, getpagesize()); 1055 } 1056 1057 static int check_for_dasd(int fd) 1058 { 1059 #ifdef BIODASDINFO2 1060 struct dasd_information2_t info = {0}; 1061 1062 return ioctl(fd, BIODASDINFO2, &info); 1063 #else 1064 return -1; 1065 #endif 1066 } 1067 1068 /** 1069 * Try to get @bs's logical and physical block size. 1070 * On success, store them in @bsz and return zero. 1071 * On failure, return negative errno. 1072 */ 1073 static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz) 1074 { 1075 BDRVRawState *s = bs->opaque; 1076 int ret; 1077 1078 /* If DASD, get blocksizes */ 1079 if (check_for_dasd(s->fd) < 0) { 1080 return -ENOTSUP; 1081 } 1082 ret = probe_logical_blocksize(s->fd, &bsz->log); 1083 if (ret < 0) { 1084 return ret; 1085 } 1086 return probe_physical_blocksize(s->fd, &bsz->phys); 1087 } 1088 1089 /** 1090 * Try to get @bs's geometry: cyls, heads, sectors. 1091 * On success, store them in @geo and return 0. 1092 * On failure return -errno. 1093 * (Allows block driver to assign default geometry values that guest sees) 1094 */ 1095 #ifdef __linux__ 1096 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo) 1097 { 1098 BDRVRawState *s = bs->opaque; 1099 struct hd_geometry ioctl_geo = {0}; 1100 1101 /* If DASD, get its geometry */ 1102 if (check_for_dasd(s->fd) < 0) { 1103 return -ENOTSUP; 1104 } 1105 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) { 1106 return -errno; 1107 } 1108 /* HDIO_GETGEO may return success even though geo contains zeros 1109 (e.g. certain multipath setups) */ 1110 if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) { 1111 return -ENOTSUP; 1112 } 1113 /* Do not return a geometry for partition */ 1114 if (ioctl_geo.start != 0) { 1115 return -ENOTSUP; 1116 } 1117 geo->heads = ioctl_geo.heads; 1118 geo->sectors = ioctl_geo.sectors; 1119 geo->cylinders = ioctl_geo.cylinders; 1120 1121 return 0; 1122 } 1123 #else /* __linux__ */ 1124 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo) 1125 { 1126 return -ENOTSUP; 1127 } 1128 #endif 1129 1130 static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb) 1131 { 1132 int ret; 1133 1134 ret = ioctl(aiocb->aio_fildes, aiocb->aio_ioctl_cmd, aiocb->aio_ioctl_buf); 1135 if (ret == -1) { 1136 return -errno; 1137 } 1138 1139 return 0; 1140 } 1141 1142 static ssize_t handle_aiocb_flush(RawPosixAIOData *aiocb) 1143 { 1144 BDRVRawState *s = aiocb->bs->opaque; 1145 int ret; 1146 1147 if (s->page_cache_inconsistent) { 1148 return -EIO; 1149 } 1150 1151 ret = qemu_fdatasync(aiocb->aio_fildes); 1152 if (ret == -1) { 1153 /* There is no clear definition of the semantics of a failing fsync(), 1154 * so we may have to assume the worst. The sad truth is that this 1155 * assumption is correct for Linux. Some pages are now probably marked 1156 * clean in the page cache even though they are inconsistent with the 1157 * on-disk contents. The next fdatasync() call would succeed, but no 1158 * further writeback attempt will be made. We can't get back to a state 1159 * in which we know what is on disk (we would have to rewrite 1160 * everything that was touched since the last fdatasync() at least), so 1161 * make bdrv_flush() fail permanently. Given that the behaviour isn't 1162 * really defined, I have little hope that other OSes are doing better. 1163 * 1164 * Obviously, this doesn't affect O_DIRECT, which bypasses the page 1165 * cache. */ 1166 if ((s->open_flags & O_DIRECT) == 0) { 1167 s->page_cache_inconsistent = true; 1168 } 1169 return -errno; 1170 } 1171 return 0; 1172 } 1173 1174 #ifdef CONFIG_PREADV 1175 1176 static bool preadv_present = true; 1177 1178 static ssize_t 1179 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset) 1180 { 1181 return preadv(fd, iov, nr_iov, offset); 1182 } 1183 1184 static ssize_t 1185 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset) 1186 { 1187 return pwritev(fd, iov, nr_iov, offset); 1188 } 1189 1190 #else 1191 1192 static bool preadv_present = false; 1193 1194 static ssize_t 1195 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset) 1196 { 1197 return -ENOSYS; 1198 } 1199 1200 static ssize_t 1201 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset) 1202 { 1203 return -ENOSYS; 1204 } 1205 1206 #endif 1207 1208 static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb) 1209 { 1210 ssize_t len; 1211 1212 do { 1213 if (aiocb->aio_type & QEMU_AIO_WRITE) 1214 len = qemu_pwritev(aiocb->aio_fildes, 1215 aiocb->aio_iov, 1216 aiocb->aio_niov, 1217 aiocb->aio_offset); 1218 else 1219 len = qemu_preadv(aiocb->aio_fildes, 1220 aiocb->aio_iov, 1221 aiocb->aio_niov, 1222 aiocb->aio_offset); 1223 } while (len == -1 && errno == EINTR); 1224 1225 if (len == -1) { 1226 return -errno; 1227 } 1228 return len; 1229 } 1230 1231 /* 1232 * Read/writes the data to/from a given linear buffer. 1233 * 1234 * Returns the number of bytes handles or -errno in case of an error. Short 1235 * reads are only returned if the end of the file is reached. 1236 */ 1237 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf) 1238 { 1239 ssize_t offset = 0; 1240 ssize_t len; 1241 1242 while (offset < aiocb->aio_nbytes) { 1243 if (aiocb->aio_type & QEMU_AIO_WRITE) { 1244 len = pwrite(aiocb->aio_fildes, 1245 (const char *)buf + offset, 1246 aiocb->aio_nbytes - offset, 1247 aiocb->aio_offset + offset); 1248 } else { 1249 len = pread(aiocb->aio_fildes, 1250 buf + offset, 1251 aiocb->aio_nbytes - offset, 1252 aiocb->aio_offset + offset); 1253 } 1254 if (len == -1 && errno == EINTR) { 1255 continue; 1256 } else if (len == -1 && errno == EINVAL && 1257 (aiocb->bs->open_flags & BDRV_O_NOCACHE) && 1258 !(aiocb->aio_type & QEMU_AIO_WRITE) && 1259 offset > 0) { 1260 /* O_DIRECT pread() may fail with EINVAL when offset is unaligned 1261 * after a short read. Assume that O_DIRECT short reads only occur 1262 * at EOF. Therefore this is a short read, not an I/O error. 1263 */ 1264 break; 1265 } else if (len == -1) { 1266 offset = -errno; 1267 break; 1268 } else if (len == 0) { 1269 break; 1270 } 1271 offset += len; 1272 } 1273 1274 return offset; 1275 } 1276 1277 static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb) 1278 { 1279 ssize_t nbytes; 1280 char *buf; 1281 1282 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) { 1283 /* 1284 * If there is just a single buffer, and it is properly aligned 1285 * we can just use plain pread/pwrite without any problems. 1286 */ 1287 if (aiocb->aio_niov == 1) { 1288 return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base); 1289 } 1290 /* 1291 * We have more than one iovec, and all are properly aligned. 1292 * 1293 * Try preadv/pwritev first and fall back to linearizing the 1294 * buffer if it's not supported. 1295 */ 1296 if (preadv_present) { 1297 nbytes = handle_aiocb_rw_vector(aiocb); 1298 if (nbytes == aiocb->aio_nbytes || 1299 (nbytes < 0 && nbytes != -ENOSYS)) { 1300 return nbytes; 1301 } 1302 preadv_present = false; 1303 } 1304 1305 /* 1306 * XXX(hch): short read/write. no easy way to handle the reminder 1307 * using these interfaces. For now retry using plain 1308 * pread/pwrite? 1309 */ 1310 } 1311 1312 /* 1313 * Ok, we have to do it the hard way, copy all segments into 1314 * a single aligned buffer. 1315 */ 1316 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes); 1317 if (buf == NULL) { 1318 return -ENOMEM; 1319 } 1320 1321 if (aiocb->aio_type & QEMU_AIO_WRITE) { 1322 char *p = buf; 1323 int i; 1324 1325 for (i = 0; i < aiocb->aio_niov; ++i) { 1326 memcpy(p, aiocb->aio_iov[i].iov_base, aiocb->aio_iov[i].iov_len); 1327 p += aiocb->aio_iov[i].iov_len; 1328 } 1329 assert(p - buf == aiocb->aio_nbytes); 1330 } 1331 1332 nbytes = handle_aiocb_rw_linear(aiocb, buf); 1333 if (!(aiocb->aio_type & QEMU_AIO_WRITE)) { 1334 char *p = buf; 1335 size_t count = aiocb->aio_nbytes, copy; 1336 int i; 1337 1338 for (i = 0; i < aiocb->aio_niov && count; ++i) { 1339 copy = count; 1340 if (copy > aiocb->aio_iov[i].iov_len) { 1341 copy = aiocb->aio_iov[i].iov_len; 1342 } 1343 memcpy(aiocb->aio_iov[i].iov_base, p, copy); 1344 assert(count >= copy); 1345 p += copy; 1346 count -= copy; 1347 } 1348 assert(count == 0); 1349 } 1350 qemu_vfree(buf); 1351 1352 return nbytes; 1353 } 1354 1355 #ifdef CONFIG_XFS 1356 static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes) 1357 { 1358 struct xfs_flock64 fl; 1359 int err; 1360 1361 memset(&fl, 0, sizeof(fl)); 1362 fl.l_whence = SEEK_SET; 1363 fl.l_start = offset; 1364 fl.l_len = bytes; 1365 1366 if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) { 1367 err = errno; 1368 DPRINTF("cannot write zero range (%s)\n", strerror(errno)); 1369 return -err; 1370 } 1371 1372 return 0; 1373 } 1374 1375 static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes) 1376 { 1377 struct xfs_flock64 fl; 1378 int err; 1379 1380 memset(&fl, 0, sizeof(fl)); 1381 fl.l_whence = SEEK_SET; 1382 fl.l_start = offset; 1383 fl.l_len = bytes; 1384 1385 if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) { 1386 err = errno; 1387 DPRINTF("cannot punch hole (%s)\n", strerror(errno)); 1388 return -err; 1389 } 1390 1391 return 0; 1392 } 1393 #endif 1394 1395 static int translate_err(int err) 1396 { 1397 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP || 1398 err == -ENOTTY) { 1399 err = -ENOTSUP; 1400 } 1401 return err; 1402 } 1403 1404 #ifdef CONFIG_FALLOCATE 1405 static int do_fallocate(int fd, int mode, off_t offset, off_t len) 1406 { 1407 do { 1408 if (fallocate(fd, mode, offset, len) == 0) { 1409 return 0; 1410 } 1411 } while (errno == EINTR); 1412 return translate_err(-errno); 1413 } 1414 #endif 1415 1416 static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb) 1417 { 1418 int ret = -ENOTSUP; 1419 BDRVRawState *s = aiocb->bs->opaque; 1420 1421 if (!s->has_write_zeroes) { 1422 return -ENOTSUP; 1423 } 1424 1425 #ifdef BLKZEROOUT 1426 do { 1427 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes }; 1428 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) { 1429 return 0; 1430 } 1431 } while (errno == EINTR); 1432 1433 ret = translate_err(-errno); 1434 #endif 1435 1436 if (ret == -ENOTSUP) { 1437 s->has_write_zeroes = false; 1438 } 1439 return ret; 1440 } 1441 1442 static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb) 1443 { 1444 #if defined(CONFIG_FALLOCATE) || defined(CONFIG_XFS) 1445 BDRVRawState *s = aiocb->bs->opaque; 1446 #endif 1447 #ifdef CONFIG_FALLOCATE 1448 int64_t len; 1449 #endif 1450 1451 if (aiocb->aio_type & QEMU_AIO_BLKDEV) { 1452 return handle_aiocb_write_zeroes_block(aiocb); 1453 } 1454 1455 #ifdef CONFIG_XFS 1456 if (s->is_xfs) { 1457 return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes); 1458 } 1459 #endif 1460 1461 #ifdef CONFIG_FALLOCATE_ZERO_RANGE 1462 if (s->has_write_zeroes) { 1463 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE, 1464 aiocb->aio_offset, aiocb->aio_nbytes); 1465 if (ret == 0 || ret != -ENOTSUP) { 1466 return ret; 1467 } 1468 s->has_write_zeroes = false; 1469 } 1470 #endif 1471 1472 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE 1473 if (s->has_discard && s->has_fallocate) { 1474 int ret = do_fallocate(s->fd, 1475 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 1476 aiocb->aio_offset, aiocb->aio_nbytes); 1477 if (ret == 0) { 1478 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes); 1479 if (ret == 0 || ret != -ENOTSUP) { 1480 return ret; 1481 } 1482 s->has_fallocate = false; 1483 } else if (ret != -ENOTSUP) { 1484 return ret; 1485 } else { 1486 s->has_discard = false; 1487 } 1488 } 1489 #endif 1490 1491 #ifdef CONFIG_FALLOCATE 1492 /* Last resort: we are trying to extend the file with zeroed data. This 1493 * can be done via fallocate(fd, 0) */ 1494 len = bdrv_getlength(aiocb->bs); 1495 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) { 1496 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes); 1497 if (ret == 0 || ret != -ENOTSUP) { 1498 return ret; 1499 } 1500 s->has_fallocate = false; 1501 } 1502 #endif 1503 1504 return -ENOTSUP; 1505 } 1506 1507 static ssize_t handle_aiocb_write_zeroes_unmap(RawPosixAIOData *aiocb) 1508 { 1509 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque; 1510 int ret; 1511 1512 /* First try to write zeros and unmap at the same time */ 1513 1514 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE 1515 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 1516 aiocb->aio_offset, aiocb->aio_nbytes); 1517 if (ret != -ENOTSUP) { 1518 return ret; 1519 } 1520 #endif 1521 1522 #ifdef CONFIG_XFS 1523 if (s->is_xfs) { 1524 /* xfs_discard() guarantees that the discarded area reads as all-zero 1525 * afterwards, so we can use it here. */ 1526 return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes); 1527 } 1528 #endif 1529 1530 /* If we couldn't manage to unmap while guaranteed that the area reads as 1531 * all-zero afterwards, just write zeroes without unmapping */ 1532 ret = handle_aiocb_write_zeroes(aiocb); 1533 return ret; 1534 } 1535 1536 #ifndef HAVE_COPY_FILE_RANGE 1537 static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd, 1538 off_t *out_off, size_t len, unsigned int flags) 1539 { 1540 #ifdef __NR_copy_file_range 1541 return syscall(__NR_copy_file_range, in_fd, in_off, out_fd, 1542 out_off, len, flags); 1543 #else 1544 errno = ENOSYS; 1545 return -1; 1546 #endif 1547 } 1548 #endif 1549 1550 static ssize_t handle_aiocb_copy_range(RawPosixAIOData *aiocb) 1551 { 1552 uint64_t bytes = aiocb->aio_nbytes; 1553 off_t in_off = aiocb->aio_offset; 1554 off_t out_off = aiocb->aio_offset2; 1555 1556 while (bytes) { 1557 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off, 1558 aiocb->aio_fd2, &out_off, 1559 bytes, 0); 1560 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off, 1561 aiocb->aio_fd2, out_off, bytes, 0, ret); 1562 if (ret == 0) { 1563 /* No progress (e.g. when beyond EOF), let the caller fall back to 1564 * buffer I/O. */ 1565 return -ENOSPC; 1566 } 1567 if (ret < 0) { 1568 switch (errno) { 1569 case ENOSYS: 1570 return -ENOTSUP; 1571 case EINTR: 1572 continue; 1573 default: 1574 return -errno; 1575 } 1576 } 1577 bytes -= ret; 1578 } 1579 return 0; 1580 } 1581 1582 static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb) 1583 { 1584 int ret = -EOPNOTSUPP; 1585 BDRVRawState *s = aiocb->bs->opaque; 1586 1587 if (!s->has_discard) { 1588 return -ENOTSUP; 1589 } 1590 1591 if (aiocb->aio_type & QEMU_AIO_BLKDEV) { 1592 #ifdef BLKDISCARD 1593 do { 1594 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes }; 1595 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) { 1596 return 0; 1597 } 1598 } while (errno == EINTR); 1599 1600 ret = -errno; 1601 #endif 1602 } else { 1603 #ifdef CONFIG_XFS 1604 if (s->is_xfs) { 1605 return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes); 1606 } 1607 #endif 1608 1609 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE 1610 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 1611 aiocb->aio_offset, aiocb->aio_nbytes); 1612 #endif 1613 } 1614 1615 ret = translate_err(ret); 1616 if (ret == -ENOTSUP) { 1617 s->has_discard = false; 1618 } 1619 return ret; 1620 } 1621 1622 static int handle_aiocb_truncate(RawPosixAIOData *aiocb) 1623 { 1624 int result = 0; 1625 int64_t current_length = 0; 1626 char *buf = NULL; 1627 struct stat st; 1628 int fd = aiocb->aio_fildes; 1629 int64_t offset = aiocb->aio_offset; 1630 Error **errp = aiocb->errp; 1631 1632 if (fstat(fd, &st) < 0) { 1633 result = -errno; 1634 error_setg_errno(errp, -result, "Could not stat file"); 1635 return result; 1636 } 1637 1638 current_length = st.st_size; 1639 if (current_length > offset && aiocb->prealloc != PREALLOC_MODE_OFF) { 1640 error_setg(errp, "Cannot use preallocation for shrinking files"); 1641 return -ENOTSUP; 1642 } 1643 1644 switch (aiocb->prealloc) { 1645 #ifdef CONFIG_POSIX_FALLOCATE 1646 case PREALLOC_MODE_FALLOC: 1647 /* 1648 * Truncating before posix_fallocate() makes it about twice slower on 1649 * file systems that do not support fallocate(), trying to check if a 1650 * block is allocated before allocating it, so don't do that here. 1651 */ 1652 if (offset != current_length) { 1653 result = -posix_fallocate(fd, current_length, 1654 offset - current_length); 1655 if (result != 0) { 1656 /* posix_fallocate() doesn't set errno. */ 1657 error_setg_errno(errp, -result, 1658 "Could not preallocate new data"); 1659 } 1660 } else { 1661 result = 0; 1662 } 1663 goto out; 1664 #endif 1665 case PREALLOC_MODE_FULL: 1666 { 1667 int64_t num = 0, left = offset - current_length; 1668 off_t seek_result; 1669 1670 /* 1671 * Knowing the final size from the beginning could allow the file 1672 * system driver to do less allocations and possibly avoid 1673 * fragmentation of the file. 1674 */ 1675 if (ftruncate(fd, offset) != 0) { 1676 result = -errno; 1677 error_setg_errno(errp, -result, "Could not resize file"); 1678 goto out; 1679 } 1680 1681 buf = g_malloc0(65536); 1682 1683 seek_result = lseek(fd, current_length, SEEK_SET); 1684 if (seek_result < 0) { 1685 result = -errno; 1686 error_setg_errno(errp, -result, 1687 "Failed to seek to the old end of file"); 1688 goto out; 1689 } 1690 1691 while (left > 0) { 1692 num = MIN(left, 65536); 1693 result = write(fd, buf, num); 1694 if (result < 0) { 1695 if (errno == EINTR) { 1696 continue; 1697 } 1698 result = -errno; 1699 error_setg_errno(errp, -result, 1700 "Could not write zeros for preallocation"); 1701 goto out; 1702 } 1703 left -= result; 1704 } 1705 if (result >= 0) { 1706 result = fsync(fd); 1707 if (result < 0) { 1708 result = -errno; 1709 error_setg_errno(errp, -result, 1710 "Could not flush file to disk"); 1711 goto out; 1712 } 1713 } 1714 goto out; 1715 } 1716 case PREALLOC_MODE_OFF: 1717 if (ftruncate(fd, offset) != 0) { 1718 result = -errno; 1719 error_setg_errno(errp, -result, "Could not resize file"); 1720 } 1721 return result; 1722 default: 1723 result = -ENOTSUP; 1724 error_setg(errp, "Unsupported preallocation mode: %s", 1725 PreallocMode_str(aiocb->prealloc)); 1726 return result; 1727 } 1728 1729 out: 1730 if (result < 0) { 1731 if (ftruncate(fd, current_length) < 0) { 1732 error_report("Failed to restore old file length: %s", 1733 strerror(errno)); 1734 } 1735 } 1736 1737 g_free(buf); 1738 return result; 1739 } 1740 1741 static int aio_worker(void *arg) 1742 { 1743 RawPosixAIOData *aiocb = arg; 1744 ssize_t ret = 0; 1745 1746 switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) { 1747 case QEMU_AIO_READ: 1748 ret = handle_aiocb_rw(aiocb); 1749 if (ret >= 0 && ret < aiocb->aio_nbytes) { 1750 iov_memset(aiocb->aio_iov, aiocb->aio_niov, ret, 1751 0, aiocb->aio_nbytes - ret); 1752 1753 ret = aiocb->aio_nbytes; 1754 } 1755 if (ret == aiocb->aio_nbytes) { 1756 ret = 0; 1757 } else if (ret >= 0 && ret < aiocb->aio_nbytes) { 1758 ret = -EINVAL; 1759 } 1760 break; 1761 case QEMU_AIO_WRITE: 1762 ret = handle_aiocb_rw(aiocb); 1763 if (ret == aiocb->aio_nbytes) { 1764 ret = 0; 1765 } else if (ret >= 0 && ret < aiocb->aio_nbytes) { 1766 ret = -EINVAL; 1767 } 1768 break; 1769 case QEMU_AIO_FLUSH: 1770 ret = handle_aiocb_flush(aiocb); 1771 break; 1772 case QEMU_AIO_IOCTL: 1773 ret = handle_aiocb_ioctl(aiocb); 1774 break; 1775 case QEMU_AIO_DISCARD: 1776 ret = handle_aiocb_discard(aiocb); 1777 break; 1778 case QEMU_AIO_WRITE_ZEROES: 1779 ret = handle_aiocb_write_zeroes(aiocb); 1780 break; 1781 case QEMU_AIO_WRITE_ZEROES | QEMU_AIO_DISCARD: 1782 ret = handle_aiocb_write_zeroes_unmap(aiocb); 1783 break; 1784 case QEMU_AIO_COPY_RANGE: 1785 ret = handle_aiocb_copy_range(aiocb); 1786 break; 1787 case QEMU_AIO_TRUNCATE: 1788 ret = handle_aiocb_truncate(aiocb); 1789 break; 1790 default: 1791 fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type); 1792 ret = -EINVAL; 1793 break; 1794 } 1795 1796 g_free(aiocb); 1797 return ret; 1798 } 1799 1800 static int paio_submit_co_full(BlockDriverState *bs, int fd, 1801 int64_t offset, int fd2, int64_t offset2, 1802 QEMUIOVector *qiov, 1803 int bytes, int type) 1804 { 1805 RawPosixAIOData *acb = g_new(RawPosixAIOData, 1); 1806 ThreadPool *pool; 1807 1808 acb->bs = bs; 1809 acb->aio_type = type; 1810 acb->aio_fildes = fd; 1811 acb->aio_fd2 = fd2; 1812 acb->aio_offset2 = offset2; 1813 1814 acb->aio_nbytes = bytes; 1815 acb->aio_offset = offset; 1816 1817 if (qiov) { 1818 acb->aio_iov = qiov->iov; 1819 acb->aio_niov = qiov->niov; 1820 assert(qiov->size == bytes); 1821 } 1822 1823 trace_file_paio_submit_co(offset, bytes, type); 1824 pool = aio_get_thread_pool(bdrv_get_aio_context(bs)); 1825 return thread_pool_submit_co(pool, aio_worker, acb); 1826 } 1827 1828 static inline int paio_submit_co(BlockDriverState *bs, int fd, 1829 int64_t offset, QEMUIOVector *qiov, 1830 int bytes, int type) 1831 { 1832 return paio_submit_co_full(bs, fd, offset, -1, 0, qiov, bytes, type); 1833 } 1834 1835 static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset, 1836 uint64_t bytes, QEMUIOVector *qiov, int type) 1837 { 1838 BDRVRawState *s = bs->opaque; 1839 1840 if (fd_open(bs) < 0) 1841 return -EIO; 1842 1843 /* 1844 * Check if the underlying device requires requests to be aligned, 1845 * and if the request we are trying to submit is aligned or not. 1846 * If this is the case tell the low-level driver that it needs 1847 * to copy the buffer. 1848 */ 1849 if (s->needs_alignment) { 1850 if (!bdrv_qiov_is_aligned(bs, qiov)) { 1851 type |= QEMU_AIO_MISALIGNED; 1852 #ifdef CONFIG_LINUX_AIO 1853 } else if (s->use_linux_aio) { 1854 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs)); 1855 assert(qiov->size == bytes); 1856 return laio_co_submit(bs, aio, s->fd, offset, qiov, type); 1857 #endif 1858 } 1859 } 1860 1861 return paio_submit_co(bs, s->fd, offset, qiov, bytes, type); 1862 } 1863 1864 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset, 1865 uint64_t bytes, QEMUIOVector *qiov, 1866 int flags) 1867 { 1868 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ); 1869 } 1870 1871 static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset, 1872 uint64_t bytes, QEMUIOVector *qiov, 1873 int flags) 1874 { 1875 assert(flags == 0); 1876 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE); 1877 } 1878 1879 static void raw_aio_plug(BlockDriverState *bs) 1880 { 1881 #ifdef CONFIG_LINUX_AIO 1882 BDRVRawState *s = bs->opaque; 1883 if (s->use_linux_aio) { 1884 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs)); 1885 laio_io_plug(bs, aio); 1886 } 1887 #endif 1888 } 1889 1890 static void raw_aio_unplug(BlockDriverState *bs) 1891 { 1892 #ifdef CONFIG_LINUX_AIO 1893 BDRVRawState *s = bs->opaque; 1894 if (s->use_linux_aio) { 1895 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs)); 1896 laio_io_unplug(bs, aio); 1897 } 1898 #endif 1899 } 1900 1901 static int raw_co_flush_to_disk(BlockDriverState *bs) 1902 { 1903 BDRVRawState *s = bs->opaque; 1904 int ret; 1905 1906 ret = fd_open(bs); 1907 if (ret < 0) { 1908 return ret; 1909 } 1910 1911 return paio_submit_co(bs, s->fd, 0, NULL, 0, QEMU_AIO_FLUSH); 1912 } 1913 1914 static void raw_aio_attach_aio_context(BlockDriverState *bs, 1915 AioContext *new_context) 1916 { 1917 #ifdef CONFIG_LINUX_AIO 1918 BDRVRawState *s = bs->opaque; 1919 if (s->use_linux_aio) { 1920 Error *local_err; 1921 if (!aio_setup_linux_aio(new_context, &local_err)) { 1922 error_reportf_err(local_err, "Unable to use native AIO, " 1923 "falling back to thread pool: "); 1924 s->use_linux_aio = false; 1925 } 1926 } 1927 #endif 1928 } 1929 1930 static void raw_close(BlockDriverState *bs) 1931 { 1932 BDRVRawState *s = bs->opaque; 1933 1934 if (s->fd >= 0) { 1935 qemu_close(s->fd); 1936 s->fd = -1; 1937 } 1938 if (s->lock_fd >= 0) { 1939 qemu_close(s->lock_fd); 1940 s->lock_fd = -1; 1941 } 1942 } 1943 1944 /** 1945 * Truncates the given regular file @fd to @offset and, when growing, fills the 1946 * new space according to @prealloc. 1947 * 1948 * Returns: 0 on success, -errno on failure. 1949 */ 1950 static int coroutine_fn 1951 raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset, 1952 PreallocMode prealloc, Error **errp) 1953 { 1954 RawPosixAIOData *acb = g_new(RawPosixAIOData, 1); 1955 ThreadPool *pool; 1956 1957 *acb = (RawPosixAIOData) { 1958 .bs = bs, 1959 .aio_fildes = fd, 1960 .aio_type = QEMU_AIO_TRUNCATE, 1961 .aio_offset = offset, 1962 .prealloc = prealloc, 1963 .errp = errp, 1964 }; 1965 1966 /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */ 1967 pool = aio_get_thread_pool(bdrv_get_aio_context(bs)); 1968 return thread_pool_submit_co(pool, aio_worker, acb); 1969 } 1970 1971 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, 1972 PreallocMode prealloc, Error **errp) 1973 { 1974 BDRVRawState *s = bs->opaque; 1975 struct stat st; 1976 int ret; 1977 1978 if (fstat(s->fd, &st)) { 1979 ret = -errno; 1980 error_setg_errno(errp, -ret, "Failed to fstat() the file"); 1981 return ret; 1982 } 1983 1984 if (S_ISREG(st.st_mode)) { 1985 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp); 1986 } 1987 1988 if (prealloc != PREALLOC_MODE_OFF) { 1989 error_setg(errp, "Preallocation mode '%s' unsupported for this " 1990 "non-regular file", PreallocMode_str(prealloc)); 1991 return -ENOTSUP; 1992 } 1993 1994 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) { 1995 if (offset > raw_getlength(bs)) { 1996 error_setg(errp, "Cannot grow device files"); 1997 return -EINVAL; 1998 } 1999 } else { 2000 error_setg(errp, "Resizing this file is not supported"); 2001 return -ENOTSUP; 2002 } 2003 2004 return 0; 2005 } 2006 2007 #ifdef __OpenBSD__ 2008 static int64_t raw_getlength(BlockDriverState *bs) 2009 { 2010 BDRVRawState *s = bs->opaque; 2011 int fd = s->fd; 2012 struct stat st; 2013 2014 if (fstat(fd, &st)) 2015 return -errno; 2016 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) { 2017 struct disklabel dl; 2018 2019 if (ioctl(fd, DIOCGDINFO, &dl)) 2020 return -errno; 2021 return (uint64_t)dl.d_secsize * 2022 dl.d_partitions[DISKPART(st.st_rdev)].p_size; 2023 } else 2024 return st.st_size; 2025 } 2026 #elif defined(__NetBSD__) 2027 static int64_t raw_getlength(BlockDriverState *bs) 2028 { 2029 BDRVRawState *s = bs->opaque; 2030 int fd = s->fd; 2031 struct stat st; 2032 2033 if (fstat(fd, &st)) 2034 return -errno; 2035 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) { 2036 struct dkwedge_info dkw; 2037 2038 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) { 2039 return dkw.dkw_size * 512; 2040 } else { 2041 struct disklabel dl; 2042 2043 if (ioctl(fd, DIOCGDINFO, &dl)) 2044 return -errno; 2045 return (uint64_t)dl.d_secsize * 2046 dl.d_partitions[DISKPART(st.st_rdev)].p_size; 2047 } 2048 } else 2049 return st.st_size; 2050 } 2051 #elif defined(__sun__) 2052 static int64_t raw_getlength(BlockDriverState *bs) 2053 { 2054 BDRVRawState *s = bs->opaque; 2055 struct dk_minfo minfo; 2056 int ret; 2057 int64_t size; 2058 2059 ret = fd_open(bs); 2060 if (ret < 0) { 2061 return ret; 2062 } 2063 2064 /* 2065 * Use the DKIOCGMEDIAINFO ioctl to read the size. 2066 */ 2067 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo); 2068 if (ret != -1) { 2069 return minfo.dki_lbsize * minfo.dki_capacity; 2070 } 2071 2072 /* 2073 * There are reports that lseek on some devices fails, but 2074 * irc discussion said that contingency on contingency was overkill. 2075 */ 2076 size = lseek(s->fd, 0, SEEK_END); 2077 if (size < 0) { 2078 return -errno; 2079 } 2080 return size; 2081 } 2082 #elif defined(CONFIG_BSD) 2083 static int64_t raw_getlength(BlockDriverState *bs) 2084 { 2085 BDRVRawState *s = bs->opaque; 2086 int fd = s->fd; 2087 int64_t size; 2088 struct stat sb; 2089 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) 2090 int reopened = 0; 2091 #endif 2092 int ret; 2093 2094 ret = fd_open(bs); 2095 if (ret < 0) 2096 return ret; 2097 2098 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) 2099 again: 2100 #endif 2101 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) { 2102 #ifdef DIOCGMEDIASIZE 2103 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size)) 2104 #elif defined(DIOCGPART) 2105 { 2106 struct partinfo pi; 2107 if (ioctl(fd, DIOCGPART, &pi) == 0) 2108 size = pi.media_size; 2109 else 2110 size = 0; 2111 } 2112 if (size == 0) 2113 #endif 2114 #if defined(__APPLE__) && defined(__MACH__) 2115 { 2116 uint64_t sectors = 0; 2117 uint32_t sector_size = 0; 2118 2119 if (ioctl(fd, DKIOCGETBLOCKCOUNT, §ors) == 0 2120 && ioctl(fd, DKIOCGETBLOCKSIZE, §or_size) == 0) { 2121 size = sectors * sector_size; 2122 } else { 2123 size = lseek(fd, 0LL, SEEK_END); 2124 if (size < 0) { 2125 return -errno; 2126 } 2127 } 2128 } 2129 #else 2130 size = lseek(fd, 0LL, SEEK_END); 2131 if (size < 0) { 2132 return -errno; 2133 } 2134 #endif 2135 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 2136 switch(s->type) { 2137 case FTYPE_CD: 2138 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */ 2139 if (size == 2048LL * (unsigned)-1) 2140 size = 0; 2141 /* XXX no disc? maybe we need to reopen... */ 2142 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) { 2143 reopened = 1; 2144 goto again; 2145 } 2146 } 2147 #endif 2148 } else { 2149 size = lseek(fd, 0, SEEK_END); 2150 if (size < 0) { 2151 return -errno; 2152 } 2153 } 2154 return size; 2155 } 2156 #else 2157 static int64_t raw_getlength(BlockDriverState *bs) 2158 { 2159 BDRVRawState *s = bs->opaque; 2160 int ret; 2161 int64_t size; 2162 2163 ret = fd_open(bs); 2164 if (ret < 0) { 2165 return ret; 2166 } 2167 2168 size = lseek(s->fd, 0, SEEK_END); 2169 if (size < 0) { 2170 return -errno; 2171 } 2172 return size; 2173 } 2174 #endif 2175 2176 static int64_t raw_get_allocated_file_size(BlockDriverState *bs) 2177 { 2178 struct stat st; 2179 BDRVRawState *s = bs->opaque; 2180 2181 if (fstat(s->fd, &st) < 0) { 2182 return -errno; 2183 } 2184 return (int64_t)st.st_blocks * 512; 2185 } 2186 2187 static int coroutine_fn 2188 raw_co_create(BlockdevCreateOptions *options, Error **errp) 2189 { 2190 BlockdevCreateOptionsFile *file_opts; 2191 Error *local_err = NULL; 2192 int fd; 2193 uint64_t perm, shared; 2194 int result = 0; 2195 2196 /* Validate options and set default values */ 2197 assert(options->driver == BLOCKDEV_DRIVER_FILE); 2198 file_opts = &options->u.file; 2199 2200 if (!file_opts->has_nocow) { 2201 file_opts->nocow = false; 2202 } 2203 if (!file_opts->has_preallocation) { 2204 file_opts->preallocation = PREALLOC_MODE_OFF; 2205 } 2206 2207 /* Create file */ 2208 fd = qemu_open(file_opts->filename, O_RDWR | O_CREAT | O_BINARY, 0644); 2209 if (fd < 0) { 2210 result = -errno; 2211 error_setg_errno(errp, -result, "Could not create file"); 2212 goto out; 2213 } 2214 2215 /* Take permissions: We want to discard everything, so we need 2216 * BLK_PERM_WRITE; and truncation to the desired size requires 2217 * BLK_PERM_RESIZE. 2218 * On the other hand, we cannot share the RESIZE permission 2219 * because we promise that after this function, the file has the 2220 * size given in the options. If someone else were to resize it 2221 * concurrently, we could not guarantee that. 2222 * Note that after this function, we can no longer guarantee that 2223 * the file is not touched by a third party, so it may be resized 2224 * then. */ 2225 perm = BLK_PERM_WRITE | BLK_PERM_RESIZE; 2226 shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE; 2227 2228 /* Step one: Take locks */ 2229 result = raw_apply_lock_bytes(fd, perm, ~shared, false, errp); 2230 if (result < 0) { 2231 goto out_close; 2232 } 2233 2234 /* Step two: Check that nobody else has taken conflicting locks */ 2235 result = raw_check_lock_bytes(fd, perm, shared, errp); 2236 if (result < 0) { 2237 error_append_hint(errp, 2238 "Is another process using the image [%s]?\n", 2239 file_opts->filename); 2240 goto out_unlock; 2241 } 2242 2243 /* Clear the file by truncating it to 0 */ 2244 result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp); 2245 if (result < 0) { 2246 goto out_unlock; 2247 } 2248 2249 if (file_opts->nocow) { 2250 #ifdef __linux__ 2251 /* Set NOCOW flag to solve performance issue on fs like btrfs. 2252 * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value 2253 * will be ignored since any failure of this operation should not 2254 * block the left work. 2255 */ 2256 int attr; 2257 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) { 2258 attr |= FS_NOCOW_FL; 2259 ioctl(fd, FS_IOC_SETFLAGS, &attr); 2260 } 2261 #endif 2262 } 2263 2264 /* Resize and potentially preallocate the file to the desired 2265 * final size */ 2266 result = raw_regular_truncate(NULL, fd, file_opts->size, 2267 file_opts->preallocation, errp); 2268 if (result < 0) { 2269 goto out_unlock; 2270 } 2271 2272 out_unlock: 2273 raw_apply_lock_bytes(fd, 0, 0, true, &local_err); 2274 if (local_err) { 2275 /* The above call should not fail, and if it does, that does 2276 * not mean the whole creation operation has failed. So 2277 * report it the user for their convenience, but do not report 2278 * it to the caller. */ 2279 error_report_err(local_err); 2280 } 2281 2282 out_close: 2283 if (qemu_close(fd) != 0 && result == 0) { 2284 result = -errno; 2285 error_setg_errno(errp, -result, "Could not close the new file"); 2286 } 2287 out: 2288 return result; 2289 } 2290 2291 static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts, 2292 Error **errp) 2293 { 2294 BlockdevCreateOptions options; 2295 int64_t total_size = 0; 2296 bool nocow = false; 2297 PreallocMode prealloc; 2298 char *buf = NULL; 2299 Error *local_err = NULL; 2300 2301 /* Skip file: protocol prefix */ 2302 strstart(filename, "file:", &filename); 2303 2304 /* Read out options */ 2305 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 2306 BDRV_SECTOR_SIZE); 2307 nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false); 2308 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC); 2309 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf, 2310 PREALLOC_MODE_OFF, &local_err); 2311 g_free(buf); 2312 if (local_err) { 2313 error_propagate(errp, local_err); 2314 return -EINVAL; 2315 } 2316 2317 options = (BlockdevCreateOptions) { 2318 .driver = BLOCKDEV_DRIVER_FILE, 2319 .u.file = { 2320 .filename = (char *) filename, 2321 .size = total_size, 2322 .has_preallocation = true, 2323 .preallocation = prealloc, 2324 .has_nocow = true, 2325 .nocow = nocow, 2326 }, 2327 }; 2328 return raw_co_create(&options, errp); 2329 } 2330 2331 /* 2332 * Find allocation range in @bs around offset @start. 2333 * May change underlying file descriptor's file offset. 2334 * If @start is not in a hole, store @start in @data, and the 2335 * beginning of the next hole in @hole, and return 0. 2336 * If @start is in a non-trailing hole, store @start in @hole and the 2337 * beginning of the next non-hole in @data, and return 0. 2338 * If @start is in a trailing hole or beyond EOF, return -ENXIO. 2339 * If we can't find out, return a negative errno other than -ENXIO. 2340 */ 2341 static int find_allocation(BlockDriverState *bs, off_t start, 2342 off_t *data, off_t *hole) 2343 { 2344 #if defined SEEK_HOLE && defined SEEK_DATA 2345 BDRVRawState *s = bs->opaque; 2346 off_t offs; 2347 2348 /* 2349 * SEEK_DATA cases: 2350 * D1. offs == start: start is in data 2351 * D2. offs > start: start is in a hole, next data at offs 2352 * D3. offs < 0, errno = ENXIO: either start is in a trailing hole 2353 * or start is beyond EOF 2354 * If the latter happens, the file has been truncated behind 2355 * our back since we opened it. All bets are off then. 2356 * Treating like a trailing hole is simplest. 2357 * D4. offs < 0, errno != ENXIO: we learned nothing 2358 */ 2359 offs = lseek(s->fd, start, SEEK_DATA); 2360 if (offs < 0) { 2361 return -errno; /* D3 or D4 */ 2362 } 2363 2364 if (offs < start) { 2365 /* This is not a valid return by lseek(). We are safe to just return 2366 * -EIO in this case, and we'll treat it like D4. */ 2367 return -EIO; 2368 } 2369 2370 if (offs > start) { 2371 /* D2: in hole, next data at offs */ 2372 *hole = start; 2373 *data = offs; 2374 return 0; 2375 } 2376 2377 /* D1: in data, end not yet known */ 2378 2379 /* 2380 * SEEK_HOLE cases: 2381 * H1. offs == start: start is in a hole 2382 * If this happens here, a hole has been dug behind our back 2383 * since the previous lseek(). 2384 * H2. offs > start: either start is in data, next hole at offs, 2385 * or start is in trailing hole, EOF at offs 2386 * Linux treats trailing holes like any other hole: offs == 2387 * start. Solaris seeks to EOF instead: offs > start (blech). 2388 * If that happens here, a hole has been dug behind our back 2389 * since the previous lseek(). 2390 * H3. offs < 0, errno = ENXIO: start is beyond EOF 2391 * If this happens, the file has been truncated behind our 2392 * back since we opened it. Treat it like a trailing hole. 2393 * H4. offs < 0, errno != ENXIO: we learned nothing 2394 * Pretend we know nothing at all, i.e. "forget" about D1. 2395 */ 2396 offs = lseek(s->fd, start, SEEK_HOLE); 2397 if (offs < 0) { 2398 return -errno; /* D1 and (H3 or H4) */ 2399 } 2400 2401 if (offs < start) { 2402 /* This is not a valid return by lseek(). We are safe to just return 2403 * -EIO in this case, and we'll treat it like H4. */ 2404 return -EIO; 2405 } 2406 2407 if (offs > start) { 2408 /* 2409 * D1 and H2: either in data, next hole at offs, or it was in 2410 * data but is now in a trailing hole. In the latter case, 2411 * all bets are off. Treating it as if it there was data all 2412 * the way to EOF is safe, so simply do that. 2413 */ 2414 *data = start; 2415 *hole = offs; 2416 return 0; 2417 } 2418 2419 /* D1 and H1 */ 2420 return -EBUSY; 2421 #else 2422 return -ENOTSUP; 2423 #endif 2424 } 2425 2426 /* 2427 * Returns the allocation status of the specified offset. 2428 * 2429 * The block layer guarantees 'offset' and 'bytes' are within bounds. 2430 * 2431 * 'pnum' is set to the number of bytes (including and immediately following 2432 * the specified offset) that are known to be in the same 2433 * allocated/unallocated state. 2434 * 2435 * 'bytes' is the max value 'pnum' should be set to. 2436 */ 2437 static int coroutine_fn raw_co_block_status(BlockDriverState *bs, 2438 bool want_zero, 2439 int64_t offset, 2440 int64_t bytes, int64_t *pnum, 2441 int64_t *map, 2442 BlockDriverState **file) 2443 { 2444 off_t data = 0, hole = 0; 2445 int ret; 2446 2447 ret = fd_open(bs); 2448 if (ret < 0) { 2449 return ret; 2450 } 2451 2452 if (!want_zero) { 2453 *pnum = bytes; 2454 *map = offset; 2455 *file = bs; 2456 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID; 2457 } 2458 2459 ret = find_allocation(bs, offset, &data, &hole); 2460 if (ret == -ENXIO) { 2461 /* Trailing hole */ 2462 *pnum = bytes; 2463 ret = BDRV_BLOCK_ZERO; 2464 } else if (ret < 0) { 2465 /* No info available, so pretend there are no holes */ 2466 *pnum = bytes; 2467 ret = BDRV_BLOCK_DATA; 2468 } else if (data == offset) { 2469 /* On a data extent, compute bytes to the end of the extent, 2470 * possibly including a partial sector at EOF. */ 2471 *pnum = MIN(bytes, hole - offset); 2472 ret = BDRV_BLOCK_DATA; 2473 } else { 2474 /* On a hole, compute bytes to the beginning of the next extent. */ 2475 assert(hole == offset); 2476 *pnum = MIN(bytes, data - offset); 2477 ret = BDRV_BLOCK_ZERO; 2478 } 2479 *map = offset; 2480 *file = bs; 2481 return ret | BDRV_BLOCK_OFFSET_VALID; 2482 } 2483 2484 #if defined(__linux__) 2485 /* Verify that the file is not in the page cache */ 2486 static void check_cache_dropped(BlockDriverState *bs, Error **errp) 2487 { 2488 const size_t window_size = 128 * 1024 * 1024; 2489 BDRVRawState *s = bs->opaque; 2490 void *window = NULL; 2491 size_t length = 0; 2492 unsigned char *vec; 2493 size_t page_size; 2494 off_t offset; 2495 off_t end; 2496 2497 /* mincore(2) page status information requires 1 byte per page */ 2498 page_size = sysconf(_SC_PAGESIZE); 2499 vec = g_malloc(DIV_ROUND_UP(window_size, page_size)); 2500 2501 end = raw_getlength(bs); 2502 2503 for (offset = 0; offset < end; offset += window_size) { 2504 void *new_window; 2505 size_t new_length; 2506 size_t vec_end; 2507 size_t i; 2508 int ret; 2509 2510 /* Unmap previous window if size has changed */ 2511 new_length = MIN(end - offset, window_size); 2512 if (new_length != length) { 2513 munmap(window, length); 2514 window = NULL; 2515 length = 0; 2516 } 2517 2518 new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE, 2519 s->fd, offset); 2520 if (new_window == MAP_FAILED) { 2521 error_setg_errno(errp, errno, "mmap failed"); 2522 break; 2523 } 2524 2525 window = new_window; 2526 length = new_length; 2527 2528 ret = mincore(window, length, vec); 2529 if (ret < 0) { 2530 error_setg_errno(errp, errno, "mincore failed"); 2531 break; 2532 } 2533 2534 vec_end = DIV_ROUND_UP(length, page_size); 2535 for (i = 0; i < vec_end; i++) { 2536 if (vec[i] & 0x1) { 2537 error_setg(errp, "page cache still in use!"); 2538 break; 2539 } 2540 } 2541 } 2542 2543 if (window) { 2544 munmap(window, length); 2545 } 2546 2547 g_free(vec); 2548 } 2549 #endif /* __linux__ */ 2550 2551 static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs, 2552 Error **errp) 2553 { 2554 BDRVRawState *s = bs->opaque; 2555 int ret; 2556 2557 ret = fd_open(bs); 2558 if (ret < 0) { 2559 error_setg_errno(errp, -ret, "The file descriptor is not open"); 2560 return; 2561 } 2562 2563 if (s->open_flags & O_DIRECT) { 2564 return; /* No host kernel page cache */ 2565 } 2566 2567 #if defined(__linux__) 2568 /* This sets the scene for the next syscall... */ 2569 ret = bdrv_co_flush(bs); 2570 if (ret < 0) { 2571 error_setg_errno(errp, -ret, "flush failed"); 2572 return; 2573 } 2574 2575 /* Linux does not invalidate pages that are dirty, locked, or mmapped by a 2576 * process. These limitations are okay because we just fsynced the file, 2577 * we don't use mmap, and the file should not be in use by other processes. 2578 */ 2579 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED); 2580 if (ret != 0) { /* the return value is a positive errno */ 2581 error_setg_errno(errp, ret, "fadvise failed"); 2582 return; 2583 } 2584 2585 if (s->check_cache_dropped) { 2586 check_cache_dropped(bs, errp); 2587 } 2588 #else /* __linux__ */ 2589 /* Do nothing. Live migration to a remote host with cache.direct=off is 2590 * unsupported on other host operating systems. Cache consistency issues 2591 * may occur but no error is reported here, partly because that's the 2592 * historical behavior and partly because it's hard to differentiate valid 2593 * configurations that should not cause errors. 2594 */ 2595 #endif /* !__linux__ */ 2596 } 2597 2598 static coroutine_fn int 2599 raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes) 2600 { 2601 BDRVRawState *s = bs->opaque; 2602 2603 return paio_submit_co(bs, s->fd, offset, NULL, bytes, QEMU_AIO_DISCARD); 2604 } 2605 2606 static int coroutine_fn raw_co_pwrite_zeroes( 2607 BlockDriverState *bs, int64_t offset, 2608 int bytes, BdrvRequestFlags flags) 2609 { 2610 BDRVRawState *s = bs->opaque; 2611 int operation = QEMU_AIO_WRITE_ZEROES; 2612 2613 if (flags & BDRV_REQ_MAY_UNMAP) { 2614 operation |= QEMU_AIO_DISCARD; 2615 } 2616 2617 return paio_submit_co(bs, s->fd, offset, NULL, bytes, operation); 2618 } 2619 2620 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 2621 { 2622 BDRVRawState *s = bs->opaque; 2623 2624 bdi->unallocated_blocks_are_zero = s->discard_zeroes; 2625 return 0; 2626 } 2627 2628 static QemuOptsList raw_create_opts = { 2629 .name = "raw-create-opts", 2630 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head), 2631 .desc = { 2632 { 2633 .name = BLOCK_OPT_SIZE, 2634 .type = QEMU_OPT_SIZE, 2635 .help = "Virtual disk size" 2636 }, 2637 { 2638 .name = BLOCK_OPT_NOCOW, 2639 .type = QEMU_OPT_BOOL, 2640 .help = "Turn off copy-on-write (valid only on btrfs)" 2641 }, 2642 { 2643 .name = BLOCK_OPT_PREALLOC, 2644 .type = QEMU_OPT_STRING, 2645 .help = "Preallocation mode (allowed values: off, falloc, full)" 2646 }, 2647 { /* end of list */ } 2648 } 2649 }; 2650 2651 static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared, 2652 Error **errp) 2653 { 2654 return raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp); 2655 } 2656 2657 static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared) 2658 { 2659 BDRVRawState *s = bs->opaque; 2660 raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL); 2661 s->perm = perm; 2662 s->shared_perm = shared; 2663 } 2664 2665 static void raw_abort_perm_update(BlockDriverState *bs) 2666 { 2667 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL); 2668 } 2669 2670 static int coroutine_fn raw_co_copy_range_from( 2671 BlockDriverState *bs, BdrvChild *src, uint64_t src_offset, 2672 BdrvChild *dst, uint64_t dst_offset, uint64_t bytes, 2673 BdrvRequestFlags read_flags, BdrvRequestFlags write_flags) 2674 { 2675 return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes, 2676 read_flags, write_flags); 2677 } 2678 2679 static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs, 2680 BdrvChild *src, 2681 uint64_t src_offset, 2682 BdrvChild *dst, 2683 uint64_t dst_offset, 2684 uint64_t bytes, 2685 BdrvRequestFlags read_flags, 2686 BdrvRequestFlags write_flags) 2687 { 2688 BDRVRawState *s = bs->opaque; 2689 BDRVRawState *src_s; 2690 2691 assert(dst->bs == bs); 2692 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) { 2693 return -ENOTSUP; 2694 } 2695 2696 src_s = src->bs->opaque; 2697 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) { 2698 return -EIO; 2699 } 2700 return paio_submit_co_full(bs, src_s->fd, src_offset, s->fd, dst_offset, 2701 NULL, bytes, QEMU_AIO_COPY_RANGE); 2702 } 2703 2704 BlockDriver bdrv_file = { 2705 .format_name = "file", 2706 .protocol_name = "file", 2707 .instance_size = sizeof(BDRVRawState), 2708 .bdrv_needs_filename = true, 2709 .bdrv_probe = NULL, /* no probe for protocols */ 2710 .bdrv_parse_filename = raw_parse_filename, 2711 .bdrv_file_open = raw_open, 2712 .bdrv_reopen_prepare = raw_reopen_prepare, 2713 .bdrv_reopen_commit = raw_reopen_commit, 2714 .bdrv_reopen_abort = raw_reopen_abort, 2715 .bdrv_close = raw_close, 2716 .bdrv_co_create = raw_co_create, 2717 .bdrv_co_create_opts = raw_co_create_opts, 2718 .bdrv_has_zero_init = bdrv_has_zero_init_1, 2719 .bdrv_co_block_status = raw_co_block_status, 2720 .bdrv_co_invalidate_cache = raw_co_invalidate_cache, 2721 .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes, 2722 2723 .bdrv_co_preadv = raw_co_preadv, 2724 .bdrv_co_pwritev = raw_co_pwritev, 2725 .bdrv_co_flush_to_disk = raw_co_flush_to_disk, 2726 .bdrv_co_pdiscard = raw_co_pdiscard, 2727 .bdrv_co_copy_range_from = raw_co_copy_range_from, 2728 .bdrv_co_copy_range_to = raw_co_copy_range_to, 2729 .bdrv_refresh_limits = raw_refresh_limits, 2730 .bdrv_io_plug = raw_aio_plug, 2731 .bdrv_io_unplug = raw_aio_unplug, 2732 .bdrv_attach_aio_context = raw_aio_attach_aio_context, 2733 2734 .bdrv_co_truncate = raw_co_truncate, 2735 .bdrv_getlength = raw_getlength, 2736 .bdrv_get_info = raw_get_info, 2737 .bdrv_get_allocated_file_size 2738 = raw_get_allocated_file_size, 2739 .bdrv_check_perm = raw_check_perm, 2740 .bdrv_set_perm = raw_set_perm, 2741 .bdrv_abort_perm_update = raw_abort_perm_update, 2742 .create_opts = &raw_create_opts, 2743 }; 2744 2745 /***********************************************/ 2746 /* host device */ 2747 2748 #if defined(__APPLE__) && defined(__MACH__) 2749 static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath, 2750 CFIndex maxPathSize, int flags); 2751 static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator) 2752 { 2753 kern_return_t kernResult = KERN_FAILURE; 2754 mach_port_t masterPort; 2755 CFMutableDictionaryRef classesToMatch; 2756 const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass}; 2757 char *mediaType = NULL; 2758 2759 kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort ); 2760 if ( KERN_SUCCESS != kernResult ) { 2761 printf( "IOMasterPort returned %d\n", kernResult ); 2762 } 2763 2764 int index; 2765 for (index = 0; index < ARRAY_SIZE(matching_array); index++) { 2766 classesToMatch = IOServiceMatching(matching_array[index]); 2767 if (classesToMatch == NULL) { 2768 error_report("IOServiceMatching returned NULL for %s", 2769 matching_array[index]); 2770 continue; 2771 } 2772 CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey), 2773 kCFBooleanTrue); 2774 kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch, 2775 mediaIterator); 2776 if (kernResult != KERN_SUCCESS) { 2777 error_report("Note: IOServiceGetMatchingServices returned %d", 2778 kernResult); 2779 continue; 2780 } 2781 2782 /* If a match was found, leave the loop */ 2783 if (*mediaIterator != 0) { 2784 DPRINTF("Matching using %s\n", matching_array[index]); 2785 mediaType = g_strdup(matching_array[index]); 2786 break; 2787 } 2788 } 2789 return mediaType; 2790 } 2791 2792 kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath, 2793 CFIndex maxPathSize, int flags) 2794 { 2795 io_object_t nextMedia; 2796 kern_return_t kernResult = KERN_FAILURE; 2797 *bsdPath = '\0'; 2798 nextMedia = IOIteratorNext( mediaIterator ); 2799 if ( nextMedia ) 2800 { 2801 CFTypeRef bsdPathAsCFString; 2802 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 ); 2803 if ( bsdPathAsCFString ) { 2804 size_t devPathLength; 2805 strcpy( bsdPath, _PATH_DEV ); 2806 if (flags & BDRV_O_NOCACHE) { 2807 strcat(bsdPath, "r"); 2808 } 2809 devPathLength = strlen( bsdPath ); 2810 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) { 2811 kernResult = KERN_SUCCESS; 2812 } 2813 CFRelease( bsdPathAsCFString ); 2814 } 2815 IOObjectRelease( nextMedia ); 2816 } 2817 2818 return kernResult; 2819 } 2820 2821 /* Sets up a real cdrom for use in QEMU */ 2822 static bool setup_cdrom(char *bsd_path, Error **errp) 2823 { 2824 int index, num_of_test_partitions = 2, fd; 2825 char test_partition[MAXPATHLEN]; 2826 bool partition_found = false; 2827 2828 /* look for a working partition */ 2829 for (index = 0; index < num_of_test_partitions; index++) { 2830 snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path, 2831 index); 2832 fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE); 2833 if (fd >= 0) { 2834 partition_found = true; 2835 qemu_close(fd); 2836 break; 2837 } 2838 } 2839 2840 /* if a working partition on the device was not found */ 2841 if (partition_found == false) { 2842 error_setg(errp, "Failed to find a working partition on disc"); 2843 } else { 2844 DPRINTF("Using %s as optical disc\n", test_partition); 2845 pstrcpy(bsd_path, MAXPATHLEN, test_partition); 2846 } 2847 return partition_found; 2848 } 2849 2850 /* Prints directions on mounting and unmounting a device */ 2851 static void print_unmounting_directions(const char *file_name) 2852 { 2853 error_report("If device %s is mounted on the desktop, unmount" 2854 " it first before using it in QEMU", file_name); 2855 error_report("Command to unmount device: diskutil unmountDisk %s", 2856 file_name); 2857 error_report("Command to mount device: diskutil mountDisk %s", file_name); 2858 } 2859 2860 #endif /* defined(__APPLE__) && defined(__MACH__) */ 2861 2862 static int hdev_probe_device(const char *filename) 2863 { 2864 struct stat st; 2865 2866 /* allow a dedicated CD-ROM driver to match with a higher priority */ 2867 if (strstart(filename, "/dev/cdrom", NULL)) 2868 return 50; 2869 2870 if (stat(filename, &st) >= 0 && 2871 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) { 2872 return 100; 2873 } 2874 2875 return 0; 2876 } 2877 2878 static int check_hdev_writable(BDRVRawState *s) 2879 { 2880 #if defined(BLKROGET) 2881 /* Linux block devices can be configured "read-only" using blockdev(8). 2882 * This is independent of device node permissions and therefore open(2) 2883 * with O_RDWR succeeds. Actual writes fail with EPERM. 2884 * 2885 * bdrv_open() is supposed to fail if the disk is read-only. Explicitly 2886 * check for read-only block devices so that Linux block devices behave 2887 * properly. 2888 */ 2889 struct stat st; 2890 int readonly = 0; 2891 2892 if (fstat(s->fd, &st)) { 2893 return -errno; 2894 } 2895 2896 if (!S_ISBLK(st.st_mode)) { 2897 return 0; 2898 } 2899 2900 if (ioctl(s->fd, BLKROGET, &readonly) < 0) { 2901 return -errno; 2902 } 2903 2904 if (readonly) { 2905 return -EACCES; 2906 } 2907 #endif /* defined(BLKROGET) */ 2908 return 0; 2909 } 2910 2911 static void hdev_parse_filename(const char *filename, QDict *options, 2912 Error **errp) 2913 { 2914 bdrv_parse_filename_strip_prefix(filename, "host_device:", options); 2915 } 2916 2917 static bool hdev_is_sg(BlockDriverState *bs) 2918 { 2919 2920 #if defined(__linux__) 2921 2922 BDRVRawState *s = bs->opaque; 2923 struct stat st; 2924 struct sg_scsi_id scsiid; 2925 int sg_version; 2926 int ret; 2927 2928 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) { 2929 return false; 2930 } 2931 2932 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version); 2933 if (ret < 0) { 2934 return false; 2935 } 2936 2937 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid); 2938 if (ret >= 0) { 2939 DPRINTF("SG device found: type=%d, version=%d\n", 2940 scsiid.scsi_type, sg_version); 2941 return true; 2942 } 2943 2944 #endif 2945 2946 return false; 2947 } 2948 2949 static int hdev_open(BlockDriverState *bs, QDict *options, int flags, 2950 Error **errp) 2951 { 2952 BDRVRawState *s = bs->opaque; 2953 Error *local_err = NULL; 2954 int ret; 2955 2956 #if defined(__APPLE__) && defined(__MACH__) 2957 /* 2958 * Caution: while qdict_get_str() is fine, getting non-string types 2959 * would require more care. When @options come from -blockdev or 2960 * blockdev_add, its members are typed according to the QAPI 2961 * schema, but when they come from -drive, they're all QString. 2962 */ 2963 const char *filename = qdict_get_str(options, "filename"); 2964 char bsd_path[MAXPATHLEN] = ""; 2965 bool error_occurred = false; 2966 2967 /* If using a real cdrom */ 2968 if (strcmp(filename, "/dev/cdrom") == 0) { 2969 char *mediaType = NULL; 2970 kern_return_t ret_val; 2971 io_iterator_t mediaIterator = 0; 2972 2973 mediaType = FindEjectableOpticalMedia(&mediaIterator); 2974 if (mediaType == NULL) { 2975 error_setg(errp, "Please make sure your CD/DVD is in the optical" 2976 " drive"); 2977 error_occurred = true; 2978 goto hdev_open_Mac_error; 2979 } 2980 2981 ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags); 2982 if (ret_val != KERN_SUCCESS) { 2983 error_setg(errp, "Could not get BSD path for optical drive"); 2984 error_occurred = true; 2985 goto hdev_open_Mac_error; 2986 } 2987 2988 /* If a real optical drive was not found */ 2989 if (bsd_path[0] == '\0') { 2990 error_setg(errp, "Failed to obtain bsd path for optical drive"); 2991 error_occurred = true; 2992 goto hdev_open_Mac_error; 2993 } 2994 2995 /* If using a cdrom disc and finding a partition on the disc failed */ 2996 if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 && 2997 setup_cdrom(bsd_path, errp) == false) { 2998 print_unmounting_directions(bsd_path); 2999 error_occurred = true; 3000 goto hdev_open_Mac_error; 3001 } 3002 3003 qdict_put_str(options, "filename", bsd_path); 3004 3005 hdev_open_Mac_error: 3006 g_free(mediaType); 3007 if (mediaIterator) { 3008 IOObjectRelease(mediaIterator); 3009 } 3010 if (error_occurred) { 3011 return -ENOENT; 3012 } 3013 } 3014 #endif /* defined(__APPLE__) && defined(__MACH__) */ 3015 3016 s->type = FTYPE_FILE; 3017 3018 ret = raw_open_common(bs, options, flags, 0, true, &local_err); 3019 if (ret < 0) { 3020 error_propagate(errp, local_err); 3021 #if defined(__APPLE__) && defined(__MACH__) 3022 if (*bsd_path) { 3023 filename = bsd_path; 3024 } 3025 /* if a physical device experienced an error while being opened */ 3026 if (strncmp(filename, "/dev/", 5) == 0) { 3027 print_unmounting_directions(filename); 3028 } 3029 #endif /* defined(__APPLE__) && defined(__MACH__) */ 3030 return ret; 3031 } 3032 3033 /* Since this does ioctl the device must be already opened */ 3034 bs->sg = hdev_is_sg(bs); 3035 3036 if (flags & BDRV_O_RDWR) { 3037 ret = check_hdev_writable(s); 3038 if (ret < 0) { 3039 raw_close(bs); 3040 error_setg_errno(errp, -ret, "The device is not writable"); 3041 return ret; 3042 } 3043 } 3044 3045 return ret; 3046 } 3047 3048 #if defined(__linux__) 3049 3050 static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs, 3051 unsigned long int req, void *buf, 3052 BlockCompletionFunc *cb, void *opaque) 3053 { 3054 BDRVRawState *s = bs->opaque; 3055 RawPosixAIOData *acb; 3056 ThreadPool *pool; 3057 3058 if (fd_open(bs) < 0) 3059 return NULL; 3060 3061 if (req == SG_IO && s->pr_mgr) { 3062 struct sg_io_hdr *io_hdr = buf; 3063 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT || 3064 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) { 3065 return pr_manager_execute(s->pr_mgr, bdrv_get_aio_context(bs), 3066 s->fd, io_hdr, cb, opaque); 3067 } 3068 } 3069 3070 acb = g_new(RawPosixAIOData, 1); 3071 acb->bs = bs; 3072 acb->aio_type = QEMU_AIO_IOCTL; 3073 acb->aio_fildes = s->fd; 3074 acb->aio_offset = 0; 3075 acb->aio_ioctl_buf = buf; 3076 acb->aio_ioctl_cmd = req; 3077 pool = aio_get_thread_pool(bdrv_get_aio_context(bs)); 3078 return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque); 3079 } 3080 #endif /* linux */ 3081 3082 static int fd_open(BlockDriverState *bs) 3083 { 3084 BDRVRawState *s = bs->opaque; 3085 3086 /* this is just to ensure s->fd is sane (its called by io ops) */ 3087 if (s->fd >= 0) 3088 return 0; 3089 return -EIO; 3090 } 3091 3092 static coroutine_fn int 3093 hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes) 3094 { 3095 BDRVRawState *s = bs->opaque; 3096 int ret; 3097 3098 ret = fd_open(bs); 3099 if (ret < 0) { 3100 return ret; 3101 } 3102 return paio_submit_co(bs, s->fd, offset, NULL, bytes, 3103 QEMU_AIO_DISCARD | QEMU_AIO_BLKDEV); 3104 } 3105 3106 static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs, 3107 int64_t offset, int bytes, BdrvRequestFlags flags) 3108 { 3109 BDRVRawState *s = bs->opaque; 3110 int operation = QEMU_AIO_WRITE_ZEROES | QEMU_AIO_BLKDEV; 3111 int rc; 3112 3113 rc = fd_open(bs); 3114 if (rc < 0) { 3115 return rc; 3116 } 3117 3118 if (flags & BDRV_REQ_MAY_UNMAP) { 3119 operation |= QEMU_AIO_DISCARD; 3120 } 3121 3122 return paio_submit_co(bs, s->fd, offset, NULL, bytes, operation); 3123 } 3124 3125 static int coroutine_fn hdev_co_create_opts(const char *filename, QemuOpts *opts, 3126 Error **errp) 3127 { 3128 int fd; 3129 int ret = 0; 3130 struct stat stat_buf; 3131 int64_t total_size = 0; 3132 bool has_prefix; 3133 3134 /* This function is used by both protocol block drivers and therefore either 3135 * of these prefixes may be given. 3136 * The return value has to be stored somewhere, otherwise this is an error 3137 * due to -Werror=unused-value. */ 3138 has_prefix = 3139 strstart(filename, "host_device:", &filename) || 3140 strstart(filename, "host_cdrom:" , &filename); 3141 3142 (void)has_prefix; 3143 3144 ret = raw_normalize_devicepath(&filename); 3145 if (ret < 0) { 3146 error_setg_errno(errp, -ret, "Could not normalize device path"); 3147 return ret; 3148 } 3149 3150 /* Read out options */ 3151 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 3152 BDRV_SECTOR_SIZE); 3153 3154 fd = qemu_open(filename, O_WRONLY | O_BINARY); 3155 if (fd < 0) { 3156 ret = -errno; 3157 error_setg_errno(errp, -ret, "Could not open device"); 3158 return ret; 3159 } 3160 3161 if (fstat(fd, &stat_buf) < 0) { 3162 ret = -errno; 3163 error_setg_errno(errp, -ret, "Could not stat device"); 3164 } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) { 3165 error_setg(errp, 3166 "The given file is neither a block nor a character device"); 3167 ret = -ENODEV; 3168 } else if (lseek(fd, 0, SEEK_END) < total_size) { 3169 error_setg(errp, "Device is too small"); 3170 ret = -ENOSPC; 3171 } 3172 3173 if (!ret && total_size) { 3174 uint8_t buf[BDRV_SECTOR_SIZE] = { 0 }; 3175 int64_t zero_size = MIN(BDRV_SECTOR_SIZE, total_size); 3176 if (lseek(fd, 0, SEEK_SET) == -1) { 3177 ret = -errno; 3178 } else { 3179 ret = qemu_write_full(fd, buf, zero_size); 3180 ret = ret == zero_size ? 0 : -errno; 3181 } 3182 } 3183 qemu_close(fd); 3184 return ret; 3185 } 3186 3187 static BlockDriver bdrv_host_device = { 3188 .format_name = "host_device", 3189 .protocol_name = "host_device", 3190 .instance_size = sizeof(BDRVRawState), 3191 .bdrv_needs_filename = true, 3192 .bdrv_probe_device = hdev_probe_device, 3193 .bdrv_parse_filename = hdev_parse_filename, 3194 .bdrv_file_open = hdev_open, 3195 .bdrv_close = raw_close, 3196 .bdrv_reopen_prepare = raw_reopen_prepare, 3197 .bdrv_reopen_commit = raw_reopen_commit, 3198 .bdrv_reopen_abort = raw_reopen_abort, 3199 .bdrv_co_create_opts = hdev_co_create_opts, 3200 .create_opts = &raw_create_opts, 3201 .bdrv_co_invalidate_cache = raw_co_invalidate_cache, 3202 .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes, 3203 3204 .bdrv_co_preadv = raw_co_preadv, 3205 .bdrv_co_pwritev = raw_co_pwritev, 3206 .bdrv_co_flush_to_disk = raw_co_flush_to_disk, 3207 .bdrv_co_pdiscard = hdev_co_pdiscard, 3208 .bdrv_co_copy_range_from = raw_co_copy_range_from, 3209 .bdrv_co_copy_range_to = raw_co_copy_range_to, 3210 .bdrv_refresh_limits = raw_refresh_limits, 3211 .bdrv_io_plug = raw_aio_plug, 3212 .bdrv_io_unplug = raw_aio_unplug, 3213 .bdrv_attach_aio_context = raw_aio_attach_aio_context, 3214 3215 .bdrv_co_truncate = raw_co_truncate, 3216 .bdrv_getlength = raw_getlength, 3217 .bdrv_get_info = raw_get_info, 3218 .bdrv_get_allocated_file_size 3219 = raw_get_allocated_file_size, 3220 .bdrv_check_perm = raw_check_perm, 3221 .bdrv_set_perm = raw_set_perm, 3222 .bdrv_abort_perm_update = raw_abort_perm_update, 3223 .bdrv_probe_blocksizes = hdev_probe_blocksizes, 3224 .bdrv_probe_geometry = hdev_probe_geometry, 3225 3226 /* generic scsi device */ 3227 #ifdef __linux__ 3228 .bdrv_aio_ioctl = hdev_aio_ioctl, 3229 #endif 3230 }; 3231 3232 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 3233 static void cdrom_parse_filename(const char *filename, QDict *options, 3234 Error **errp) 3235 { 3236 bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options); 3237 } 3238 #endif 3239 3240 #ifdef __linux__ 3241 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags, 3242 Error **errp) 3243 { 3244 BDRVRawState *s = bs->opaque; 3245 3246 s->type = FTYPE_CD; 3247 3248 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */ 3249 return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp); 3250 } 3251 3252 static int cdrom_probe_device(const char *filename) 3253 { 3254 int fd, ret; 3255 int prio = 0; 3256 struct stat st; 3257 3258 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK); 3259 if (fd < 0) { 3260 goto out; 3261 } 3262 ret = fstat(fd, &st); 3263 if (ret == -1 || !S_ISBLK(st.st_mode)) { 3264 goto outc; 3265 } 3266 3267 /* Attempt to detect via a CDROM specific ioctl */ 3268 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT); 3269 if (ret >= 0) 3270 prio = 100; 3271 3272 outc: 3273 qemu_close(fd); 3274 out: 3275 return prio; 3276 } 3277 3278 static bool cdrom_is_inserted(BlockDriverState *bs) 3279 { 3280 BDRVRawState *s = bs->opaque; 3281 int ret; 3282 3283 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT); 3284 return ret == CDS_DISC_OK; 3285 } 3286 3287 static void cdrom_eject(BlockDriverState *bs, bool eject_flag) 3288 { 3289 BDRVRawState *s = bs->opaque; 3290 3291 if (eject_flag) { 3292 if (ioctl(s->fd, CDROMEJECT, NULL) < 0) 3293 perror("CDROMEJECT"); 3294 } else { 3295 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0) 3296 perror("CDROMEJECT"); 3297 } 3298 } 3299 3300 static void cdrom_lock_medium(BlockDriverState *bs, bool locked) 3301 { 3302 BDRVRawState *s = bs->opaque; 3303 3304 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) { 3305 /* 3306 * Note: an error can happen if the distribution automatically 3307 * mounts the CD-ROM 3308 */ 3309 /* perror("CDROM_LOCKDOOR"); */ 3310 } 3311 } 3312 3313 static BlockDriver bdrv_host_cdrom = { 3314 .format_name = "host_cdrom", 3315 .protocol_name = "host_cdrom", 3316 .instance_size = sizeof(BDRVRawState), 3317 .bdrv_needs_filename = true, 3318 .bdrv_probe_device = cdrom_probe_device, 3319 .bdrv_parse_filename = cdrom_parse_filename, 3320 .bdrv_file_open = cdrom_open, 3321 .bdrv_close = raw_close, 3322 .bdrv_reopen_prepare = raw_reopen_prepare, 3323 .bdrv_reopen_commit = raw_reopen_commit, 3324 .bdrv_reopen_abort = raw_reopen_abort, 3325 .bdrv_co_create_opts = hdev_co_create_opts, 3326 .create_opts = &raw_create_opts, 3327 .bdrv_co_invalidate_cache = raw_co_invalidate_cache, 3328 3329 3330 .bdrv_co_preadv = raw_co_preadv, 3331 .bdrv_co_pwritev = raw_co_pwritev, 3332 .bdrv_co_flush_to_disk = raw_co_flush_to_disk, 3333 .bdrv_refresh_limits = raw_refresh_limits, 3334 .bdrv_io_plug = raw_aio_plug, 3335 .bdrv_io_unplug = raw_aio_unplug, 3336 .bdrv_attach_aio_context = raw_aio_attach_aio_context, 3337 3338 .bdrv_co_truncate = raw_co_truncate, 3339 .bdrv_getlength = raw_getlength, 3340 .has_variable_length = true, 3341 .bdrv_get_allocated_file_size 3342 = raw_get_allocated_file_size, 3343 3344 /* removable device support */ 3345 .bdrv_is_inserted = cdrom_is_inserted, 3346 .bdrv_eject = cdrom_eject, 3347 .bdrv_lock_medium = cdrom_lock_medium, 3348 3349 /* generic scsi device */ 3350 .bdrv_aio_ioctl = hdev_aio_ioctl, 3351 }; 3352 #endif /* __linux__ */ 3353 3354 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__) 3355 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags, 3356 Error **errp) 3357 { 3358 BDRVRawState *s = bs->opaque; 3359 Error *local_err = NULL; 3360 int ret; 3361 3362 s->type = FTYPE_CD; 3363 3364 ret = raw_open_common(bs, options, flags, 0, true, &local_err); 3365 if (ret) { 3366 error_propagate(errp, local_err); 3367 return ret; 3368 } 3369 3370 /* make sure the door isn't locked at this time */ 3371 ioctl(s->fd, CDIOCALLOW); 3372 return 0; 3373 } 3374 3375 static int cdrom_probe_device(const char *filename) 3376 { 3377 if (strstart(filename, "/dev/cd", NULL) || 3378 strstart(filename, "/dev/acd", NULL)) 3379 return 100; 3380 return 0; 3381 } 3382 3383 static int cdrom_reopen(BlockDriverState *bs) 3384 { 3385 BDRVRawState *s = bs->opaque; 3386 int fd; 3387 3388 /* 3389 * Force reread of possibly changed/newly loaded disc, 3390 * FreeBSD seems to not notice sometimes... 3391 */ 3392 if (s->fd >= 0) 3393 qemu_close(s->fd); 3394 fd = qemu_open(bs->filename, s->open_flags, 0644); 3395 if (fd < 0) { 3396 s->fd = -1; 3397 return -EIO; 3398 } 3399 s->fd = fd; 3400 3401 /* make sure the door isn't locked at this time */ 3402 ioctl(s->fd, CDIOCALLOW); 3403 return 0; 3404 } 3405 3406 static bool cdrom_is_inserted(BlockDriverState *bs) 3407 { 3408 return raw_getlength(bs) > 0; 3409 } 3410 3411 static void cdrom_eject(BlockDriverState *bs, bool eject_flag) 3412 { 3413 BDRVRawState *s = bs->opaque; 3414 3415 if (s->fd < 0) 3416 return; 3417 3418 (void) ioctl(s->fd, CDIOCALLOW); 3419 3420 if (eject_flag) { 3421 if (ioctl(s->fd, CDIOCEJECT) < 0) 3422 perror("CDIOCEJECT"); 3423 } else { 3424 if (ioctl(s->fd, CDIOCCLOSE) < 0) 3425 perror("CDIOCCLOSE"); 3426 } 3427 3428 cdrom_reopen(bs); 3429 } 3430 3431 static void cdrom_lock_medium(BlockDriverState *bs, bool locked) 3432 { 3433 BDRVRawState *s = bs->opaque; 3434 3435 if (s->fd < 0) 3436 return; 3437 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) { 3438 /* 3439 * Note: an error can happen if the distribution automatically 3440 * mounts the CD-ROM 3441 */ 3442 /* perror("CDROM_LOCKDOOR"); */ 3443 } 3444 } 3445 3446 static BlockDriver bdrv_host_cdrom = { 3447 .format_name = "host_cdrom", 3448 .protocol_name = "host_cdrom", 3449 .instance_size = sizeof(BDRVRawState), 3450 .bdrv_needs_filename = true, 3451 .bdrv_probe_device = cdrom_probe_device, 3452 .bdrv_parse_filename = cdrom_parse_filename, 3453 .bdrv_file_open = cdrom_open, 3454 .bdrv_close = raw_close, 3455 .bdrv_reopen_prepare = raw_reopen_prepare, 3456 .bdrv_reopen_commit = raw_reopen_commit, 3457 .bdrv_reopen_abort = raw_reopen_abort, 3458 .bdrv_co_create_opts = hdev_co_create_opts, 3459 .create_opts = &raw_create_opts, 3460 3461 .bdrv_co_preadv = raw_co_preadv, 3462 .bdrv_co_pwritev = raw_co_pwritev, 3463 .bdrv_co_flush_to_disk = raw_co_flush_to_disk, 3464 .bdrv_refresh_limits = raw_refresh_limits, 3465 .bdrv_io_plug = raw_aio_plug, 3466 .bdrv_io_unplug = raw_aio_unplug, 3467 .bdrv_attach_aio_context = raw_aio_attach_aio_context, 3468 3469 .bdrv_co_truncate = raw_co_truncate, 3470 .bdrv_getlength = raw_getlength, 3471 .has_variable_length = true, 3472 .bdrv_get_allocated_file_size 3473 = raw_get_allocated_file_size, 3474 3475 /* removable device support */ 3476 .bdrv_is_inserted = cdrom_is_inserted, 3477 .bdrv_eject = cdrom_eject, 3478 .bdrv_lock_medium = cdrom_lock_medium, 3479 }; 3480 #endif /* __FreeBSD__ */ 3481 3482 static void bdrv_file_init(void) 3483 { 3484 /* 3485 * Register all the drivers. Note that order is important, the driver 3486 * registered last will get probed first. 3487 */ 3488 bdrv_register(&bdrv_file); 3489 bdrv_register(&bdrv_host_device); 3490 #ifdef __linux__ 3491 bdrv_register(&bdrv_host_cdrom); 3492 #endif 3493 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 3494 bdrv_register(&bdrv_host_cdrom); 3495 #endif 3496 } 3497 3498 block_init(bdrv_file_init); 3499