Merge tag 'qemu-macppc-20230206' of https://github.com/mcayland/qemu into staging
[qemu.git] / block / file-posix.c
blobd3073a7caa9e8a433bcead9a6362247fe6a4fad1
1 /*
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
22 * THE SOFTWARE.
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-io.h"
30 #include "block/block_int.h"
31 #include "qemu/module.h"
32 #include "qemu/option.h"
33 #include "qemu/units.h"
34 #include "qemu/memalign.h"
35 #include "trace.h"
36 #include "block/thread-pool.h"
37 #include "qemu/iov.h"
38 #include "block/raw-aio.h"
39 #include "qapi/qmp/qdict.h"
40 #include "qapi/qmp/qstring.h"
42 #include "scsi/pr-manager.h"
43 #include "scsi/constants.h"
45 #if defined(__APPLE__) && (__MACH__)
46 #include <sys/ioctl.h>
47 #if defined(HAVE_HOST_BLOCK_DEVICE)
48 #include <paths.h>
49 #include <sys/param.h>
50 #include <sys/mount.h>
51 #include <IOKit/IOKitLib.h>
52 #include <IOKit/IOBSD.h>
53 #include <IOKit/storage/IOMediaBSDClient.h>
54 #include <IOKit/storage/IOMedia.h>
55 #include <IOKit/storage/IOCDMedia.h>
56 //#include <IOKit/storage/IOCDTypes.h>
57 #include <IOKit/storage/IODVDMedia.h>
58 #include <CoreFoundation/CoreFoundation.h>
59 #endif /* defined(HAVE_HOST_BLOCK_DEVICE) */
60 #endif
62 #ifdef __sun__
63 #define _POSIX_PTHREAD_SEMANTICS 1
64 #include <sys/dkio.h>
65 #endif
66 #ifdef __linux__
67 #include <sys/ioctl.h>
68 #include <sys/param.h>
69 #include <sys/syscall.h>
70 #include <sys/vfs.h>
71 #include <linux/cdrom.h>
72 #include <linux/fd.h>
73 #include <linux/fs.h>
74 #include <linux/hdreg.h>
75 #include <linux/magic.h>
76 #include <scsi/sg.h>
77 #ifdef __s390__
78 #include <asm/dasd.h>
79 #endif
80 #ifndef FS_NOCOW_FL
81 #define FS_NOCOW_FL 0x00800000 /* Do not cow file */
82 #endif
83 #endif
84 #if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
85 #include <linux/falloc.h>
86 #endif
87 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
88 #include <sys/disk.h>
89 #include <sys/cdio.h>
90 #endif
92 #ifdef __OpenBSD__
93 #include <sys/ioctl.h>
94 #include <sys/disklabel.h>
95 #include <sys/dkio.h>
96 #endif
98 #ifdef __NetBSD__
99 #include <sys/ioctl.h>
100 #include <sys/disklabel.h>
101 #include <sys/dkio.h>
102 #include <sys/disk.h>
103 #endif
105 #ifdef __DragonFly__
106 #include <sys/ioctl.h>
107 #include <sys/diskslice.h>
108 #endif
110 /* OS X does not have O_DSYNC */
111 #ifndef O_DSYNC
112 #ifdef O_SYNC
113 #define O_DSYNC O_SYNC
114 #elif defined(O_FSYNC)
115 #define O_DSYNC O_FSYNC
116 #endif
117 #endif
119 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
120 #ifndef O_DIRECT
121 #define O_DIRECT O_DSYNC
122 #endif
124 #define FTYPE_FILE 0
125 #define FTYPE_CD 1
127 #define MAX_BLOCKSIZE 4096
129 /* Posix file locking bytes. Libvirt takes byte 0, we start from higher bytes,
130 * leaving a few more bytes for its future use. */
131 #define RAW_LOCK_PERM_BASE 100
132 #define RAW_LOCK_SHARED_BASE 200
134 typedef struct BDRVRawState {
135 int fd;
136 bool use_lock;
137 int type;
138 int open_flags;
139 size_t buf_align;
141 /* The current permissions. */
142 uint64_t perm;
143 uint64_t shared_perm;
145 /* The perms bits whose corresponding bytes are already locked in
146 * s->fd. */
147 uint64_t locked_perm;
148 uint64_t locked_shared_perm;
150 uint64_t aio_max_batch;
152 int perm_change_fd;
153 int perm_change_flags;
154 BDRVReopenState *reopen_state;
156 bool has_discard:1;
157 bool has_write_zeroes:1;
158 bool use_linux_aio:1;
159 bool use_linux_io_uring:1;
160 int page_cache_inconsistent; /* errno from fdatasync failure */
161 bool has_fallocate;
162 bool needs_alignment;
163 bool force_alignment;
164 bool drop_cache;
165 bool check_cache_dropped;
166 struct {
167 uint64_t discard_nb_ok;
168 uint64_t discard_nb_failed;
169 uint64_t discard_bytes_ok;
170 } stats;
172 PRManager *pr_mgr;
173 } BDRVRawState;
175 typedef struct BDRVRawReopenState {
176 int open_flags;
177 bool drop_cache;
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) */
186 if (s->fd >= 0) {
187 return 0;
189 return -EIO;
192 static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs);
194 typedef struct RawPosixAIOData {
195 BlockDriverState *bs;
196 int aio_type;
197 int aio_fildes;
199 off_t aio_offset;
200 uint64_t aio_nbytes;
202 union {
203 struct {
204 struct iovec *iov;
205 int niov;
206 } io;
207 struct {
208 uint64_t cmd;
209 void *buf;
210 } ioctl;
211 struct {
212 int aio_fd2;
213 off_t aio_offset2;
214 } copy_range;
215 struct {
216 PreallocMode prealloc;
217 Error **errp;
218 } truncate;
220 } RawPosixAIOData;
222 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
223 static int cdrom_reopen(BlockDriverState *bs);
224 #endif
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, ...) \
232 do { \
233 if ((err) == EAGAIN || (err) == EACCES) { \
234 error_setg((errp), (fmt), ## __VA_ARGS__); \
235 } else { \
236 error_setg_errno((errp), (err), (fmt), ## __VA_ARGS__); \
238 } while (0)
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;
245 struct stat sb;
247 fname = *filename;
248 dp = strrchr(fname, '/');
249 if (lstat(fname, &sb) < 0) {
250 error_setg_file_open(errp, errno, fname);
251 return -errno;
254 if (!S_ISBLK(sb.st_mode)) {
255 return 0;
258 if (dp == NULL) {
259 snprintf(namebuf, PATH_MAX, "r%s", fname);
260 } else {
261 snprintf(namebuf, PATH_MAX, "%.*s/r%s",
262 (int)(dp - fname), fname, dp + 1);
264 *filename = namebuf;
265 warn_report("%s is a block device, using %s", fname, *filename);
267 return 0;
269 #else
270 static int raw_normalize_devicepath(const char **filename, Error **errp)
272 return 0;
274 #endif
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;
283 int i;
285 errno = ENOTSUP;
286 static const unsigned long ioctl_list[] = {
287 #ifdef BLKSSZGET
288 BLKSSZGET,
289 #endif
290 #ifdef DKIOCGETBLOCKSIZE
291 DKIOCGETBLOCKSIZE,
292 #endif
293 #ifdef DIOCGSECTORSIZE
294 DIOCGSECTORSIZE,
295 #endif
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], &sector_size) >= 0) {
301 *sector_size_p = sector_size;
302 success = true;
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)
316 #ifdef BLKPBSZGET
317 if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
318 return -errno;
320 return 0;
321 #else
322 return -ENOTSUP;
323 #endif
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)
336 #ifdef __linux__
337 struct statfs buf;
338 int ret;
340 ret = fstatfs(fd, &buf);
341 if (ret == 0 && buf.f_type == NFS_SUPER_MAGIC) {
342 return true;
344 #endif
345 return false;
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)) {
353 return true;
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);
367 if (ret >= 0) {
368 return true;
371 #ifdef __linux__
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) {
377 return true;
379 #endif
381 return false;
384 static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
386 BDRVRawState *s = bs->opaque;
387 char *buf;
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;
395 s->buf_align = 1;
396 return;
399 bs->bl.request_alignment = 0;
400 s->buf_align = 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;
406 #ifdef __linux__
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:
412 struct xfs_dioattr {
413 uint32_t d_mem;
414 uint32_t d_miniosz;
415 uint32_t d_maxiosz;
416 } da;
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; */
422 #endif
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
429 * request_alignment.
432 if (!bs->bl.request_alignment) {
433 int i;
434 size_t align;
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;
441 break;
444 qemu_vfree(buf);
447 if (!s->buf_align) {
448 int i;
449 size_t 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;
456 break;
459 qemu_vfree(buf);
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
477 * properly.
479 struct stat st;
480 int readonly = 0;
482 if (fstat(fd, &st)) {
483 return -errno;
486 if (!S_ISBLK(st.st_mode)) {
487 return 0;
490 if (ioctl(fd, BLKROGET, &readonly) < 0) {
491 return -errno;
494 if (readonly) {
495 return -EACCES;
497 #endif /* defined(BLKROGET) */
498 return 0;
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) {
512 read_write = true;
515 if (read_write) {
516 *open_flags |= O_RDWR;
517 } else {
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,
529 Error **errp)
531 bdrv_parse_filename_strip_prefix(filename, "file:", options);
534 static QemuOptsList raw_runtime_opts = {
535 .name = "raw",
536 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
537 .desc = {
539 .name = "filename",
540 .type = QEMU_OPT_STRING,
541 .help = "File name of the image",
544 .name = "aio",
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)",
554 .name = "locking",
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)",
569 #endif
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;
586 QemuOpts *opts;
587 Error *local_err = NULL;
588 const char *filename = NULL;
589 const char *str;
590 BlockdevAioOptions aio, aio_default;
591 int fd, ret;
592 struct stat st;
593 OnOffAuto locking;
595 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
596 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
597 ret = -EINVAL;
598 goto fail;
601 filename = qemu_opt_get(opts, "filename");
603 ret = raw_normalize_devicepath(&filename, errp);
604 if (ret != 0) {
605 goto fail;
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;
613 #endif
614 } else {
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);
621 if (local_err) {
622 error_propagate(errp, local_err);
623 ret = -EINVAL;
624 goto fail;
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);
630 #endif
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);
637 if (local_err) {
638 error_propagate(errp, local_err);
639 ret = -EINVAL;
640 goto fail;
642 switch (locking) {
643 case ON_OFF_AUTO_ON:
644 s->use_lock = true;
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 "
649 "unexpectedly.\n");
651 break;
652 case ON_OFF_AUTO_OFF:
653 s->use_lock = false;
654 break;
655 case ON_OFF_AUTO_AUTO:
656 s->use_lock = qemu_has_ofd_lock();
657 break;
658 default:
659 abort();
662 str = qemu_opt_get(opts, "pr-manager");
663 if (str) {
664 s->pr_mgr = pr_manager_lookup(str, &local_err);
665 if (local_err) {
666 error_propagate(errp, local_err);
667 ret = -EINVAL;
668 goto fail;
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",
674 false);
676 s->open_flags = open_flags;
677 raw_parse_flags(bdrv_flags, &s->open_flags, false);
679 s->fd = -1;
680 fd = qemu_open(filename, s->open_flags, errp);
681 ret = fd < 0 ? -errno : 0;
683 if (ret < 0) {
684 if (ret == -EROFS) {
685 ret = -EACCES;
687 goto fail;
689 s->fd = fd;
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);
694 if (ret < 0) {
695 error_setg_errno(errp, -ret, "The device is not writable");
696 goto fail;
700 s->perm = 0;
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.");
709 ret = -EINVAL;
710 goto fail;
712 if (!aio_setup_linux_aio(bdrv_get_aio_context(bs), errp)) {
713 error_prepend(errp, "Unable to use native AIO: ");
714 goto fail;
717 #else
718 if (s->use_linux_aio) {
719 error_setg(errp, "aio=native was specified, but is not supported "
720 "in this build.");
721 ret = -EINVAL;
722 goto fail;
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: ");
730 goto fail;
733 #else
734 if (s->use_linux_io_uring) {
735 error_setg(errp, "aio=io_uring was specified, but is not supported "
736 "in this build.");
737 ret = -EINVAL;
738 goto fail;
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) {
746 ret = -errno;
747 error_setg_errno(errp, errno, "Could not stat file");
748 goto fail;
751 if (!device) {
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);
755 ret = -EINVAL;
756 goto fail;
757 } else {
758 s->has_fallocate = true;
760 } else {
761 if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
762 error_setg(errp, "'%s' driver requires '%s' to be either "
763 "a character or block device",
764 bs->drv->format_name, bs->filename);
765 ret = -EINVAL;
766 goto fail;
770 if (S_ISBLK(st.st_mode)) {
771 #ifdef __linux__
772 /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache. Do
773 * not rely on the contents of discarded blocks unless using O_DIRECT.
774 * Same for BLKZEROOUT.
776 if (!(bs->open_flags & BDRV_O_NOCACHE)) {
777 s->has_write_zeroes = false;
779 #endif
781 #ifdef __FreeBSD__
782 if (S_ISCHR(st.st_mode)) {
784 * The file is a char device (disk), which on FreeBSD isn't behind
785 * a pager, so force all requests to be aligned. This is needed
786 * so QEMU makes sure all IO operations on the device are aligned
787 * to sector size, or else FreeBSD will reject them with EINVAL.
789 s->force_alignment = true;
791 #endif
792 s->needs_alignment = raw_needs_alignment(bs);
794 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
795 if (S_ISREG(st.st_mode)) {
796 /* When extending regular files, we get zeros from the OS */
797 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
799 ret = 0;
800 fail:
801 if (ret < 0 && s->fd != -1) {
802 qemu_close(s->fd);
804 if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
805 unlink(filename);
807 qemu_opts_del(opts);
808 return ret;
811 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
812 Error **errp)
814 BDRVRawState *s = bs->opaque;
816 s->type = FTYPE_FILE;
817 return raw_open_common(bs, options, flags, 0, false, errp);
820 typedef enum {
821 RAW_PL_PREPARE,
822 RAW_PL_COMMIT,
823 RAW_PL_ABORT,
824 } RawPermLockOp;
826 #define PERM_FOREACH(i) \
827 for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++)
829 /* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the
830 * file; if @unlock == true, also unlock the unneeded bytes.
831 * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
833 static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
834 uint64_t perm_lock_bits,
835 uint64_t shared_perm_lock_bits,
836 bool unlock, Error **errp)
838 int ret;
839 int i;
840 uint64_t locked_perm, locked_shared_perm;
842 if (s) {
843 locked_perm = s->locked_perm;
844 locked_shared_perm = s->locked_shared_perm;
845 } else {
847 * We don't have the previous bits, just lock/unlock for each of the
848 * requested bits.
850 if (unlock) {
851 locked_perm = BLK_PERM_ALL;
852 locked_shared_perm = BLK_PERM_ALL;
853 } else {
854 locked_perm = 0;
855 locked_shared_perm = 0;
859 PERM_FOREACH(i) {
860 int off = RAW_LOCK_PERM_BASE + i;
861 uint64_t bit = (1ULL << i);
862 if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
863 ret = qemu_lock_fd(fd, off, 1, false);
864 if (ret) {
865 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d",
866 off);
867 return ret;
868 } else if (s) {
869 s->locked_perm |= bit;
871 } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
872 ret = qemu_unlock_fd(fd, off, 1);
873 if (ret) {
874 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off);
875 return ret;
876 } else if (s) {
877 s->locked_perm &= ~bit;
881 PERM_FOREACH(i) {
882 int off = RAW_LOCK_SHARED_BASE + i;
883 uint64_t bit = (1ULL << i);
884 if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
885 ret = qemu_lock_fd(fd, off, 1, false);
886 if (ret) {
887 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d",
888 off);
889 return ret;
890 } else if (s) {
891 s->locked_shared_perm |= bit;
893 } else if (unlock && (locked_shared_perm & bit) &&
894 !(shared_perm_lock_bits & bit)) {
895 ret = qemu_unlock_fd(fd, off, 1);
896 if (ret) {
897 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off);
898 return ret;
899 } else if (s) {
900 s->locked_shared_perm &= ~bit;
904 return 0;
907 /* Check "unshared" bytes implied by @perm and ~@shared_perm in the file. */
908 static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm,
909 Error **errp)
911 int ret;
912 int i;
914 PERM_FOREACH(i) {
915 int off = RAW_LOCK_SHARED_BASE + i;
916 uint64_t p = 1ULL << i;
917 if (perm & p) {
918 ret = qemu_lock_fd_test(fd, off, 1, true);
919 if (ret) {
920 char *perm_name = bdrv_perm_names(p);
922 raw_lock_error_setg_errno(errp, -ret,
923 "Failed to get \"%s\" lock",
924 perm_name);
925 g_free(perm_name);
926 return ret;
930 PERM_FOREACH(i) {
931 int off = RAW_LOCK_PERM_BASE + i;
932 uint64_t p = 1ULL << i;
933 if (!(shared_perm & p)) {
934 ret = qemu_lock_fd_test(fd, off, 1, true);
935 if (ret) {
936 char *perm_name = bdrv_perm_names(p);
938 raw_lock_error_setg_errno(errp, -ret,
939 "Failed to get shared \"%s\" lock",
940 perm_name);
941 g_free(perm_name);
942 return ret;
946 return 0;
949 static int raw_handle_perm_lock(BlockDriverState *bs,
950 RawPermLockOp op,
951 uint64_t new_perm, uint64_t new_shared,
952 Error **errp)
954 BDRVRawState *s = bs->opaque;
955 int ret = 0;
956 Error *local_err = NULL;
958 if (!s->use_lock) {
959 return 0;
962 if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) {
963 return 0;
966 switch (op) {
967 case RAW_PL_PREPARE:
968 if ((s->perm | new_perm) == s->perm &&
969 (s->shared_perm & new_shared) == s->shared_perm)
972 * We are going to unlock bytes, it should not fail. If it fail due
973 * to some fs-dependent permission-unrelated reasons (which occurs
974 * sometimes on NFS and leads to abort in bdrv_replace_child) we
975 * can't prevent such errors by any check here. And we ignore them
976 * anyway in ABORT and COMMIT.
978 return 0;
980 ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm,
981 ~s->shared_perm | ~new_shared,
982 false, errp);
983 if (!ret) {
984 ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp);
985 if (!ret) {
986 return 0;
988 error_append_hint(errp,
989 "Is another process using the image [%s]?\n",
990 bs->filename);
992 /* fall through to unlock bytes. */
993 case RAW_PL_ABORT:
994 raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm,
995 true, &local_err);
996 if (local_err) {
997 /* Theoretically the above call only unlocks bytes and it cannot
998 * fail. Something weird happened, report it.
1000 warn_report_err(local_err);
1002 break;
1003 case RAW_PL_COMMIT:
1004 raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared,
1005 true, &local_err);
1006 if (local_err) {
1007 /* Theoretically the above call only unlocks bytes and it cannot
1008 * fail. Something weird happened, report it.
1010 warn_report_err(local_err);
1012 break;
1014 return ret;
1017 /* Sets a specific flag */
1018 static int fcntl_setfl(int fd, int flag)
1020 int flags;
1022 flags = fcntl(fd, F_GETFL);
1023 if (flags == -1) {
1024 return -errno;
1026 if (fcntl(fd, F_SETFL, flags | flag) == -1) {
1027 return -errno;
1029 return 0;
1032 static int raw_reconfigure_getfd(BlockDriverState *bs, int flags,
1033 int *open_flags, uint64_t perm, bool force_dup,
1034 Error **errp)
1036 BDRVRawState *s = bs->opaque;
1037 int fd = -1;
1038 int ret;
1039 bool has_writers = perm &
1040 (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_RESIZE);
1041 int fcntl_flags = O_APPEND | O_NONBLOCK;
1042 #ifdef O_NOATIME
1043 fcntl_flags |= O_NOATIME;
1044 #endif
1046 *open_flags = 0;
1047 if (s->type == FTYPE_CD) {
1048 *open_flags |= O_NONBLOCK;
1051 raw_parse_flags(flags, open_flags, has_writers);
1053 #ifdef O_ASYNC
1054 /* Not all operating systems have O_ASYNC, and those that don't
1055 * will not let us track the state into rs->open_flags (typically
1056 * you achieve the same effect with an ioctl, for example I_SETSIG
1057 * on Solaris). But we do not use O_ASYNC, so that's fine.
1059 assert((s->open_flags & O_ASYNC) == 0);
1060 #endif
1062 if (!force_dup && *open_flags == s->open_flags) {
1063 /* We're lucky, the existing fd is fine */
1064 return s->fd;
1067 if ((*open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
1068 /* dup the original fd */
1069 fd = qemu_dup(s->fd);
1070 if (fd >= 0) {
1071 ret = fcntl_setfl(fd, *open_flags);
1072 if (ret) {
1073 qemu_close(fd);
1074 fd = -1;
1079 /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
1080 if (fd == -1) {
1081 const char *normalized_filename = bs->filename;
1082 ret = raw_normalize_devicepath(&normalized_filename, errp);
1083 if (ret >= 0) {
1084 fd = qemu_open(normalized_filename, *open_flags, errp);
1085 if (fd == -1) {
1086 return -1;
1091 if (fd != -1 && (*open_flags & O_RDWR)) {
1092 ret = check_hdev_writable(fd);
1093 if (ret < 0) {
1094 qemu_close(fd);
1095 error_setg_errno(errp, -ret, "The device is not writable");
1096 return -1;
1100 return fd;
1103 static int raw_reopen_prepare(BDRVReopenState *state,
1104 BlockReopenQueue *queue, Error **errp)
1106 BDRVRawState *s;
1107 BDRVRawReopenState *rs;
1108 QemuOpts *opts;
1109 int ret;
1111 assert(state != NULL);
1112 assert(state->bs != NULL);
1114 s = state->bs->opaque;
1116 state->opaque = g_new0(BDRVRawReopenState, 1);
1117 rs = state->opaque;
1119 /* Handle options changes */
1120 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
1121 if (!qemu_opts_absorb_qdict(opts, state->options, errp)) {
1122 ret = -EINVAL;
1123 goto out;
1126 rs->drop_cache = qemu_opt_get_bool_del(opts, "drop-cache", true);
1127 rs->check_cache_dropped =
1128 qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false);
1130 /* This driver's reopen function doesn't currently allow changing
1131 * other options, so let's put them back in the original QDict and
1132 * bdrv_reopen_prepare() will detect changes and complain. */
1133 qemu_opts_to_qdict(opts, state->options);
1136 * As part of reopen prepare we also want to create new fd by
1137 * raw_reconfigure_getfd(). But it wants updated "perm", when in
1138 * bdrv_reopen_multiple() .bdrv_reopen_prepare() callback called prior to
1139 * permission update. Happily, permission update is always a part (a seprate
1140 * stage) of bdrv_reopen_multiple() so we can rely on this fact and
1141 * reconfigure fd in raw_check_perm().
1144 s->reopen_state = state;
1145 ret = 0;
1147 out:
1148 qemu_opts_del(opts);
1149 return ret;
1152 static void raw_reopen_commit(BDRVReopenState *state)
1154 BDRVRawReopenState *rs = state->opaque;
1155 BDRVRawState *s = state->bs->opaque;
1157 s->drop_cache = rs->drop_cache;
1158 s->check_cache_dropped = rs->check_cache_dropped;
1159 s->open_flags = rs->open_flags;
1160 g_free(state->opaque);
1161 state->opaque = NULL;
1163 assert(s->reopen_state == state);
1164 s->reopen_state = NULL;
1168 static void raw_reopen_abort(BDRVReopenState *state)
1170 BDRVRawReopenState *rs = state->opaque;
1171 BDRVRawState *s = state->bs->opaque;
1173 /* nothing to do if NULL, we didn't get far enough */
1174 if (rs == NULL) {
1175 return;
1178 g_free(state->opaque);
1179 state->opaque = NULL;
1181 assert(s->reopen_state == state);
1182 s->reopen_state = NULL;
1185 static int hdev_get_max_hw_transfer(int fd, struct stat *st)
1187 #ifdef BLKSECTGET
1188 if (S_ISBLK(st->st_mode)) {
1189 unsigned short max_sectors = 0;
1190 if (ioctl(fd, BLKSECTGET, &max_sectors) == 0) {
1191 return max_sectors * 512;
1193 } else {
1194 int max_bytes = 0;
1195 if (ioctl(fd, BLKSECTGET, &max_bytes) == 0) {
1196 return max_bytes;
1199 return -errno;
1200 #else
1201 return -ENOSYS;
1202 #endif
1205 static int hdev_get_max_segments(int fd, struct stat *st)
1207 #ifdef CONFIG_LINUX
1208 char buf[32];
1209 const char *end;
1210 char *sysfspath = NULL;
1211 int ret;
1212 int sysfd = -1;
1213 long max_segments;
1215 if (S_ISCHR(st->st_mode)) {
1216 if (ioctl(fd, SG_GET_SG_TABLESIZE, &ret) == 0) {
1217 return ret;
1219 return -ENOTSUP;
1222 if (!S_ISBLK(st->st_mode)) {
1223 return -ENOTSUP;
1226 sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments",
1227 major(st->st_rdev), minor(st->st_rdev));
1228 sysfd = open(sysfspath, O_RDONLY);
1229 if (sysfd == -1) {
1230 ret = -errno;
1231 goto out;
1233 ret = RETRY_ON_EINTR(read(sysfd, buf, sizeof(buf) - 1));
1234 if (ret < 0) {
1235 ret = -errno;
1236 goto out;
1237 } else if (ret == 0) {
1238 ret = -EIO;
1239 goto out;
1241 buf[ret] = 0;
1242 /* The file is ended with '\n', pass 'end' to accept that. */
1243 ret = qemu_strtol(buf, &end, 10, &max_segments);
1244 if (ret == 0 && end && *end == '\n') {
1245 ret = max_segments;
1248 out:
1249 if (sysfd != -1) {
1250 close(sysfd);
1252 g_free(sysfspath);
1253 return ret;
1254 #else
1255 return -ENOTSUP;
1256 #endif
1259 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
1261 BDRVRawState *s = bs->opaque;
1262 struct stat st;
1264 s->needs_alignment = raw_needs_alignment(bs);
1265 raw_probe_alignment(bs, s->fd, errp);
1267 bs->bl.min_mem_alignment = s->buf_align;
1268 bs->bl.opt_mem_alignment = MAX(s->buf_align, qemu_real_host_page_size());
1271 * Maximum transfers are best effort, so it is okay to ignore any
1272 * errors. That said, based on the man page errors in fstat would be
1273 * very much unexpected; the only possible case seems to be ENOMEM.
1275 if (fstat(s->fd, &st)) {
1276 return;
1279 #if defined(__APPLE__) && (__MACH__)
1280 struct statfs buf;
1282 if (!fstatfs(s->fd, &buf)) {
1283 bs->bl.opt_transfer = buf.f_iosize;
1284 bs->bl.pdiscard_alignment = buf.f_bsize;
1286 #endif
1288 if (bdrv_is_sg(bs) || S_ISBLK(st.st_mode)) {
1289 int ret = hdev_get_max_hw_transfer(s->fd, &st);
1291 if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) {
1292 bs->bl.max_hw_transfer = ret;
1295 ret = hdev_get_max_segments(s->fd, &st);
1296 if (ret > 0) {
1297 bs->bl.max_hw_iov = ret;
1302 static int check_for_dasd(int fd)
1304 #ifdef BIODASDINFO2
1305 struct dasd_information2_t info = {0};
1307 return ioctl(fd, BIODASDINFO2, &info);
1308 #else
1309 return -1;
1310 #endif
1314 * Try to get @bs's logical and physical block size.
1315 * On success, store them in @bsz and return zero.
1316 * On failure, return negative errno.
1318 static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
1320 BDRVRawState *s = bs->opaque;
1321 int ret;
1323 /* If DASD, get blocksizes */
1324 if (check_for_dasd(s->fd) < 0) {
1325 return -ENOTSUP;
1327 ret = probe_logical_blocksize(s->fd, &bsz->log);
1328 if (ret < 0) {
1329 return ret;
1331 return probe_physical_blocksize(s->fd, &bsz->phys);
1335 * Try to get @bs's geometry: cyls, heads, sectors.
1336 * On success, store them in @geo and return 0.
1337 * On failure return -errno.
1338 * (Allows block driver to assign default geometry values that guest sees)
1340 #ifdef __linux__
1341 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1343 BDRVRawState *s = bs->opaque;
1344 struct hd_geometry ioctl_geo = {0};
1346 /* If DASD, get its geometry */
1347 if (check_for_dasd(s->fd) < 0) {
1348 return -ENOTSUP;
1350 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
1351 return -errno;
1353 /* HDIO_GETGEO may return success even though geo contains zeros
1354 (e.g. certain multipath setups) */
1355 if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
1356 return -ENOTSUP;
1358 /* Do not return a geometry for partition */
1359 if (ioctl_geo.start != 0) {
1360 return -ENOTSUP;
1362 geo->heads = ioctl_geo.heads;
1363 geo->sectors = ioctl_geo.sectors;
1364 geo->cylinders = ioctl_geo.cylinders;
1366 return 0;
1368 #else /* __linux__ */
1369 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1371 return -ENOTSUP;
1373 #endif
1375 #if defined(__linux__)
1376 static int handle_aiocb_ioctl(void *opaque)
1378 RawPosixAIOData *aiocb = opaque;
1379 int ret;
1381 ret = RETRY_ON_EINTR(
1382 ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf)
1384 if (ret == -1) {
1385 return -errno;
1388 return 0;
1390 #endif /* linux */
1392 static int handle_aiocb_flush(void *opaque)
1394 RawPosixAIOData *aiocb = opaque;
1395 BDRVRawState *s = aiocb->bs->opaque;
1396 int ret;
1398 if (s->page_cache_inconsistent) {
1399 return -s->page_cache_inconsistent;
1402 ret = qemu_fdatasync(aiocb->aio_fildes);
1403 if (ret == -1) {
1404 trace_file_flush_fdatasync_failed(errno);
1406 /* There is no clear definition of the semantics of a failing fsync(),
1407 * so we may have to assume the worst. The sad truth is that this
1408 * assumption is correct for Linux. Some pages are now probably marked
1409 * clean in the page cache even though they are inconsistent with the
1410 * on-disk contents. The next fdatasync() call would succeed, but no
1411 * further writeback attempt will be made. We can't get back to a state
1412 * in which we know what is on disk (we would have to rewrite
1413 * everything that was touched since the last fdatasync() at least), so
1414 * make bdrv_flush() fail permanently. Given that the behaviour isn't
1415 * really defined, I have little hope that other OSes are doing better.
1417 * Obviously, this doesn't affect O_DIRECT, which bypasses the page
1418 * cache. */
1419 if ((s->open_flags & O_DIRECT) == 0) {
1420 s->page_cache_inconsistent = errno;
1422 return -errno;
1424 return 0;
1427 #ifdef CONFIG_PREADV
1429 static bool preadv_present = true;
1431 static ssize_t
1432 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1434 return preadv(fd, iov, nr_iov, offset);
1437 static ssize_t
1438 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1440 return pwritev(fd, iov, nr_iov, offset);
1443 #else
1445 static bool preadv_present = false;
1447 static ssize_t
1448 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1450 return -ENOSYS;
1453 static ssize_t
1454 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1456 return -ENOSYS;
1459 #endif
1461 static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
1463 ssize_t len;
1465 len = RETRY_ON_EINTR(
1466 (aiocb->aio_type & QEMU_AIO_WRITE) ?
1467 qemu_pwritev(aiocb->aio_fildes,
1468 aiocb->io.iov,
1469 aiocb->io.niov,
1470 aiocb->aio_offset) :
1471 qemu_preadv(aiocb->aio_fildes,
1472 aiocb->io.iov,
1473 aiocb->io.niov,
1474 aiocb->aio_offset)
1477 if (len == -1) {
1478 return -errno;
1480 return len;
1484 * Read/writes the data to/from a given linear buffer.
1486 * Returns the number of bytes handles or -errno in case of an error. Short
1487 * reads are only returned if the end of the file is reached.
1489 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
1491 ssize_t offset = 0;
1492 ssize_t len;
1494 while (offset < aiocb->aio_nbytes) {
1495 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1496 len = pwrite(aiocb->aio_fildes,
1497 (const char *)buf + offset,
1498 aiocb->aio_nbytes - offset,
1499 aiocb->aio_offset + offset);
1500 } else {
1501 len = pread(aiocb->aio_fildes,
1502 buf + offset,
1503 aiocb->aio_nbytes - offset,
1504 aiocb->aio_offset + offset);
1506 if (len == -1 && errno == EINTR) {
1507 continue;
1508 } else if (len == -1 && errno == EINVAL &&
1509 (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
1510 !(aiocb->aio_type & QEMU_AIO_WRITE) &&
1511 offset > 0) {
1512 /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
1513 * after a short read. Assume that O_DIRECT short reads only occur
1514 * at EOF. Therefore this is a short read, not an I/O error.
1516 break;
1517 } else if (len == -1) {
1518 offset = -errno;
1519 break;
1520 } else if (len == 0) {
1521 break;
1523 offset += len;
1526 return offset;
1529 static int handle_aiocb_rw(void *opaque)
1531 RawPosixAIOData *aiocb = opaque;
1532 ssize_t nbytes;
1533 char *buf;
1535 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
1537 * If there is just a single buffer, and it is properly aligned
1538 * we can just use plain pread/pwrite without any problems.
1540 if (aiocb->io.niov == 1) {
1541 nbytes = handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base);
1542 goto out;
1545 * We have more than one iovec, and all are properly aligned.
1547 * Try preadv/pwritev first and fall back to linearizing the
1548 * buffer if it's not supported.
1550 if (preadv_present) {
1551 nbytes = handle_aiocb_rw_vector(aiocb);
1552 if (nbytes == aiocb->aio_nbytes ||
1553 (nbytes < 0 && nbytes != -ENOSYS)) {
1554 goto out;
1556 preadv_present = false;
1560 * XXX(hch): short read/write. no easy way to handle the reminder
1561 * using these interfaces. For now retry using plain
1562 * pread/pwrite?
1567 * Ok, we have to do it the hard way, copy all segments into
1568 * a single aligned buffer.
1570 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
1571 if (buf == NULL) {
1572 nbytes = -ENOMEM;
1573 goto out;
1576 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1577 char *p = buf;
1578 int i;
1580 for (i = 0; i < aiocb->io.niov; ++i) {
1581 memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len);
1582 p += aiocb->io.iov[i].iov_len;
1584 assert(p - buf == aiocb->aio_nbytes);
1587 nbytes = handle_aiocb_rw_linear(aiocb, buf);
1588 if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
1589 char *p = buf;
1590 size_t count = aiocb->aio_nbytes, copy;
1591 int i;
1593 for (i = 0; i < aiocb->io.niov && count; ++i) {
1594 copy = count;
1595 if (copy > aiocb->io.iov[i].iov_len) {
1596 copy = aiocb->io.iov[i].iov_len;
1598 memcpy(aiocb->io.iov[i].iov_base, p, copy);
1599 assert(count >= copy);
1600 p += copy;
1601 count -= copy;
1603 assert(count == 0);
1605 qemu_vfree(buf);
1607 out:
1608 if (nbytes == aiocb->aio_nbytes) {
1609 return 0;
1610 } else if (nbytes >= 0 && nbytes < aiocb->aio_nbytes) {
1611 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1612 return -EINVAL;
1613 } else {
1614 iov_memset(aiocb->io.iov, aiocb->io.niov, nbytes,
1615 0, aiocb->aio_nbytes - nbytes);
1616 return 0;
1618 } else {
1619 assert(nbytes < 0);
1620 return nbytes;
1624 #if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
1625 static int translate_err(int err)
1627 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1628 err == -ENOTTY) {
1629 err = -ENOTSUP;
1631 return err;
1633 #endif
1635 #ifdef CONFIG_FALLOCATE
1636 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1638 do {
1639 if (fallocate(fd, mode, offset, len) == 0) {
1640 return 0;
1642 } while (errno == EINTR);
1643 return translate_err(-errno);
1645 #endif
1647 static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1649 int ret = -ENOTSUP;
1650 BDRVRawState *s = aiocb->bs->opaque;
1652 if (!s->has_write_zeroes) {
1653 return -ENOTSUP;
1656 #ifdef BLKZEROOUT
1657 /* The BLKZEROOUT implementation in the kernel doesn't set
1658 * BLKDEV_ZERO_NOFALLBACK, so we can't call this if we have to avoid slow
1659 * fallbacks. */
1660 if (!(aiocb->aio_type & QEMU_AIO_NO_FALLBACK)) {
1661 do {
1662 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1663 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1664 return 0;
1666 } while (errno == EINTR);
1668 ret = translate_err(-errno);
1669 if (ret == -ENOTSUP) {
1670 s->has_write_zeroes = false;
1673 #endif
1675 return ret;
1678 static int handle_aiocb_write_zeroes(void *opaque)
1680 RawPosixAIOData *aiocb = opaque;
1681 #ifdef CONFIG_FALLOCATE
1682 BDRVRawState *s = aiocb->bs->opaque;
1683 int64_t len;
1684 #endif
1686 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1687 return handle_aiocb_write_zeroes_block(aiocb);
1690 #ifdef CONFIG_FALLOCATE_ZERO_RANGE
1691 if (s->has_write_zeroes) {
1692 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1693 aiocb->aio_offset, aiocb->aio_nbytes);
1694 if (ret == -ENOTSUP) {
1695 s->has_write_zeroes = false;
1696 } else if (ret == 0 || ret != -EINVAL) {
1697 return ret;
1700 * Note: Some file systems do not like unaligned byte ranges, and
1701 * return EINVAL in such a case, though they should not do it according
1702 * to the man-page of fallocate(). Thus we simply ignore this return
1703 * value and try the other fallbacks instead.
1706 #endif
1708 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1709 if (s->has_discard && s->has_fallocate) {
1710 int ret = do_fallocate(s->fd,
1711 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1712 aiocb->aio_offset, aiocb->aio_nbytes);
1713 if (ret == 0) {
1714 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1715 if (ret == 0 || ret != -ENOTSUP) {
1716 return ret;
1718 s->has_fallocate = false;
1719 } else if (ret == -EINVAL) {
1721 * Some file systems like older versions of GPFS do not like un-
1722 * aligned byte ranges, and return EINVAL in such a case, though
1723 * they should not do it according to the man-page of fallocate().
1724 * Warn about the bad filesystem and try the final fallback instead.
1726 warn_report_once("Your file system is misbehaving: "
1727 "fallocate(FALLOC_FL_PUNCH_HOLE) returned EINVAL. "
1728 "Please report this bug to your file system "
1729 "vendor.");
1730 } else if (ret != -ENOTSUP) {
1731 return ret;
1732 } else {
1733 s->has_discard = false;
1736 #endif
1738 #ifdef CONFIG_FALLOCATE
1739 /* Last resort: we are trying to extend the file with zeroed data. This
1740 * can be done via fallocate(fd, 0) */
1741 len = bdrv_getlength(aiocb->bs);
1742 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
1743 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1744 if (ret == 0 || ret != -ENOTSUP) {
1745 return ret;
1747 s->has_fallocate = false;
1749 #endif
1751 return -ENOTSUP;
1754 static int handle_aiocb_write_zeroes_unmap(void *opaque)
1756 RawPosixAIOData *aiocb = opaque;
1757 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque;
1759 /* First try to write zeros and unmap at the same time */
1761 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1762 int ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1763 aiocb->aio_offset, aiocb->aio_nbytes);
1764 switch (ret) {
1765 case -ENOTSUP:
1766 case -EINVAL:
1767 case -EBUSY:
1768 break;
1769 default:
1770 return ret;
1772 #endif
1774 /* If we couldn't manage to unmap while guaranteed that the area reads as
1775 * all-zero afterwards, just write zeroes without unmapping */
1776 return handle_aiocb_write_zeroes(aiocb);
1779 #ifndef HAVE_COPY_FILE_RANGE
1780 static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
1781 off_t *out_off, size_t len, unsigned int flags)
1783 #ifdef __NR_copy_file_range
1784 return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
1785 out_off, len, flags);
1786 #else
1787 errno = ENOSYS;
1788 return -1;
1789 #endif
1791 #endif
1793 static int handle_aiocb_copy_range(void *opaque)
1795 RawPosixAIOData *aiocb = opaque;
1796 uint64_t bytes = aiocb->aio_nbytes;
1797 off_t in_off = aiocb->aio_offset;
1798 off_t out_off = aiocb->copy_range.aio_offset2;
1800 while (bytes) {
1801 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
1802 aiocb->copy_range.aio_fd2, &out_off,
1803 bytes, 0);
1804 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
1805 aiocb->copy_range.aio_fd2, out_off, bytes,
1806 0, ret);
1807 if (ret == 0) {
1808 /* No progress (e.g. when beyond EOF), let the caller fall back to
1809 * buffer I/O. */
1810 return -ENOSPC;
1812 if (ret < 0) {
1813 switch (errno) {
1814 case ENOSYS:
1815 return -ENOTSUP;
1816 case EINTR:
1817 continue;
1818 default:
1819 return -errno;
1822 bytes -= ret;
1824 return 0;
1827 static int handle_aiocb_discard(void *opaque)
1829 RawPosixAIOData *aiocb = opaque;
1830 int ret = -ENOTSUP;
1831 BDRVRawState *s = aiocb->bs->opaque;
1833 if (!s->has_discard) {
1834 return -ENOTSUP;
1837 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1838 #ifdef BLKDISCARD
1839 do {
1840 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1841 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1842 return 0;
1844 } while (errno == EINTR);
1846 ret = translate_err(-errno);
1847 #endif
1848 } else {
1849 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1850 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1851 aiocb->aio_offset, aiocb->aio_nbytes);
1852 ret = translate_err(ret);
1853 #elif defined(__APPLE__) && (__MACH__)
1854 fpunchhole_t fpunchhole;
1855 fpunchhole.fp_flags = 0;
1856 fpunchhole.reserved = 0;
1857 fpunchhole.fp_offset = aiocb->aio_offset;
1858 fpunchhole.fp_length = aiocb->aio_nbytes;
1859 if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
1860 ret = errno == ENODEV ? -ENOTSUP : -errno;
1861 } else {
1862 ret = 0;
1864 #endif
1867 if (ret == -ENOTSUP) {
1868 s->has_discard = false;
1870 return ret;
1874 * Help alignment probing by allocating the first block.
1876 * When reading with direct I/O from unallocated area on Gluster backed by XFS,
1877 * reading succeeds regardless of request length. In this case we fallback to
1878 * safe alignment which is not optimal. Allocating the first block avoids this
1879 * fallback.
1881 * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
1882 * request alignment, so we use safe values.
1884 * Returns: 0 on success, -errno on failure. Since this is an optimization,
1885 * caller may ignore failures.
1887 static int allocate_first_block(int fd, size_t max_size)
1889 size_t write_size = (max_size < MAX_BLOCKSIZE)
1890 ? BDRV_SECTOR_SIZE
1891 : MAX_BLOCKSIZE;
1892 size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size());
1893 void *buf;
1894 ssize_t n;
1895 int ret;
1897 buf = qemu_memalign(max_align, write_size);
1898 memset(buf, 0, write_size);
1900 n = RETRY_ON_EINTR(pwrite(fd, buf, write_size, 0));
1902 ret = (n == -1) ? -errno : 0;
1904 qemu_vfree(buf);
1905 return ret;
1908 static int handle_aiocb_truncate(void *opaque)
1910 RawPosixAIOData *aiocb = opaque;
1911 int result = 0;
1912 int64_t current_length = 0;
1913 char *buf = NULL;
1914 struct stat st;
1915 int fd = aiocb->aio_fildes;
1916 int64_t offset = aiocb->aio_offset;
1917 PreallocMode prealloc = aiocb->truncate.prealloc;
1918 Error **errp = aiocb->truncate.errp;
1920 if (fstat(fd, &st) < 0) {
1921 result = -errno;
1922 error_setg_errno(errp, -result, "Could not stat file");
1923 return result;
1926 current_length = st.st_size;
1927 if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
1928 error_setg(errp, "Cannot use preallocation for shrinking files");
1929 return -ENOTSUP;
1932 switch (prealloc) {
1933 #ifdef CONFIG_POSIX_FALLOCATE
1934 case PREALLOC_MODE_FALLOC:
1936 * Truncating before posix_fallocate() makes it about twice slower on
1937 * file systems that do not support fallocate(), trying to check if a
1938 * block is allocated before allocating it, so don't do that here.
1940 if (offset != current_length) {
1941 result = -posix_fallocate(fd, current_length,
1942 offset - current_length);
1943 if (result != 0) {
1944 /* posix_fallocate() doesn't set errno. */
1945 error_setg_errno(errp, -result,
1946 "Could not preallocate new data");
1947 } else if (current_length == 0) {
1949 * posix_fallocate() uses fallocate() if the filesystem
1950 * supports it, or fallback to manually writing zeroes. If
1951 * fallocate() was used, unaligned reads from the fallocated
1952 * area in raw_probe_alignment() will succeed, hence we need to
1953 * allocate the first block.
1955 * Optimize future alignment probing; ignore failures.
1957 allocate_first_block(fd, offset);
1959 } else {
1960 result = 0;
1962 goto out;
1963 #endif
1964 case PREALLOC_MODE_FULL:
1966 int64_t num = 0, left = offset - current_length;
1967 off_t seek_result;
1970 * Knowing the final size from the beginning could allow the file
1971 * system driver to do less allocations and possibly avoid
1972 * fragmentation of the file.
1974 if (ftruncate(fd, offset) != 0) {
1975 result = -errno;
1976 error_setg_errno(errp, -result, "Could not resize file");
1977 goto out;
1980 buf = g_malloc0(65536);
1982 seek_result = lseek(fd, current_length, SEEK_SET);
1983 if (seek_result < 0) {
1984 result = -errno;
1985 error_setg_errno(errp, -result,
1986 "Failed to seek to the old end of file");
1987 goto out;
1990 while (left > 0) {
1991 num = MIN(left, 65536);
1992 result = write(fd, buf, num);
1993 if (result < 0) {
1994 if (errno == EINTR) {
1995 continue;
1997 result = -errno;
1998 error_setg_errno(errp, -result,
1999 "Could not write zeros for preallocation");
2000 goto out;
2002 left -= result;
2004 if (result >= 0) {
2005 result = fsync(fd);
2006 if (result < 0) {
2007 result = -errno;
2008 error_setg_errno(errp, -result,
2009 "Could not flush file to disk");
2010 goto out;
2013 goto out;
2015 case PREALLOC_MODE_OFF:
2016 if (ftruncate(fd, offset) != 0) {
2017 result = -errno;
2018 error_setg_errno(errp, -result, "Could not resize file");
2019 } else if (current_length == 0 && offset > current_length) {
2020 /* Optimize future alignment probing; ignore failures. */
2021 allocate_first_block(fd, offset);
2023 return result;
2024 default:
2025 result = -ENOTSUP;
2026 error_setg(errp, "Unsupported preallocation mode: %s",
2027 PreallocMode_str(prealloc));
2028 return result;
2031 out:
2032 if (result < 0) {
2033 if (ftruncate(fd, current_length) < 0) {
2034 error_report("Failed to restore old file length: %s",
2035 strerror(errno));
2039 g_free(buf);
2040 return result;
2043 static int coroutine_fn raw_thread_pool_submit(BlockDriverState *bs,
2044 ThreadPoolFunc func, void *arg)
2046 /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */
2047 ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
2048 return thread_pool_submit_co(pool, func, arg);
2052 * Check if all memory in this vector is sector aligned.
2054 static bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
2056 int i;
2057 size_t alignment = bdrv_min_mem_align(bs);
2058 size_t len = bs->bl.request_alignment;
2059 IO_CODE();
2061 for (i = 0; i < qiov->niov; i++) {
2062 if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
2063 return false;
2065 if (qiov->iov[i].iov_len % len) {
2066 return false;
2070 return true;
2073 static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
2074 uint64_t bytes, QEMUIOVector *qiov, int type)
2076 BDRVRawState *s = bs->opaque;
2077 RawPosixAIOData acb;
2079 if (fd_open(bs) < 0)
2080 return -EIO;
2083 * When using O_DIRECT, the request must be aligned to be able to use
2084 * either libaio or io_uring interface. If not fail back to regular thread
2085 * pool read/write code which emulates this for us if we
2086 * set QEMU_AIO_MISALIGNED.
2088 if (s->needs_alignment && !bdrv_qiov_is_aligned(bs, qiov)) {
2089 type |= QEMU_AIO_MISALIGNED;
2090 #ifdef CONFIG_LINUX_IO_URING
2091 } else if (s->use_linux_io_uring) {
2092 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2093 assert(qiov->size == bytes);
2094 return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
2095 #endif
2096 #ifdef CONFIG_LINUX_AIO
2097 } else if (s->use_linux_aio) {
2098 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2099 assert(qiov->size == bytes);
2100 return laio_co_submit(bs, aio, s->fd, offset, qiov, type,
2101 s->aio_max_batch);
2102 #endif
2105 acb = (RawPosixAIOData) {
2106 .bs = bs,
2107 .aio_fildes = s->fd,
2108 .aio_type = type,
2109 .aio_offset = offset,
2110 .aio_nbytes = bytes,
2111 .io = {
2112 .iov = qiov->iov,
2113 .niov = qiov->niov,
2117 assert(qiov->size == bytes);
2118 return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
2121 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
2122 int64_t bytes, QEMUIOVector *qiov,
2123 BdrvRequestFlags flags)
2125 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
2128 static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
2129 int64_t bytes, QEMUIOVector *qiov,
2130 BdrvRequestFlags flags)
2132 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
2135 static void coroutine_fn raw_co_io_plug(BlockDriverState *bs)
2137 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2138 #ifdef CONFIG_LINUX_AIO
2139 if (s->use_linux_aio) {
2140 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2141 laio_io_plug(bs, aio);
2143 #endif
2144 #ifdef CONFIG_LINUX_IO_URING
2145 if (s->use_linux_io_uring) {
2146 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2147 luring_io_plug(bs, aio);
2149 #endif
2152 static void coroutine_fn raw_co_io_unplug(BlockDriverState *bs)
2154 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2155 #ifdef CONFIG_LINUX_AIO
2156 if (s->use_linux_aio) {
2157 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2158 laio_io_unplug(bs, aio, s->aio_max_batch);
2160 #endif
2161 #ifdef CONFIG_LINUX_IO_URING
2162 if (s->use_linux_io_uring) {
2163 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2164 luring_io_unplug(bs, aio);
2166 #endif
2169 static int coroutine_fn raw_co_flush_to_disk(BlockDriverState *bs)
2171 BDRVRawState *s = bs->opaque;
2172 RawPosixAIOData acb;
2173 int ret;
2175 ret = fd_open(bs);
2176 if (ret < 0) {
2177 return ret;
2180 acb = (RawPosixAIOData) {
2181 .bs = bs,
2182 .aio_fildes = s->fd,
2183 .aio_type = QEMU_AIO_FLUSH,
2186 #ifdef CONFIG_LINUX_IO_URING
2187 if (s->use_linux_io_uring) {
2188 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2189 return luring_co_submit(bs, aio, s->fd, 0, NULL, QEMU_AIO_FLUSH);
2191 #endif
2192 return raw_thread_pool_submit(bs, handle_aiocb_flush, &acb);
2195 static void raw_aio_attach_aio_context(BlockDriverState *bs,
2196 AioContext *new_context)
2198 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2199 #ifdef CONFIG_LINUX_AIO
2200 if (s->use_linux_aio) {
2201 Error *local_err = NULL;
2202 if (!aio_setup_linux_aio(new_context, &local_err)) {
2203 error_reportf_err(local_err, "Unable to use native AIO, "
2204 "falling back to thread pool: ");
2205 s->use_linux_aio = false;
2208 #endif
2209 #ifdef CONFIG_LINUX_IO_URING
2210 if (s->use_linux_io_uring) {
2211 Error *local_err = NULL;
2212 if (!aio_setup_linux_io_uring(new_context, &local_err)) {
2213 error_reportf_err(local_err, "Unable to use linux io_uring, "
2214 "falling back to thread pool: ");
2215 s->use_linux_io_uring = false;
2218 #endif
2221 static void raw_close(BlockDriverState *bs)
2223 BDRVRawState *s = bs->opaque;
2225 if (s->fd >= 0) {
2226 qemu_close(s->fd);
2227 s->fd = -1;
2232 * Truncates the given regular file @fd to @offset and, when growing, fills the
2233 * new space according to @prealloc.
2235 * Returns: 0 on success, -errno on failure.
2237 static int coroutine_fn
2238 raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
2239 PreallocMode prealloc, Error **errp)
2241 RawPosixAIOData acb;
2243 acb = (RawPosixAIOData) {
2244 .bs = bs,
2245 .aio_fildes = fd,
2246 .aio_type = QEMU_AIO_TRUNCATE,
2247 .aio_offset = offset,
2248 .truncate = {
2249 .prealloc = prealloc,
2250 .errp = errp,
2254 return raw_thread_pool_submit(bs, handle_aiocb_truncate, &acb);
2257 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
2258 bool exact, PreallocMode prealloc,
2259 BdrvRequestFlags flags, Error **errp)
2261 BDRVRawState *s = bs->opaque;
2262 struct stat st;
2263 int ret;
2265 if (fstat(s->fd, &st)) {
2266 ret = -errno;
2267 error_setg_errno(errp, -ret, "Failed to fstat() the file");
2268 return ret;
2271 if (S_ISREG(st.st_mode)) {
2272 /* Always resizes to the exact @offset */
2273 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
2276 if (prealloc != PREALLOC_MODE_OFF) {
2277 error_setg(errp, "Preallocation mode '%s' unsupported for this "
2278 "non-regular file", PreallocMode_str(prealloc));
2279 return -ENOTSUP;
2282 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2283 int64_t cur_length = raw_co_getlength(bs);
2285 if (offset != cur_length && exact) {
2286 error_setg(errp, "Cannot resize device files");
2287 return -ENOTSUP;
2288 } else if (offset > cur_length) {
2289 error_setg(errp, "Cannot grow device files");
2290 return -EINVAL;
2292 } else {
2293 error_setg(errp, "Resizing this file is not supported");
2294 return -ENOTSUP;
2297 return 0;
2300 #ifdef __OpenBSD__
2301 static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
2303 BDRVRawState *s = bs->opaque;
2304 int fd = s->fd;
2305 struct stat st;
2307 if (fstat(fd, &st))
2308 return -errno;
2309 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2310 struct disklabel dl;
2312 if (ioctl(fd, DIOCGDINFO, &dl))
2313 return -errno;
2314 return (uint64_t)dl.d_secsize *
2315 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2316 } else
2317 return st.st_size;
2319 #elif defined(__NetBSD__)
2320 static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
2322 BDRVRawState *s = bs->opaque;
2323 int fd = s->fd;
2324 struct stat st;
2326 if (fstat(fd, &st))
2327 return -errno;
2328 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2329 struct dkwedge_info dkw;
2331 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
2332 return dkw.dkw_size * 512;
2333 } else {
2334 struct disklabel dl;
2336 if (ioctl(fd, DIOCGDINFO, &dl))
2337 return -errno;
2338 return (uint64_t)dl.d_secsize *
2339 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2341 } else
2342 return st.st_size;
2344 #elif defined(__sun__)
2345 static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
2347 BDRVRawState *s = bs->opaque;
2348 struct dk_minfo minfo;
2349 int ret;
2350 int64_t size;
2352 ret = fd_open(bs);
2353 if (ret < 0) {
2354 return ret;
2358 * Use the DKIOCGMEDIAINFO ioctl to read the size.
2360 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
2361 if (ret != -1) {
2362 return minfo.dki_lbsize * minfo.dki_capacity;
2366 * There are reports that lseek on some devices fails, but
2367 * irc discussion said that contingency on contingency was overkill.
2369 size = lseek(s->fd, 0, SEEK_END);
2370 if (size < 0) {
2371 return -errno;
2373 return size;
2375 #elif defined(CONFIG_BSD)
2376 static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
2378 BDRVRawState *s = bs->opaque;
2379 int fd = s->fd;
2380 int64_t size;
2381 struct stat sb;
2382 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2383 int reopened = 0;
2384 #endif
2385 int ret;
2387 ret = fd_open(bs);
2388 if (ret < 0)
2389 return ret;
2391 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2392 again:
2393 #endif
2394 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2395 size = 0;
2396 #ifdef DIOCGMEDIASIZE
2397 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size)) {
2398 size = 0;
2400 #endif
2401 #ifdef DIOCGPART
2402 if (size == 0) {
2403 struct partinfo pi;
2404 if (ioctl(fd, DIOCGPART, &pi) == 0) {
2405 size = pi.media_size;
2408 #endif
2409 #if defined(DKIOCGETBLOCKCOUNT) && defined(DKIOCGETBLOCKSIZE)
2410 if (size == 0) {
2411 uint64_t sectors = 0;
2412 uint32_t sector_size = 0;
2414 if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
2415 && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
2416 size = sectors * sector_size;
2419 #endif
2420 if (size == 0) {
2421 size = lseek(fd, 0LL, SEEK_END);
2423 if (size < 0) {
2424 return -errno;
2426 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2427 switch(s->type) {
2428 case FTYPE_CD:
2429 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
2430 if (size == 2048LL * (unsigned)-1)
2431 size = 0;
2432 /* XXX no disc? maybe we need to reopen... */
2433 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
2434 reopened = 1;
2435 goto again;
2438 #endif
2439 } else {
2440 size = lseek(fd, 0, SEEK_END);
2441 if (size < 0) {
2442 return -errno;
2445 return size;
2447 #else
2448 static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
2450 BDRVRawState *s = bs->opaque;
2451 int ret;
2452 int64_t size;
2454 ret = fd_open(bs);
2455 if (ret < 0) {
2456 return ret;
2459 size = lseek(s->fd, 0, SEEK_END);
2460 if (size < 0) {
2461 return -errno;
2463 return size;
2465 #endif
2467 static int64_t coroutine_fn raw_co_get_allocated_file_size(BlockDriverState *bs)
2469 struct stat st;
2470 BDRVRawState *s = bs->opaque;
2472 if (fstat(s->fd, &st) < 0) {
2473 return -errno;
2475 return (int64_t)st.st_blocks * 512;
2478 static int coroutine_fn
2479 raw_co_create(BlockdevCreateOptions *options, Error **errp)
2481 BlockdevCreateOptionsFile *file_opts;
2482 Error *local_err = NULL;
2483 int fd;
2484 uint64_t perm, shared;
2485 int result = 0;
2487 /* Validate options and set default values */
2488 assert(options->driver == BLOCKDEV_DRIVER_FILE);
2489 file_opts = &options->u.file;
2491 if (!file_opts->has_nocow) {
2492 file_opts->nocow = false;
2494 if (!file_opts->has_preallocation) {
2495 file_opts->preallocation = PREALLOC_MODE_OFF;
2497 if (!file_opts->has_extent_size_hint) {
2498 file_opts->extent_size_hint = 1 * MiB;
2500 if (file_opts->extent_size_hint > UINT32_MAX) {
2501 result = -EINVAL;
2502 error_setg(errp, "Extent size hint is too large");
2503 goto out;
2506 /* Create file */
2507 fd = qemu_create(file_opts->filename, O_RDWR | O_BINARY, 0644, errp);
2508 if (fd < 0) {
2509 result = -errno;
2510 goto out;
2513 /* Take permissions: We want to discard everything, so we need
2514 * BLK_PERM_WRITE; and truncation to the desired size requires
2515 * BLK_PERM_RESIZE.
2516 * On the other hand, we cannot share the RESIZE permission
2517 * because we promise that after this function, the file has the
2518 * size given in the options. If someone else were to resize it
2519 * concurrently, we could not guarantee that.
2520 * Note that after this function, we can no longer guarantee that
2521 * the file is not touched by a third party, so it may be resized
2522 * then. */
2523 perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2524 shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2526 /* Step one: Take locks */
2527 result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
2528 if (result < 0) {
2529 goto out_close;
2532 /* Step two: Check that nobody else has taken conflicting locks */
2533 result = raw_check_lock_bytes(fd, perm, shared, errp);
2534 if (result < 0) {
2535 error_append_hint(errp,
2536 "Is another process using the image [%s]?\n",
2537 file_opts->filename);
2538 goto out_unlock;
2541 /* Clear the file by truncating it to 0 */
2542 result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
2543 if (result < 0) {
2544 goto out_unlock;
2547 if (file_opts->nocow) {
2548 #ifdef __linux__
2549 /* Set NOCOW flag to solve performance issue on fs like btrfs.
2550 * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
2551 * will be ignored since any failure of this operation should not
2552 * block the left work.
2554 int attr;
2555 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2556 attr |= FS_NOCOW_FL;
2557 ioctl(fd, FS_IOC_SETFLAGS, &attr);
2559 #endif
2561 #ifdef FS_IOC_FSSETXATTR
2563 * Try to set the extent size hint. Failure is not fatal, and a warning is
2564 * only printed if the option was explicitly specified.
2567 struct fsxattr attr;
2568 result = ioctl(fd, FS_IOC_FSGETXATTR, &attr);
2569 if (result == 0) {
2570 attr.fsx_xflags |= FS_XFLAG_EXTSIZE;
2571 attr.fsx_extsize = file_opts->extent_size_hint;
2572 result = ioctl(fd, FS_IOC_FSSETXATTR, &attr);
2574 if (result < 0 && file_opts->has_extent_size_hint &&
2575 file_opts->extent_size_hint)
2577 warn_report("Failed to set extent size hint: %s",
2578 strerror(errno));
2581 #endif
2583 /* Resize and potentially preallocate the file to the desired
2584 * final size */
2585 result = raw_regular_truncate(NULL, fd, file_opts->size,
2586 file_opts->preallocation, errp);
2587 if (result < 0) {
2588 goto out_unlock;
2591 out_unlock:
2592 raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
2593 if (local_err) {
2594 /* The above call should not fail, and if it does, that does
2595 * not mean the whole creation operation has failed. So
2596 * report it the user for their convenience, but do not report
2597 * it to the caller. */
2598 warn_report_err(local_err);
2601 out_close:
2602 if (qemu_close(fd) != 0 && result == 0) {
2603 result = -errno;
2604 error_setg_errno(errp, -result, "Could not close the new file");
2606 out:
2607 return result;
2610 static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
2611 const char *filename,
2612 QemuOpts *opts,
2613 Error **errp)
2615 BlockdevCreateOptions options;
2616 int64_t total_size = 0;
2617 int64_t extent_size_hint = 0;
2618 bool has_extent_size_hint = false;
2619 bool nocow = false;
2620 PreallocMode prealloc;
2621 char *buf = NULL;
2622 Error *local_err = NULL;
2624 /* Skip file: protocol prefix */
2625 strstart(filename, "file:", &filename);
2627 /* Read out options */
2628 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2629 BDRV_SECTOR_SIZE);
2630 if (qemu_opt_get(opts, BLOCK_OPT_EXTENT_SIZE_HINT)) {
2631 has_extent_size_hint = true;
2632 extent_size_hint =
2633 qemu_opt_get_size_del(opts, BLOCK_OPT_EXTENT_SIZE_HINT, -1);
2635 nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
2636 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2637 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
2638 PREALLOC_MODE_OFF, &local_err);
2639 g_free(buf);
2640 if (local_err) {
2641 error_propagate(errp, local_err);
2642 return -EINVAL;
2645 options = (BlockdevCreateOptions) {
2646 .driver = BLOCKDEV_DRIVER_FILE,
2647 .u.file = {
2648 .filename = (char *) filename,
2649 .size = total_size,
2650 .has_preallocation = true,
2651 .preallocation = prealloc,
2652 .has_nocow = true,
2653 .nocow = nocow,
2654 .has_extent_size_hint = has_extent_size_hint,
2655 .extent_size_hint = extent_size_hint,
2658 return raw_co_create(&options, errp);
2661 static int coroutine_fn raw_co_delete_file(BlockDriverState *bs,
2662 Error **errp)
2664 struct stat st;
2665 int ret;
2667 if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) {
2668 error_setg_errno(errp, ENOENT, "%s is not a regular file",
2669 bs->filename);
2670 return -ENOENT;
2673 ret = unlink(bs->filename);
2674 if (ret < 0) {
2675 ret = -errno;
2676 error_setg_errno(errp, -ret, "Error when deleting file %s",
2677 bs->filename);
2680 return ret;
2684 * Find allocation range in @bs around offset @start.
2685 * May change underlying file descriptor's file offset.
2686 * If @start is not in a hole, store @start in @data, and the
2687 * beginning of the next hole in @hole, and return 0.
2688 * If @start is in a non-trailing hole, store @start in @hole and the
2689 * beginning of the next non-hole in @data, and return 0.
2690 * If @start is in a trailing hole or beyond EOF, return -ENXIO.
2691 * If we can't find out, return a negative errno other than -ENXIO.
2693 static int find_allocation(BlockDriverState *bs, off_t start,
2694 off_t *data, off_t *hole)
2696 #if defined SEEK_HOLE && defined SEEK_DATA
2697 BDRVRawState *s = bs->opaque;
2698 off_t offs;
2701 * SEEK_DATA cases:
2702 * D1. offs == start: start is in data
2703 * D2. offs > start: start is in a hole, next data at offs
2704 * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
2705 * or start is beyond EOF
2706 * If the latter happens, the file has been truncated behind
2707 * our back since we opened it. All bets are off then.
2708 * Treating like a trailing hole is simplest.
2709 * D4. offs < 0, errno != ENXIO: we learned nothing
2711 offs = lseek(s->fd, start, SEEK_DATA);
2712 if (offs < 0) {
2713 return -errno; /* D3 or D4 */
2716 if (offs < start) {
2717 /* This is not a valid return by lseek(). We are safe to just return
2718 * -EIO in this case, and we'll treat it like D4. */
2719 return -EIO;
2722 if (offs > start) {
2723 /* D2: in hole, next data at offs */
2724 *hole = start;
2725 *data = offs;
2726 return 0;
2729 /* D1: in data, end not yet known */
2732 * SEEK_HOLE cases:
2733 * H1. offs == start: start is in a hole
2734 * If this happens here, a hole has been dug behind our back
2735 * since the previous lseek().
2736 * H2. offs > start: either start is in data, next hole at offs,
2737 * or start is in trailing hole, EOF at offs
2738 * Linux treats trailing holes like any other hole: offs ==
2739 * start. Solaris seeks to EOF instead: offs > start (blech).
2740 * If that happens here, a hole has been dug behind our back
2741 * since the previous lseek().
2742 * H3. offs < 0, errno = ENXIO: start is beyond EOF
2743 * If this happens, the file has been truncated behind our
2744 * back since we opened it. Treat it like a trailing hole.
2745 * H4. offs < 0, errno != ENXIO: we learned nothing
2746 * Pretend we know nothing at all, i.e. "forget" about D1.
2748 offs = lseek(s->fd, start, SEEK_HOLE);
2749 if (offs < 0) {
2750 return -errno; /* D1 and (H3 or H4) */
2753 if (offs < start) {
2754 /* This is not a valid return by lseek(). We are safe to just return
2755 * -EIO in this case, and we'll treat it like H4. */
2756 return -EIO;
2759 if (offs > start) {
2761 * D1 and H2: either in data, next hole at offs, or it was in
2762 * data but is now in a trailing hole. In the latter case,
2763 * all bets are off. Treating it as if it there was data all
2764 * the way to EOF is safe, so simply do that.
2766 *data = start;
2767 *hole = offs;
2768 return 0;
2771 /* D1 and H1 */
2772 return -EBUSY;
2773 #else
2774 return -ENOTSUP;
2775 #endif
2779 * Returns the allocation status of the specified offset.
2781 * The block layer guarantees 'offset' and 'bytes' are within bounds.
2783 * 'pnum' is set to the number of bytes (including and immediately following
2784 * the specified offset) that are known to be in the same
2785 * allocated/unallocated state.
2787 * 'bytes' is a soft cap for 'pnum'. If the information is free, 'pnum' may
2788 * well exceed it.
2790 static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
2791 bool want_zero,
2792 int64_t offset,
2793 int64_t bytes, int64_t *pnum,
2794 int64_t *map,
2795 BlockDriverState **file)
2797 off_t data = 0, hole = 0;
2798 int ret;
2800 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
2802 ret = fd_open(bs);
2803 if (ret < 0) {
2804 return ret;
2807 if (!want_zero) {
2808 *pnum = bytes;
2809 *map = offset;
2810 *file = bs;
2811 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
2814 ret = find_allocation(bs, offset, &data, &hole);
2815 if (ret == -ENXIO) {
2816 /* Trailing hole */
2817 *pnum = bytes;
2818 ret = BDRV_BLOCK_ZERO;
2819 } else if (ret < 0) {
2820 /* No info available, so pretend there are no holes */
2821 *pnum = bytes;
2822 ret = BDRV_BLOCK_DATA;
2823 } else if (data == offset) {
2824 /* On a data extent, compute bytes to the end of the extent,
2825 * possibly including a partial sector at EOF. */
2826 *pnum = hole - offset;
2829 * We are not allowed to return partial sectors, though, so
2830 * round up if necessary.
2832 if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
2833 int64_t file_length = raw_co_getlength(bs);
2834 if (file_length > 0) {
2835 /* Ignore errors, this is just a safeguard */
2836 assert(hole == file_length);
2838 *pnum = ROUND_UP(*pnum, bs->bl.request_alignment);
2841 ret = BDRV_BLOCK_DATA;
2842 } else {
2843 /* On a hole, compute bytes to the beginning of the next extent. */
2844 assert(hole == offset);
2845 *pnum = data - offset;
2846 ret = BDRV_BLOCK_ZERO;
2848 *map = offset;
2849 *file = bs;
2850 return ret | BDRV_BLOCK_OFFSET_VALID;
2853 #if defined(__linux__)
2854 /* Verify that the file is not in the page cache */
2855 static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp)
2857 const size_t window_size = 128 * 1024 * 1024;
2858 BDRVRawState *s = bs->opaque;
2859 void *window = NULL;
2860 size_t length = 0;
2861 unsigned char *vec;
2862 size_t page_size;
2863 off_t offset;
2864 off_t end;
2866 /* mincore(2) page status information requires 1 byte per page */
2867 page_size = sysconf(_SC_PAGESIZE);
2868 vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
2870 end = raw_co_getlength(bs);
2872 for (offset = 0; offset < end; offset += window_size) {
2873 void *new_window;
2874 size_t new_length;
2875 size_t vec_end;
2876 size_t i;
2877 int ret;
2879 /* Unmap previous window if size has changed */
2880 new_length = MIN(end - offset, window_size);
2881 if (new_length != length) {
2882 munmap(window, length);
2883 window = NULL;
2884 length = 0;
2887 new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
2888 s->fd, offset);
2889 if (new_window == MAP_FAILED) {
2890 error_setg_errno(errp, errno, "mmap failed");
2891 break;
2894 window = new_window;
2895 length = new_length;
2897 ret = mincore(window, length, vec);
2898 if (ret < 0) {
2899 error_setg_errno(errp, errno, "mincore failed");
2900 break;
2903 vec_end = DIV_ROUND_UP(length, page_size);
2904 for (i = 0; i < vec_end; i++) {
2905 if (vec[i] & 0x1) {
2906 break;
2909 if (i < vec_end) {
2910 error_setg(errp, "page cache still in use!");
2911 break;
2915 if (window) {
2916 munmap(window, length);
2919 g_free(vec);
2921 #endif /* __linux__ */
2923 static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs,
2924 Error **errp)
2926 BDRVRawState *s = bs->opaque;
2927 int ret;
2929 ret = fd_open(bs);
2930 if (ret < 0) {
2931 error_setg_errno(errp, -ret, "The file descriptor is not open");
2932 return;
2935 if (!s->drop_cache) {
2936 return;
2939 if (s->open_flags & O_DIRECT) {
2940 return; /* No host kernel page cache */
2943 #if defined(__linux__)
2944 /* This sets the scene for the next syscall... */
2945 ret = bdrv_co_flush(bs);
2946 if (ret < 0) {
2947 error_setg_errno(errp, -ret, "flush failed");
2948 return;
2951 /* Linux does not invalidate pages that are dirty, locked, or mmapped by a
2952 * process. These limitations are okay because we just fsynced the file,
2953 * we don't use mmap, and the file should not be in use by other processes.
2955 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
2956 if (ret != 0) { /* the return value is a positive errno */
2957 error_setg_errno(errp, ret, "fadvise failed");
2958 return;
2961 if (s->check_cache_dropped) {
2962 check_cache_dropped(bs, errp);
2964 #else /* __linux__ */
2965 /* Do nothing. Live migration to a remote host with cache.direct=off is
2966 * unsupported on other host operating systems. Cache consistency issues
2967 * may occur but no error is reported here, partly because that's the
2968 * historical behavior and partly because it's hard to differentiate valid
2969 * configurations that should not cause errors.
2971 #endif /* !__linux__ */
2974 static void raw_account_discard(BDRVRawState *s, uint64_t nbytes, int ret)
2976 if (ret) {
2977 s->stats.discard_nb_failed++;
2978 } else {
2979 s->stats.discard_nb_ok++;
2980 s->stats.discard_bytes_ok += nbytes;
2984 static coroutine_fn int
2985 raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes,
2986 bool blkdev)
2988 BDRVRawState *s = bs->opaque;
2989 RawPosixAIOData acb;
2990 int ret;
2992 acb = (RawPosixAIOData) {
2993 .bs = bs,
2994 .aio_fildes = s->fd,
2995 .aio_type = QEMU_AIO_DISCARD,
2996 .aio_offset = offset,
2997 .aio_nbytes = bytes,
3000 if (blkdev) {
3001 acb.aio_type |= QEMU_AIO_BLKDEV;
3004 ret = raw_thread_pool_submit(bs, handle_aiocb_discard, &acb);
3005 raw_account_discard(s, bytes, ret);
3006 return ret;
3009 static coroutine_fn int
3010 raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
3012 return raw_do_pdiscard(bs, offset, bytes, false);
3015 static int coroutine_fn
3016 raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
3017 BdrvRequestFlags flags, bool blkdev)
3019 BDRVRawState *s = bs->opaque;
3020 RawPosixAIOData acb;
3021 ThreadPoolFunc *handler;
3023 #ifdef CONFIG_FALLOCATE
3024 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
3025 BdrvTrackedRequest *req;
3028 * This is a workaround for a bug in the Linux XFS driver,
3029 * where writes submitted through the AIO interface will be
3030 * discarded if they happen beyond a concurrently running
3031 * fallocate() that increases the file length (i.e., both the
3032 * write and the fallocate() happen beyond the EOF).
3034 * To work around it, we extend the tracked request for this
3035 * zero write until INT64_MAX (effectively infinity), and mark
3036 * it as serializing.
3038 * We have to enable this workaround for all filesystems and
3039 * AIO modes (not just XFS with aio=native), because for
3040 * remote filesystems we do not know the host configuration.
3043 req = bdrv_co_get_self_request(bs);
3044 assert(req);
3045 assert(req->type == BDRV_TRACKED_WRITE);
3046 assert(req->offset <= offset);
3047 assert(req->offset + req->bytes >= offset + bytes);
3049 req->bytes = BDRV_MAX_LENGTH - req->offset;
3051 bdrv_check_request(req->offset, req->bytes, &error_abort);
3053 bdrv_make_request_serialising(req, bs->bl.request_alignment);
3055 #endif
3057 acb = (RawPosixAIOData) {
3058 .bs = bs,
3059 .aio_fildes = s->fd,
3060 .aio_type = QEMU_AIO_WRITE_ZEROES,
3061 .aio_offset = offset,
3062 .aio_nbytes = bytes,
3065 if (blkdev) {
3066 acb.aio_type |= QEMU_AIO_BLKDEV;
3068 if (flags & BDRV_REQ_NO_FALLBACK) {
3069 acb.aio_type |= QEMU_AIO_NO_FALLBACK;
3072 if (flags & BDRV_REQ_MAY_UNMAP) {
3073 acb.aio_type |= QEMU_AIO_DISCARD;
3074 handler = handle_aiocb_write_zeroes_unmap;
3075 } else {
3076 handler = handle_aiocb_write_zeroes;
3079 return raw_thread_pool_submit(bs, handler, &acb);
3082 static int coroutine_fn raw_co_pwrite_zeroes(
3083 BlockDriverState *bs, int64_t offset,
3084 int64_t bytes, BdrvRequestFlags flags)
3086 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, false);
3089 static int coroutine_fn
3090 raw_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3092 return 0;
3095 static ImageInfoSpecific *raw_get_specific_info(BlockDriverState *bs,
3096 Error **errp)
3098 ImageInfoSpecificFile *file_info = g_new0(ImageInfoSpecificFile, 1);
3099 ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1);
3101 *spec_info = (ImageInfoSpecific){
3102 .type = IMAGE_INFO_SPECIFIC_KIND_FILE,
3103 .u.file.data = file_info,
3106 #ifdef FS_IOC_FSGETXATTR
3108 BDRVRawState *s = bs->opaque;
3109 struct fsxattr attr;
3110 int ret;
3112 ret = ioctl(s->fd, FS_IOC_FSGETXATTR, &attr);
3113 if (!ret && attr.fsx_extsize != 0) {
3114 file_info->has_extent_size_hint = true;
3115 file_info->extent_size_hint = attr.fsx_extsize;
3118 #endif
3120 return spec_info;
3123 static BlockStatsSpecificFile get_blockstats_specific_file(BlockDriverState *bs)
3125 BDRVRawState *s = bs->opaque;
3126 return (BlockStatsSpecificFile) {
3127 .discard_nb_ok = s->stats.discard_nb_ok,
3128 .discard_nb_failed = s->stats.discard_nb_failed,
3129 .discard_bytes_ok = s->stats.discard_bytes_ok,
3133 static BlockStatsSpecific *raw_get_specific_stats(BlockDriverState *bs)
3135 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3137 stats->driver = BLOCKDEV_DRIVER_FILE;
3138 stats->u.file = get_blockstats_specific_file(bs);
3140 return stats;
3143 #if defined(HAVE_HOST_BLOCK_DEVICE)
3144 static BlockStatsSpecific *hdev_get_specific_stats(BlockDriverState *bs)
3146 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3148 stats->driver = BLOCKDEV_DRIVER_HOST_DEVICE;
3149 stats->u.host_device = get_blockstats_specific_file(bs);
3151 return stats;
3153 #endif /* HAVE_HOST_BLOCK_DEVICE */
3155 static QemuOptsList raw_create_opts = {
3156 .name = "raw-create-opts",
3157 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
3158 .desc = {
3160 .name = BLOCK_OPT_SIZE,
3161 .type = QEMU_OPT_SIZE,
3162 .help = "Virtual disk size"
3165 .name = BLOCK_OPT_NOCOW,
3166 .type = QEMU_OPT_BOOL,
3167 .help = "Turn off copy-on-write (valid only on btrfs)"
3170 .name = BLOCK_OPT_PREALLOC,
3171 .type = QEMU_OPT_STRING,
3172 .help = "Preallocation mode (allowed values: off"
3173 #ifdef CONFIG_POSIX_FALLOCATE
3174 ", falloc"
3175 #endif
3176 ", full)"
3179 .name = BLOCK_OPT_EXTENT_SIZE_HINT,
3180 .type = QEMU_OPT_SIZE,
3181 .help = "Extent size hint for the image file, 0 to disable"
3183 { /* end of list */ }
3187 static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
3188 Error **errp)
3190 BDRVRawState *s = bs->opaque;
3191 int input_flags = s->reopen_state ? s->reopen_state->flags : bs->open_flags;
3192 int open_flags;
3193 int ret;
3195 /* We may need a new fd if auto-read-only switches the mode */
3196 ret = raw_reconfigure_getfd(bs, input_flags, &open_flags, perm,
3197 false, errp);
3198 if (ret < 0) {
3199 return ret;
3200 } else if (ret != s->fd) {
3201 Error *local_err = NULL;
3204 * Fail already check_perm() if we can't get a working O_DIRECT
3205 * alignment with the new fd.
3207 raw_probe_alignment(bs, ret, &local_err);
3208 if (local_err) {
3209 error_propagate(errp, local_err);
3210 return -EINVAL;
3213 s->perm_change_fd = ret;
3214 s->perm_change_flags = open_flags;
3217 /* Prepare permissions on old fd to avoid conflicts between old and new,
3218 * but keep everything locked that new will need. */
3219 ret = raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
3220 if (ret < 0) {
3221 goto fail;
3224 /* Copy locks to the new fd */
3225 if (s->perm_change_fd && s->use_lock) {
3226 ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared,
3227 false, errp);
3228 if (ret < 0) {
3229 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3230 goto fail;
3233 return 0;
3235 fail:
3236 if (s->perm_change_fd) {
3237 qemu_close(s->perm_change_fd);
3239 s->perm_change_fd = 0;
3240 return ret;
3243 static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
3245 BDRVRawState *s = bs->opaque;
3247 /* For reopen, we have already switched to the new fd (.bdrv_set_perm is
3248 * called after .bdrv_reopen_commit) */
3249 if (s->perm_change_fd && s->fd != s->perm_change_fd) {
3250 qemu_close(s->fd);
3251 s->fd = s->perm_change_fd;
3252 s->open_flags = s->perm_change_flags;
3254 s->perm_change_fd = 0;
3256 raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
3257 s->perm = perm;
3258 s->shared_perm = shared;
3261 static void raw_abort_perm_update(BlockDriverState *bs)
3263 BDRVRawState *s = bs->opaque;
3265 /* For reopen, .bdrv_reopen_abort is called afterwards and will close
3266 * the file descriptor. */
3267 if (s->perm_change_fd) {
3268 qemu_close(s->perm_change_fd);
3270 s->perm_change_fd = 0;
3272 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3275 static int coroutine_fn raw_co_copy_range_from(
3276 BlockDriverState *bs, BdrvChild *src, int64_t src_offset,
3277 BdrvChild *dst, int64_t dst_offset, int64_t bytes,
3278 BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
3280 return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
3281 read_flags, write_flags);
3284 static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
3285 BdrvChild *src,
3286 int64_t src_offset,
3287 BdrvChild *dst,
3288 int64_t dst_offset,
3289 int64_t bytes,
3290 BdrvRequestFlags read_flags,
3291 BdrvRequestFlags write_flags)
3293 RawPosixAIOData acb;
3294 BDRVRawState *s = bs->opaque;
3295 BDRVRawState *src_s;
3297 assert(dst->bs == bs);
3298 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
3299 return -ENOTSUP;
3302 src_s = src->bs->opaque;
3303 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) {
3304 return -EIO;
3307 acb = (RawPosixAIOData) {
3308 .bs = bs,
3309 .aio_type = QEMU_AIO_COPY_RANGE,
3310 .aio_fildes = src_s->fd,
3311 .aio_offset = src_offset,
3312 .aio_nbytes = bytes,
3313 .copy_range = {
3314 .aio_fd2 = s->fd,
3315 .aio_offset2 = dst_offset,
3319 return raw_thread_pool_submit(bs, handle_aiocb_copy_range, &acb);
3322 BlockDriver bdrv_file = {
3323 .format_name = "file",
3324 .protocol_name = "file",
3325 .instance_size = sizeof(BDRVRawState),
3326 .bdrv_needs_filename = true,
3327 .bdrv_probe = NULL, /* no probe for protocols */
3328 .bdrv_parse_filename = raw_parse_filename,
3329 .bdrv_file_open = raw_open,
3330 .bdrv_reopen_prepare = raw_reopen_prepare,
3331 .bdrv_reopen_commit = raw_reopen_commit,
3332 .bdrv_reopen_abort = raw_reopen_abort,
3333 .bdrv_close = raw_close,
3334 .bdrv_co_create = raw_co_create,
3335 .bdrv_co_create_opts = raw_co_create_opts,
3336 .bdrv_has_zero_init = bdrv_has_zero_init_1,
3337 .bdrv_co_block_status = raw_co_block_status,
3338 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3339 .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
3340 .bdrv_co_delete_file = raw_co_delete_file,
3342 .bdrv_co_preadv = raw_co_preadv,
3343 .bdrv_co_pwritev = raw_co_pwritev,
3344 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3345 .bdrv_co_pdiscard = raw_co_pdiscard,
3346 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3347 .bdrv_co_copy_range_to = raw_co_copy_range_to,
3348 .bdrv_refresh_limits = raw_refresh_limits,
3349 .bdrv_co_io_plug = raw_co_io_plug,
3350 .bdrv_co_io_unplug = raw_co_io_unplug,
3351 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3353 .bdrv_co_truncate = raw_co_truncate,
3354 .bdrv_co_getlength = raw_co_getlength,
3355 .bdrv_co_get_info = raw_co_get_info,
3356 .bdrv_get_specific_info = raw_get_specific_info,
3357 .bdrv_co_get_allocated_file_size = raw_co_get_allocated_file_size,
3358 .bdrv_get_specific_stats = raw_get_specific_stats,
3359 .bdrv_check_perm = raw_check_perm,
3360 .bdrv_set_perm = raw_set_perm,
3361 .bdrv_abort_perm_update = raw_abort_perm_update,
3362 .create_opts = &raw_create_opts,
3363 .mutable_opts = mutable_opts,
3366 /***********************************************/
3367 /* host device */
3369 #if defined(HAVE_HOST_BLOCK_DEVICE)
3371 #if defined(__APPLE__) && defined(__MACH__)
3372 static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3373 CFIndex maxPathSize, int flags);
3375 #if !defined(MAC_OS_VERSION_12_0) \
3376 || (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_12_0)
3377 #define IOMainPort IOMasterPort
3378 #endif
3380 static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
3382 kern_return_t kernResult = KERN_FAILURE;
3383 mach_port_t mainPort;
3384 CFMutableDictionaryRef classesToMatch;
3385 const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
3386 char *mediaType = NULL;
3388 kernResult = IOMainPort(MACH_PORT_NULL, &mainPort);
3389 if ( KERN_SUCCESS != kernResult ) {
3390 printf("IOMainPort returned %d\n", kernResult);
3393 int index;
3394 for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
3395 classesToMatch = IOServiceMatching(matching_array[index]);
3396 if (classesToMatch == NULL) {
3397 error_report("IOServiceMatching returned NULL for %s",
3398 matching_array[index]);
3399 continue;
3401 CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
3402 kCFBooleanTrue);
3403 kernResult = IOServiceGetMatchingServices(mainPort, classesToMatch,
3404 mediaIterator);
3405 if (kernResult != KERN_SUCCESS) {
3406 error_report("Note: IOServiceGetMatchingServices returned %d",
3407 kernResult);
3408 continue;
3411 /* If a match was found, leave the loop */
3412 if (*mediaIterator != 0) {
3413 trace_file_FindEjectableOpticalMedia(matching_array[index]);
3414 mediaType = g_strdup(matching_array[index]);
3415 break;
3418 return mediaType;
3421 kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3422 CFIndex maxPathSize, int flags)
3424 io_object_t nextMedia;
3425 kern_return_t kernResult = KERN_FAILURE;
3426 *bsdPath = '\0';
3427 nextMedia = IOIteratorNext( mediaIterator );
3428 if ( nextMedia )
3430 CFTypeRef bsdPathAsCFString;
3431 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
3432 if ( bsdPathAsCFString ) {
3433 size_t devPathLength;
3434 strcpy( bsdPath, _PATH_DEV );
3435 if (flags & BDRV_O_NOCACHE) {
3436 strcat(bsdPath, "r");
3438 devPathLength = strlen( bsdPath );
3439 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
3440 kernResult = KERN_SUCCESS;
3442 CFRelease( bsdPathAsCFString );
3444 IOObjectRelease( nextMedia );
3447 return kernResult;
3450 /* Sets up a real cdrom for use in QEMU */
3451 static bool setup_cdrom(char *bsd_path, Error **errp)
3453 int index, num_of_test_partitions = 2, fd;
3454 char test_partition[MAXPATHLEN];
3455 bool partition_found = false;
3457 /* look for a working partition */
3458 for (index = 0; index < num_of_test_partitions; index++) {
3459 snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
3460 index);
3461 fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE, NULL);
3462 if (fd >= 0) {
3463 partition_found = true;
3464 qemu_close(fd);
3465 break;
3469 /* if a working partition on the device was not found */
3470 if (partition_found == false) {
3471 error_setg(errp, "Failed to find a working partition on disc");
3472 } else {
3473 trace_file_setup_cdrom(test_partition);
3474 pstrcpy(bsd_path, MAXPATHLEN, test_partition);
3476 return partition_found;
3479 /* Prints directions on mounting and unmounting a device */
3480 static void print_unmounting_directions(const char *file_name)
3482 error_report("If device %s is mounted on the desktop, unmount"
3483 " it first before using it in QEMU", file_name);
3484 error_report("Command to unmount device: diskutil unmountDisk %s",
3485 file_name);
3486 error_report("Command to mount device: diskutil mountDisk %s", file_name);
3489 #endif /* defined(__APPLE__) && defined(__MACH__) */
3491 static int hdev_probe_device(const char *filename)
3493 struct stat st;
3495 /* allow a dedicated CD-ROM driver to match with a higher priority */
3496 if (strstart(filename, "/dev/cdrom", NULL))
3497 return 50;
3499 if (stat(filename, &st) >= 0 &&
3500 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
3501 return 100;
3504 return 0;
3507 static void hdev_parse_filename(const char *filename, QDict *options,
3508 Error **errp)
3510 bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
3513 static bool hdev_is_sg(BlockDriverState *bs)
3516 #if defined(__linux__)
3518 BDRVRawState *s = bs->opaque;
3519 struct stat st;
3520 struct sg_scsi_id scsiid;
3521 int sg_version;
3522 int ret;
3524 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
3525 return false;
3528 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
3529 if (ret < 0) {
3530 return false;
3533 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
3534 if (ret >= 0) {
3535 trace_file_hdev_is_sg(scsiid.scsi_type, sg_version);
3536 return true;
3539 #endif
3541 return false;
3544 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
3545 Error **errp)
3547 BDRVRawState *s = bs->opaque;
3548 int ret;
3550 #if defined(__APPLE__) && defined(__MACH__)
3552 * Caution: while qdict_get_str() is fine, getting non-string types
3553 * would require more care. When @options come from -blockdev or
3554 * blockdev_add, its members are typed according to the QAPI
3555 * schema, but when they come from -drive, they're all QString.
3557 const char *filename = qdict_get_str(options, "filename");
3558 char bsd_path[MAXPATHLEN] = "";
3559 bool error_occurred = false;
3561 /* If using a real cdrom */
3562 if (strcmp(filename, "/dev/cdrom") == 0) {
3563 char *mediaType = NULL;
3564 kern_return_t ret_val;
3565 io_iterator_t mediaIterator = 0;
3567 mediaType = FindEjectableOpticalMedia(&mediaIterator);
3568 if (mediaType == NULL) {
3569 error_setg(errp, "Please make sure your CD/DVD is in the optical"
3570 " drive");
3571 error_occurred = true;
3572 goto hdev_open_Mac_error;
3575 ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
3576 if (ret_val != KERN_SUCCESS) {
3577 error_setg(errp, "Could not get BSD path for optical drive");
3578 error_occurred = true;
3579 goto hdev_open_Mac_error;
3582 /* If a real optical drive was not found */
3583 if (bsd_path[0] == '\0') {
3584 error_setg(errp, "Failed to obtain bsd path for optical drive");
3585 error_occurred = true;
3586 goto hdev_open_Mac_error;
3589 /* If using a cdrom disc and finding a partition on the disc failed */
3590 if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
3591 setup_cdrom(bsd_path, errp) == false) {
3592 print_unmounting_directions(bsd_path);
3593 error_occurred = true;
3594 goto hdev_open_Mac_error;
3597 qdict_put_str(options, "filename", bsd_path);
3599 hdev_open_Mac_error:
3600 g_free(mediaType);
3601 if (mediaIterator) {
3602 IOObjectRelease(mediaIterator);
3604 if (error_occurred) {
3605 return -ENOENT;
3608 #endif /* defined(__APPLE__) && defined(__MACH__) */
3610 s->type = FTYPE_FILE;
3612 ret = raw_open_common(bs, options, flags, 0, true, errp);
3613 if (ret < 0) {
3614 #if defined(__APPLE__) && defined(__MACH__)
3615 if (*bsd_path) {
3616 filename = bsd_path;
3618 /* if a physical device experienced an error while being opened */
3619 if (strncmp(filename, "/dev/", 5) == 0) {
3620 print_unmounting_directions(filename);
3622 #endif /* defined(__APPLE__) && defined(__MACH__) */
3623 return ret;
3626 /* Since this does ioctl the device must be already opened */
3627 bs->sg = hdev_is_sg(bs);
3629 return ret;
3632 #if defined(__linux__)
3633 static int coroutine_fn
3634 hdev_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
3636 BDRVRawState *s = bs->opaque;
3637 RawPosixAIOData acb;
3638 int ret;
3640 ret = fd_open(bs);
3641 if (ret < 0) {
3642 return ret;
3645 if (req == SG_IO && s->pr_mgr) {
3646 struct sg_io_hdr *io_hdr = buf;
3647 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
3648 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
3649 return pr_manager_execute(s->pr_mgr, bdrv_get_aio_context(bs),
3650 s->fd, io_hdr);
3654 acb = (RawPosixAIOData) {
3655 .bs = bs,
3656 .aio_type = QEMU_AIO_IOCTL,
3657 .aio_fildes = s->fd,
3658 .aio_offset = 0,
3659 .ioctl = {
3660 .buf = buf,
3661 .cmd = req,
3665 return raw_thread_pool_submit(bs, handle_aiocb_ioctl, &acb);
3667 #endif /* linux */
3669 static coroutine_fn int
3670 hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
3672 BDRVRawState *s = bs->opaque;
3673 int ret;
3675 ret = fd_open(bs);
3676 if (ret < 0) {
3677 raw_account_discard(s, bytes, ret);
3678 return ret;
3680 return raw_do_pdiscard(bs, offset, bytes, true);
3683 static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
3684 int64_t offset, int64_t bytes, BdrvRequestFlags flags)
3686 int rc;
3688 rc = fd_open(bs);
3689 if (rc < 0) {
3690 return rc;
3693 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
3696 static BlockDriver bdrv_host_device = {
3697 .format_name = "host_device",
3698 .protocol_name = "host_device",
3699 .instance_size = sizeof(BDRVRawState),
3700 .bdrv_needs_filename = true,
3701 .bdrv_probe_device = hdev_probe_device,
3702 .bdrv_parse_filename = hdev_parse_filename,
3703 .bdrv_file_open = hdev_open,
3704 .bdrv_close = raw_close,
3705 .bdrv_reopen_prepare = raw_reopen_prepare,
3706 .bdrv_reopen_commit = raw_reopen_commit,
3707 .bdrv_reopen_abort = raw_reopen_abort,
3708 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3709 .create_opts = &bdrv_create_opts_simple,
3710 .mutable_opts = mutable_opts,
3711 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3712 .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
3714 .bdrv_co_preadv = raw_co_preadv,
3715 .bdrv_co_pwritev = raw_co_pwritev,
3716 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3717 .bdrv_co_pdiscard = hdev_co_pdiscard,
3718 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3719 .bdrv_co_copy_range_to = raw_co_copy_range_to,
3720 .bdrv_refresh_limits = raw_refresh_limits,
3721 .bdrv_co_io_plug = raw_co_io_plug,
3722 .bdrv_co_io_unplug = raw_co_io_unplug,
3723 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3725 .bdrv_co_truncate = raw_co_truncate,
3726 .bdrv_co_getlength = raw_co_getlength,
3727 .bdrv_co_get_info = raw_co_get_info,
3728 .bdrv_get_specific_info = raw_get_specific_info,
3729 .bdrv_co_get_allocated_file_size = raw_co_get_allocated_file_size,
3730 .bdrv_get_specific_stats = hdev_get_specific_stats,
3731 .bdrv_check_perm = raw_check_perm,
3732 .bdrv_set_perm = raw_set_perm,
3733 .bdrv_abort_perm_update = raw_abort_perm_update,
3734 .bdrv_probe_blocksizes = hdev_probe_blocksizes,
3735 .bdrv_probe_geometry = hdev_probe_geometry,
3737 /* generic scsi device */
3738 #ifdef __linux__
3739 .bdrv_co_ioctl = hdev_co_ioctl,
3740 #endif
3743 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3744 static void cdrom_parse_filename(const char *filename, QDict *options,
3745 Error **errp)
3747 bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
3749 #endif
3751 #ifdef __linux__
3752 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3753 Error **errp)
3755 BDRVRawState *s = bs->opaque;
3757 s->type = FTYPE_CD;
3759 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
3760 return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp);
3763 static int cdrom_probe_device(const char *filename)
3765 int fd, ret;
3766 int prio = 0;
3767 struct stat st;
3769 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK, NULL);
3770 if (fd < 0) {
3771 goto out;
3773 ret = fstat(fd, &st);
3774 if (ret == -1 || !S_ISBLK(st.st_mode)) {
3775 goto outc;
3778 /* Attempt to detect via a CDROM specific ioctl */
3779 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3780 if (ret >= 0)
3781 prio = 100;
3783 outc:
3784 qemu_close(fd);
3785 out:
3786 return prio;
3789 static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs)
3791 BDRVRawState *s = bs->opaque;
3792 int ret;
3794 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3795 return ret == CDS_DISC_OK;
3798 static void coroutine_fn cdrom_co_eject(BlockDriverState *bs, bool eject_flag)
3800 BDRVRawState *s = bs->opaque;
3802 if (eject_flag) {
3803 if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
3804 perror("CDROMEJECT");
3805 } else {
3806 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
3807 perror("CDROMEJECT");
3811 static void coroutine_fn cdrom_co_lock_medium(BlockDriverState *bs, bool locked)
3813 BDRVRawState *s = bs->opaque;
3815 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
3817 * Note: an error can happen if the distribution automatically
3818 * mounts the CD-ROM
3820 /* perror("CDROM_LOCKDOOR"); */
3824 static BlockDriver bdrv_host_cdrom = {
3825 .format_name = "host_cdrom",
3826 .protocol_name = "host_cdrom",
3827 .instance_size = sizeof(BDRVRawState),
3828 .bdrv_needs_filename = true,
3829 .bdrv_probe_device = cdrom_probe_device,
3830 .bdrv_parse_filename = cdrom_parse_filename,
3831 .bdrv_file_open = cdrom_open,
3832 .bdrv_close = raw_close,
3833 .bdrv_reopen_prepare = raw_reopen_prepare,
3834 .bdrv_reopen_commit = raw_reopen_commit,
3835 .bdrv_reopen_abort = raw_reopen_abort,
3836 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3837 .create_opts = &bdrv_create_opts_simple,
3838 .mutable_opts = mutable_opts,
3839 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3841 .bdrv_co_preadv = raw_co_preadv,
3842 .bdrv_co_pwritev = raw_co_pwritev,
3843 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3844 .bdrv_refresh_limits = raw_refresh_limits,
3845 .bdrv_co_io_plug = raw_co_io_plug,
3846 .bdrv_co_io_unplug = raw_co_io_unplug,
3847 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3849 .bdrv_co_truncate = raw_co_truncate,
3850 .bdrv_co_getlength = raw_co_getlength,
3851 .has_variable_length = true,
3852 .bdrv_co_get_allocated_file_size = raw_co_get_allocated_file_size,
3854 /* removable device support */
3855 .bdrv_co_is_inserted = cdrom_co_is_inserted,
3856 .bdrv_co_eject = cdrom_co_eject,
3857 .bdrv_co_lock_medium = cdrom_co_lock_medium,
3859 /* generic scsi device */
3860 .bdrv_co_ioctl = hdev_co_ioctl,
3862 #endif /* __linux__ */
3864 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
3865 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3866 Error **errp)
3868 BDRVRawState *s = bs->opaque;
3869 int ret;
3871 s->type = FTYPE_CD;
3873 ret = raw_open_common(bs, options, flags, 0, true, errp);
3874 if (ret) {
3875 return ret;
3878 /* make sure the door isn't locked at this time */
3879 ioctl(s->fd, CDIOCALLOW);
3880 return 0;
3883 static int cdrom_probe_device(const char *filename)
3885 if (strstart(filename, "/dev/cd", NULL) ||
3886 strstart(filename, "/dev/acd", NULL))
3887 return 100;
3888 return 0;
3891 static int cdrom_reopen(BlockDriverState *bs)
3893 BDRVRawState *s = bs->opaque;
3894 int fd;
3897 * Force reread of possibly changed/newly loaded disc,
3898 * FreeBSD seems to not notice sometimes...
3900 if (s->fd >= 0)
3901 qemu_close(s->fd);
3902 fd = qemu_open(bs->filename, s->open_flags, NULL);
3903 if (fd < 0) {
3904 s->fd = -1;
3905 return -EIO;
3907 s->fd = fd;
3909 /* make sure the door isn't locked at this time */
3910 ioctl(s->fd, CDIOCALLOW);
3911 return 0;
3914 static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs)
3916 return raw_co_getlength(bs) > 0;
3919 static void coroutine_fn cdrom_co_eject(BlockDriverState *bs, bool eject_flag)
3921 BDRVRawState *s = bs->opaque;
3923 if (s->fd < 0)
3924 return;
3926 (void) ioctl(s->fd, CDIOCALLOW);
3928 if (eject_flag) {
3929 if (ioctl(s->fd, CDIOCEJECT) < 0)
3930 perror("CDIOCEJECT");
3931 } else {
3932 if (ioctl(s->fd, CDIOCCLOSE) < 0)
3933 perror("CDIOCCLOSE");
3936 cdrom_reopen(bs);
3939 static void coroutine_fn cdrom_co_lock_medium(BlockDriverState *bs, bool locked)
3941 BDRVRawState *s = bs->opaque;
3943 if (s->fd < 0)
3944 return;
3945 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
3947 * Note: an error can happen if the distribution automatically
3948 * mounts the CD-ROM
3950 /* perror("CDROM_LOCKDOOR"); */
3954 static BlockDriver bdrv_host_cdrom = {
3955 .format_name = "host_cdrom",
3956 .protocol_name = "host_cdrom",
3957 .instance_size = sizeof(BDRVRawState),
3958 .bdrv_needs_filename = true,
3959 .bdrv_probe_device = cdrom_probe_device,
3960 .bdrv_parse_filename = cdrom_parse_filename,
3961 .bdrv_file_open = cdrom_open,
3962 .bdrv_close = raw_close,
3963 .bdrv_reopen_prepare = raw_reopen_prepare,
3964 .bdrv_reopen_commit = raw_reopen_commit,
3965 .bdrv_reopen_abort = raw_reopen_abort,
3966 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3967 .create_opts = &bdrv_create_opts_simple,
3968 .mutable_opts = mutable_opts,
3970 .bdrv_co_preadv = raw_co_preadv,
3971 .bdrv_co_pwritev = raw_co_pwritev,
3972 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3973 .bdrv_refresh_limits = raw_refresh_limits,
3974 .bdrv_co_io_plug = raw_co_io_plug,
3975 .bdrv_co_io_unplug = raw_co_io_unplug,
3976 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3978 .bdrv_co_truncate = raw_co_truncate,
3979 .bdrv_co_getlength = raw_co_getlength,
3980 .has_variable_length = true,
3981 .bdrv_co_get_allocated_file_size = raw_co_get_allocated_file_size,
3983 /* removable device support */
3984 .bdrv_co_is_inserted = cdrom_co_is_inserted,
3985 .bdrv_co_eject = cdrom_co_eject,
3986 .bdrv_co_lock_medium = cdrom_co_lock_medium,
3988 #endif /* __FreeBSD__ */
3990 #endif /* HAVE_HOST_BLOCK_DEVICE */
3992 static void bdrv_file_init(void)
3995 * Register all the drivers. Note that order is important, the driver
3996 * registered last will get probed first.
3998 bdrv_register(&bdrv_file);
3999 #if defined(HAVE_HOST_BLOCK_DEVICE)
4000 bdrv_register(&bdrv_host_device);
4001 #ifdef __linux__
4002 bdrv_register(&bdrv_host_cdrom);
4003 #endif
4004 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
4005 bdrv_register(&bdrv_host_cdrom);
4006 #endif
4007 #endif /* HAVE_HOST_BLOCK_DEVICE */
4010 block_init(bdrv_file_init);