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