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