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