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"
27 #include "block_int.h"
30 #include "posix-aio-compat.h"
35 #include <sys/param.h>
36 #include <IOKit/IOKitLib.h>
37 #include <IOKit/IOBSD.h>
38 #include <IOKit/storage/IOMediaBSDClient.h>
39 #include <IOKit/storage/IOMedia.h>
40 #include <IOKit/storage/IOCDMedia.h>
41 //#include <IOKit/storage/IOCDTypes.h>
42 #include <CoreFoundation/CoreFoundation.h>
46 #define _POSIX_PTHREAD_SEMANTICS 1
51 #include <sys/ioctl.h>
52 #include <linux/cdrom.h>
62 #include <sys/ioctl.h>
63 #include <sys/disklabel.h>
68 #include <sys/ioctl.h>
69 #include <sys/diskslice.h>
72 //#define DEBUG_FLOPPY
75 #if defined(DEBUG_BLOCK)
76 #define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \
77 { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0)
79 #define DEBUG_BLOCK_PRINT(formatCstr, ...)
82 /* OS X does not have O_DSYNC */
84 #define O_DSYNC O_SYNC
87 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
89 #define O_DIRECT O_DSYNC
96 #define ALIGNED_BUFFER_SIZE (32 * 512)
98 /* if the FD is not accessed during that time (in ms), we try to
99 reopen it to see if the disk has been changed */
100 #define FD_OPEN_TIMEOUT 1000
102 typedef struct BDRVRawState
{
105 unsigned int lseek_err_cnt
;
107 #if defined(__linux__)
108 /* linux floppy specific */
109 int64_t fd_open_time
;
110 int64_t fd_error_time
;
112 int fd_media_changed
;
114 uint8_t* aligned_buf
;
117 static int posix_aio_init(void);
119 static int fd_open(BlockDriverState
*bs
);
121 #if defined(__FreeBSD__)
122 static int cdrom_reopen(BlockDriverState
*bs
);
125 static int raw_open_common(BlockDriverState
*bs
, const char *filename
,
128 BDRVRawState
*s
= bs
->opaque
;
133 s
->lseek_err_cnt
= 0;
135 s
->open_flags
|= O_BINARY
;
136 if ((flags
& BDRV_O_ACCESS
) == O_RDWR
) {
137 s
->open_flags
|= O_RDWR
;
139 s
->open_flags
|= O_RDONLY
;
143 /* Use O_DSYNC for write-through caching, no flags for write-back caching,
144 * and O_DIRECT for no caching. */
145 if ((flags
& BDRV_O_NOCACHE
))
146 s
->open_flags
|= O_DIRECT
;
147 else if (!(flags
& BDRV_O_CACHE_WB
))
148 s
->open_flags
|= O_DSYNC
;
151 fd
= open(filename
, s
->open_flags
, 0644);
159 s
->aligned_buf
= NULL
;
160 if ((flags
& BDRV_O_NOCACHE
)) {
161 s
->aligned_buf
= qemu_blockalign(bs
, ALIGNED_BUFFER_SIZE
);
162 if (s
->aligned_buf
== NULL
) {
171 static int raw_open(BlockDriverState
*bs
, const char *filename
, int flags
)
173 BDRVRawState
*s
= bs
->opaque
;
175 s
->type
= FTYPE_FILE
;
176 if (flags
& BDRV_O_CREAT
)
177 s
->open_flags
|= O_CREAT
| O_TRUNC
;
179 return raw_open_common(bs
, filename
, flags
);
182 /* XXX: use host sector size if necessary with:
183 #ifdef DIOCGSECTORSIZE
185 unsigned int sectorsize = 512;
186 if (!ioctl(fd, DIOCGSECTORSIZE, §orsize) &&
187 sectorsize > bufsize)
188 bufsize = sectorsize;
192 u_int32_t blockSize = 512;
193 if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) {
200 * offset and count are in bytes, but must be multiples of 512 for files
201 * opened with O_DIRECT. buf must be aligned to 512 bytes then.
203 * This function may be called without alignment if the caller ensures
204 * that O_DIRECT is not in effect.
206 static int raw_pread_aligned(BlockDriverState
*bs
, int64_t offset
,
207 uint8_t *buf
, int count
)
209 BDRVRawState
*s
= bs
->opaque
;
216 if (offset
>= 0 && lseek(s
->fd
, offset
, SEEK_SET
) == (off_t
)-1) {
217 ++(s
->lseek_err_cnt
);
218 if(s
->lseek_err_cnt
<= 10) {
219 DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64
", %p, %d) [%" PRId64
220 "] lseek failed : %d = %s\n",
221 s
->fd
, bs
->filename
, offset
, buf
, count
,
222 bs
->total_sectors
, errno
, strerror(errno
));
228 ret
= read(s
->fd
, buf
, count
);
230 goto label__raw_read__success
;
232 DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64
", %p, %d) [%" PRId64
233 "] read failed %d : %d = %s\n",
234 s
->fd
, bs
->filename
, offset
, buf
, count
,
235 bs
->total_sectors
, ret
, errno
, strerror(errno
));
237 /* Try harder for CDrom. */
238 if (bs
->type
== BDRV_TYPE_CDROM
) {
239 lseek(s
->fd
, offset
, SEEK_SET
);
240 ret
= read(s
->fd
, buf
, count
);
242 goto label__raw_read__success
;
243 lseek(s
->fd
, offset
, SEEK_SET
);
244 ret
= read(s
->fd
, buf
, count
);
246 goto label__raw_read__success
;
248 DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64
", %p, %d) [%" PRId64
249 "] retry read failed %d : %d = %s\n",
250 s
->fd
, bs
->filename
, offset
, buf
, count
,
251 bs
->total_sectors
, ret
, errno
, strerror(errno
));
254 label__raw_read__success
:
256 return (ret
< 0) ? -errno
: ret
;
260 * offset and count are in bytes, but must be multiples of 512 for files
261 * opened with O_DIRECT. buf must be aligned to 512 bytes then.
263 * This function may be called without alignment if the caller ensures
264 * that O_DIRECT is not in effect.
266 static int raw_pwrite_aligned(BlockDriverState
*bs
, int64_t offset
,
267 const uint8_t *buf
, int count
)
269 BDRVRawState
*s
= bs
->opaque
;
276 if (offset
>= 0 && lseek(s
->fd
, offset
, SEEK_SET
) == (off_t
)-1) {
277 ++(s
->lseek_err_cnt
);
278 if(s
->lseek_err_cnt
) {
279 DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64
", %p, %d) [%"
280 PRId64
"] lseek failed : %d = %s\n",
281 s
->fd
, bs
->filename
, offset
, buf
, count
,
282 bs
->total_sectors
, errno
, strerror(errno
));
286 s
->lseek_err_cnt
= 0;
288 ret
= write(s
->fd
, buf
, count
);
290 goto label__raw_write__success
;
292 DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64
", %p, %d) [%" PRId64
293 "] write failed %d : %d = %s\n",
294 s
->fd
, bs
->filename
, offset
, buf
, count
,
295 bs
->total_sectors
, ret
, errno
, strerror(errno
));
297 label__raw_write__success
:
299 return (ret
< 0) ? -errno
: ret
;
304 * offset and count are in bytes and possibly not aligned. For files opened
305 * with O_DIRECT, necessary alignments are ensured before calling
306 * raw_pread_aligned to do the actual read.
308 static int raw_pread(BlockDriverState
*bs
, int64_t offset
,
309 uint8_t *buf
, int count
)
311 BDRVRawState
*s
= bs
->opaque
;
312 int size
, ret
, shift
, sum
;
316 if (s
->aligned_buf
!= NULL
) {
318 if (offset
& 0x1ff) {
319 /* align offset on a 512 bytes boundary */
321 shift
= offset
& 0x1ff;
322 size
= (shift
+ count
+ 0x1ff) & ~0x1ff;
323 if (size
> ALIGNED_BUFFER_SIZE
)
324 size
= ALIGNED_BUFFER_SIZE
;
325 ret
= raw_pread_aligned(bs
, offset
- shift
, s
->aligned_buf
, size
);
332 memcpy(buf
, s
->aligned_buf
+ shift
, size
);
342 if (count
& 0x1ff || (uintptr_t) buf
& 0x1ff) {
344 /* read on aligned buffer */
348 size
= (count
+ 0x1ff) & ~0x1ff;
349 if (size
> ALIGNED_BUFFER_SIZE
)
350 size
= ALIGNED_BUFFER_SIZE
;
352 ret
= raw_pread_aligned(bs
, offset
, s
->aligned_buf
, size
);
360 memcpy(buf
, s
->aligned_buf
, size
);
372 return raw_pread_aligned(bs
, offset
, buf
, count
) + sum
;
375 static int raw_read(BlockDriverState
*bs
, int64_t sector_num
,
376 uint8_t *buf
, int nb_sectors
)
380 ret
= raw_pread(bs
, sector_num
* 512, buf
, nb_sectors
* 512);
381 if (ret
== (nb_sectors
* 512))
387 * offset and count are in bytes and possibly not aligned. For files opened
388 * with O_DIRECT, necessary alignments are ensured before calling
389 * raw_pwrite_aligned to do the actual write.
391 static int raw_pwrite(BlockDriverState
*bs
, int64_t offset
,
392 const uint8_t *buf
, int count
)
394 BDRVRawState
*s
= bs
->opaque
;
395 int size
, ret
, shift
, sum
;
399 if (s
->aligned_buf
!= NULL
) {
401 if (offset
& 0x1ff) {
402 /* align offset on a 512 bytes boundary */
403 shift
= offset
& 0x1ff;
404 ret
= raw_pread_aligned(bs
, offset
- shift
, s
->aligned_buf
, 512);
411 memcpy(s
->aligned_buf
+ shift
, buf
, size
);
413 ret
= raw_pwrite_aligned(bs
, offset
- shift
, s
->aligned_buf
, 512);
425 if (count
& 0x1ff || (uintptr_t) buf
& 0x1ff) {
427 while ((size
= (count
& ~0x1ff)) != 0) {
429 if (size
> ALIGNED_BUFFER_SIZE
)
430 size
= ALIGNED_BUFFER_SIZE
;
432 memcpy(s
->aligned_buf
, buf
, size
);
434 ret
= raw_pwrite_aligned(bs
, offset
, s
->aligned_buf
, size
);
443 /* here, count < 512 because (count & ~0x1ff) == 0 */
445 ret
= raw_pread_aligned(bs
, offset
, s
->aligned_buf
, 512);
448 memcpy(s
->aligned_buf
, buf
, count
);
450 ret
= raw_pwrite_aligned(bs
, offset
, s
->aligned_buf
, 512);
461 return raw_pwrite_aligned(bs
, offset
, buf
, count
) + sum
;
464 static int raw_write(BlockDriverState
*bs
, int64_t sector_num
,
465 const uint8_t *buf
, int nb_sectors
)
468 ret
= raw_pwrite(bs
, sector_num
* 512, buf
, nb_sectors
* 512);
469 if (ret
== (nb_sectors
* 512))
475 /***********************************************************/
476 /* Unix AIO using POSIX AIO */
478 typedef struct RawAIOCB
{
479 BlockDriverAIOCB common
;
480 struct qemu_paiocb aiocb
;
481 struct RawAIOCB
*next
;
485 typedef struct PosixAioState
491 static void posix_aio_read(void *opaque
)
493 PosixAioState
*s
= opaque
;
494 RawAIOCB
*acb
, **pacb
;
498 /* read all bytes from signal pipe */
502 len
= read(s
->rfd
, bytes
, sizeof(bytes
));
503 if (len
== -1 && errno
== EINTR
)
504 continue; /* try again */
505 if (len
== sizeof(bytes
))
506 continue; /* more to read */
511 pacb
= &s
->first_aio
;
516 ret
= qemu_paio_error(&acb
->aiocb
);
517 if (ret
== ECANCELED
) {
518 /* remove the request */
520 qemu_aio_release(acb
);
521 } else if (ret
!= EINPROGRESS
) {
524 ret
= qemu_paio_return(&acb
->aiocb
);
525 if (ret
== acb
->aiocb
.aio_nbytes
)
532 /* remove the request */
534 /* call the callback */
535 acb
->common
.cb(acb
->common
.opaque
, ret
);
536 qemu_aio_release(acb
);
546 static int posix_aio_flush(void *opaque
)
548 PosixAioState
*s
= opaque
;
549 return !!s
->first_aio
;
552 static PosixAioState
*posix_aio_state
;
554 static void aio_signal_handler(int signum
)
556 if (posix_aio_state
) {
559 write(posix_aio_state
->wfd
, &byte
, sizeof(byte
));
565 static int posix_aio_init(void)
567 struct sigaction act
;
570 struct qemu_paioinit ai
;
575 s
= qemu_malloc(sizeof(PosixAioState
));
577 sigfillset(&act
.sa_mask
);
578 act
.sa_flags
= 0; /* do not restart syscalls to interrupt select() */
579 act
.sa_handler
= aio_signal_handler
;
580 sigaction(SIGUSR2
, &act
, NULL
);
583 if (pipe(fds
) == -1) {
584 fprintf(stderr
, "failed to create pipe\n");
591 fcntl(s
->rfd
, F_SETFL
, O_NONBLOCK
);
592 fcntl(s
->wfd
, F_SETFL
, O_NONBLOCK
);
594 qemu_aio_set_fd_handler(s
->rfd
, posix_aio_read
, NULL
, posix_aio_flush
, s
);
596 memset(&ai
, 0, sizeof(ai
));
606 static void raw_aio_remove(RawAIOCB
*acb
)
610 /* remove the callback from the queue */
611 pacb
= &posix_aio_state
->first_aio
;
614 fprintf(stderr
, "raw_aio_remove: aio request not found!\n");
616 } else if (*pacb
== acb
) {
618 qemu_aio_release(acb
);
621 pacb
= &(*pacb
)->next
;
625 static void raw_aio_cancel(BlockDriverAIOCB
*blockacb
)
628 RawAIOCB
*acb
= (RawAIOCB
*)blockacb
;
630 ret
= qemu_paio_cancel(acb
->aiocb
.aio_fildes
, &acb
->aiocb
);
631 if (ret
== QEMU_PAIO_NOTCANCELED
) {
632 /* fail safe: if the aio could not be canceled, we wait for
634 while (qemu_paio_error(&acb
->aiocb
) == EINPROGRESS
);
640 static AIOPool raw_aio_pool
= {
641 .aiocb_size
= sizeof(RawAIOCB
),
642 .cancel
= raw_aio_cancel
,
645 static RawAIOCB
*raw_aio_setup(BlockDriverState
*bs
, int64_t sector_num
,
646 QEMUIOVector
*qiov
, int nb_sectors
,
647 BlockDriverCompletionFunc
*cb
, void *opaque
)
649 BDRVRawState
*s
= bs
->opaque
;
655 acb
= qemu_aio_get(&raw_aio_pool
, bs
, cb
, opaque
);
658 acb
->aiocb
.aio_fildes
= s
->fd
;
659 acb
->aiocb
.ev_signo
= SIGUSR2
;
660 acb
->aiocb
.aio_iov
= qiov
->iov
;
661 acb
->aiocb
.aio_niov
= qiov
->niov
;
662 acb
->aiocb
.aio_nbytes
= nb_sectors
* 512;
663 acb
->aiocb
.aio_offset
= sector_num
* 512;
664 acb
->aiocb
.aio_flags
= 0;
667 * If O_DIRECT is used the buffer needs to be aligned on a sector
668 * boundary. Tell the low level code to ensure that in case it's
672 acb
->aiocb
.aio_flags
|= QEMU_AIO_SECTOR_ALIGNED
;
674 acb
->next
= posix_aio_state
->first_aio
;
675 posix_aio_state
->first_aio
= acb
;
679 static BlockDriverAIOCB
*raw_aio_readv(BlockDriverState
*bs
,
680 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
681 BlockDriverCompletionFunc
*cb
, void *opaque
)
685 acb
= raw_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
);
688 if (qemu_paio_read(&acb
->aiocb
) < 0) {
695 static BlockDriverAIOCB
*raw_aio_writev(BlockDriverState
*bs
,
696 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
697 BlockDriverCompletionFunc
*cb
, void *opaque
)
701 acb
= raw_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
);
704 if (qemu_paio_write(&acb
->aiocb
) < 0) {
710 #else /* CONFIG_AIO */
711 static int posix_aio_init(void)
715 #endif /* CONFIG_AIO */
718 static void raw_close(BlockDriverState
*bs
)
720 BDRVRawState
*s
= bs
->opaque
;
724 if (s
->aligned_buf
!= NULL
)
725 qemu_free(s
->aligned_buf
);
729 static int raw_truncate(BlockDriverState
*bs
, int64_t offset
)
731 BDRVRawState
*s
= bs
->opaque
;
732 if (s
->type
!= FTYPE_FILE
)
734 if (ftruncate(s
->fd
, offset
) < 0)
740 static int64_t raw_getlength(BlockDriverState
*bs
)
742 BDRVRawState
*s
= bs
->opaque
;
748 if (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
)) {
751 if (ioctl(fd
, DIOCGDINFO
, &dl
))
753 return (uint64_t)dl
.d_secsize
*
754 dl
.d_partitions
[DISKPART(st
.st_rdev
)].p_size
;
758 #else /* !__OpenBSD__ */
759 static int64_t raw_getlength(BlockDriverState
*bs
)
761 BDRVRawState
*s
= bs
->opaque
;
771 struct dk_minfo minfo
;
784 if (!fstat(fd
, &sb
) && (S_IFCHR
& sb
.st_mode
)) {
785 #ifdef DIOCGMEDIASIZE
786 if (ioctl(fd
, DIOCGMEDIASIZE
, (off_t
*)&size
))
787 #elif defined(DIOCGPART)
790 if (ioctl(fd
, DIOCGPART
, &pi
) == 0)
791 size
= pi
.media_size
;
798 size
= LONG_LONG_MAX
;
800 size
= lseek(fd
, 0LL, SEEK_END
);
805 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
806 if (size
== 2048LL * (unsigned)-1)
808 /* XXX no disc? maybe we need to reopen... */
809 if (size
<= 0 && !reopened
&& cdrom_reopen(bs
) >= 0) {
819 * use the DKIOCGMEDIAINFO ioctl to read the size.
821 rv
= ioctl ( fd
, DKIOCGMEDIAINFO
, &minfo
);
823 size
= minfo
.dki_lbsize
* minfo
.dki_capacity
;
824 } else /* there are reports that lseek on some devices
825 fails, but irc discussion said that contingency
826 on contingency was overkill */
829 size
= lseek(fd
, 0, SEEK_END
);
835 static int raw_create(const char *filename
, QEMUOptionParameter
*options
)
838 int64_t total_size
= 0;
840 /* Read out options */
841 while (options
&& options
->name
) {
842 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
843 total_size
= options
->value
.n
/ 512;
848 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
,
852 ftruncate(fd
, total_size
* 512);
857 static void raw_flush(BlockDriverState
*bs
)
859 BDRVRawState
*s
= bs
->opaque
;
864 static QEMUOptionParameter raw_create_options
[] = {
866 .name
= BLOCK_OPT_SIZE
,
868 .help
= "Virtual disk size"
873 static BlockDriver bdrv_raw
= {
874 .format_name
= "raw",
875 .instance_size
= sizeof(BDRVRawState
),
876 .bdrv_probe
= NULL
, /* no probe for protocols */
877 .bdrv_open
= raw_open
,
878 .bdrv_read
= raw_read
,
879 .bdrv_write
= raw_write
,
880 .bdrv_close
= raw_close
,
881 .bdrv_create
= raw_create
,
882 .bdrv_flush
= raw_flush
,
885 .bdrv_aio_readv
= raw_aio_readv
,
886 .bdrv_aio_writev
= raw_aio_writev
,
889 .bdrv_truncate
= raw_truncate
,
890 .bdrv_getlength
= raw_getlength
,
892 .create_options
= raw_create_options
,
895 /***********************************************/
899 static kern_return_t
FindEjectableCDMedia( io_iterator_t
*mediaIterator
);
900 static kern_return_t
GetBSDPath( io_iterator_t mediaIterator
, char *bsdPath
, CFIndex maxPathSize
);
902 kern_return_t
FindEjectableCDMedia( io_iterator_t
*mediaIterator
)
904 kern_return_t kernResult
;
905 mach_port_t masterPort
;
906 CFMutableDictionaryRef classesToMatch
;
908 kernResult
= IOMasterPort( MACH_PORT_NULL
, &masterPort
);
909 if ( KERN_SUCCESS
!= kernResult
) {
910 printf( "IOMasterPort returned %d\n", kernResult
);
913 classesToMatch
= IOServiceMatching( kIOCDMediaClass
);
914 if ( classesToMatch
== NULL
) {
915 printf( "IOServiceMatching returned a NULL dictionary.\n" );
917 CFDictionarySetValue( classesToMatch
, CFSTR( kIOMediaEjectableKey
), kCFBooleanTrue
);
919 kernResult
= IOServiceGetMatchingServices( masterPort
, classesToMatch
, mediaIterator
);
920 if ( KERN_SUCCESS
!= kernResult
)
922 printf( "IOServiceGetMatchingServices returned %d\n", kernResult
);
928 kern_return_t
GetBSDPath( io_iterator_t mediaIterator
, char *bsdPath
, CFIndex maxPathSize
)
930 io_object_t nextMedia
;
931 kern_return_t kernResult
= KERN_FAILURE
;
933 nextMedia
= IOIteratorNext( mediaIterator
);
936 CFTypeRef bsdPathAsCFString
;
937 bsdPathAsCFString
= IORegistryEntryCreateCFProperty( nextMedia
, CFSTR( kIOBSDNameKey
), kCFAllocatorDefault
, 0 );
938 if ( bsdPathAsCFString
) {
939 size_t devPathLength
;
940 strcpy( bsdPath
, _PATH_DEV
);
941 strcat( bsdPath
, "r" );
942 devPathLength
= strlen( bsdPath
);
943 if ( CFStringGetCString( bsdPathAsCFString
, bsdPath
+ devPathLength
, maxPathSize
- devPathLength
, kCFStringEncodingASCII
) ) {
944 kernResult
= KERN_SUCCESS
;
946 CFRelease( bsdPathAsCFString
);
948 IOObjectRelease( nextMedia
);
956 static int hdev_probe_device(const char *filename
)
960 /* allow a dedicated CD-ROM driver to match with a higher priority */
961 if (strstart(filename
, "/dev/cdrom", NULL
))
964 if (stat(filename
, &st
) >= 0 &&
965 (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
))) {
972 static int hdev_open(BlockDriverState
*bs
, const char *filename
, int flags
)
974 BDRVRawState
*s
= bs
->opaque
;
977 if (strstart(filename
, "/dev/cdrom", NULL
)) {
978 kern_return_t kernResult
;
979 io_iterator_t mediaIterator
;
980 char bsdPath
[ MAXPATHLEN
];
983 kernResult
= FindEjectableCDMedia( &mediaIterator
);
984 kernResult
= GetBSDPath( mediaIterator
, bsdPath
, sizeof( bsdPath
) );
986 if ( bsdPath
[ 0 ] != '\0' ) {
987 strcat(bsdPath
,"s0");
988 /* some CDs don't have a partition 0 */
989 fd
= open(bsdPath
, O_RDONLY
| O_BINARY
| O_LARGEFILE
);
991 bsdPath
[strlen(bsdPath
)-1] = '1';
999 IOObjectRelease( mediaIterator
);
1003 s
->type
= FTYPE_FILE
;
1004 #if defined(__linux__) && defined(CONFIG_AIO)
1005 if (strstart(filename
, "/dev/sg", NULL
)) {
1010 return raw_open_common(bs
, filename
, flags
);
1013 #if defined(__linux__)
1014 /* Note: we do not have a reliable method to detect if the floppy is
1015 present. The current method is to try to open the floppy at every
1016 I/O and to keep it opened during a few hundreds of ms. */
1017 static int fd_open(BlockDriverState
*bs
)
1019 BDRVRawState
*s
= bs
->opaque
;
1020 int last_media_present
;
1022 if (s
->type
!= FTYPE_FD
)
1024 last_media_present
= (s
->fd
>= 0);
1026 (qemu_get_clock(rt_clock
) - s
->fd_open_time
) >= FD_OPEN_TIMEOUT
) {
1030 printf("Floppy closed\n");
1034 if (s
->fd_got_error
&&
1035 (qemu_get_clock(rt_clock
) - s
->fd_error_time
) < FD_OPEN_TIMEOUT
) {
1037 printf("No floppy (open delayed)\n");
1041 s
->fd
= open(bs
->filename
, s
->open_flags
& ~O_NONBLOCK
);
1043 s
->fd_error_time
= qemu_get_clock(rt_clock
);
1044 s
->fd_got_error
= 1;
1045 if (last_media_present
)
1046 s
->fd_media_changed
= 1;
1048 printf("No floppy\n");
1053 printf("Floppy opened\n");
1056 if (!last_media_present
)
1057 s
->fd_media_changed
= 1;
1058 s
->fd_open_time
= qemu_get_clock(rt_clock
);
1059 s
->fd_got_error
= 0;
1063 static int raw_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
1065 BDRVRawState
*s
= bs
->opaque
;
1067 return ioctl(s
->fd
, req
, buf
);
1071 static BlockDriverAIOCB
*raw_aio_ioctl(BlockDriverState
*bs
,
1072 unsigned long int req
, void *buf
,
1073 BlockDriverCompletionFunc
*cb
, void *opaque
)
1075 BDRVRawState
*s
= bs
->opaque
;
1078 if (fd_open(bs
) < 0)
1081 acb
= qemu_aio_get(&raw_aio_pool
, bs
, cb
, opaque
);
1084 acb
->aiocb
.aio_fildes
= s
->fd
;
1085 acb
->aiocb
.ev_signo
= SIGUSR2
;
1086 acb
->aiocb
.aio_offset
= 0;
1087 acb
->aiocb
.aio_flags
= 0;
1089 acb
->next
= posix_aio_state
->first_aio
;
1090 posix_aio_state
->first_aio
= acb
;
1092 acb
->aiocb
.aio_ioctl_buf
= buf
;
1093 acb
->aiocb
.aio_ioctl_cmd
= req
;
1094 if (qemu_paio_ioctl(&acb
->aiocb
) < 0) {
1095 raw_aio_remove(acb
);
1099 return &acb
->common
;
1103 #elif defined(__FreeBSD__)
1104 static int fd_open(BlockDriverState
*bs
)
1106 BDRVRawState
*s
= bs
->opaque
;
1108 /* this is just to ensure s->fd is sane (its called by io ops) */
1114 static int raw_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
1118 #else /* !linux && !FreeBSD */
1120 static int fd_open(BlockDriverState
*bs
)
1125 static int raw_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
1130 static BlockDriverAIOCB
*raw_aio_ioctl(BlockDriverState
*bs
,
1131 unsigned long int req
, void *buf
,
1132 BlockDriverCompletionFunc
*cb
, void *opaque
)
1136 #endif /* !linux && !FreeBSD */
1138 static int hdev_create(const char *filename
, QEMUOptionParameter
*options
)
1142 struct stat stat_buf
;
1143 int64_t total_size
= 0;
1145 /* Read out options */
1146 while (options
&& options
->name
) {
1147 if (!strcmp(options
->name
, "size")) {
1148 total_size
= options
->value
.n
/ 512;
1153 fd
= open(filename
, O_WRONLY
| O_BINARY
);
1157 if (fstat(fd
, &stat_buf
) < 0)
1159 else if (!S_ISBLK(stat_buf
.st_mode
) && !S_ISCHR(stat_buf
.st_mode
))
1161 else if (lseek(fd
, 0, SEEK_END
) < total_size
* 512)
1168 static BlockDriver bdrv_host_device
= {
1169 .format_name
= "host_device",
1170 .instance_size
= sizeof(BDRVRawState
),
1171 .bdrv_probe_device
= hdev_probe_device
,
1172 .bdrv_open
= hdev_open
,
1173 .bdrv_close
= raw_close
,
1174 .bdrv_create
= hdev_create
,
1175 .bdrv_flush
= raw_flush
,
1178 .bdrv_aio_readv
= raw_aio_readv
,
1179 .bdrv_aio_writev
= raw_aio_writev
,
1182 .bdrv_read
= raw_read
,
1183 .bdrv_write
= raw_write
,
1184 .bdrv_getlength
= raw_getlength
,
1186 /* generic scsi device */
1187 .bdrv_ioctl
= raw_ioctl
,
1189 .bdrv_aio_ioctl
= raw_aio_ioctl
,
1194 static int floppy_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1196 BDRVRawState
*s
= bs
->opaque
;
1202 /* open will not fail even if no floppy is inserted */
1203 s
->open_flags
|= O_NONBLOCK
;
1205 ret
= raw_open_common(bs
, filename
, flags
);
1209 /* close fd so that we can reopen it as needed */
1212 s
->fd_media_changed
= 1;
1217 static int floppy_probe_device(const char *filename
)
1219 if (strstart(filename
, "/dev/fd", NULL
))
1225 static int floppy_is_inserted(BlockDriverState
*bs
)
1227 return fd_open(bs
) >= 0;
1230 static int floppy_media_changed(BlockDriverState
*bs
)
1232 BDRVRawState
*s
= bs
->opaque
;
1236 * XXX: we do not have a true media changed indication.
1237 * It does not work if the floppy is changed without trying to read it.
1240 ret
= s
->fd_media_changed
;
1241 s
->fd_media_changed
= 0;
1243 printf("Floppy changed=%d\n", ret
);
1248 static int floppy_eject(BlockDriverState
*bs
, int eject_flag
)
1250 BDRVRawState
*s
= bs
->opaque
;
1257 fd
= open(bs
->filename
, s
->open_flags
| O_NONBLOCK
);
1259 if (ioctl(fd
, FDEJECT
, 0) < 0)
1267 static BlockDriver bdrv_host_floppy
= {
1268 .format_name
= "host_floppy",
1269 .instance_size
= sizeof(BDRVRawState
),
1270 .bdrv_probe_device
= floppy_probe_device
,
1271 .bdrv_open
= floppy_open
,
1272 .bdrv_close
= raw_close
,
1273 .bdrv_create
= hdev_create
,
1274 .bdrv_flush
= raw_flush
,
1277 .bdrv_aio_readv
= raw_aio_readv
,
1278 .bdrv_aio_writev
= raw_aio_writev
,
1281 .bdrv_read
= raw_read
,
1282 .bdrv_write
= raw_write
,
1283 .bdrv_getlength
= raw_getlength
,
1285 /* removable device support */
1286 .bdrv_is_inserted
= floppy_is_inserted
,
1287 .bdrv_media_changed
= floppy_media_changed
,
1288 .bdrv_eject
= floppy_eject
,
1290 /* generic scsi device */
1291 .bdrv_ioctl
= raw_ioctl
,
1293 .bdrv_aio_ioctl
= raw_aio_ioctl
,
1297 static int cdrom_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1299 BDRVRawState
*s
= bs
->opaque
;
1301 /* open will not fail even if no CD is inserted */
1302 s
->open_flags
|= O_NONBLOCK
;
1305 return raw_open_common(bs
, filename
, flags
);
1308 static int cdrom_probe_device(const char *filename
)
1310 if (strstart(filename
, "/dev/cd", NULL
))
1315 static int cdrom_is_inserted(BlockDriverState
*bs
)
1317 BDRVRawState
*s
= bs
->opaque
;
1320 ret
= ioctl(s
->fd
, CDROM_DRIVE_STATUS
, CDSL_CURRENT
);
1321 if (ret
== CDS_DISC_OK
)
1326 static int cdrom_eject(BlockDriverState
*bs
, int eject_flag
)
1328 BDRVRawState
*s
= bs
->opaque
;
1331 if (ioctl(s
->fd
, CDROMEJECT
, NULL
) < 0)
1332 perror("CDROMEJECT");
1334 if (ioctl(s
->fd
, CDROMCLOSETRAY
, NULL
) < 0)
1335 perror("CDROMEJECT");
1341 static int cdrom_set_locked(BlockDriverState
*bs
, int locked
)
1343 BDRVRawState
*s
= bs
->opaque
;
1345 if (ioctl(s
->fd
, CDROM_LOCKDOOR
, locked
) < 0) {
1347 * Note: an error can happen if the distribution automatically
1350 /* perror("CDROM_LOCKDOOR"); */
1356 static BlockDriver bdrv_host_cdrom
= {
1357 .format_name
= "host_cdrom",
1358 .instance_size
= sizeof(BDRVRawState
),
1359 .bdrv_probe_device
= cdrom_probe_device
,
1360 .bdrv_open
= cdrom_open
,
1361 .bdrv_close
= raw_close
,
1362 .bdrv_create
= hdev_create
,
1363 .bdrv_flush
= raw_flush
,
1366 .bdrv_aio_readv
= raw_aio_readv
,
1367 .bdrv_aio_writev
= raw_aio_writev
,
1370 .bdrv_read
= raw_read
,
1371 .bdrv_write
= raw_write
,
1372 .bdrv_getlength
= raw_getlength
,
1374 /* removable device support */
1375 .bdrv_is_inserted
= cdrom_is_inserted
,
1376 .bdrv_eject
= cdrom_eject
,
1377 .bdrv_set_locked
= cdrom_set_locked
,
1379 /* generic scsi device */
1380 .bdrv_ioctl
= raw_ioctl
,
1382 .bdrv_aio_ioctl
= raw_aio_ioctl
,
1385 #endif /* __linux__ */
1388 static int cdrom_open(BlockDriverState
*bs
, const char *filename
, int flags
)
1390 BDRVRawState
*s
= bs
->opaque
;
1395 ret
= raw_open_common(bs
, filename
, flags
);
1399 /* make sure the door isnt locked at this time */
1400 ioctl(s
->fd
, CDIOCALLOW
);
1404 static int cdrom_probe_device(const char *filename
)
1406 if (strstart(filename
, "/dev/cd", NULL
) ||
1407 strstart(filename
, "/dev/acd", NULL
))
1412 static int cdrom_reopen(BlockDriverState
*bs
)
1414 BDRVRawState
*s
= bs
->opaque
;
1418 * Force reread of possibly changed/newly loaded disc,
1419 * FreeBSD seems to not notice sometimes...
1423 fd
= open(bs
->filename
, s
->open_flags
, 0644);
1430 /* make sure the door isnt locked at this time */
1431 ioctl(s
->fd
, CDIOCALLOW
);
1435 static int cdrom_is_inserted(BlockDriverState
*bs
)
1437 return raw_getlength(bs
) > 0;
1440 static int cdrom_eject(BlockDriverState
*bs
, int eject_flag
)
1442 BDRVRawState
*s
= bs
->opaque
;
1447 (void) ioctl(s
->fd
, CDIOCALLOW
);
1450 if (ioctl(s
->fd
, CDIOCEJECT
) < 0)
1451 perror("CDIOCEJECT");
1453 if (ioctl(s
->fd
, CDIOCCLOSE
) < 0)
1454 perror("CDIOCCLOSE");
1457 if (cdrom_reopen(bs
) < 0)
1462 static int cdrom_set_locked(BlockDriverState
*bs
, int locked
)
1464 BDRVRawState
*s
= bs
->opaque
;
1468 if (ioctl(s
->fd
, (locked
? CDIOCPREVENT
: CDIOCALLOW
)) < 0) {
1470 * Note: an error can happen if the distribution automatically
1473 /* perror("CDROM_LOCKDOOR"); */
1479 static BlockDriver bdrv_host_cdrom
= {
1480 .format_name
= "host_cdrom",
1481 .instance_size
= sizeof(BDRVRawState
),
1482 .bdrv_probe_device
= cdrom_probe_device
,
1483 .bdrv_open
= cdrom_open
,
1484 .bdrv_close
= raw_close
,
1485 .bdrv_create
= hdev_create
,
1486 .bdrv_flush
= raw_flush
,
1489 .bdrv_aio_readv
= raw_aio_readv
,
1490 .bdrv_aio_writev
= raw_aio_writev
,
1493 .bdrv_read
= raw_read
,
1494 .bdrv_write
= raw_write
,
1495 .bdrv_getlength
= raw_getlength
,
1497 /* removable device support */
1498 .bdrv_is_inserted
= cdrom_is_inserted
,
1499 .bdrv_eject
= cdrom_eject
,
1500 .bdrv_set_locked
= cdrom_set_locked
,
1502 /* generic scsi device */
1503 .bdrv_ioctl
= raw_ioctl
,
1505 .bdrv_aio_ioctl
= raw_aio_ioctl
,
1508 #endif /* __FreeBSD__ */
1510 static void bdrv_raw_init(void)
1513 * Register all the drivers. Note that order is important, the driver
1514 * registered last will get probed first.
1516 bdrv_register(&bdrv_raw
);
1517 bdrv_register(&bdrv_host_device
);
1519 bdrv_register(&bdrv_host_floppy
);
1520 bdrv_register(&bdrv_host_cdrom
);
1523 bdrv_register(&bdrv_host_cdrom
);
1527 block_init(bdrv_raw_init
);