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