2 * Block driver for RAW files (posix)
4 * Copyright (c) 2006 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu/cutils.h"
28 #include "qemu/error-report.h"
29 #include "block/block_int.h"
30 #include "qemu/module.h"
31 #include "qemu/option.h"
32 #include "qemu/units.h"
33 #include "qemu/memalign.h"
35 #include "block/thread-pool.h"
37 #include "block/raw-aio.h"
38 #include "qapi/qmp/qdict.h"
39 #include "qapi/qmp/qstring.h"
41 #include "scsi/pr-manager.h"
42 #include "scsi/constants.h"
44 #if defined(__APPLE__) && (__MACH__)
45 #include <sys/ioctl.h>
46 #if defined(HAVE_HOST_BLOCK_DEVICE)
48 #include <sys/param.h>
49 #include <sys/mount.h>
50 #include <IOKit/IOKitLib.h>
51 #include <IOKit/IOBSD.h>
52 #include <IOKit/storage/IOMediaBSDClient.h>
53 #include <IOKit/storage/IOMedia.h>
54 #include <IOKit/storage/IOCDMedia.h>
55 //#include <IOKit/storage/IOCDTypes.h>
56 #include <IOKit/storage/IODVDMedia.h>
57 #include <CoreFoundation/CoreFoundation.h>
58 #endif /* defined(HAVE_HOST_BLOCK_DEVICE) */
62 #define _POSIX_PTHREAD_SEMANTICS 1
66 #include <sys/ioctl.h>
67 #include <sys/param.h>
68 #include <sys/syscall.h>
70 #include <linux/cdrom.h>
73 #include <linux/hdreg.h>
74 #include <linux/magic.h>
80 #define FS_NOCOW_FL 0x00800000 /* Do not cow file */
83 #if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
84 #include <linux/falloc.h>
86 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
92 #include <sys/ioctl.h>
93 #include <sys/disklabel.h>
98 #include <sys/ioctl.h>
99 #include <sys/disklabel.h>
100 #include <sys/dkio.h>
101 #include <sys/disk.h>
105 #include <sys/ioctl.h>
106 #include <sys/diskslice.h>
109 /* OS X does not have O_DSYNC */
112 #define O_DSYNC O_SYNC
113 #elif defined(O_FSYNC)
114 #define O_DSYNC O_FSYNC
118 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
120 #define O_DIRECT O_DSYNC
126 #define MAX_BLOCKSIZE 4096
128 /* Posix file locking bytes. Libvirt takes byte 0, we start from higher bytes,
129 * leaving a few more bytes for its future use. */
130 #define RAW_LOCK_PERM_BASE 100
131 #define RAW_LOCK_SHARED_BASE 200
133 typedef struct BDRVRawState {
140 /* The current permissions. */
142 uint64_t shared_perm;
144 /* The perms bits whose corresponding bytes are already locked in
146 uint64_t locked_perm;
147 uint64_t locked_shared_perm;
149 uint64_t aio_max_batch;
152 int perm_change_flags;
153 BDRVReopenState *reopen_state;
156 bool has_write_zeroes:1;
157 bool discard_zeroes:1;
158 bool use_linux_aio:1;
159 bool use_linux_io_uring:1;
160 int page_cache_inconsistent; /* errno from fdatasync failure */
162 bool needs_alignment;
163 bool force_alignment;
165 bool check_cache_dropped;
167 uint64_t discard_nb_ok;
168 uint64_t discard_nb_failed;
169 uint64_t discard_bytes_ok;
175 typedef struct BDRVRawReopenState {
178 bool check_cache_dropped;
179 } BDRVRawReopenState;
181 static int fd_open(BlockDriverState *bs)
183 BDRVRawState *s = bs->opaque;
185 /* this is just to ensure s->fd is sane (its called by io ops) */
192 static int64_t raw_getlength(BlockDriverState *bs);
194 typedef struct RawPosixAIOData {
195 BlockDriverState *bs;
216 PreallocMode prealloc;
222 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
223 static int cdrom_reopen(BlockDriverState *bs);
227 * Elide EAGAIN and EACCES details when failing to lock, as this
228 * indicates that the specified file region is already locked by
229 * another process, which is considered a common scenario.
231 #define raw_lock_error_setg_errno(errp, err, fmt, ...) \
233 if ((err) == EAGAIN || (err) == EACCES) { \
234 error_setg((errp), (fmt), ## __VA_ARGS__); \
236 error_setg_errno((errp), (err), (fmt), ## __VA_ARGS__); \
240 #if defined(__NetBSD__)
241 static int raw_normalize_devicepath(const char **filename, Error **errp)
243 static char namebuf[PATH_MAX];
244 const char *dp, *fname;
248 dp = strrchr(fname, '/');
249 if (lstat(fname, &sb) < 0) {
250 error_setg_file_open(errp, errno, fname);
254 if (!S_ISBLK(sb.st_mode)) {
259 snprintf(namebuf, PATH_MAX, "r%s", fname);
261 snprintf(namebuf, PATH_MAX, "%.*s/r%s",
262 (int)(dp - fname), fname, dp + 1);
265 warn_report("%s is a block device, using %s", fname, *filename);
270 static int raw_normalize_devicepath(const char **filename, Error **errp)
277 * Get logical block size via ioctl. On success store it in @sector_size_p.
279 static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
281 unsigned int sector_size;
282 bool success = false;
286 static const unsigned long ioctl_list[] = {
290 #ifdef DKIOCGETBLOCKSIZE
293 #ifdef DIOCGSECTORSIZE
298 /* Try a few ioctls to get the right size */
299 for (i = 0; i < (int)ARRAY_SIZE(ioctl_list); i++) {
300 if (ioctl(fd, ioctl_list[i], §or_size) >= 0) {
301 *sector_size_p = sector_size;
306 return success ? 0 : -errno;
310 * Get physical block size of @fd.
311 * On success, store it in @blk_size and return 0.
312 * On failure, return -errno.
314 static int probe_physical_blocksize(int fd, unsigned int *blk_size)
317 if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
327 * Returns true if no alignment restrictions are necessary even for files
328 * opened with O_DIRECT.
330 * raw_probe_alignment() probes the required alignment and assume that 1 means
331 * the probing failed, so it falls back to a safe default of 4k. This can be
332 * avoided if we know that byte alignment is okay for the file.
334 static bool dio_byte_aligned(int fd)
340 ret = fstatfs(fd, &buf);
341 if (ret == 0 && buf.f_type == NFS_SUPER_MAGIC) {
348 static bool raw_needs_alignment(BlockDriverState *bs)
350 BDRVRawState *s = bs->opaque;
352 if ((bs->open_flags & BDRV_O_NOCACHE) != 0 && !dio_byte_aligned(s->fd)) {
356 return s->force_alignment;
359 /* Check if read is allowed with given memory buffer and length.
361 * This function is used to check O_DIRECT memory buffer and request alignment.
363 static bool raw_is_io_aligned(int fd, void *buf, size_t len)
365 ssize_t ret = pread(fd, buf, len, 0);
372 /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads. Ignore
373 * other errors (e.g. real I/O error), which could happen on a failed
374 * drive, since we only care about probing alignment.
376 if (errno != EINVAL) {
384 static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
386 BDRVRawState *s = bs->opaque;
388 size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size());
389 size_t alignments[] = {1, 512, 1024, 2048, 4096};
391 /* For SCSI generic devices the alignment is not really used.
392 With buffered I/O, we don't have any restrictions. */
393 if (bdrv_is_sg(bs) || !s->needs_alignment) {
394 bs->bl.request_alignment = 1;
399 bs->bl.request_alignment = 0;
401 /* Let's try to use the logical blocksize for the alignment. */
402 if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) {
403 bs->bl.request_alignment = 0;
408 * The XFS ioctl definitions are shipped in extra packages that might
409 * not always be available. Since we just need the XFS_IOC_DIOINFO ioctl
410 * here, we simply use our own definition instead:
417 if (ioctl(fd, _IOR('X', 30, struct xfs_dioattr), &da) >= 0) {
418 bs->bl.request_alignment = da.d_miniosz;
419 /* The kernel returns wrong information for d_mem */
420 /* s->buf_align = da.d_mem; */
425 * If we could not get the sizes so far, we can only guess them. First try
426 * to detect request alignment, since it is more likely to succeed. Then
427 * try to detect buf_align, which cannot be detected in some cases (e.g.
428 * Gluster). If buf_align cannot be detected, we fallback to the value of
432 if (!bs->bl.request_alignment) {
435 buf = qemu_memalign(max_align, max_align);
436 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
437 align = alignments[i];
438 if (raw_is_io_aligned(fd, buf, align)) {
439 /* Fallback to safe value. */
440 bs->bl.request_alignment = (align != 1) ? align : max_align;
450 buf = qemu_memalign(max_align, 2 * max_align);
451 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
452 align = alignments[i];
453 if (raw_is_io_aligned(fd, buf + align, max_align)) {
454 /* Fallback to request_alignment. */
455 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
462 if (!s->buf_align || !bs->bl.request_alignment) {
463 error_setg(errp, "Could not find working O_DIRECT alignment");
464 error_append_hint(errp, "Try cache.direct=off\n");
468 static int check_hdev_writable(int fd)
470 #if defined(BLKROGET)
471 /* Linux block devices can be configured "read-only" using blockdev(8).
472 * This is independent of device node permissions and therefore open(2)
473 * with O_RDWR succeeds. Actual writes fail with EPERM.
475 * bdrv_open() is supposed to fail if the disk is read-only. Explicitly
476 * check for read-only block devices so that Linux block devices behave
482 if (fstat(fd, &st)) {
486 if (!S_ISBLK(st.st_mode)) {
490 if (ioctl(fd, BLKROGET, &readonly) < 0) {
497 #endif /* defined(BLKROGET) */
501 static void raw_parse_flags(int bdrv_flags, int *open_flags, bool has_writers)
503 bool read_write = false;
504 assert(open_flags != NULL);
506 *open_flags |= O_BINARY;
507 *open_flags &= ~O_ACCMODE;
509 if (bdrv_flags & BDRV_O_AUTO_RDONLY) {
510 read_write = has_writers;
511 } else if (bdrv_flags & BDRV_O_RDWR) {
516 *open_flags |= O_RDWR;
518 *open_flags |= O_RDONLY;
521 /* Use O_DSYNC for write-through caching, no flags for write-back caching,
522 * and O_DIRECT for no caching. */
523 if ((bdrv_flags & BDRV_O_NOCACHE)) {
524 *open_flags |= O_DIRECT;
528 static void raw_parse_filename(const char *filename, QDict *options,
531 bdrv_parse_filename_strip_prefix(filename, "file:", options);
534 static QemuOptsList raw_runtime_opts = {
536 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
540 .type = QEMU_OPT_STRING,
541 .help = "File name of the image",
545 .type = QEMU_OPT_STRING,
546 .help = "host AIO implementation (threads, native, io_uring)",
549 .name = "aio-max-batch",
550 .type = QEMU_OPT_NUMBER,
551 .help = "AIO max batch size (0 = auto handled by AIO backend, default: 0)",
555 .type = QEMU_OPT_STRING,
556 .help = "file locking mode (on/off/auto, default: auto)",
559 .name = "pr-manager",
560 .type = QEMU_OPT_STRING,
561 .help = "id of persistent reservation manager object (default: none)",
563 #if defined(__linux__)
565 .name = "drop-cache",
566 .type = QEMU_OPT_BOOL,
567 .help = "invalidate page cache during live migration (default: on)",
571 .name = "x-check-cache-dropped",
572 .type = QEMU_OPT_BOOL,
573 .help = "check that page cache was dropped on live migration (default: off)"
575 { /* end of list */ }
579 static const char *const mutable_opts[] = { "x-check-cache-dropped", NULL };
581 static int raw_open_common(BlockDriverState *bs, QDict *options,
582 int bdrv_flags, int open_flags,
583 bool device, Error **errp)
585 BDRVRawState *s = bs->opaque;
587 Error *local_err = NULL;
588 const char *filename = NULL;
590 BlockdevAioOptions aio, aio_default;
595 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
596 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
601 filename = qemu_opt_get(opts, "filename");
603 ret = raw_normalize_devicepath(&filename, errp);
608 if (bdrv_flags & BDRV_O_NATIVE_AIO) {
609 aio_default = BLOCKDEV_AIO_OPTIONS_NATIVE;
610 #ifdef CONFIG_LINUX_IO_URING
611 } else if (bdrv_flags & BDRV_O_IO_URING) {
612 aio_default = BLOCKDEV_AIO_OPTIONS_IO_URING;
615 aio_default = BLOCKDEV_AIO_OPTIONS_THREADS;
618 aio = qapi_enum_parse(&BlockdevAioOptions_lookup,
619 qemu_opt_get(opts, "aio"),
620 aio_default, &local_err);
622 error_propagate(errp, local_err);
627 s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
628 #ifdef CONFIG_LINUX_IO_URING
629 s->use_linux_io_uring = (aio == BLOCKDEV_AIO_OPTIONS_IO_URING);
632 s->aio_max_batch = qemu_opt_get_number(opts, "aio-max-batch", 0);
634 locking = qapi_enum_parse(&OnOffAuto_lookup,
635 qemu_opt_get(opts, "locking"),
636 ON_OFF_AUTO_AUTO, &local_err);
638 error_propagate(errp, local_err);
645 if (!qemu_has_ofd_lock()) {
646 warn_report("File lock requested but OFD locking syscall is "
647 "unavailable, falling back to POSIX file locks");
648 error_printf("Due to the implementation, locks can be lost "
652 case ON_OFF_AUTO_OFF:
655 case ON_OFF_AUTO_AUTO:
656 s->use_lock = qemu_has_ofd_lock();
662 str = qemu_opt_get(opts, "pr-manager");
664 s->pr_mgr = pr_manager_lookup(str, &local_err);
666 error_propagate(errp, local_err);
672 s->drop_cache = qemu_opt_get_bool(opts, "drop-cache", true);
673 s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped",
676 s->open_flags = open_flags;
677 raw_parse_flags(bdrv_flags, &s->open_flags, false);
680 fd = qemu_open(filename, s->open_flags, errp);
681 ret = fd < 0 ? -errno : 0;
691 /* Check s->open_flags rather than bdrv_flags due to auto-read-only */
692 if (s->open_flags & O_RDWR) {
693 ret = check_hdev_writable(s->fd);
695 error_setg_errno(errp, -ret, "The device is not writable");
701 s->shared_perm = BLK_PERM_ALL;
703 #ifdef CONFIG_LINUX_AIO
704 /* Currently Linux does AIO only for files opened with O_DIRECT */
705 if (s->use_linux_aio) {
706 if (!(s->open_flags & O_DIRECT)) {
707 error_setg(errp, "aio=native was specified, but it requires "
708 "cache.direct=on, which was not specified.");
712 if (!aio_setup_linux_aio(bdrv_get_aio_context(bs), errp)) {
713 error_prepend(errp, "Unable to use native AIO: ");
718 if (s->use_linux_aio) {
719 error_setg(errp, "aio=native was specified, but is not supported "
724 #endif /* !defined(CONFIG_LINUX_AIO) */
726 #ifdef CONFIG_LINUX_IO_URING
727 if (s->use_linux_io_uring) {
728 if (!aio_setup_linux_io_uring(bdrv_get_aio_context(bs), errp)) {
729 error_prepend(errp, "Unable to use io_uring: ");
734 if (s->use_linux_io_uring) {
735 error_setg(errp, "aio=io_uring was specified, but is not supported "
740 #endif /* !defined(CONFIG_LINUX_IO_URING) */
742 s->has_discard = true;
743 s->has_write_zeroes = true;
745 if (fstat(s->fd, &st) < 0) {
747 error_setg_errno(errp, errno, "Could not stat file");
752 if (!S_ISREG(st.st_mode)) {
753 error_setg(errp, "'%s' driver requires '%s' to be a regular file",
754 bs->drv->format_name, bs->filename);
758 s->discard_zeroes = true;
759 s->has_fallocate = true;
762 if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
763 error_setg(errp, "'%s' driver requires '%s' to be either "
764 "a character or block device",
765 bs->drv->format_name, bs->filename);
771 if (S_ISBLK(st.st_mode)) {
772 #ifdef BLKDISCARDZEROES
774 if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
775 s->discard_zeroes = true;
779 /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache. Do
780 * not rely on the contents of discarded blocks unless using O_DIRECT.
781 * Same for BLKZEROOUT.
783 if (!(bs->open_flags & BDRV_O_NOCACHE)) {
784 s->discard_zeroes = false;
785 s->has_write_zeroes = false;
790 if (S_ISCHR(st.st_mode)) {
792 * The file is a char device (disk), which on FreeBSD isn't behind
793 * a pager, so force all requests to be aligned. This is needed
794 * so QEMU makes sure all IO operations on the device are aligned
795 * to sector size, or else FreeBSD will reject them with EINVAL.
797 s->force_alignment = true;
800 s->needs_alignment = raw_needs_alignment(bs);
802 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
803 if (S_ISREG(st.st_mode)) {
804 /* When extending regular files, we get zeros from the OS */
805 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
809 if (ret < 0 && s->fd != -1) {
812 if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
819 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
822 BDRVRawState *s = bs->opaque;
824 s->type = FTYPE_FILE;
825 return raw_open_common(bs, options, flags, 0, false, errp);
834 #define PERM_FOREACH(i) \
835 for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++)
837 /* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the
838 * file; if @unlock == true, also unlock the unneeded bytes.
839 * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
841 static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
842 uint64_t perm_lock_bits,
843 uint64_t shared_perm_lock_bits,
844 bool unlock, Error **errp)
848 uint64_t locked_perm, locked_shared_perm;
851 locked_perm = s->locked_perm;
852 locked_shared_perm = s->locked_shared_perm;
855 * We don't have the previous bits, just lock/unlock for each of the
859 locked_perm = BLK_PERM_ALL;
860 locked_shared_perm = BLK_PERM_ALL;
863 locked_shared_perm = 0;
868 int off = RAW_LOCK_PERM_BASE + i;
869 uint64_t bit = (1ULL << i);
870 if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
871 ret = qemu_lock_fd(fd, off, 1, false);
873 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d",
877 s->locked_perm |= bit;
879 } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
880 ret = qemu_unlock_fd(fd, off, 1);
882 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off);
885 s->locked_perm &= ~bit;
890 int off = RAW_LOCK_SHARED_BASE + i;
891 uint64_t bit = (1ULL << i);
892 if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
893 ret = qemu_lock_fd(fd, off, 1, false);
895 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d",
899 s->locked_shared_perm |= bit;
901 } else if (unlock && (locked_shared_perm & bit) &&
902 !(shared_perm_lock_bits & bit)) {
903 ret = qemu_unlock_fd(fd, off, 1);
905 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off);
908 s->locked_shared_perm &= ~bit;
915 /* Check "unshared" bytes implied by @perm and ~@shared_perm in the file. */
916 static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm,
923 int off = RAW_LOCK_SHARED_BASE + i;
924 uint64_t p = 1ULL << i;
926 ret = qemu_lock_fd_test(fd, off, 1, true);
928 char *perm_name = bdrv_perm_names(p);
930 raw_lock_error_setg_errno(errp, -ret,
931 "Failed to get \"%s\" lock",
939 int off = RAW_LOCK_PERM_BASE + i;
940 uint64_t p = 1ULL << i;
941 if (!(shared_perm & p)) {
942 ret = qemu_lock_fd_test(fd, off, 1, true);
944 char *perm_name = bdrv_perm_names(p);
946 raw_lock_error_setg_errno(errp, -ret,
947 "Failed to get shared \"%s\" lock",
957 static int raw_handle_perm_lock(BlockDriverState *bs,
959 uint64_t new_perm, uint64_t new_shared,
962 BDRVRawState *s = bs->opaque;
964 Error *local_err = NULL;
970 if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) {
976 if ((s->perm | new_perm) == s->perm &&
977 (s->shared_perm & new_shared) == s->shared_perm)
980 * We are going to unlock bytes, it should not fail. If it fail due
981 * to some fs-dependent permission-unrelated reasons (which occurs
982 * sometimes on NFS and leads to abort in bdrv_replace_child) we
983 * can't prevent such errors by any check here. And we ignore them
984 * anyway in ABORT and COMMIT.
988 ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm,
989 ~s->shared_perm | ~new_shared,
992 ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp);
996 error_append_hint(errp,
997 "Is another process using the image [%s]?\n",
1000 /* fall through to unlock bytes. */
1002 raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm,
1005 /* Theoretically the above call only unlocks bytes and it cannot
1006 * fail. Something weird happened, report it.
1008 warn_report_err(local_err);
1012 raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared,
1015 /* Theoretically the above call only unlocks bytes and it cannot
1016 * fail. Something weird happened, report it.
1018 warn_report_err(local_err);
1025 /* Sets a specific flag */
1026 static int fcntl_setfl(int fd, int flag)
1030 flags = fcntl(fd, F_GETFL);
1034 if (fcntl(fd, F_SETFL, flags | flag) == -1) {
1040 static int raw_reconfigure_getfd(BlockDriverState *bs, int flags,
1041 int *open_flags, uint64_t perm, bool force_dup,
1044 BDRVRawState *s = bs->opaque;
1047 bool has_writers = perm &
1048 (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_RESIZE);
1049 int fcntl_flags = O_APPEND | O_NONBLOCK;
1051 fcntl_flags |= O_NOATIME;
1055 if (s->type == FTYPE_CD) {
1056 *open_flags |= O_NONBLOCK;
1059 raw_parse_flags(flags, open_flags, has_writers);
1062 /* Not all operating systems have O_ASYNC, and those that don't
1063 * will not let us track the state into rs->open_flags (typically
1064 * you achieve the same effect with an ioctl, for example I_SETSIG
1065 * on Solaris). But we do not use O_ASYNC, so that's fine.
1067 assert((s->open_flags & O_ASYNC) == 0);
1070 if (!force_dup && *open_flags == s->open_flags) {
1071 /* We're lucky, the existing fd is fine */
1075 if ((*open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
1076 /* dup the original fd */
1077 fd = qemu_dup(s->fd);
1079 ret = fcntl_setfl(fd, *open_flags);
1087 /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
1089 const char *normalized_filename = bs->filename;
1090 ret = raw_normalize_devicepath(&normalized_filename, errp);
1092 fd = qemu_open(normalized_filename, *open_flags, errp);
1099 if (fd != -1 && (*open_flags & O_RDWR)) {
1100 ret = check_hdev_writable(fd);
1103 error_setg_errno(errp, -ret, "The device is not writable");
1111 static int raw_reopen_prepare(BDRVReopenState *state,
1112 BlockReopenQueue *queue, Error **errp)
1115 BDRVRawReopenState *rs;
1119 assert(state != NULL);
1120 assert(state->bs != NULL);
1122 s = state->bs->opaque;
1124 state->opaque = g_new0(BDRVRawReopenState, 1);
1127 /* Handle options changes */
1128 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
1129 if (!qemu_opts_absorb_qdict(opts, state->options, errp)) {
1134 rs->drop_cache = qemu_opt_get_bool_del(opts, "drop-cache", true);
1135 rs->check_cache_dropped =
1136 qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false);
1138 /* This driver's reopen function doesn't currently allow changing
1139 * other options, so let's put them back in the original QDict and
1140 * bdrv_reopen_prepare() will detect changes and complain. */
1141 qemu_opts_to_qdict(opts, state->options);
1144 * As part of reopen prepare we also want to create new fd by
1145 * raw_reconfigure_getfd(). But it wants updated "perm", when in
1146 * bdrv_reopen_multiple() .bdrv_reopen_prepare() callback called prior to
1147 * permission update. Happily, permission update is always a part (a seprate
1148 * stage) of bdrv_reopen_multiple() so we can rely on this fact and
1149 * reconfigure fd in raw_check_perm().
1152 s->reopen_state = state;
1156 qemu_opts_del(opts);
1160 static void raw_reopen_commit(BDRVReopenState *state)
1162 BDRVRawReopenState *rs = state->opaque;
1163 BDRVRawState *s = state->bs->opaque;
1165 s->drop_cache = rs->drop_cache;
1166 s->check_cache_dropped = rs->check_cache_dropped;
1167 s->open_flags = rs->open_flags;
1168 g_free(state->opaque);
1169 state->opaque = NULL;
1171 assert(s->reopen_state == state);
1172 s->reopen_state = NULL;
1176 static void raw_reopen_abort(BDRVReopenState *state)
1178 BDRVRawReopenState *rs = state->opaque;
1179 BDRVRawState *s = state->bs->opaque;
1181 /* nothing to do if NULL, we didn't get far enough */
1186 g_free(state->opaque);
1187 state->opaque = NULL;
1189 assert(s->reopen_state == state);
1190 s->reopen_state = NULL;
1193 static int hdev_get_max_hw_transfer(int fd, struct stat *st)
1196 if (S_ISBLK(st->st_mode)) {
1197 unsigned short max_sectors = 0;
1198 if (ioctl(fd, BLKSECTGET, &max_sectors) == 0) {
1199 return max_sectors * 512;
1203 if (ioctl(fd, BLKSECTGET, &max_bytes) == 0) {
1213 static int hdev_get_max_segments(int fd, struct stat *st)
1218 char *sysfspath = NULL;
1223 if (S_ISCHR(st->st_mode)) {
1224 if (ioctl(fd, SG_GET_SG_TABLESIZE, &ret) == 0) {
1230 if (!S_ISBLK(st->st_mode)) {
1234 sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments",
1235 major(st->st_rdev), minor(st->st_rdev));
1236 sysfd = open(sysfspath, O_RDONLY);
1242 ret = read(sysfd, buf, sizeof(buf) - 1);
1243 } while (ret == -1 && errno == EINTR);
1247 } else if (ret == 0) {
1252 /* The file is ended with '\n', pass 'end' to accept that. */
1253 ret = qemu_strtol(buf, &end, 10, &max_segments);
1254 if (ret == 0 && end && *end == '\n') {
1269 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
1271 BDRVRawState *s = bs->opaque;
1274 s->needs_alignment = raw_needs_alignment(bs);
1275 raw_probe_alignment(bs, s->fd, errp);
1277 bs->bl.min_mem_alignment = s->buf_align;
1278 bs->bl.opt_mem_alignment = MAX(s->buf_align, qemu_real_host_page_size());
1281 * Maximum transfers are best effort, so it is okay to ignore any
1282 * errors. That said, based on the man page errors in fstat would be
1283 * very much unexpected; the only possible case seems to be ENOMEM.
1285 if (fstat(s->fd, &st)) {
1289 #if defined(__APPLE__) && (__MACH__)
1292 if (!fstatfs(s->fd, &buf)) {
1293 bs->bl.opt_transfer = buf.f_iosize;
1294 bs->bl.pdiscard_alignment = buf.f_bsize;
1298 if (bs->sg || S_ISBLK(st.st_mode)) {
1299 int ret = hdev_get_max_hw_transfer(s->fd, &st);
1301 if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) {
1302 bs->bl.max_hw_transfer = ret;
1305 ret = hdev_get_max_segments(s->fd, &st);
1307 bs->bl.max_hw_iov = ret;
1312 static int check_for_dasd(int fd)
1315 struct dasd_information2_t info = {0};
1317 return ioctl(fd, BIODASDINFO2, &info);
1324 * Try to get @bs's logical and physical block size.
1325 * On success, store them in @bsz and return zero.
1326 * On failure, return negative errno.
1328 static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
1330 BDRVRawState *s = bs->opaque;
1333 /* If DASD, get blocksizes */
1334 if (check_for_dasd(s->fd) < 0) {
1337 ret = probe_logical_blocksize(s->fd, &bsz->log);
1341 return probe_physical_blocksize(s->fd, &bsz->phys);
1345 * Try to get @bs's geometry: cyls, heads, sectors.
1346 * On success, store them in @geo and return 0.
1347 * On failure return -errno.
1348 * (Allows block driver to assign default geometry values that guest sees)
1351 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1353 BDRVRawState *s = bs->opaque;
1354 struct hd_geometry ioctl_geo = {0};
1356 /* If DASD, get its geometry */
1357 if (check_for_dasd(s->fd) < 0) {
1360 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
1363 /* HDIO_GETGEO may return success even though geo contains zeros
1364 (e.g. certain multipath setups) */
1365 if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
1368 /* Do not return a geometry for partition */
1369 if (ioctl_geo.start != 0) {
1372 geo->heads = ioctl_geo.heads;
1373 geo->sectors = ioctl_geo.sectors;
1374 geo->cylinders = ioctl_geo.cylinders;
1378 #else /* __linux__ */
1379 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1385 #if defined(__linux__)
1386 static int handle_aiocb_ioctl(void *opaque)
1388 RawPosixAIOData *aiocb = opaque;
1392 ret = ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf);
1393 } while (ret == -1 && errno == EINTR);
1402 static int handle_aiocb_flush(void *opaque)
1404 RawPosixAIOData *aiocb = opaque;
1405 BDRVRawState *s = aiocb->bs->opaque;
1408 if (s->page_cache_inconsistent) {
1409 return -s->page_cache_inconsistent;
1412 ret = qemu_fdatasync(aiocb->aio_fildes);
1414 trace_file_flush_fdatasync_failed(errno);
1416 /* There is no clear definition of the semantics of a failing fsync(),
1417 * so we may have to assume the worst. The sad truth is that this
1418 * assumption is correct for Linux. Some pages are now probably marked
1419 * clean in the page cache even though they are inconsistent with the
1420 * on-disk contents. The next fdatasync() call would succeed, but no
1421 * further writeback attempt will be made. We can't get back to a state
1422 * in which we know what is on disk (we would have to rewrite
1423 * everything that was touched since the last fdatasync() at least), so
1424 * make bdrv_flush() fail permanently. Given that the behaviour isn't
1425 * really defined, I have little hope that other OSes are doing better.
1427 * Obviously, this doesn't affect O_DIRECT, which bypasses the page
1429 if ((s->open_flags & O_DIRECT) == 0) {
1430 s->page_cache_inconsistent = errno;
1437 #ifdef CONFIG_PREADV
1439 static bool preadv_present = true;
1442 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1444 return preadv(fd, iov, nr_iov, offset);
1448 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1450 return pwritev(fd, iov, nr_iov, offset);
1455 static bool preadv_present = false;
1458 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1464 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1471 static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
1476 if (aiocb->aio_type & QEMU_AIO_WRITE)
1477 len = qemu_pwritev(aiocb->aio_fildes,
1482 len = qemu_preadv(aiocb->aio_fildes,
1486 } while (len == -1 && errno == EINTR);
1495 * Read/writes the data to/from a given linear buffer.
1497 * Returns the number of bytes handles or -errno in case of an error. Short
1498 * reads are only returned if the end of the file is reached.
1500 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
1505 while (offset < aiocb->aio_nbytes) {
1506 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1507 len = pwrite(aiocb->aio_fildes,
1508 (const char *)buf + offset,
1509 aiocb->aio_nbytes - offset,
1510 aiocb->aio_offset + offset);
1512 len = pread(aiocb->aio_fildes,
1514 aiocb->aio_nbytes - offset,
1515 aiocb->aio_offset + offset);
1517 if (len == -1 && errno == EINTR) {
1519 } else if (len == -1 && errno == EINVAL &&
1520 (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
1521 !(aiocb->aio_type & QEMU_AIO_WRITE) &&
1523 /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
1524 * after a short read. Assume that O_DIRECT short reads only occur
1525 * at EOF. Therefore this is a short read, not an I/O error.
1528 } else if (len == -1) {
1531 } else if (len == 0) {
1540 static int handle_aiocb_rw(void *opaque)
1542 RawPosixAIOData *aiocb = opaque;
1546 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
1548 * If there is just a single buffer, and it is properly aligned
1549 * we can just use plain pread/pwrite without any problems.
1551 if (aiocb->io.niov == 1) {
1552 nbytes = handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base);
1556 * We have more than one iovec, and all are properly aligned.
1558 * Try preadv/pwritev first and fall back to linearizing the
1559 * buffer if it's not supported.
1561 if (preadv_present) {
1562 nbytes = handle_aiocb_rw_vector(aiocb);
1563 if (nbytes == aiocb->aio_nbytes ||
1564 (nbytes < 0 && nbytes != -ENOSYS)) {
1567 preadv_present = false;
1571 * XXX(hch): short read/write. no easy way to handle the reminder
1572 * using these interfaces. For now retry using plain
1578 * Ok, we have to do it the hard way, copy all segments into
1579 * a single aligned buffer.
1581 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
1587 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1591 for (i = 0; i < aiocb->io.niov; ++i) {
1592 memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len);
1593 p += aiocb->io.iov[i].iov_len;
1595 assert(p - buf == aiocb->aio_nbytes);
1598 nbytes = handle_aiocb_rw_linear(aiocb, buf);
1599 if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
1601 size_t count = aiocb->aio_nbytes, copy;
1604 for (i = 0; i < aiocb->io.niov && count; ++i) {
1606 if (copy > aiocb->io.iov[i].iov_len) {
1607 copy = aiocb->io.iov[i].iov_len;
1609 memcpy(aiocb->io.iov[i].iov_base, p, copy);
1610 assert(count >= copy);
1619 if (nbytes == aiocb->aio_nbytes) {
1621 } else if (nbytes >= 0 && nbytes < aiocb->aio_nbytes) {
1622 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1625 iov_memset(aiocb->io.iov, aiocb->io.niov, nbytes,
1626 0, aiocb->aio_nbytes - nbytes);
1635 #if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
1636 static int translate_err(int err)
1638 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1646 #ifdef CONFIG_FALLOCATE
1647 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1650 if (fallocate(fd, mode, offset, len) == 0) {
1653 } while (errno == EINTR);
1654 return translate_err(-errno);
1658 static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1661 BDRVRawState *s = aiocb->bs->opaque;
1663 if (!s->has_write_zeroes) {
1668 /* The BLKZEROOUT implementation in the kernel doesn't set
1669 * BLKDEV_ZERO_NOFALLBACK, so we can't call this if we have to avoid slow
1671 if (!(aiocb->aio_type & QEMU_AIO_NO_FALLBACK)) {
1673 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1674 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1677 } while (errno == EINTR);
1679 ret = translate_err(-errno);
1680 if (ret == -ENOTSUP) {
1681 s->has_write_zeroes = false;
1689 static int handle_aiocb_write_zeroes(void *opaque)
1691 RawPosixAIOData *aiocb = opaque;
1692 #ifdef CONFIG_FALLOCATE
1693 BDRVRawState *s = aiocb->bs->opaque;
1697 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1698 return handle_aiocb_write_zeroes_block(aiocb);
1701 #ifdef CONFIG_FALLOCATE_ZERO_RANGE
1702 if (s->has_write_zeroes) {
1703 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1704 aiocb->aio_offset, aiocb->aio_nbytes);
1705 if (ret == -ENOTSUP) {
1706 s->has_write_zeroes = false;
1707 } else if (ret == 0 || ret != -EINVAL) {
1711 * Note: Some file systems do not like unaligned byte ranges, and
1712 * return EINVAL in such a case, though they should not do it according
1713 * to the man-page of fallocate(). Thus we simply ignore this return
1714 * value and try the other fallbacks instead.
1719 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1720 if (s->has_discard && s->has_fallocate) {
1721 int ret = do_fallocate(s->fd,
1722 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1723 aiocb->aio_offset, aiocb->aio_nbytes);
1725 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1726 if (ret == 0 || ret != -ENOTSUP) {
1729 s->has_fallocate = false;
1730 } else if (ret == -EINVAL) {
1732 * Some file systems like older versions of GPFS do not like un-
1733 * aligned byte ranges, and return EINVAL in such a case, though
1734 * they should not do it according to the man-page of fallocate().
1735 * Warn about the bad filesystem and try the final fallback instead.
1737 warn_report_once("Your file system is misbehaving: "
1738 "fallocate(FALLOC_FL_PUNCH_HOLE) returned EINVAL. "
1739 "Please report this bug to your file system "
1741 } else if (ret != -ENOTSUP) {
1744 s->has_discard = false;
1749 #ifdef CONFIG_FALLOCATE
1750 /* Last resort: we are trying to extend the file with zeroed data. This
1751 * can be done via fallocate(fd, 0) */
1752 len = bdrv_getlength(aiocb->bs);
1753 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
1754 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1755 if (ret == 0 || ret != -ENOTSUP) {
1758 s->has_fallocate = false;
1765 static int handle_aiocb_write_zeroes_unmap(void *opaque)
1767 RawPosixAIOData *aiocb = opaque;
1768 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque;
1770 /* First try to write zeros and unmap at the same time */
1772 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1773 int ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1774 aiocb->aio_offset, aiocb->aio_nbytes);
1785 /* If we couldn't manage to unmap while guaranteed that the area reads as
1786 * all-zero afterwards, just write zeroes without unmapping */
1787 return handle_aiocb_write_zeroes(aiocb);
1790 #ifndef HAVE_COPY_FILE_RANGE
1791 static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
1792 off_t *out_off, size_t len, unsigned int flags)
1794 #ifdef __NR_copy_file_range
1795 return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
1796 out_off, len, flags);
1804 static int handle_aiocb_copy_range(void *opaque)
1806 RawPosixAIOData *aiocb = opaque;
1807 uint64_t bytes = aiocb->aio_nbytes;
1808 off_t in_off = aiocb->aio_offset;
1809 off_t out_off = aiocb->copy_range.aio_offset2;
1812 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
1813 aiocb->copy_range.aio_fd2, &out_off,
1815 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
1816 aiocb->copy_range.aio_fd2, out_off, bytes,
1819 /* No progress (e.g. when beyond EOF), let the caller fall back to
1838 static int handle_aiocb_discard(void *opaque)
1840 RawPosixAIOData *aiocb = opaque;
1842 BDRVRawState *s = aiocb->bs->opaque;
1844 if (!s->has_discard) {
1848 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1851 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1852 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1855 } while (errno == EINTR);
1857 ret = translate_err(-errno);
1860 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1861 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1862 aiocb->aio_offset, aiocb->aio_nbytes);
1863 ret = translate_err(ret);
1864 #elif defined(__APPLE__) && (__MACH__)
1865 fpunchhole_t fpunchhole;
1866 fpunchhole.fp_flags = 0;
1867 fpunchhole.reserved = 0;
1868 fpunchhole.fp_offset = aiocb->aio_offset;
1869 fpunchhole.fp_length = aiocb->aio_nbytes;
1870 if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
1871 ret = errno == ENODEV ? -ENOTSUP : -errno;
1878 if (ret == -ENOTSUP) {
1879 s->has_discard = false;
1885 * Help alignment probing by allocating the first block.
1887 * When reading with direct I/O from unallocated area on Gluster backed by XFS,
1888 * reading succeeds regardless of request length. In this case we fallback to
1889 * safe alignment which is not optimal. Allocating the first block avoids this
1892 * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
1893 * request alignment, so we use safe values.
1895 * Returns: 0 on success, -errno on failure. Since this is an optimization,
1896 * caller may ignore failures.
1898 static int allocate_first_block(int fd, size_t max_size)
1900 size_t write_size = (max_size < MAX_BLOCKSIZE)
1903 size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size());
1908 buf = qemu_memalign(max_align, write_size);
1909 memset(buf, 0, write_size);
1912 n = pwrite(fd, buf, write_size, 0);
1913 } while (n == -1 && errno == EINTR);
1915 ret = (n == -1) ? -errno : 0;
1921 static int handle_aiocb_truncate(void *opaque)
1923 RawPosixAIOData *aiocb = opaque;
1925 int64_t current_length = 0;
1928 int fd = aiocb->aio_fildes;
1929 int64_t offset = aiocb->aio_offset;
1930 PreallocMode prealloc = aiocb->truncate.prealloc;
1931 Error **errp = aiocb->truncate.errp;
1933 if (fstat(fd, &st) < 0) {
1935 error_setg_errno(errp, -result, "Could not stat file");
1939 current_length = st.st_size;
1940 if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
1941 error_setg(errp, "Cannot use preallocation for shrinking files");
1946 #ifdef CONFIG_POSIX_FALLOCATE
1947 case PREALLOC_MODE_FALLOC:
1949 * Truncating before posix_fallocate() makes it about twice slower on
1950 * file systems that do not support fallocate(), trying to check if a
1951 * block is allocated before allocating it, so don't do that here.
1953 if (offset != current_length) {
1954 result = -posix_fallocate(fd, current_length,
1955 offset - current_length);
1957 /* posix_fallocate() doesn't set errno. */
1958 error_setg_errno(errp, -result,
1959 "Could not preallocate new data");
1960 } else if (current_length == 0) {
1962 * posix_fallocate() uses fallocate() if the filesystem
1963 * supports it, or fallback to manually writing zeroes. If
1964 * fallocate() was used, unaligned reads from the fallocated
1965 * area in raw_probe_alignment() will succeed, hence we need to
1966 * allocate the first block.
1968 * Optimize future alignment probing; ignore failures.
1970 allocate_first_block(fd, offset);
1977 case PREALLOC_MODE_FULL:
1979 int64_t num = 0, left = offset - current_length;
1983 * Knowing the final size from the beginning could allow the file
1984 * system driver to do less allocations and possibly avoid
1985 * fragmentation of the file.
1987 if (ftruncate(fd, offset) != 0) {
1989 error_setg_errno(errp, -result, "Could not resize file");
1993 buf = g_malloc0(65536);
1995 seek_result = lseek(fd, current_length, SEEK_SET);
1996 if (seek_result < 0) {
1998 error_setg_errno(errp, -result,
1999 "Failed to seek to the old end of file");
2004 num = MIN(left, 65536);
2005 result = write(fd, buf, num);
2007 if (errno == EINTR) {
2011 error_setg_errno(errp, -result,
2012 "Could not write zeros for preallocation");
2021 error_setg_errno(errp, -result,
2022 "Could not flush file to disk");
2028 case PREALLOC_MODE_OFF:
2029 if (ftruncate(fd, offset) != 0) {
2031 error_setg_errno(errp, -result, "Could not resize file");
2032 } else if (current_length == 0 && offset > current_length) {
2033 /* Optimize future alignment probing; ignore failures. */
2034 allocate_first_block(fd, offset);
2039 error_setg(errp, "Unsupported preallocation mode: %s",
2040 PreallocMode_str(prealloc));
2046 if (ftruncate(fd, current_length) < 0) {
2047 error_report("Failed to restore old file length: %s",
2056 static int coroutine_fn raw_thread_pool_submit(BlockDriverState *bs,
2057 ThreadPoolFunc func, void *arg)
2059 /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */
2060 ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
2061 return thread_pool_submit_co(pool, func, arg);
2064 static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
2065 uint64_t bytes, QEMUIOVector *qiov, int type)
2067 BDRVRawState *s = bs->opaque;
2068 RawPosixAIOData acb;
2070 if (fd_open(bs) < 0)
2074 * When using O_DIRECT, the request must be aligned to be able to use
2075 * either libaio or io_uring interface. If not fail back to regular thread
2076 * pool read/write code which emulates this for us if we
2077 * set QEMU_AIO_MISALIGNED.
2079 if (s->needs_alignment && !bdrv_qiov_is_aligned(bs, qiov)) {
2080 type |= QEMU_AIO_MISALIGNED;
2081 #ifdef CONFIG_LINUX_IO_URING
2082 } else if (s->use_linux_io_uring) {
2083 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2084 assert(qiov->size == bytes);
2085 return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
2087 #ifdef CONFIG_LINUX_AIO
2088 } else if (s->use_linux_aio) {
2089 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2090 assert(qiov->size == bytes);
2091 return laio_co_submit(bs, aio, s->fd, offset, qiov, type,
2096 acb = (RawPosixAIOData) {
2098 .aio_fildes = s->fd,
2100 .aio_offset = offset,
2101 .aio_nbytes = bytes,
2108 assert(qiov->size == bytes);
2109 return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
2112 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
2113 int64_t bytes, QEMUIOVector *qiov,
2114 BdrvRequestFlags flags)
2116 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
2119 static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
2120 int64_t bytes, QEMUIOVector *qiov,
2121 BdrvRequestFlags flags)
2124 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
2127 static void raw_aio_plug(BlockDriverState *bs)
2129 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2130 #ifdef CONFIG_LINUX_AIO
2131 if (s->use_linux_aio) {
2132 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2133 laio_io_plug(bs, aio);
2136 #ifdef CONFIG_LINUX_IO_URING
2137 if (s->use_linux_io_uring) {
2138 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2139 luring_io_plug(bs, aio);
2144 static void raw_aio_unplug(BlockDriverState *bs)
2146 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2147 #ifdef CONFIG_LINUX_AIO
2148 if (s->use_linux_aio) {
2149 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2150 laio_io_unplug(bs, aio, s->aio_max_batch);
2153 #ifdef CONFIG_LINUX_IO_URING
2154 if (s->use_linux_io_uring) {
2155 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2156 luring_io_unplug(bs, aio);
2161 static int raw_co_flush_to_disk(BlockDriverState *bs)
2163 BDRVRawState *s = bs->opaque;
2164 RawPosixAIOData acb;
2172 acb = (RawPosixAIOData) {
2174 .aio_fildes = s->fd,
2175 .aio_type = QEMU_AIO_FLUSH,
2178 #ifdef CONFIG_LINUX_IO_URING
2179 if (s->use_linux_io_uring) {
2180 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2181 return luring_co_submit(bs, aio, s->fd, 0, NULL, QEMU_AIO_FLUSH);
2184 return raw_thread_pool_submit(bs, handle_aiocb_flush, &acb);
2187 static void raw_aio_attach_aio_context(BlockDriverState *bs,
2188 AioContext *new_context)
2190 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2191 #ifdef CONFIG_LINUX_AIO
2192 if (s->use_linux_aio) {
2193 Error *local_err = NULL;
2194 if (!aio_setup_linux_aio(new_context, &local_err)) {
2195 error_reportf_err(local_err, "Unable to use native AIO, "
2196 "falling back to thread pool: ");
2197 s->use_linux_aio = false;
2201 #ifdef CONFIG_LINUX_IO_URING
2202 if (s->use_linux_io_uring) {
2203 Error *local_err = NULL;
2204 if (!aio_setup_linux_io_uring(new_context, &local_err)) {
2205 error_reportf_err(local_err, "Unable to use linux io_uring, "
2206 "falling back to thread pool: ");
2207 s->use_linux_io_uring = false;
2213 static void raw_close(BlockDriverState *bs)
2215 BDRVRawState *s = bs->opaque;
2224 * Truncates the given regular file @fd to @offset and, when growing, fills the
2225 * new space according to @prealloc.
2227 * Returns: 0 on success, -errno on failure.
2229 static int coroutine_fn
2230 raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
2231 PreallocMode prealloc, Error **errp)
2233 RawPosixAIOData acb;
2235 acb = (RawPosixAIOData) {
2238 .aio_type = QEMU_AIO_TRUNCATE,
2239 .aio_offset = offset,
2241 .prealloc = prealloc,
2246 return raw_thread_pool_submit(bs, handle_aiocb_truncate, &acb);
2249 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
2250 bool exact, PreallocMode prealloc,
2251 BdrvRequestFlags flags, Error **errp)
2253 BDRVRawState *s = bs->opaque;
2257 if (fstat(s->fd, &st)) {
2259 error_setg_errno(errp, -ret, "Failed to fstat() the file");
2263 if (S_ISREG(st.st_mode)) {
2264 /* Always resizes to the exact @offset */
2265 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
2268 if (prealloc != PREALLOC_MODE_OFF) {
2269 error_setg(errp, "Preallocation mode '%s' unsupported for this "
2270 "non-regular file", PreallocMode_str(prealloc));
2274 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2275 int64_t cur_length = raw_getlength(bs);
2277 if (offset != cur_length && exact) {
2278 error_setg(errp, "Cannot resize device files");
2280 } else if (offset > cur_length) {
2281 error_setg(errp, "Cannot grow device files");
2285 error_setg(errp, "Resizing this file is not supported");
2293 static int64_t raw_getlength(BlockDriverState *bs)
2295 BDRVRawState *s = bs->opaque;
2301 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2302 struct disklabel dl;
2304 if (ioctl(fd, DIOCGDINFO, &dl))
2306 return (uint64_t)dl.d_secsize *
2307 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2311 #elif defined(__NetBSD__)
2312 static int64_t raw_getlength(BlockDriverState *bs)
2314 BDRVRawState *s = bs->opaque;
2320 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2321 struct dkwedge_info dkw;
2323 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
2324 return dkw.dkw_size * 512;
2326 struct disklabel dl;
2328 if (ioctl(fd, DIOCGDINFO, &dl))
2330 return (uint64_t)dl.d_secsize *
2331 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2336 #elif defined(__sun__)
2337 static int64_t raw_getlength(BlockDriverState *bs)
2339 BDRVRawState *s = bs->opaque;
2340 struct dk_minfo minfo;
2350 * Use the DKIOCGMEDIAINFO ioctl to read the size.
2352 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
2354 return minfo.dki_lbsize * minfo.dki_capacity;
2358 * There are reports that lseek on some devices fails, but
2359 * irc discussion said that contingency on contingency was overkill.
2361 size = lseek(s->fd, 0, SEEK_END);
2367 #elif defined(CONFIG_BSD)
2368 static int64_t raw_getlength(BlockDriverState *bs)
2370 BDRVRawState *s = bs->opaque;
2374 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2383 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2386 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2388 #ifdef DIOCGMEDIASIZE
2389 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size)) {
2396 if (ioctl(fd, DIOCGPART, &pi) == 0) {
2397 size = pi.media_size;
2401 #if defined(DKIOCGETBLOCKCOUNT) && defined(DKIOCGETBLOCKSIZE)
2403 uint64_t sectors = 0;
2404 uint32_t sector_size = 0;
2406 if (ioctl(fd, DKIOCGETBLOCKCOUNT, §ors) == 0
2407 && ioctl(fd, DKIOCGETBLOCKSIZE, §or_size) == 0) {
2408 size = sectors * sector_size;
2413 size = lseek(fd, 0LL, SEEK_END);
2418 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2421 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
2422 if (size == 2048LL * (unsigned)-1)
2424 /* XXX no disc? maybe we need to reopen... */
2425 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
2432 size = lseek(fd, 0, SEEK_END);
2440 static int64_t raw_getlength(BlockDriverState *bs)
2442 BDRVRawState *s = bs->opaque;
2451 size = lseek(s->fd, 0, SEEK_END);
2459 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
2462 BDRVRawState *s = bs->opaque;
2464 if (fstat(s->fd, &st) < 0) {
2467 return (int64_t)st.st_blocks * 512;
2470 static int coroutine_fn
2471 raw_co_create(BlockdevCreateOptions *options, Error **errp)
2473 BlockdevCreateOptionsFile *file_opts;
2474 Error *local_err = NULL;
2476 uint64_t perm, shared;
2479 /* Validate options and set default values */
2480 assert(options->driver == BLOCKDEV_DRIVER_FILE);
2481 file_opts = &options->u.file;
2483 if (!file_opts->has_nocow) {
2484 file_opts->nocow = false;
2486 if (!file_opts->has_preallocation) {
2487 file_opts->preallocation = PREALLOC_MODE_OFF;
2489 if (!file_opts->has_extent_size_hint) {
2490 file_opts->extent_size_hint = 1 * MiB;
2492 if (file_opts->extent_size_hint > UINT32_MAX) {
2494 error_setg(errp, "Extent size hint is too large");
2499 fd = qemu_create(file_opts->filename, O_RDWR | O_BINARY, 0644, errp);
2505 /* Take permissions: We want to discard everything, so we need
2506 * BLK_PERM_WRITE; and truncation to the desired size requires
2508 * On the other hand, we cannot share the RESIZE permission
2509 * because we promise that after this function, the file has the
2510 * size given in the options. If someone else were to resize it
2511 * concurrently, we could not guarantee that.
2512 * Note that after this function, we can no longer guarantee that
2513 * the file is not touched by a third party, so it may be resized
2515 perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2516 shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2518 /* Step one: Take locks */
2519 result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
2524 /* Step two: Check that nobody else has taken conflicting locks */
2525 result = raw_check_lock_bytes(fd, perm, shared, errp);
2527 error_append_hint(errp,
2528 "Is another process using the image [%s]?\n",
2529 file_opts->filename);
2533 /* Clear the file by truncating it to 0 */
2534 result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
2539 if (file_opts->nocow) {
2541 /* Set NOCOW flag to solve performance issue on fs like btrfs.
2542 * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
2543 * will be ignored since any failure of this operation should not
2544 * block the left work.
2547 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2548 attr |= FS_NOCOW_FL;
2549 ioctl(fd, FS_IOC_SETFLAGS, &attr);
2553 #ifdef FS_IOC_FSSETXATTR
2555 * Try to set the extent size hint. Failure is not fatal, and a warning is
2556 * only printed if the option was explicitly specified.
2559 struct fsxattr attr;
2560 result = ioctl(fd, FS_IOC_FSGETXATTR, &attr);
2562 attr.fsx_xflags |= FS_XFLAG_EXTSIZE;
2563 attr.fsx_extsize = file_opts->extent_size_hint;
2564 result = ioctl(fd, FS_IOC_FSSETXATTR, &attr);
2566 if (result < 0 && file_opts->has_extent_size_hint &&
2567 file_opts->extent_size_hint)
2569 warn_report("Failed to set extent size hint: %s",
2575 /* Resize and potentially preallocate the file to the desired
2577 result = raw_regular_truncate(NULL, fd, file_opts->size,
2578 file_opts->preallocation, errp);
2584 raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
2586 /* The above call should not fail, and if it does, that does
2587 * not mean the whole creation operation has failed. So
2588 * report it the user for their convenience, but do not report
2589 * it to the caller. */
2590 warn_report_err(local_err);
2594 if (qemu_close(fd) != 0 && result == 0) {
2596 error_setg_errno(errp, -result, "Could not close the new file");
2602 static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
2603 const char *filename,
2607 BlockdevCreateOptions options;
2608 int64_t total_size = 0;
2609 int64_t extent_size_hint = 0;
2610 bool has_extent_size_hint = false;
2612 PreallocMode prealloc;
2614 Error *local_err = NULL;
2616 /* Skip file: protocol prefix */
2617 strstart(filename, "file:", &filename);
2619 /* Read out options */
2620 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2622 if (qemu_opt_get(opts, BLOCK_OPT_EXTENT_SIZE_HINT)) {
2623 has_extent_size_hint = true;
2625 qemu_opt_get_size_del(opts, BLOCK_OPT_EXTENT_SIZE_HINT, -1);
2627 nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
2628 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2629 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
2630 PREALLOC_MODE_OFF, &local_err);
2633 error_propagate(errp, local_err);
2637 options = (BlockdevCreateOptions) {
2638 .driver = BLOCKDEV_DRIVER_FILE,
2640 .filename = (char *) filename,
2642 .has_preallocation = true,
2643 .preallocation = prealloc,
2646 .has_extent_size_hint = has_extent_size_hint,
2647 .extent_size_hint = extent_size_hint,
2650 return raw_co_create(&options, errp);
2653 static int coroutine_fn raw_co_delete_file(BlockDriverState *bs,
2659 if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) {
2660 error_setg_errno(errp, ENOENT, "%s is not a regular file",
2665 ret = unlink(bs->filename);
2668 error_setg_errno(errp, -ret, "Error when deleting file %s",
2676 * Find allocation range in @bs around offset @start.
2677 * May change underlying file descriptor's file offset.
2678 * If @start is not in a hole, store @start in @data, and the
2679 * beginning of the next hole in @hole, and return 0.
2680 * If @start is in a non-trailing hole, store @start in @hole and the
2681 * beginning of the next non-hole in @data, and return 0.
2682 * If @start is in a trailing hole or beyond EOF, return -ENXIO.
2683 * If we can't find out, return a negative errno other than -ENXIO.
2685 static int find_allocation(BlockDriverState *bs, off_t start,
2686 off_t *data, off_t *hole)
2688 #if defined SEEK_HOLE && defined SEEK_DATA
2689 BDRVRawState *s = bs->opaque;
2694 * D1. offs == start: start is in data
2695 * D2. offs > start: start is in a hole, next data at offs
2696 * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
2697 * or start is beyond EOF
2698 * If the latter happens, the file has been truncated behind
2699 * our back since we opened it. All bets are off then.
2700 * Treating like a trailing hole is simplest.
2701 * D4. offs < 0, errno != ENXIO: we learned nothing
2703 offs = lseek(s->fd, start, SEEK_DATA);
2705 return -errno; /* D3 or D4 */
2709 /* This is not a valid return by lseek(). We are safe to just return
2710 * -EIO in this case, and we'll treat it like D4. */
2715 /* D2: in hole, next data at offs */
2721 /* D1: in data, end not yet known */
2725 * H1. offs == start: start is in a hole
2726 * If this happens here, a hole has been dug behind our back
2727 * since the previous lseek().
2728 * H2. offs > start: either start is in data, next hole at offs,
2729 * or start is in trailing hole, EOF at offs
2730 * Linux treats trailing holes like any other hole: offs ==
2731 * start. Solaris seeks to EOF instead: offs > start (blech).
2732 * If that happens here, a hole has been dug behind our back
2733 * since the previous lseek().
2734 * H3. offs < 0, errno = ENXIO: start is beyond EOF
2735 * If this happens, the file has been truncated behind our
2736 * back since we opened it. Treat it like a trailing hole.
2737 * H4. offs < 0, errno != ENXIO: we learned nothing
2738 * Pretend we know nothing at all, i.e. "forget" about D1.
2740 offs = lseek(s->fd, start, SEEK_HOLE);
2742 return -errno; /* D1 and (H3 or H4) */
2746 /* This is not a valid return by lseek(). We are safe to just return
2747 * -EIO in this case, and we'll treat it like H4. */
2753 * D1 and H2: either in data, next hole at offs, or it was in
2754 * data but is now in a trailing hole. In the latter case,
2755 * all bets are off. Treating it as if it there was data all
2756 * the way to EOF is safe, so simply do that.
2771 * Returns the allocation status of the specified offset.
2773 * The block layer guarantees 'offset' and 'bytes' are within bounds.
2775 * 'pnum' is set to the number of bytes (including and immediately following
2776 * the specified offset) that are known to be in the same
2777 * allocated/unallocated state.
2779 * 'bytes' is a soft cap for 'pnum'. If the information is free, 'pnum' may
2782 static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
2785 int64_t bytes, int64_t *pnum,
2787 BlockDriverState **file)
2789 off_t data = 0, hole = 0;
2792 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
2803 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
2806 ret = find_allocation(bs, offset, &data, &hole);
2807 if (ret == -ENXIO) {
2810 ret = BDRV_BLOCK_ZERO;
2811 } else if (ret < 0) {
2812 /* No info available, so pretend there are no holes */
2814 ret = BDRV_BLOCK_DATA;
2815 } else if (data == offset) {
2816 /* On a data extent, compute bytes to the end of the extent,
2817 * possibly including a partial sector at EOF. */
2818 *pnum = hole - offset;
2821 * We are not allowed to return partial sectors, though, so
2822 * round up if necessary.
2824 if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
2825 int64_t file_length = raw_getlength(bs);
2826 if (file_length > 0) {
2827 /* Ignore errors, this is just a safeguard */
2828 assert(hole == file_length);
2830 *pnum = ROUND_UP(*pnum, bs->bl.request_alignment);
2833 ret = BDRV_BLOCK_DATA;
2835 /* On a hole, compute bytes to the beginning of the next extent. */
2836 assert(hole == offset);
2837 *pnum = data - offset;
2838 ret = BDRV_BLOCK_ZERO;
2842 return ret | BDRV_BLOCK_OFFSET_VALID;
2845 #if defined(__linux__)
2846 /* Verify that the file is not in the page cache */
2847 static void check_cache_dropped(BlockDriverState *bs, Error **errp)
2849 const size_t window_size = 128 * 1024 * 1024;
2850 BDRVRawState *s = bs->opaque;
2851 void *window = NULL;
2858 /* mincore(2) page status information requires 1 byte per page */
2859 page_size = sysconf(_SC_PAGESIZE);
2860 vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
2862 end = raw_getlength(bs);
2864 for (offset = 0; offset < end; offset += window_size) {
2871 /* Unmap previous window if size has changed */
2872 new_length = MIN(end - offset, window_size);
2873 if (new_length != length) {
2874 munmap(window, length);
2879 new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
2881 if (new_window == MAP_FAILED) {
2882 error_setg_errno(errp, errno, "mmap failed");
2886 window = new_window;
2887 length = new_length;
2889 ret = mincore(window, length, vec);
2891 error_setg_errno(errp, errno, "mincore failed");
2895 vec_end = DIV_ROUND_UP(length, page_size);
2896 for (i = 0; i < vec_end; i++) {
2902 error_setg(errp, "page cache still in use!");
2908 munmap(window, length);
2913 #endif /* __linux__ */
2915 static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs,
2918 BDRVRawState *s = bs->opaque;
2923 error_setg_errno(errp, -ret, "The file descriptor is not open");
2927 if (!s->drop_cache) {
2931 if (s->open_flags & O_DIRECT) {
2932 return; /* No host kernel page cache */
2935 #if defined(__linux__)
2936 /* This sets the scene for the next syscall... */
2937 ret = bdrv_co_flush(bs);
2939 error_setg_errno(errp, -ret, "flush failed");
2943 /* Linux does not invalidate pages that are dirty, locked, or mmapped by a
2944 * process. These limitations are okay because we just fsynced the file,
2945 * we don't use mmap, and the file should not be in use by other processes.
2947 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
2948 if (ret != 0) { /* the return value is a positive errno */
2949 error_setg_errno(errp, ret, "fadvise failed");
2953 if (s->check_cache_dropped) {
2954 check_cache_dropped(bs, errp);
2956 #else /* __linux__ */
2957 /* Do nothing. Live migration to a remote host with cache.direct=off is
2958 * unsupported on other host operating systems. Cache consistency issues
2959 * may occur but no error is reported here, partly because that's the
2960 * historical behavior and partly because it's hard to differentiate valid
2961 * configurations that should not cause errors.
2963 #endif /* !__linux__ */
2966 static void raw_account_discard(BDRVRawState *s, uint64_t nbytes, int ret)
2969 s->stats.discard_nb_failed++;
2971 s->stats.discard_nb_ok++;
2972 s->stats.discard_bytes_ok += nbytes;
2976 static coroutine_fn int
2977 raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes,
2980 BDRVRawState *s = bs->opaque;
2981 RawPosixAIOData acb;
2984 acb = (RawPosixAIOData) {
2986 .aio_fildes = s->fd,
2987 .aio_type = QEMU_AIO_DISCARD,
2988 .aio_offset = offset,
2989 .aio_nbytes = bytes,
2993 acb.aio_type |= QEMU_AIO_BLKDEV;
2996 ret = raw_thread_pool_submit(bs, handle_aiocb_discard, &acb);
2997 raw_account_discard(s, bytes, ret);
3001 static coroutine_fn int
3002 raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
3004 return raw_do_pdiscard(bs, offset, bytes, false);
3007 static int coroutine_fn
3008 raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
3009 BdrvRequestFlags flags, bool blkdev)
3011 BDRVRawState *s = bs->opaque;
3012 RawPosixAIOData acb;
3013 ThreadPoolFunc *handler;
3015 #ifdef CONFIG_FALLOCATE
3016 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
3017 BdrvTrackedRequest *req;
3020 * This is a workaround for a bug in the Linux XFS driver,
3021 * where writes submitted through the AIO interface will be
3022 * discarded if they happen beyond a concurrently running
3023 * fallocate() that increases the file length (i.e., both the
3024 * write and the fallocate() happen beyond the EOF).
3026 * To work around it, we extend the tracked request for this
3027 * zero write until INT64_MAX (effectively infinity), and mark
3028 * it as serializing.
3030 * We have to enable this workaround for all filesystems and
3031 * AIO modes (not just XFS with aio=native), because for
3032 * remote filesystems we do not know the host configuration.
3035 req = bdrv_co_get_self_request(bs);
3037 assert(req->type == BDRV_TRACKED_WRITE);
3038 assert(req->offset <= offset);
3039 assert(req->offset + req->bytes >= offset + bytes);
3041 req->bytes = BDRV_MAX_LENGTH - req->offset;
3043 bdrv_check_request(req->offset, req->bytes, &error_abort);
3045 bdrv_make_request_serialising(req, bs->bl.request_alignment);
3049 acb = (RawPosixAIOData) {
3051 .aio_fildes = s->fd,
3052 .aio_type = QEMU_AIO_WRITE_ZEROES,
3053 .aio_offset = offset,
3054 .aio_nbytes = bytes,
3058 acb.aio_type |= QEMU_AIO_BLKDEV;
3060 if (flags & BDRV_REQ_NO_FALLBACK) {
3061 acb.aio_type |= QEMU_AIO_NO_FALLBACK;
3064 if (flags & BDRV_REQ_MAY_UNMAP) {
3065 acb.aio_type |= QEMU_AIO_DISCARD;
3066 handler = handle_aiocb_write_zeroes_unmap;
3068 handler = handle_aiocb_write_zeroes;
3071 return raw_thread_pool_submit(bs, handler, &acb);
3074 static int coroutine_fn raw_co_pwrite_zeroes(
3075 BlockDriverState *bs, int64_t offset,
3076 int64_t bytes, BdrvRequestFlags flags)
3078 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, false);
3081 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3086 static BlockStatsSpecificFile get_blockstats_specific_file(BlockDriverState *bs)
3088 BDRVRawState *s = bs->opaque;
3089 return (BlockStatsSpecificFile) {
3090 .discard_nb_ok = s->stats.discard_nb_ok,
3091 .discard_nb_failed = s->stats.discard_nb_failed,
3092 .discard_bytes_ok = s->stats.discard_bytes_ok,
3096 static BlockStatsSpecific *raw_get_specific_stats(BlockDriverState *bs)
3098 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3100 stats->driver = BLOCKDEV_DRIVER_FILE;
3101 stats->u.file = get_blockstats_specific_file(bs);
3106 #if defined(HAVE_HOST_BLOCK_DEVICE)
3107 static BlockStatsSpecific *hdev_get_specific_stats(BlockDriverState *bs)
3109 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3111 stats->driver = BLOCKDEV_DRIVER_HOST_DEVICE;
3112 stats->u.host_device = get_blockstats_specific_file(bs);
3116 #endif /* HAVE_HOST_BLOCK_DEVICE */
3118 static QemuOptsList raw_create_opts = {
3119 .name = "raw-create-opts",
3120 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
3123 .name = BLOCK_OPT_SIZE,
3124 .type = QEMU_OPT_SIZE,
3125 .help = "Virtual disk size"
3128 .name = BLOCK_OPT_NOCOW,
3129 .type = QEMU_OPT_BOOL,
3130 .help = "Turn off copy-on-write (valid only on btrfs)"
3133 .name = BLOCK_OPT_PREALLOC,
3134 .type = QEMU_OPT_STRING,
3135 .help = "Preallocation mode (allowed values: off"
3136 #ifdef CONFIG_POSIX_FALLOCATE
3142 .name = BLOCK_OPT_EXTENT_SIZE_HINT,
3143 .type = QEMU_OPT_SIZE,
3144 .help = "Extent size hint for the image file, 0 to disable"
3146 { /* end of list */ }
3150 static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
3153 BDRVRawState *s = bs->opaque;
3154 int input_flags = s->reopen_state ? s->reopen_state->flags : bs->open_flags;
3158 /* We may need a new fd if auto-read-only switches the mode */
3159 ret = raw_reconfigure_getfd(bs, input_flags, &open_flags, perm,
3163 } else if (ret != s->fd) {
3164 Error *local_err = NULL;
3167 * Fail already check_perm() if we can't get a working O_DIRECT
3168 * alignment with the new fd.
3170 raw_probe_alignment(bs, ret, &local_err);
3172 error_propagate(errp, local_err);
3176 s->perm_change_fd = ret;
3177 s->perm_change_flags = open_flags;
3180 /* Prepare permissions on old fd to avoid conflicts between old and new,
3181 * but keep everything locked that new will need. */
3182 ret = raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
3187 /* Copy locks to the new fd */
3188 if (s->perm_change_fd && s->use_lock) {
3189 ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared,
3192 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3199 if (s->perm_change_fd) {
3200 qemu_close(s->perm_change_fd);
3202 s->perm_change_fd = 0;
3206 static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
3208 BDRVRawState *s = bs->opaque;
3210 /* For reopen, we have already switched to the new fd (.bdrv_set_perm is
3211 * called after .bdrv_reopen_commit) */
3212 if (s->perm_change_fd && s->fd != s->perm_change_fd) {
3214 s->fd = s->perm_change_fd;
3215 s->open_flags = s->perm_change_flags;
3217 s->perm_change_fd = 0;
3219 raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
3221 s->shared_perm = shared;
3224 static void raw_abort_perm_update(BlockDriverState *bs)
3226 BDRVRawState *s = bs->opaque;
3228 /* For reopen, .bdrv_reopen_abort is called afterwards and will close
3229 * the file descriptor. */
3230 if (s->perm_change_fd) {
3231 qemu_close(s->perm_change_fd);
3233 s->perm_change_fd = 0;
3235 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3238 static int coroutine_fn raw_co_copy_range_from(
3239 BlockDriverState *bs, BdrvChild *src, int64_t src_offset,
3240 BdrvChild *dst, int64_t dst_offset, int64_t bytes,
3241 BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
3243 return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
3244 read_flags, write_flags);
3247 static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
3253 BdrvRequestFlags read_flags,
3254 BdrvRequestFlags write_flags)
3256 RawPosixAIOData acb;
3257 BDRVRawState *s = bs->opaque;
3258 BDRVRawState *src_s;
3260 assert(dst->bs == bs);
3261 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
3265 src_s = src->bs->opaque;
3266 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) {
3270 acb = (RawPosixAIOData) {
3272 .aio_type = QEMU_AIO_COPY_RANGE,
3273 .aio_fildes = src_s->fd,
3274 .aio_offset = src_offset,
3275 .aio_nbytes = bytes,
3278 .aio_offset2 = dst_offset,
3282 return raw_thread_pool_submit(bs, handle_aiocb_copy_range, &acb);
3285 BlockDriver bdrv_file = {
3286 .format_name = "file",
3287 .protocol_name = "file",
3288 .instance_size = sizeof(BDRVRawState),
3289 .bdrv_needs_filename = true,
3290 .bdrv_probe = NULL, /* no probe for protocols */
3291 .bdrv_parse_filename = raw_parse_filename,
3292 .bdrv_file_open = raw_open,
3293 .bdrv_reopen_prepare = raw_reopen_prepare,
3294 .bdrv_reopen_commit = raw_reopen_commit,
3295 .bdrv_reopen_abort = raw_reopen_abort,
3296 .bdrv_close = raw_close,
3297 .bdrv_co_create = raw_co_create,
3298 .bdrv_co_create_opts = raw_co_create_opts,
3299 .bdrv_has_zero_init = bdrv_has_zero_init_1,
3300 .bdrv_co_block_status = raw_co_block_status,
3301 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3302 .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
3303 .bdrv_co_delete_file = raw_co_delete_file,
3305 .bdrv_co_preadv = raw_co_preadv,
3306 .bdrv_co_pwritev = raw_co_pwritev,
3307 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3308 .bdrv_co_pdiscard = raw_co_pdiscard,
3309 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3310 .bdrv_co_copy_range_to = raw_co_copy_range_to,
3311 .bdrv_refresh_limits = raw_refresh_limits,
3312 .bdrv_io_plug = raw_aio_plug,
3313 .bdrv_io_unplug = raw_aio_unplug,
3314 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3316 .bdrv_co_truncate = raw_co_truncate,
3317 .bdrv_getlength = raw_getlength,
3318 .bdrv_get_info = raw_get_info,
3319 .bdrv_get_allocated_file_size
3320 = raw_get_allocated_file_size,
3321 .bdrv_get_specific_stats = raw_get_specific_stats,
3322 .bdrv_check_perm = raw_check_perm,
3323 .bdrv_set_perm = raw_set_perm,
3324 .bdrv_abort_perm_update = raw_abort_perm_update,
3325 .create_opts = &raw_create_opts,
3326 .mutable_opts = mutable_opts,
3329 /***********************************************/
3332 #if defined(HAVE_HOST_BLOCK_DEVICE)
3334 #if defined(__APPLE__) && defined(__MACH__)
3335 static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3336 CFIndex maxPathSize, int flags);
3338 #if !defined(MAC_OS_VERSION_12_0) \
3339 || (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_12_0)
3340 #define IOMainPort IOMasterPort
3343 static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
3345 kern_return_t kernResult = KERN_FAILURE;
3346 mach_port_t mainPort;
3347 CFMutableDictionaryRef classesToMatch;
3348 const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
3349 char *mediaType = NULL;
3351 kernResult = IOMainPort(MACH_PORT_NULL, &mainPort);
3352 if ( KERN_SUCCESS != kernResult ) {
3353 printf("IOMainPort returned %d\n", kernResult);
3357 for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
3358 classesToMatch = IOServiceMatching(matching_array[index]);
3359 if (classesToMatch == NULL) {
3360 error_report("IOServiceMatching returned NULL for %s",
3361 matching_array[index]);
3364 CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
3366 kernResult = IOServiceGetMatchingServices(mainPort, classesToMatch,
3368 if (kernResult != KERN_SUCCESS) {
3369 error_report("Note: IOServiceGetMatchingServices returned %d",
3374 /* If a match was found, leave the loop */
3375 if (*mediaIterator != 0) {
3376 trace_file_FindEjectableOpticalMedia(matching_array[index]);
3377 mediaType = g_strdup(matching_array[index]);
3384 kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3385 CFIndex maxPathSize, int flags)
3387 io_object_t nextMedia;
3388 kern_return_t kernResult = KERN_FAILURE;
3390 nextMedia = IOIteratorNext( mediaIterator );
3393 CFTypeRef bsdPathAsCFString;
3394 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
3395 if ( bsdPathAsCFString ) {
3396 size_t devPathLength;
3397 strcpy( bsdPath, _PATH_DEV );
3398 if (flags & BDRV_O_NOCACHE) {
3399 strcat(bsdPath, "r");
3401 devPathLength = strlen( bsdPath );
3402 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
3403 kernResult = KERN_SUCCESS;
3405 CFRelease( bsdPathAsCFString );
3407 IOObjectRelease( nextMedia );
3413 /* Sets up a real cdrom for use in QEMU */
3414 static bool setup_cdrom(char *bsd_path, Error **errp)
3416 int index, num_of_test_partitions = 2, fd;
3417 char test_partition[MAXPATHLEN];
3418 bool partition_found = false;
3420 /* look for a working partition */
3421 for (index = 0; index < num_of_test_partitions; index++) {
3422 snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
3424 fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE, NULL);
3426 partition_found = true;
3432 /* if a working partition on the device was not found */
3433 if (partition_found == false) {
3434 error_setg(errp, "Failed to find a working partition on disc");
3436 trace_file_setup_cdrom(test_partition);
3437 pstrcpy(bsd_path, MAXPATHLEN, test_partition);
3439 return partition_found;
3442 /* Prints directions on mounting and unmounting a device */
3443 static void print_unmounting_directions(const char *file_name)
3445 error_report("If device %s is mounted on the desktop, unmount"
3446 " it first before using it in QEMU", file_name);
3447 error_report("Command to unmount device: diskutil unmountDisk %s",
3449 error_report("Command to mount device: diskutil mountDisk %s", file_name);
3452 #endif /* defined(__APPLE__) && defined(__MACH__) */
3454 static int hdev_probe_device(const char *filename)
3458 /* allow a dedicated CD-ROM driver to match with a higher priority */
3459 if (strstart(filename, "/dev/cdrom", NULL))
3462 if (stat(filename, &st) >= 0 &&
3463 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
3470 static void hdev_parse_filename(const char *filename, QDict *options,
3473 bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
3476 static bool hdev_is_sg(BlockDriverState *bs)
3479 #if defined(__linux__)
3481 BDRVRawState *s = bs->opaque;
3483 struct sg_scsi_id scsiid;
3487 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
3491 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
3496 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
3498 trace_file_hdev_is_sg(scsiid.scsi_type, sg_version);
3507 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
3510 BDRVRawState *s = bs->opaque;
3513 #if defined(__APPLE__) && defined(__MACH__)
3515 * Caution: while qdict_get_str() is fine, getting non-string types
3516 * would require more care. When @options come from -blockdev or
3517 * blockdev_add, its members are typed according to the QAPI
3518 * schema, but when they come from -drive, they're all QString.
3520 const char *filename = qdict_get_str(options, "filename");
3521 char bsd_path[MAXPATHLEN] = "";
3522 bool error_occurred = false;
3524 /* If using a real cdrom */
3525 if (strcmp(filename, "/dev/cdrom") == 0) {
3526 char *mediaType = NULL;
3527 kern_return_t ret_val;
3528 io_iterator_t mediaIterator = 0;
3530 mediaType = FindEjectableOpticalMedia(&mediaIterator);
3531 if (mediaType == NULL) {
3532 error_setg(errp, "Please make sure your CD/DVD is in the optical"
3534 error_occurred = true;
3535 goto hdev_open_Mac_error;
3538 ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
3539 if (ret_val != KERN_SUCCESS) {
3540 error_setg(errp, "Could not get BSD path for optical drive");
3541 error_occurred = true;
3542 goto hdev_open_Mac_error;
3545 /* If a real optical drive was not found */
3546 if (bsd_path[0] == '\0') {
3547 error_setg(errp, "Failed to obtain bsd path for optical drive");
3548 error_occurred = true;
3549 goto hdev_open_Mac_error;
3552 /* If using a cdrom disc and finding a partition on the disc failed */
3553 if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
3554 setup_cdrom(bsd_path, errp) == false) {
3555 print_unmounting_directions(bsd_path);
3556 error_occurred = true;
3557 goto hdev_open_Mac_error;
3560 qdict_put_str(options, "filename", bsd_path);
3562 hdev_open_Mac_error:
3564 if (mediaIterator) {
3565 IOObjectRelease(mediaIterator);
3567 if (error_occurred) {
3571 #endif /* defined(__APPLE__) && defined(__MACH__) */
3573 s->type = FTYPE_FILE;
3575 ret = raw_open_common(bs, options, flags, 0, true, errp);
3577 #if defined(__APPLE__) && defined(__MACH__)
3579 filename = bsd_path;
3581 /* if a physical device experienced an error while being opened */
3582 if (strncmp(filename, "/dev/", 5) == 0) {
3583 print_unmounting_directions(filename);
3585 #endif /* defined(__APPLE__) && defined(__MACH__) */
3589 /* Since this does ioctl the device must be already opened */
3590 bs->sg = hdev_is_sg(bs);
3595 #if defined(__linux__)
3596 static int coroutine_fn
3597 hdev_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
3599 BDRVRawState *s = bs->opaque;
3600 RawPosixAIOData acb;
3608 if (req == SG_IO && s->pr_mgr) {
3609 struct sg_io_hdr *io_hdr = buf;
3610 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
3611 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
3612 return pr_manager_execute(s->pr_mgr, bdrv_get_aio_context(bs),
3617 acb = (RawPosixAIOData) {
3619 .aio_type = QEMU_AIO_IOCTL,
3620 .aio_fildes = s->fd,
3628 return raw_thread_pool_submit(bs, handle_aiocb_ioctl, &acb);
3632 static coroutine_fn int
3633 hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
3635 BDRVRawState *s = bs->opaque;
3640 raw_account_discard(s, bytes, ret);
3643 return raw_do_pdiscard(bs, offset, bytes, true);
3646 static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
3647 int64_t offset, int64_t bytes, BdrvRequestFlags flags)
3656 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
3659 static BlockDriver bdrv_host_device = {
3660 .format_name = "host_device",
3661 .protocol_name = "host_device",
3662 .instance_size = sizeof(BDRVRawState),
3663 .bdrv_needs_filename = true,
3664 .bdrv_probe_device = hdev_probe_device,
3665 .bdrv_parse_filename = hdev_parse_filename,
3666 .bdrv_file_open = hdev_open,
3667 .bdrv_close = raw_close,
3668 .bdrv_reopen_prepare = raw_reopen_prepare,
3669 .bdrv_reopen_commit = raw_reopen_commit,
3670 .bdrv_reopen_abort = raw_reopen_abort,
3671 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3672 .create_opts = &bdrv_create_opts_simple,
3673 .mutable_opts = mutable_opts,
3674 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3675 .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
3677 .bdrv_co_preadv = raw_co_preadv,
3678 .bdrv_co_pwritev = raw_co_pwritev,
3679 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3680 .bdrv_co_pdiscard = hdev_co_pdiscard,
3681 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3682 .bdrv_co_copy_range_to = raw_co_copy_range_to,
3683 .bdrv_refresh_limits = raw_refresh_limits,
3684 .bdrv_io_plug = raw_aio_plug,
3685 .bdrv_io_unplug = raw_aio_unplug,
3686 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3688 .bdrv_co_truncate = raw_co_truncate,
3689 .bdrv_getlength = raw_getlength,
3690 .bdrv_get_info = raw_get_info,
3691 .bdrv_get_allocated_file_size
3692 = raw_get_allocated_file_size,
3693 .bdrv_get_specific_stats = hdev_get_specific_stats,
3694 .bdrv_check_perm = raw_check_perm,
3695 .bdrv_set_perm = raw_set_perm,
3696 .bdrv_abort_perm_update = raw_abort_perm_update,
3697 .bdrv_probe_blocksizes = hdev_probe_blocksizes,
3698 .bdrv_probe_geometry = hdev_probe_geometry,
3700 /* generic scsi device */
3702 .bdrv_co_ioctl = hdev_co_ioctl,
3706 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3707 static void cdrom_parse_filename(const char *filename, QDict *options,
3710 bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
3715 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3718 BDRVRawState *s = bs->opaque;
3722 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
3723 return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp);
3726 static int cdrom_probe_device(const char *filename)
3732 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK, NULL);
3736 ret = fstat(fd, &st);
3737 if (ret == -1 || !S_ISBLK(st.st_mode)) {
3741 /* Attempt to detect via a CDROM specific ioctl */
3742 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3752 static bool cdrom_is_inserted(BlockDriverState *bs)
3754 BDRVRawState *s = bs->opaque;
3757 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3758 return ret == CDS_DISC_OK;
3761 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3763 BDRVRawState *s = bs->opaque;
3766 if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
3767 perror("CDROMEJECT");
3769 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
3770 perror("CDROMEJECT");
3774 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3776 BDRVRawState *s = bs->opaque;
3778 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
3780 * Note: an error can happen if the distribution automatically
3783 /* perror("CDROM_LOCKDOOR"); */
3787 static BlockDriver bdrv_host_cdrom = {
3788 .format_name = "host_cdrom",
3789 .protocol_name = "host_cdrom",
3790 .instance_size = sizeof(BDRVRawState),
3791 .bdrv_needs_filename = true,
3792 .bdrv_probe_device = cdrom_probe_device,
3793 .bdrv_parse_filename = cdrom_parse_filename,
3794 .bdrv_file_open = cdrom_open,
3795 .bdrv_close = raw_close,
3796 .bdrv_reopen_prepare = raw_reopen_prepare,
3797 .bdrv_reopen_commit = raw_reopen_commit,
3798 .bdrv_reopen_abort = raw_reopen_abort,
3799 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3800 .create_opts = &bdrv_create_opts_simple,
3801 .mutable_opts = mutable_opts,
3802 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3804 .bdrv_co_preadv = raw_co_preadv,
3805 .bdrv_co_pwritev = raw_co_pwritev,
3806 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3807 .bdrv_refresh_limits = raw_refresh_limits,
3808 .bdrv_io_plug = raw_aio_plug,
3809 .bdrv_io_unplug = raw_aio_unplug,
3810 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3812 .bdrv_co_truncate = raw_co_truncate,
3813 .bdrv_getlength = raw_getlength,
3814 .has_variable_length = true,
3815 .bdrv_get_allocated_file_size
3816 = raw_get_allocated_file_size,
3818 /* removable device support */
3819 .bdrv_is_inserted = cdrom_is_inserted,
3820 .bdrv_eject = cdrom_eject,
3821 .bdrv_lock_medium = cdrom_lock_medium,
3823 /* generic scsi device */
3824 .bdrv_co_ioctl = hdev_co_ioctl,
3826 #endif /* __linux__ */
3828 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
3829 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3832 BDRVRawState *s = bs->opaque;
3837 ret = raw_open_common(bs, options, flags, 0, true, errp);
3842 /* make sure the door isn't locked at this time */
3843 ioctl(s->fd, CDIOCALLOW);
3847 static int cdrom_probe_device(const char *filename)
3849 if (strstart(filename, "/dev/cd", NULL) ||
3850 strstart(filename, "/dev/acd", NULL))
3855 static int cdrom_reopen(BlockDriverState *bs)
3857 BDRVRawState *s = bs->opaque;
3861 * Force reread of possibly changed/newly loaded disc,
3862 * FreeBSD seems to not notice sometimes...
3866 fd = qemu_open(bs->filename, s->open_flags, NULL);
3873 /* make sure the door isn't locked at this time */
3874 ioctl(s->fd, CDIOCALLOW);
3878 static bool cdrom_is_inserted(BlockDriverState *bs)
3880 return raw_getlength(bs) > 0;
3883 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3885 BDRVRawState *s = bs->opaque;
3890 (void) ioctl(s->fd, CDIOCALLOW);
3893 if (ioctl(s->fd, CDIOCEJECT) < 0)
3894 perror("CDIOCEJECT");
3896 if (ioctl(s->fd, CDIOCCLOSE) < 0)
3897 perror("CDIOCCLOSE");
3903 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3905 BDRVRawState *s = bs->opaque;
3909 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
3911 * Note: an error can happen if the distribution automatically
3914 /* perror("CDROM_LOCKDOOR"); */
3918 static BlockDriver bdrv_host_cdrom = {
3919 .format_name = "host_cdrom",
3920 .protocol_name = "host_cdrom",
3921 .instance_size = sizeof(BDRVRawState),
3922 .bdrv_needs_filename = true,
3923 .bdrv_probe_device = cdrom_probe_device,
3924 .bdrv_parse_filename = cdrom_parse_filename,
3925 .bdrv_file_open = cdrom_open,
3926 .bdrv_close = raw_close,
3927 .bdrv_reopen_prepare = raw_reopen_prepare,
3928 .bdrv_reopen_commit = raw_reopen_commit,
3929 .bdrv_reopen_abort = raw_reopen_abort,
3930 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3931 .create_opts = &bdrv_create_opts_simple,
3932 .mutable_opts = mutable_opts,
3934 .bdrv_co_preadv = raw_co_preadv,
3935 .bdrv_co_pwritev = raw_co_pwritev,
3936 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3937 .bdrv_refresh_limits = raw_refresh_limits,
3938 .bdrv_io_plug = raw_aio_plug,
3939 .bdrv_io_unplug = raw_aio_unplug,
3940 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3942 .bdrv_co_truncate = raw_co_truncate,
3943 .bdrv_getlength = raw_getlength,
3944 .has_variable_length = true,
3945 .bdrv_get_allocated_file_size
3946 = raw_get_allocated_file_size,
3948 /* removable device support */
3949 .bdrv_is_inserted = cdrom_is_inserted,
3950 .bdrv_eject = cdrom_eject,
3951 .bdrv_lock_medium = cdrom_lock_medium,
3953 #endif /* __FreeBSD__ */
3955 #endif /* HAVE_HOST_BLOCK_DEVICE */
3957 static void bdrv_file_init(void)
3960 * Register all the drivers. Note that order is important, the driver
3961 * registered last will get probed first.
3963 bdrv_register(&bdrv_file);
3964 #if defined(HAVE_HOST_BLOCK_DEVICE)
3965 bdrv_register(&bdrv_host_device);
3967 bdrv_register(&bdrv_host_cdrom);
3969 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3970 bdrv_register(&bdrv_host_cdrom);
3972 #endif /* HAVE_HOST_BLOCK_DEVICE */
3975 block_init(bdrv_file_init);