1688e16c6481cf121b9971a11cc39c0342278637
[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
34 #if defined(__APPLE__) && (__MACH__)
35 #include <paths.h>
36 #include <sys/param.h>
37 #include <IOKit/IOKitLib.h>
38 #include <IOKit/IOBSD.h>
39 #include <IOKit/storage/IOMediaBSDClient.h>
40 #include <IOKit/storage/IOMedia.h>
41 #include <IOKit/storage/IOCDMedia.h>
42 //#include <IOKit/storage/IOCDTypes.h>
43 #include <CoreFoundation/CoreFoundation.h>
44 #endif
45
46 #ifdef __sun__
47 #define _POSIX_PTHREAD_SEMANTICS 1
48 #include <sys/dkio.h>
49 #endif
50 #ifdef __linux__
51 #include <sys/types.h>
52 #include <sys/stat.h>
53 #include <sys/ioctl.h>
54 #include <sys/param.h>
55 #include <linux/cdrom.h>
56 #include <linux/fd.h>
57 #include <linux/fs.h>
58 #endif
59 #ifdef CONFIG_FIEMAP
60 #include <linux/fiemap.h>
61 #endif
62 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
63 #include <linux/falloc.h>
64 #endif
65 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
66 #include <sys/disk.h>
67 #include <sys/cdio.h>
68 #endif
69
70 #ifdef __OpenBSD__
71 #include <sys/ioctl.h>
72 #include <sys/disklabel.h>
73 #include <sys/dkio.h>
74 #endif
75
76 #ifdef __NetBSD__
77 #include <sys/ioctl.h>
78 #include <sys/disklabel.h>
79 #include <sys/dkio.h>
80 #include <sys/disk.h>
81 #endif
82
83 #ifdef __DragonFly__
84 #include <sys/ioctl.h>
85 #include <sys/diskslice.h>
86 #endif
87
88 #ifdef CONFIG_XFS
89 #include <xfs/xfs.h>
90 #endif
91
92 //#define DEBUG_FLOPPY
93
94 //#define DEBUG_BLOCK
95 #if defined(DEBUG_BLOCK)
96 #define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \
97     { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0)
98 #else
99 #define DEBUG_BLOCK_PRINT(formatCstr, ...)
100 #endif
101
102 /* OS X does not have O_DSYNC */
103 #ifndef O_DSYNC
104 #ifdef O_SYNC
105 #define O_DSYNC O_SYNC
106 #elif defined(O_FSYNC)
107 #define O_DSYNC O_FSYNC
108 #endif
109 #endif
110
111 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
112 #ifndef O_DIRECT
113 #define O_DIRECT O_DSYNC
114 #endif
115
116 #define FTYPE_FILE   0
117 #define FTYPE_CD     1
118 #define FTYPE_FD     2
119
120 /* if the FD is not accessed during that time (in ns), we try to
121    reopen it to see if the disk has been changed */
122 #define FD_OPEN_TIMEOUT (1000000000)
123
124 #define MAX_BLOCKSIZE   4096
125
126 typedef struct BDRVRawState {
127     int fd;
128     int type;
129     int open_flags;
130     size_t buf_align;
131
132 #if defined(__linux__)
133     /* linux floppy specific */
134     int64_t fd_open_time;
135     int64_t fd_error_time;
136     int fd_got_error;
137     int fd_media_changed;
138 #endif
139 #ifdef CONFIG_LINUX_AIO
140     int use_aio;
141     void *aio_ctx;
142 #endif
143 #ifdef CONFIG_XFS
144     bool is_xfs:1;
145 #endif
146     bool has_discard:1;
147     bool has_write_zeroes:1;
148     bool discard_zeroes:1;
149 } BDRVRawState;
150
151 typedef struct BDRVRawReopenState {
152     int fd;
153     int open_flags;
154 #ifdef CONFIG_LINUX_AIO
155     int use_aio;
156 #endif
157 } BDRVRawReopenState;
158
159 static int fd_open(BlockDriverState *bs);
160 static int64_t raw_getlength(BlockDriverState *bs);
161
162 typedef struct RawPosixAIOData {
163     BlockDriverState *bs;
164     int aio_fildes;
165     union {
166         struct iovec *aio_iov;
167         void *aio_ioctl_buf;
168     };
169     int aio_niov;
170     uint64_t aio_nbytes;
171 #define aio_ioctl_cmd   aio_nbytes /* for QEMU_AIO_IOCTL */
172     off_t aio_offset;
173     int aio_type;
174 } RawPosixAIOData;
175
176 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
177 static int cdrom_reopen(BlockDriverState *bs);
178 #endif
179
180 #if defined(__NetBSD__)
181 static int raw_normalize_devicepath(const char **filename)
182 {
183     static char namebuf[PATH_MAX];
184     const char *dp, *fname;
185     struct stat sb;
186
187     fname = *filename;
188     dp = strrchr(fname, '/');
189     if (lstat(fname, &sb) < 0) {
190         fprintf(stderr, "%s: stat failed: %s\n",
191             fname, strerror(errno));
192         return -errno;
193     }
194
195     if (!S_ISBLK(sb.st_mode)) {
196         return 0;
197     }
198
199     if (dp == NULL) {
200         snprintf(namebuf, PATH_MAX, "r%s", fname);
201     } else {
202         snprintf(namebuf, PATH_MAX, "%.*s/r%s",
203             (int)(dp - fname), fname, dp + 1);
204     }
205     fprintf(stderr, "%s is a block device", fname);
206     *filename = namebuf;
207     fprintf(stderr, ", using %s\n", *filename);
208
209     return 0;
210 }
211 #else
212 static int raw_normalize_devicepath(const char **filename)
213 {
214     return 0;
215 }
216 #endif
217
218 static void raw_probe_alignment(BlockDriverState *bs)
219 {
220     BDRVRawState *s = bs->opaque;
221     char *buf;
222     unsigned int sector_size;
223
224     /* For /dev/sg devices the alignment is not really used.
225        With buffered I/O, we don't have any restrictions. */
226     if (bs->sg || !(s->open_flags & O_DIRECT)) {
227         bs->request_alignment = 1;
228         s->buf_align = 1;
229         return;
230     }
231
232     /* Try a few ioctls to get the right size */
233     bs->request_alignment = 0;
234     s->buf_align = 0;
235
236 #ifdef BLKSSZGET
237     if (ioctl(s->fd, BLKSSZGET, &sector_size) >= 0) {
238         bs->request_alignment = sector_size;
239     }
240 #endif
241 #ifdef DKIOCGETBLOCKSIZE
242     if (ioctl(s->fd, DKIOCGETBLOCKSIZE, &sector_size) >= 0) {
243         bs->request_alignment = sector_size;
244     }
245 #endif
246 #ifdef DIOCGSECTORSIZE
247     if (ioctl(s->fd, DIOCGSECTORSIZE, &sector_size) >= 0) {
248         bs->request_alignment = sector_size;
249     }
250 #endif
251 #ifdef CONFIG_XFS
252     if (s->is_xfs) {
253         struct dioattr da;
254         if (xfsctl(NULL, s->fd, XFS_IOC_DIOINFO, &da) >= 0) {
255             bs->request_alignment = da.d_miniosz;
256             /* The kernel returns wrong information for d_mem */
257             /* s->buf_align = da.d_mem; */
258         }
259     }
260 #endif
261
262     /* If we could not get the sizes so far, we can only guess them */
263     if (!s->buf_align) {
264         size_t align;
265         buf = qemu_memalign(MAX_BLOCKSIZE, 2 * MAX_BLOCKSIZE);
266         for (align = 512; align <= MAX_BLOCKSIZE; align <<= 1) {
267             if (pread(s->fd, buf + align, MAX_BLOCKSIZE, 0) >= 0) {
268                 s->buf_align = align;
269                 break;
270             }
271         }
272         qemu_vfree(buf);
273     }
274
275     if (!bs->request_alignment) {
276         size_t align;
277         buf = qemu_memalign(s->buf_align, MAX_BLOCKSIZE);
278         for (align = 512; align <= MAX_BLOCKSIZE; align <<= 1) {
279             if (pread(s->fd, buf, align, 0) >= 0) {
280                 bs->request_alignment = align;
281                 break;
282             }
283         }
284         qemu_vfree(buf);
285     }
286 }
287
288 static void raw_parse_flags(int bdrv_flags, int *open_flags)
289 {
290     assert(open_flags != NULL);
291
292     *open_flags |= O_BINARY;
293     *open_flags &= ~O_ACCMODE;
294     if (bdrv_flags & BDRV_O_RDWR) {
295         *open_flags |= O_RDWR;
296     } else {
297         *open_flags |= O_RDONLY;
298     }
299
300     /* Use O_DSYNC for write-through caching, no flags for write-back caching,
301      * and O_DIRECT for no caching. */
302     if ((bdrv_flags & BDRV_O_NOCACHE)) {
303         *open_flags |= O_DIRECT;
304     }
305 }
306
307 #ifdef CONFIG_LINUX_AIO
308 static int raw_set_aio(void **aio_ctx, int *use_aio, int bdrv_flags)
309 {
310     int ret = -1;
311     assert(aio_ctx != NULL);
312     assert(use_aio != NULL);
313     /*
314      * Currently Linux do AIO only for files opened with O_DIRECT
315      * specified so check NOCACHE flag too
316      */
317     if ((bdrv_flags & (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) ==
318                       (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) {
319
320         /* if non-NULL, laio_init() has already been run */
321         if (*aio_ctx == NULL) {
322             *aio_ctx = laio_init();
323             if (!*aio_ctx) {
324                 goto error;
325             }
326         }
327         *use_aio = 1;
328     } else {
329         *use_aio = 0;
330     }
331
332     ret = 0;
333
334 error:
335     return ret;
336 }
337 #endif
338
339 static void raw_parse_filename(const char *filename, QDict *options,
340                                Error **errp)
341 {
342     /* The filename does not have to be prefixed by the protocol name, since
343      * "file" is the default protocol; therefore, the return value of this
344      * function call can be ignored. */
345     strstart(filename, "file:", &filename);
346
347     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
348 }
349
350 static QemuOptsList raw_runtime_opts = {
351     .name = "raw",
352     .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
353     .desc = {
354         {
355             .name = "filename",
356             .type = QEMU_OPT_STRING,
357             .help = "File name of the image",
358         },
359         { /* end of list */ }
360     },
361 };
362
363 static int raw_open_common(BlockDriverState *bs, QDict *options,
364                            int bdrv_flags, int open_flags, Error **errp)
365 {
366     BDRVRawState *s = bs->opaque;
367     QemuOpts *opts;
368     Error *local_err = NULL;
369     const char *filename;
370     int fd, ret;
371     struct stat st;
372
373     opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
374     qemu_opts_absorb_qdict(opts, options, &local_err);
375     if (local_err) {
376         error_propagate(errp, local_err);
377         ret = -EINVAL;
378         goto fail;
379     }
380
381     filename = qemu_opt_get(opts, "filename");
382
383     ret = raw_normalize_devicepath(&filename);
384     if (ret != 0) {
385         error_setg_errno(errp, -ret, "Could not normalize device path");
386         goto fail;
387     }
388
389     s->open_flags = open_flags;
390     raw_parse_flags(bdrv_flags, &s->open_flags);
391
392     s->fd = -1;
393     fd = qemu_open(filename, s->open_flags, 0644);
394     if (fd < 0) {
395         ret = -errno;
396         if (ret == -EROFS) {
397             ret = -EACCES;
398         }
399         goto fail;
400     }
401     s->fd = fd;
402
403 #ifdef CONFIG_LINUX_AIO
404     if (raw_set_aio(&s->aio_ctx, &s->use_aio, bdrv_flags)) {
405         qemu_close(fd);
406         ret = -errno;
407         error_setg_errno(errp, -ret, "Could not set AIO state");
408         goto fail;
409     }
410 #endif
411
412     s->has_discard = true;
413     s->has_write_zeroes = true;
414
415     if (fstat(s->fd, &st) < 0) {
416         error_setg_errno(errp, errno, "Could not stat file");
417         goto fail;
418     }
419     if (S_ISREG(st.st_mode)) {
420         s->discard_zeroes = true;
421     }
422     if (S_ISBLK(st.st_mode)) {
423 #ifdef BLKDISCARDZEROES
424         unsigned int arg;
425         if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
426             s->discard_zeroes = true;
427         }
428 #endif
429 #ifdef __linux__
430         /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache.  Do
431          * not rely on the contents of discarded blocks unless using O_DIRECT.
432          * Same for BLKZEROOUT.
433          */
434         if (!(bs->open_flags & BDRV_O_NOCACHE)) {
435             s->discard_zeroes = false;
436             s->has_write_zeroes = false;
437         }
438 #endif
439     }
440
441 #ifdef CONFIG_XFS
442     if (platform_test_xfs_fd(s->fd)) {
443         s->is_xfs = true;
444     }
445 #endif
446
447     ret = 0;
448 fail:
449     qemu_opts_del(opts);
450     return ret;
451 }
452
453 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
454                     Error **errp)
455 {
456     BDRVRawState *s = bs->opaque;
457     Error *local_err = NULL;
458     int ret;
459
460     s->type = FTYPE_FILE;
461     ret = raw_open_common(bs, options, flags, 0, &local_err);
462     if (local_err) {
463         error_propagate(errp, local_err);
464     }
465     return ret;
466 }
467
468 static int raw_reopen_prepare(BDRVReopenState *state,
469                               BlockReopenQueue *queue, Error **errp)
470 {
471     BDRVRawState *s;
472     BDRVRawReopenState *raw_s;
473     int ret = 0;
474
475     assert(state != NULL);
476     assert(state->bs != NULL);
477
478     s = state->bs->opaque;
479
480     state->opaque = g_malloc0(sizeof(BDRVRawReopenState));
481     raw_s = state->opaque;
482
483 #ifdef CONFIG_LINUX_AIO
484     raw_s->use_aio = s->use_aio;
485
486     /* we can use s->aio_ctx instead of a copy, because the use_aio flag is
487      * valid in the 'false' condition even if aio_ctx is set, and raw_set_aio()
488      * won't override aio_ctx if aio_ctx is non-NULL */
489     if (raw_set_aio(&s->aio_ctx, &raw_s->use_aio, state->flags)) {
490         error_setg(errp, "Could not set AIO state");
491         return -1;
492     }
493 #endif
494
495     if (s->type == FTYPE_FD || s->type == FTYPE_CD) {
496         raw_s->open_flags |= O_NONBLOCK;
497     }
498
499     raw_parse_flags(state->flags, &raw_s->open_flags);
500
501     raw_s->fd = -1;
502
503     int fcntl_flags = O_APPEND | O_NONBLOCK;
504 #ifdef O_NOATIME
505     fcntl_flags |= O_NOATIME;
506 #endif
507
508 #ifdef O_ASYNC
509     /* Not all operating systems have O_ASYNC, and those that don't
510      * will not let us track the state into raw_s->open_flags (typically
511      * you achieve the same effect with an ioctl, for example I_SETSIG
512      * on Solaris). But we do not use O_ASYNC, so that's fine.
513      */
514     assert((s->open_flags & O_ASYNC) == 0);
515 #endif
516
517     if ((raw_s->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
518         /* dup the original fd */
519         /* TODO: use qemu fcntl wrapper */
520 #ifdef F_DUPFD_CLOEXEC
521         raw_s->fd = fcntl(s->fd, F_DUPFD_CLOEXEC, 0);
522 #else
523         raw_s->fd = dup(s->fd);
524         if (raw_s->fd != -1) {
525             qemu_set_cloexec(raw_s->fd);
526         }
527 #endif
528         if (raw_s->fd >= 0) {
529             ret = fcntl_setfl(raw_s->fd, raw_s->open_flags);
530             if (ret) {
531                 qemu_close(raw_s->fd);
532                 raw_s->fd = -1;
533             }
534         }
535     }
536
537     /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
538     if (raw_s->fd == -1) {
539         assert(!(raw_s->open_flags & O_CREAT));
540         raw_s->fd = qemu_open(state->bs->filename, raw_s->open_flags);
541         if (raw_s->fd == -1) {
542             error_setg_errno(errp, errno, "Could not reopen file");
543             ret = -1;
544         }
545     }
546     return ret;
547 }
548
549 static void raw_reopen_commit(BDRVReopenState *state)
550 {
551     BDRVRawReopenState *raw_s = state->opaque;
552     BDRVRawState *s = state->bs->opaque;
553
554     s->open_flags = raw_s->open_flags;
555
556     qemu_close(s->fd);
557     s->fd = raw_s->fd;
558 #ifdef CONFIG_LINUX_AIO
559     s->use_aio = raw_s->use_aio;
560 #endif
561
562     g_free(state->opaque);
563     state->opaque = NULL;
564 }
565
566
567 static void raw_reopen_abort(BDRVReopenState *state)
568 {
569     BDRVRawReopenState *raw_s = state->opaque;
570
571      /* nothing to do if NULL, we didn't get far enough */
572     if (raw_s == NULL) {
573         return;
574     }
575
576     if (raw_s->fd >= 0) {
577         qemu_close(raw_s->fd);
578         raw_s->fd = -1;
579     }
580     g_free(state->opaque);
581     state->opaque = NULL;
582 }
583
584 static int raw_refresh_limits(BlockDriverState *bs)
585 {
586     BDRVRawState *s = bs->opaque;
587
588     raw_probe_alignment(bs);
589     bs->bl.opt_mem_alignment = s->buf_align;
590
591     return 0;
592 }
593
594 static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb)
595 {
596     int ret;
597
598     ret = ioctl(aiocb->aio_fildes, aiocb->aio_ioctl_cmd, aiocb->aio_ioctl_buf);
599     if (ret == -1) {
600         return -errno;
601     }
602
603     return 0;
604 }
605
606 static ssize_t handle_aiocb_flush(RawPosixAIOData *aiocb)
607 {
608     int ret;
609
610     ret = qemu_fdatasync(aiocb->aio_fildes);
611     if (ret == -1) {
612         return -errno;
613     }
614     return 0;
615 }
616
617 #ifdef CONFIG_PREADV
618
619 static bool preadv_present = true;
620
621 static ssize_t
622 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
623 {
624     return preadv(fd, iov, nr_iov, offset);
625 }
626
627 static ssize_t
628 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
629 {
630     return pwritev(fd, iov, nr_iov, offset);
631 }
632
633 #else
634
635 static bool preadv_present = false;
636
637 static ssize_t
638 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
639 {
640     return -ENOSYS;
641 }
642
643 static ssize_t
644 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
645 {
646     return -ENOSYS;
647 }
648
649 #endif
650
651 static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
652 {
653     ssize_t len;
654
655     do {
656         if (aiocb->aio_type & QEMU_AIO_WRITE)
657             len = qemu_pwritev(aiocb->aio_fildes,
658                                aiocb->aio_iov,
659                                aiocb->aio_niov,
660                                aiocb->aio_offset);
661          else
662             len = qemu_preadv(aiocb->aio_fildes,
663                               aiocb->aio_iov,
664                               aiocb->aio_niov,
665                               aiocb->aio_offset);
666     } while (len == -1 && errno == EINTR);
667
668     if (len == -1) {
669         return -errno;
670     }
671     return len;
672 }
673
674 /*
675  * Read/writes the data to/from a given linear buffer.
676  *
677  * Returns the number of bytes handles or -errno in case of an error. Short
678  * reads are only returned if the end of the file is reached.
679  */
680 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
681 {
682     ssize_t offset = 0;
683     ssize_t len;
684
685     while (offset < aiocb->aio_nbytes) {
686         if (aiocb->aio_type & QEMU_AIO_WRITE) {
687             len = pwrite(aiocb->aio_fildes,
688                          (const char *)buf + offset,
689                          aiocb->aio_nbytes - offset,
690                          aiocb->aio_offset + offset);
691         } else {
692             len = pread(aiocb->aio_fildes,
693                         buf + offset,
694                         aiocb->aio_nbytes - offset,
695                         aiocb->aio_offset + offset);
696         }
697         if (len == -1 && errno == EINTR) {
698             continue;
699         } else if (len == -1) {
700             offset = -errno;
701             break;
702         } else if (len == 0) {
703             break;
704         }
705         offset += len;
706     }
707
708     return offset;
709 }
710
711 static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
712 {
713     ssize_t nbytes;
714     char *buf;
715
716     if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
717         /*
718          * If there is just a single buffer, and it is properly aligned
719          * we can just use plain pread/pwrite without any problems.
720          */
721         if (aiocb->aio_niov == 1) {
722              return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base);
723         }
724         /*
725          * We have more than one iovec, and all are properly aligned.
726          *
727          * Try preadv/pwritev first and fall back to linearizing the
728          * buffer if it's not supported.
729          */
730         if (preadv_present) {
731             nbytes = handle_aiocb_rw_vector(aiocb);
732             if (nbytes == aiocb->aio_nbytes ||
733                 (nbytes < 0 && nbytes != -ENOSYS)) {
734                 return nbytes;
735             }
736             preadv_present = false;
737         }
738
739         /*
740          * XXX(hch): short read/write.  no easy way to handle the reminder
741          * using these interfaces.  For now retry using plain
742          * pread/pwrite?
743          */
744     }
745
746     /*
747      * Ok, we have to do it the hard way, copy all segments into
748      * a single aligned buffer.
749      */
750     buf = qemu_blockalign(aiocb->bs, aiocb->aio_nbytes);
751     if (aiocb->aio_type & QEMU_AIO_WRITE) {
752         char *p = buf;
753         int i;
754
755         for (i = 0; i < aiocb->aio_niov; ++i) {
756             memcpy(p, aiocb->aio_iov[i].iov_base, aiocb->aio_iov[i].iov_len);
757             p += aiocb->aio_iov[i].iov_len;
758         }
759     }
760
761     nbytes = handle_aiocb_rw_linear(aiocb, buf);
762     if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
763         char *p = buf;
764         size_t count = aiocb->aio_nbytes, copy;
765         int i;
766
767         for (i = 0; i < aiocb->aio_niov && count; ++i) {
768             copy = count;
769             if (copy > aiocb->aio_iov[i].iov_len) {
770                 copy = aiocb->aio_iov[i].iov_len;
771             }
772             memcpy(aiocb->aio_iov[i].iov_base, p, copy);
773             p     += copy;
774             count -= copy;
775         }
776     }
777     qemu_vfree(buf);
778
779     return nbytes;
780 }
781
782 #ifdef CONFIG_XFS
783 static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes)
784 {
785     struct xfs_flock64 fl;
786
787     memset(&fl, 0, sizeof(fl));
788     fl.l_whence = SEEK_SET;
789     fl.l_start = offset;
790     fl.l_len = bytes;
791
792     if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) {
793         DEBUG_BLOCK_PRINT("cannot write zero range (%s)\n", strerror(errno));
794         return -errno;
795     }
796
797     return 0;
798 }
799
800 static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes)
801 {
802     struct xfs_flock64 fl;
803
804     memset(&fl, 0, sizeof(fl));
805     fl.l_whence = SEEK_SET;
806     fl.l_start = offset;
807     fl.l_len = bytes;
808
809     if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {
810         DEBUG_BLOCK_PRINT("cannot punch hole (%s)\n", strerror(errno));
811         return -errno;
812     }
813
814     return 0;
815 }
816 #endif
817
818 static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb)
819 {
820     int ret = -EOPNOTSUPP;
821     BDRVRawState *s = aiocb->bs->opaque;
822
823     if (s->has_write_zeroes == 0) {
824         return -ENOTSUP;
825     }
826
827     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
828 #ifdef BLKZEROOUT
829         do {
830             uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
831             if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
832                 return 0;
833             }
834         } while (errno == EINTR);
835
836         ret = -errno;
837 #endif
838     } else {
839 #ifdef CONFIG_XFS
840         if (s->is_xfs) {
841             return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes);
842         }
843 #endif
844     }
845
846     if (ret == -ENODEV || ret == -ENOSYS || ret == -EOPNOTSUPP ||
847         ret == -ENOTTY) {
848         s->has_write_zeroes = false;
849         ret = -ENOTSUP;
850     }
851     return ret;
852 }
853
854 static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb)
855 {
856     int ret = -EOPNOTSUPP;
857     BDRVRawState *s = aiocb->bs->opaque;
858
859     if (!s->has_discard) {
860         return -ENOTSUP;
861     }
862
863     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
864 #ifdef BLKDISCARD
865         do {
866             uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
867             if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
868                 return 0;
869             }
870         } while (errno == EINTR);
871
872         ret = -errno;
873 #endif
874     } else {
875 #ifdef CONFIG_XFS
876         if (s->is_xfs) {
877             return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
878         }
879 #endif
880
881 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
882         do {
883             if (fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
884                           aiocb->aio_offset, aiocb->aio_nbytes) == 0) {
885                 return 0;
886             }
887         } while (errno == EINTR);
888
889         ret = -errno;
890 #endif
891     }
892
893     if (ret == -ENODEV || ret == -ENOSYS || ret == -EOPNOTSUPP ||
894         ret == -ENOTTY) {
895         s->has_discard = false;
896         ret = -ENOTSUP;
897     }
898     return ret;
899 }
900
901 static int aio_worker(void *arg)
902 {
903     RawPosixAIOData *aiocb = arg;
904     ssize_t ret = 0;
905
906     switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
907     case QEMU_AIO_READ:
908         ret = handle_aiocb_rw(aiocb);
909         if (ret >= 0 && ret < aiocb->aio_nbytes && aiocb->bs->growable) {
910             iov_memset(aiocb->aio_iov, aiocb->aio_niov, ret,
911                       0, aiocb->aio_nbytes - ret);
912
913             ret = aiocb->aio_nbytes;
914         }
915         if (ret == aiocb->aio_nbytes) {
916             ret = 0;
917         } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
918             ret = -EINVAL;
919         }
920         break;
921     case QEMU_AIO_WRITE:
922         ret = handle_aiocb_rw(aiocb);
923         if (ret == aiocb->aio_nbytes) {
924             ret = 0;
925         } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
926             ret = -EINVAL;
927         }
928         break;
929     case QEMU_AIO_FLUSH:
930         ret = handle_aiocb_flush(aiocb);
931         break;
932     case QEMU_AIO_IOCTL:
933         ret = handle_aiocb_ioctl(aiocb);
934         break;
935     case QEMU_AIO_DISCARD:
936         ret = handle_aiocb_discard(aiocb);
937         break;
938     case QEMU_AIO_WRITE_ZEROES:
939         ret = handle_aiocb_write_zeroes(aiocb);
940         break;
941     default:
942         fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
943         ret = -EINVAL;
944         break;
945     }
946
947     g_slice_free(RawPosixAIOData, aiocb);
948     return ret;
949 }
950
951 static int paio_submit_co(BlockDriverState *bs, int fd,
952         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
953         int type)
954 {
955     RawPosixAIOData *acb = g_slice_new(RawPosixAIOData);
956     ThreadPool *pool;
957
958     acb->bs = bs;
959     acb->aio_type = type;
960     acb->aio_fildes = fd;
961
962     if (qiov) {
963         acb->aio_iov = qiov->iov;
964         acb->aio_niov = qiov->niov;
965     }
966     acb->aio_nbytes = nb_sectors * 512;
967     acb->aio_offset = sector_num * 512;
968
969     trace_paio_submit_co(sector_num, nb_sectors, type);
970     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
971     return thread_pool_submit_co(pool, aio_worker, acb);
972 }
973
974 static BlockDriverAIOCB *paio_submit(BlockDriverState *bs, int fd,
975         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
976         BlockDriverCompletionFunc *cb, void *opaque, int type)
977 {
978     RawPosixAIOData *acb = g_slice_new(RawPosixAIOData);
979     ThreadPool *pool;
980
981     acb->bs = bs;
982     acb->aio_type = type;
983     acb->aio_fildes = fd;
984
985     if (qiov) {
986         acb->aio_iov = qiov->iov;
987         acb->aio_niov = qiov->niov;
988     }
989     acb->aio_nbytes = nb_sectors * 512;
990     acb->aio_offset = sector_num * 512;
991
992     trace_paio_submit(acb, opaque, sector_num, nb_sectors, type);
993     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
994     return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
995 }
996
997 static BlockDriverAIOCB *raw_aio_submit(BlockDriverState *bs,
998         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
999         BlockDriverCompletionFunc *cb, void *opaque, int type)
1000 {
1001     BDRVRawState *s = bs->opaque;
1002
1003     if (fd_open(bs) < 0)
1004         return NULL;
1005
1006     /*
1007      * If O_DIRECT is used the buffer needs to be aligned on a sector
1008      * boundary.  Check if this is the case or tell the low-level
1009      * driver that it needs to copy the buffer.
1010      */
1011     if ((bs->open_flags & BDRV_O_NOCACHE)) {
1012         if (!bdrv_qiov_is_aligned(bs, qiov)) {
1013             type |= QEMU_AIO_MISALIGNED;
1014 #ifdef CONFIG_LINUX_AIO
1015         } else if (s->use_aio) {
1016             return laio_submit(bs, s->aio_ctx, s->fd, sector_num, qiov,
1017                                nb_sectors, cb, opaque, type);
1018 #endif
1019         }
1020     }
1021
1022     return paio_submit(bs, s->fd, sector_num, qiov, nb_sectors,
1023                        cb, opaque, type);
1024 }
1025
1026 static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs,
1027         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1028         BlockDriverCompletionFunc *cb, void *opaque)
1029 {
1030     return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
1031                           cb, opaque, QEMU_AIO_READ);
1032 }
1033
1034 static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs,
1035         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1036         BlockDriverCompletionFunc *cb, void *opaque)
1037 {
1038     return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
1039                           cb, opaque, QEMU_AIO_WRITE);
1040 }
1041
1042 static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs,
1043         BlockDriverCompletionFunc *cb, void *opaque)
1044 {
1045     BDRVRawState *s = bs->opaque;
1046
1047     if (fd_open(bs) < 0)
1048         return NULL;
1049
1050     return paio_submit(bs, s->fd, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
1051 }
1052
1053 static void raw_close(BlockDriverState *bs)
1054 {
1055     BDRVRawState *s = bs->opaque;
1056     if (s->fd >= 0) {
1057         qemu_close(s->fd);
1058         s->fd = -1;
1059     }
1060 }
1061
1062 static int raw_truncate(BlockDriverState *bs, int64_t offset)
1063 {
1064     BDRVRawState *s = bs->opaque;
1065     struct stat st;
1066
1067     if (fstat(s->fd, &st)) {
1068         return -errno;
1069     }
1070
1071     if (S_ISREG(st.st_mode)) {
1072         if (ftruncate(s->fd, offset) < 0) {
1073             return -errno;
1074         }
1075     } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1076        if (offset > raw_getlength(bs)) {
1077            return -EINVAL;
1078        }
1079     } else {
1080         return -ENOTSUP;
1081     }
1082
1083     return 0;
1084 }
1085
1086 #ifdef __OpenBSD__
1087 static int64_t raw_getlength(BlockDriverState *bs)
1088 {
1089     BDRVRawState *s = bs->opaque;
1090     int fd = s->fd;
1091     struct stat st;
1092
1093     if (fstat(fd, &st))
1094         return -1;
1095     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1096         struct disklabel dl;
1097
1098         if (ioctl(fd, DIOCGDINFO, &dl))
1099             return -1;
1100         return (uint64_t)dl.d_secsize *
1101             dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1102     } else
1103         return st.st_size;
1104 }
1105 #elif defined(__NetBSD__)
1106 static int64_t raw_getlength(BlockDriverState *bs)
1107 {
1108     BDRVRawState *s = bs->opaque;
1109     int fd = s->fd;
1110     struct stat st;
1111
1112     if (fstat(fd, &st))
1113         return -1;
1114     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1115         struct dkwedge_info dkw;
1116
1117         if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
1118             return dkw.dkw_size * 512;
1119         } else {
1120             struct disklabel dl;
1121
1122             if (ioctl(fd, DIOCGDINFO, &dl))
1123                 return -1;
1124             return (uint64_t)dl.d_secsize *
1125                 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1126         }
1127     } else
1128         return st.st_size;
1129 }
1130 #elif defined(__sun__)
1131 static int64_t raw_getlength(BlockDriverState *bs)
1132 {
1133     BDRVRawState *s = bs->opaque;
1134     struct dk_minfo minfo;
1135     int ret;
1136
1137     ret = fd_open(bs);
1138     if (ret < 0) {
1139         return ret;
1140     }
1141
1142     /*
1143      * Use the DKIOCGMEDIAINFO ioctl to read the size.
1144      */
1145     ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
1146     if (ret != -1) {
1147         return minfo.dki_lbsize * minfo.dki_capacity;
1148     }
1149
1150     /*
1151      * There are reports that lseek on some devices fails, but
1152      * irc discussion said that contingency on contingency was overkill.
1153      */
1154     return lseek(s->fd, 0, SEEK_END);
1155 }
1156 #elif defined(CONFIG_BSD)
1157 static int64_t raw_getlength(BlockDriverState *bs)
1158 {
1159     BDRVRawState *s = bs->opaque;
1160     int fd = s->fd;
1161     int64_t size;
1162     struct stat sb;
1163 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1164     int reopened = 0;
1165 #endif
1166     int ret;
1167
1168     ret = fd_open(bs);
1169     if (ret < 0)
1170         return ret;
1171
1172 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1173 again:
1174 #endif
1175     if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
1176 #ifdef DIOCGMEDIASIZE
1177         if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
1178 #elif defined(DIOCGPART)
1179         {
1180                 struct partinfo pi;
1181                 if (ioctl(fd, DIOCGPART, &pi) == 0)
1182                         size = pi.media_size;
1183                 else
1184                         size = 0;
1185         }
1186         if (size == 0)
1187 #endif
1188 #if defined(__APPLE__) && defined(__MACH__)
1189         size = LONG_LONG_MAX;
1190 #else
1191         size = lseek(fd, 0LL, SEEK_END);
1192 #endif
1193 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1194         switch(s->type) {
1195         case FTYPE_CD:
1196             /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
1197             if (size == 2048LL * (unsigned)-1)
1198                 size = 0;
1199             /* XXX no disc?  maybe we need to reopen... */
1200             if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
1201                 reopened = 1;
1202                 goto again;
1203             }
1204         }
1205 #endif
1206     } else {
1207         size = lseek(fd, 0, SEEK_END);
1208     }
1209     return size;
1210 }
1211 #else
1212 static int64_t raw_getlength(BlockDriverState *bs)
1213 {
1214     BDRVRawState *s = bs->opaque;
1215     int ret;
1216
1217     ret = fd_open(bs);
1218     if (ret < 0) {
1219         return ret;
1220     }
1221
1222     return lseek(s->fd, 0, SEEK_END);
1223 }
1224 #endif
1225
1226 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
1227 {
1228     struct stat st;
1229     BDRVRawState *s = bs->opaque;
1230
1231     if (fstat(s->fd, &st) < 0) {
1232         return -errno;
1233     }
1234     return (int64_t)st.st_blocks * 512;
1235 }
1236
1237 static int raw_create(const char *filename, QEMUOptionParameter *options,
1238                       Error **errp)
1239 {
1240     int fd;
1241     int result = 0;
1242     int64_t total_size = 0;
1243
1244     strstart(filename, "file:", &filename);
1245
1246     /* Read out options */
1247     while (options && options->name) {
1248         if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1249             total_size = options->value.n / BDRV_SECTOR_SIZE;
1250         }
1251         options++;
1252     }
1253
1254     fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
1255                    0644);
1256     if (fd < 0) {
1257         result = -errno;
1258         error_setg_errno(errp, -result, "Could not create file");
1259     } else {
1260         if (ftruncate(fd, total_size * BDRV_SECTOR_SIZE) != 0) {
1261             result = -errno;
1262             error_setg_errno(errp, -result, "Could not resize file");
1263         }
1264         if (qemu_close(fd) != 0) {
1265             result = -errno;
1266             error_setg_errno(errp, -result, "Could not close the new file");
1267         }
1268     }
1269     return result;
1270 }
1271
1272 /*
1273  * Returns true iff the specified sector is present in the disk image. Drivers
1274  * not implementing the functionality are assumed to not support backing files,
1275  * hence all their sectors are reported as allocated.
1276  *
1277  * If 'sector_num' is beyond the end of the disk image the return value is 0
1278  * and 'pnum' is set to 0.
1279  *
1280  * 'pnum' is set to the number of sectors (including and immediately following
1281  * the specified sector) that are known to be in the same
1282  * allocated/unallocated state.
1283  *
1284  * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
1285  * beyond the end of the disk image it will be clamped.
1286  */
1287 static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
1288                                             int64_t sector_num,
1289                                             int nb_sectors, int *pnum)
1290 {
1291     off_t start, data, hole;
1292     int64_t ret;
1293
1294     ret = fd_open(bs);
1295     if (ret < 0) {
1296         return ret;
1297     }
1298
1299     start = sector_num * BDRV_SECTOR_SIZE;
1300     ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;
1301
1302 #ifdef CONFIG_FIEMAP
1303
1304     BDRVRawState *s = bs->opaque;
1305     struct {
1306         struct fiemap fm;
1307         struct fiemap_extent fe;
1308     } f;
1309
1310     f.fm.fm_start = start;
1311     f.fm.fm_length = (int64_t)nb_sectors * BDRV_SECTOR_SIZE;
1312     f.fm.fm_flags = 0;
1313     f.fm.fm_extent_count = 1;
1314     f.fm.fm_reserved = 0;
1315     if (ioctl(s->fd, FS_IOC_FIEMAP, &f) == -1) {
1316         /* Assume everything is allocated.  */
1317         *pnum = nb_sectors;
1318         return ret;
1319     }
1320
1321     if (f.fm.fm_mapped_extents == 0) {
1322         /* No extents found, data is beyond f.fm.fm_start + f.fm.fm_length.
1323          * f.fm.fm_start + f.fm.fm_length must be clamped to the file size!
1324          */
1325         off_t length = lseek(s->fd, 0, SEEK_END);
1326         hole = f.fm.fm_start;
1327         data = MIN(f.fm.fm_start + f.fm.fm_length, length);
1328     } else {
1329         data = f.fe.fe_logical;
1330         hole = f.fe.fe_logical + f.fe.fe_length;
1331         if (f.fe.fe_flags & FIEMAP_EXTENT_UNWRITTEN) {
1332             ret |= BDRV_BLOCK_ZERO;
1333         }
1334     }
1335
1336 #elif defined SEEK_HOLE && defined SEEK_DATA
1337
1338     BDRVRawState *s = bs->opaque;
1339
1340     hole = lseek(s->fd, start, SEEK_HOLE);
1341     if (hole == -1) {
1342         /* -ENXIO indicates that sector_num was past the end of the file.
1343          * There is a virtual hole there.  */
1344         assert(errno != -ENXIO);
1345
1346         /* Most likely EINVAL.  Assume everything is allocated.  */
1347         *pnum = nb_sectors;
1348         return ret;
1349     }
1350
1351     if (hole > start) {
1352         data = start;
1353     } else {
1354         /* On a hole.  We need another syscall to find its end.  */
1355         data = lseek(s->fd, start, SEEK_DATA);
1356         if (data == -1) {
1357             data = lseek(s->fd, 0, SEEK_END);
1358         }
1359     }
1360 #else
1361     data = 0;
1362     hole = start + nb_sectors * BDRV_SECTOR_SIZE;
1363 #endif
1364
1365     if (data <= start) {
1366         /* On a data extent, compute sectors to the end of the extent.  */
1367         *pnum = MIN(nb_sectors, (hole - start) / BDRV_SECTOR_SIZE);
1368     } else {
1369         /* On a hole, compute sectors to the beginning of the next extent.  */
1370         *pnum = MIN(nb_sectors, (data - start) / BDRV_SECTOR_SIZE);
1371         ret &= ~BDRV_BLOCK_DATA;
1372         ret |= BDRV_BLOCK_ZERO;
1373     }
1374
1375     return ret;
1376 }
1377
1378 static coroutine_fn BlockDriverAIOCB *raw_aio_discard(BlockDriverState *bs,
1379     int64_t sector_num, int nb_sectors,
1380     BlockDriverCompletionFunc *cb, void *opaque)
1381 {
1382     BDRVRawState *s = bs->opaque;
1383
1384     return paio_submit(bs, s->fd, sector_num, NULL, nb_sectors,
1385                        cb, opaque, QEMU_AIO_DISCARD);
1386 }
1387
1388 static int coroutine_fn raw_co_write_zeroes(
1389     BlockDriverState *bs, int64_t sector_num,
1390     int nb_sectors, BdrvRequestFlags flags)
1391 {
1392     BDRVRawState *s = bs->opaque;
1393
1394     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
1395         return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1396                               QEMU_AIO_WRITE_ZEROES);
1397     } else if (s->discard_zeroes) {
1398         return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1399                               QEMU_AIO_DISCARD);
1400     }
1401     return -ENOTSUP;
1402 }
1403
1404 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1405 {
1406     BDRVRawState *s = bs->opaque;
1407
1408     bdi->unallocated_blocks_are_zero = s->discard_zeroes;
1409     bdi->can_write_zeroes_with_unmap = s->discard_zeroes;
1410     return 0;
1411 }
1412
1413 static QEMUOptionParameter raw_create_options[] = {
1414     {
1415         .name = BLOCK_OPT_SIZE,
1416         .type = OPT_SIZE,
1417         .help = "Virtual disk size"
1418     },
1419     { NULL }
1420 };
1421
1422 static BlockDriver bdrv_file = {
1423     .format_name = "file",
1424     .protocol_name = "file",
1425     .instance_size = sizeof(BDRVRawState),
1426     .bdrv_needs_filename = true,
1427     .bdrv_probe = NULL, /* no probe for protocols */
1428     .bdrv_parse_filename = raw_parse_filename,
1429     .bdrv_file_open = raw_open,
1430     .bdrv_reopen_prepare = raw_reopen_prepare,
1431     .bdrv_reopen_commit = raw_reopen_commit,
1432     .bdrv_reopen_abort = raw_reopen_abort,
1433     .bdrv_close = raw_close,
1434     .bdrv_create = raw_create,
1435     .bdrv_has_zero_init = bdrv_has_zero_init_1,
1436     .bdrv_co_get_block_status = raw_co_get_block_status,
1437     .bdrv_co_write_zeroes = raw_co_write_zeroes,
1438
1439     .bdrv_aio_readv = raw_aio_readv,
1440     .bdrv_aio_writev = raw_aio_writev,
1441     .bdrv_aio_flush = raw_aio_flush,
1442     .bdrv_aio_discard = raw_aio_discard,
1443     .bdrv_refresh_limits = raw_refresh_limits,
1444
1445     .bdrv_truncate = raw_truncate,
1446     .bdrv_getlength = raw_getlength,
1447     .bdrv_get_info = raw_get_info,
1448     .bdrv_get_allocated_file_size
1449                         = raw_get_allocated_file_size,
1450
1451     .create_options = raw_create_options,
1452 };
1453
1454 /***********************************************/
1455 /* host device */
1456
1457 #if defined(__APPLE__) && defined(__MACH__)
1458 static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator );
1459 static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize );
1460
1461 kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
1462 {
1463     kern_return_t       kernResult;
1464     mach_port_t     masterPort;
1465     CFMutableDictionaryRef  classesToMatch;
1466
1467     kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
1468     if ( KERN_SUCCESS != kernResult ) {
1469         printf( "IOMasterPort returned %d\n", kernResult );
1470     }
1471
1472     classesToMatch = IOServiceMatching( kIOCDMediaClass );
1473     if ( classesToMatch == NULL ) {
1474         printf( "IOServiceMatching returned a NULL dictionary.\n" );
1475     } else {
1476     CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue );
1477     }
1478     kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator );
1479     if ( KERN_SUCCESS != kernResult )
1480     {
1481         printf( "IOServiceGetMatchingServices returned %d\n", kernResult );
1482     }
1483
1484     return kernResult;
1485 }
1486
1487 kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize )
1488 {
1489     io_object_t     nextMedia;
1490     kern_return_t   kernResult = KERN_FAILURE;
1491     *bsdPath = '\0';
1492     nextMedia = IOIteratorNext( mediaIterator );
1493     if ( nextMedia )
1494     {
1495         CFTypeRef   bsdPathAsCFString;
1496     bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
1497         if ( bsdPathAsCFString ) {
1498             size_t devPathLength;
1499             strcpy( bsdPath, _PATH_DEV );
1500             strcat( bsdPath, "r" );
1501             devPathLength = strlen( bsdPath );
1502             if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
1503                 kernResult = KERN_SUCCESS;
1504             }
1505             CFRelease( bsdPathAsCFString );
1506         }
1507         IOObjectRelease( nextMedia );
1508     }
1509
1510     return kernResult;
1511 }
1512
1513 #endif
1514
1515 static int hdev_probe_device(const char *filename)
1516 {
1517     struct stat st;
1518
1519     /* allow a dedicated CD-ROM driver to match with a higher priority */
1520     if (strstart(filename, "/dev/cdrom", NULL))
1521         return 50;
1522
1523     if (stat(filename, &st) >= 0 &&
1524             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
1525         return 100;
1526     }
1527
1528     return 0;
1529 }
1530
1531 static int check_hdev_writable(BDRVRawState *s)
1532 {
1533 #if defined(BLKROGET)
1534     /* Linux block devices can be configured "read-only" using blockdev(8).
1535      * This is independent of device node permissions and therefore open(2)
1536      * with O_RDWR succeeds.  Actual writes fail with EPERM.
1537      *
1538      * bdrv_open() is supposed to fail if the disk is read-only.  Explicitly
1539      * check for read-only block devices so that Linux block devices behave
1540      * properly.
1541      */
1542     struct stat st;
1543     int readonly = 0;
1544
1545     if (fstat(s->fd, &st)) {
1546         return -errno;
1547     }
1548
1549     if (!S_ISBLK(st.st_mode)) {
1550         return 0;
1551     }
1552
1553     if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
1554         return -errno;
1555     }
1556
1557     if (readonly) {
1558         return -EACCES;
1559     }
1560 #endif /* defined(BLKROGET) */
1561     return 0;
1562 }
1563
1564 static void hdev_parse_filename(const char *filename, QDict *options,
1565                                 Error **errp)
1566 {
1567     /* The prefix is optional, just as for "file". */
1568     strstart(filename, "host_device:", &filename);
1569
1570     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
1571 }
1572
1573 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
1574                      Error **errp)
1575 {
1576     BDRVRawState *s = bs->opaque;
1577     Error *local_err = NULL;
1578     int ret;
1579     const char *filename = qdict_get_str(options, "filename");
1580
1581 #if defined(__APPLE__) && defined(__MACH__)
1582     if (strstart(filename, "/dev/cdrom", NULL)) {
1583         kern_return_t kernResult;
1584         io_iterator_t mediaIterator;
1585         char bsdPath[ MAXPATHLEN ];
1586         int fd;
1587
1588         kernResult = FindEjectableCDMedia( &mediaIterator );
1589         kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );
1590
1591         if ( bsdPath[ 0 ] != '\0' ) {
1592             strcat(bsdPath,"s0");
1593             /* some CDs don't have a partition 0 */
1594             fd = qemu_open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
1595             if (fd < 0) {
1596                 bsdPath[strlen(bsdPath)-1] = '1';
1597             } else {
1598                 qemu_close(fd);
1599             }
1600             filename = bsdPath;
1601             qdict_put(options, "filename", qstring_from_str(filename));
1602         }
1603
1604         if ( mediaIterator )
1605             IOObjectRelease( mediaIterator );
1606     }
1607 #endif
1608
1609     s->type = FTYPE_FILE;
1610 #if defined(__linux__)
1611     {
1612         char resolved_path[ MAXPATHLEN ], *temp;
1613
1614         temp = realpath(filename, resolved_path);
1615         if (temp && strstart(temp, "/dev/sg", NULL)) {
1616             bs->sg = 1;
1617         }
1618     }
1619 #endif
1620
1621     ret = raw_open_common(bs, options, flags, 0, &local_err);
1622     if (ret < 0) {
1623         if (local_err) {
1624             error_propagate(errp, local_err);
1625         }
1626         return ret;
1627     }
1628
1629     if (flags & BDRV_O_RDWR) {
1630         ret = check_hdev_writable(s);
1631         if (ret < 0) {
1632             raw_close(bs);
1633             error_setg_errno(errp, -ret, "The device is not writable");
1634             return ret;
1635         }
1636     }
1637
1638     return ret;
1639 }
1640
1641 #if defined(__linux__)
1642 /* Note: we do not have a reliable method to detect if the floppy is
1643    present. The current method is to try to open the floppy at every
1644    I/O and to keep it opened during a few hundreds of ms. */
1645 static int fd_open(BlockDriverState *bs)
1646 {
1647     BDRVRawState *s = bs->opaque;
1648     int last_media_present;
1649
1650     if (s->type != FTYPE_FD)
1651         return 0;
1652     last_media_present = (s->fd >= 0);
1653     if (s->fd >= 0 &&
1654         (get_clock() - s->fd_open_time) >= FD_OPEN_TIMEOUT) {
1655         qemu_close(s->fd);
1656         s->fd = -1;
1657 #ifdef DEBUG_FLOPPY
1658         printf("Floppy closed\n");
1659 #endif
1660     }
1661     if (s->fd < 0) {
1662         if (s->fd_got_error &&
1663             (get_clock() - s->fd_error_time) < FD_OPEN_TIMEOUT) {
1664 #ifdef DEBUG_FLOPPY
1665             printf("No floppy (open delayed)\n");
1666 #endif
1667             return -EIO;
1668         }
1669         s->fd = qemu_open(bs->filename, s->open_flags & ~O_NONBLOCK);
1670         if (s->fd < 0) {
1671             s->fd_error_time = get_clock();
1672             s->fd_got_error = 1;
1673             if (last_media_present)
1674                 s->fd_media_changed = 1;
1675 #ifdef DEBUG_FLOPPY
1676             printf("No floppy\n");
1677 #endif
1678             return -EIO;
1679         }
1680 #ifdef DEBUG_FLOPPY
1681         printf("Floppy opened\n");
1682 #endif
1683     }
1684     if (!last_media_present)
1685         s->fd_media_changed = 1;
1686     s->fd_open_time = get_clock();
1687     s->fd_got_error = 0;
1688     return 0;
1689 }
1690
1691 static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1692 {
1693     BDRVRawState *s = bs->opaque;
1694
1695     return ioctl(s->fd, req, buf);
1696 }
1697
1698 static BlockDriverAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
1699         unsigned long int req, void *buf,
1700         BlockDriverCompletionFunc *cb, void *opaque)
1701 {
1702     BDRVRawState *s = bs->opaque;
1703     RawPosixAIOData *acb;
1704     ThreadPool *pool;
1705
1706     if (fd_open(bs) < 0)
1707         return NULL;
1708
1709     acb = g_slice_new(RawPosixAIOData);
1710     acb->bs = bs;
1711     acb->aio_type = QEMU_AIO_IOCTL;
1712     acb->aio_fildes = s->fd;
1713     acb->aio_offset = 0;
1714     acb->aio_ioctl_buf = buf;
1715     acb->aio_ioctl_cmd = req;
1716     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1717     return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
1718 }
1719
1720 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1721 static int fd_open(BlockDriverState *bs)
1722 {
1723     BDRVRawState *s = bs->opaque;
1724
1725     /* this is just to ensure s->fd is sane (its called by io ops) */
1726     if (s->fd >= 0)
1727         return 0;
1728     return -EIO;
1729 }
1730 #else /* !linux && !FreeBSD */
1731
1732 static int fd_open(BlockDriverState *bs)
1733 {
1734     return 0;
1735 }
1736
1737 #endif /* !linux && !FreeBSD */
1738
1739 static coroutine_fn BlockDriverAIOCB *hdev_aio_discard(BlockDriverState *bs,
1740     int64_t sector_num, int nb_sectors,
1741     BlockDriverCompletionFunc *cb, void *opaque)
1742 {
1743     BDRVRawState *s = bs->opaque;
1744
1745     if (fd_open(bs) < 0) {
1746         return NULL;
1747     }
1748     return paio_submit(bs, s->fd, sector_num, NULL, nb_sectors,
1749                        cb, opaque, QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
1750 }
1751
1752 static coroutine_fn int hdev_co_write_zeroes(BlockDriverState *bs,
1753     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
1754 {
1755     BDRVRawState *s = bs->opaque;
1756     int rc;
1757
1758     rc = fd_open(bs);
1759     if (rc < 0) {
1760         return rc;
1761     }
1762     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
1763         return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1764                               QEMU_AIO_WRITE_ZEROES|QEMU_AIO_BLKDEV);
1765     } else if (s->discard_zeroes) {
1766         return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1767                               QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
1768     }
1769     return -ENOTSUP;
1770 }
1771
1772 static int hdev_create(const char *filename, QEMUOptionParameter *options,
1773                        Error **errp)
1774 {
1775     int fd;
1776     int ret = 0;
1777     struct stat stat_buf;
1778     int64_t total_size = 0;
1779     bool has_prefix;
1780
1781     /* This function is used by all three protocol block drivers and therefore
1782      * any of these three prefixes may be given.
1783      * The return value has to be stored somewhere, otherwise this is an error
1784      * due to -Werror=unused-value. */
1785     has_prefix =
1786         strstart(filename, "host_device:", &filename) ||
1787         strstart(filename, "host_cdrom:" , &filename) ||
1788         strstart(filename, "host_floppy:", &filename);
1789
1790     (void)has_prefix;
1791
1792     /* Read out options */
1793     while (options && options->name) {
1794         if (!strcmp(options->name, "size")) {
1795             total_size = options->value.n / BDRV_SECTOR_SIZE;
1796         }
1797         options++;
1798     }
1799
1800     fd = qemu_open(filename, O_WRONLY | O_BINARY);
1801     if (fd < 0) {
1802         ret = -errno;
1803         error_setg_errno(errp, -ret, "Could not open device");
1804         return ret;
1805     }
1806
1807     if (fstat(fd, &stat_buf) < 0) {
1808         ret = -errno;
1809         error_setg_errno(errp, -ret, "Could not stat device");
1810     } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
1811         error_setg(errp,
1812                    "The given file is neither a block nor a character device");
1813         ret = -ENODEV;
1814     } else if (lseek(fd, 0, SEEK_END) < total_size * BDRV_SECTOR_SIZE) {
1815         error_setg(errp, "Device is too small");
1816         ret = -ENOSPC;
1817     }
1818
1819     qemu_close(fd);
1820     return ret;
1821 }
1822
1823 static BlockDriver bdrv_host_device = {
1824     .format_name        = "host_device",
1825     .protocol_name        = "host_device",
1826     .instance_size      = sizeof(BDRVRawState),
1827     .bdrv_needs_filename = true,
1828     .bdrv_probe_device  = hdev_probe_device,
1829     .bdrv_parse_filename = hdev_parse_filename,
1830     .bdrv_file_open     = hdev_open,
1831     .bdrv_close         = raw_close,
1832     .bdrv_reopen_prepare = raw_reopen_prepare,
1833     .bdrv_reopen_commit  = raw_reopen_commit,
1834     .bdrv_reopen_abort   = raw_reopen_abort,
1835     .bdrv_create        = hdev_create,
1836     .create_options     = raw_create_options,
1837     .bdrv_co_write_zeroes = hdev_co_write_zeroes,
1838
1839     .bdrv_aio_readv     = raw_aio_readv,
1840     .bdrv_aio_writev    = raw_aio_writev,
1841     .bdrv_aio_flush     = raw_aio_flush,
1842     .bdrv_aio_discard   = hdev_aio_discard,
1843     .bdrv_refresh_limits = raw_refresh_limits,
1844
1845     .bdrv_truncate      = raw_truncate,
1846     .bdrv_getlength     = raw_getlength,
1847     .bdrv_get_info = raw_get_info,
1848     .bdrv_get_allocated_file_size
1849                         = raw_get_allocated_file_size,
1850
1851     /* generic scsi device */
1852 #ifdef __linux__
1853     .bdrv_ioctl         = hdev_ioctl,
1854     .bdrv_aio_ioctl     = hdev_aio_ioctl,
1855 #endif
1856 };
1857
1858 #ifdef __linux__
1859 static void floppy_parse_filename(const char *filename, QDict *options,
1860                                   Error **errp)
1861 {
1862     /* The prefix is optional, just as for "file". */
1863     strstart(filename, "host_floppy:", &filename);
1864
1865     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
1866 }
1867
1868 static int floppy_open(BlockDriverState *bs, QDict *options, int flags,
1869                        Error **errp)
1870 {
1871     BDRVRawState *s = bs->opaque;
1872     Error *local_err = NULL;
1873     int ret;
1874
1875     s->type = FTYPE_FD;
1876
1877     /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */
1878     ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
1879     if (ret) {
1880         if (local_err) {
1881             error_propagate(errp, local_err);
1882         }
1883         return ret;
1884     }
1885
1886     /* close fd so that we can reopen it as needed */
1887     qemu_close(s->fd);
1888     s->fd = -1;
1889     s->fd_media_changed = 1;
1890
1891     return 0;
1892 }
1893
1894 static int floppy_probe_device(const char *filename)
1895 {
1896     int fd, ret;
1897     int prio = 0;
1898     struct floppy_struct fdparam;
1899     struct stat st;
1900
1901     if (strstart(filename, "/dev/fd", NULL) &&
1902         !strstart(filename, "/dev/fdset/", NULL)) {
1903         prio = 50;
1904     }
1905
1906     fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
1907     if (fd < 0) {
1908         goto out;
1909     }
1910     ret = fstat(fd, &st);
1911     if (ret == -1 || !S_ISBLK(st.st_mode)) {
1912         goto outc;
1913     }
1914
1915     /* Attempt to detect via a floppy specific ioctl */
1916     ret = ioctl(fd, FDGETPRM, &fdparam);
1917     if (ret >= 0)
1918         prio = 100;
1919
1920 outc:
1921     qemu_close(fd);
1922 out:
1923     return prio;
1924 }
1925
1926
1927 static int floppy_is_inserted(BlockDriverState *bs)
1928 {
1929     return fd_open(bs) >= 0;
1930 }
1931
1932 static int floppy_media_changed(BlockDriverState *bs)
1933 {
1934     BDRVRawState *s = bs->opaque;
1935     int ret;
1936
1937     /*
1938      * XXX: we do not have a true media changed indication.
1939      * It does not work if the floppy is changed without trying to read it.
1940      */
1941     fd_open(bs);
1942     ret = s->fd_media_changed;
1943     s->fd_media_changed = 0;
1944 #ifdef DEBUG_FLOPPY
1945     printf("Floppy changed=%d\n", ret);
1946 #endif
1947     return ret;
1948 }
1949
1950 static void floppy_eject(BlockDriverState *bs, bool eject_flag)
1951 {
1952     BDRVRawState *s = bs->opaque;
1953     int fd;
1954
1955     if (s->fd >= 0) {
1956         qemu_close(s->fd);
1957         s->fd = -1;
1958     }
1959     fd = qemu_open(bs->filename, s->open_flags | O_NONBLOCK);
1960     if (fd >= 0) {
1961         if (ioctl(fd, FDEJECT, 0) < 0)
1962             perror("FDEJECT");
1963         qemu_close(fd);
1964     }
1965 }
1966
1967 static BlockDriver bdrv_host_floppy = {
1968     .format_name        = "host_floppy",
1969     .protocol_name      = "host_floppy",
1970     .instance_size      = sizeof(BDRVRawState),
1971     .bdrv_needs_filename = true,
1972     .bdrv_probe_device  = floppy_probe_device,
1973     .bdrv_parse_filename = floppy_parse_filename,
1974     .bdrv_file_open     = floppy_open,
1975     .bdrv_close         = raw_close,
1976     .bdrv_reopen_prepare = raw_reopen_prepare,
1977     .bdrv_reopen_commit  = raw_reopen_commit,
1978     .bdrv_reopen_abort   = raw_reopen_abort,
1979     .bdrv_create        = hdev_create,
1980     .create_options     = raw_create_options,
1981
1982     .bdrv_aio_readv     = raw_aio_readv,
1983     .bdrv_aio_writev    = raw_aio_writev,
1984     .bdrv_aio_flush     = raw_aio_flush,
1985     .bdrv_refresh_limits = raw_refresh_limits,
1986
1987     .bdrv_truncate      = raw_truncate,
1988     .bdrv_getlength      = raw_getlength,
1989     .has_variable_length = true,
1990     .bdrv_get_allocated_file_size
1991                         = raw_get_allocated_file_size,
1992
1993     /* removable device support */
1994     .bdrv_is_inserted   = floppy_is_inserted,
1995     .bdrv_media_changed = floppy_media_changed,
1996     .bdrv_eject         = floppy_eject,
1997 };
1998 #endif
1999
2000 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2001 static void cdrom_parse_filename(const char *filename, QDict *options,
2002                                  Error **errp)
2003 {
2004     /* The prefix is optional, just as for "file". */
2005     strstart(filename, "host_cdrom:", &filename);
2006
2007     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
2008 }
2009 #endif
2010
2011 #ifdef __linux__
2012 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
2013                       Error **errp)
2014 {
2015     BDRVRawState *s = bs->opaque;
2016     Error *local_err = NULL;
2017     int ret;
2018
2019     s->type = FTYPE_CD;
2020
2021     /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
2022     ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
2023     if (local_err) {
2024         error_propagate(errp, local_err);
2025     }
2026     return ret;
2027 }
2028
2029 static int cdrom_probe_device(const char *filename)
2030 {
2031     int fd, ret;
2032     int prio = 0;
2033     struct stat st;
2034
2035     fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
2036     if (fd < 0) {
2037         goto out;
2038     }
2039     ret = fstat(fd, &st);
2040     if (ret == -1 || !S_ISBLK(st.st_mode)) {
2041         goto outc;
2042     }
2043
2044     /* Attempt to detect via a CDROM specific ioctl */
2045     ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2046     if (ret >= 0)
2047         prio = 100;
2048
2049 outc:
2050     qemu_close(fd);
2051 out:
2052     return prio;
2053 }
2054
2055 static int cdrom_is_inserted(BlockDriverState *bs)
2056 {
2057     BDRVRawState *s = bs->opaque;
2058     int ret;
2059
2060     ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2061     if (ret == CDS_DISC_OK)
2062         return 1;
2063     return 0;
2064 }
2065
2066 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2067 {
2068     BDRVRawState *s = bs->opaque;
2069
2070     if (eject_flag) {
2071         if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
2072             perror("CDROMEJECT");
2073     } else {
2074         if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
2075             perror("CDROMEJECT");
2076     }
2077 }
2078
2079 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2080 {
2081     BDRVRawState *s = bs->opaque;
2082
2083     if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
2084         /*
2085          * Note: an error can happen if the distribution automatically
2086          * mounts the CD-ROM
2087          */
2088         /* perror("CDROM_LOCKDOOR"); */
2089     }
2090 }
2091
2092 static BlockDriver bdrv_host_cdrom = {
2093     .format_name        = "host_cdrom",
2094     .protocol_name      = "host_cdrom",
2095     .instance_size      = sizeof(BDRVRawState),
2096     .bdrv_needs_filename = true,
2097     .bdrv_probe_device  = cdrom_probe_device,
2098     .bdrv_parse_filename = cdrom_parse_filename,
2099     .bdrv_file_open     = cdrom_open,
2100     .bdrv_close         = raw_close,
2101     .bdrv_reopen_prepare = raw_reopen_prepare,
2102     .bdrv_reopen_commit  = raw_reopen_commit,
2103     .bdrv_reopen_abort   = raw_reopen_abort,
2104     .bdrv_create        = hdev_create,
2105     .create_options     = raw_create_options,
2106
2107     .bdrv_aio_readv     = raw_aio_readv,
2108     .bdrv_aio_writev    = raw_aio_writev,
2109     .bdrv_aio_flush     = raw_aio_flush,
2110     .bdrv_refresh_limits = raw_refresh_limits,
2111
2112     .bdrv_truncate      = raw_truncate,
2113     .bdrv_getlength      = raw_getlength,
2114     .has_variable_length = true,
2115     .bdrv_get_allocated_file_size
2116                         = raw_get_allocated_file_size,
2117
2118     /* removable device support */
2119     .bdrv_is_inserted   = cdrom_is_inserted,
2120     .bdrv_eject         = cdrom_eject,
2121     .bdrv_lock_medium   = cdrom_lock_medium,
2122
2123     /* generic scsi device */
2124     .bdrv_ioctl         = hdev_ioctl,
2125     .bdrv_aio_ioctl     = hdev_aio_ioctl,
2126 };
2127 #endif /* __linux__ */
2128
2129 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2130 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
2131                       Error **errp)
2132 {
2133     BDRVRawState *s = bs->opaque;
2134     Error *local_err = NULL;
2135     int ret;
2136
2137     s->type = FTYPE_CD;
2138
2139     ret = raw_open_common(bs, options, flags, 0, &local_err);
2140     if (ret) {
2141         if (local_err) {
2142             error_propagate(errp, local_err);
2143         }
2144         return ret;
2145     }
2146
2147     /* make sure the door isn't locked at this time */
2148     ioctl(s->fd, CDIOCALLOW);
2149     return 0;
2150 }
2151
2152 static int cdrom_probe_device(const char *filename)
2153 {
2154     if (strstart(filename, "/dev/cd", NULL) ||
2155             strstart(filename, "/dev/acd", NULL))
2156         return 100;
2157     return 0;
2158 }
2159
2160 static int cdrom_reopen(BlockDriverState *bs)
2161 {
2162     BDRVRawState *s = bs->opaque;
2163     int fd;
2164
2165     /*
2166      * Force reread of possibly changed/newly loaded disc,
2167      * FreeBSD seems to not notice sometimes...
2168      */
2169     if (s->fd >= 0)
2170         qemu_close(s->fd);
2171     fd = qemu_open(bs->filename, s->open_flags, 0644);
2172     if (fd < 0) {
2173         s->fd = -1;
2174         return -EIO;
2175     }
2176     s->fd = fd;
2177
2178     /* make sure the door isn't locked at this time */
2179     ioctl(s->fd, CDIOCALLOW);
2180     return 0;
2181 }
2182
2183 static int cdrom_is_inserted(BlockDriverState *bs)
2184 {
2185     return raw_getlength(bs) > 0;
2186 }
2187
2188 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2189 {
2190     BDRVRawState *s = bs->opaque;
2191
2192     if (s->fd < 0)
2193         return;
2194
2195     (void) ioctl(s->fd, CDIOCALLOW);
2196
2197     if (eject_flag) {
2198         if (ioctl(s->fd, CDIOCEJECT) < 0)
2199             perror("CDIOCEJECT");
2200     } else {
2201         if (ioctl(s->fd, CDIOCCLOSE) < 0)
2202             perror("CDIOCCLOSE");
2203     }
2204
2205     cdrom_reopen(bs);
2206 }
2207
2208 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2209 {
2210     BDRVRawState *s = bs->opaque;
2211
2212     if (s->fd < 0)
2213         return;
2214     if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
2215         /*
2216          * Note: an error can happen if the distribution automatically
2217          * mounts the CD-ROM
2218          */
2219         /* perror("CDROM_LOCKDOOR"); */
2220     }
2221 }
2222
2223 static BlockDriver bdrv_host_cdrom = {
2224     .format_name        = "host_cdrom",
2225     .protocol_name      = "host_cdrom",
2226     .instance_size      = sizeof(BDRVRawState),
2227     .bdrv_needs_filename = true,
2228     .bdrv_probe_device  = cdrom_probe_device,
2229     .bdrv_parse_filename = cdrom_parse_filename,
2230     .bdrv_file_open     = cdrom_open,
2231     .bdrv_close         = raw_close,
2232     .bdrv_reopen_prepare = raw_reopen_prepare,
2233     .bdrv_reopen_commit  = raw_reopen_commit,
2234     .bdrv_reopen_abort   = raw_reopen_abort,
2235     .bdrv_create        = hdev_create,
2236     .create_options     = raw_create_options,
2237
2238     .bdrv_aio_readv     = raw_aio_readv,
2239     .bdrv_aio_writev    = raw_aio_writev,
2240     .bdrv_aio_flush     = raw_aio_flush,
2241     .bdrv_refresh_limits = raw_refresh_limits,
2242
2243     .bdrv_truncate      = raw_truncate,
2244     .bdrv_getlength      = raw_getlength,
2245     .has_variable_length = true,
2246     .bdrv_get_allocated_file_size
2247                         = raw_get_allocated_file_size,
2248
2249     /* removable device support */
2250     .bdrv_is_inserted   = cdrom_is_inserted,
2251     .bdrv_eject         = cdrom_eject,
2252     .bdrv_lock_medium   = cdrom_lock_medium,
2253 };
2254 #endif /* __FreeBSD__ */
2255
2256 #ifdef CONFIG_LINUX_AIO
2257 /**
2258  * Return the file descriptor for Linux AIO
2259  *
2260  * This function is a layering violation and should be removed when it becomes
2261  * possible to call the block layer outside the global mutex.  It allows the
2262  * caller to hijack the file descriptor so I/O can be performed outside the
2263  * block layer.
2264  */
2265 int raw_get_aio_fd(BlockDriverState *bs)
2266 {
2267     BDRVRawState *s;
2268
2269     if (!bs->drv) {
2270         return -ENOMEDIUM;
2271     }
2272
2273     if (bs->drv == bdrv_find_format("raw")) {
2274         bs = bs->file;
2275     }
2276
2277     /* raw-posix has several protocols so just check for raw_aio_readv */
2278     if (bs->drv->bdrv_aio_readv != raw_aio_readv) {
2279         return -ENOTSUP;
2280     }
2281
2282     s = bs->opaque;
2283     if (!s->use_aio) {
2284         return -ENOTSUP;
2285     }
2286     return s->fd;
2287 }
2288 #endif /* CONFIG_LINUX_AIO */
2289
2290 static void bdrv_file_init(void)
2291 {
2292     /*
2293      * Register all the drivers.  Note that order is important, the driver
2294      * registered last will get probed first.
2295      */
2296     bdrv_register(&bdrv_file);
2297     bdrv_register(&bdrv_host_device);
2298 #ifdef __linux__
2299     bdrv_register(&bdrv_host_floppy);
2300     bdrv_register(&bdrv_host_cdrom);
2301 #endif
2302 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2303     bdrv_register(&bdrv_host_cdrom);
2304 #endif
2305 }
2306
2307 block_init(bdrv_file_init);