28b47d977bb9d56de06cb09a392fd22fc9b9d5e7
[qemu.git] / block / raw-posix.c
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 #include "qemu/osdep.h"
25 #include "qapi/error.h"
26 #include "qemu/cutils.h"
27 #include "qemu/error-report.h"
28 #include "qemu/timer.h"
29 #include "qemu/log.h"
30 #include "block/block_int.h"
31 #include "qemu/module.h"
32 #include "trace.h"
33 #include "block/thread-pool.h"
34 #include "qemu/iov.h"
35 #include "block/raw-aio.h"
36 #include "qapi/util.h"
37 #include "qapi/qmp/qstring.h"
38
39 #if defined(__APPLE__) && (__MACH__)
40 #include <paths.h>
41 #include <sys/param.h>
42 #include <IOKit/IOKitLib.h>
43 #include <IOKit/IOBSD.h>
44 #include <IOKit/storage/IOMediaBSDClient.h>
45 #include <IOKit/storage/IOMedia.h>
46 #include <IOKit/storage/IOCDMedia.h>
47 //#include <IOKit/storage/IOCDTypes.h>
48 #include <IOKit/storage/IODVDMedia.h>
49 #include <CoreFoundation/CoreFoundation.h>
50 #endif
51
52 #ifdef __sun__
53 #define _POSIX_PTHREAD_SEMANTICS 1
54 #include <sys/dkio.h>
55 #endif
56 #ifdef __linux__
57 #include <sys/ioctl.h>
58 #include <sys/param.h>
59 #include <linux/cdrom.h>
60 #include <linux/fd.h>
61 #include <linux/fs.h>
62 #include <linux/hdreg.h>
63 #include <scsi/sg.h>
64 #ifdef __s390__
65 #include <asm/dasd.h>
66 #endif
67 #ifndef FS_NOCOW_FL
68 #define FS_NOCOW_FL                     0x00800000 /* Do not cow file */
69 #endif
70 #endif
71 #if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
72 #include <linux/falloc.h>
73 #endif
74 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
75 #include <sys/disk.h>
76 #include <sys/cdio.h>
77 #endif
78
79 #ifdef __OpenBSD__
80 #include <sys/ioctl.h>
81 #include <sys/disklabel.h>
82 #include <sys/dkio.h>
83 #endif
84
85 #ifdef __NetBSD__
86 #include <sys/ioctl.h>
87 #include <sys/disklabel.h>
88 #include <sys/dkio.h>
89 #include <sys/disk.h>
90 #endif
91
92 #ifdef __DragonFly__
93 #include <sys/ioctl.h>
94 #include <sys/diskslice.h>
95 #endif
96
97 #ifdef CONFIG_XFS
98 #include <xfs/xfs.h>
99 #endif
100
101 //#define DEBUG_BLOCK
102
103 #ifdef DEBUG_BLOCK
104 # define DEBUG_BLOCK_PRINT 1
105 #else
106 # define DEBUG_BLOCK_PRINT 0
107 #endif
108 #define DPRINTF(fmt, ...) \
109 do { \
110     if (DEBUG_BLOCK_PRINT) { \
111         printf(fmt, ## __VA_ARGS__); \
112     } \
113 } while (0)
114
115 /* OS X does not have O_DSYNC */
116 #ifndef O_DSYNC
117 #ifdef O_SYNC
118 #define O_DSYNC O_SYNC
119 #elif defined(O_FSYNC)
120 #define O_DSYNC O_FSYNC
121 #endif
122 #endif
123
124 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
125 #ifndef O_DIRECT
126 #define O_DIRECT O_DSYNC
127 #endif
128
129 #define FTYPE_FILE   0
130 #define FTYPE_CD     1
131
132 #define MAX_BLOCKSIZE   4096
133
134 typedef struct BDRVRawState {
135     int fd;
136     int type;
137     int open_flags;
138     size_t buf_align;
139
140 #ifdef CONFIG_XFS
141     bool is_xfs:1;
142 #endif
143     bool has_discard:1;
144     bool has_write_zeroes:1;
145     bool discard_zeroes:1;
146     bool use_linux_aio:1;
147     bool has_fallocate;
148     bool needs_alignment;
149 } BDRVRawState;
150
151 typedef struct BDRVRawReopenState {
152     int fd;
153     int open_flags;
154 } BDRVRawReopenState;
155
156 static int fd_open(BlockDriverState *bs);
157 static int64_t raw_getlength(BlockDriverState *bs);
158
159 typedef struct RawPosixAIOData {
160     BlockDriverState *bs;
161     int aio_fildes;
162     union {
163         struct iovec *aio_iov;
164         void *aio_ioctl_buf;
165     };
166     int aio_niov;
167     uint64_t aio_nbytes;
168 #define aio_ioctl_cmd   aio_nbytes /* for QEMU_AIO_IOCTL */
169     off_t aio_offset;
170     int aio_type;
171 } RawPosixAIOData;
172
173 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
174 static int cdrom_reopen(BlockDriverState *bs);
175 #endif
176
177 #if defined(__NetBSD__)
178 static int raw_normalize_devicepath(const char **filename)
179 {
180     static char namebuf[PATH_MAX];
181     const char *dp, *fname;
182     struct stat sb;
183
184     fname = *filename;
185     dp = strrchr(fname, '/');
186     if (lstat(fname, &sb) < 0) {
187         fprintf(stderr, "%s: stat failed: %s\n",
188             fname, strerror(errno));
189         return -errno;
190     }
191
192     if (!S_ISBLK(sb.st_mode)) {
193         return 0;
194     }
195
196     if (dp == NULL) {
197         snprintf(namebuf, PATH_MAX, "r%s", fname);
198     } else {
199         snprintf(namebuf, PATH_MAX, "%.*s/r%s",
200             (int)(dp - fname), fname, dp + 1);
201     }
202     fprintf(stderr, "%s is a block device", fname);
203     *filename = namebuf;
204     fprintf(stderr, ", using %s\n", *filename);
205
206     return 0;
207 }
208 #else
209 static int raw_normalize_devicepath(const char **filename)
210 {
211     return 0;
212 }
213 #endif
214
215 /*
216  * Get logical block size via ioctl. On success store it in @sector_size_p.
217  */
218 static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
219 {
220     unsigned int sector_size;
221     bool success = false;
222
223     errno = ENOTSUP;
224
225     /* Try a few ioctls to get the right size */
226 #ifdef BLKSSZGET
227     if (ioctl(fd, BLKSSZGET, &sector_size) >= 0) {
228         *sector_size_p = sector_size;
229         success = true;
230     }
231 #endif
232 #ifdef DKIOCGETBLOCKSIZE
233     if (ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) >= 0) {
234         *sector_size_p = sector_size;
235         success = true;
236     }
237 #endif
238 #ifdef DIOCGSECTORSIZE
239     if (ioctl(fd, DIOCGSECTORSIZE, &sector_size) >= 0) {
240         *sector_size_p = sector_size;
241         success = true;
242     }
243 #endif
244
245     return success ? 0 : -errno;
246 }
247
248 /**
249  * Get physical block size of @fd.
250  * On success, store it in @blk_size and return 0.
251  * On failure, return -errno.
252  */
253 static int probe_physical_blocksize(int fd, unsigned int *blk_size)
254 {
255 #ifdef BLKPBSZGET
256     if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
257         return -errno;
258     }
259     return 0;
260 #else
261     return -ENOTSUP;
262 #endif
263 }
264
265 /* Check if read is allowed with given memory buffer and length.
266  *
267  * This function is used to check O_DIRECT memory buffer and request alignment.
268  */
269 static bool raw_is_io_aligned(int fd, void *buf, size_t len)
270 {
271     ssize_t ret = pread(fd, buf, len, 0);
272
273     if (ret >= 0) {
274         return true;
275     }
276
277 #ifdef __linux__
278     /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads.  Ignore
279      * other errors (e.g. real I/O error), which could happen on a failed
280      * drive, since we only care about probing alignment.
281      */
282     if (errno != EINVAL) {
283         return true;
284     }
285 #endif
286
287     return false;
288 }
289
290 static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
291 {
292     BDRVRawState *s = bs->opaque;
293     char *buf;
294     size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
295
296     /* For SCSI generic devices the alignment is not really used.
297        With buffered I/O, we don't have any restrictions. */
298     if (bdrv_is_sg(bs) || !s->needs_alignment) {
299         bs->bl.request_alignment = 1;
300         s->buf_align = 1;
301         return;
302     }
303
304     bs->bl.request_alignment = 0;
305     s->buf_align = 0;
306     /* Let's try to use the logical blocksize for the alignment. */
307     if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) {
308         bs->bl.request_alignment = 0;
309     }
310 #ifdef CONFIG_XFS
311     if (s->is_xfs) {
312         struct dioattr da;
313         if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {
314             bs->bl.request_alignment = da.d_miniosz;
315             /* The kernel returns wrong information for d_mem */
316             /* s->buf_align = da.d_mem; */
317         }
318     }
319 #endif
320
321     /* If we could not get the sizes so far, we can only guess them */
322     if (!s->buf_align) {
323         size_t align;
324         buf = qemu_memalign(max_align, 2 * max_align);
325         for (align = 512; align <= max_align; align <<= 1) {
326             if (raw_is_io_aligned(fd, buf + align, max_align)) {
327                 s->buf_align = align;
328                 break;
329             }
330         }
331         qemu_vfree(buf);
332     }
333
334     if (!bs->bl.request_alignment) {
335         size_t align;
336         buf = qemu_memalign(s->buf_align, max_align);
337         for (align = 512; align <= max_align; align <<= 1) {
338             if (raw_is_io_aligned(fd, buf, align)) {
339                 bs->bl.request_alignment = align;
340                 break;
341             }
342         }
343         qemu_vfree(buf);
344     }
345
346     if (!s->buf_align || !bs->bl.request_alignment) {
347         error_setg(errp, "Could not find working O_DIRECT alignment");
348         error_append_hint(errp, "Try cache.direct=off\n");
349     }
350 }
351
352 static void raw_parse_flags(int bdrv_flags, int *open_flags)
353 {
354     assert(open_flags != NULL);
355
356     *open_flags |= O_BINARY;
357     *open_flags &= ~O_ACCMODE;
358     if (bdrv_flags & BDRV_O_RDWR) {
359         *open_flags |= O_RDWR;
360     } else {
361         *open_flags |= O_RDONLY;
362     }
363
364     /* Use O_DSYNC for write-through caching, no flags for write-back caching,
365      * and O_DIRECT for no caching. */
366     if ((bdrv_flags & BDRV_O_NOCACHE)) {
367         *open_flags |= O_DIRECT;
368     }
369 }
370
371 static void raw_parse_filename(const char *filename, QDict *options,
372                                Error **errp)
373 {
374     /* The filename does not have to be prefixed by the protocol name, since
375      * "file" is the default protocol; therefore, the return value of this
376      * function call can be ignored. */
377     strstart(filename, "file:", &filename);
378
379     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
380 }
381
382 static QemuOptsList raw_runtime_opts = {
383     .name = "raw",
384     .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
385     .desc = {
386         {
387             .name = "filename",
388             .type = QEMU_OPT_STRING,
389             .help = "File name of the image",
390         },
391         {
392             .name = "aio",
393             .type = QEMU_OPT_STRING,
394             .help = "host AIO implementation (threads, native)",
395         },
396         { /* end of list */ }
397     },
398 };
399
400 static int raw_open_common(BlockDriverState *bs, QDict *options,
401                            int bdrv_flags, int open_flags, Error **errp)
402 {
403     BDRVRawState *s = bs->opaque;
404     QemuOpts *opts;
405     Error *local_err = NULL;
406     const char *filename = NULL;
407     BlockdevAioOptions aio, aio_default;
408     int fd, ret;
409     struct stat st;
410
411     opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
412     qemu_opts_absorb_qdict(opts, options, &local_err);
413     if (local_err) {
414         error_propagate(errp, local_err);
415         ret = -EINVAL;
416         goto fail;
417     }
418
419     filename = qemu_opt_get(opts, "filename");
420
421     ret = raw_normalize_devicepath(&filename);
422     if (ret != 0) {
423         error_setg_errno(errp, -ret, "Could not normalize device path");
424         goto fail;
425     }
426
427     aio_default = (bdrv_flags & BDRV_O_NATIVE_AIO)
428                   ? BLOCKDEV_AIO_OPTIONS_NATIVE
429                   : BLOCKDEV_AIO_OPTIONS_THREADS;
430     aio = qapi_enum_parse(BlockdevAioOptions_lookup, qemu_opt_get(opts, "aio"),
431                           BLOCKDEV_AIO_OPTIONS__MAX, aio_default, &local_err);
432     if (local_err) {
433         error_propagate(errp, local_err);
434         ret = -EINVAL;
435         goto fail;
436     }
437     s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
438
439     s->open_flags = open_flags;
440     raw_parse_flags(bdrv_flags, &s->open_flags);
441
442     s->fd = -1;
443     fd = qemu_open(filename, s->open_flags, 0644);
444     if (fd < 0) {
445         ret = -errno;
446         error_setg_errno(errp, errno, "Could not open '%s'", filename);
447         if (ret == -EROFS) {
448             ret = -EACCES;
449         }
450         goto fail;
451     }
452     s->fd = fd;
453
454 #ifdef CONFIG_LINUX_AIO
455      /* Currently Linux does AIO only for files opened with O_DIRECT */
456     if (s->use_linux_aio && !(s->open_flags & O_DIRECT)) {
457         error_setg(errp, "aio=native was specified, but it requires "
458                          "cache.direct=on, which was not specified.");
459         ret = -EINVAL;
460         goto fail;
461     }
462 #else
463     if (s->use_linux_aio) {
464         error_setg(errp, "aio=native was specified, but is not supported "
465                          "in this build.");
466         ret = -EINVAL;
467         goto fail;
468     }
469 #endif /* !defined(CONFIG_LINUX_AIO) */
470
471     s->has_discard = true;
472     s->has_write_zeroes = true;
473     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP;
474     if ((bs->open_flags & BDRV_O_NOCACHE) != 0) {
475         s->needs_alignment = true;
476     }
477
478     if (fstat(s->fd, &st) < 0) {
479         ret = -errno;
480         error_setg_errno(errp, errno, "Could not stat file");
481         goto fail;
482     }
483     if (S_ISREG(st.st_mode)) {
484         s->discard_zeroes = true;
485         s->has_fallocate = true;
486     }
487     if (S_ISBLK(st.st_mode)) {
488 #ifdef BLKDISCARDZEROES
489         unsigned int arg;
490         if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
491             s->discard_zeroes = true;
492         }
493 #endif
494 #ifdef __linux__
495         /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache.  Do
496          * not rely on the contents of discarded blocks unless using O_DIRECT.
497          * Same for BLKZEROOUT.
498          */
499         if (!(bs->open_flags & BDRV_O_NOCACHE)) {
500             s->discard_zeroes = false;
501             s->has_write_zeroes = false;
502         }
503 #endif
504     }
505 #ifdef __FreeBSD__
506     if (S_ISCHR(st.st_mode)) {
507         /*
508          * The file is a char device (disk), which on FreeBSD isn't behind
509          * a pager, so force all requests to be aligned. This is needed
510          * so QEMU makes sure all IO operations on the device are aligned
511          * to sector size, or else FreeBSD will reject them with EINVAL.
512          */
513         s->needs_alignment = true;
514     }
515 #endif
516
517 #ifdef CONFIG_XFS
518     if (platform_test_xfs_fd(s->fd)) {
519         s->is_xfs = true;
520     }
521 #endif
522
523     ret = 0;
524 fail:
525     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
526         unlink(filename);
527     }
528     qemu_opts_del(opts);
529     return ret;
530 }
531
532 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
533                     Error **errp)
534 {
535     BDRVRawState *s = bs->opaque;
536
537     s->type = FTYPE_FILE;
538     return raw_open_common(bs, options, flags, 0, errp);
539 }
540
541 static int raw_reopen_prepare(BDRVReopenState *state,
542                               BlockReopenQueue *queue, Error **errp)
543 {
544     BDRVRawState *s;
545     BDRVRawReopenState *rs;
546     int ret = 0;
547     Error *local_err = NULL;
548
549     assert(state != NULL);
550     assert(state->bs != NULL);
551
552     s = state->bs->opaque;
553
554     state->opaque = g_new0(BDRVRawReopenState, 1);
555     rs = state->opaque;
556
557     if (s->type == FTYPE_CD) {
558         rs->open_flags |= O_NONBLOCK;
559     }
560
561     raw_parse_flags(state->flags, &rs->open_flags);
562
563     rs->fd = -1;
564
565     int fcntl_flags = O_APPEND | O_NONBLOCK;
566 #ifdef O_NOATIME
567     fcntl_flags |= O_NOATIME;
568 #endif
569
570 #ifdef O_ASYNC
571     /* Not all operating systems have O_ASYNC, and those that don't
572      * will not let us track the state into rs->open_flags (typically
573      * you achieve the same effect with an ioctl, for example I_SETSIG
574      * on Solaris). But we do not use O_ASYNC, so that's fine.
575      */
576     assert((s->open_flags & O_ASYNC) == 0);
577 #endif
578
579     if ((rs->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
580         /* dup the original fd */
581         rs->fd = qemu_dup(s->fd);
582         if (rs->fd >= 0) {
583             ret = fcntl_setfl(rs->fd, rs->open_flags);
584             if (ret) {
585                 qemu_close(rs->fd);
586                 rs->fd = -1;
587             }
588         }
589     }
590
591     /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
592     if (rs->fd == -1) {
593         const char *normalized_filename = state->bs->filename;
594         ret = raw_normalize_devicepath(&normalized_filename);
595         if (ret < 0) {
596             error_setg_errno(errp, -ret, "Could not normalize device path");
597         } else {
598             assert(!(rs->open_flags & O_CREAT));
599             rs->fd = qemu_open(normalized_filename, rs->open_flags);
600             if (rs->fd == -1) {
601                 error_setg_errno(errp, errno, "Could not reopen file");
602                 ret = -1;
603             }
604         }
605     }
606
607     /* Fail already reopen_prepare() if we can't get a working O_DIRECT
608      * alignment with the new fd. */
609     if (rs->fd != -1) {
610         raw_probe_alignment(state->bs, rs->fd, &local_err);
611         if (local_err) {
612             qemu_close(rs->fd);
613             rs->fd = -1;
614             error_propagate(errp, local_err);
615             ret = -EINVAL;
616         }
617     }
618
619     return ret;
620 }
621
622 static void raw_reopen_commit(BDRVReopenState *state)
623 {
624     BDRVRawReopenState *rs = state->opaque;
625     BDRVRawState *s = state->bs->opaque;
626
627     s->open_flags = rs->open_flags;
628
629     qemu_close(s->fd);
630     s->fd = rs->fd;
631
632     g_free(state->opaque);
633     state->opaque = NULL;
634 }
635
636
637 static void raw_reopen_abort(BDRVReopenState *state)
638 {
639     BDRVRawReopenState *rs = state->opaque;
640
641      /* nothing to do if NULL, we didn't get far enough */
642     if (rs == NULL) {
643         return;
644     }
645
646     if (rs->fd >= 0) {
647         qemu_close(rs->fd);
648         rs->fd = -1;
649     }
650     g_free(state->opaque);
651     state->opaque = NULL;
652 }
653
654 static int hdev_get_max_transfer_length(int fd)
655 {
656 #ifdef BLKSECTGET
657     int max_sectors = 0;
658     if (ioctl(fd, BLKSECTGET, &max_sectors) == 0) {
659         return max_sectors;
660     } else {
661         return -errno;
662     }
663 #else
664     return -ENOSYS;
665 #endif
666 }
667
668 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
669 {
670     BDRVRawState *s = bs->opaque;
671     struct stat st;
672
673     if (!fstat(s->fd, &st)) {
674         if (S_ISBLK(st.st_mode)) {
675             int ret = hdev_get_max_transfer_length(s->fd);
676             if (ret > 0 && ret <= BDRV_REQUEST_MAX_SECTORS) {
677                 bs->bl.max_transfer = pow2floor(ret << BDRV_SECTOR_BITS);
678             }
679         }
680     }
681
682     raw_probe_alignment(bs, s->fd, errp);
683     bs->bl.min_mem_alignment = s->buf_align;
684     bs->bl.opt_mem_alignment = MAX(s->buf_align, getpagesize());
685 }
686
687 static int check_for_dasd(int fd)
688 {
689 #ifdef BIODASDINFO2
690     struct dasd_information2_t info = {0};
691
692     return ioctl(fd, BIODASDINFO2, &info);
693 #else
694     return -1;
695 #endif
696 }
697
698 /**
699  * Try to get @bs's logical and physical block size.
700  * On success, store them in @bsz and return zero.
701  * On failure, return negative errno.
702  */
703 static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
704 {
705     BDRVRawState *s = bs->opaque;
706     int ret;
707
708     /* If DASD, get blocksizes */
709     if (check_for_dasd(s->fd) < 0) {
710         return -ENOTSUP;
711     }
712     ret = probe_logical_blocksize(s->fd, &bsz->log);
713     if (ret < 0) {
714         return ret;
715     }
716     return probe_physical_blocksize(s->fd, &bsz->phys);
717 }
718
719 /**
720  * Try to get @bs's geometry: cyls, heads, sectors.
721  * On success, store them in @geo and return 0.
722  * On failure return -errno.
723  * (Allows block driver to assign default geometry values that guest sees)
724  */
725 #ifdef __linux__
726 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
727 {
728     BDRVRawState *s = bs->opaque;
729     struct hd_geometry ioctl_geo = {0};
730
731     /* If DASD, get its geometry */
732     if (check_for_dasd(s->fd) < 0) {
733         return -ENOTSUP;
734     }
735     if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
736         return -errno;
737     }
738     /* HDIO_GETGEO may return success even though geo contains zeros
739        (e.g. certain multipath setups) */
740     if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
741         return -ENOTSUP;
742     }
743     /* Do not return a geometry for partition */
744     if (ioctl_geo.start != 0) {
745         return -ENOTSUP;
746     }
747     geo->heads = ioctl_geo.heads;
748     geo->sectors = ioctl_geo.sectors;
749     geo->cylinders = ioctl_geo.cylinders;
750
751     return 0;
752 }
753 #else /* __linux__ */
754 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
755 {
756     return -ENOTSUP;
757 }
758 #endif
759
760 static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb)
761 {
762     int ret;
763
764     ret = ioctl(aiocb->aio_fildes, aiocb->aio_ioctl_cmd, aiocb->aio_ioctl_buf);
765     if (ret == -1) {
766         return -errno;
767     }
768
769     return 0;
770 }
771
772 static ssize_t handle_aiocb_flush(RawPosixAIOData *aiocb)
773 {
774     int ret;
775
776     ret = qemu_fdatasync(aiocb->aio_fildes);
777     if (ret == -1) {
778         return -errno;
779     }
780     return 0;
781 }
782
783 #ifdef CONFIG_PREADV
784
785 static bool preadv_present = true;
786
787 static ssize_t
788 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
789 {
790     return preadv(fd, iov, nr_iov, offset);
791 }
792
793 static ssize_t
794 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
795 {
796     return pwritev(fd, iov, nr_iov, offset);
797 }
798
799 #else
800
801 static bool preadv_present = false;
802
803 static ssize_t
804 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
805 {
806     return -ENOSYS;
807 }
808
809 static ssize_t
810 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
811 {
812     return -ENOSYS;
813 }
814
815 #endif
816
817 static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
818 {
819     ssize_t len;
820
821     do {
822         if (aiocb->aio_type & QEMU_AIO_WRITE)
823             len = qemu_pwritev(aiocb->aio_fildes,
824                                aiocb->aio_iov,
825                                aiocb->aio_niov,
826                                aiocb->aio_offset);
827          else
828             len = qemu_preadv(aiocb->aio_fildes,
829                               aiocb->aio_iov,
830                               aiocb->aio_niov,
831                               aiocb->aio_offset);
832     } while (len == -1 && errno == EINTR);
833
834     if (len == -1) {
835         return -errno;
836     }
837     return len;
838 }
839
840 /*
841  * Read/writes the data to/from a given linear buffer.
842  *
843  * Returns the number of bytes handles or -errno in case of an error. Short
844  * reads are only returned if the end of the file is reached.
845  */
846 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
847 {
848     ssize_t offset = 0;
849     ssize_t len;
850
851     while (offset < aiocb->aio_nbytes) {
852         if (aiocb->aio_type & QEMU_AIO_WRITE) {
853             len = pwrite(aiocb->aio_fildes,
854                          (const char *)buf + offset,
855                          aiocb->aio_nbytes - offset,
856                          aiocb->aio_offset + offset);
857         } else {
858             len = pread(aiocb->aio_fildes,
859                         buf + offset,
860                         aiocb->aio_nbytes - offset,
861                         aiocb->aio_offset + offset);
862         }
863         if (len == -1 && errno == EINTR) {
864             continue;
865         } else if (len == -1 && errno == EINVAL &&
866                    (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
867                    !(aiocb->aio_type & QEMU_AIO_WRITE) &&
868                    offset > 0) {
869             /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
870              * after a short read.  Assume that O_DIRECT short reads only occur
871              * at EOF.  Therefore this is a short read, not an I/O error.
872              */
873             break;
874         } else if (len == -1) {
875             offset = -errno;
876             break;
877         } else if (len == 0) {
878             break;
879         }
880         offset += len;
881     }
882
883     return offset;
884 }
885
886 static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
887 {
888     ssize_t nbytes;
889     char *buf;
890
891     if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
892         /*
893          * If there is just a single buffer, and it is properly aligned
894          * we can just use plain pread/pwrite without any problems.
895          */
896         if (aiocb->aio_niov == 1) {
897              return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base);
898         }
899         /*
900          * We have more than one iovec, and all are properly aligned.
901          *
902          * Try preadv/pwritev first and fall back to linearizing the
903          * buffer if it's not supported.
904          */
905         if (preadv_present) {
906             nbytes = handle_aiocb_rw_vector(aiocb);
907             if (nbytes == aiocb->aio_nbytes ||
908                 (nbytes < 0 && nbytes != -ENOSYS)) {
909                 return nbytes;
910             }
911             preadv_present = false;
912         }
913
914         /*
915          * XXX(hch): short read/write.  no easy way to handle the reminder
916          * using these interfaces.  For now retry using plain
917          * pread/pwrite?
918          */
919     }
920
921     /*
922      * Ok, we have to do it the hard way, copy all segments into
923      * a single aligned buffer.
924      */
925     buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
926     if (buf == NULL) {
927         return -ENOMEM;
928     }
929
930     if (aiocb->aio_type & QEMU_AIO_WRITE) {
931         char *p = buf;
932         int i;
933
934         for (i = 0; i < aiocb->aio_niov; ++i) {
935             memcpy(p, aiocb->aio_iov[i].iov_base, aiocb->aio_iov[i].iov_len);
936             p += aiocb->aio_iov[i].iov_len;
937         }
938         assert(p - buf == aiocb->aio_nbytes);
939     }
940
941     nbytes = handle_aiocb_rw_linear(aiocb, buf);
942     if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
943         char *p = buf;
944         size_t count = aiocb->aio_nbytes, copy;
945         int i;
946
947         for (i = 0; i < aiocb->aio_niov && count; ++i) {
948             copy = count;
949             if (copy > aiocb->aio_iov[i].iov_len) {
950                 copy = aiocb->aio_iov[i].iov_len;
951             }
952             memcpy(aiocb->aio_iov[i].iov_base, p, copy);
953             assert(count >= copy);
954             p     += copy;
955             count -= copy;
956         }
957         assert(count == 0);
958     }
959     qemu_vfree(buf);
960
961     return nbytes;
962 }
963
964 #ifdef CONFIG_XFS
965 static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes)
966 {
967     struct xfs_flock64 fl;
968     int err;
969
970     memset(&fl, 0, sizeof(fl));
971     fl.l_whence = SEEK_SET;
972     fl.l_start = offset;
973     fl.l_len = bytes;
974
975     if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) {
976         err = errno;
977         DPRINTF("cannot write zero range (%s)\n", strerror(errno));
978         return -err;
979     }
980
981     return 0;
982 }
983
984 static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes)
985 {
986     struct xfs_flock64 fl;
987     int err;
988
989     memset(&fl, 0, sizeof(fl));
990     fl.l_whence = SEEK_SET;
991     fl.l_start = offset;
992     fl.l_len = bytes;
993
994     if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {
995         err = errno;
996         DPRINTF("cannot punch hole (%s)\n", strerror(errno));
997         return -err;
998     }
999
1000     return 0;
1001 }
1002 #endif
1003
1004 static int translate_err(int err)
1005 {
1006     if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1007         err == -ENOTTY) {
1008         err = -ENOTSUP;
1009     }
1010     return err;
1011 }
1012
1013 #ifdef CONFIG_FALLOCATE
1014 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1015 {
1016     do {
1017         if (fallocate(fd, mode, offset, len) == 0) {
1018             return 0;
1019         }
1020     } while (errno == EINTR);
1021     return translate_err(-errno);
1022 }
1023 #endif
1024
1025 static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1026 {
1027     int ret = -ENOTSUP;
1028     BDRVRawState *s = aiocb->bs->opaque;
1029
1030     if (!s->has_write_zeroes) {
1031         return -ENOTSUP;
1032     }
1033
1034 #ifdef BLKZEROOUT
1035     do {
1036         uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1037         if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1038             return 0;
1039         }
1040     } while (errno == EINTR);
1041
1042     ret = translate_err(-errno);
1043 #endif
1044
1045     if (ret == -ENOTSUP) {
1046         s->has_write_zeroes = false;
1047     }
1048     return ret;
1049 }
1050
1051 static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb)
1052 {
1053 #if defined(CONFIG_FALLOCATE) || defined(CONFIG_XFS)
1054     BDRVRawState *s = aiocb->bs->opaque;
1055 #endif
1056
1057     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1058         return handle_aiocb_write_zeroes_block(aiocb);
1059     }
1060
1061 #ifdef CONFIG_XFS
1062     if (s->is_xfs) {
1063         return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes);
1064     }
1065 #endif
1066
1067 #ifdef CONFIG_FALLOCATE_ZERO_RANGE
1068     if (s->has_write_zeroes) {
1069         int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1070                                aiocb->aio_offset, aiocb->aio_nbytes);
1071         if (ret == 0 || ret != -ENOTSUP) {
1072             return ret;
1073         }
1074         s->has_write_zeroes = false;
1075     }
1076 #endif
1077
1078 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1079     if (s->has_discard && s->has_fallocate) {
1080         int ret = do_fallocate(s->fd,
1081                                FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1082                                aiocb->aio_offset, aiocb->aio_nbytes);
1083         if (ret == 0) {
1084             ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1085             if (ret == 0 || ret != -ENOTSUP) {
1086                 return ret;
1087             }
1088             s->has_fallocate = false;
1089         } else if (ret != -ENOTSUP) {
1090             return ret;
1091         } else {
1092             s->has_discard = false;
1093         }
1094     }
1095 #endif
1096
1097 #ifdef CONFIG_FALLOCATE
1098     if (s->has_fallocate && aiocb->aio_offset >= bdrv_getlength(aiocb->bs)) {
1099         int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1100         if (ret == 0 || ret != -ENOTSUP) {
1101             return ret;
1102         }
1103         s->has_fallocate = false;
1104     }
1105 #endif
1106
1107     return -ENOTSUP;
1108 }
1109
1110 static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb)
1111 {
1112     int ret = -EOPNOTSUPP;
1113     BDRVRawState *s = aiocb->bs->opaque;
1114
1115     if (!s->has_discard) {
1116         return -ENOTSUP;
1117     }
1118
1119     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1120 #ifdef BLKDISCARD
1121         do {
1122             uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1123             if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1124                 return 0;
1125             }
1126         } while (errno == EINTR);
1127
1128         ret = -errno;
1129 #endif
1130     } else {
1131 #ifdef CONFIG_XFS
1132         if (s->is_xfs) {
1133             return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1134         }
1135 #endif
1136
1137 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1138         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1139                            aiocb->aio_offset, aiocb->aio_nbytes);
1140 #endif
1141     }
1142
1143     ret = translate_err(ret);
1144     if (ret == -ENOTSUP) {
1145         s->has_discard = false;
1146     }
1147     return ret;
1148 }
1149
1150 static int aio_worker(void *arg)
1151 {
1152     RawPosixAIOData *aiocb = arg;
1153     ssize_t ret = 0;
1154
1155     switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
1156     case QEMU_AIO_READ:
1157         ret = handle_aiocb_rw(aiocb);
1158         if (ret >= 0 && ret < aiocb->aio_nbytes) {
1159             iov_memset(aiocb->aio_iov, aiocb->aio_niov, ret,
1160                       0, aiocb->aio_nbytes - ret);
1161
1162             ret = aiocb->aio_nbytes;
1163         }
1164         if (ret == aiocb->aio_nbytes) {
1165             ret = 0;
1166         } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1167             ret = -EINVAL;
1168         }
1169         break;
1170     case QEMU_AIO_WRITE:
1171         ret = handle_aiocb_rw(aiocb);
1172         if (ret == aiocb->aio_nbytes) {
1173             ret = 0;
1174         } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1175             ret = -EINVAL;
1176         }
1177         break;
1178     case QEMU_AIO_FLUSH:
1179         ret = handle_aiocb_flush(aiocb);
1180         break;
1181     case QEMU_AIO_IOCTL:
1182         ret = handle_aiocb_ioctl(aiocb);
1183         break;
1184     case QEMU_AIO_DISCARD:
1185         ret = handle_aiocb_discard(aiocb);
1186         break;
1187     case QEMU_AIO_WRITE_ZEROES:
1188         ret = handle_aiocb_write_zeroes(aiocb);
1189         break;
1190     default:
1191         fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
1192         ret = -EINVAL;
1193         break;
1194     }
1195
1196     g_free(aiocb);
1197     return ret;
1198 }
1199
1200 static int paio_submit_co(BlockDriverState *bs, int fd,
1201                           int64_t offset, QEMUIOVector *qiov,
1202                           int count, int type)
1203 {
1204     RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
1205     ThreadPool *pool;
1206
1207     acb->bs = bs;
1208     acb->aio_type = type;
1209     acb->aio_fildes = fd;
1210
1211     acb->aio_nbytes = count;
1212     acb->aio_offset = offset;
1213
1214     if (qiov) {
1215         acb->aio_iov = qiov->iov;
1216         acb->aio_niov = qiov->niov;
1217         assert(qiov->size == count);
1218     }
1219
1220     trace_paio_submit_co(offset, count, type);
1221     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1222     return thread_pool_submit_co(pool, aio_worker, acb);
1223 }
1224
1225 static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd,
1226         int64_t offset, QEMUIOVector *qiov, int count,
1227         BlockCompletionFunc *cb, void *opaque, int type)
1228 {
1229     RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
1230     ThreadPool *pool;
1231
1232     acb->bs = bs;
1233     acb->aio_type = type;
1234     acb->aio_fildes = fd;
1235
1236     acb->aio_nbytes = count;
1237     acb->aio_offset = offset;
1238
1239     if (qiov) {
1240         acb->aio_iov = qiov->iov;
1241         acb->aio_niov = qiov->niov;
1242         assert(qiov->size == acb->aio_nbytes);
1243     }
1244
1245     trace_paio_submit(acb, opaque, offset, count, type);
1246     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1247     return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
1248 }
1249
1250 static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
1251                                    uint64_t bytes, QEMUIOVector *qiov, int type)
1252 {
1253     BDRVRawState *s = bs->opaque;
1254
1255     if (fd_open(bs) < 0)
1256         return -EIO;
1257
1258     /*
1259      * Check if the underlying device requires requests to be aligned,
1260      * and if the request we are trying to submit is aligned or not.
1261      * If this is the case tell the low-level driver that it needs
1262      * to copy the buffer.
1263      */
1264     if (s->needs_alignment) {
1265         if (!bdrv_qiov_is_aligned(bs, qiov)) {
1266             type |= QEMU_AIO_MISALIGNED;
1267 #ifdef CONFIG_LINUX_AIO
1268         } else if (s->use_linux_aio) {
1269             LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1270             assert(qiov->size == bytes);
1271             return laio_co_submit(bs, aio, s->fd, offset, qiov, type);
1272 #endif
1273         }
1274     }
1275
1276     return paio_submit_co(bs, s->fd, offset, qiov, bytes, type);
1277 }
1278
1279 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
1280                                       uint64_t bytes, QEMUIOVector *qiov,
1281                                       int flags)
1282 {
1283     return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
1284 }
1285
1286 static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
1287                                        uint64_t bytes, QEMUIOVector *qiov,
1288                                        int flags)
1289 {
1290     assert(flags == 0);
1291     return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
1292 }
1293
1294 static void raw_aio_plug(BlockDriverState *bs)
1295 {
1296 #ifdef CONFIG_LINUX_AIO
1297     BDRVRawState *s = bs->opaque;
1298     if (s->use_linux_aio) {
1299         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1300         laio_io_plug(bs, aio);
1301     }
1302 #endif
1303 }
1304
1305 static void raw_aio_unplug(BlockDriverState *bs)
1306 {
1307 #ifdef CONFIG_LINUX_AIO
1308     BDRVRawState *s = bs->opaque;
1309     if (s->use_linux_aio) {
1310         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1311         laio_io_unplug(bs, aio);
1312     }
1313 #endif
1314 }
1315
1316 static BlockAIOCB *raw_aio_flush(BlockDriverState *bs,
1317         BlockCompletionFunc *cb, void *opaque)
1318 {
1319     BDRVRawState *s = bs->opaque;
1320
1321     if (fd_open(bs) < 0)
1322         return NULL;
1323
1324     return paio_submit(bs, s->fd, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
1325 }
1326
1327 static void raw_close(BlockDriverState *bs)
1328 {
1329     BDRVRawState *s = bs->opaque;
1330
1331     if (s->fd >= 0) {
1332         qemu_close(s->fd);
1333         s->fd = -1;
1334     }
1335 }
1336
1337 static int raw_truncate(BlockDriverState *bs, int64_t offset)
1338 {
1339     BDRVRawState *s = bs->opaque;
1340     struct stat st;
1341
1342     if (fstat(s->fd, &st)) {
1343         return -errno;
1344     }
1345
1346     if (S_ISREG(st.st_mode)) {
1347         if (ftruncate(s->fd, offset) < 0) {
1348             return -errno;
1349         }
1350     } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1351        if (offset > raw_getlength(bs)) {
1352            return -EINVAL;
1353        }
1354     } else {
1355         return -ENOTSUP;
1356     }
1357
1358     return 0;
1359 }
1360
1361 #ifdef __OpenBSD__
1362 static int64_t raw_getlength(BlockDriverState *bs)
1363 {
1364     BDRVRawState *s = bs->opaque;
1365     int fd = s->fd;
1366     struct stat st;
1367
1368     if (fstat(fd, &st))
1369         return -errno;
1370     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1371         struct disklabel dl;
1372
1373         if (ioctl(fd, DIOCGDINFO, &dl))
1374             return -errno;
1375         return (uint64_t)dl.d_secsize *
1376             dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1377     } else
1378         return st.st_size;
1379 }
1380 #elif defined(__NetBSD__)
1381 static int64_t raw_getlength(BlockDriverState *bs)
1382 {
1383     BDRVRawState *s = bs->opaque;
1384     int fd = s->fd;
1385     struct stat st;
1386
1387     if (fstat(fd, &st))
1388         return -errno;
1389     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1390         struct dkwedge_info dkw;
1391
1392         if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
1393             return dkw.dkw_size * 512;
1394         } else {
1395             struct disklabel dl;
1396
1397             if (ioctl(fd, DIOCGDINFO, &dl))
1398                 return -errno;
1399             return (uint64_t)dl.d_secsize *
1400                 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1401         }
1402     } else
1403         return st.st_size;
1404 }
1405 #elif defined(__sun__)
1406 static int64_t raw_getlength(BlockDriverState *bs)
1407 {
1408     BDRVRawState *s = bs->opaque;
1409     struct dk_minfo minfo;
1410     int ret;
1411     int64_t size;
1412
1413     ret = fd_open(bs);
1414     if (ret < 0) {
1415         return ret;
1416     }
1417
1418     /*
1419      * Use the DKIOCGMEDIAINFO ioctl to read the size.
1420      */
1421     ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
1422     if (ret != -1) {
1423         return minfo.dki_lbsize * minfo.dki_capacity;
1424     }
1425
1426     /*
1427      * There are reports that lseek on some devices fails, but
1428      * irc discussion said that contingency on contingency was overkill.
1429      */
1430     size = lseek(s->fd, 0, SEEK_END);
1431     if (size < 0) {
1432         return -errno;
1433     }
1434     return size;
1435 }
1436 #elif defined(CONFIG_BSD)
1437 static int64_t raw_getlength(BlockDriverState *bs)
1438 {
1439     BDRVRawState *s = bs->opaque;
1440     int fd = s->fd;
1441     int64_t size;
1442     struct stat sb;
1443 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1444     int reopened = 0;
1445 #endif
1446     int ret;
1447
1448     ret = fd_open(bs);
1449     if (ret < 0)
1450         return ret;
1451
1452 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1453 again:
1454 #endif
1455     if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
1456 #ifdef DIOCGMEDIASIZE
1457         if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
1458 #elif defined(DIOCGPART)
1459         {
1460                 struct partinfo pi;
1461                 if (ioctl(fd, DIOCGPART, &pi) == 0)
1462                         size = pi.media_size;
1463                 else
1464                         size = 0;
1465         }
1466         if (size == 0)
1467 #endif
1468 #if defined(__APPLE__) && defined(__MACH__)
1469         {
1470             uint64_t sectors = 0;
1471             uint32_t sector_size = 0;
1472
1473             if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
1474                && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
1475                 size = sectors * sector_size;
1476             } else {
1477                 size = lseek(fd, 0LL, SEEK_END);
1478                 if (size < 0) {
1479                     return -errno;
1480                 }
1481             }
1482         }
1483 #else
1484         size = lseek(fd, 0LL, SEEK_END);
1485         if (size < 0) {
1486             return -errno;
1487         }
1488 #endif
1489 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1490         switch(s->type) {
1491         case FTYPE_CD:
1492             /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
1493             if (size == 2048LL * (unsigned)-1)
1494                 size = 0;
1495             /* XXX no disc?  maybe we need to reopen... */
1496             if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
1497                 reopened = 1;
1498                 goto again;
1499             }
1500         }
1501 #endif
1502     } else {
1503         size = lseek(fd, 0, SEEK_END);
1504         if (size < 0) {
1505             return -errno;
1506         }
1507     }
1508     return size;
1509 }
1510 #else
1511 static int64_t raw_getlength(BlockDriverState *bs)
1512 {
1513     BDRVRawState *s = bs->opaque;
1514     int ret;
1515     int64_t size;
1516
1517     ret = fd_open(bs);
1518     if (ret < 0) {
1519         return ret;
1520     }
1521
1522     size = lseek(s->fd, 0, SEEK_END);
1523     if (size < 0) {
1524         return -errno;
1525     }
1526     return size;
1527 }
1528 #endif
1529
1530 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
1531 {
1532     struct stat st;
1533     BDRVRawState *s = bs->opaque;
1534
1535     if (fstat(s->fd, &st) < 0) {
1536         return -errno;
1537     }
1538     return (int64_t)st.st_blocks * 512;
1539 }
1540
1541 static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
1542 {
1543     int fd;
1544     int result = 0;
1545     int64_t total_size = 0;
1546     bool nocow = false;
1547     PreallocMode prealloc;
1548     char *buf = NULL;
1549     Error *local_err = NULL;
1550
1551     strstart(filename, "file:", &filename);
1552
1553     /* Read out options */
1554     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
1555                           BDRV_SECTOR_SIZE);
1556     nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
1557     buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
1558     prealloc = qapi_enum_parse(PreallocMode_lookup, buf,
1559                                PREALLOC_MODE__MAX, PREALLOC_MODE_OFF,
1560                                &local_err);
1561     g_free(buf);
1562     if (local_err) {
1563         error_propagate(errp, local_err);
1564         result = -EINVAL;
1565         goto out;
1566     }
1567
1568     fd = qemu_open(filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
1569                    0644);
1570     if (fd < 0) {
1571         result = -errno;
1572         error_setg_errno(errp, -result, "Could not create file");
1573         goto out;
1574     }
1575
1576     if (nocow) {
1577 #ifdef __linux__
1578         /* Set NOCOW flag to solve performance issue on fs like btrfs.
1579          * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
1580          * will be ignored since any failure of this operation should not
1581          * block the left work.
1582          */
1583         int attr;
1584         if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
1585             attr |= FS_NOCOW_FL;
1586             ioctl(fd, FS_IOC_SETFLAGS, &attr);
1587         }
1588 #endif
1589     }
1590
1591     if (ftruncate(fd, total_size) != 0) {
1592         result = -errno;
1593         error_setg_errno(errp, -result, "Could not resize file");
1594         goto out_close;
1595     }
1596
1597     switch (prealloc) {
1598 #ifdef CONFIG_POSIX_FALLOCATE
1599     case PREALLOC_MODE_FALLOC:
1600         /* posix_fallocate() doesn't set errno. */
1601         result = -posix_fallocate(fd, 0, total_size);
1602         if (result != 0) {
1603             error_setg_errno(errp, -result,
1604                              "Could not preallocate data for the new file");
1605         }
1606         break;
1607 #endif
1608     case PREALLOC_MODE_FULL:
1609     {
1610         int64_t num = 0, left = total_size;
1611         buf = g_malloc0(65536);
1612
1613         while (left > 0) {
1614             num = MIN(left, 65536);
1615             result = write(fd, buf, num);
1616             if (result < 0) {
1617                 result = -errno;
1618                 error_setg_errno(errp, -result,
1619                                  "Could not write to the new file");
1620                 break;
1621             }
1622             left -= result;
1623         }
1624         if (result >= 0) {
1625             result = fsync(fd);
1626             if (result < 0) {
1627                 result = -errno;
1628                 error_setg_errno(errp, -result,
1629                                  "Could not flush new file to disk");
1630             }
1631         }
1632         g_free(buf);
1633         break;
1634     }
1635     case PREALLOC_MODE_OFF:
1636         break;
1637     default:
1638         result = -EINVAL;
1639         error_setg(errp, "Unsupported preallocation mode: %s",
1640                    PreallocMode_lookup[prealloc]);
1641         break;
1642     }
1643
1644 out_close:
1645     if (qemu_close(fd) != 0 && result == 0) {
1646         result = -errno;
1647         error_setg_errno(errp, -result, "Could not close the new file");
1648     }
1649 out:
1650     return result;
1651 }
1652
1653 /*
1654  * Find allocation range in @bs around offset @start.
1655  * May change underlying file descriptor's file offset.
1656  * If @start is not in a hole, store @start in @data, and the
1657  * beginning of the next hole in @hole, and return 0.
1658  * If @start is in a non-trailing hole, store @start in @hole and the
1659  * beginning of the next non-hole in @data, and return 0.
1660  * If @start is in a trailing hole or beyond EOF, return -ENXIO.
1661  * If we can't find out, return a negative errno other than -ENXIO.
1662  */
1663 static int find_allocation(BlockDriverState *bs, off_t start,
1664                            off_t *data, off_t *hole)
1665 {
1666 #if defined SEEK_HOLE && defined SEEK_DATA
1667     BDRVRawState *s = bs->opaque;
1668     off_t offs;
1669
1670     /*
1671      * SEEK_DATA cases:
1672      * D1. offs == start: start is in data
1673      * D2. offs > start: start is in a hole, next data at offs
1674      * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
1675      *                              or start is beyond EOF
1676      *     If the latter happens, the file has been truncated behind
1677      *     our back since we opened it.  All bets are off then.
1678      *     Treating like a trailing hole is simplest.
1679      * D4. offs < 0, errno != ENXIO: we learned nothing
1680      */
1681     offs = lseek(s->fd, start, SEEK_DATA);
1682     if (offs < 0) {
1683         return -errno;          /* D3 or D4 */
1684     }
1685     assert(offs >= start);
1686
1687     if (offs > start) {
1688         /* D2: in hole, next data at offs */
1689         *hole = start;
1690         *data = offs;
1691         return 0;
1692     }
1693
1694     /* D1: in data, end not yet known */
1695
1696     /*
1697      * SEEK_HOLE cases:
1698      * H1. offs == start: start is in a hole
1699      *     If this happens here, a hole has been dug behind our back
1700      *     since the previous lseek().
1701      * H2. offs > start: either start is in data, next hole at offs,
1702      *                   or start is in trailing hole, EOF at offs
1703      *     Linux treats trailing holes like any other hole: offs ==
1704      *     start.  Solaris seeks to EOF instead: offs > start (blech).
1705      *     If that happens here, a hole has been dug behind our back
1706      *     since the previous lseek().
1707      * H3. offs < 0, errno = ENXIO: start is beyond EOF
1708      *     If this happens, the file has been truncated behind our
1709      *     back since we opened it.  Treat it like a trailing hole.
1710      * H4. offs < 0, errno != ENXIO: we learned nothing
1711      *     Pretend we know nothing at all, i.e. "forget" about D1.
1712      */
1713     offs = lseek(s->fd, start, SEEK_HOLE);
1714     if (offs < 0) {
1715         return -errno;          /* D1 and (H3 or H4) */
1716     }
1717     assert(offs >= start);
1718
1719     if (offs > start) {
1720         /*
1721          * D1 and H2: either in data, next hole at offs, or it was in
1722          * data but is now in a trailing hole.  In the latter case,
1723          * all bets are off.  Treating it as if it there was data all
1724          * the way to EOF is safe, so simply do that.
1725          */
1726         *data = start;
1727         *hole = offs;
1728         return 0;
1729     }
1730
1731     /* D1 and H1 */
1732     return -EBUSY;
1733 #else
1734     return -ENOTSUP;
1735 #endif
1736 }
1737
1738 /*
1739  * Returns the allocation status of the specified sectors.
1740  *
1741  * If 'sector_num' is beyond the end of the disk image the return value is 0
1742  * and 'pnum' is set to 0.
1743  *
1744  * 'pnum' is set to the number of sectors (including and immediately following
1745  * the specified sector) that are known to be in the same
1746  * allocated/unallocated state.
1747  *
1748  * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
1749  * beyond the end of the disk image it will be clamped.
1750  */
1751 static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
1752                                                     int64_t sector_num,
1753                                                     int nb_sectors, int *pnum,
1754                                                     BlockDriverState **file)
1755 {
1756     off_t start, data = 0, hole = 0;
1757     int64_t total_size;
1758     int ret;
1759
1760     ret = fd_open(bs);
1761     if (ret < 0) {
1762         return ret;
1763     }
1764
1765     start = sector_num * BDRV_SECTOR_SIZE;
1766     total_size = bdrv_getlength(bs);
1767     if (total_size < 0) {
1768         return total_size;
1769     } else if (start >= total_size) {
1770         *pnum = 0;
1771         return 0;
1772     } else if (start + nb_sectors * BDRV_SECTOR_SIZE > total_size) {
1773         nb_sectors = DIV_ROUND_UP(total_size - start, BDRV_SECTOR_SIZE);
1774     }
1775
1776     ret = find_allocation(bs, start, &data, &hole);
1777     if (ret == -ENXIO) {
1778         /* Trailing hole */
1779         *pnum = nb_sectors;
1780         ret = BDRV_BLOCK_ZERO;
1781     } else if (ret < 0) {
1782         /* No info available, so pretend there are no holes */
1783         *pnum = nb_sectors;
1784         ret = BDRV_BLOCK_DATA;
1785     } else if (data == start) {
1786         /* On a data extent, compute sectors to the end of the extent,
1787          * possibly including a partial sector at EOF. */
1788         *pnum = MIN(nb_sectors, DIV_ROUND_UP(hole - start, BDRV_SECTOR_SIZE));
1789         ret = BDRV_BLOCK_DATA;
1790     } else {
1791         /* On a hole, compute sectors to the beginning of the next extent.  */
1792         assert(hole == start);
1793         *pnum = MIN(nb_sectors, (data - start) / BDRV_SECTOR_SIZE);
1794         ret = BDRV_BLOCK_ZERO;
1795     }
1796     *file = bs;
1797     return ret | BDRV_BLOCK_OFFSET_VALID | start;
1798 }
1799
1800 static coroutine_fn BlockAIOCB *raw_aio_pdiscard(BlockDriverState *bs,
1801     int64_t offset, int count,
1802     BlockCompletionFunc *cb, void *opaque)
1803 {
1804     BDRVRawState *s = bs->opaque;
1805
1806     return paio_submit(bs, s->fd, offset, NULL, count,
1807                        cb, opaque, QEMU_AIO_DISCARD);
1808 }
1809
1810 static int coroutine_fn raw_co_pwrite_zeroes(
1811     BlockDriverState *bs, int64_t offset,
1812     int count, BdrvRequestFlags flags)
1813 {
1814     BDRVRawState *s = bs->opaque;
1815
1816     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
1817         return paio_submit_co(bs, s->fd, offset, NULL, count,
1818                               QEMU_AIO_WRITE_ZEROES);
1819     } else if (s->discard_zeroes) {
1820         return paio_submit_co(bs, s->fd, offset, NULL, count,
1821                               QEMU_AIO_DISCARD);
1822     }
1823     return -ENOTSUP;
1824 }
1825
1826 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1827 {
1828     BDRVRawState *s = bs->opaque;
1829
1830     bdi->unallocated_blocks_are_zero = s->discard_zeroes;
1831     bdi->can_write_zeroes_with_unmap = s->discard_zeroes;
1832     return 0;
1833 }
1834
1835 static QemuOptsList raw_create_opts = {
1836     .name = "raw-create-opts",
1837     .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
1838     .desc = {
1839         {
1840             .name = BLOCK_OPT_SIZE,
1841             .type = QEMU_OPT_SIZE,
1842             .help = "Virtual disk size"
1843         },
1844         {
1845             .name = BLOCK_OPT_NOCOW,
1846             .type = QEMU_OPT_BOOL,
1847             .help = "Turn off copy-on-write (valid only on btrfs)"
1848         },
1849         {
1850             .name = BLOCK_OPT_PREALLOC,
1851             .type = QEMU_OPT_STRING,
1852             .help = "Preallocation mode (allowed values: off, falloc, full)"
1853         },
1854         { /* end of list */ }
1855     }
1856 };
1857
1858 BlockDriver bdrv_file = {
1859     .format_name = "file",
1860     .protocol_name = "file",
1861     .instance_size = sizeof(BDRVRawState),
1862     .bdrv_needs_filename = true,
1863     .bdrv_probe = NULL, /* no probe for protocols */
1864     .bdrv_parse_filename = raw_parse_filename,
1865     .bdrv_file_open = raw_open,
1866     .bdrv_reopen_prepare = raw_reopen_prepare,
1867     .bdrv_reopen_commit = raw_reopen_commit,
1868     .bdrv_reopen_abort = raw_reopen_abort,
1869     .bdrv_close = raw_close,
1870     .bdrv_create = raw_create,
1871     .bdrv_has_zero_init = bdrv_has_zero_init_1,
1872     .bdrv_co_get_block_status = raw_co_get_block_status,
1873     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
1874
1875     .bdrv_co_preadv         = raw_co_preadv,
1876     .bdrv_co_pwritev        = raw_co_pwritev,
1877     .bdrv_aio_flush = raw_aio_flush,
1878     .bdrv_aio_pdiscard = raw_aio_pdiscard,
1879     .bdrv_refresh_limits = raw_refresh_limits,
1880     .bdrv_io_plug = raw_aio_plug,
1881     .bdrv_io_unplug = raw_aio_unplug,
1882
1883     .bdrv_truncate = raw_truncate,
1884     .bdrv_getlength = raw_getlength,
1885     .bdrv_get_info = raw_get_info,
1886     .bdrv_get_allocated_file_size
1887                         = raw_get_allocated_file_size,
1888
1889     .create_opts = &raw_create_opts,
1890 };
1891
1892 /***********************************************/
1893 /* host device */
1894
1895 #if defined(__APPLE__) && defined(__MACH__)
1896 static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
1897                                 CFIndex maxPathSize, int flags);
1898 static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
1899 {
1900     kern_return_t kernResult = KERN_FAILURE;
1901     mach_port_t     masterPort;
1902     CFMutableDictionaryRef  classesToMatch;
1903     const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
1904     char *mediaType = NULL;
1905
1906     kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
1907     if ( KERN_SUCCESS != kernResult ) {
1908         printf( "IOMasterPort returned %d\n", kernResult );
1909     }
1910
1911     int index;
1912     for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
1913         classesToMatch = IOServiceMatching(matching_array[index]);
1914         if (classesToMatch == NULL) {
1915             error_report("IOServiceMatching returned NULL for %s",
1916                          matching_array[index]);
1917             continue;
1918         }
1919         CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
1920                              kCFBooleanTrue);
1921         kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
1922                                                   mediaIterator);
1923         if (kernResult != KERN_SUCCESS) {
1924             error_report("Note: IOServiceGetMatchingServices returned %d",
1925                          kernResult);
1926             continue;
1927         }
1928
1929         /* If a match was found, leave the loop */
1930         if (*mediaIterator != 0) {
1931             DPRINTF("Matching using %s\n", matching_array[index]);
1932             mediaType = g_strdup(matching_array[index]);
1933             break;
1934         }
1935     }
1936     return mediaType;
1937 }
1938
1939 kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
1940                          CFIndex maxPathSize, int flags)
1941 {
1942     io_object_t     nextMedia;
1943     kern_return_t   kernResult = KERN_FAILURE;
1944     *bsdPath = '\0';
1945     nextMedia = IOIteratorNext( mediaIterator );
1946     if ( nextMedia )
1947     {
1948         CFTypeRef   bsdPathAsCFString;
1949     bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
1950         if ( bsdPathAsCFString ) {
1951             size_t devPathLength;
1952             strcpy( bsdPath, _PATH_DEV );
1953             if (flags & BDRV_O_NOCACHE) {
1954                 strcat(bsdPath, "r");
1955             }
1956             devPathLength = strlen( bsdPath );
1957             if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
1958                 kernResult = KERN_SUCCESS;
1959             }
1960             CFRelease( bsdPathAsCFString );
1961         }
1962         IOObjectRelease( nextMedia );
1963     }
1964
1965     return kernResult;
1966 }
1967
1968 /* Sets up a real cdrom for use in QEMU */
1969 static bool setup_cdrom(char *bsd_path, Error **errp)
1970 {
1971     int index, num_of_test_partitions = 2, fd;
1972     char test_partition[MAXPATHLEN];
1973     bool partition_found = false;
1974
1975     /* look for a working partition */
1976     for (index = 0; index < num_of_test_partitions; index++) {
1977         snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
1978                  index);
1979         fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE);
1980         if (fd >= 0) {
1981             partition_found = true;
1982             qemu_close(fd);
1983             break;
1984         }
1985     }
1986
1987     /* if a working partition on the device was not found */
1988     if (partition_found == false) {
1989         error_setg(errp, "Failed to find a working partition on disc");
1990     } else {
1991         DPRINTF("Using %s as optical disc\n", test_partition);
1992         pstrcpy(bsd_path, MAXPATHLEN, test_partition);
1993     }
1994     return partition_found;
1995 }
1996
1997 /* Prints directions on mounting and unmounting a device */
1998 static void print_unmounting_directions(const char *file_name)
1999 {
2000     error_report("If device %s is mounted on the desktop, unmount"
2001                  " it first before using it in QEMU", file_name);
2002     error_report("Command to unmount device: diskutil unmountDisk %s",
2003                  file_name);
2004     error_report("Command to mount device: diskutil mountDisk %s", file_name);
2005 }
2006
2007 #endif /* defined(__APPLE__) && defined(__MACH__) */
2008
2009 static int hdev_probe_device(const char *filename)
2010 {
2011     struct stat st;
2012
2013     /* allow a dedicated CD-ROM driver to match with a higher priority */
2014     if (strstart(filename, "/dev/cdrom", NULL))
2015         return 50;
2016
2017     if (stat(filename, &st) >= 0 &&
2018             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
2019         return 100;
2020     }
2021
2022     return 0;
2023 }
2024
2025 static int check_hdev_writable(BDRVRawState *s)
2026 {
2027 #if defined(BLKROGET)
2028     /* Linux block devices can be configured "read-only" using blockdev(8).
2029      * This is independent of device node permissions and therefore open(2)
2030      * with O_RDWR succeeds.  Actual writes fail with EPERM.
2031      *
2032      * bdrv_open() is supposed to fail if the disk is read-only.  Explicitly
2033      * check for read-only block devices so that Linux block devices behave
2034      * properly.
2035      */
2036     struct stat st;
2037     int readonly = 0;
2038
2039     if (fstat(s->fd, &st)) {
2040         return -errno;
2041     }
2042
2043     if (!S_ISBLK(st.st_mode)) {
2044         return 0;
2045     }
2046
2047     if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
2048         return -errno;
2049     }
2050
2051     if (readonly) {
2052         return -EACCES;
2053     }
2054 #endif /* defined(BLKROGET) */
2055     return 0;
2056 }
2057
2058 static void hdev_parse_filename(const char *filename, QDict *options,
2059                                 Error **errp)
2060 {
2061     /* The prefix is optional, just as for "file". */
2062     strstart(filename, "host_device:", &filename);
2063
2064     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
2065 }
2066
2067 static bool hdev_is_sg(BlockDriverState *bs)
2068 {
2069
2070 #if defined(__linux__)
2071
2072     BDRVRawState *s = bs->opaque;
2073     struct stat st;
2074     struct sg_scsi_id scsiid;
2075     int sg_version;
2076     int ret;
2077
2078     if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
2079         return false;
2080     }
2081
2082     ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
2083     if (ret < 0) {
2084         return false;
2085     }
2086
2087     ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
2088     if (ret >= 0) {
2089         DPRINTF("SG device found: type=%d, version=%d\n",
2090             scsiid.scsi_type, sg_version);
2091         return true;
2092     }
2093
2094 #endif
2095
2096     return false;
2097 }
2098
2099 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
2100                      Error **errp)
2101 {
2102     BDRVRawState *s = bs->opaque;
2103     Error *local_err = NULL;
2104     int ret;
2105
2106 #if defined(__APPLE__) && defined(__MACH__)
2107     const char *filename = qdict_get_str(options, "filename");
2108     char bsd_path[MAXPATHLEN] = "";
2109     bool error_occurred = false;
2110
2111     /* If using a real cdrom */
2112     if (strcmp(filename, "/dev/cdrom") == 0) {
2113         char *mediaType = NULL;
2114         kern_return_t ret_val;
2115         io_iterator_t mediaIterator = 0;
2116
2117         mediaType = FindEjectableOpticalMedia(&mediaIterator);
2118         if (mediaType == NULL) {
2119             error_setg(errp, "Please make sure your CD/DVD is in the optical"
2120                        " drive");
2121             error_occurred = true;
2122             goto hdev_open_Mac_error;
2123         }
2124
2125         ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
2126         if (ret_val != KERN_SUCCESS) {
2127             error_setg(errp, "Could not get BSD path for optical drive");
2128             error_occurred = true;
2129             goto hdev_open_Mac_error;
2130         }
2131
2132         /* If a real optical drive was not found */
2133         if (bsd_path[0] == '\0') {
2134             error_setg(errp, "Failed to obtain bsd path for optical drive");
2135             error_occurred = true;
2136             goto hdev_open_Mac_error;
2137         }
2138
2139         /* If using a cdrom disc and finding a partition on the disc failed */
2140         if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
2141             setup_cdrom(bsd_path, errp) == false) {
2142             print_unmounting_directions(bsd_path);
2143             error_occurred = true;
2144             goto hdev_open_Mac_error;
2145         }
2146
2147         qdict_put(options, "filename", qstring_from_str(bsd_path));
2148
2149 hdev_open_Mac_error:
2150         g_free(mediaType);
2151         if (mediaIterator) {
2152             IOObjectRelease(mediaIterator);
2153         }
2154         if (error_occurred) {
2155             return -ENOENT;
2156         }
2157     }
2158 #endif /* defined(__APPLE__) && defined(__MACH__) */
2159
2160     s->type = FTYPE_FILE;
2161
2162     ret = raw_open_common(bs, options, flags, 0, &local_err);
2163     if (ret < 0) {
2164         error_propagate(errp, local_err);
2165 #if defined(__APPLE__) && defined(__MACH__)
2166         if (*bsd_path) {
2167             filename = bsd_path;
2168         }
2169         /* if a physical device experienced an error while being opened */
2170         if (strncmp(filename, "/dev/", 5) == 0) {
2171             print_unmounting_directions(filename);
2172         }
2173 #endif /* defined(__APPLE__) && defined(__MACH__) */
2174         return ret;
2175     }
2176
2177     /* Since this does ioctl the device must be already opened */
2178     bs->sg = hdev_is_sg(bs);
2179
2180     if (flags & BDRV_O_RDWR) {
2181         ret = check_hdev_writable(s);
2182         if (ret < 0) {
2183             raw_close(bs);
2184             error_setg_errno(errp, -ret, "The device is not writable");
2185             return ret;
2186         }
2187     }
2188
2189     return ret;
2190 }
2191
2192 #if defined(__linux__)
2193
2194 static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
2195         unsigned long int req, void *buf,
2196         BlockCompletionFunc *cb, void *opaque)
2197 {
2198     BDRVRawState *s = bs->opaque;
2199     RawPosixAIOData *acb;
2200     ThreadPool *pool;
2201
2202     if (fd_open(bs) < 0)
2203         return NULL;
2204
2205     acb = g_new(RawPosixAIOData, 1);
2206     acb->bs = bs;
2207     acb->aio_type = QEMU_AIO_IOCTL;
2208     acb->aio_fildes = s->fd;
2209     acb->aio_offset = 0;
2210     acb->aio_ioctl_buf = buf;
2211     acb->aio_ioctl_cmd = req;
2212     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
2213     return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
2214 }
2215 #endif /* linux */
2216
2217 static int fd_open(BlockDriverState *bs)
2218 {
2219     BDRVRawState *s = bs->opaque;
2220
2221     /* this is just to ensure s->fd is sane (its called by io ops) */
2222     if (s->fd >= 0)
2223         return 0;
2224     return -EIO;
2225 }
2226
2227 static coroutine_fn BlockAIOCB *hdev_aio_pdiscard(BlockDriverState *bs,
2228     int64_t offset, int count,
2229     BlockCompletionFunc *cb, void *opaque)
2230 {
2231     BDRVRawState *s = bs->opaque;
2232
2233     if (fd_open(bs) < 0) {
2234         return NULL;
2235     }
2236     return paio_submit(bs, s->fd, offset, NULL, count,
2237                        cb, opaque, QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
2238 }
2239
2240 static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
2241     int64_t offset, int count, BdrvRequestFlags flags)
2242 {
2243     BDRVRawState *s = bs->opaque;
2244     int rc;
2245
2246     rc = fd_open(bs);
2247     if (rc < 0) {
2248         return rc;
2249     }
2250     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
2251         return paio_submit_co(bs, s->fd, offset, NULL, count,
2252                               QEMU_AIO_WRITE_ZEROES|QEMU_AIO_BLKDEV);
2253     } else if (s->discard_zeroes) {
2254         return paio_submit_co(bs, s->fd, offset, NULL, count,
2255                               QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
2256     }
2257     return -ENOTSUP;
2258 }
2259
2260 static int hdev_create(const char *filename, QemuOpts *opts,
2261                        Error **errp)
2262 {
2263     int fd;
2264     int ret = 0;
2265     struct stat stat_buf;
2266     int64_t total_size = 0;
2267     bool has_prefix;
2268
2269     /* This function is used by both protocol block drivers and therefore either
2270      * of these prefixes may be given.
2271      * The return value has to be stored somewhere, otherwise this is an error
2272      * due to -Werror=unused-value. */
2273     has_prefix =
2274         strstart(filename, "host_device:", &filename) ||
2275         strstart(filename, "host_cdrom:" , &filename);
2276
2277     (void)has_prefix;
2278
2279     ret = raw_normalize_devicepath(&filename);
2280     if (ret < 0) {
2281         error_setg_errno(errp, -ret, "Could not normalize device path");
2282         return ret;
2283     }
2284
2285     /* Read out options */
2286     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2287                           BDRV_SECTOR_SIZE);
2288
2289     fd = qemu_open(filename, O_WRONLY | O_BINARY);
2290     if (fd < 0) {
2291         ret = -errno;
2292         error_setg_errno(errp, -ret, "Could not open device");
2293         return ret;
2294     }
2295
2296     if (fstat(fd, &stat_buf) < 0) {
2297         ret = -errno;
2298         error_setg_errno(errp, -ret, "Could not stat device");
2299     } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
2300         error_setg(errp,
2301                    "The given file is neither a block nor a character device");
2302         ret = -ENODEV;
2303     } else if (lseek(fd, 0, SEEK_END) < total_size) {
2304         error_setg(errp, "Device is too small");
2305         ret = -ENOSPC;
2306     }
2307
2308     qemu_close(fd);
2309     return ret;
2310 }
2311
2312 static BlockDriver bdrv_host_device = {
2313     .format_name        = "host_device",
2314     .protocol_name        = "host_device",
2315     .instance_size      = sizeof(BDRVRawState),
2316     .bdrv_needs_filename = true,
2317     .bdrv_probe_device  = hdev_probe_device,
2318     .bdrv_parse_filename = hdev_parse_filename,
2319     .bdrv_file_open     = hdev_open,
2320     .bdrv_close         = raw_close,
2321     .bdrv_reopen_prepare = raw_reopen_prepare,
2322     .bdrv_reopen_commit  = raw_reopen_commit,
2323     .bdrv_reopen_abort   = raw_reopen_abort,
2324     .bdrv_create         = hdev_create,
2325     .create_opts         = &raw_create_opts,
2326     .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
2327
2328     .bdrv_co_preadv         = raw_co_preadv,
2329     .bdrv_co_pwritev        = raw_co_pwritev,
2330     .bdrv_aio_flush     = raw_aio_flush,
2331     .bdrv_aio_pdiscard   = hdev_aio_pdiscard,
2332     .bdrv_refresh_limits = raw_refresh_limits,
2333     .bdrv_io_plug = raw_aio_plug,
2334     .bdrv_io_unplug = raw_aio_unplug,
2335
2336     .bdrv_truncate      = raw_truncate,
2337     .bdrv_getlength     = raw_getlength,
2338     .bdrv_get_info = raw_get_info,
2339     .bdrv_get_allocated_file_size
2340                         = raw_get_allocated_file_size,
2341     .bdrv_probe_blocksizes = hdev_probe_blocksizes,
2342     .bdrv_probe_geometry = hdev_probe_geometry,
2343
2344     /* generic scsi device */
2345 #ifdef __linux__
2346     .bdrv_aio_ioctl     = hdev_aio_ioctl,
2347 #endif
2348 };
2349
2350 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2351 static void cdrom_parse_filename(const char *filename, QDict *options,
2352                                  Error **errp)
2353 {
2354     /* The prefix is optional, just as for "file". */
2355     strstart(filename, "host_cdrom:", &filename);
2356
2357     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
2358 }
2359 #endif
2360
2361 #ifdef __linux__
2362 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
2363                       Error **errp)
2364 {
2365     BDRVRawState *s = bs->opaque;
2366
2367     s->type = FTYPE_CD;
2368
2369     /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
2370     return raw_open_common(bs, options, flags, O_NONBLOCK, errp);
2371 }
2372
2373 static int cdrom_probe_device(const char *filename)
2374 {
2375     int fd, ret;
2376     int prio = 0;
2377     struct stat st;
2378
2379     fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
2380     if (fd < 0) {
2381         goto out;
2382     }
2383     ret = fstat(fd, &st);
2384     if (ret == -1 || !S_ISBLK(st.st_mode)) {
2385         goto outc;
2386     }
2387
2388     /* Attempt to detect via a CDROM specific ioctl */
2389     ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2390     if (ret >= 0)
2391         prio = 100;
2392
2393 outc:
2394     qemu_close(fd);
2395 out:
2396     return prio;
2397 }
2398
2399 static bool cdrom_is_inserted(BlockDriverState *bs)
2400 {
2401     BDRVRawState *s = bs->opaque;
2402     int ret;
2403
2404     ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2405     return ret == CDS_DISC_OK;
2406 }
2407
2408 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2409 {
2410     BDRVRawState *s = bs->opaque;
2411
2412     if (eject_flag) {
2413         if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
2414             perror("CDROMEJECT");
2415     } else {
2416         if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
2417             perror("CDROMEJECT");
2418     }
2419 }
2420
2421 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2422 {
2423     BDRVRawState *s = bs->opaque;
2424
2425     if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
2426         /*
2427          * Note: an error can happen if the distribution automatically
2428          * mounts the CD-ROM
2429          */
2430         /* perror("CDROM_LOCKDOOR"); */
2431     }
2432 }
2433
2434 static BlockDriver bdrv_host_cdrom = {
2435     .format_name        = "host_cdrom",
2436     .protocol_name      = "host_cdrom",
2437     .instance_size      = sizeof(BDRVRawState),
2438     .bdrv_needs_filename = true,
2439     .bdrv_probe_device  = cdrom_probe_device,
2440     .bdrv_parse_filename = cdrom_parse_filename,
2441     .bdrv_file_open     = cdrom_open,
2442     .bdrv_close         = raw_close,
2443     .bdrv_reopen_prepare = raw_reopen_prepare,
2444     .bdrv_reopen_commit  = raw_reopen_commit,
2445     .bdrv_reopen_abort   = raw_reopen_abort,
2446     .bdrv_create         = hdev_create,
2447     .create_opts         = &raw_create_opts,
2448
2449
2450     .bdrv_co_preadv         = raw_co_preadv,
2451     .bdrv_co_pwritev        = raw_co_pwritev,
2452     .bdrv_aio_flush     = raw_aio_flush,
2453     .bdrv_refresh_limits = raw_refresh_limits,
2454     .bdrv_io_plug = raw_aio_plug,
2455     .bdrv_io_unplug = raw_aio_unplug,
2456
2457     .bdrv_truncate      = raw_truncate,
2458     .bdrv_getlength      = raw_getlength,
2459     .has_variable_length = true,
2460     .bdrv_get_allocated_file_size
2461                         = raw_get_allocated_file_size,
2462
2463     /* removable device support */
2464     .bdrv_is_inserted   = cdrom_is_inserted,
2465     .bdrv_eject         = cdrom_eject,
2466     .bdrv_lock_medium   = cdrom_lock_medium,
2467
2468     /* generic scsi device */
2469     .bdrv_aio_ioctl     = hdev_aio_ioctl,
2470 };
2471 #endif /* __linux__ */
2472
2473 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2474 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
2475                       Error **errp)
2476 {
2477     BDRVRawState *s = bs->opaque;
2478     Error *local_err = NULL;
2479     int ret;
2480
2481     s->type = FTYPE_CD;
2482
2483     ret = raw_open_common(bs, options, flags, 0, &local_err);
2484     if (ret) {
2485         error_propagate(errp, local_err);
2486         return ret;
2487     }
2488
2489     /* make sure the door isn't locked at this time */
2490     ioctl(s->fd, CDIOCALLOW);
2491     return 0;
2492 }
2493
2494 static int cdrom_probe_device(const char *filename)
2495 {
2496     if (strstart(filename, "/dev/cd", NULL) ||
2497             strstart(filename, "/dev/acd", NULL))
2498         return 100;
2499     return 0;
2500 }
2501
2502 static int cdrom_reopen(BlockDriverState *bs)
2503 {
2504     BDRVRawState *s = bs->opaque;
2505     int fd;
2506
2507     /*
2508      * Force reread of possibly changed/newly loaded disc,
2509      * FreeBSD seems to not notice sometimes...
2510      */
2511     if (s->fd >= 0)
2512         qemu_close(s->fd);
2513     fd = qemu_open(bs->filename, s->open_flags, 0644);
2514     if (fd < 0) {
2515         s->fd = -1;
2516         return -EIO;
2517     }
2518     s->fd = fd;
2519
2520     /* make sure the door isn't locked at this time */
2521     ioctl(s->fd, CDIOCALLOW);
2522     return 0;
2523 }
2524
2525 static bool cdrom_is_inserted(BlockDriverState *bs)
2526 {
2527     return raw_getlength(bs) > 0;
2528 }
2529
2530 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2531 {
2532     BDRVRawState *s = bs->opaque;
2533
2534     if (s->fd < 0)
2535         return;
2536
2537     (void) ioctl(s->fd, CDIOCALLOW);
2538
2539     if (eject_flag) {
2540         if (ioctl(s->fd, CDIOCEJECT) < 0)
2541             perror("CDIOCEJECT");
2542     } else {
2543         if (ioctl(s->fd, CDIOCCLOSE) < 0)
2544             perror("CDIOCCLOSE");
2545     }
2546
2547     cdrom_reopen(bs);
2548 }
2549
2550 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2551 {
2552     BDRVRawState *s = bs->opaque;
2553
2554     if (s->fd < 0)
2555         return;
2556     if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
2557         /*
2558          * Note: an error can happen if the distribution automatically
2559          * mounts the CD-ROM
2560          */
2561         /* perror("CDROM_LOCKDOOR"); */
2562     }
2563 }
2564
2565 static BlockDriver bdrv_host_cdrom = {
2566     .format_name        = "host_cdrom",
2567     .protocol_name      = "host_cdrom",
2568     .instance_size      = sizeof(BDRVRawState),
2569     .bdrv_needs_filename = true,
2570     .bdrv_probe_device  = cdrom_probe_device,
2571     .bdrv_parse_filename = cdrom_parse_filename,
2572     .bdrv_file_open     = cdrom_open,
2573     .bdrv_close         = raw_close,
2574     .bdrv_reopen_prepare = raw_reopen_prepare,
2575     .bdrv_reopen_commit  = raw_reopen_commit,
2576     .bdrv_reopen_abort   = raw_reopen_abort,
2577     .bdrv_create        = hdev_create,
2578     .create_opts        = &raw_create_opts,
2579
2580     .bdrv_co_preadv         = raw_co_preadv,
2581     .bdrv_co_pwritev        = raw_co_pwritev,
2582     .bdrv_aio_flush     = raw_aio_flush,
2583     .bdrv_refresh_limits = raw_refresh_limits,
2584     .bdrv_io_plug = raw_aio_plug,
2585     .bdrv_io_unplug = raw_aio_unplug,
2586
2587     .bdrv_truncate      = raw_truncate,
2588     .bdrv_getlength      = raw_getlength,
2589     .has_variable_length = true,
2590     .bdrv_get_allocated_file_size
2591                         = raw_get_allocated_file_size,
2592
2593     /* removable device support */
2594     .bdrv_is_inserted   = cdrom_is_inserted,
2595     .bdrv_eject         = cdrom_eject,
2596     .bdrv_lock_medium   = cdrom_lock_medium,
2597 };
2598 #endif /* __FreeBSD__ */
2599
2600 static void bdrv_file_init(void)
2601 {
2602     /*
2603      * Register all the drivers.  Note that order is important, the driver
2604      * registered last will get probed first.
2605      */
2606     bdrv_register(&bdrv_file);
2607     bdrv_register(&bdrv_host_device);
2608 #ifdef __linux__
2609     bdrv_register(&bdrv_host_cdrom);
2610 #endif
2611 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2612     bdrv_register(&bdrv_host_cdrom);
2613 #endif
2614 }
2615
2616 block_init(bdrv_file_init);