2 * Block driver for RAW files (posix)
4 * Copyright (c) 2006 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu-common.h"
25 #include "qemu-timer.h"
26 #include "qemu-char.h"
28 #include "block_int.h"
31 #include "thread-pool.h"
35 #if defined(__APPLE__) && (__MACH__)
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>
48 #define _POSIX_PTHREAD_SEMANTICS 1
52 #include <sys/types.h>
54 #include <sys/ioctl.h>
55 #include <sys/param.h>
56 #include <linux/cdrom.h>
61 #include <linux/fiemap.h>
63 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
69 #include <sys/ioctl.h>
70 #include <sys/disklabel.h>
75 #include <sys/ioctl.h>
76 #include <sys/disklabel.h>
82 #include <sys/ioctl.h>
83 #include <sys/diskslice.h>
90 //#define DEBUG_FLOPPY
93 #if defined(DEBUG_BLOCK)
94 #define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \
95 { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0)
97 #define DEBUG_BLOCK_PRINT(formatCstr, ...)
100 /* OS X does not have O_DSYNC */
103 #define O_DSYNC O_SYNC
104 #elif defined(O_FSYNC)
105 #define O_DSYNC O_FSYNC
109 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
111 #define O_DIRECT O_DSYNC
118 /* if the FD is not accessed during that time (in ns), we try to
119 reopen it to see if the disk has been changed */
120 #define FD_OPEN_TIMEOUT (1000000000)
122 #define MAX_BLOCKSIZE 4096
124 typedef struct BDRVRawState
{
128 #if defined(__linux__)
129 /* linux floppy specific */
130 int64_t fd_open_time
;
131 int64_t fd_error_time
;
133 int fd_media_changed
;
135 #ifdef CONFIG_LINUX_AIO
144 typedef struct BDRVRawReopenState
{
147 #ifdef CONFIG_LINUX_AIO
150 } BDRVRawReopenState
;
152 static int fd_open(BlockDriverState
*bs
);
153 static int64_t raw_getlength(BlockDriverState
*bs
);
155 typedef struct RawPosixAIOData
{
156 BlockDriverState
*bs
;
159 struct iovec
*aio_iov
;
164 #define aio_ioctl_cmd aio_nbytes /* for QEMU_AIO_IOCTL */
169 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
170 static int cdrom_reopen(BlockDriverState
*bs
);
173 #if defined(__NetBSD__)
174 static int raw_normalize_devicepath(const char **filename
)
176 static char namebuf
[PATH_MAX
];
177 const char *dp
, *fname
;
181 dp
= strrchr(fname
, '/');
182 if (lstat(fname
, &sb
) < 0) {
183 fprintf(stderr
, "%s: stat failed: %s\n",
184 fname
, strerror(errno
));
188 if (!S_ISBLK(sb
.st_mode
)) {
193 snprintf(namebuf
, PATH_MAX
, "r%s", fname
);
195 snprintf(namebuf
, PATH_MAX
, "%.*s/r%s",
196 (int)(dp
- fname
), fname
, dp
+ 1);
198 fprintf(stderr
, "%s is a block device", fname
);
200 fprintf(stderr
, ", using %s\n", *filename
);
205 static int raw_normalize_devicepath(const char **filename
)
211 static void raw_parse_flags(int bdrv_flags
, int *open_flags
)
213 assert(open_flags
!= NULL
);
215 *open_flags
|= O_BINARY
;
216 *open_flags
&= ~O_ACCMODE
;
217 if (bdrv_flags
& BDRV_O_RDWR
) {
218 *open_flags
|= O_RDWR
;
220 *open_flags
|= O_RDONLY
;
223 /* Use O_DSYNC for write-through caching, no flags for write-back caching,
224 * and O_DIRECT for no caching. */
225 if ((bdrv_flags
& BDRV_O_NOCACHE
)) {
226 *open_flags
|= O_DIRECT
;
230 #ifdef CONFIG_LINUX_AIO
231 static int raw_set_aio(void **aio_ctx
, int *use_aio
, int bdrv_flags
)
234 assert(aio_ctx
!= NULL
);
235 assert(use_aio
!= NULL
);
237 * Currently Linux do AIO only for files opened with O_DIRECT
238 * specified so check NOCACHE flag too
240 if ((bdrv_flags
& (BDRV_O_NOCACHE
|BDRV_O_NATIVE_AIO
)) ==
241 (BDRV_O_NOCACHE
|BDRV_O_NATIVE_AIO
)) {
243 /* if non-NULL, laio_init() has already been run */
244 if (*aio_ctx
== NULL
) {
245 *aio_ctx
= laio_init();
262 static int raw_open_common(BlockDriverState
*bs
, const char *filename
,
263 int bdrv_flags
, int open_flags
)
265 BDRVRawState
*s
= bs
->opaque
;
268 ret
= raw_normalize_devicepath(&filename
);
273 s
->open_flags
= open_flags
;
274 raw_parse_flags(bdrv_flags
, &s
->open_flags
);
277 fd
= qemu_open(filename
, s
->open_flags
, 0644);
286 #ifdef CONFIG_LINUX_AIO
287 if (raw_set_aio(&s
->aio_ctx
, &s
->use_aio
, bdrv_flags
)) {
294 if (platform_test_xfs_fd(s
->fd
)) {
302 static int raw_open(BlockDriverState
*bs
, const char *filename
, int flags
)
304 BDRVRawState
*s
= bs
->opaque
;
306 s
->type
= FTYPE_FILE
;
307 return raw_open_common(bs
, filename
, flags
, 0);
310 static int raw_reopen_prepare(BDRVReopenState
*state
,
311 BlockReopenQueue
*queue
, Error
**errp
)
314 BDRVRawReopenState
*raw_s
;
317 assert(state
!= NULL
);
318 assert(state
->bs
!= NULL
);
320 s
= state
->bs
->opaque
;
322 state
->opaque
= g_malloc0(sizeof(BDRVRawReopenState
));
323 raw_s
= state
->opaque
;
325 #ifdef CONFIG_LINUX_AIO
326 raw_s
->use_aio
= s
->use_aio
;
328 /* we can use s->aio_ctx instead of a copy, because the use_aio flag is
329 * valid in the 'false' condition even if aio_ctx is set, and raw_set_aio()
330 * won't override aio_ctx if aio_ctx is non-NULL */
331 if (raw_set_aio(&s
->aio_ctx
, &raw_s
->use_aio
, state
->flags
)) {
336 if (s
->type
== FTYPE_FD
|| s
->type
== FTYPE_CD
) {
337 raw_s
->open_flags
|= O_NONBLOCK
;
340 raw_parse_flags(state
->flags
, &raw_s
->open_flags
);
344 int fcntl_flags
= O_APPEND
| O_ASYNC
| O_NONBLOCK
;
346 fcntl_flags
|= O_NOATIME
;
349 if ((raw_s
->open_flags
& ~fcntl_flags
) == (s
->open_flags
& ~fcntl_flags
)) {
350 /* dup the original fd */
351 /* TODO: use qemu fcntl wrapper */
352 #ifdef F_DUPFD_CLOEXEC
353 raw_s
->fd
= fcntl(s
->fd
, F_DUPFD_CLOEXEC
, 0);
355 raw_s
->fd
= dup(s
->fd
);
356 if (raw_s
->fd
!= -1) {
357 qemu_set_cloexec(raw_s
->fd
);
360 if (raw_s
->fd
>= 0) {
361 ret
= fcntl_setfl(raw_s
->fd
, raw_s
->open_flags
);
363 qemu_close(raw_s
->fd
);
369 /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
370 if (raw_s
->fd
== -1) {
371 assert(!(raw_s
->open_flags
& O_CREAT
));
372 raw_s
->fd
= qemu_open(state
->bs
->filename
, raw_s
->open_flags
);
373 if (raw_s
->fd
== -1) {
381 static void raw_reopen_commit(BDRVReopenState
*state
)
383 BDRVRawReopenState
*raw_s
= state
->opaque
;
384 BDRVRawState
*s
= state
->bs
->opaque
;
386 s
->open_flags
= raw_s
->open_flags
;
390 #ifdef CONFIG_LINUX_AIO
391 s
->use_aio
= raw_s
->use_aio
;
394 g_free(state
->opaque
);
395 state
->opaque
= NULL
;
399 static void raw_reopen_abort(BDRVReopenState
*state
)
401 BDRVRawReopenState
*raw_s
= state
->opaque
;
403 /* nothing to do if NULL, we didn't get far enough */
408 if (raw_s
->fd
>= 0) {
409 qemu_close(raw_s
->fd
);
412 g_free(state
->opaque
);
413 state
->opaque
= NULL
;
417 /* XXX: use host sector size if necessary with:
418 #ifdef DIOCGSECTORSIZE
420 unsigned int sectorsize = 512;
421 if (!ioctl(fd, DIOCGSECTORSIZE, §orsize) &&
422 sectorsize > bufsize)
423 bufsize = sectorsize;
427 uint32_t blockSize = 512;
428 if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) {
435 * Check if all memory in this vector is sector aligned.
437 static int qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
441 for (i
= 0; i
< qiov
->niov
; i
++) {
442 if ((uintptr_t) qiov
->iov
[i
].iov_base
% bs
->buffer_alignment
) {
450 static ssize_t
handle_aiocb_ioctl(RawPosixAIOData
*aiocb
)
454 ret
= ioctl(aiocb
->aio_fildes
, aiocb
->aio_ioctl_cmd
, aiocb
->aio_ioctl_buf
);
460 * This looks weird, but the aio code only considers a request
461 * successful if it has written the full number of bytes.
463 * Now we overload aio_nbytes as aio_ioctl_cmd for the ioctl command,
464 * so in fact we return the ioctl command here to make posix_aio_read()
467 return aiocb
->aio_nbytes
;
470 static ssize_t
handle_aiocb_flush(RawPosixAIOData
*aiocb
)
474 ret
= qemu_fdatasync(aiocb
->aio_fildes
);
483 static bool preadv_present
= true;
486 qemu_preadv(int fd
, const struct iovec
*iov
, int nr_iov
, off_t offset
)
488 return preadv(fd
, iov
, nr_iov
, offset
);
492 qemu_pwritev(int fd
, const struct iovec
*iov
, int nr_iov
, off_t offset
)
494 return pwritev(fd
, iov
, nr_iov
, offset
);
499 static bool preadv_present
= false;
502 qemu_preadv(int fd
, const struct iovec
*iov
, int nr_iov
, off_t offset
)
508 qemu_pwritev(int fd
, const struct iovec
*iov
, int nr_iov
, off_t offset
)
515 static ssize_t
handle_aiocb_rw_vector(RawPosixAIOData
*aiocb
)
520 if (aiocb
->aio_type
& QEMU_AIO_WRITE
)
521 len
= qemu_pwritev(aiocb
->aio_fildes
,
526 len
= qemu_preadv(aiocb
->aio_fildes
,
530 } while (len
== -1 && errno
== EINTR
);
539 * Read/writes the data to/from a given linear buffer.
541 * Returns the number of bytes handles or -errno in case of an error. Short
542 * reads are only returned if the end of the file is reached.
544 static ssize_t
handle_aiocb_rw_linear(RawPosixAIOData
*aiocb
, char *buf
)
549 while (offset
< aiocb
->aio_nbytes
) {
550 if (aiocb
->aio_type
& QEMU_AIO_WRITE
) {
551 len
= pwrite(aiocb
->aio_fildes
,
552 (const char *)buf
+ offset
,
553 aiocb
->aio_nbytes
- offset
,
554 aiocb
->aio_offset
+ offset
);
556 len
= pread(aiocb
->aio_fildes
,
558 aiocb
->aio_nbytes
- offset
,
559 aiocb
->aio_offset
+ offset
);
561 if (len
== -1 && errno
== EINTR
) {
563 } else if (len
== -1) {
566 } else if (len
== 0) {
575 static ssize_t
handle_aiocb_rw(RawPosixAIOData
*aiocb
)
580 if (!(aiocb
->aio_type
& QEMU_AIO_MISALIGNED
)) {
582 * If there is just a single buffer, and it is properly aligned
583 * we can just use plain pread/pwrite without any problems.
585 if (aiocb
->aio_niov
== 1) {
586 return handle_aiocb_rw_linear(aiocb
, aiocb
->aio_iov
->iov_base
);
589 * We have more than one iovec, and all are properly aligned.
591 * Try preadv/pwritev first and fall back to linearizing the
592 * buffer if it's not supported.
594 if (preadv_present
) {
595 nbytes
= handle_aiocb_rw_vector(aiocb
);
596 if (nbytes
== aiocb
->aio_nbytes
||
597 (nbytes
< 0 && nbytes
!= -ENOSYS
)) {
600 preadv_present
= false;
604 * XXX(hch): short read/write. no easy way to handle the reminder
605 * using these interfaces. For now retry using plain
611 * Ok, we have to do it the hard way, copy all segments into
612 * a single aligned buffer.
614 buf
= qemu_blockalign(aiocb
->bs
, aiocb
->aio_nbytes
);
615 if (aiocb
->aio_type
& QEMU_AIO_WRITE
) {
619 for (i
= 0; i
< aiocb
->aio_niov
; ++i
) {
620 memcpy(p
, aiocb
->aio_iov
[i
].iov_base
, aiocb
->aio_iov
[i
].iov_len
);
621 p
+= aiocb
->aio_iov
[i
].iov_len
;
625 nbytes
= handle_aiocb_rw_linear(aiocb
, buf
);
626 if (!(aiocb
->aio_type
& QEMU_AIO_WRITE
)) {
628 size_t count
= aiocb
->aio_nbytes
, copy
;
631 for (i
= 0; i
< aiocb
->aio_niov
&& count
; ++i
) {
633 if (copy
> aiocb
->aio_iov
[i
].iov_len
) {
634 copy
= aiocb
->aio_iov
[i
].iov_len
;
636 memcpy(aiocb
->aio_iov
[i
].iov_base
, p
, copy
);
646 static int aio_worker(void *arg
)
648 RawPosixAIOData
*aiocb
= arg
;
651 switch (aiocb
->aio_type
& QEMU_AIO_TYPE_MASK
) {
653 ret
= handle_aiocb_rw(aiocb
);
654 if (ret
>= 0 && ret
< aiocb
->aio_nbytes
&& aiocb
->bs
->growable
) {
655 iov_memset(aiocb
->aio_iov
, aiocb
->aio_niov
, ret
,
656 0, aiocb
->aio_nbytes
- ret
);
658 ret
= aiocb
->aio_nbytes
;
660 if (ret
== aiocb
->aio_nbytes
) {
662 } else if (ret
>= 0 && ret
< aiocb
->aio_nbytes
) {
667 ret
= handle_aiocb_rw(aiocb
);
668 if (ret
== aiocb
->aio_nbytes
) {
670 } else if (ret
>= 0 && ret
< aiocb
->aio_nbytes
) {
675 ret
= handle_aiocb_flush(aiocb
);
678 ret
= handle_aiocb_ioctl(aiocb
);
681 fprintf(stderr
, "invalid aio request (0x%x)\n", aiocb
->aio_type
);
686 g_slice_free(RawPosixAIOData
, aiocb
);
690 static BlockDriverAIOCB
*paio_submit(BlockDriverState
*bs
, int fd
,
691 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
692 BlockDriverCompletionFunc
*cb
, void *opaque
, int type
)
694 RawPosixAIOData
*acb
= g_slice_new(RawPosixAIOData
);
697 acb
->aio_type
= type
;
698 acb
->aio_fildes
= fd
;
701 acb
->aio_iov
= qiov
->iov
;
702 acb
->aio_niov
= qiov
->niov
;
704 acb
->aio_nbytes
= nb_sectors
* 512;
705 acb
->aio_offset
= sector_num
* 512;
707 trace_paio_submit(acb
, opaque
, sector_num
, nb_sectors
, type
);
708 return thread_pool_submit_aio(aio_worker
, acb
, cb
, opaque
);
711 static BlockDriverAIOCB
*paio_ioctl(BlockDriverState
*bs
, int fd
,
712 unsigned long int req
, void *buf
,
713 BlockDriverCompletionFunc
*cb
, void *opaque
)
715 RawPosixAIOData
*acb
= g_slice_new(RawPosixAIOData
);
718 acb
->aio_type
= QEMU_AIO_IOCTL
;
719 acb
->aio_fildes
= fd
;
721 acb
->aio_ioctl_buf
= buf
;
722 acb
->aio_ioctl_cmd
= req
;
724 return thread_pool_submit_aio(aio_worker
, acb
, cb
, opaque
);
727 static BlockDriverAIOCB
*raw_aio_submit(BlockDriverState
*bs
,
728 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
729 BlockDriverCompletionFunc
*cb
, void *opaque
, int type
)
731 BDRVRawState
*s
= bs
->opaque
;
737 * If O_DIRECT is used the buffer needs to be aligned on a sector
738 * boundary. Check if this is the case or tell the low-level
739 * driver that it needs to copy the buffer.
741 if ((bs
->open_flags
& BDRV_O_NOCACHE
)) {
742 if (!qiov_is_aligned(bs
, qiov
)) {
743 type
|= QEMU_AIO_MISALIGNED
;
744 #ifdef CONFIG_LINUX_AIO
745 } else if (s
->use_aio
) {
746 return laio_submit(bs
, s
->aio_ctx
, s
->fd
, sector_num
, qiov
,
747 nb_sectors
, cb
, opaque
, type
);
752 return paio_submit(bs
, s
->fd
, sector_num
, qiov
, nb_sectors
,
756 static BlockDriverAIOCB
*raw_aio_readv(BlockDriverState
*bs
,
757 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
758 BlockDriverCompletionFunc
*cb
, void *opaque
)
760 return raw_aio_submit(bs
, sector_num
, qiov
, nb_sectors
,
761 cb
, opaque
, QEMU_AIO_READ
);
764 static BlockDriverAIOCB
*raw_aio_writev(BlockDriverState
*bs
,
765 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
766 BlockDriverCompletionFunc
*cb
, void *opaque
)
768 return raw_aio_submit(bs
, sector_num
, qiov
, nb_sectors
,
769 cb
, opaque
, QEMU_AIO_WRITE
);
772 static BlockDriverAIOCB
*raw_aio_flush(BlockDriverState
*bs
,
773 BlockDriverCompletionFunc
*cb
, void *opaque
)
775 BDRVRawState
*s
= bs
->opaque
;
780 return paio_submit(bs
, s
->fd
, 0, NULL
, 0, cb
, opaque
, QEMU_AIO_FLUSH
);
783 static void raw_close(BlockDriverState
*bs
)
785 BDRVRawState
*s
= bs
->opaque
;
792 static int raw_truncate(BlockDriverState
*bs
, int64_t offset
)
794 BDRVRawState
*s
= bs
->opaque
;
797 if (fstat(s
->fd
, &st
)) {
801 if (S_ISREG(st
.st_mode
)) {
802 if (ftruncate(s
->fd
, offset
) < 0) {
805 } else if (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
)) {
806 if (offset
> raw_getlength(bs
)) {
817 static int64_t raw_getlength(BlockDriverState
*bs
)
819 BDRVRawState
*s
= bs
->opaque
;
825 if (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
)) {
828 if (ioctl(fd
, DIOCGDINFO
, &dl
))
830 return (uint64_t)dl
.d_secsize
*
831 dl
.d_partitions
[DISKPART(st
.st_rdev
)].p_size
;
835 #elif defined(__NetBSD__)
836 static int64_t raw_getlength(BlockDriverState
*bs
)
838 BDRVRawState
*s
= bs
->opaque
;
844 if (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
)) {
845 struct dkwedge_info dkw
;
847 if (ioctl(fd
, DIOCGWEDGEINFO
, &dkw
) != -1) {
848 return dkw
.dkw_size
* 512;
852 if (ioctl(fd
, DIOCGDINFO
, &dl
))
854 return (uint64_t)dl
.d_secsize
*
855 dl
.d_partitions
[DISKPART(st
.st_rdev
)].p_size
;
860 #elif defined(__sun__)
861 static int64_t raw_getlength(BlockDriverState
*bs
)
863 BDRVRawState
*s
= bs
->opaque
;
864 struct dk_minfo minfo
;
873 * Use the DKIOCGMEDIAINFO ioctl to read the size.
875 ret
= ioctl(s
->fd
, DKIOCGMEDIAINFO
, &minfo
);
877 return minfo
.dki_lbsize
* minfo
.dki_capacity
;
881 * There are reports that lseek on some devices fails, but
882 * irc discussion said that contingency on contingency was overkill.
884 return lseek(s
->fd
, 0, SEEK_END
);
886 #elif defined(CONFIG_BSD)
887 static int64_t raw_getlength(BlockDriverState
*bs
)
889 BDRVRawState
*s
= bs
->opaque
;
893 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
902 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
905 if (!fstat(fd
, &sb
) && (S_IFCHR
& sb
.st_mode
)) {
906 #ifdef DIOCGMEDIASIZE
907 if (ioctl(fd
, DIOCGMEDIASIZE
, (off_t
*)&size
))
908 #elif defined(DIOCGPART)
911 if (ioctl(fd
, DIOCGPART
, &pi
) == 0)
912 size
= pi
.media_size
;
918 #if defined(__APPLE__) && defined(__MACH__)
919 size
= LONG_LONG_MAX
;
921 size
= lseek(fd
, 0LL, SEEK_END
);
923 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
926 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
927 if (size
== 2048LL * (unsigned)-1)
929 /* XXX no disc? maybe we need to reopen... */
930 if (size
<= 0 && !reopened
&& cdrom_reopen(bs
) >= 0) {
937 size
= lseek(fd
, 0, SEEK_END
);
942 static int64_t raw_getlength(BlockDriverState
*bs
)
944 BDRVRawState
*s
= bs
->opaque
;
952 return lseek(s
->fd
, 0, SEEK_END
);
956 static int64_t raw_get_allocated_file_size(BlockDriverState
*bs
)
959 BDRVRawState
*s
= bs
->opaque
;
961 if (fstat(s
->fd
, &st
) < 0) {
964 return (int64_t)st
.st_blocks
* 512;
967 static int raw_create(const char *filename
, QEMUOptionParameter
*options
)
971 int64_t total_size
= 0;
973 /* Read out options */
974 while (options
&& options
->name
) {
975 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
976 total_size
= options
->value
.n
/ BDRV_SECTOR_SIZE
;
981 fd
= qemu_open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
,
986 if (ftruncate(fd
, total_size
* BDRV_SECTOR_SIZE
) != 0) {
989 if (qemu_close(fd
) != 0) {
997 * Returns true iff the specified sector is present in the disk image. Drivers
998 * not implementing the functionality are assumed to not support backing files,
999 * hence all their sectors are reported as allocated.
1001 * If 'sector_num' is beyond the end of the disk image the return value is 0
1002 * and 'pnum' is set to 0.
1004 * 'pnum' is set to the number of sectors (including and immediately following
1005 * the specified sector) that are known to be in the same
1006 * allocated/unallocated state.
1008 * 'nb_sectors' is the max value 'pnum' should be set to. If nb_sectors goes
1009 * beyond the end of the disk image it will be clamped.
1011 static int coroutine_fn
raw_co_is_allocated(BlockDriverState
*bs
,
1013 int nb_sectors
, int *pnum
)
1015 off_t start
, data
, hole
;
1023 start
= sector_num
* BDRV_SECTOR_SIZE
;
1025 #ifdef CONFIG_FIEMAP
1027 BDRVRawState
*s
= bs
->opaque
;
1030 struct fiemap_extent fe
;
1033 f
.fm
.fm_start
= start
;
1034 f
.fm
.fm_length
= (int64_t)nb_sectors
* BDRV_SECTOR_SIZE
;
1036 f
.fm
.fm_extent_count
= 1;
1037 f
.fm
.fm_reserved
= 0;
1038 if (ioctl(s
->fd
, FS_IOC_FIEMAP
, &f
) == -1) {
1039 /* Assume everything is allocated. */
1044 if (f
.fm
.fm_mapped_extents
== 0) {
1045 /* No extents found, data is beyond f.fm.fm_start + f.fm.fm_length.
1046 * f.fm.fm_start + f.fm.fm_length must be clamped to the file size!
1048 off_t length
= lseek(s
->fd
, 0, SEEK_END
);
1049 hole
= f
.fm
.fm_start
;
1050 data
= MIN(f
.fm
.fm_start
+ f
.fm
.fm_length
, length
);
1052 data
= f
.fe
.fe_logical
;
1053 hole
= f
.fe
.fe_logical
+ f
.fe
.fe_length
;
1056 #elif defined SEEK_HOLE && defined SEEK_DATA
1058 BDRVRawState
*s
= bs
->opaque
;
1060 hole
= lseek(s
->fd
, start
, SEEK_HOLE
);
1062 /* -ENXIO indicates that sector_num was past the end of the file.
1063 * There is a virtual hole there. */
1064 assert(errno
!= -ENXIO
);
1066 /* Most likely EINVAL. Assume everything is allocated. */
1074 /* On a hole. We need another syscall to find its end. */
1075 data
= lseek(s
->fd
, start
, SEEK_DATA
);
1077 data
= lseek(s
->fd
, 0, SEEK_END
);
1085 if (data
<= start
) {
1086 /* On a data extent, compute sectors to the end of the extent. */
1087 *pnum
= MIN(nb_sectors
, (hole
- start
) / BDRV_SECTOR_SIZE
);
1090 /* On a hole, compute sectors to the beginning of the next extent. */
1091 *pnum
= MIN(nb_sectors
, (data
- start
) / BDRV_SECTOR_SIZE
);
1097 static int xfs_discard(BDRVRawState
*s
, int64_t sector_num
, int nb_sectors
)
1099 struct xfs_flock64 fl
;
1101 memset(&fl
, 0, sizeof(fl
));
1102 fl
.l_whence
= SEEK_SET
;
1103 fl
.l_start
= sector_num
<< 9;
1104 fl
.l_len
= (int64_t)nb_sectors
<< 9;
1106 if (xfsctl(NULL
, s
->fd
, XFS_IOC_UNRESVSP64
, &fl
) < 0) {
1107 DEBUG_BLOCK_PRINT("cannot punch hole (%s)\n", strerror(errno
));
1115 static coroutine_fn
int raw_co_discard(BlockDriverState
*bs
,
1116 int64_t sector_num
, int nb_sectors
)
1119 BDRVRawState
*s
= bs
->opaque
;
1122 return xfs_discard(s
, sector_num
, nb_sectors
);
1129 static QEMUOptionParameter raw_create_options
[] = {
1131 .name
= BLOCK_OPT_SIZE
,
1133 .help
= "Virtual disk size"
1138 static BlockDriver bdrv_file
= {
1139 .format_name
= "file",
1140 .protocol_name
= "file",
1141 .instance_size
= sizeof(BDRVRawState
),
1142 .bdrv_probe
= NULL
, /* no probe for protocols */
1143 .bdrv_file_open
= raw_open
,
1144 .bdrv_reopen_prepare
= raw_reopen_prepare
,
1145 .bdrv_reopen_commit
= raw_reopen_commit
,
1146 .bdrv_reopen_abort
= raw_reopen_abort
,
1147 .bdrv_close
= raw_close
,
1148 .bdrv_create
= raw_create
,
1149 .bdrv_co_discard
= raw_co_discard
,
1150 .bdrv_co_is_allocated
= raw_co_is_allocated
,
1152 .bdrv_aio_readv
= raw_aio_readv
,
1153 .bdrv_aio_writev
= raw_aio_writev
,
1154 .bdrv_aio_flush
= raw_aio_flush
,
1156 .bdrv_truncate
= raw_truncate
,
1157 .bdrv_getlength
= raw_getlength
,
1158 .bdrv_get_allocated_file_size
1159 = raw_get_allocated_file_size
,
1161 .create_options
= raw_create_options
,
1164 /***********************************************/
1167 #if defined(__APPLE__) && defined(__MACH__)
1168 static kern_return_t
FindEjectableCDMedia( io_iterator_t
*mediaIterator
);
1169 static kern_return_t
GetBSDPath( io_iterator_t mediaIterator
, char *bsdPath
, CFIndex maxPathSize
);
1171 kern_return_t
FindEjectableCDMedia( io_iterator_t
*mediaIterator
)
1173 kern_return_t kernResult
;
1174 mach_port_t masterPort
;
1175 CFMutableDictionaryRef classesToMatch
;
1177 kernResult
= IOMasterPort( MACH_PORT_NULL
, &masterPort
);
1178 if ( KERN_SUCCESS
!= kernResult
) {
1179 printf( "IOMasterPort returned %d\n", kernResult
);
1182 classesToMatch
= IOServiceMatching( kIOCDMediaClass
);
1183 if ( classesToMatch
== NULL
) {
1184 printf( "IOServiceMatching returned a NULL dictionary.\n" );
1186 CFDictionarySetValue( classesToMatch
, CFSTR( kIOMediaEjectableKey
), kCFBooleanTrue
);
1188 kernResult
= IOServiceGetMatchingServices( masterPort
, classesToMatch
, mediaIterator
);
1189 if ( KERN_SUCCESS
!= kernResult
)
1191 printf( "IOServiceGetMatchingServices returned %d\n", kernResult
);
1197 kern_return_t
GetBSDPath( io_iterator_t mediaIterator
, char *bsdPath
, CFIndex maxPathSize
)
1199 io_object_t nextMedia
;
1200 kern_return_t kernResult
= KERN_FAILURE
;
1202 nextMedia
= IOIteratorNext( mediaIterator
);
1205 CFTypeRef bsdPathAsCFString
;
1206 bsdPathAsCFString
= IORegistryEntryCreateCFProperty( nextMedia
, CFSTR( kIOBSDNameKey
), kCFAllocatorDefault
, 0 );
1207 if ( bsdPathAsCFString
) {
1208 size_t devPathLength
;
1209 strcpy( bsdPath
, _PATH_DEV
);
1210 strcat( bsdPath
, "r" );
1211 devPathLength
= strlen( bsdPath
);
1212 if ( CFStringGetCString( bsdPathAsCFString
, bsdPath
+ devPathLength
, maxPathSize
- devPathLength
, kCFStringEncodingASCII
) ) {
1213 kernResult
= KERN_SUCCESS
;
1215 CFRelease( bsdPathAsCFString
);
1217 IOObjectRelease( nextMedia
);
1225 static int hdev_probe_device(const char *filename
)
1229 /* allow a dedicated CD-ROM driver to match with a higher priority */
1230 if (strstart(filename
, "/dev/cdrom", NULL
))
1233 if (stat(filename
, &st
) >= 0 &&
1234 (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
))) {
1241 static int hdev_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1243 BDRVRawState
*s
= bs
->opaque
;
1245 #if defined(__APPLE__) && defined(__MACH__)
1246 if (strstart(filename
, "/dev/cdrom", NULL
)) {
1247 kern_return_t kernResult
;
1248 io_iterator_t mediaIterator
;
1249 char bsdPath
[ MAXPATHLEN
];
1252 kernResult
= FindEjectableCDMedia( &mediaIterator
);
1253 kernResult
= GetBSDPath( mediaIterator
, bsdPath
, sizeof( bsdPath
) );
1255 if ( bsdPath
[ 0 ] != '\0' ) {
1256 strcat(bsdPath
,"s0");
1257 /* some CDs don't have a partition 0 */
1258 fd
= qemu_open(bsdPath
, O_RDONLY
| O_BINARY
| O_LARGEFILE
);
1260 bsdPath
[strlen(bsdPath
)-1] = '1';
1267 if ( mediaIterator
)
1268 IOObjectRelease( mediaIterator
);
1272 s
->type
= FTYPE_FILE
;
1273 #if defined(__linux__)
1275 char resolved_path
[ MAXPATHLEN
], *temp
;
1277 temp
= realpath(filename
, resolved_path
);
1278 if (temp
&& strstart(temp
, "/dev/sg", NULL
)) {
1284 return raw_open_common(bs
, filename
, flags
, 0);
1287 #if defined(__linux__)
1288 /* Note: we do not have a reliable method to detect if the floppy is
1289 present. The current method is to try to open the floppy at every
1290 I/O and to keep it opened during a few hundreds of ms. */
1291 static int fd_open(BlockDriverState
*bs
)
1293 BDRVRawState
*s
= bs
->opaque
;
1294 int last_media_present
;
1296 if (s
->type
!= FTYPE_FD
)
1298 last_media_present
= (s
->fd
>= 0);
1300 (get_clock() - s
->fd_open_time
) >= FD_OPEN_TIMEOUT
) {
1304 printf("Floppy closed\n");
1308 if (s
->fd_got_error
&&
1309 (get_clock() - s
->fd_error_time
) < FD_OPEN_TIMEOUT
) {
1311 printf("No floppy (open delayed)\n");
1315 s
->fd
= qemu_open(bs
->filename
, s
->open_flags
& ~O_NONBLOCK
);
1317 s
->fd_error_time
= get_clock();
1318 s
->fd_got_error
= 1;
1319 if (last_media_present
)
1320 s
->fd_media_changed
= 1;
1322 printf("No floppy\n");
1327 printf("Floppy opened\n");
1330 if (!last_media_present
)
1331 s
->fd_media_changed
= 1;
1332 s
->fd_open_time
= get_clock();
1333 s
->fd_got_error
= 0;
1337 static int hdev_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
1339 BDRVRawState
*s
= bs
->opaque
;
1341 return ioctl(s
->fd
, req
, buf
);
1344 static BlockDriverAIOCB
*hdev_aio_ioctl(BlockDriverState
*bs
,
1345 unsigned long int req
, void *buf
,
1346 BlockDriverCompletionFunc
*cb
, void *opaque
)
1348 BDRVRawState
*s
= bs
->opaque
;
1350 if (fd_open(bs
) < 0)
1352 return paio_ioctl(bs
, s
->fd
, req
, buf
, cb
, opaque
);
1355 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1356 static int fd_open(BlockDriverState
*bs
)
1358 BDRVRawState
*s
= bs
->opaque
;
1360 /* this is just to ensure s->fd is sane (its called by io ops) */
1365 #else /* !linux && !FreeBSD */
1367 static int fd_open(BlockDriverState
*bs
)
1372 #endif /* !linux && !FreeBSD */
1374 static int hdev_create(const char *filename
, QEMUOptionParameter
*options
)
1378 struct stat stat_buf
;
1379 int64_t total_size
= 0;
1381 /* Read out options */
1382 while (options
&& options
->name
) {
1383 if (!strcmp(options
->name
, "size")) {
1384 total_size
= options
->value
.n
/ BDRV_SECTOR_SIZE
;
1389 fd
= qemu_open(filename
, O_WRONLY
| O_BINARY
);
1393 if (fstat(fd
, &stat_buf
) < 0)
1395 else if (!S_ISBLK(stat_buf
.st_mode
) && !S_ISCHR(stat_buf
.st_mode
))
1397 else if (lseek(fd
, 0, SEEK_END
) < total_size
* BDRV_SECTOR_SIZE
)
1404 static int hdev_has_zero_init(BlockDriverState
*bs
)
1409 static BlockDriver bdrv_host_device
= {
1410 .format_name
= "host_device",
1411 .protocol_name
= "host_device",
1412 .instance_size
= sizeof(BDRVRawState
),
1413 .bdrv_probe_device
= hdev_probe_device
,
1414 .bdrv_file_open
= hdev_open
,
1415 .bdrv_close
= raw_close
,
1416 .bdrv_reopen_prepare
= raw_reopen_prepare
,
1417 .bdrv_reopen_commit
= raw_reopen_commit
,
1418 .bdrv_reopen_abort
= raw_reopen_abort
,
1419 .bdrv_create
= hdev_create
,
1420 .create_options
= raw_create_options
,
1421 .bdrv_has_zero_init
= hdev_has_zero_init
,
1423 .bdrv_aio_readv
= raw_aio_readv
,
1424 .bdrv_aio_writev
= raw_aio_writev
,
1425 .bdrv_aio_flush
= raw_aio_flush
,
1427 .bdrv_truncate
= raw_truncate
,
1428 .bdrv_getlength
= raw_getlength
,
1429 .bdrv_get_allocated_file_size
1430 = raw_get_allocated_file_size
,
1432 /* generic scsi device */
1434 .bdrv_ioctl
= hdev_ioctl
,
1435 .bdrv_aio_ioctl
= hdev_aio_ioctl
,
1440 static int floppy_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1442 BDRVRawState
*s
= bs
->opaque
;
1447 /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */
1448 ret
= raw_open_common(bs
, filename
, flags
, O_NONBLOCK
);
1452 /* close fd so that we can reopen it as needed */
1455 s
->fd_media_changed
= 1;
1460 static int floppy_probe_device(const char *filename
)
1464 struct floppy_struct fdparam
;
1467 if (strstart(filename
, "/dev/fd", NULL
) &&
1468 !strstart(filename
, "/dev/fdset/", NULL
)) {
1472 fd
= qemu_open(filename
, O_RDONLY
| O_NONBLOCK
);
1476 ret
= fstat(fd
, &st
);
1477 if (ret
== -1 || !S_ISBLK(st
.st_mode
)) {
1481 /* Attempt to detect via a floppy specific ioctl */
1482 ret
= ioctl(fd
, FDGETPRM
, &fdparam
);
1493 static int floppy_is_inserted(BlockDriverState
*bs
)
1495 return fd_open(bs
) >= 0;
1498 static int floppy_media_changed(BlockDriverState
*bs
)
1500 BDRVRawState
*s
= bs
->opaque
;
1504 * XXX: we do not have a true media changed indication.
1505 * It does not work if the floppy is changed without trying to read it.
1508 ret
= s
->fd_media_changed
;
1509 s
->fd_media_changed
= 0;
1511 printf("Floppy changed=%d\n", ret
);
1516 static void floppy_eject(BlockDriverState
*bs
, bool eject_flag
)
1518 BDRVRawState
*s
= bs
->opaque
;
1525 fd
= qemu_open(bs
->filename
, s
->open_flags
| O_NONBLOCK
);
1527 if (ioctl(fd
, FDEJECT
, 0) < 0)
1533 static BlockDriver bdrv_host_floppy
= {
1534 .format_name
= "host_floppy",
1535 .protocol_name
= "host_floppy",
1536 .instance_size
= sizeof(BDRVRawState
),
1537 .bdrv_probe_device
= floppy_probe_device
,
1538 .bdrv_file_open
= floppy_open
,
1539 .bdrv_close
= raw_close
,
1540 .bdrv_reopen_prepare
= raw_reopen_prepare
,
1541 .bdrv_reopen_commit
= raw_reopen_commit
,
1542 .bdrv_reopen_abort
= raw_reopen_abort
,
1543 .bdrv_create
= hdev_create
,
1544 .create_options
= raw_create_options
,
1545 .bdrv_has_zero_init
= hdev_has_zero_init
,
1547 .bdrv_aio_readv
= raw_aio_readv
,
1548 .bdrv_aio_writev
= raw_aio_writev
,
1549 .bdrv_aio_flush
= raw_aio_flush
,
1551 .bdrv_truncate
= raw_truncate
,
1552 .bdrv_getlength
= raw_getlength
,
1553 .bdrv_get_allocated_file_size
1554 = raw_get_allocated_file_size
,
1556 /* removable device support */
1557 .bdrv_is_inserted
= floppy_is_inserted
,
1558 .bdrv_media_changed
= floppy_media_changed
,
1559 .bdrv_eject
= floppy_eject
,
1562 static int cdrom_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1564 BDRVRawState
*s
= bs
->opaque
;
1568 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
1569 return raw_open_common(bs
, filename
, flags
, O_NONBLOCK
);
1572 static int cdrom_probe_device(const char *filename
)
1578 fd
= qemu_open(filename
, O_RDONLY
| O_NONBLOCK
);
1582 ret
= fstat(fd
, &st
);
1583 if (ret
== -1 || !S_ISBLK(st
.st_mode
)) {
1587 /* Attempt to detect via a CDROM specific ioctl */
1588 ret
= ioctl(fd
, CDROM_DRIVE_STATUS
, CDSL_CURRENT
);
1598 static int cdrom_is_inserted(BlockDriverState
*bs
)
1600 BDRVRawState
*s
= bs
->opaque
;
1603 ret
= ioctl(s
->fd
, CDROM_DRIVE_STATUS
, CDSL_CURRENT
);
1604 if (ret
== CDS_DISC_OK
)
1609 static void cdrom_eject(BlockDriverState
*bs
, bool eject_flag
)
1611 BDRVRawState
*s
= bs
->opaque
;
1614 if (ioctl(s
->fd
, CDROMEJECT
, NULL
) < 0)
1615 perror("CDROMEJECT");
1617 if (ioctl(s
->fd
, CDROMCLOSETRAY
, NULL
) < 0)
1618 perror("CDROMEJECT");
1622 static void cdrom_lock_medium(BlockDriverState
*bs
, bool locked
)
1624 BDRVRawState
*s
= bs
->opaque
;
1626 if (ioctl(s
->fd
, CDROM_LOCKDOOR
, locked
) < 0) {
1628 * Note: an error can happen if the distribution automatically
1631 /* perror("CDROM_LOCKDOOR"); */
1635 static BlockDriver bdrv_host_cdrom
= {
1636 .format_name
= "host_cdrom",
1637 .protocol_name
= "host_cdrom",
1638 .instance_size
= sizeof(BDRVRawState
),
1639 .bdrv_probe_device
= cdrom_probe_device
,
1640 .bdrv_file_open
= cdrom_open
,
1641 .bdrv_close
= raw_close
,
1642 .bdrv_reopen_prepare
= raw_reopen_prepare
,
1643 .bdrv_reopen_commit
= raw_reopen_commit
,
1644 .bdrv_reopen_abort
= raw_reopen_abort
,
1645 .bdrv_create
= hdev_create
,
1646 .create_options
= raw_create_options
,
1647 .bdrv_has_zero_init
= hdev_has_zero_init
,
1649 .bdrv_aio_readv
= raw_aio_readv
,
1650 .bdrv_aio_writev
= raw_aio_writev
,
1651 .bdrv_aio_flush
= raw_aio_flush
,
1653 .bdrv_truncate
= raw_truncate
,
1654 .bdrv_getlength
= raw_getlength
,
1655 .bdrv_get_allocated_file_size
1656 = raw_get_allocated_file_size
,
1658 /* removable device support */
1659 .bdrv_is_inserted
= cdrom_is_inserted
,
1660 .bdrv_eject
= cdrom_eject
,
1661 .bdrv_lock_medium
= cdrom_lock_medium
,
1663 /* generic scsi device */
1664 .bdrv_ioctl
= hdev_ioctl
,
1665 .bdrv_aio_ioctl
= hdev_aio_ioctl
,
1667 #endif /* __linux__ */
1669 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1670 static int cdrom_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1672 BDRVRawState
*s
= bs
->opaque
;
1677 ret
= raw_open_common(bs
, filename
, flags
, 0);
1681 /* make sure the door isn't locked at this time */
1682 ioctl(s
->fd
, CDIOCALLOW
);
1686 static int cdrom_probe_device(const char *filename
)
1688 if (strstart(filename
, "/dev/cd", NULL
) ||
1689 strstart(filename
, "/dev/acd", NULL
))
1694 static int cdrom_reopen(BlockDriverState
*bs
)
1696 BDRVRawState
*s
= bs
->opaque
;
1700 * Force reread of possibly changed/newly loaded disc,
1701 * FreeBSD seems to not notice sometimes...
1705 fd
= qemu_open(bs
->filename
, s
->open_flags
, 0644);
1712 /* make sure the door isn't locked at this time */
1713 ioctl(s
->fd
, CDIOCALLOW
);
1717 static int cdrom_is_inserted(BlockDriverState
*bs
)
1719 return raw_getlength(bs
) > 0;
1722 static void cdrom_eject(BlockDriverState
*bs
, bool eject_flag
)
1724 BDRVRawState
*s
= bs
->opaque
;
1729 (void) ioctl(s
->fd
, CDIOCALLOW
);
1732 if (ioctl(s
->fd
, CDIOCEJECT
) < 0)
1733 perror("CDIOCEJECT");
1735 if (ioctl(s
->fd
, CDIOCCLOSE
) < 0)
1736 perror("CDIOCCLOSE");
1742 static void cdrom_lock_medium(BlockDriverState
*bs
, bool locked
)
1744 BDRVRawState
*s
= bs
->opaque
;
1748 if (ioctl(s
->fd
, (locked
? CDIOCPREVENT
: CDIOCALLOW
)) < 0) {
1750 * Note: an error can happen if the distribution automatically
1753 /* perror("CDROM_LOCKDOOR"); */
1757 static BlockDriver bdrv_host_cdrom
= {
1758 .format_name
= "host_cdrom",
1759 .protocol_name
= "host_cdrom",
1760 .instance_size
= sizeof(BDRVRawState
),
1761 .bdrv_probe_device
= cdrom_probe_device
,
1762 .bdrv_file_open
= cdrom_open
,
1763 .bdrv_close
= raw_close
,
1764 .bdrv_reopen_prepare
= raw_reopen_prepare
,
1765 .bdrv_reopen_commit
= raw_reopen_commit
,
1766 .bdrv_reopen_abort
= raw_reopen_abort
,
1767 .bdrv_create
= hdev_create
,
1768 .create_options
= raw_create_options
,
1769 .bdrv_has_zero_init
= hdev_has_zero_init
,
1771 .bdrv_aio_readv
= raw_aio_readv
,
1772 .bdrv_aio_writev
= raw_aio_writev
,
1773 .bdrv_aio_flush
= raw_aio_flush
,
1775 .bdrv_truncate
= raw_truncate
,
1776 .bdrv_getlength
= raw_getlength
,
1777 .bdrv_get_allocated_file_size
1778 = raw_get_allocated_file_size
,
1780 /* removable device support */
1781 .bdrv_is_inserted
= cdrom_is_inserted
,
1782 .bdrv_eject
= cdrom_eject
,
1783 .bdrv_lock_medium
= cdrom_lock_medium
,
1785 #endif /* __FreeBSD__ */
1787 static void bdrv_file_init(void)
1790 * Register all the drivers. Note that order is important, the driver
1791 * registered last will get probed first.
1793 bdrv_register(&bdrv_file
);
1794 bdrv_register(&bdrv_host_device
);
1796 bdrv_register(&bdrv_host_floppy
);
1797 bdrv_register(&bdrv_host_cdrom
);
1799 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1800 bdrv_register(&bdrv_host_cdrom
);
1804 block_init(bdrv_file_init
);