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"
30 #include "block/raw-posix-aio.h"
34 #include <sys/param.h>
35 #include <IOKit/IOKitLib.h>
36 #include <IOKit/IOBSD.h>
37 #include <IOKit/storage/IOMediaBSDClient.h>
38 #include <IOKit/storage/IOMedia.h>
39 #include <IOKit/storage/IOCDMedia.h>
40 //#include <IOKit/storage/IOCDTypes.h>
41 #include <CoreFoundation/CoreFoundation.h>
45 #define _POSIX_PTHREAD_SEMANTICS 1
49 #include <sys/types.h>
51 #include <sys/ioctl.h>
52 #include <sys/param.h>
53 #include <linux/cdrom.h>
56 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
62 #include <sys/ioctl.h>
63 #include <sys/disklabel.h>
68 #include <sys/ioctl.h>
69 #include <sys/disklabel.h>
75 #include <sys/ioctl.h>
76 #include <sys/diskslice.h>
83 //#define DEBUG_FLOPPY
86 #if defined(DEBUG_BLOCK)
87 #define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \
88 { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0)
90 #define DEBUG_BLOCK_PRINT(formatCstr, ...)
93 /* OS X does not have O_DSYNC */
96 #define O_DSYNC O_SYNC
97 #elif defined(O_FSYNC)
98 #define O_DSYNC O_FSYNC
102 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
104 #define O_DIRECT O_DSYNC
111 /* if the FD is not accessed during that time (in ns), we try to
112 reopen it to see if the disk has been changed */
113 #define FD_OPEN_TIMEOUT (1000000000)
115 #define MAX_BLOCKSIZE 4096
117 typedef struct BDRVRawState
{
121 #if defined(__linux__)
122 /* linux floppy specific */
123 int64_t fd_open_time
;
124 int64_t fd_error_time
;
126 int fd_media_changed
;
128 #ifdef CONFIG_LINUX_AIO
132 uint8_t *aligned_buf
;
133 unsigned aligned_buf_size
;
139 static int fd_open(BlockDriverState
*bs
);
140 static int64_t raw_getlength(BlockDriverState
*bs
);
142 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
143 static int cdrom_reopen(BlockDriverState
*bs
);
146 #if defined(__NetBSD__)
147 static int raw_normalize_devicepath(const char **filename
)
149 static char namebuf
[PATH_MAX
];
150 const char *dp
, *fname
;
154 dp
= strrchr(fname
, '/');
155 if (lstat(fname
, &sb
) < 0) {
156 fprintf(stderr
, "%s: stat failed: %s\n",
157 fname
, strerror(errno
));
161 if (!S_ISBLK(sb
.st_mode
)) {
166 snprintf(namebuf
, PATH_MAX
, "r%s", fname
);
168 snprintf(namebuf
, PATH_MAX
, "%.*s/r%s",
169 (int)(dp
- fname
), fname
, dp
+ 1);
171 fprintf(stderr
, "%s is a block device", fname
);
173 fprintf(stderr
, ", using %s\n", *filename
);
178 static int raw_normalize_devicepath(const char **filename
)
184 static int raw_open_common(BlockDriverState
*bs
, const char *filename
,
185 int bdrv_flags
, int open_flags
)
187 BDRVRawState
*s
= bs
->opaque
;
190 ret
= raw_normalize_devicepath(&filename
);
195 s
->open_flags
= open_flags
| O_BINARY
;
196 s
->open_flags
&= ~O_ACCMODE
;
197 if (bdrv_flags
& BDRV_O_RDWR
) {
198 s
->open_flags
|= O_RDWR
;
200 s
->open_flags
|= O_RDONLY
;
203 /* Use O_DSYNC for write-through caching, no flags for write-back caching,
204 * and O_DIRECT for no caching. */
205 if ((bdrv_flags
& BDRV_O_NOCACHE
))
206 s
->open_flags
|= O_DIRECT
;
207 if (!(bdrv_flags
& BDRV_O_CACHE_WB
))
208 s
->open_flags
|= O_DSYNC
;
211 fd
= qemu_open(filename
, s
->open_flags
, 0644);
219 s
->aligned_buf
= NULL
;
221 if ((bdrv_flags
& BDRV_O_NOCACHE
)) {
223 * Allocate a buffer for read/modify/write cycles. Chose the size
224 * pessimistically as we don't know the block size yet.
226 s
->aligned_buf_size
= 32 * MAX_BLOCKSIZE
;
227 s
->aligned_buf
= qemu_memalign(MAX_BLOCKSIZE
, s
->aligned_buf_size
);
228 if (s
->aligned_buf
== NULL
) {
233 /* We're falling back to POSIX AIO in some cases so init always */
234 if (paio_init() < 0) {
238 #ifdef CONFIG_LINUX_AIO
240 * Currently Linux do AIO only for files opened with O_DIRECT
241 * specified so check NOCACHE flag too
243 if ((bdrv_flags
& (BDRV_O_NOCACHE
|BDRV_O_NATIVE_AIO
)) ==
244 (BDRV_O_NOCACHE
|BDRV_O_NATIVE_AIO
)) {
246 s
->aio_ctx
= laio_init();
254 #ifdef CONFIG_LINUX_AIO
260 if (platform_test_xfs_fd(s
->fd
)) {
268 qemu_vfree(s
->aligned_buf
);
274 static int raw_open(BlockDriverState
*bs
, const char *filename
, int flags
)
276 BDRVRawState
*s
= bs
->opaque
;
278 s
->type
= FTYPE_FILE
;
279 return raw_open_common(bs
, filename
, flags
, 0);
282 /* XXX: use host sector size if necessary with:
283 #ifdef DIOCGSECTORSIZE
285 unsigned int sectorsize = 512;
286 if (!ioctl(fd, DIOCGSECTORSIZE, §orsize) &&
287 sectorsize > bufsize)
288 bufsize = sectorsize;
292 uint32_t blockSize = 512;
293 if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) {
300 * Check if all memory in this vector is sector aligned.
302 static int qiov_is_aligned(BlockDriverState
*bs
, QEMUIOVector
*qiov
)
306 for (i
= 0; i
< qiov
->niov
; i
++) {
307 if ((uintptr_t) qiov
->iov
[i
].iov_base
% bs
->buffer_alignment
) {
315 static BlockDriverAIOCB
*raw_aio_submit(BlockDriverState
*bs
,
316 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
317 BlockDriverCompletionFunc
*cb
, void *opaque
, int type
)
319 BDRVRawState
*s
= bs
->opaque
;
325 * If O_DIRECT is used the buffer needs to be aligned on a sector
326 * boundary. Check if this is the case or tell the low-level
327 * driver that it needs to copy the buffer.
329 if (s
->aligned_buf
) {
330 if (!qiov_is_aligned(bs
, qiov
)) {
331 type
|= QEMU_AIO_MISALIGNED
;
332 #ifdef CONFIG_LINUX_AIO
333 } else if (s
->use_aio
) {
334 return laio_submit(bs
, s
->aio_ctx
, s
->fd
, sector_num
, qiov
,
335 nb_sectors
, cb
, opaque
, type
);
340 return paio_submit(bs
, s
->fd
, sector_num
, qiov
, nb_sectors
,
344 static BlockDriverAIOCB
*raw_aio_readv(BlockDriverState
*bs
,
345 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
346 BlockDriverCompletionFunc
*cb
, void *opaque
)
348 return raw_aio_submit(bs
, sector_num
, qiov
, nb_sectors
,
349 cb
, opaque
, QEMU_AIO_READ
);
352 static BlockDriverAIOCB
*raw_aio_writev(BlockDriverState
*bs
,
353 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
354 BlockDriverCompletionFunc
*cb
, void *opaque
)
356 return raw_aio_submit(bs
, sector_num
, qiov
, nb_sectors
,
357 cb
, opaque
, QEMU_AIO_WRITE
);
360 static BlockDriverAIOCB
*raw_aio_flush(BlockDriverState
*bs
,
361 BlockDriverCompletionFunc
*cb
, void *opaque
)
363 BDRVRawState
*s
= bs
->opaque
;
368 return paio_submit(bs
, s
->fd
, 0, NULL
, 0, cb
, opaque
, QEMU_AIO_FLUSH
);
371 static void raw_close(BlockDriverState
*bs
)
373 BDRVRawState
*s
= bs
->opaque
;
377 if (s
->aligned_buf
!= NULL
)
378 qemu_vfree(s
->aligned_buf
);
382 static int raw_truncate(BlockDriverState
*bs
, int64_t offset
)
384 BDRVRawState
*s
= bs
->opaque
;
387 if (fstat(s
->fd
, &st
)) {
391 if (S_ISREG(st
.st_mode
)) {
392 if (ftruncate(s
->fd
, offset
) < 0) {
395 } else if (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
)) {
396 if (offset
> raw_getlength(bs
)) {
407 static int64_t raw_getlength(BlockDriverState
*bs
)
409 BDRVRawState
*s
= bs
->opaque
;
415 if (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
)) {
418 if (ioctl(fd
, DIOCGDINFO
, &dl
))
420 return (uint64_t)dl
.d_secsize
*
421 dl
.d_partitions
[DISKPART(st
.st_rdev
)].p_size
;
425 #elif defined(__NetBSD__)
426 static int64_t raw_getlength(BlockDriverState
*bs
)
428 BDRVRawState
*s
= bs
->opaque
;
434 if (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
)) {
435 struct dkwedge_info dkw
;
437 if (ioctl(fd
, DIOCGWEDGEINFO
, &dkw
) != -1) {
438 return dkw
.dkw_size
* 512;
442 if (ioctl(fd
, DIOCGDINFO
, &dl
))
444 return (uint64_t)dl
.d_secsize
*
445 dl
.d_partitions
[DISKPART(st
.st_rdev
)].p_size
;
450 #elif defined(__sun__)
451 static int64_t raw_getlength(BlockDriverState
*bs
)
453 BDRVRawState
*s
= bs
->opaque
;
454 struct dk_minfo minfo
;
463 * Use the DKIOCGMEDIAINFO ioctl to read the size.
465 ret
= ioctl(s
->fd
, DKIOCGMEDIAINFO
, &minfo
);
467 return minfo
.dki_lbsize
* minfo
.dki_capacity
;
471 * There are reports that lseek on some devices fails, but
472 * irc discussion said that contingency on contingency was overkill.
474 return lseek(s
->fd
, 0, SEEK_END
);
476 #elif defined(CONFIG_BSD)
477 static int64_t raw_getlength(BlockDriverState
*bs
)
479 BDRVRawState
*s
= bs
->opaque
;
483 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
492 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
495 if (!fstat(fd
, &sb
) && (S_IFCHR
& sb
.st_mode
)) {
496 #ifdef DIOCGMEDIASIZE
497 if (ioctl(fd
, DIOCGMEDIASIZE
, (off_t
*)&size
))
498 #elif defined(DIOCGPART)
501 if (ioctl(fd
, DIOCGPART
, &pi
) == 0)
502 size
= pi
.media_size
;
509 size
= LONG_LONG_MAX
;
511 size
= lseek(fd
, 0LL, SEEK_END
);
513 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
516 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
517 if (size
== 2048LL * (unsigned)-1)
519 /* XXX no disc? maybe we need to reopen... */
520 if (size
<= 0 && !reopened
&& cdrom_reopen(bs
) >= 0) {
527 size
= lseek(fd
, 0, SEEK_END
);
532 static int64_t raw_getlength(BlockDriverState
*bs
)
534 BDRVRawState
*s
= bs
->opaque
;
542 return lseek(s
->fd
, 0, SEEK_END
);
546 static int64_t raw_get_allocated_file_size(BlockDriverState
*bs
)
549 BDRVRawState
*s
= bs
->opaque
;
551 if (fstat(s
->fd
, &st
) < 0) {
554 return (int64_t)st
.st_blocks
* 512;
557 static int raw_create(const char *filename
, QEMUOptionParameter
*options
)
561 int64_t total_size
= 0;
563 /* Read out options */
564 while (options
&& options
->name
) {
565 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
566 total_size
= options
->value
.n
/ BDRV_SECTOR_SIZE
;
571 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
,
576 if (ftruncate(fd
, total_size
* BDRV_SECTOR_SIZE
) != 0) {
579 if (close(fd
) != 0) {
586 static int raw_flush(BlockDriverState
*bs
)
588 BDRVRawState
*s
= bs
->opaque
;
591 ret
= qemu_fdatasync(s
->fd
);
600 static int xfs_discard(BDRVRawState
*s
, int64_t sector_num
, int nb_sectors
)
602 struct xfs_flock64 fl
;
604 memset(&fl
, 0, sizeof(fl
));
605 fl
.l_whence
= SEEK_SET
;
606 fl
.l_start
= sector_num
<< 9;
607 fl
.l_len
= (int64_t)nb_sectors
<< 9;
609 if (xfsctl(NULL
, s
->fd
, XFS_IOC_UNRESVSP64
, &fl
) < 0) {
610 DEBUG_BLOCK_PRINT("cannot punch hole (%s)\n", strerror(errno
));
618 static int raw_discard(BlockDriverState
*bs
, int64_t sector_num
, int nb_sectors
)
621 BDRVRawState
*s
= bs
->opaque
;
624 return xfs_discard(s
, sector_num
, nb_sectors
);
631 static QEMUOptionParameter raw_create_options
[] = {
633 .name
= BLOCK_OPT_SIZE
,
635 .help
= "Virtual disk size"
640 static BlockDriver bdrv_file
= {
641 .format_name
= "file",
642 .protocol_name
= "file",
643 .instance_size
= sizeof(BDRVRawState
),
644 .bdrv_probe
= NULL
, /* no probe for protocols */
645 .bdrv_file_open
= raw_open
,
646 .bdrv_close
= raw_close
,
647 .bdrv_create
= raw_create
,
648 .bdrv_flush
= raw_flush
,
649 .bdrv_discard
= raw_discard
,
651 .bdrv_aio_readv
= raw_aio_readv
,
652 .bdrv_aio_writev
= raw_aio_writev
,
653 .bdrv_aio_flush
= raw_aio_flush
,
655 .bdrv_truncate
= raw_truncate
,
656 .bdrv_getlength
= raw_getlength
,
657 .bdrv_get_allocated_file_size
658 = raw_get_allocated_file_size
,
660 .create_options
= raw_create_options
,
663 /***********************************************/
667 static kern_return_t
FindEjectableCDMedia( io_iterator_t
*mediaIterator
);
668 static kern_return_t
GetBSDPath( io_iterator_t mediaIterator
, char *bsdPath
, CFIndex maxPathSize
);
670 kern_return_t
FindEjectableCDMedia( io_iterator_t
*mediaIterator
)
672 kern_return_t kernResult
;
673 mach_port_t masterPort
;
674 CFMutableDictionaryRef classesToMatch
;
676 kernResult
= IOMasterPort( MACH_PORT_NULL
, &masterPort
);
677 if ( KERN_SUCCESS
!= kernResult
) {
678 printf( "IOMasterPort returned %d\n", kernResult
);
681 classesToMatch
= IOServiceMatching( kIOCDMediaClass
);
682 if ( classesToMatch
== NULL
) {
683 printf( "IOServiceMatching returned a NULL dictionary.\n" );
685 CFDictionarySetValue( classesToMatch
, CFSTR( kIOMediaEjectableKey
), kCFBooleanTrue
);
687 kernResult
= IOServiceGetMatchingServices( masterPort
, classesToMatch
, mediaIterator
);
688 if ( KERN_SUCCESS
!= kernResult
)
690 printf( "IOServiceGetMatchingServices returned %d\n", kernResult
);
696 kern_return_t
GetBSDPath( io_iterator_t mediaIterator
, char *bsdPath
, CFIndex maxPathSize
)
698 io_object_t nextMedia
;
699 kern_return_t kernResult
= KERN_FAILURE
;
701 nextMedia
= IOIteratorNext( mediaIterator
);
704 CFTypeRef bsdPathAsCFString
;
705 bsdPathAsCFString
= IORegistryEntryCreateCFProperty( nextMedia
, CFSTR( kIOBSDNameKey
), kCFAllocatorDefault
, 0 );
706 if ( bsdPathAsCFString
) {
707 size_t devPathLength
;
708 strcpy( bsdPath
, _PATH_DEV
);
709 strcat( bsdPath
, "r" );
710 devPathLength
= strlen( bsdPath
);
711 if ( CFStringGetCString( bsdPathAsCFString
, bsdPath
+ devPathLength
, maxPathSize
- devPathLength
, kCFStringEncodingASCII
) ) {
712 kernResult
= KERN_SUCCESS
;
714 CFRelease( bsdPathAsCFString
);
716 IOObjectRelease( nextMedia
);
724 static int hdev_probe_device(const char *filename
)
728 /* allow a dedicated CD-ROM driver to match with a higher priority */
729 if (strstart(filename
, "/dev/cdrom", NULL
))
732 if (stat(filename
, &st
) >= 0 &&
733 (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
))) {
740 static int hdev_open(BlockDriverState
*bs
, const char *filename
, int flags
)
742 BDRVRawState
*s
= bs
->opaque
;
745 if (strstart(filename
, "/dev/cdrom", NULL
)) {
746 kern_return_t kernResult
;
747 io_iterator_t mediaIterator
;
748 char bsdPath
[ MAXPATHLEN
];
751 kernResult
= FindEjectableCDMedia( &mediaIterator
);
752 kernResult
= GetBSDPath( mediaIterator
, bsdPath
, sizeof( bsdPath
) );
754 if ( bsdPath
[ 0 ] != '\0' ) {
755 strcat(bsdPath
,"s0");
756 /* some CDs don't have a partition 0 */
757 fd
= open(bsdPath
, O_RDONLY
| O_BINARY
| O_LARGEFILE
);
759 bsdPath
[strlen(bsdPath
)-1] = '1';
767 IOObjectRelease( mediaIterator
);
771 s
->type
= FTYPE_FILE
;
772 #if defined(__linux__)
774 char resolved_path
[ MAXPATHLEN
], *temp
;
776 temp
= realpath(filename
, resolved_path
);
777 if (temp
&& strstart(temp
, "/dev/sg", NULL
)) {
783 return raw_open_common(bs
, filename
, flags
, 0);
786 #if defined(__linux__)
787 /* Note: we do not have a reliable method to detect if the floppy is
788 present. The current method is to try to open the floppy at every
789 I/O and to keep it opened during a few hundreds of ms. */
790 static int fd_open(BlockDriverState
*bs
)
792 BDRVRawState
*s
= bs
->opaque
;
793 int last_media_present
;
795 if (s
->type
!= FTYPE_FD
)
797 last_media_present
= (s
->fd
>= 0);
799 (get_clock() - s
->fd_open_time
) >= FD_OPEN_TIMEOUT
) {
803 printf("Floppy closed\n");
807 if (s
->fd_got_error
&&
808 (get_clock() - s
->fd_error_time
) < FD_OPEN_TIMEOUT
) {
810 printf("No floppy (open delayed)\n");
814 s
->fd
= open(bs
->filename
, s
->open_flags
& ~O_NONBLOCK
);
816 s
->fd_error_time
= get_clock();
818 if (last_media_present
)
819 s
->fd_media_changed
= 1;
821 printf("No floppy\n");
826 printf("Floppy opened\n");
829 if (!last_media_present
)
830 s
->fd_media_changed
= 1;
831 s
->fd_open_time
= get_clock();
836 static int hdev_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
838 BDRVRawState
*s
= bs
->opaque
;
840 return ioctl(s
->fd
, req
, buf
);
843 static BlockDriverAIOCB
*hdev_aio_ioctl(BlockDriverState
*bs
,
844 unsigned long int req
, void *buf
,
845 BlockDriverCompletionFunc
*cb
, void *opaque
)
847 BDRVRawState
*s
= bs
->opaque
;
851 return paio_ioctl(bs
, s
->fd
, req
, buf
, cb
, opaque
);
854 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
855 static int fd_open(BlockDriverState
*bs
)
857 BDRVRawState
*s
= bs
->opaque
;
859 /* this is just to ensure s->fd is sane (its called by io ops) */
864 #else /* !linux && !FreeBSD */
866 static int fd_open(BlockDriverState
*bs
)
871 #endif /* !linux && !FreeBSD */
873 static int hdev_create(const char *filename
, QEMUOptionParameter
*options
)
877 struct stat stat_buf
;
878 int64_t total_size
= 0;
880 /* Read out options */
881 while (options
&& options
->name
) {
882 if (!strcmp(options
->name
, "size")) {
883 total_size
= options
->value
.n
/ BDRV_SECTOR_SIZE
;
888 fd
= open(filename
, O_WRONLY
| O_BINARY
);
892 if (fstat(fd
, &stat_buf
) < 0)
894 else if (!S_ISBLK(stat_buf
.st_mode
) && !S_ISCHR(stat_buf
.st_mode
))
896 else if (lseek(fd
, 0, SEEK_END
) < total_size
* BDRV_SECTOR_SIZE
)
903 static int hdev_has_zero_init(BlockDriverState
*bs
)
908 static BlockDriver bdrv_host_device
= {
909 .format_name
= "host_device",
910 .protocol_name
= "host_device",
911 .instance_size
= sizeof(BDRVRawState
),
912 .bdrv_probe_device
= hdev_probe_device
,
913 .bdrv_file_open
= hdev_open
,
914 .bdrv_close
= raw_close
,
915 .bdrv_create
= hdev_create
,
916 .create_options
= raw_create_options
,
917 .bdrv_has_zero_init
= hdev_has_zero_init
,
918 .bdrv_flush
= raw_flush
,
920 .bdrv_aio_readv
= raw_aio_readv
,
921 .bdrv_aio_writev
= raw_aio_writev
,
922 .bdrv_aio_flush
= raw_aio_flush
,
924 .bdrv_truncate
= raw_truncate
,
925 .bdrv_getlength
= raw_getlength
,
926 .bdrv_get_allocated_file_size
927 = raw_get_allocated_file_size
,
929 /* generic scsi device */
931 .bdrv_ioctl
= hdev_ioctl
,
932 .bdrv_aio_ioctl
= hdev_aio_ioctl
,
937 static int floppy_open(BlockDriverState
*bs
, const char *filename
, int flags
)
939 BDRVRawState
*s
= bs
->opaque
;
944 /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */
945 ret
= raw_open_common(bs
, filename
, flags
, O_NONBLOCK
);
949 /* close fd so that we can reopen it as needed */
952 s
->fd_media_changed
= 1;
957 static int floppy_probe_device(const char *filename
)
961 struct floppy_struct fdparam
;
964 if (strstart(filename
, "/dev/fd", NULL
))
967 fd
= open(filename
, O_RDONLY
| O_NONBLOCK
);
971 ret
= fstat(fd
, &st
);
972 if (ret
== -1 || !S_ISBLK(st
.st_mode
)) {
976 /* Attempt to detect via a floppy specific ioctl */
977 ret
= ioctl(fd
, FDGETPRM
, &fdparam
);
988 static int floppy_is_inserted(BlockDriverState
*bs
)
990 return fd_open(bs
) >= 0;
993 static int floppy_media_changed(BlockDriverState
*bs
)
995 BDRVRawState
*s
= bs
->opaque
;
999 * XXX: we do not have a true media changed indication.
1000 * It does not work if the floppy is changed without trying to read it.
1003 ret
= s
->fd_media_changed
;
1004 s
->fd_media_changed
= 0;
1006 printf("Floppy changed=%d\n", ret
);
1011 static void floppy_eject(BlockDriverState
*bs
, int eject_flag
)
1013 BDRVRawState
*s
= bs
->opaque
;
1020 fd
= open(bs
->filename
, s
->open_flags
| O_NONBLOCK
);
1022 if (ioctl(fd
, FDEJECT
, 0) < 0)
1028 static BlockDriver bdrv_host_floppy
= {
1029 .format_name
= "host_floppy",
1030 .protocol_name
= "host_floppy",
1031 .instance_size
= sizeof(BDRVRawState
),
1032 .bdrv_probe_device
= floppy_probe_device
,
1033 .bdrv_file_open
= floppy_open
,
1034 .bdrv_close
= raw_close
,
1035 .bdrv_create
= hdev_create
,
1036 .create_options
= raw_create_options
,
1037 .bdrv_has_zero_init
= hdev_has_zero_init
,
1038 .bdrv_flush
= raw_flush
,
1040 .bdrv_aio_readv
= raw_aio_readv
,
1041 .bdrv_aio_writev
= raw_aio_writev
,
1042 .bdrv_aio_flush
= raw_aio_flush
,
1044 .bdrv_truncate
= raw_truncate
,
1045 .bdrv_getlength
= raw_getlength
,
1046 .bdrv_get_allocated_file_size
1047 = raw_get_allocated_file_size
,
1049 /* removable device support */
1050 .bdrv_is_inserted
= floppy_is_inserted
,
1051 .bdrv_media_changed
= floppy_media_changed
,
1052 .bdrv_eject
= floppy_eject
,
1055 static int cdrom_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1057 BDRVRawState
*s
= bs
->opaque
;
1061 /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
1062 return raw_open_common(bs
, filename
, flags
, O_NONBLOCK
);
1065 static int cdrom_probe_device(const char *filename
)
1071 fd
= open(filename
, O_RDONLY
| O_NONBLOCK
);
1075 ret
= fstat(fd
, &st
);
1076 if (ret
== -1 || !S_ISBLK(st
.st_mode
)) {
1080 /* Attempt to detect via a CDROM specific ioctl */
1081 ret
= ioctl(fd
, CDROM_DRIVE_STATUS
, CDSL_CURRENT
);
1091 static int cdrom_is_inserted(BlockDriverState
*bs
)
1093 BDRVRawState
*s
= bs
->opaque
;
1096 ret
= ioctl(s
->fd
, CDROM_DRIVE_STATUS
, CDSL_CURRENT
);
1097 if (ret
== CDS_DISC_OK
)
1102 static void cdrom_eject(BlockDriverState
*bs
, int eject_flag
)
1104 BDRVRawState
*s
= bs
->opaque
;
1107 if (ioctl(s
->fd
, CDROMEJECT
, NULL
) < 0)
1108 perror("CDROMEJECT");
1110 if (ioctl(s
->fd
, CDROMCLOSETRAY
, NULL
) < 0)
1111 perror("CDROMEJECT");
1115 static void cdrom_lock_medium(BlockDriverState
*bs
, bool locked
)
1117 BDRVRawState
*s
= bs
->opaque
;
1119 if (ioctl(s
->fd
, CDROM_LOCKDOOR
, locked
) < 0) {
1121 * Note: an error can happen if the distribution automatically
1124 /* perror("CDROM_LOCKDOOR"); */
1128 static BlockDriver bdrv_host_cdrom
= {
1129 .format_name
= "host_cdrom",
1130 .protocol_name
= "host_cdrom",
1131 .instance_size
= sizeof(BDRVRawState
),
1132 .bdrv_probe_device
= cdrom_probe_device
,
1133 .bdrv_file_open
= cdrom_open
,
1134 .bdrv_close
= raw_close
,
1135 .bdrv_create
= hdev_create
,
1136 .create_options
= raw_create_options
,
1137 .bdrv_has_zero_init
= hdev_has_zero_init
,
1138 .bdrv_flush
= raw_flush
,
1140 .bdrv_aio_readv
= raw_aio_readv
,
1141 .bdrv_aio_writev
= raw_aio_writev
,
1142 .bdrv_aio_flush
= raw_aio_flush
,
1144 .bdrv_truncate
= raw_truncate
,
1145 .bdrv_getlength
= raw_getlength
,
1146 .bdrv_get_allocated_file_size
1147 = raw_get_allocated_file_size
,
1149 /* removable device support */
1150 .bdrv_is_inserted
= cdrom_is_inserted
,
1151 .bdrv_eject
= cdrom_eject
,
1152 .bdrv_lock_medium
= cdrom_lock_medium
,
1154 /* generic scsi device */
1155 .bdrv_ioctl
= hdev_ioctl
,
1156 .bdrv_aio_ioctl
= hdev_aio_ioctl
,
1158 #endif /* __linux__ */
1160 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1161 static int cdrom_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1163 BDRVRawState
*s
= bs
->opaque
;
1168 ret
= raw_open_common(bs
, filename
, flags
, 0);
1172 /* make sure the door isnt locked at this time */
1173 ioctl(s
->fd
, CDIOCALLOW
);
1177 static int cdrom_probe_device(const char *filename
)
1179 if (strstart(filename
, "/dev/cd", NULL
) ||
1180 strstart(filename
, "/dev/acd", NULL
))
1185 static int cdrom_reopen(BlockDriverState
*bs
)
1187 BDRVRawState
*s
= bs
->opaque
;
1191 * Force reread of possibly changed/newly loaded disc,
1192 * FreeBSD seems to not notice sometimes...
1196 fd
= open(bs
->filename
, s
->open_flags
, 0644);
1203 /* make sure the door isnt locked at this time */
1204 ioctl(s
->fd
, CDIOCALLOW
);
1208 static int cdrom_is_inserted(BlockDriverState
*bs
)
1210 return raw_getlength(bs
) > 0;
1213 static void cdrom_eject(BlockDriverState
*bs
, int eject_flag
)
1215 BDRVRawState
*s
= bs
->opaque
;
1220 (void) ioctl(s
->fd
, CDIOCALLOW
);
1223 if (ioctl(s
->fd
, CDIOCEJECT
) < 0)
1224 perror("CDIOCEJECT");
1226 if (ioctl(s
->fd
, CDIOCCLOSE
) < 0)
1227 perror("CDIOCCLOSE");
1233 static void cdrom_lock_medium(BlockDriverState
*bs
, bool locked
)
1235 BDRVRawState
*s
= bs
->opaque
;
1239 if (ioctl(s
->fd
, (locked
? CDIOCPREVENT
: CDIOCALLOW
)) < 0) {
1241 * Note: an error can happen if the distribution automatically
1244 /* perror("CDROM_LOCKDOOR"); */
1248 static BlockDriver bdrv_host_cdrom
= {
1249 .format_name
= "host_cdrom",
1250 .protocol_name
= "host_cdrom",
1251 .instance_size
= sizeof(BDRVRawState
),
1252 .bdrv_probe_device
= cdrom_probe_device
,
1253 .bdrv_file_open
= cdrom_open
,
1254 .bdrv_close
= raw_close
,
1255 .bdrv_create
= hdev_create
,
1256 .create_options
= raw_create_options
,
1257 .bdrv_has_zero_init
= hdev_has_zero_init
,
1258 .bdrv_flush
= raw_flush
,
1260 .bdrv_aio_readv
= raw_aio_readv
,
1261 .bdrv_aio_writev
= raw_aio_writev
,
1262 .bdrv_aio_flush
= raw_aio_flush
,
1264 .bdrv_truncate
= raw_truncate
,
1265 .bdrv_getlength
= raw_getlength
,
1266 .bdrv_get_allocated_file_size
1267 = raw_get_allocated_file_size
,
1269 /* removable device support */
1270 .bdrv_is_inserted
= cdrom_is_inserted
,
1271 .bdrv_eject
= cdrom_eject
,
1272 .bdrv_lock_medium
= cdrom_lock_medium
,
1274 #endif /* __FreeBSD__ */
1276 static void bdrv_file_init(void)
1279 * Register all the drivers. Note that order is important, the driver
1280 * registered last will get probed first.
1282 bdrv_register(&bdrv_file
);
1283 bdrv_register(&bdrv_host_device
);
1285 bdrv_register(&bdrv_host_floppy
);
1286 bdrv_register(&bdrv_host_cdrom
);
1288 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1289 bdrv_register(&bdrv_host_cdrom
);
1293 block_init(bdrv_file_init
);