Merge remote-tracking branch 'remotes/armbru/tags/pull-qobject-2020-11-17' into staging
[qemu/ar7.git] / block / file-posix.c
blobd5fd1dbcd20bddc320a86c0cdaca03bca3b73974
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 "qemu-common.h"
27 #include "qapi/error.h"
28 #include "qemu/cutils.h"
29 #include "qemu/error-report.h"
30 #include "block/block_int.h"
31 #include "qemu/module.h"
32 #include "qemu/option.h"
33 #include "qemu/units.h"
34 #include "trace.h"
35 #include "block/thread-pool.h"
36 #include "qemu/iov.h"
37 #include "block/raw-aio.h"
38 #include "qapi/qmp/qdict.h"
39 #include "qapi/qmp/qstring.h"
41 #include "scsi/pr-manager.h"
42 #include "scsi/constants.h"
44 #if defined(__APPLE__) && (__MACH__)
45 #include <paths.h>
46 #include <sys/param.h>
47 #include <IOKit/IOKitLib.h>
48 #include <IOKit/IOBSD.h>
49 #include <IOKit/storage/IOMediaBSDClient.h>
50 #include <IOKit/storage/IOMedia.h>
51 #include <IOKit/storage/IOCDMedia.h>
52 //#include <IOKit/storage/IOCDTypes.h>
53 #include <IOKit/storage/IODVDMedia.h>
54 #include <CoreFoundation/CoreFoundation.h>
55 #endif
57 #ifdef __sun__
58 #define _POSIX_PTHREAD_SEMANTICS 1
59 #include <sys/dkio.h>
60 #endif
61 #ifdef __linux__
62 #include <sys/ioctl.h>
63 #include <sys/param.h>
64 #include <sys/syscall.h>
65 #include <sys/vfs.h>
66 #include <linux/cdrom.h>
67 #include <linux/fd.h>
68 #include <linux/fs.h>
69 #include <linux/hdreg.h>
70 #include <linux/magic.h>
71 #include <scsi/sg.h>
72 #ifdef __s390__
73 #include <asm/dasd.h>
74 #endif
75 #ifndef FS_NOCOW_FL
76 #define FS_NOCOW_FL 0x00800000 /* Do not cow file */
77 #endif
78 #endif
79 #if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
80 #include <linux/falloc.h>
81 #endif
82 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
83 #include <sys/disk.h>
84 #include <sys/cdio.h>
85 #endif
87 #ifdef __OpenBSD__
88 #include <sys/ioctl.h>
89 #include <sys/disklabel.h>
90 #include <sys/dkio.h>
91 #endif
93 #ifdef __NetBSD__
94 #include <sys/ioctl.h>
95 #include <sys/disklabel.h>
96 #include <sys/dkio.h>
97 #include <sys/disk.h>
98 #endif
100 #ifdef __DragonFly__
101 #include <sys/ioctl.h>
102 #include <sys/diskslice.h>
103 #endif
105 #ifdef CONFIG_XFS
106 #include <xfs/xfs.h>
107 #endif
109 #include "trace.h"
111 /* OS X does not have O_DSYNC */
112 #ifndef O_DSYNC
113 #ifdef O_SYNC
114 #define O_DSYNC O_SYNC
115 #elif defined(O_FSYNC)
116 #define O_DSYNC O_FSYNC
117 #endif
118 #endif
120 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
121 #ifndef O_DIRECT
122 #define O_DIRECT O_DSYNC
123 #endif
125 #define FTYPE_FILE 0
126 #define FTYPE_CD 1
128 #define MAX_BLOCKSIZE 4096
130 /* Posix file locking bytes. Libvirt takes byte 0, we start from higher bytes,
131 * leaving a few more bytes for its future use. */
132 #define RAW_LOCK_PERM_BASE 100
133 #define RAW_LOCK_SHARED_BASE 200
135 typedef struct BDRVRawState {
136 int fd;
137 bool use_lock;
138 int type;
139 int open_flags;
140 size_t buf_align;
142 /* The current permissions. */
143 uint64_t perm;
144 uint64_t shared_perm;
146 /* The perms bits whose corresponding bytes are already locked in
147 * s->fd. */
148 uint64_t locked_perm;
149 uint64_t locked_shared_perm;
151 int perm_change_fd;
152 int perm_change_flags;
153 BDRVReopenState *reopen_state;
155 #ifdef CONFIG_XFS
156 bool is_xfs:1;
157 #endif
158 bool has_discard:1;
159 bool has_write_zeroes:1;
160 bool discard_zeroes:1;
161 bool use_linux_aio:1;
162 bool use_linux_io_uring:1;
163 bool page_cache_inconsistent:1;
164 bool has_fallocate;
165 bool needs_alignment;
166 bool drop_cache;
167 bool check_cache_dropped;
168 struct {
169 uint64_t discard_nb_ok;
170 uint64_t discard_nb_failed;
171 uint64_t discard_bytes_ok;
172 } stats;
174 PRManager *pr_mgr;
175 } BDRVRawState;
177 typedef struct BDRVRawReopenState {
178 int fd;
179 int open_flags;
180 bool drop_cache;
181 bool check_cache_dropped;
182 } BDRVRawReopenState;
184 static int fd_open(BlockDriverState *bs);
185 static int64_t raw_getlength(BlockDriverState *bs);
187 typedef struct RawPosixAIOData {
188 BlockDriverState *bs;
189 int aio_type;
190 int aio_fildes;
192 off_t aio_offset;
193 uint64_t aio_nbytes;
195 union {
196 struct {
197 struct iovec *iov;
198 int niov;
199 } io;
200 struct {
201 uint64_t cmd;
202 void *buf;
203 } ioctl;
204 struct {
205 int aio_fd2;
206 off_t aio_offset2;
207 } copy_range;
208 struct {
209 PreallocMode prealloc;
210 Error **errp;
211 } truncate;
213 } RawPosixAIOData;
215 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
216 static int cdrom_reopen(BlockDriverState *bs);
217 #endif
219 #if defined(__NetBSD__)
220 static int raw_normalize_devicepath(const char **filename, Error **errp)
222 static char namebuf[PATH_MAX];
223 const char *dp, *fname;
224 struct stat sb;
226 fname = *filename;
227 dp = strrchr(fname, '/');
228 if (lstat(fname, &sb) < 0) {
229 error_setg_file_open(errp, errno, fname);
230 return -errno;
233 if (!S_ISBLK(sb.st_mode)) {
234 return 0;
237 if (dp == NULL) {
238 snprintf(namebuf, PATH_MAX, "r%s", fname);
239 } else {
240 snprintf(namebuf, PATH_MAX, "%.*s/r%s",
241 (int)(dp - fname), fname, dp + 1);
243 *filename = namebuf;
244 warn_report("%s is a block device, using %s", fname, *filename);
246 return 0;
248 #else
249 static int raw_normalize_devicepath(const char **filename, Error **errp)
251 return 0;
253 #endif
256 * Get logical block size via ioctl. On success store it in @sector_size_p.
258 static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
260 unsigned int sector_size;
261 bool success = false;
262 int i;
264 errno = ENOTSUP;
265 static const unsigned long ioctl_list[] = {
266 #ifdef BLKSSZGET
267 BLKSSZGET,
268 #endif
269 #ifdef DKIOCGETBLOCKSIZE
270 DKIOCGETBLOCKSIZE,
271 #endif
272 #ifdef DIOCGSECTORSIZE
273 DIOCGSECTORSIZE,
274 #endif
277 /* Try a few ioctls to get the right size */
278 for (i = 0; i < (int)ARRAY_SIZE(ioctl_list); i++) {
279 if (ioctl(fd, ioctl_list[i], &sector_size) >= 0) {
280 *sector_size_p = sector_size;
281 success = true;
285 return success ? 0 : -errno;
289 * Get physical block size of @fd.
290 * On success, store it in @blk_size and return 0.
291 * On failure, return -errno.
293 static int probe_physical_blocksize(int fd, unsigned int *blk_size)
295 #ifdef BLKPBSZGET
296 if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
297 return -errno;
299 return 0;
300 #else
301 return -ENOTSUP;
302 #endif
306 * Returns true if no alignment restrictions are necessary even for files
307 * opened with O_DIRECT.
309 * raw_probe_alignment() probes the required alignment and assume that 1 means
310 * the probing failed, so it falls back to a safe default of 4k. This can be
311 * avoided if we know that byte alignment is okay for the file.
313 static bool dio_byte_aligned(int fd)
315 #ifdef __linux__
316 struct statfs buf;
317 int ret;
319 ret = fstatfs(fd, &buf);
320 if (ret == 0 && buf.f_type == NFS_SUPER_MAGIC) {
321 return true;
323 #endif
324 return false;
327 /* Check if read is allowed with given memory buffer and length.
329 * This function is used to check O_DIRECT memory buffer and request alignment.
331 static bool raw_is_io_aligned(int fd, void *buf, size_t len)
333 ssize_t ret = pread(fd, buf, len, 0);
335 if (ret >= 0) {
336 return true;
339 #ifdef __linux__
340 /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads. Ignore
341 * other errors (e.g. real I/O error), which could happen on a failed
342 * drive, since we only care about probing alignment.
344 if (errno != EINVAL) {
345 return true;
347 #endif
349 return false;
352 static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
354 BDRVRawState *s = bs->opaque;
355 char *buf;
356 size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size);
357 size_t alignments[] = {1, 512, 1024, 2048, 4096};
359 /* For SCSI generic devices the alignment is not really used.
360 With buffered I/O, we don't have any restrictions. */
361 if (bdrv_is_sg(bs) || !s->needs_alignment) {
362 bs->bl.request_alignment = 1;
363 s->buf_align = 1;
364 return;
367 bs->bl.request_alignment = 0;
368 s->buf_align = 0;
369 /* Let's try to use the logical blocksize for the alignment. */
370 if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) {
371 bs->bl.request_alignment = 0;
373 #ifdef CONFIG_XFS
374 if (s->is_xfs) {
375 struct dioattr da;
376 if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {
377 bs->bl.request_alignment = da.d_miniosz;
378 /* The kernel returns wrong information for d_mem */
379 /* s->buf_align = da.d_mem; */
382 #endif
385 * If we could not get the sizes so far, we can only guess them. First try
386 * to detect request alignment, since it is more likely to succeed. Then
387 * try to detect buf_align, which cannot be detected in some cases (e.g.
388 * Gluster). If buf_align cannot be detected, we fallback to the value of
389 * request_alignment.
392 if (!bs->bl.request_alignment) {
393 int i;
394 size_t align;
395 buf = qemu_memalign(max_align, max_align);
396 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
397 align = alignments[i];
398 if (raw_is_io_aligned(fd, buf, align)) {
399 /* Fallback to safe value. */
400 bs->bl.request_alignment = (align != 1) ? align : max_align;
401 break;
404 qemu_vfree(buf);
407 if (!s->buf_align) {
408 int i;
409 size_t align;
410 buf = qemu_memalign(max_align, 2 * max_align);
411 for (i = 0; i < ARRAY_SIZE(alignments); i++) {
412 align = alignments[i];
413 if (raw_is_io_aligned(fd, buf + align, max_align)) {
414 /* Fallback to request_alignment. */
415 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
416 break;
419 qemu_vfree(buf);
422 if (!s->buf_align || !bs->bl.request_alignment) {
423 error_setg(errp, "Could not find working O_DIRECT alignment");
424 error_append_hint(errp, "Try cache.direct=off\n");
428 static int check_hdev_writable(int fd)
430 #if defined(BLKROGET)
431 /* Linux block devices can be configured "read-only" using blockdev(8).
432 * This is independent of device node permissions and therefore open(2)
433 * with O_RDWR succeeds. Actual writes fail with EPERM.
435 * bdrv_open() is supposed to fail if the disk is read-only. Explicitly
436 * check for read-only block devices so that Linux block devices behave
437 * properly.
439 struct stat st;
440 int readonly = 0;
442 if (fstat(fd, &st)) {
443 return -errno;
446 if (!S_ISBLK(st.st_mode)) {
447 return 0;
450 if (ioctl(fd, BLKROGET, &readonly) < 0) {
451 return -errno;
454 if (readonly) {
455 return -EACCES;
457 #endif /* defined(BLKROGET) */
458 return 0;
461 static void raw_parse_flags(int bdrv_flags, int *open_flags, bool has_writers)
463 bool read_write = false;
464 assert(open_flags != NULL);
466 *open_flags |= O_BINARY;
467 *open_flags &= ~O_ACCMODE;
469 if (bdrv_flags & BDRV_O_AUTO_RDONLY) {
470 read_write = has_writers;
471 } else if (bdrv_flags & BDRV_O_RDWR) {
472 read_write = true;
475 if (read_write) {
476 *open_flags |= O_RDWR;
477 } else {
478 *open_flags |= O_RDONLY;
481 /* Use O_DSYNC for write-through caching, no flags for write-back caching,
482 * and O_DIRECT for no caching. */
483 if ((bdrv_flags & BDRV_O_NOCACHE)) {
484 *open_flags |= O_DIRECT;
488 static void raw_parse_filename(const char *filename, QDict *options,
489 Error **errp)
491 bdrv_parse_filename_strip_prefix(filename, "file:", options);
494 static QemuOptsList raw_runtime_opts = {
495 .name = "raw",
496 .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
497 .desc = {
499 .name = "filename",
500 .type = QEMU_OPT_STRING,
501 .help = "File name of the image",
504 .name = "aio",
505 .type = QEMU_OPT_STRING,
506 .help = "host AIO implementation (threads, native, io_uring)",
509 .name = "locking",
510 .type = QEMU_OPT_STRING,
511 .help = "file locking mode (on/off/auto, default: auto)",
514 .name = "pr-manager",
515 .type = QEMU_OPT_STRING,
516 .help = "id of persistent reservation manager object (default: none)",
518 #if defined(__linux__)
520 .name = "drop-cache",
521 .type = QEMU_OPT_BOOL,
522 .help = "invalidate page cache during live migration (default: on)",
524 #endif
526 .name = "x-check-cache-dropped",
527 .type = QEMU_OPT_BOOL,
528 .help = "check that page cache was dropped on live migration (default: off)"
530 { /* end of list */ }
534 static const char *const mutable_opts[] = { "x-check-cache-dropped", NULL };
536 static int raw_open_common(BlockDriverState *bs, QDict *options,
537 int bdrv_flags, int open_flags,
538 bool device, Error **errp)
540 BDRVRawState *s = bs->opaque;
541 QemuOpts *opts;
542 Error *local_err = NULL;
543 const char *filename = NULL;
544 const char *str;
545 BlockdevAioOptions aio, aio_default;
546 int fd, ret;
547 struct stat st;
548 OnOffAuto locking;
550 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
551 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
552 ret = -EINVAL;
553 goto fail;
556 filename = qemu_opt_get(opts, "filename");
558 ret = raw_normalize_devicepath(&filename, errp);
559 if (ret != 0) {
560 goto fail;
563 if (bdrv_flags & BDRV_O_NATIVE_AIO) {
564 aio_default = BLOCKDEV_AIO_OPTIONS_NATIVE;
565 #ifdef CONFIG_LINUX_IO_URING
566 } else if (bdrv_flags & BDRV_O_IO_URING) {
567 aio_default = BLOCKDEV_AIO_OPTIONS_IO_URING;
568 #endif
569 } else {
570 aio_default = BLOCKDEV_AIO_OPTIONS_THREADS;
573 aio = qapi_enum_parse(&BlockdevAioOptions_lookup,
574 qemu_opt_get(opts, "aio"),
575 aio_default, &local_err);
576 if (local_err) {
577 error_propagate(errp, local_err);
578 ret = -EINVAL;
579 goto fail;
582 s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
583 #ifdef CONFIG_LINUX_IO_URING
584 s->use_linux_io_uring = (aio == BLOCKDEV_AIO_OPTIONS_IO_URING);
585 #endif
587 locking = qapi_enum_parse(&OnOffAuto_lookup,
588 qemu_opt_get(opts, "locking"),
589 ON_OFF_AUTO_AUTO, &local_err);
590 if (local_err) {
591 error_propagate(errp, local_err);
592 ret = -EINVAL;
593 goto fail;
595 switch (locking) {
596 case ON_OFF_AUTO_ON:
597 s->use_lock = true;
598 if (!qemu_has_ofd_lock()) {
599 warn_report("File lock requested but OFD locking syscall is "
600 "unavailable, falling back to POSIX file locks");
601 error_printf("Due to the implementation, locks can be lost "
602 "unexpectedly.\n");
604 break;
605 case ON_OFF_AUTO_OFF:
606 s->use_lock = false;
607 break;
608 case ON_OFF_AUTO_AUTO:
609 s->use_lock = qemu_has_ofd_lock();
610 break;
611 default:
612 abort();
615 str = qemu_opt_get(opts, "pr-manager");
616 if (str) {
617 s->pr_mgr = pr_manager_lookup(str, &local_err);
618 if (local_err) {
619 error_propagate(errp, local_err);
620 ret = -EINVAL;
621 goto fail;
625 s->drop_cache = qemu_opt_get_bool(opts, "drop-cache", true);
626 s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped",
627 false);
629 s->open_flags = open_flags;
630 raw_parse_flags(bdrv_flags, &s->open_flags, false);
632 s->fd = -1;
633 fd = qemu_open(filename, s->open_flags, errp);
634 ret = fd < 0 ? -errno : 0;
636 if (ret < 0) {
637 if (ret == -EROFS) {
638 ret = -EACCES;
640 goto fail;
642 s->fd = fd;
644 /* Check s->open_flags rather than bdrv_flags due to auto-read-only */
645 if (s->open_flags & O_RDWR) {
646 ret = check_hdev_writable(s->fd);
647 if (ret < 0) {
648 error_setg_errno(errp, -ret, "The device is not writable");
649 goto fail;
653 s->perm = 0;
654 s->shared_perm = BLK_PERM_ALL;
656 #ifdef CONFIG_LINUX_AIO
657 /* Currently Linux does AIO only for files opened with O_DIRECT */
658 if (s->use_linux_aio) {
659 if (!(s->open_flags & O_DIRECT)) {
660 error_setg(errp, "aio=native was specified, but it requires "
661 "cache.direct=on, which was not specified.");
662 ret = -EINVAL;
663 goto fail;
665 if (!aio_setup_linux_aio(bdrv_get_aio_context(bs), errp)) {
666 error_prepend(errp, "Unable to use native AIO: ");
667 goto fail;
670 #else
671 if (s->use_linux_aio) {
672 error_setg(errp, "aio=native was specified, but is not supported "
673 "in this build.");
674 ret = -EINVAL;
675 goto fail;
677 #endif /* !defined(CONFIG_LINUX_AIO) */
679 #ifdef CONFIG_LINUX_IO_URING
680 if (s->use_linux_io_uring) {
681 if (!aio_setup_linux_io_uring(bdrv_get_aio_context(bs), errp)) {
682 error_prepend(errp, "Unable to use io_uring: ");
683 goto fail;
686 #else
687 if (s->use_linux_io_uring) {
688 error_setg(errp, "aio=io_uring was specified, but is not supported "
689 "in this build.");
690 ret = -EINVAL;
691 goto fail;
693 #endif /* !defined(CONFIG_LINUX_IO_URING) */
695 s->has_discard = true;
696 s->has_write_zeroes = true;
697 if ((bs->open_flags & BDRV_O_NOCACHE) != 0 && !dio_byte_aligned(s->fd)) {
698 s->needs_alignment = true;
701 if (fstat(s->fd, &st) < 0) {
702 ret = -errno;
703 error_setg_errno(errp, errno, "Could not stat file");
704 goto fail;
707 if (!device) {
708 if (S_ISBLK(st.st_mode)) {
709 warn_report("Opening a block device as a file using the '%s' "
710 "driver is deprecated", bs->drv->format_name);
711 } else if (S_ISCHR(st.st_mode)) {
712 warn_report("Opening a character device as a file using the '%s' "
713 "driver is deprecated", bs->drv->format_name);
714 } else if (!S_ISREG(st.st_mode)) {
715 error_setg(errp, "A regular file was expected by the '%s' driver, "
716 "but something else was given", bs->drv->format_name);
717 ret = -EINVAL;
718 goto fail;
719 } else {
720 s->discard_zeroes = true;
721 s->has_fallocate = true;
723 } else {
724 if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
725 error_setg(errp, "'%s' driver expects either "
726 "a character or block device", bs->drv->format_name);
727 ret = -EINVAL;
728 goto fail;
732 if (S_ISBLK(st.st_mode)) {
733 #ifdef BLKDISCARDZEROES
734 unsigned int arg;
735 if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
736 s->discard_zeroes = true;
738 #endif
739 #ifdef __linux__
740 /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache. Do
741 * not rely on the contents of discarded blocks unless using O_DIRECT.
742 * Same for BLKZEROOUT.
744 if (!(bs->open_flags & BDRV_O_NOCACHE)) {
745 s->discard_zeroes = false;
746 s->has_write_zeroes = false;
748 #endif
750 #ifdef __FreeBSD__
751 if (S_ISCHR(st.st_mode)) {
753 * The file is a char device (disk), which on FreeBSD isn't behind
754 * a pager, so force all requests to be aligned. This is needed
755 * so QEMU makes sure all IO operations on the device are aligned
756 * to sector size, or else FreeBSD will reject them with EINVAL.
758 s->needs_alignment = true;
760 #endif
762 #ifdef CONFIG_XFS
763 if (platform_test_xfs_fd(s->fd)) {
764 s->is_xfs = true;
766 #endif
768 bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
769 if (S_ISREG(st.st_mode)) {
770 /* When extending regular files, we get zeros from the OS */
771 bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
773 ret = 0;
774 fail:
775 if (ret < 0 && s->fd != -1) {
776 qemu_close(s->fd);
778 if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
779 unlink(filename);
781 qemu_opts_del(opts);
782 return ret;
785 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
786 Error **errp)
788 BDRVRawState *s = bs->opaque;
790 s->type = FTYPE_FILE;
791 return raw_open_common(bs, options, flags, 0, false, errp);
794 typedef enum {
795 RAW_PL_PREPARE,
796 RAW_PL_COMMIT,
797 RAW_PL_ABORT,
798 } RawPermLockOp;
800 #define PERM_FOREACH(i) \
801 for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++)
803 /* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the
804 * file; if @unlock == true, also unlock the unneeded bytes.
805 * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
807 static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
808 uint64_t perm_lock_bits,
809 uint64_t shared_perm_lock_bits,
810 bool unlock, Error **errp)
812 int ret;
813 int i;
814 uint64_t locked_perm, locked_shared_perm;
816 if (s) {
817 locked_perm = s->locked_perm;
818 locked_shared_perm = s->locked_shared_perm;
819 } else {
821 * We don't have the previous bits, just lock/unlock for each of the
822 * requested bits.
824 if (unlock) {
825 locked_perm = BLK_PERM_ALL;
826 locked_shared_perm = BLK_PERM_ALL;
827 } else {
828 locked_perm = 0;
829 locked_shared_perm = 0;
833 PERM_FOREACH(i) {
834 int off = RAW_LOCK_PERM_BASE + i;
835 uint64_t bit = (1ULL << i);
836 if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
837 ret = qemu_lock_fd(fd, off, 1, false);
838 if (ret) {
839 error_setg(errp, "Failed to lock byte %d", off);
840 return ret;
841 } else if (s) {
842 s->locked_perm |= bit;
844 } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
845 ret = qemu_unlock_fd(fd, off, 1);
846 if (ret) {
847 error_setg(errp, "Failed to unlock byte %d", off);
848 return ret;
849 } else if (s) {
850 s->locked_perm &= ~bit;
854 PERM_FOREACH(i) {
855 int off = RAW_LOCK_SHARED_BASE + i;
856 uint64_t bit = (1ULL << i);
857 if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
858 ret = qemu_lock_fd(fd, off, 1, false);
859 if (ret) {
860 error_setg(errp, "Failed to lock byte %d", off);
861 return ret;
862 } else if (s) {
863 s->locked_shared_perm |= bit;
865 } else if (unlock && (locked_shared_perm & bit) &&
866 !(shared_perm_lock_bits & bit)) {
867 ret = qemu_unlock_fd(fd, off, 1);
868 if (ret) {
869 error_setg(errp, "Failed to unlock byte %d", off);
870 return ret;
871 } else if (s) {
872 s->locked_shared_perm &= ~bit;
876 return 0;
879 /* Check "unshared" bytes implied by @perm and ~@shared_perm in the file. */
880 static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm,
881 Error **errp)
883 int ret;
884 int i;
886 PERM_FOREACH(i) {
887 int off = RAW_LOCK_SHARED_BASE + i;
888 uint64_t p = 1ULL << i;
889 if (perm & p) {
890 ret = qemu_lock_fd_test(fd, off, 1, true);
891 if (ret) {
892 char *perm_name = bdrv_perm_names(p);
893 error_setg(errp,
894 "Failed to get \"%s\" lock",
895 perm_name);
896 g_free(perm_name);
897 return ret;
901 PERM_FOREACH(i) {
902 int off = RAW_LOCK_PERM_BASE + i;
903 uint64_t p = 1ULL << i;
904 if (!(shared_perm & p)) {
905 ret = qemu_lock_fd_test(fd, off, 1, true);
906 if (ret) {
907 char *perm_name = bdrv_perm_names(p);
908 error_setg(errp,
909 "Failed to get shared \"%s\" lock",
910 perm_name);
911 g_free(perm_name);
912 return ret;
916 return 0;
919 static int raw_handle_perm_lock(BlockDriverState *bs,
920 RawPermLockOp op,
921 uint64_t new_perm, uint64_t new_shared,
922 Error **errp)
924 BDRVRawState *s = bs->opaque;
925 int ret = 0;
926 Error *local_err = NULL;
928 if (!s->use_lock) {
929 return 0;
932 if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) {
933 return 0;
936 switch (op) {
937 case RAW_PL_PREPARE:
938 if ((s->perm | new_perm) == s->perm &&
939 (s->shared_perm & new_shared) == s->shared_perm)
942 * We are going to unlock bytes, it should not fail. If it fail due
943 * to some fs-dependent permission-unrelated reasons (which occurs
944 * sometimes on NFS and leads to abort in bdrv_replace_child) we
945 * can't prevent such errors by any check here. And we ignore them
946 * anyway in ABORT and COMMIT.
948 return 0;
950 ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm,
951 ~s->shared_perm | ~new_shared,
952 false, errp);
953 if (!ret) {
954 ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp);
955 if (!ret) {
956 return 0;
958 error_append_hint(errp,
959 "Is another process using the image [%s]?\n",
960 bs->filename);
962 /* fall through to unlock bytes. */
963 case RAW_PL_ABORT:
964 raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm,
965 true, &local_err);
966 if (local_err) {
967 /* Theoretically the above call only unlocks bytes and it cannot
968 * fail. Something weird happened, report it.
970 warn_report_err(local_err);
972 break;
973 case RAW_PL_COMMIT:
974 raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared,
975 true, &local_err);
976 if (local_err) {
977 /* Theoretically the above call only unlocks bytes and it cannot
978 * fail. Something weird happened, report it.
980 warn_report_err(local_err);
982 break;
984 return ret;
987 static int raw_reconfigure_getfd(BlockDriverState *bs, int flags,
988 int *open_flags, uint64_t perm, bool force_dup,
989 Error **errp)
991 BDRVRawState *s = bs->opaque;
992 int fd = -1;
993 int ret;
994 bool has_writers = perm &
995 (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_RESIZE);
996 int fcntl_flags = O_APPEND | O_NONBLOCK;
997 #ifdef O_NOATIME
998 fcntl_flags |= O_NOATIME;
999 #endif
1001 *open_flags = 0;
1002 if (s->type == FTYPE_CD) {
1003 *open_flags |= O_NONBLOCK;
1006 raw_parse_flags(flags, open_flags, has_writers);
1008 #ifdef O_ASYNC
1009 /* Not all operating systems have O_ASYNC, and those that don't
1010 * will not let us track the state into rs->open_flags (typically
1011 * you achieve the same effect with an ioctl, for example I_SETSIG
1012 * on Solaris). But we do not use O_ASYNC, so that's fine.
1014 assert((s->open_flags & O_ASYNC) == 0);
1015 #endif
1017 if (!force_dup && *open_flags == s->open_flags) {
1018 /* We're lucky, the existing fd is fine */
1019 return s->fd;
1022 if ((*open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
1023 /* dup the original fd */
1024 fd = qemu_dup(s->fd);
1025 if (fd >= 0) {
1026 ret = fcntl_setfl(fd, *open_flags);
1027 if (ret) {
1028 qemu_close(fd);
1029 fd = -1;
1034 /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
1035 if (fd == -1) {
1036 const char *normalized_filename = bs->filename;
1037 ret = raw_normalize_devicepath(&normalized_filename, errp);
1038 if (ret >= 0) {
1039 fd = qemu_open(normalized_filename, *open_flags, errp);
1040 if (fd == -1) {
1041 return -1;
1046 if (fd != -1 && (*open_flags & O_RDWR)) {
1047 ret = check_hdev_writable(fd);
1048 if (ret < 0) {
1049 qemu_close(fd);
1050 error_setg_errno(errp, -ret, "The device is not writable");
1051 return -1;
1055 return fd;
1058 static int raw_reopen_prepare(BDRVReopenState *state,
1059 BlockReopenQueue *queue, Error **errp)
1061 BDRVRawState *s;
1062 BDRVRawReopenState *rs;
1063 QemuOpts *opts;
1064 int ret;
1065 Error *local_err = NULL;
1067 assert(state != NULL);
1068 assert(state->bs != NULL);
1070 s = state->bs->opaque;
1072 state->opaque = g_new0(BDRVRawReopenState, 1);
1073 rs = state->opaque;
1075 /* Handle options changes */
1076 opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
1077 if (!qemu_opts_absorb_qdict(opts, state->options, errp)) {
1078 ret = -EINVAL;
1079 goto out;
1082 rs->drop_cache = qemu_opt_get_bool_del(opts, "drop-cache", true);
1083 rs->check_cache_dropped =
1084 qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false);
1086 /* This driver's reopen function doesn't currently allow changing
1087 * other options, so let's put them back in the original QDict and
1088 * bdrv_reopen_prepare() will detect changes and complain. */
1089 qemu_opts_to_qdict(opts, state->options);
1091 rs->fd = raw_reconfigure_getfd(state->bs, state->flags, &rs->open_flags,
1092 state->perm, true, &local_err);
1093 if (local_err) {
1094 error_propagate(errp, local_err);
1095 ret = -1;
1096 goto out;
1099 /* Fail already reopen_prepare() if we can't get a working O_DIRECT
1100 * alignment with the new fd. */
1101 if (rs->fd != -1) {
1102 raw_probe_alignment(state->bs, rs->fd, &local_err);
1103 if (local_err) {
1104 error_propagate(errp, local_err);
1105 ret = -EINVAL;
1106 goto out_fd;
1110 s->reopen_state = state;
1111 ret = 0;
1112 out_fd:
1113 if (ret < 0) {
1114 qemu_close(rs->fd);
1115 rs->fd = -1;
1117 out:
1118 qemu_opts_del(opts);
1119 return ret;
1122 static void raw_reopen_commit(BDRVReopenState *state)
1124 BDRVRawReopenState *rs = state->opaque;
1125 BDRVRawState *s = state->bs->opaque;
1127 s->drop_cache = rs->drop_cache;
1128 s->check_cache_dropped = rs->check_cache_dropped;
1129 s->open_flags = rs->open_flags;
1131 qemu_close(s->fd);
1132 s->fd = rs->fd;
1134 g_free(state->opaque);
1135 state->opaque = NULL;
1137 assert(s->reopen_state == state);
1138 s->reopen_state = NULL;
1142 static void raw_reopen_abort(BDRVReopenState *state)
1144 BDRVRawReopenState *rs = state->opaque;
1145 BDRVRawState *s = state->bs->opaque;
1147 /* nothing to do if NULL, we didn't get far enough */
1148 if (rs == NULL) {
1149 return;
1152 if (rs->fd >= 0) {
1153 qemu_close(rs->fd);
1154 rs->fd = -1;
1156 g_free(state->opaque);
1157 state->opaque = NULL;
1159 assert(s->reopen_state == state);
1160 s->reopen_state = NULL;
1163 static int sg_get_max_transfer_length(int fd)
1165 #ifdef BLKSECTGET
1166 int max_bytes = 0;
1168 if (ioctl(fd, BLKSECTGET, &max_bytes) == 0) {
1169 return max_bytes;
1170 } else {
1171 return -errno;
1173 #else
1174 return -ENOSYS;
1175 #endif
1178 static int sg_get_max_segments(int fd)
1180 #ifdef CONFIG_LINUX
1181 char buf[32];
1182 const char *end;
1183 char *sysfspath = NULL;
1184 int ret;
1185 int sysfd = -1;
1186 long max_segments;
1187 struct stat st;
1189 if (fstat(fd, &st)) {
1190 ret = -errno;
1191 goto out;
1194 sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments",
1195 major(st.st_rdev), minor(st.st_rdev));
1196 sysfd = open(sysfspath, O_RDONLY);
1197 if (sysfd == -1) {
1198 ret = -errno;
1199 goto out;
1201 do {
1202 ret = read(sysfd, buf, sizeof(buf) - 1);
1203 } while (ret == -1 && errno == EINTR);
1204 if (ret < 0) {
1205 ret = -errno;
1206 goto out;
1207 } else if (ret == 0) {
1208 ret = -EIO;
1209 goto out;
1211 buf[ret] = 0;
1212 /* The file is ended with '\n', pass 'end' to accept that. */
1213 ret = qemu_strtol(buf, &end, 10, &max_segments);
1214 if (ret == 0 && end && *end == '\n') {
1215 ret = max_segments;
1218 out:
1219 if (sysfd != -1) {
1220 close(sysfd);
1222 g_free(sysfspath);
1223 return ret;
1224 #else
1225 return -ENOTSUP;
1226 #endif
1229 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
1231 BDRVRawState *s = bs->opaque;
1233 if (bs->sg) {
1234 int ret = sg_get_max_transfer_length(s->fd);
1236 if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) {
1237 bs->bl.max_transfer = pow2floor(ret);
1240 ret = sg_get_max_segments(s->fd);
1241 if (ret > 0) {
1242 bs->bl.max_transfer = MIN(bs->bl.max_transfer,
1243 ret * qemu_real_host_page_size);
1247 raw_probe_alignment(bs, s->fd, errp);
1248 bs->bl.min_mem_alignment = s->buf_align;
1249 bs->bl.opt_mem_alignment = MAX(s->buf_align, qemu_real_host_page_size);
1252 static int check_for_dasd(int fd)
1254 #ifdef BIODASDINFO2
1255 struct dasd_information2_t info = {0};
1257 return ioctl(fd, BIODASDINFO2, &info);
1258 #else
1259 return -1;
1260 #endif
1264 * Try to get @bs's logical and physical block size.
1265 * On success, store them in @bsz and return zero.
1266 * On failure, return negative errno.
1268 static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
1270 BDRVRawState *s = bs->opaque;
1271 int ret;
1273 /* If DASD, get blocksizes */
1274 if (check_for_dasd(s->fd) < 0) {
1275 return -ENOTSUP;
1277 ret = probe_logical_blocksize(s->fd, &bsz->log);
1278 if (ret < 0) {
1279 return ret;
1281 return probe_physical_blocksize(s->fd, &bsz->phys);
1285 * Try to get @bs's geometry: cyls, heads, sectors.
1286 * On success, store them in @geo and return 0.
1287 * On failure return -errno.
1288 * (Allows block driver to assign default geometry values that guest sees)
1290 #ifdef __linux__
1291 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1293 BDRVRawState *s = bs->opaque;
1294 struct hd_geometry ioctl_geo = {0};
1296 /* If DASD, get its geometry */
1297 if (check_for_dasd(s->fd) < 0) {
1298 return -ENOTSUP;
1300 if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
1301 return -errno;
1303 /* HDIO_GETGEO may return success even though geo contains zeros
1304 (e.g. certain multipath setups) */
1305 if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
1306 return -ENOTSUP;
1308 /* Do not return a geometry for partition */
1309 if (ioctl_geo.start != 0) {
1310 return -ENOTSUP;
1312 geo->heads = ioctl_geo.heads;
1313 geo->sectors = ioctl_geo.sectors;
1314 geo->cylinders = ioctl_geo.cylinders;
1316 return 0;
1318 #else /* __linux__ */
1319 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1321 return -ENOTSUP;
1323 #endif
1325 #if defined(__linux__)
1326 static int handle_aiocb_ioctl(void *opaque)
1328 RawPosixAIOData *aiocb = opaque;
1329 int ret;
1331 ret = ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf);
1332 if (ret == -1) {
1333 return -errno;
1336 return 0;
1338 #endif /* linux */
1340 static int handle_aiocb_flush(void *opaque)
1342 RawPosixAIOData *aiocb = opaque;
1343 BDRVRawState *s = aiocb->bs->opaque;
1344 int ret;
1346 if (s->page_cache_inconsistent) {
1347 return -EIO;
1350 ret = qemu_fdatasync(aiocb->aio_fildes);
1351 if (ret == -1) {
1352 /* There is no clear definition of the semantics of a failing fsync(),
1353 * so we may have to assume the worst. The sad truth is that this
1354 * assumption is correct for Linux. Some pages are now probably marked
1355 * clean in the page cache even though they are inconsistent with the
1356 * on-disk contents. The next fdatasync() call would succeed, but no
1357 * further writeback attempt will be made. We can't get back to a state
1358 * in which we know what is on disk (we would have to rewrite
1359 * everything that was touched since the last fdatasync() at least), so
1360 * make bdrv_flush() fail permanently. Given that the behaviour isn't
1361 * really defined, I have little hope that other OSes are doing better.
1363 * Obviously, this doesn't affect O_DIRECT, which bypasses the page
1364 * cache. */
1365 if ((s->open_flags & O_DIRECT) == 0) {
1366 s->page_cache_inconsistent = true;
1368 return -errno;
1370 return 0;
1373 #ifdef CONFIG_PREADV
1375 static bool preadv_present = true;
1377 static ssize_t
1378 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1380 return preadv(fd, iov, nr_iov, offset);
1383 static ssize_t
1384 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1386 return pwritev(fd, iov, nr_iov, offset);
1389 #else
1391 static bool preadv_present = false;
1393 static ssize_t
1394 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1396 return -ENOSYS;
1399 static ssize_t
1400 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1402 return -ENOSYS;
1405 #endif
1407 static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
1409 ssize_t len;
1411 do {
1412 if (aiocb->aio_type & QEMU_AIO_WRITE)
1413 len = qemu_pwritev(aiocb->aio_fildes,
1414 aiocb->io.iov,
1415 aiocb->io.niov,
1416 aiocb->aio_offset);
1417 else
1418 len = qemu_preadv(aiocb->aio_fildes,
1419 aiocb->io.iov,
1420 aiocb->io.niov,
1421 aiocb->aio_offset);
1422 } while (len == -1 && errno == EINTR);
1424 if (len == -1) {
1425 return -errno;
1427 return len;
1431 * Read/writes the data to/from a given linear buffer.
1433 * Returns the number of bytes handles or -errno in case of an error. Short
1434 * reads are only returned if the end of the file is reached.
1436 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
1438 ssize_t offset = 0;
1439 ssize_t len;
1441 while (offset < aiocb->aio_nbytes) {
1442 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1443 len = pwrite(aiocb->aio_fildes,
1444 (const char *)buf + offset,
1445 aiocb->aio_nbytes - offset,
1446 aiocb->aio_offset + offset);
1447 } else {
1448 len = pread(aiocb->aio_fildes,
1449 buf + offset,
1450 aiocb->aio_nbytes - offset,
1451 aiocb->aio_offset + offset);
1453 if (len == -1 && errno == EINTR) {
1454 continue;
1455 } else if (len == -1 && errno == EINVAL &&
1456 (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
1457 !(aiocb->aio_type & QEMU_AIO_WRITE) &&
1458 offset > 0) {
1459 /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
1460 * after a short read. Assume that O_DIRECT short reads only occur
1461 * at EOF. Therefore this is a short read, not an I/O error.
1463 break;
1464 } else if (len == -1) {
1465 offset = -errno;
1466 break;
1467 } else if (len == 0) {
1468 break;
1470 offset += len;
1473 return offset;
1476 static int handle_aiocb_rw(void *opaque)
1478 RawPosixAIOData *aiocb = opaque;
1479 ssize_t nbytes;
1480 char *buf;
1482 if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
1484 * If there is just a single buffer, and it is properly aligned
1485 * we can just use plain pread/pwrite without any problems.
1487 if (aiocb->io.niov == 1) {
1488 nbytes = handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base);
1489 goto out;
1492 * We have more than one iovec, and all are properly aligned.
1494 * Try preadv/pwritev first and fall back to linearizing the
1495 * buffer if it's not supported.
1497 if (preadv_present) {
1498 nbytes = handle_aiocb_rw_vector(aiocb);
1499 if (nbytes == aiocb->aio_nbytes ||
1500 (nbytes < 0 && nbytes != -ENOSYS)) {
1501 goto out;
1503 preadv_present = false;
1507 * XXX(hch): short read/write. no easy way to handle the reminder
1508 * using these interfaces. For now retry using plain
1509 * pread/pwrite?
1514 * Ok, we have to do it the hard way, copy all segments into
1515 * a single aligned buffer.
1517 buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
1518 if (buf == NULL) {
1519 nbytes = -ENOMEM;
1520 goto out;
1523 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1524 char *p = buf;
1525 int i;
1527 for (i = 0; i < aiocb->io.niov; ++i) {
1528 memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len);
1529 p += aiocb->io.iov[i].iov_len;
1531 assert(p - buf == aiocb->aio_nbytes);
1534 nbytes = handle_aiocb_rw_linear(aiocb, buf);
1535 if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
1536 char *p = buf;
1537 size_t count = aiocb->aio_nbytes, copy;
1538 int i;
1540 for (i = 0; i < aiocb->io.niov && count; ++i) {
1541 copy = count;
1542 if (copy > aiocb->io.iov[i].iov_len) {
1543 copy = aiocb->io.iov[i].iov_len;
1545 memcpy(aiocb->io.iov[i].iov_base, p, copy);
1546 assert(count >= copy);
1547 p += copy;
1548 count -= copy;
1550 assert(count == 0);
1552 qemu_vfree(buf);
1554 out:
1555 if (nbytes == aiocb->aio_nbytes) {
1556 return 0;
1557 } else if (nbytes >= 0 && nbytes < aiocb->aio_nbytes) {
1558 if (aiocb->aio_type & QEMU_AIO_WRITE) {
1559 return -EINVAL;
1560 } else {
1561 iov_memset(aiocb->io.iov, aiocb->io.niov, nbytes,
1562 0, aiocb->aio_nbytes - nbytes);
1563 return 0;
1565 } else {
1566 assert(nbytes < 0);
1567 return nbytes;
1571 static int translate_err(int err)
1573 if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1574 err == -ENOTTY) {
1575 err = -ENOTSUP;
1577 return err;
1580 #ifdef CONFIG_FALLOCATE
1581 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1583 do {
1584 if (fallocate(fd, mode, offset, len) == 0) {
1585 return 0;
1587 } while (errno == EINTR);
1588 return translate_err(-errno);
1590 #endif
1592 static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1594 int ret = -ENOTSUP;
1595 BDRVRawState *s = aiocb->bs->opaque;
1597 if (!s->has_write_zeroes) {
1598 return -ENOTSUP;
1601 #ifdef BLKZEROOUT
1602 /* The BLKZEROOUT implementation in the kernel doesn't set
1603 * BLKDEV_ZERO_NOFALLBACK, so we can't call this if we have to avoid slow
1604 * fallbacks. */
1605 if (!(aiocb->aio_type & QEMU_AIO_NO_FALLBACK)) {
1606 do {
1607 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1608 if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1609 return 0;
1611 } while (errno == EINTR);
1613 ret = translate_err(-errno);
1614 if (ret == -ENOTSUP) {
1615 s->has_write_zeroes = false;
1618 #endif
1620 return ret;
1623 static int handle_aiocb_write_zeroes(void *opaque)
1625 RawPosixAIOData *aiocb = opaque;
1626 #ifdef CONFIG_FALLOCATE
1627 BDRVRawState *s = aiocb->bs->opaque;
1628 int64_t len;
1629 #endif
1631 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1632 return handle_aiocb_write_zeroes_block(aiocb);
1635 #ifdef CONFIG_FALLOCATE_ZERO_RANGE
1636 if (s->has_write_zeroes) {
1637 int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1638 aiocb->aio_offset, aiocb->aio_nbytes);
1639 if (ret == -EINVAL) {
1641 * Allow falling back to pwrite for file systems that
1642 * do not support fallocate() for an unaligned byte range.
1644 return -ENOTSUP;
1646 if (ret == 0 || ret != -ENOTSUP) {
1647 return ret;
1649 s->has_write_zeroes = false;
1651 #endif
1653 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1654 if (s->has_discard && s->has_fallocate) {
1655 int ret = do_fallocate(s->fd,
1656 FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1657 aiocb->aio_offset, aiocb->aio_nbytes);
1658 if (ret == 0) {
1659 ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1660 if (ret == 0 || ret != -ENOTSUP) {
1661 return ret;
1663 s->has_fallocate = false;
1664 } else if (ret != -ENOTSUP) {
1665 return ret;
1666 } else {
1667 s->has_discard = false;
1670 #endif
1672 #ifdef CONFIG_FALLOCATE
1673 /* Last resort: we are trying to extend the file with zeroed data. This
1674 * can be done via fallocate(fd, 0) */
1675 len = bdrv_getlength(aiocb->bs);
1676 if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
1677 int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1678 if (ret == 0 || ret != -ENOTSUP) {
1679 return ret;
1681 s->has_fallocate = false;
1683 #endif
1685 return -ENOTSUP;
1688 static int handle_aiocb_write_zeroes_unmap(void *opaque)
1690 RawPosixAIOData *aiocb = opaque;
1691 BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque;
1693 /* First try to write zeros and unmap at the same time */
1695 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1696 int ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1697 aiocb->aio_offset, aiocb->aio_nbytes);
1698 switch (ret) {
1699 case -ENOTSUP:
1700 case -EINVAL:
1701 case -EBUSY:
1702 break;
1703 default:
1704 return ret;
1706 #endif
1708 /* If we couldn't manage to unmap while guaranteed that the area reads as
1709 * all-zero afterwards, just write zeroes without unmapping */
1710 return handle_aiocb_write_zeroes(aiocb);
1713 #ifndef HAVE_COPY_FILE_RANGE
1714 static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
1715 off_t *out_off, size_t len, unsigned int flags)
1717 #ifdef __NR_copy_file_range
1718 return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
1719 out_off, len, flags);
1720 #else
1721 errno = ENOSYS;
1722 return -1;
1723 #endif
1725 #endif
1727 static int handle_aiocb_copy_range(void *opaque)
1729 RawPosixAIOData *aiocb = opaque;
1730 uint64_t bytes = aiocb->aio_nbytes;
1731 off_t in_off = aiocb->aio_offset;
1732 off_t out_off = aiocb->copy_range.aio_offset2;
1734 while (bytes) {
1735 ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
1736 aiocb->copy_range.aio_fd2, &out_off,
1737 bytes, 0);
1738 trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
1739 aiocb->copy_range.aio_fd2, out_off, bytes,
1740 0, ret);
1741 if (ret == 0) {
1742 /* No progress (e.g. when beyond EOF), let the caller fall back to
1743 * buffer I/O. */
1744 return -ENOSPC;
1746 if (ret < 0) {
1747 switch (errno) {
1748 case ENOSYS:
1749 return -ENOTSUP;
1750 case EINTR:
1751 continue;
1752 default:
1753 return -errno;
1756 bytes -= ret;
1758 return 0;
1761 static int handle_aiocb_discard(void *opaque)
1763 RawPosixAIOData *aiocb = opaque;
1764 int ret = -EOPNOTSUPP;
1765 BDRVRawState *s = aiocb->bs->opaque;
1767 if (!s->has_discard) {
1768 return -ENOTSUP;
1771 if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1772 #ifdef BLKDISCARD
1773 do {
1774 uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1775 if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1776 return 0;
1778 } while (errno == EINTR);
1780 ret = -errno;
1781 #endif
1782 } else {
1783 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1784 ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1785 aiocb->aio_offset, aiocb->aio_nbytes);
1786 #endif
1789 ret = translate_err(ret);
1790 if (ret == -ENOTSUP) {
1791 s->has_discard = false;
1793 return ret;
1797 * Help alignment probing by allocating the first block.
1799 * When reading with direct I/O from unallocated area on Gluster backed by XFS,
1800 * reading succeeds regardless of request length. In this case we fallback to
1801 * safe alignment which is not optimal. Allocating the first block avoids this
1802 * fallback.
1804 * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
1805 * request alignment, so we use safe values.
1807 * Returns: 0 on success, -errno on failure. Since this is an optimization,
1808 * caller may ignore failures.
1810 static int allocate_first_block(int fd, size_t max_size)
1812 size_t write_size = (max_size < MAX_BLOCKSIZE)
1813 ? BDRV_SECTOR_SIZE
1814 : MAX_BLOCKSIZE;
1815 size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size);
1816 void *buf;
1817 ssize_t n;
1818 int ret;
1820 buf = qemu_memalign(max_align, write_size);
1821 memset(buf, 0, write_size);
1823 do {
1824 n = pwrite(fd, buf, write_size, 0);
1825 } while (n == -1 && errno == EINTR);
1827 ret = (n == -1) ? -errno : 0;
1829 qemu_vfree(buf);
1830 return ret;
1833 static int handle_aiocb_truncate(void *opaque)
1835 RawPosixAIOData *aiocb = opaque;
1836 int result = 0;
1837 int64_t current_length = 0;
1838 char *buf = NULL;
1839 struct stat st;
1840 int fd = aiocb->aio_fildes;
1841 int64_t offset = aiocb->aio_offset;
1842 PreallocMode prealloc = aiocb->truncate.prealloc;
1843 Error **errp = aiocb->truncate.errp;
1845 if (fstat(fd, &st) < 0) {
1846 result = -errno;
1847 error_setg_errno(errp, -result, "Could not stat file");
1848 return result;
1851 current_length = st.st_size;
1852 if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
1853 error_setg(errp, "Cannot use preallocation for shrinking files");
1854 return -ENOTSUP;
1857 switch (prealloc) {
1858 #ifdef CONFIG_POSIX_FALLOCATE
1859 case PREALLOC_MODE_FALLOC:
1861 * Truncating before posix_fallocate() makes it about twice slower on
1862 * file systems that do not support fallocate(), trying to check if a
1863 * block is allocated before allocating it, so don't do that here.
1865 if (offset != current_length) {
1866 result = -posix_fallocate(fd, current_length,
1867 offset - current_length);
1868 if (result != 0) {
1869 /* posix_fallocate() doesn't set errno. */
1870 error_setg_errno(errp, -result,
1871 "Could not preallocate new data");
1872 } else if (current_length == 0) {
1874 * posix_fallocate() uses fallocate() if the filesystem
1875 * supports it, or fallback to manually writing zeroes. If
1876 * fallocate() was used, unaligned reads from the fallocated
1877 * area in raw_probe_alignment() will succeed, hence we need to
1878 * allocate the first block.
1880 * Optimize future alignment probing; ignore failures.
1882 allocate_first_block(fd, offset);
1884 } else {
1885 result = 0;
1887 goto out;
1888 #endif
1889 case PREALLOC_MODE_FULL:
1891 int64_t num = 0, left = offset - current_length;
1892 off_t seek_result;
1895 * Knowing the final size from the beginning could allow the file
1896 * system driver to do less allocations and possibly avoid
1897 * fragmentation of the file.
1899 if (ftruncate(fd, offset) != 0) {
1900 result = -errno;
1901 error_setg_errno(errp, -result, "Could not resize file");
1902 goto out;
1905 buf = g_malloc0(65536);
1907 seek_result = lseek(fd, current_length, SEEK_SET);
1908 if (seek_result < 0) {
1909 result = -errno;
1910 error_setg_errno(errp, -result,
1911 "Failed to seek to the old end of file");
1912 goto out;
1915 while (left > 0) {
1916 num = MIN(left, 65536);
1917 result = write(fd, buf, num);
1918 if (result < 0) {
1919 if (errno == EINTR) {
1920 continue;
1922 result = -errno;
1923 error_setg_errno(errp, -result,
1924 "Could not write zeros for preallocation");
1925 goto out;
1927 left -= result;
1929 if (result >= 0) {
1930 result = fsync(fd);
1931 if (result < 0) {
1932 result = -errno;
1933 error_setg_errno(errp, -result,
1934 "Could not flush file to disk");
1935 goto out;
1938 goto out;
1940 case PREALLOC_MODE_OFF:
1941 if (ftruncate(fd, offset) != 0) {
1942 result = -errno;
1943 error_setg_errno(errp, -result, "Could not resize file");
1944 } else if (current_length == 0 && offset > current_length) {
1945 /* Optimize future alignment probing; ignore failures. */
1946 allocate_first_block(fd, offset);
1948 return result;
1949 default:
1950 result = -ENOTSUP;
1951 error_setg(errp, "Unsupported preallocation mode: %s",
1952 PreallocMode_str(prealloc));
1953 return result;
1956 out:
1957 if (result < 0) {
1958 if (ftruncate(fd, current_length) < 0) {
1959 error_report("Failed to restore old file length: %s",
1960 strerror(errno));
1964 g_free(buf);
1965 return result;
1968 static int coroutine_fn raw_thread_pool_submit(BlockDriverState *bs,
1969 ThreadPoolFunc func, void *arg)
1971 /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */
1972 ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1973 return thread_pool_submit_co(pool, func, arg);
1976 static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
1977 uint64_t bytes, QEMUIOVector *qiov, int type)
1979 BDRVRawState *s = bs->opaque;
1980 RawPosixAIOData acb;
1982 if (fd_open(bs) < 0)
1983 return -EIO;
1986 * When using O_DIRECT, the request must be aligned to be able to use
1987 * either libaio or io_uring interface. If not fail back to regular thread
1988 * pool read/write code which emulates this for us if we
1989 * set QEMU_AIO_MISALIGNED.
1991 if (s->needs_alignment && !bdrv_qiov_is_aligned(bs, qiov)) {
1992 type |= QEMU_AIO_MISALIGNED;
1993 #ifdef CONFIG_LINUX_IO_URING
1994 } else if (s->use_linux_io_uring) {
1995 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
1996 assert(qiov->size == bytes);
1997 return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
1998 #endif
1999 #ifdef CONFIG_LINUX_AIO
2000 } else if (s->use_linux_aio) {
2001 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2002 assert(qiov->size == bytes);
2003 return laio_co_submit(bs, aio, s->fd, offset, qiov, type);
2004 #endif
2007 acb = (RawPosixAIOData) {
2008 .bs = bs,
2009 .aio_fildes = s->fd,
2010 .aio_type = type,
2011 .aio_offset = offset,
2012 .aio_nbytes = bytes,
2013 .io = {
2014 .iov = qiov->iov,
2015 .niov = qiov->niov,
2019 assert(qiov->size == bytes);
2020 return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
2023 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
2024 uint64_t bytes, QEMUIOVector *qiov,
2025 int flags)
2027 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
2030 static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
2031 uint64_t bytes, QEMUIOVector *qiov,
2032 int flags)
2034 assert(flags == 0);
2035 return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
2038 static void raw_aio_plug(BlockDriverState *bs)
2040 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2041 #ifdef CONFIG_LINUX_AIO
2042 if (s->use_linux_aio) {
2043 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2044 laio_io_plug(bs, aio);
2046 #endif
2047 #ifdef CONFIG_LINUX_IO_URING
2048 if (s->use_linux_io_uring) {
2049 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2050 luring_io_plug(bs, aio);
2052 #endif
2055 static void raw_aio_unplug(BlockDriverState *bs)
2057 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2058 #ifdef CONFIG_LINUX_AIO
2059 if (s->use_linux_aio) {
2060 LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2061 laio_io_unplug(bs, aio);
2063 #endif
2064 #ifdef CONFIG_LINUX_IO_URING
2065 if (s->use_linux_io_uring) {
2066 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2067 luring_io_unplug(bs, aio);
2069 #endif
2072 static int raw_co_flush_to_disk(BlockDriverState *bs)
2074 BDRVRawState *s = bs->opaque;
2075 RawPosixAIOData acb;
2076 int ret;
2078 ret = fd_open(bs);
2079 if (ret < 0) {
2080 return ret;
2083 acb = (RawPosixAIOData) {
2084 .bs = bs,
2085 .aio_fildes = s->fd,
2086 .aio_type = QEMU_AIO_FLUSH,
2089 #ifdef CONFIG_LINUX_IO_URING
2090 if (s->use_linux_io_uring) {
2091 LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
2092 return luring_co_submit(bs, aio, s->fd, 0, NULL, QEMU_AIO_FLUSH);
2094 #endif
2095 return raw_thread_pool_submit(bs, handle_aiocb_flush, &acb);
2098 static void raw_aio_attach_aio_context(BlockDriverState *bs,
2099 AioContext *new_context)
2101 BDRVRawState __attribute__((unused)) *s = bs->opaque;
2102 #ifdef CONFIG_LINUX_AIO
2103 if (s->use_linux_aio) {
2104 Error *local_err = NULL;
2105 if (!aio_setup_linux_aio(new_context, &local_err)) {
2106 error_reportf_err(local_err, "Unable to use native AIO, "
2107 "falling back to thread pool: ");
2108 s->use_linux_aio = false;
2111 #endif
2112 #ifdef CONFIG_LINUX_IO_URING
2113 if (s->use_linux_io_uring) {
2114 Error *local_err;
2115 if (!aio_setup_linux_io_uring(new_context, &local_err)) {
2116 error_reportf_err(local_err, "Unable to use linux io_uring, "
2117 "falling back to thread pool: ");
2118 s->use_linux_io_uring = false;
2121 #endif
2124 static void raw_close(BlockDriverState *bs)
2126 BDRVRawState *s = bs->opaque;
2128 if (s->fd >= 0) {
2129 qemu_close(s->fd);
2130 s->fd = -1;
2135 * Truncates the given regular file @fd to @offset and, when growing, fills the
2136 * new space according to @prealloc.
2138 * Returns: 0 on success, -errno on failure.
2140 static int coroutine_fn
2141 raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
2142 PreallocMode prealloc, Error **errp)
2144 RawPosixAIOData acb;
2146 acb = (RawPosixAIOData) {
2147 .bs = bs,
2148 .aio_fildes = fd,
2149 .aio_type = QEMU_AIO_TRUNCATE,
2150 .aio_offset = offset,
2151 .truncate = {
2152 .prealloc = prealloc,
2153 .errp = errp,
2157 return raw_thread_pool_submit(bs, handle_aiocb_truncate, &acb);
2160 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
2161 bool exact, PreallocMode prealloc,
2162 BdrvRequestFlags flags, Error **errp)
2164 BDRVRawState *s = bs->opaque;
2165 struct stat st;
2166 int ret;
2168 if (fstat(s->fd, &st)) {
2169 ret = -errno;
2170 error_setg_errno(errp, -ret, "Failed to fstat() the file");
2171 return ret;
2174 if (S_ISREG(st.st_mode)) {
2175 /* Always resizes to the exact @offset */
2176 return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
2179 if (prealloc != PREALLOC_MODE_OFF) {
2180 error_setg(errp, "Preallocation mode '%s' unsupported for this "
2181 "non-regular file", PreallocMode_str(prealloc));
2182 return -ENOTSUP;
2185 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2186 int64_t cur_length = raw_getlength(bs);
2188 if (offset != cur_length && exact) {
2189 error_setg(errp, "Cannot resize device files");
2190 return -ENOTSUP;
2191 } else if (offset > cur_length) {
2192 error_setg(errp, "Cannot grow device files");
2193 return -EINVAL;
2195 } else {
2196 error_setg(errp, "Resizing this file is not supported");
2197 return -ENOTSUP;
2200 return 0;
2203 #ifdef __OpenBSD__
2204 static int64_t raw_getlength(BlockDriverState *bs)
2206 BDRVRawState *s = bs->opaque;
2207 int fd = s->fd;
2208 struct stat st;
2210 if (fstat(fd, &st))
2211 return -errno;
2212 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2213 struct disklabel dl;
2215 if (ioctl(fd, DIOCGDINFO, &dl))
2216 return -errno;
2217 return (uint64_t)dl.d_secsize *
2218 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2219 } else
2220 return st.st_size;
2222 #elif defined(__NetBSD__)
2223 static int64_t raw_getlength(BlockDriverState *bs)
2225 BDRVRawState *s = bs->opaque;
2226 int fd = s->fd;
2227 struct stat st;
2229 if (fstat(fd, &st))
2230 return -errno;
2231 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2232 struct dkwedge_info dkw;
2234 if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
2235 return dkw.dkw_size * 512;
2236 } else {
2237 struct disklabel dl;
2239 if (ioctl(fd, DIOCGDINFO, &dl))
2240 return -errno;
2241 return (uint64_t)dl.d_secsize *
2242 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2244 } else
2245 return st.st_size;
2247 #elif defined(__sun__)
2248 static int64_t raw_getlength(BlockDriverState *bs)
2250 BDRVRawState *s = bs->opaque;
2251 struct dk_minfo minfo;
2252 int ret;
2253 int64_t size;
2255 ret = fd_open(bs);
2256 if (ret < 0) {
2257 return ret;
2261 * Use the DKIOCGMEDIAINFO ioctl to read the size.
2263 ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
2264 if (ret != -1) {
2265 return minfo.dki_lbsize * minfo.dki_capacity;
2269 * There are reports that lseek on some devices fails, but
2270 * irc discussion said that contingency on contingency was overkill.
2272 size = lseek(s->fd, 0, SEEK_END);
2273 if (size < 0) {
2274 return -errno;
2276 return size;
2278 #elif defined(CONFIG_BSD)
2279 static int64_t raw_getlength(BlockDriverState *bs)
2281 BDRVRawState *s = bs->opaque;
2282 int fd = s->fd;
2283 int64_t size;
2284 struct stat sb;
2285 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2286 int reopened = 0;
2287 #endif
2288 int ret;
2290 ret = fd_open(bs);
2291 if (ret < 0)
2292 return ret;
2294 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2295 again:
2296 #endif
2297 if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2298 #ifdef DIOCGMEDIASIZE
2299 if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
2300 #elif defined(DIOCGPART)
2302 struct partinfo pi;
2303 if (ioctl(fd, DIOCGPART, &pi) == 0)
2304 size = pi.media_size;
2305 else
2306 size = 0;
2308 if (size == 0)
2309 #endif
2310 #if defined(__APPLE__) && defined(__MACH__)
2312 uint64_t sectors = 0;
2313 uint32_t sector_size = 0;
2315 if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
2316 && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
2317 size = sectors * sector_size;
2318 } else {
2319 size = lseek(fd, 0LL, SEEK_END);
2320 if (size < 0) {
2321 return -errno;
2325 #else
2326 size = lseek(fd, 0LL, SEEK_END);
2327 if (size < 0) {
2328 return -errno;
2330 #endif
2331 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2332 switch(s->type) {
2333 case FTYPE_CD:
2334 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
2335 if (size == 2048LL * (unsigned)-1)
2336 size = 0;
2337 /* XXX no disc? maybe we need to reopen... */
2338 if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
2339 reopened = 1;
2340 goto again;
2343 #endif
2344 } else {
2345 size = lseek(fd, 0, SEEK_END);
2346 if (size < 0) {
2347 return -errno;
2350 return size;
2352 #else
2353 static int64_t raw_getlength(BlockDriverState *bs)
2355 BDRVRawState *s = bs->opaque;
2356 int ret;
2357 int64_t size;
2359 ret = fd_open(bs);
2360 if (ret < 0) {
2361 return ret;
2364 size = lseek(s->fd, 0, SEEK_END);
2365 if (size < 0) {
2366 return -errno;
2368 return size;
2370 #endif
2372 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
2374 struct stat st;
2375 BDRVRawState *s = bs->opaque;
2377 if (fstat(s->fd, &st) < 0) {
2378 return -errno;
2380 return (int64_t)st.st_blocks * 512;
2383 static int coroutine_fn
2384 raw_co_create(BlockdevCreateOptions *options, Error **errp)
2386 BlockdevCreateOptionsFile *file_opts;
2387 Error *local_err = NULL;
2388 int fd;
2389 uint64_t perm, shared;
2390 int result = 0;
2392 /* Validate options and set default values */
2393 assert(options->driver == BLOCKDEV_DRIVER_FILE);
2394 file_opts = &options->u.file;
2396 if (!file_opts->has_nocow) {
2397 file_opts->nocow = false;
2399 if (!file_opts->has_preallocation) {
2400 file_opts->preallocation = PREALLOC_MODE_OFF;
2402 if (!file_opts->has_extent_size_hint) {
2403 file_opts->extent_size_hint = 1 * MiB;
2405 if (file_opts->extent_size_hint > UINT32_MAX) {
2406 result = -EINVAL;
2407 error_setg(errp, "Extent size hint is too large");
2408 goto out;
2411 /* Create file */
2412 fd = qemu_create(file_opts->filename, O_RDWR | O_BINARY, 0644, errp);
2413 if (fd < 0) {
2414 result = -errno;
2415 goto out;
2418 /* Take permissions: We want to discard everything, so we need
2419 * BLK_PERM_WRITE; and truncation to the desired size requires
2420 * BLK_PERM_RESIZE.
2421 * On the other hand, we cannot share the RESIZE permission
2422 * because we promise that after this function, the file has the
2423 * size given in the options. If someone else were to resize it
2424 * concurrently, we could not guarantee that.
2425 * Note that after this function, we can no longer guarantee that
2426 * the file is not touched by a third party, so it may be resized
2427 * then. */
2428 perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2429 shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2431 /* Step one: Take locks */
2432 result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
2433 if (result < 0) {
2434 goto out_close;
2437 /* Step two: Check that nobody else has taken conflicting locks */
2438 result = raw_check_lock_bytes(fd, perm, shared, errp);
2439 if (result < 0) {
2440 error_append_hint(errp,
2441 "Is another process using the image [%s]?\n",
2442 file_opts->filename);
2443 goto out_unlock;
2446 /* Clear the file by truncating it to 0 */
2447 result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
2448 if (result < 0) {
2449 goto out_unlock;
2452 if (file_opts->nocow) {
2453 #ifdef __linux__
2454 /* Set NOCOW flag to solve performance issue on fs like btrfs.
2455 * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
2456 * will be ignored since any failure of this operation should not
2457 * block the left work.
2459 int attr;
2460 if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2461 attr |= FS_NOCOW_FL;
2462 ioctl(fd, FS_IOC_SETFLAGS, &attr);
2464 #endif
2466 #ifdef FS_IOC_FSSETXATTR
2468 * Try to set the extent size hint. Failure is not fatal, and a warning is
2469 * only printed if the option was explicitly specified.
2472 struct fsxattr attr;
2473 result = ioctl(fd, FS_IOC_FSGETXATTR, &attr);
2474 if (result == 0) {
2475 attr.fsx_xflags |= FS_XFLAG_EXTSIZE;
2476 attr.fsx_extsize = file_opts->extent_size_hint;
2477 result = ioctl(fd, FS_IOC_FSSETXATTR, &attr);
2479 if (result < 0 && file_opts->has_extent_size_hint &&
2480 file_opts->extent_size_hint)
2482 warn_report("Failed to set extent size hint: %s",
2483 strerror(errno));
2486 #endif
2488 /* Resize and potentially preallocate the file to the desired
2489 * final size */
2490 result = raw_regular_truncate(NULL, fd, file_opts->size,
2491 file_opts->preallocation, errp);
2492 if (result < 0) {
2493 goto out_unlock;
2496 out_unlock:
2497 raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
2498 if (local_err) {
2499 /* The above call should not fail, and if it does, that does
2500 * not mean the whole creation operation has failed. So
2501 * report it the user for their convenience, but do not report
2502 * it to the caller. */
2503 warn_report_err(local_err);
2506 out_close:
2507 if (qemu_close(fd) != 0 && result == 0) {
2508 result = -errno;
2509 error_setg_errno(errp, -result, "Could not close the new file");
2511 out:
2512 return result;
2515 static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
2516 const char *filename,
2517 QemuOpts *opts,
2518 Error **errp)
2520 BlockdevCreateOptions options;
2521 int64_t total_size = 0;
2522 int64_t extent_size_hint = 0;
2523 bool has_extent_size_hint = false;
2524 bool nocow = false;
2525 PreallocMode prealloc;
2526 char *buf = NULL;
2527 Error *local_err = NULL;
2529 /* Skip file: protocol prefix */
2530 strstart(filename, "file:", &filename);
2532 /* Read out options */
2533 total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2534 BDRV_SECTOR_SIZE);
2535 if (qemu_opt_get(opts, BLOCK_OPT_EXTENT_SIZE_HINT)) {
2536 has_extent_size_hint = true;
2537 extent_size_hint =
2538 qemu_opt_get_size_del(opts, BLOCK_OPT_EXTENT_SIZE_HINT, -1);
2540 nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
2541 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2542 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
2543 PREALLOC_MODE_OFF, &local_err);
2544 g_free(buf);
2545 if (local_err) {
2546 error_propagate(errp, local_err);
2547 return -EINVAL;
2550 options = (BlockdevCreateOptions) {
2551 .driver = BLOCKDEV_DRIVER_FILE,
2552 .u.file = {
2553 .filename = (char *) filename,
2554 .size = total_size,
2555 .has_preallocation = true,
2556 .preallocation = prealloc,
2557 .has_nocow = true,
2558 .nocow = nocow,
2559 .has_extent_size_hint = has_extent_size_hint,
2560 .extent_size_hint = extent_size_hint,
2563 return raw_co_create(&options, errp);
2566 static int coroutine_fn raw_co_delete_file(BlockDriverState *bs,
2567 Error **errp)
2569 struct stat st;
2570 int ret;
2572 if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) {
2573 error_setg_errno(errp, ENOENT, "%s is not a regular file",
2574 bs->filename);
2575 return -ENOENT;
2578 ret = unlink(bs->filename);
2579 if (ret < 0) {
2580 ret = -errno;
2581 error_setg_errno(errp, -ret, "Error when deleting file %s",
2582 bs->filename);
2585 return ret;
2589 * Find allocation range in @bs around offset @start.
2590 * May change underlying file descriptor's file offset.
2591 * If @start is not in a hole, store @start in @data, and the
2592 * beginning of the next hole in @hole, and return 0.
2593 * If @start is in a non-trailing hole, store @start in @hole and the
2594 * beginning of the next non-hole in @data, and return 0.
2595 * If @start is in a trailing hole or beyond EOF, return -ENXIO.
2596 * If we can't find out, return a negative errno other than -ENXIO.
2598 static int find_allocation(BlockDriverState *bs, off_t start,
2599 off_t *data, off_t *hole)
2601 #if defined SEEK_HOLE && defined SEEK_DATA
2602 BDRVRawState *s = bs->opaque;
2603 off_t offs;
2606 * SEEK_DATA cases:
2607 * D1. offs == start: start is in data
2608 * D2. offs > start: start is in a hole, next data at offs
2609 * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
2610 * or start is beyond EOF
2611 * If the latter happens, the file has been truncated behind
2612 * our back since we opened it. All bets are off then.
2613 * Treating like a trailing hole is simplest.
2614 * D4. offs < 0, errno != ENXIO: we learned nothing
2616 offs = lseek(s->fd, start, SEEK_DATA);
2617 if (offs < 0) {
2618 return -errno; /* D3 or D4 */
2621 if (offs < start) {
2622 /* This is not a valid return by lseek(). We are safe to just return
2623 * -EIO in this case, and we'll treat it like D4. */
2624 return -EIO;
2627 if (offs > start) {
2628 /* D2: in hole, next data at offs */
2629 *hole = start;
2630 *data = offs;
2631 return 0;
2634 /* D1: in data, end not yet known */
2637 * SEEK_HOLE cases:
2638 * H1. offs == start: start is in a hole
2639 * If this happens here, a hole has been dug behind our back
2640 * since the previous lseek().
2641 * H2. offs > start: either start is in data, next hole at offs,
2642 * or start is in trailing hole, EOF at offs
2643 * Linux treats trailing holes like any other hole: offs ==
2644 * start. Solaris seeks to EOF instead: offs > start (blech).
2645 * If that happens here, a hole has been dug behind our back
2646 * since the previous lseek().
2647 * H3. offs < 0, errno = ENXIO: start is beyond EOF
2648 * If this happens, the file has been truncated behind our
2649 * back since we opened it. Treat it like a trailing hole.
2650 * H4. offs < 0, errno != ENXIO: we learned nothing
2651 * Pretend we know nothing at all, i.e. "forget" about D1.
2653 offs = lseek(s->fd, start, SEEK_HOLE);
2654 if (offs < 0) {
2655 return -errno; /* D1 and (H3 or H4) */
2658 if (offs < start) {
2659 /* This is not a valid return by lseek(). We are safe to just return
2660 * -EIO in this case, and we'll treat it like H4. */
2661 return -EIO;
2664 if (offs > start) {
2666 * D1 and H2: either in data, next hole at offs, or it was in
2667 * data but is now in a trailing hole. In the latter case,
2668 * all bets are off. Treating it as if it there was data all
2669 * the way to EOF is safe, so simply do that.
2671 *data = start;
2672 *hole = offs;
2673 return 0;
2676 /* D1 and H1 */
2677 return -EBUSY;
2678 #else
2679 return -ENOTSUP;
2680 #endif
2684 * Returns the allocation status of the specified offset.
2686 * The block layer guarantees 'offset' and 'bytes' are within bounds.
2688 * 'pnum' is set to the number of bytes (including and immediately following
2689 * the specified offset) that are known to be in the same
2690 * allocated/unallocated state.
2692 * 'bytes' is the max value 'pnum' should be set to.
2694 static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
2695 bool want_zero,
2696 int64_t offset,
2697 int64_t bytes, int64_t *pnum,
2698 int64_t *map,
2699 BlockDriverState **file)
2701 off_t data = 0, hole = 0;
2702 int ret;
2704 assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
2706 ret = fd_open(bs);
2707 if (ret < 0) {
2708 return ret;
2711 if (!want_zero) {
2712 *pnum = bytes;
2713 *map = offset;
2714 *file = bs;
2715 return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
2718 ret = find_allocation(bs, offset, &data, &hole);
2719 if (ret == -ENXIO) {
2720 /* Trailing hole */
2721 *pnum = bytes;
2722 ret = BDRV_BLOCK_ZERO;
2723 } else if (ret < 0) {
2724 /* No info available, so pretend there are no holes */
2725 *pnum = bytes;
2726 ret = BDRV_BLOCK_DATA;
2727 } else if (data == offset) {
2728 /* On a data extent, compute bytes to the end of the extent,
2729 * possibly including a partial sector at EOF. */
2730 *pnum = MIN(bytes, hole - offset);
2733 * We are not allowed to return partial sectors, though, so
2734 * round up if necessary.
2736 if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
2737 int64_t file_length = raw_getlength(bs);
2738 if (file_length > 0) {
2739 /* Ignore errors, this is just a safeguard */
2740 assert(hole == file_length);
2742 *pnum = ROUND_UP(*pnum, bs->bl.request_alignment);
2745 ret = BDRV_BLOCK_DATA;
2746 } else {
2747 /* On a hole, compute bytes to the beginning of the next extent. */
2748 assert(hole == offset);
2749 *pnum = MIN(bytes, data - offset);
2750 ret = BDRV_BLOCK_ZERO;
2752 *map = offset;
2753 *file = bs;
2754 return ret | BDRV_BLOCK_OFFSET_VALID;
2757 #if defined(__linux__)
2758 /* Verify that the file is not in the page cache */
2759 static void check_cache_dropped(BlockDriverState *bs, Error **errp)
2761 const size_t window_size = 128 * 1024 * 1024;
2762 BDRVRawState *s = bs->opaque;
2763 void *window = NULL;
2764 size_t length = 0;
2765 unsigned char *vec;
2766 size_t page_size;
2767 off_t offset;
2768 off_t end;
2770 /* mincore(2) page status information requires 1 byte per page */
2771 page_size = sysconf(_SC_PAGESIZE);
2772 vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
2774 end = raw_getlength(bs);
2776 for (offset = 0; offset < end; offset += window_size) {
2777 void *new_window;
2778 size_t new_length;
2779 size_t vec_end;
2780 size_t i;
2781 int ret;
2783 /* Unmap previous window if size has changed */
2784 new_length = MIN(end - offset, window_size);
2785 if (new_length != length) {
2786 munmap(window, length);
2787 window = NULL;
2788 length = 0;
2791 new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
2792 s->fd, offset);
2793 if (new_window == MAP_FAILED) {
2794 error_setg_errno(errp, errno, "mmap failed");
2795 break;
2798 window = new_window;
2799 length = new_length;
2801 ret = mincore(window, length, vec);
2802 if (ret < 0) {
2803 error_setg_errno(errp, errno, "mincore failed");
2804 break;
2807 vec_end = DIV_ROUND_UP(length, page_size);
2808 for (i = 0; i < vec_end; i++) {
2809 if (vec[i] & 0x1) {
2810 break;
2813 if (i < vec_end) {
2814 error_setg(errp, "page cache still in use!");
2815 break;
2819 if (window) {
2820 munmap(window, length);
2823 g_free(vec);
2825 #endif /* __linux__ */
2827 static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs,
2828 Error **errp)
2830 BDRVRawState *s = bs->opaque;
2831 int ret;
2833 ret = fd_open(bs);
2834 if (ret < 0) {
2835 error_setg_errno(errp, -ret, "The file descriptor is not open");
2836 return;
2839 if (!s->drop_cache) {
2840 return;
2843 if (s->open_flags & O_DIRECT) {
2844 return; /* No host kernel page cache */
2847 #if defined(__linux__)
2848 /* This sets the scene for the next syscall... */
2849 ret = bdrv_co_flush(bs);
2850 if (ret < 0) {
2851 error_setg_errno(errp, -ret, "flush failed");
2852 return;
2855 /* Linux does not invalidate pages that are dirty, locked, or mmapped by a
2856 * process. These limitations are okay because we just fsynced the file,
2857 * we don't use mmap, and the file should not be in use by other processes.
2859 ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
2860 if (ret != 0) { /* the return value is a positive errno */
2861 error_setg_errno(errp, ret, "fadvise failed");
2862 return;
2865 if (s->check_cache_dropped) {
2866 check_cache_dropped(bs, errp);
2868 #else /* __linux__ */
2869 /* Do nothing. Live migration to a remote host with cache.direct=off is
2870 * unsupported on other host operating systems. Cache consistency issues
2871 * may occur but no error is reported here, partly because that's the
2872 * historical behavior and partly because it's hard to differentiate valid
2873 * configurations that should not cause errors.
2875 #endif /* !__linux__ */
2878 static void raw_account_discard(BDRVRawState *s, uint64_t nbytes, int ret)
2880 if (ret) {
2881 s->stats.discard_nb_failed++;
2882 } else {
2883 s->stats.discard_nb_ok++;
2884 s->stats.discard_bytes_ok += nbytes;
2888 static coroutine_fn int
2889 raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int bytes, bool blkdev)
2891 BDRVRawState *s = bs->opaque;
2892 RawPosixAIOData acb;
2893 int ret;
2895 acb = (RawPosixAIOData) {
2896 .bs = bs,
2897 .aio_fildes = s->fd,
2898 .aio_type = QEMU_AIO_DISCARD,
2899 .aio_offset = offset,
2900 .aio_nbytes = bytes,
2903 if (blkdev) {
2904 acb.aio_type |= QEMU_AIO_BLKDEV;
2907 ret = raw_thread_pool_submit(bs, handle_aiocb_discard, &acb);
2908 raw_account_discard(s, bytes, ret);
2909 return ret;
2912 static coroutine_fn int
2913 raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
2915 return raw_do_pdiscard(bs, offset, bytes, false);
2918 static int coroutine_fn
2919 raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
2920 BdrvRequestFlags flags, bool blkdev)
2922 BDRVRawState *s = bs->opaque;
2923 RawPosixAIOData acb;
2924 ThreadPoolFunc *handler;
2926 #ifdef CONFIG_FALLOCATE
2927 if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
2928 BdrvTrackedRequest *req;
2929 uint64_t end;
2932 * This is a workaround for a bug in the Linux XFS driver,
2933 * where writes submitted through the AIO interface will be
2934 * discarded if they happen beyond a concurrently running
2935 * fallocate() that increases the file length (i.e., both the
2936 * write and the fallocate() happen beyond the EOF).
2938 * To work around it, we extend the tracked request for this
2939 * zero write until INT64_MAX (effectively infinity), and mark
2940 * it as serializing.
2942 * We have to enable this workaround for all filesystems and
2943 * AIO modes (not just XFS with aio=native), because for
2944 * remote filesystems we do not know the host configuration.
2947 req = bdrv_co_get_self_request(bs);
2948 assert(req);
2949 assert(req->type == BDRV_TRACKED_WRITE);
2950 assert(req->offset <= offset);
2951 assert(req->offset + req->bytes >= offset + bytes);
2953 end = INT64_MAX & -(uint64_t)bs->bl.request_alignment;
2954 req->bytes = end - req->offset;
2955 req->overlap_bytes = req->bytes;
2957 bdrv_mark_request_serialising(req, bs->bl.request_alignment);
2959 #endif
2961 acb = (RawPosixAIOData) {
2962 .bs = bs,
2963 .aio_fildes = s->fd,
2964 .aio_type = QEMU_AIO_WRITE_ZEROES,
2965 .aio_offset = offset,
2966 .aio_nbytes = bytes,
2969 if (blkdev) {
2970 acb.aio_type |= QEMU_AIO_BLKDEV;
2972 if (flags & BDRV_REQ_NO_FALLBACK) {
2973 acb.aio_type |= QEMU_AIO_NO_FALLBACK;
2976 if (flags & BDRV_REQ_MAY_UNMAP) {
2977 acb.aio_type |= QEMU_AIO_DISCARD;
2978 handler = handle_aiocb_write_zeroes_unmap;
2979 } else {
2980 handler = handle_aiocb_write_zeroes;
2983 return raw_thread_pool_submit(bs, handler, &acb);
2986 static int coroutine_fn raw_co_pwrite_zeroes(
2987 BlockDriverState *bs, int64_t offset,
2988 int bytes, BdrvRequestFlags flags)
2990 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, false);
2993 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2995 return 0;
2998 static BlockStatsSpecificFile get_blockstats_specific_file(BlockDriverState *bs)
3000 BDRVRawState *s = bs->opaque;
3001 return (BlockStatsSpecificFile) {
3002 .discard_nb_ok = s->stats.discard_nb_ok,
3003 .discard_nb_failed = s->stats.discard_nb_failed,
3004 .discard_bytes_ok = s->stats.discard_bytes_ok,
3008 static BlockStatsSpecific *raw_get_specific_stats(BlockDriverState *bs)
3010 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3012 stats->driver = BLOCKDEV_DRIVER_FILE;
3013 stats->u.file = get_blockstats_specific_file(bs);
3015 return stats;
3018 static BlockStatsSpecific *hdev_get_specific_stats(BlockDriverState *bs)
3020 BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3022 stats->driver = BLOCKDEV_DRIVER_HOST_DEVICE;
3023 stats->u.host_device = get_blockstats_specific_file(bs);
3025 return stats;
3028 static QemuOptsList raw_create_opts = {
3029 .name = "raw-create-opts",
3030 .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
3031 .desc = {
3033 .name = BLOCK_OPT_SIZE,
3034 .type = QEMU_OPT_SIZE,
3035 .help = "Virtual disk size"
3038 .name = BLOCK_OPT_NOCOW,
3039 .type = QEMU_OPT_BOOL,
3040 .help = "Turn off copy-on-write (valid only on btrfs)"
3043 .name = BLOCK_OPT_PREALLOC,
3044 .type = QEMU_OPT_STRING,
3045 .help = "Preallocation mode (allowed values: off"
3046 #ifdef CONFIG_POSIX_FALLOCATE
3047 ", falloc"
3048 #endif
3049 ", full)"
3052 .name = BLOCK_OPT_EXTENT_SIZE_HINT,
3053 .type = QEMU_OPT_SIZE,
3054 .help = "Extent size hint for the image file, 0 to disable"
3056 { /* end of list */ }
3060 static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
3061 Error **errp)
3063 BDRVRawState *s = bs->opaque;
3064 BDRVRawReopenState *rs = NULL;
3065 int open_flags;
3066 int ret;
3068 if (s->perm_change_fd) {
3070 * In the context of reopen, this function may be called several times
3071 * (directly and recursively while change permissions of the parent).
3072 * This is even true for children that don't inherit from the original
3073 * reopen node, so s->reopen_state is not set.
3075 * Ignore all but the first call.
3077 return 0;
3080 if (s->reopen_state) {
3081 /* We already have a new file descriptor to set permissions for */
3082 assert(s->reopen_state->perm == perm);
3083 assert(s->reopen_state->shared_perm == shared);
3084 rs = s->reopen_state->opaque;
3085 s->perm_change_fd = rs->fd;
3086 s->perm_change_flags = rs->open_flags;
3087 } else {
3088 /* We may need a new fd if auto-read-only switches the mode */
3089 ret = raw_reconfigure_getfd(bs, bs->open_flags, &open_flags, perm,
3090 false, errp);
3091 if (ret < 0) {
3092 return ret;
3093 } else if (ret != s->fd) {
3094 s->perm_change_fd = ret;
3095 s->perm_change_flags = open_flags;
3099 /* Prepare permissions on old fd to avoid conflicts between old and new,
3100 * but keep everything locked that new will need. */
3101 ret = raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
3102 if (ret < 0) {
3103 goto fail;
3106 /* Copy locks to the new fd */
3107 if (s->perm_change_fd) {
3108 ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared,
3109 false, errp);
3110 if (ret < 0) {
3111 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3112 goto fail;
3115 return 0;
3117 fail:
3118 if (s->perm_change_fd && !s->reopen_state) {
3119 qemu_close(s->perm_change_fd);
3121 s->perm_change_fd = 0;
3122 return ret;
3125 static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
3127 BDRVRawState *s = bs->opaque;
3129 /* For reopen, we have already switched to the new fd (.bdrv_set_perm is
3130 * called after .bdrv_reopen_commit) */
3131 if (s->perm_change_fd && s->fd != s->perm_change_fd) {
3132 qemu_close(s->fd);
3133 s->fd = s->perm_change_fd;
3134 s->open_flags = s->perm_change_flags;
3136 s->perm_change_fd = 0;
3138 raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
3139 s->perm = perm;
3140 s->shared_perm = shared;
3143 static void raw_abort_perm_update(BlockDriverState *bs)
3145 BDRVRawState *s = bs->opaque;
3147 /* For reopen, .bdrv_reopen_abort is called afterwards and will close
3148 * the file descriptor. */
3149 if (s->perm_change_fd && !s->reopen_state) {
3150 qemu_close(s->perm_change_fd);
3152 s->perm_change_fd = 0;
3154 raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3157 static int coroutine_fn raw_co_copy_range_from(
3158 BlockDriverState *bs, BdrvChild *src, uint64_t src_offset,
3159 BdrvChild *dst, uint64_t dst_offset, uint64_t bytes,
3160 BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
3162 return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
3163 read_flags, write_flags);
3166 static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
3167 BdrvChild *src,
3168 uint64_t src_offset,
3169 BdrvChild *dst,
3170 uint64_t dst_offset,
3171 uint64_t bytes,
3172 BdrvRequestFlags read_flags,
3173 BdrvRequestFlags write_flags)
3175 RawPosixAIOData acb;
3176 BDRVRawState *s = bs->opaque;
3177 BDRVRawState *src_s;
3179 assert(dst->bs == bs);
3180 if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
3181 return -ENOTSUP;
3184 src_s = src->bs->opaque;
3185 if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) {
3186 return -EIO;
3189 acb = (RawPosixAIOData) {
3190 .bs = bs,
3191 .aio_type = QEMU_AIO_COPY_RANGE,
3192 .aio_fildes = src_s->fd,
3193 .aio_offset = src_offset,
3194 .aio_nbytes = bytes,
3195 .copy_range = {
3196 .aio_fd2 = s->fd,
3197 .aio_offset2 = dst_offset,
3201 return raw_thread_pool_submit(bs, handle_aiocb_copy_range, &acb);
3204 BlockDriver bdrv_file = {
3205 .format_name = "file",
3206 .protocol_name = "file",
3207 .instance_size = sizeof(BDRVRawState),
3208 .bdrv_needs_filename = true,
3209 .bdrv_probe = NULL, /* no probe for protocols */
3210 .bdrv_parse_filename = raw_parse_filename,
3211 .bdrv_file_open = raw_open,
3212 .bdrv_reopen_prepare = raw_reopen_prepare,
3213 .bdrv_reopen_commit = raw_reopen_commit,
3214 .bdrv_reopen_abort = raw_reopen_abort,
3215 .bdrv_close = raw_close,
3216 .bdrv_co_create = raw_co_create,
3217 .bdrv_co_create_opts = raw_co_create_opts,
3218 .bdrv_has_zero_init = bdrv_has_zero_init_1,
3219 .bdrv_co_block_status = raw_co_block_status,
3220 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3221 .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
3222 .bdrv_co_delete_file = raw_co_delete_file,
3224 .bdrv_co_preadv = raw_co_preadv,
3225 .bdrv_co_pwritev = raw_co_pwritev,
3226 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3227 .bdrv_co_pdiscard = raw_co_pdiscard,
3228 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3229 .bdrv_co_copy_range_to = raw_co_copy_range_to,
3230 .bdrv_refresh_limits = raw_refresh_limits,
3231 .bdrv_io_plug = raw_aio_plug,
3232 .bdrv_io_unplug = raw_aio_unplug,
3233 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3235 .bdrv_co_truncate = raw_co_truncate,
3236 .bdrv_getlength = raw_getlength,
3237 .bdrv_get_info = raw_get_info,
3238 .bdrv_get_allocated_file_size
3239 = raw_get_allocated_file_size,
3240 .bdrv_get_specific_stats = raw_get_specific_stats,
3241 .bdrv_check_perm = raw_check_perm,
3242 .bdrv_set_perm = raw_set_perm,
3243 .bdrv_abort_perm_update = raw_abort_perm_update,
3244 .create_opts = &raw_create_opts,
3245 .mutable_opts = mutable_opts,
3248 /***********************************************/
3249 /* host device */
3251 #if defined(__APPLE__) && defined(__MACH__)
3252 static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3253 CFIndex maxPathSize, int flags);
3254 static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
3256 kern_return_t kernResult = KERN_FAILURE;
3257 mach_port_t masterPort;
3258 CFMutableDictionaryRef classesToMatch;
3259 const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
3260 char *mediaType = NULL;
3262 kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
3263 if ( KERN_SUCCESS != kernResult ) {
3264 printf( "IOMasterPort returned %d\n", kernResult );
3267 int index;
3268 for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
3269 classesToMatch = IOServiceMatching(matching_array[index]);
3270 if (classesToMatch == NULL) {
3271 error_report("IOServiceMatching returned NULL for %s",
3272 matching_array[index]);
3273 continue;
3275 CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
3276 kCFBooleanTrue);
3277 kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
3278 mediaIterator);
3279 if (kernResult != KERN_SUCCESS) {
3280 error_report("Note: IOServiceGetMatchingServices returned %d",
3281 kernResult);
3282 continue;
3285 /* If a match was found, leave the loop */
3286 if (*mediaIterator != 0) {
3287 trace_file_FindEjectableOpticalMedia(matching_array[index]);
3288 mediaType = g_strdup(matching_array[index]);
3289 break;
3292 return mediaType;
3295 kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3296 CFIndex maxPathSize, int flags)
3298 io_object_t nextMedia;
3299 kern_return_t kernResult = KERN_FAILURE;
3300 *bsdPath = '\0';
3301 nextMedia = IOIteratorNext( mediaIterator );
3302 if ( nextMedia )
3304 CFTypeRef bsdPathAsCFString;
3305 bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
3306 if ( bsdPathAsCFString ) {
3307 size_t devPathLength;
3308 strcpy( bsdPath, _PATH_DEV );
3309 if (flags & BDRV_O_NOCACHE) {
3310 strcat(bsdPath, "r");
3312 devPathLength = strlen( bsdPath );
3313 if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
3314 kernResult = KERN_SUCCESS;
3316 CFRelease( bsdPathAsCFString );
3318 IOObjectRelease( nextMedia );
3321 return kernResult;
3324 /* Sets up a real cdrom for use in QEMU */
3325 static bool setup_cdrom(char *bsd_path, Error **errp)
3327 int index, num_of_test_partitions = 2, fd;
3328 char test_partition[MAXPATHLEN];
3329 bool partition_found = false;
3331 /* look for a working partition */
3332 for (index = 0; index < num_of_test_partitions; index++) {
3333 snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
3334 index);
3335 fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE, NULL);
3336 if (fd >= 0) {
3337 partition_found = true;
3338 qemu_close(fd);
3339 break;
3343 /* if a working partition on the device was not found */
3344 if (partition_found == false) {
3345 error_setg(errp, "Failed to find a working partition on disc");
3346 } else {
3347 trace_file_setup_cdrom(test_partition);
3348 pstrcpy(bsd_path, MAXPATHLEN, test_partition);
3350 return partition_found;
3353 /* Prints directions on mounting and unmounting a device */
3354 static void print_unmounting_directions(const char *file_name)
3356 error_report("If device %s is mounted on the desktop, unmount"
3357 " it first before using it in QEMU", file_name);
3358 error_report("Command to unmount device: diskutil unmountDisk %s",
3359 file_name);
3360 error_report("Command to mount device: diskutil mountDisk %s", file_name);
3363 #endif /* defined(__APPLE__) && defined(__MACH__) */
3365 static int hdev_probe_device(const char *filename)
3367 struct stat st;
3369 /* allow a dedicated CD-ROM driver to match with a higher priority */
3370 if (strstart(filename, "/dev/cdrom", NULL))
3371 return 50;
3373 if (stat(filename, &st) >= 0 &&
3374 (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
3375 return 100;
3378 return 0;
3381 static void hdev_parse_filename(const char *filename, QDict *options,
3382 Error **errp)
3384 bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
3387 static bool hdev_is_sg(BlockDriverState *bs)
3390 #if defined(__linux__)
3392 BDRVRawState *s = bs->opaque;
3393 struct stat st;
3394 struct sg_scsi_id scsiid;
3395 int sg_version;
3396 int ret;
3398 if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
3399 return false;
3402 ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
3403 if (ret < 0) {
3404 return false;
3407 ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
3408 if (ret >= 0) {
3409 trace_file_hdev_is_sg(scsiid.scsi_type, sg_version);
3410 return true;
3413 #endif
3415 return false;
3418 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
3419 Error **errp)
3421 BDRVRawState *s = bs->opaque;
3422 int ret;
3424 #if defined(__APPLE__) && defined(__MACH__)
3426 * Caution: while qdict_get_str() is fine, getting non-string types
3427 * would require more care. When @options come from -blockdev or
3428 * blockdev_add, its members are typed according to the QAPI
3429 * schema, but when they come from -drive, they're all QString.
3431 const char *filename = qdict_get_str(options, "filename");
3432 char bsd_path[MAXPATHLEN] = "";
3433 bool error_occurred = false;
3435 /* If using a real cdrom */
3436 if (strcmp(filename, "/dev/cdrom") == 0) {
3437 char *mediaType = NULL;
3438 kern_return_t ret_val;
3439 io_iterator_t mediaIterator = 0;
3441 mediaType = FindEjectableOpticalMedia(&mediaIterator);
3442 if (mediaType == NULL) {
3443 error_setg(errp, "Please make sure your CD/DVD is in the optical"
3444 " drive");
3445 error_occurred = true;
3446 goto hdev_open_Mac_error;
3449 ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
3450 if (ret_val != KERN_SUCCESS) {
3451 error_setg(errp, "Could not get BSD path for optical drive");
3452 error_occurred = true;
3453 goto hdev_open_Mac_error;
3456 /* If a real optical drive was not found */
3457 if (bsd_path[0] == '\0') {
3458 error_setg(errp, "Failed to obtain bsd path for optical drive");
3459 error_occurred = true;
3460 goto hdev_open_Mac_error;
3463 /* If using a cdrom disc and finding a partition on the disc failed */
3464 if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
3465 setup_cdrom(bsd_path, errp) == false) {
3466 print_unmounting_directions(bsd_path);
3467 error_occurred = true;
3468 goto hdev_open_Mac_error;
3471 qdict_put_str(options, "filename", bsd_path);
3473 hdev_open_Mac_error:
3474 g_free(mediaType);
3475 if (mediaIterator) {
3476 IOObjectRelease(mediaIterator);
3478 if (error_occurred) {
3479 return -ENOENT;
3482 #endif /* defined(__APPLE__) && defined(__MACH__) */
3484 s->type = FTYPE_FILE;
3486 ret = raw_open_common(bs, options, flags, 0, true, errp);
3487 if (ret < 0) {
3488 #if defined(__APPLE__) && defined(__MACH__)
3489 if (*bsd_path) {
3490 filename = bsd_path;
3492 /* if a physical device experienced an error while being opened */
3493 if (strncmp(filename, "/dev/", 5) == 0) {
3494 print_unmounting_directions(filename);
3496 #endif /* defined(__APPLE__) && defined(__MACH__) */
3497 return ret;
3500 /* Since this does ioctl the device must be already opened */
3501 bs->sg = hdev_is_sg(bs);
3503 return ret;
3506 #if defined(__linux__)
3507 static int coroutine_fn
3508 hdev_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
3510 BDRVRawState *s = bs->opaque;
3511 RawPosixAIOData acb;
3512 int ret;
3514 ret = fd_open(bs);
3515 if (ret < 0) {
3516 return ret;
3519 if (req == SG_IO && s->pr_mgr) {
3520 struct sg_io_hdr *io_hdr = buf;
3521 if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
3522 io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
3523 return pr_manager_execute(s->pr_mgr, bdrv_get_aio_context(bs),
3524 s->fd, io_hdr);
3528 acb = (RawPosixAIOData) {
3529 .bs = bs,
3530 .aio_type = QEMU_AIO_IOCTL,
3531 .aio_fildes = s->fd,
3532 .aio_offset = 0,
3533 .ioctl = {
3534 .buf = buf,
3535 .cmd = req,
3539 return raw_thread_pool_submit(bs, handle_aiocb_ioctl, &acb);
3541 #endif /* linux */
3543 static int fd_open(BlockDriverState *bs)
3545 BDRVRawState *s = bs->opaque;
3547 /* this is just to ensure s->fd is sane (its called by io ops) */
3548 if (s->fd >= 0)
3549 return 0;
3550 return -EIO;
3553 static coroutine_fn int
3554 hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
3556 BDRVRawState *s = bs->opaque;
3557 int ret;
3559 ret = fd_open(bs);
3560 if (ret < 0) {
3561 raw_account_discard(s, bytes, ret);
3562 return ret;
3564 return raw_do_pdiscard(bs, offset, bytes, true);
3567 static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
3568 int64_t offset, int bytes, BdrvRequestFlags flags)
3570 int rc;
3572 rc = fd_open(bs);
3573 if (rc < 0) {
3574 return rc;
3577 return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
3580 static BlockDriver bdrv_host_device = {
3581 .format_name = "host_device",
3582 .protocol_name = "host_device",
3583 .instance_size = sizeof(BDRVRawState),
3584 .bdrv_needs_filename = true,
3585 .bdrv_probe_device = hdev_probe_device,
3586 .bdrv_parse_filename = hdev_parse_filename,
3587 .bdrv_file_open = hdev_open,
3588 .bdrv_close = raw_close,
3589 .bdrv_reopen_prepare = raw_reopen_prepare,
3590 .bdrv_reopen_commit = raw_reopen_commit,
3591 .bdrv_reopen_abort = raw_reopen_abort,
3592 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3593 .create_opts = &bdrv_create_opts_simple,
3594 .mutable_opts = mutable_opts,
3595 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3596 .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
3598 .bdrv_co_preadv = raw_co_preadv,
3599 .bdrv_co_pwritev = raw_co_pwritev,
3600 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3601 .bdrv_co_pdiscard = hdev_co_pdiscard,
3602 .bdrv_co_copy_range_from = raw_co_copy_range_from,
3603 .bdrv_co_copy_range_to = raw_co_copy_range_to,
3604 .bdrv_refresh_limits = raw_refresh_limits,
3605 .bdrv_io_plug = raw_aio_plug,
3606 .bdrv_io_unplug = raw_aio_unplug,
3607 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3609 .bdrv_co_truncate = raw_co_truncate,
3610 .bdrv_getlength = raw_getlength,
3611 .bdrv_get_info = raw_get_info,
3612 .bdrv_get_allocated_file_size
3613 = raw_get_allocated_file_size,
3614 .bdrv_get_specific_stats = hdev_get_specific_stats,
3615 .bdrv_check_perm = raw_check_perm,
3616 .bdrv_set_perm = raw_set_perm,
3617 .bdrv_abort_perm_update = raw_abort_perm_update,
3618 .bdrv_probe_blocksizes = hdev_probe_blocksizes,
3619 .bdrv_probe_geometry = hdev_probe_geometry,
3621 /* generic scsi device */
3622 #ifdef __linux__
3623 .bdrv_co_ioctl = hdev_co_ioctl,
3624 #endif
3627 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3628 static void cdrom_parse_filename(const char *filename, QDict *options,
3629 Error **errp)
3631 bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
3633 #endif
3635 #ifdef __linux__
3636 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3637 Error **errp)
3639 BDRVRawState *s = bs->opaque;
3641 s->type = FTYPE_CD;
3643 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
3644 return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp);
3647 static int cdrom_probe_device(const char *filename)
3649 int fd, ret;
3650 int prio = 0;
3651 struct stat st;
3653 fd = qemu_open(filename, O_RDONLY | O_NONBLOCK, NULL);
3654 if (fd < 0) {
3655 goto out;
3657 ret = fstat(fd, &st);
3658 if (ret == -1 || !S_ISBLK(st.st_mode)) {
3659 goto outc;
3662 /* Attempt to detect via a CDROM specific ioctl */
3663 ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3664 if (ret >= 0)
3665 prio = 100;
3667 outc:
3668 qemu_close(fd);
3669 out:
3670 return prio;
3673 static bool cdrom_is_inserted(BlockDriverState *bs)
3675 BDRVRawState *s = bs->opaque;
3676 int ret;
3678 ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3679 return ret == CDS_DISC_OK;
3682 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3684 BDRVRawState *s = bs->opaque;
3686 if (eject_flag) {
3687 if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
3688 perror("CDROMEJECT");
3689 } else {
3690 if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
3691 perror("CDROMEJECT");
3695 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3697 BDRVRawState *s = bs->opaque;
3699 if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
3701 * Note: an error can happen if the distribution automatically
3702 * mounts the CD-ROM
3704 /* perror("CDROM_LOCKDOOR"); */
3708 static BlockDriver bdrv_host_cdrom = {
3709 .format_name = "host_cdrom",
3710 .protocol_name = "host_cdrom",
3711 .instance_size = sizeof(BDRVRawState),
3712 .bdrv_needs_filename = true,
3713 .bdrv_probe_device = cdrom_probe_device,
3714 .bdrv_parse_filename = cdrom_parse_filename,
3715 .bdrv_file_open = cdrom_open,
3716 .bdrv_close = raw_close,
3717 .bdrv_reopen_prepare = raw_reopen_prepare,
3718 .bdrv_reopen_commit = raw_reopen_commit,
3719 .bdrv_reopen_abort = raw_reopen_abort,
3720 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3721 .create_opts = &bdrv_create_opts_simple,
3722 .mutable_opts = mutable_opts,
3723 .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3725 .bdrv_co_preadv = raw_co_preadv,
3726 .bdrv_co_pwritev = raw_co_pwritev,
3727 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3728 .bdrv_refresh_limits = raw_refresh_limits,
3729 .bdrv_io_plug = raw_aio_plug,
3730 .bdrv_io_unplug = raw_aio_unplug,
3731 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3733 .bdrv_co_truncate = raw_co_truncate,
3734 .bdrv_getlength = raw_getlength,
3735 .has_variable_length = true,
3736 .bdrv_get_allocated_file_size
3737 = raw_get_allocated_file_size,
3739 /* removable device support */
3740 .bdrv_is_inserted = cdrom_is_inserted,
3741 .bdrv_eject = cdrom_eject,
3742 .bdrv_lock_medium = cdrom_lock_medium,
3744 /* generic scsi device */
3745 .bdrv_co_ioctl = hdev_co_ioctl,
3747 #endif /* __linux__ */
3749 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
3750 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3751 Error **errp)
3753 BDRVRawState *s = bs->opaque;
3754 int ret;
3756 s->type = FTYPE_CD;
3758 ret = raw_open_common(bs, options, flags, 0, true, errp);
3759 if (ret) {
3760 return ret;
3763 /* make sure the door isn't locked at this time */
3764 ioctl(s->fd, CDIOCALLOW);
3765 return 0;
3768 static int cdrom_probe_device(const char *filename)
3770 if (strstart(filename, "/dev/cd", NULL) ||
3771 strstart(filename, "/dev/acd", NULL))
3772 return 100;
3773 return 0;
3776 static int cdrom_reopen(BlockDriverState *bs)
3778 BDRVRawState *s = bs->opaque;
3779 int fd;
3782 * Force reread of possibly changed/newly loaded disc,
3783 * FreeBSD seems to not notice sometimes...
3785 if (s->fd >= 0)
3786 qemu_close(s->fd);
3787 fd = qemu_open(bs->filename, s->open_flags, NULL);
3788 if (fd < 0) {
3789 s->fd = -1;
3790 return -EIO;
3792 s->fd = fd;
3794 /* make sure the door isn't locked at this time */
3795 ioctl(s->fd, CDIOCALLOW);
3796 return 0;
3799 static bool cdrom_is_inserted(BlockDriverState *bs)
3801 return raw_getlength(bs) > 0;
3804 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3806 BDRVRawState *s = bs->opaque;
3808 if (s->fd < 0)
3809 return;
3811 (void) ioctl(s->fd, CDIOCALLOW);
3813 if (eject_flag) {
3814 if (ioctl(s->fd, CDIOCEJECT) < 0)
3815 perror("CDIOCEJECT");
3816 } else {
3817 if (ioctl(s->fd, CDIOCCLOSE) < 0)
3818 perror("CDIOCCLOSE");
3821 cdrom_reopen(bs);
3824 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3826 BDRVRawState *s = bs->opaque;
3828 if (s->fd < 0)
3829 return;
3830 if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
3832 * Note: an error can happen if the distribution automatically
3833 * mounts the CD-ROM
3835 /* perror("CDROM_LOCKDOOR"); */
3839 static BlockDriver bdrv_host_cdrom = {
3840 .format_name = "host_cdrom",
3841 .protocol_name = "host_cdrom",
3842 .instance_size = sizeof(BDRVRawState),
3843 .bdrv_needs_filename = true,
3844 .bdrv_probe_device = cdrom_probe_device,
3845 .bdrv_parse_filename = cdrom_parse_filename,
3846 .bdrv_file_open = cdrom_open,
3847 .bdrv_close = raw_close,
3848 .bdrv_reopen_prepare = raw_reopen_prepare,
3849 .bdrv_reopen_commit = raw_reopen_commit,
3850 .bdrv_reopen_abort = raw_reopen_abort,
3851 .bdrv_co_create_opts = bdrv_co_create_opts_simple,
3852 .create_opts = &bdrv_create_opts_simple,
3853 .mutable_opts = mutable_opts,
3855 .bdrv_co_preadv = raw_co_preadv,
3856 .bdrv_co_pwritev = raw_co_pwritev,
3857 .bdrv_co_flush_to_disk = raw_co_flush_to_disk,
3858 .bdrv_refresh_limits = raw_refresh_limits,
3859 .bdrv_io_plug = raw_aio_plug,
3860 .bdrv_io_unplug = raw_aio_unplug,
3861 .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3863 .bdrv_co_truncate = raw_co_truncate,
3864 .bdrv_getlength = raw_getlength,
3865 .has_variable_length = true,
3866 .bdrv_get_allocated_file_size
3867 = raw_get_allocated_file_size,
3869 /* removable device support */
3870 .bdrv_is_inserted = cdrom_is_inserted,
3871 .bdrv_eject = cdrom_eject,
3872 .bdrv_lock_medium = cdrom_lock_medium,
3874 #endif /* __FreeBSD__ */
3876 static void bdrv_file_init(void)
3879 * Register all the drivers. Note that order is important, the driver
3880 * registered last will get probed first.
3882 bdrv_register(&bdrv_file);
3883 bdrv_register(&bdrv_host_device);
3884 #ifdef __linux__
3885 bdrv_register(&bdrv_host_cdrom);
3886 #endif
3887 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3888 bdrv_register(&bdrv_host_cdrom);
3889 #endif
3892 block_init(bdrv_file_init);