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 cd_open(BlockDriverState
*bs
);
125 static int raw_is_inserted(BlockDriverState
*bs
);
127 static int raw_open_common(BlockDriverState
*bs
, const char *filename
,
130 BDRVRawState
*s
= bs
->opaque
;
135 s
->lseek_err_cnt
= 0;
137 s
->open_flags
|= O_BINARY
;
138 if ((flags
& BDRV_O_ACCESS
) == O_RDWR
) {
139 s
->open_flags
|= O_RDWR
;
141 s
->open_flags
|= O_RDONLY
;
145 /* Use O_DSYNC for write-through caching, no flags for write-back caching,
146 * and O_DIRECT for no caching. */
147 if ((flags
& BDRV_O_NOCACHE
))
148 s
->open_flags
|= O_DIRECT
;
149 else if (!(flags
& BDRV_O_CACHE_WB
))
150 s
->open_flags
|= O_DSYNC
;
153 fd
= open(filename
, s
->open_flags
, 0644);
161 s
->aligned_buf
= NULL
;
162 if ((flags
& BDRV_O_NOCACHE
)) {
163 s
->aligned_buf
= qemu_blockalign(bs
, ALIGNED_BUFFER_SIZE
);
164 if (s
->aligned_buf
== NULL
) {
173 static int raw_open(BlockDriverState
*bs
, const char *filename
, int flags
)
175 BDRVRawState
*s
= bs
->opaque
;
177 s
->type
= FTYPE_FILE
;
178 if (flags
& BDRV_O_CREAT
)
179 s
->open_flags
|= O_CREAT
| O_TRUNC
;
181 return raw_open_common(bs
, filename
, flags
);
184 /* XXX: use host sector size if necessary with:
185 #ifdef DIOCGSECTORSIZE
187 unsigned int sectorsize = 512;
188 if (!ioctl(fd, DIOCGSECTORSIZE, §orsize) &&
189 sectorsize > bufsize)
190 bufsize = sectorsize;
194 u_int32_t blockSize = 512;
195 if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) {
202 * offset and count are in bytes, but must be multiples of 512 for files
203 * opened with O_DIRECT. buf must be aligned to 512 bytes then.
205 * This function may be called without alignment if the caller ensures
206 * that O_DIRECT is not in effect.
208 static int raw_pread_aligned(BlockDriverState
*bs
, int64_t offset
,
209 uint8_t *buf
, int count
)
211 BDRVRawState
*s
= bs
->opaque
;
218 if (offset
>= 0 && lseek(s
->fd
, offset
, SEEK_SET
) == (off_t
)-1) {
219 ++(s
->lseek_err_cnt
);
220 if(s
->lseek_err_cnt
<= 10) {
221 DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64
", %p, %d) [%" PRId64
222 "] lseek failed : %d = %s\n",
223 s
->fd
, bs
->filename
, offset
, buf
, count
,
224 bs
->total_sectors
, errno
, strerror(errno
));
230 ret
= read(s
->fd
, buf
, count
);
232 goto label__raw_read__success
;
234 DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64
", %p, %d) [%" PRId64
235 "] read failed %d : %d = %s\n",
236 s
->fd
, bs
->filename
, offset
, buf
, count
,
237 bs
->total_sectors
, ret
, errno
, strerror(errno
));
239 /* Try harder for CDrom. */
240 if (bs
->type
== BDRV_TYPE_CDROM
) {
241 lseek(s
->fd
, offset
, SEEK_SET
);
242 ret
= read(s
->fd
, buf
, count
);
244 goto label__raw_read__success
;
245 lseek(s
->fd
, offset
, SEEK_SET
);
246 ret
= read(s
->fd
, buf
, count
);
248 goto label__raw_read__success
;
250 DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64
", %p, %d) [%" PRId64
251 "] retry read failed %d : %d = %s\n",
252 s
->fd
, bs
->filename
, offset
, buf
, count
,
253 bs
->total_sectors
, ret
, errno
, strerror(errno
));
256 label__raw_read__success
:
258 return (ret
< 0) ? -errno
: ret
;
262 * offset and count are in bytes, but must be multiples of 512 for files
263 * opened with O_DIRECT. buf must be aligned to 512 bytes then.
265 * This function may be called without alignment if the caller ensures
266 * that O_DIRECT is not in effect.
268 static int raw_pwrite_aligned(BlockDriverState
*bs
, int64_t offset
,
269 const uint8_t *buf
, int count
)
271 BDRVRawState
*s
= bs
->opaque
;
278 if (offset
>= 0 && lseek(s
->fd
, offset
, SEEK_SET
) == (off_t
)-1) {
279 ++(s
->lseek_err_cnt
);
280 if(s
->lseek_err_cnt
) {
281 DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64
", %p, %d) [%"
282 PRId64
"] lseek failed : %d = %s\n",
283 s
->fd
, bs
->filename
, offset
, buf
, count
,
284 bs
->total_sectors
, errno
, strerror(errno
));
288 s
->lseek_err_cnt
= 0;
290 ret
= write(s
->fd
, buf
, count
);
292 goto label__raw_write__success
;
294 DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64
", %p, %d) [%" PRId64
295 "] write failed %d : %d = %s\n",
296 s
->fd
, bs
->filename
, offset
, buf
, count
,
297 bs
->total_sectors
, ret
, errno
, strerror(errno
));
299 label__raw_write__success
:
301 return (ret
< 0) ? -errno
: ret
;
306 * offset and count are in bytes and possibly not aligned. For files opened
307 * with O_DIRECT, necessary alignments are ensured before calling
308 * raw_pread_aligned to do the actual read.
310 static int raw_pread(BlockDriverState
*bs
, int64_t offset
,
311 uint8_t *buf
, int count
)
313 BDRVRawState
*s
= bs
->opaque
;
314 int size
, ret
, shift
, sum
;
318 if (s
->aligned_buf
!= NULL
) {
320 if (offset
& 0x1ff) {
321 /* align offset on a 512 bytes boundary */
323 shift
= offset
& 0x1ff;
324 size
= (shift
+ count
+ 0x1ff) & ~0x1ff;
325 if (size
> ALIGNED_BUFFER_SIZE
)
326 size
= ALIGNED_BUFFER_SIZE
;
327 ret
= raw_pread_aligned(bs
, offset
- shift
, s
->aligned_buf
, size
);
334 memcpy(buf
, s
->aligned_buf
+ shift
, size
);
344 if (count
& 0x1ff || (uintptr_t) buf
& 0x1ff) {
346 /* read on aligned buffer */
350 size
= (count
+ 0x1ff) & ~0x1ff;
351 if (size
> ALIGNED_BUFFER_SIZE
)
352 size
= ALIGNED_BUFFER_SIZE
;
354 ret
= raw_pread_aligned(bs
, offset
, s
->aligned_buf
, size
);
362 memcpy(buf
, s
->aligned_buf
, size
);
374 return raw_pread_aligned(bs
, offset
, buf
, count
) + sum
;
377 static int raw_read(BlockDriverState
*bs
, int64_t sector_num
,
378 uint8_t *buf
, int nb_sectors
)
382 ret
= raw_pread(bs
, sector_num
* 512, buf
, nb_sectors
* 512);
383 if (ret
== (nb_sectors
* 512))
389 * offset and count are in bytes and possibly not aligned. For files opened
390 * with O_DIRECT, necessary alignments are ensured before calling
391 * raw_pwrite_aligned to do the actual write.
393 static int raw_pwrite(BlockDriverState
*bs
, int64_t offset
,
394 const uint8_t *buf
, int count
)
396 BDRVRawState
*s
= bs
->opaque
;
397 int size
, ret
, shift
, sum
;
401 if (s
->aligned_buf
!= NULL
) {
403 if (offset
& 0x1ff) {
404 /* align offset on a 512 bytes boundary */
405 shift
= offset
& 0x1ff;
406 ret
= raw_pread_aligned(bs
, offset
- shift
, s
->aligned_buf
, 512);
413 memcpy(s
->aligned_buf
+ shift
, buf
, size
);
415 ret
= raw_pwrite_aligned(bs
, offset
- shift
, s
->aligned_buf
, 512);
427 if (count
& 0x1ff || (uintptr_t) buf
& 0x1ff) {
429 while ((size
= (count
& ~0x1ff)) != 0) {
431 if (size
> ALIGNED_BUFFER_SIZE
)
432 size
= ALIGNED_BUFFER_SIZE
;
434 memcpy(s
->aligned_buf
, buf
, size
);
436 ret
= raw_pwrite_aligned(bs
, offset
, s
->aligned_buf
, size
);
445 /* here, count < 512 because (count & ~0x1ff) == 0 */
447 ret
= raw_pread_aligned(bs
, offset
, s
->aligned_buf
, 512);
450 memcpy(s
->aligned_buf
, buf
, count
);
452 ret
= raw_pwrite_aligned(bs
, offset
, s
->aligned_buf
, 512);
463 return raw_pwrite_aligned(bs
, offset
, buf
, count
) + sum
;
466 static int raw_write(BlockDriverState
*bs
, int64_t sector_num
,
467 const uint8_t *buf
, int nb_sectors
)
470 ret
= raw_pwrite(bs
, sector_num
* 512, buf
, nb_sectors
* 512);
471 if (ret
== (nb_sectors
* 512))
477 /***********************************************************/
478 /* Unix AIO using POSIX AIO */
480 typedef struct RawAIOCB
{
481 BlockDriverAIOCB common
;
482 struct qemu_paiocb aiocb
;
483 struct RawAIOCB
*next
;
487 typedef struct PosixAioState
493 static void posix_aio_read(void *opaque
)
495 PosixAioState
*s
= opaque
;
496 RawAIOCB
*acb
, **pacb
;
500 /* read all bytes from signal pipe */
504 len
= read(s
->rfd
, bytes
, sizeof(bytes
));
505 if (len
== -1 && errno
== EINTR
)
506 continue; /* try again */
507 if (len
== sizeof(bytes
))
508 continue; /* more to read */
513 pacb
= &s
->first_aio
;
518 ret
= qemu_paio_error(&acb
->aiocb
);
519 if (ret
== ECANCELED
) {
520 /* remove the request */
522 qemu_aio_release(acb
);
523 } else if (ret
!= EINPROGRESS
) {
526 ret
= qemu_paio_return(&acb
->aiocb
);
527 if (ret
== acb
->aiocb
.aio_nbytes
)
534 /* remove the request */
536 /* call the callback */
537 acb
->common
.cb(acb
->common
.opaque
, ret
);
538 qemu_aio_release(acb
);
548 static int posix_aio_flush(void *opaque
)
550 PosixAioState
*s
= opaque
;
551 return !!s
->first_aio
;
554 static PosixAioState
*posix_aio_state
;
556 static void aio_signal_handler(int signum
)
558 if (posix_aio_state
) {
561 write(posix_aio_state
->wfd
, &byte
, sizeof(byte
));
567 static int posix_aio_init(void)
569 struct sigaction act
;
572 struct qemu_paioinit ai
;
577 s
= qemu_malloc(sizeof(PosixAioState
));
579 sigfillset(&act
.sa_mask
);
580 act
.sa_flags
= 0; /* do not restart syscalls to interrupt select() */
581 act
.sa_handler
= aio_signal_handler
;
582 sigaction(SIGUSR2
, &act
, NULL
);
585 if (pipe(fds
) == -1) {
586 fprintf(stderr
, "failed to create pipe\n");
593 fcntl(s
->rfd
, F_SETFL
, O_NONBLOCK
);
594 fcntl(s
->wfd
, F_SETFL
, O_NONBLOCK
);
596 qemu_aio_set_fd_handler(s
->rfd
, posix_aio_read
, NULL
, posix_aio_flush
, s
);
598 memset(&ai
, 0, sizeof(ai
));
608 static void raw_aio_remove(RawAIOCB
*acb
)
612 /* remove the callback from the queue */
613 pacb
= &posix_aio_state
->first_aio
;
616 fprintf(stderr
, "raw_aio_remove: aio request not found!\n");
618 } else if (*pacb
== acb
) {
620 qemu_aio_release(acb
);
623 pacb
= &(*pacb
)->next
;
627 static void raw_aio_cancel(BlockDriverAIOCB
*blockacb
)
630 RawAIOCB
*acb
= (RawAIOCB
*)blockacb
;
632 ret
= qemu_paio_cancel(acb
->aiocb
.aio_fildes
, &acb
->aiocb
);
633 if (ret
== QEMU_PAIO_NOTCANCELED
) {
634 /* fail safe: if the aio could not be canceled, we wait for
636 while (qemu_paio_error(&acb
->aiocb
) == EINPROGRESS
);
642 static AIOPool raw_aio_pool
= {
643 .aiocb_size
= sizeof(RawAIOCB
),
644 .cancel
= raw_aio_cancel
,
647 static RawAIOCB
*raw_aio_setup(BlockDriverState
*bs
, int64_t sector_num
,
648 QEMUIOVector
*qiov
, int nb_sectors
,
649 BlockDriverCompletionFunc
*cb
, void *opaque
)
651 BDRVRawState
*s
= bs
->opaque
;
657 acb
= qemu_aio_get(&raw_aio_pool
, bs
, cb
, opaque
);
660 acb
->aiocb
.aio_fildes
= s
->fd
;
661 acb
->aiocb
.ev_signo
= SIGUSR2
;
662 acb
->aiocb
.aio_iov
= qiov
->iov
;
663 acb
->aiocb
.aio_niov
= qiov
->niov
;
664 acb
->aiocb
.aio_nbytes
= nb_sectors
* 512;
665 acb
->aiocb
.aio_offset
= sector_num
* 512;
666 acb
->aiocb
.aio_flags
= 0;
669 * If O_DIRECT is used the buffer needs to be aligned on a sector
670 * boundary. Tell the low level code to ensure that in case it's
674 acb
->aiocb
.aio_flags
|= QEMU_AIO_SECTOR_ALIGNED
;
676 acb
->next
= posix_aio_state
->first_aio
;
677 posix_aio_state
->first_aio
= acb
;
681 static BlockDriverAIOCB
*raw_aio_readv(BlockDriverState
*bs
,
682 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
683 BlockDriverCompletionFunc
*cb
, void *opaque
)
687 acb
= raw_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
);
690 if (qemu_paio_read(&acb
->aiocb
) < 0) {
697 static BlockDriverAIOCB
*raw_aio_writev(BlockDriverState
*bs
,
698 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
699 BlockDriverCompletionFunc
*cb
, void *opaque
)
703 acb
= raw_aio_setup(bs
, sector_num
, qiov
, nb_sectors
, cb
, opaque
);
706 if (qemu_paio_write(&acb
->aiocb
) < 0) {
712 #else /* CONFIG_AIO */
713 static int posix_aio_init(void)
717 #endif /* CONFIG_AIO */
720 static void raw_close(BlockDriverState
*bs
)
722 BDRVRawState
*s
= bs
->opaque
;
726 if (s
->aligned_buf
!= NULL
)
727 qemu_free(s
->aligned_buf
);
731 static int raw_truncate(BlockDriverState
*bs
, int64_t offset
)
733 BDRVRawState
*s
= bs
->opaque
;
734 if (s
->type
!= FTYPE_FILE
)
736 if (ftruncate(s
->fd
, offset
) < 0)
742 static int64_t raw_getlength(BlockDriverState
*bs
)
744 BDRVRawState
*s
= bs
->opaque
;
750 if (S_ISCHR(st
.st_mode
) || S_ISBLK(st
.st_mode
)) {
753 if (ioctl(fd
, DIOCGDINFO
, &dl
))
755 return (uint64_t)dl
.d_secsize
*
756 dl
.d_partitions
[DISKPART(st
.st_rdev
)].p_size
;
760 #else /* !__OpenBSD__ */
761 static int64_t raw_getlength(BlockDriverState
*bs
)
763 BDRVRawState
*s
= bs
->opaque
;
773 struct dk_minfo minfo
;
786 if (!fstat(fd
, &sb
) && (S_IFCHR
& sb
.st_mode
)) {
787 #ifdef DIOCGMEDIASIZE
788 if (ioctl(fd
, DIOCGMEDIASIZE
, (off_t
*)&size
))
789 #elif defined(DIOCGPART)
792 if (ioctl(fd
, DIOCGPART
, &pi
) == 0)
793 size
= pi
.media_size
;
800 size
= LONG_LONG_MAX
;
802 size
= lseek(fd
, 0LL, SEEK_END
);
807 /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
808 if (size
== 2048LL * (unsigned)-1)
810 /* XXX no disc? maybe we need to reopen... */
811 if (size
<= 0 && !reopened
&& cd_open(bs
) >= 0) {
821 * use the DKIOCGMEDIAINFO ioctl to read the size.
823 rv
= ioctl ( fd
, DKIOCGMEDIAINFO
, &minfo
);
825 size
= minfo
.dki_lbsize
* minfo
.dki_capacity
;
826 } else /* there are reports that lseek on some devices
827 fails, but irc discussion said that contingency
828 on contingency was overkill */
831 size
= lseek(fd
, 0, SEEK_END
);
837 static int raw_create(const char *filename
, QEMUOptionParameter
*options
)
840 int64_t total_size
= 0;
842 /* Read out options */
843 while (options
&& options
->name
) {
844 if (!strcmp(options
->name
, BLOCK_OPT_SIZE
)) {
845 total_size
= options
->value
.n
/ 512;
850 fd
= open(filename
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_BINARY
,
854 ftruncate(fd
, total_size
* 512);
859 static void raw_flush(BlockDriverState
*bs
)
861 BDRVRawState
*s
= bs
->opaque
;
866 static QEMUOptionParameter raw_create_options
[] = {
868 .name
= BLOCK_OPT_SIZE
,
870 .help
= "Virtual disk size"
875 static BlockDriver bdrv_raw
= {
876 .format_name
= "raw",
877 .instance_size
= sizeof(BDRVRawState
),
878 .bdrv_probe
= NULL
, /* no probe for protocols */
879 .bdrv_open
= raw_open
,
880 .bdrv_read
= raw_read
,
881 .bdrv_write
= raw_write
,
882 .bdrv_close
= raw_close
,
883 .bdrv_create
= raw_create
,
884 .bdrv_flush
= raw_flush
,
887 .bdrv_aio_readv
= raw_aio_readv
,
888 .bdrv_aio_writev
= raw_aio_writev
,
891 .bdrv_truncate
= raw_truncate
,
892 .bdrv_getlength
= raw_getlength
,
894 .create_options
= raw_create_options
,
897 /***********************************************/
901 static kern_return_t
FindEjectableCDMedia( io_iterator_t
*mediaIterator
);
902 static kern_return_t
GetBSDPath( io_iterator_t mediaIterator
, char *bsdPath
, CFIndex maxPathSize
);
904 kern_return_t
FindEjectableCDMedia( io_iterator_t
*mediaIterator
)
906 kern_return_t kernResult
;
907 mach_port_t masterPort
;
908 CFMutableDictionaryRef classesToMatch
;
910 kernResult
= IOMasterPort( MACH_PORT_NULL
, &masterPort
);
911 if ( KERN_SUCCESS
!= kernResult
) {
912 printf( "IOMasterPort returned %d\n", kernResult
);
915 classesToMatch
= IOServiceMatching( kIOCDMediaClass
);
916 if ( classesToMatch
== NULL
) {
917 printf( "IOServiceMatching returned a NULL dictionary.\n" );
919 CFDictionarySetValue( classesToMatch
, CFSTR( kIOMediaEjectableKey
), kCFBooleanTrue
);
921 kernResult
= IOServiceGetMatchingServices( masterPort
, classesToMatch
, mediaIterator
);
922 if ( KERN_SUCCESS
!= kernResult
)
924 printf( "IOServiceGetMatchingServices returned %d\n", kernResult
);
930 kern_return_t
GetBSDPath( io_iterator_t mediaIterator
, char *bsdPath
, CFIndex maxPathSize
)
932 io_object_t nextMedia
;
933 kern_return_t kernResult
= KERN_FAILURE
;
935 nextMedia
= IOIteratorNext( mediaIterator
);
938 CFTypeRef bsdPathAsCFString
;
939 bsdPathAsCFString
= IORegistryEntryCreateCFProperty( nextMedia
, CFSTR( kIOBSDNameKey
), kCFAllocatorDefault
, 0 );
940 if ( bsdPathAsCFString
) {
941 size_t devPathLength
;
942 strcpy( bsdPath
, _PATH_DEV
);
943 strcat( bsdPath
, "r" );
944 devPathLength
= strlen( bsdPath
);
945 if ( CFStringGetCString( bsdPathAsCFString
, bsdPath
+ devPathLength
, maxPathSize
- devPathLength
, kCFStringEncodingASCII
) ) {
946 kernResult
= KERN_SUCCESS
;
948 CFRelease( bsdPathAsCFString
);
950 IOObjectRelease( nextMedia
);
958 static int hdev_open(BlockDriverState
*bs
, const char *filename
, int flags
)
960 BDRVRawState
*s
= bs
->opaque
;
964 if (strstart(filename
, "/dev/cdrom", NULL
)) {
965 kern_return_t kernResult
;
966 io_iterator_t mediaIterator
;
967 char bsdPath
[ MAXPATHLEN
];
970 kernResult
= FindEjectableCDMedia( &mediaIterator
);
971 kernResult
= GetBSDPath( mediaIterator
, bsdPath
, sizeof( bsdPath
) );
973 if ( bsdPath
[ 0 ] != '\0' ) {
974 strcat(bsdPath
,"s0");
975 /* some CDs don't have a partition 0 */
976 fd
= open(bsdPath
, O_RDONLY
| O_BINARY
| O_LARGEFILE
);
978 bsdPath
[strlen(bsdPath
)-1] = '1';
986 IOObjectRelease( mediaIterator
);
990 s
->type
= FTYPE_FILE
;
991 #if defined(__linux__)
992 if (strstart(filename
, "/dev/cd", NULL
)) {
993 /* open will not fail even if no CD is inserted */
994 s
->open_flags
|= O_NONBLOCK
;
996 } else if (strstart(filename
, "/dev/fd", NULL
)) {
998 /* open will not fail even if no floppy is inserted */
999 s
->open_flags
|= O_NONBLOCK
;
1001 } else if (strstart(filename
, "/dev/sg", NULL
)) {
1006 #if defined(__FreeBSD__)
1007 if (strstart(filename
, "/dev/cd", NULL
) ||
1008 strstart(filename
, "/dev/acd", NULL
)) {
1013 ret
= raw_open_common(bs
, filename
, flags
);
1017 #if defined(__FreeBSD__)
1018 /* make sure the door isnt locked at this time */
1019 if (s
->type
== FTYPE_CD
)
1020 ioctl (s
->fd
, CDIOCALLOW
);
1022 #if defined(__linux__)
1023 /* close fd so that we can reopen it as needed */
1024 if (s
->type
== FTYPE_FD
) {
1027 s
->fd_media_changed
= 1;
1033 #if defined(__linux__)
1034 /* Note: we do not have a reliable method to detect if the floppy is
1035 present. The current method is to try to open the floppy at every
1036 I/O and to keep it opened during a few hundreds of ms. */
1037 static int fd_open(BlockDriverState
*bs
)
1039 BDRVRawState
*s
= bs
->opaque
;
1040 int last_media_present
;
1042 if (s
->type
!= FTYPE_FD
)
1044 last_media_present
= (s
->fd
>= 0);
1046 (qemu_get_clock(rt_clock
) - s
->fd_open_time
) >= FD_OPEN_TIMEOUT
) {
1050 printf("Floppy closed\n");
1054 if (s
->fd_got_error
&&
1055 (qemu_get_clock(rt_clock
) - s
->fd_error_time
) < FD_OPEN_TIMEOUT
) {
1057 printf("No floppy (open delayed)\n");
1061 s
->fd
= open(bs
->filename
, s
->open_flags
& ~O_NONBLOCK
);
1063 s
->fd_error_time
= qemu_get_clock(rt_clock
);
1064 s
->fd_got_error
= 1;
1065 if (last_media_present
)
1066 s
->fd_media_changed
= 1;
1068 printf("No floppy\n");
1073 printf("Floppy opened\n");
1076 if (!last_media_present
)
1077 s
->fd_media_changed
= 1;
1078 s
->fd_open_time
= qemu_get_clock(rt_clock
);
1079 s
->fd_got_error
= 0;
1083 static int raw_is_inserted(BlockDriverState
*bs
)
1085 BDRVRawState
*s
= bs
->opaque
;
1090 ret
= ioctl(s
->fd
, CDROM_DRIVE_STATUS
, CDSL_CURRENT
);
1091 if (ret
== CDS_DISC_OK
)
1104 /* currently only used by fdc.c, but a CD version would be good too */
1105 static int raw_media_changed(BlockDriverState
*bs
)
1107 BDRVRawState
*s
= bs
->opaque
;
1113 /* XXX: we do not have a true media changed indication. It
1114 does not work if the floppy is changed without trying
1117 ret
= s
->fd_media_changed
;
1118 s
->fd_media_changed
= 0;
1120 printf("Floppy changed=%d\n", ret
);
1129 static int raw_eject(BlockDriverState
*bs
, int eject_flag
)
1131 BDRVRawState
*s
= bs
->opaque
;
1136 if (ioctl (s
->fd
, CDROMEJECT
, NULL
) < 0)
1137 perror("CDROMEJECT");
1139 if (ioctl (s
->fd
, CDROMCLOSETRAY
, NULL
) < 0)
1140 perror("CDROMEJECT");
1150 fd
= open(bs
->filename
, s
->open_flags
| O_NONBLOCK
);
1152 if (ioctl(fd
, FDEJECT
, 0) < 0)
1164 static int raw_set_locked(BlockDriverState
*bs
, int locked
)
1166 BDRVRawState
*s
= bs
->opaque
;
1170 if (ioctl (s
->fd
, CDROM_LOCKDOOR
, locked
) < 0) {
1171 /* Note: an error can happen if the distribution automatically
1172 mounts the CD-ROM */
1173 // perror("CDROM_LOCKDOOR");
1182 static int raw_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
1184 BDRVRawState
*s
= bs
->opaque
;
1186 return ioctl(s
->fd
, req
, buf
);
1190 static BlockDriverAIOCB
*raw_aio_ioctl(BlockDriverState
*bs
,
1191 unsigned long int req
, void *buf
,
1192 BlockDriverCompletionFunc
*cb
, void *opaque
)
1194 BDRVRawState
*s
= bs
->opaque
;
1197 if (fd_open(bs
) < 0)
1200 acb
= qemu_aio_get(&raw_aio_pool
, bs
, cb
, opaque
);
1203 acb
->aiocb
.aio_fildes
= s
->fd
;
1204 acb
->aiocb
.ev_signo
= SIGUSR2
;
1205 acb
->aiocb
.aio_offset
= 0;
1206 acb
->aiocb
.aio_flags
= 0;
1208 acb
->next
= posix_aio_state
->first_aio
;
1209 posix_aio_state
->first_aio
= acb
;
1211 acb
->aiocb
.aio_ioctl_buf
= buf
;
1212 acb
->aiocb
.aio_ioctl_cmd
= req
;
1213 if (qemu_paio_ioctl(&acb
->aiocb
) < 0) {
1214 raw_aio_remove(acb
);
1218 return &acb
->common
;
1222 #elif defined(__FreeBSD__)
1224 static int fd_open(BlockDriverState
*bs
)
1226 BDRVRawState
*s
= bs
->opaque
;
1228 /* this is just to ensure s->fd is sane (its called by io ops) */
1234 static int cd_open(BlockDriverState
*bs
)
1236 #if defined(__FreeBSD__)
1237 BDRVRawState
*s
= bs
->opaque
;
1242 /* XXX force reread of possibly changed/newly loaded disc,
1243 * FreeBSD seems to not notice sometimes... */
1246 fd
= open(bs
->filename
, s
->open_flags
, 0644);
1252 /* make sure the door isnt locked at this time */
1253 ioctl (s
->fd
, CDIOCALLOW
);
1259 static int raw_is_inserted(BlockDriverState
*bs
)
1261 BDRVRawState
*s
= bs
->opaque
;
1265 return (raw_getlength(bs
) > 0);
1267 /* XXX handle this */
1274 static int raw_media_changed(BlockDriverState
*bs
)
1279 static int raw_eject(BlockDriverState
*bs
, int eject_flag
)
1281 BDRVRawState
*s
= bs
->opaque
;
1287 (void) ioctl (s
->fd
, CDIOCALLOW
);
1289 if (ioctl (s
->fd
, CDIOCEJECT
) < 0)
1290 perror("CDIOCEJECT");
1292 if (ioctl (s
->fd
, CDIOCCLOSE
) < 0)
1293 perror("CDIOCCLOSE");
1295 if (cd_open(bs
) < 0)
1299 /* XXX handle this */
1307 static int raw_set_locked(BlockDriverState
*bs
, int locked
)
1309 BDRVRawState
*s
= bs
->opaque
;
1315 if (ioctl (s
->fd
, (locked
? CDIOCPREVENT
: CDIOCALLOW
)) < 0) {
1316 /* Note: an error can happen if the distribution automatically
1317 mounts the CD-ROM */
1318 // perror("CDROM_LOCKDOOR");
1327 static int raw_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
1331 #else /* !linux && !FreeBSD */
1333 static int fd_open(BlockDriverState
*bs
)
1338 static int raw_is_inserted(BlockDriverState
*bs
)
1343 static int raw_media_changed(BlockDriverState
*bs
)
1348 static int raw_eject(BlockDriverState
*bs
, int eject_flag
)
1353 static int raw_set_locked(BlockDriverState
*bs
, int locked
)
1358 static int raw_ioctl(BlockDriverState
*bs
, unsigned long int req
, void *buf
)
1363 static BlockDriverAIOCB
*raw_aio_ioctl(BlockDriverState
*bs
,
1364 unsigned long int req
, void *buf
,
1365 BlockDriverCompletionFunc
*cb
, void *opaque
)
1369 #endif /* !linux && !FreeBSD */
1371 static int hdev_create(const char *filename
, QEMUOptionParameter
*options
)
1375 struct stat stat_buf
;
1376 int64_t total_size
= 0;
1378 /* Read out options */
1379 while (options
&& options
->name
) {
1380 if (!strcmp(options
->name
, "size")) {
1381 total_size
= options
->value
.n
/ 512;
1386 fd
= open(filename
, O_WRONLY
| O_BINARY
);
1390 if (fstat(fd
, &stat_buf
) < 0)
1392 else if (!S_ISBLK(stat_buf
.st_mode
) && !S_ISCHR(stat_buf
.st_mode
))
1394 else if (lseek(fd
, 0, SEEK_END
) < total_size
* 512)
1401 static BlockDriver bdrv_host_device
= {
1402 .format_name
= "host_device",
1403 .instance_size
= sizeof(BDRVRawState
),
1404 .bdrv_open
= hdev_open
,
1405 .bdrv_close
= raw_close
,
1406 .bdrv_create
= hdev_create
,
1407 .bdrv_flush
= raw_flush
,
1410 .bdrv_aio_readv
= raw_aio_readv
,
1411 .bdrv_aio_writev
= raw_aio_writev
,
1414 .bdrv_read
= raw_read
,
1415 .bdrv_write
= raw_write
,
1416 .bdrv_getlength
= raw_getlength
,
1418 /* removable device support */
1419 .bdrv_is_inserted
= raw_is_inserted
,
1420 .bdrv_media_changed
= raw_media_changed
,
1421 .bdrv_eject
= raw_eject
,
1422 .bdrv_set_locked
= raw_set_locked
,
1423 /* generic scsi device */
1424 .bdrv_ioctl
= raw_ioctl
,
1426 .bdrv_aio_ioctl
= raw_aio_ioctl
,
1430 static void bdrv_raw_init(void)
1432 bdrv_register(&bdrv_raw
);
1433 bdrv_register(&bdrv_host_device
);
1436 block_init(bdrv_raw_init
);