![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to raw-posix.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / block|
Return to raw-posix.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / block |
1.1 root 1: /*
2: * Block driver for RAW files (posix)
3: *
4: * Copyright (c) 2006 Fabrice Bellard
5: *
6: * Permission is hereby granted, free of charge, to any person obtaining a copy
7: * of this software and associated documentation files (the "Software"), to deal
8: * in the Software without restriction, including without limitation the rights
9: * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10: * copies of the Software, and to permit persons to whom the Software is
11: * furnished to do so, subject to the following conditions:
12: *
13: * The above copyright notice and this permission notice shall be included in
14: * all copies or substantial portions of the Software.
15: *
16: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21: * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22: * THE SOFTWARE.
23: */
24: #include "qemu-common.h"
25: #include "qemu-timer.h"
26: #include "qemu-char.h"
27: #include "qemu-log.h"
28: #include "block_int.h"
29: #include "module.h"
30: #ifdef CONFIG_AIO
31: #include "posix-aio-compat.h"
32: #endif
33:
34: #ifdef CONFIG_COCOA
35: #include <paths.h>
36: #include <sys/param.h>
37: #include <IOKit/IOKitLib.h>
38: #include <IOKit/IOBSD.h>
39: #include <IOKit/storage/IOMediaBSDClient.h>
40: #include <IOKit/storage/IOMedia.h>
41: #include <IOKit/storage/IOCDMedia.h>
42: //#include <IOKit/storage/IOCDTypes.h>
43: #include <CoreFoundation/CoreFoundation.h>
44: #endif
45:
46: #ifdef __sun__
47: #define _POSIX_PTHREAD_SEMANTICS 1
48: #include <signal.h>
49: #include <sys/dkio.h>
50: #endif
51: #ifdef __linux__
52: #include <sys/ioctl.h>
53: #include <linux/cdrom.h>
54: #include <linux/fd.h>
55: #endif
56: #ifdef __FreeBSD__
57: #include <signal.h>
58: #include <sys/disk.h>
59: #include <sys/cdio.h>
60: #endif
61:
62: #ifdef __OpenBSD__
63: #include <sys/ioctl.h>
64: #include <sys/disklabel.h>
65: #include <sys/dkio.h>
66: #endif
67:
68: #ifdef __DragonFly__
69: #include <sys/ioctl.h>
70: #include <sys/diskslice.h>
71: #endif
72:
73: //#define DEBUG_FLOPPY
74:
75: //#define DEBUG_BLOCK
76: #if defined(DEBUG_BLOCK)
77: #define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \
78: { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0)
79: #else
80: #define DEBUG_BLOCK_PRINT(formatCstr, ...)
81: #endif
82:
83: /* OS X does not have O_DSYNC */
84: #ifndef O_DSYNC
85: #ifdef O_SYNC
86: #define O_DSYNC O_SYNC
87: #elif defined(O_FSYNC)
88: #define O_DSYNC O_FSYNC
89: #endif
90: #endif
91:
92: /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
93: #ifndef O_DIRECT
94: #define O_DIRECT O_DSYNC
95: #endif
96:
97: #define FTYPE_FILE 0
98: #define FTYPE_CD 1
99: #define FTYPE_FD 2
100:
101: #define ALIGNED_BUFFER_SIZE (32 * 512)
102:
103: /* if the FD is not accessed during that time (in ms), we try to
104: reopen it to see if the disk has been changed */
105: #define FD_OPEN_TIMEOUT 1000
106:
107: typedef struct BDRVRawState {
108: int fd;
109: int type;
110: unsigned int lseek_err_cnt;
111: int open_flags;
112: #if defined(__linux__)
113: /* linux floppy specific */
114: int64_t fd_open_time;
115: int64_t fd_error_time;
116: int fd_got_error;
117: int fd_media_changed;
118: #endif
119: uint8_t* aligned_buf;
120: } BDRVRawState;
121:
122: static int posix_aio_init(void);
123:
124: static int fd_open(BlockDriverState *bs);
125: static int64_t raw_getlength(BlockDriverState *bs);
126:
127: #if defined(__FreeBSD__)
128: static int cdrom_reopen(BlockDriverState *bs);
129: #endif
130:
131: static int raw_open_common(BlockDriverState *bs, const char *filename,
132: int bdrv_flags, int open_flags)
133: {
134: BDRVRawState *s = bs->opaque;
135: int fd, ret;
136:
137: posix_aio_init();
138:
139: s->lseek_err_cnt = 0;
140:
141: s->open_flags = open_flags | O_BINARY;
142: s->open_flags &= ~O_ACCMODE;
143: if ((bdrv_flags & BDRV_O_ACCESS) == BDRV_O_RDWR) {
144: s->open_flags |= O_RDWR;
145: } else {
146: s->open_flags |= O_RDONLY;
147: bs->read_only = 1;
148: }
149:
150: /* Use O_DSYNC for write-through caching, no flags for write-back caching,
151: * and O_DIRECT for no caching. */
152: if ((bdrv_flags & BDRV_O_NOCACHE))
153: s->open_flags |= O_DIRECT;
154: else if (!(bdrv_flags & BDRV_O_CACHE_WB))
155: s->open_flags |= O_DSYNC;
156:
157: s->fd = -1;
158: fd = open(filename, s->open_flags, 0644);
159: if (fd < 0) {
160: ret = -errno;
161: if (ret == -EROFS)
162: ret = -EACCES;
163: return ret;
164: }
165: s->fd = fd;
166: s->aligned_buf = NULL;
167: if ((bdrv_flags & BDRV_O_NOCACHE)) {
168: s->aligned_buf = qemu_blockalign(bs, ALIGNED_BUFFER_SIZE);
169: if (s->aligned_buf == NULL) {
170: ret = -errno;
171: close(fd);
172: return ret;
173: }
174: }
175: return 0;
176: }
177:
178: static int raw_open(BlockDriverState *bs, const char *filename, int flags)
179: {
180: BDRVRawState *s = bs->opaque;
181: int open_flags = 0;
182:
183: s->type = FTYPE_FILE;
184: if (flags & BDRV_O_CREAT)
185: open_flags = O_CREAT | O_TRUNC;
186:
187: return raw_open_common(bs, filename, flags, open_flags);
188: }
189:
190: /* XXX: use host sector size if necessary with:
191: #ifdef DIOCGSECTORSIZE
192: {
193: unsigned int sectorsize = 512;
194: if (!ioctl(fd, DIOCGSECTORSIZE, §orsize) &&
195: sectorsize > bufsize)
196: bufsize = sectorsize;
197: }
198: #endif
199: #ifdef CONFIG_COCOA
200: u_int32_t blockSize = 512;
201: if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) {
202: bufsize = blockSize;
203: }
204: #endif
205: */
206:
207: /*
208: * offset and count are in bytes, but must be multiples of 512 for files
209: * opened with O_DIRECT. buf must be aligned to 512 bytes then.
210: *
211: * This function may be called without alignment if the caller ensures
212: * that O_DIRECT is not in effect.
213: */
214: static int raw_pread_aligned(BlockDriverState *bs, int64_t offset,
215: uint8_t *buf, int count)
216: {
217: BDRVRawState *s = bs->opaque;
218: int ret;
219:
220: ret = fd_open(bs);
221: if (ret < 0)
222: return ret;
223:
224: if (offset >= 0 && lseek(s->fd, offset, SEEK_SET) == (off_t)-1) {
225: ++(s->lseek_err_cnt);
226: if(s->lseek_err_cnt <= 10) {
227: DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64 ", %p, %d) [%" PRId64
228: "] lseek failed : %d = %s\n",
229: s->fd, bs->filename, offset, buf, count,
230: bs->total_sectors, errno, strerror(errno));
231: }
232: return -1;
233: }
234: s->lseek_err_cnt=0;
235:
236: ret = read(s->fd, buf, count);
237: if (ret == count)
238: goto label__raw_read__success;
239:
240: /* Allow reads beyond the end (needed for pwrite) */
241: if ((ret == 0) && bs->growable) {
242: int64_t size = raw_getlength(bs);
243: if (offset >= size) {
244: memset(buf, 0, count);
245: ret = count;
246: goto label__raw_read__success;
247: }
248: }
249:
250: DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64 ", %p, %d) [%" PRId64
251: "] read failed %d : %d = %s\n",
252: s->fd, bs->filename, offset, buf, count,
253: bs->total_sectors, ret, errno, strerror(errno));
254:
255: /* Try harder for CDrom. */
256: if (bs->type == BDRV_TYPE_CDROM) {
257: lseek(s->fd, offset, SEEK_SET);
258: ret = read(s->fd, buf, count);
259: if (ret == count)
260: goto label__raw_read__success;
261: lseek(s->fd, offset, SEEK_SET);
262: ret = read(s->fd, buf, count);
263: if (ret == count)
264: goto label__raw_read__success;
265:
266: DEBUG_BLOCK_PRINT("raw_pread(%d:%s, %" PRId64 ", %p, %d) [%" PRId64
267: "] retry read failed %d : %d = %s\n",
268: s->fd, bs->filename, offset, buf, count,
269: bs->total_sectors, ret, errno, strerror(errno));
270: }
271:
272: label__raw_read__success:
273:
274: return (ret < 0) ? -errno : ret;
275: }
276:
277: /*
278: * offset and count are in bytes, but must be multiples of 512 for files
279: * opened with O_DIRECT. buf must be aligned to 512 bytes then.
280: *
281: * This function may be called without alignment if the caller ensures
282: * that O_DIRECT is not in effect.
283: */
284: static int raw_pwrite_aligned(BlockDriverState *bs, int64_t offset,
285: const uint8_t *buf, int count)
286: {
287: BDRVRawState *s = bs->opaque;
288: int ret;
289:
290: ret = fd_open(bs);
291: if (ret < 0)
292: return -errno;
293:
294: if (offset >= 0 && lseek(s->fd, offset, SEEK_SET) == (off_t)-1) {
295: ++(s->lseek_err_cnt);
296: if(s->lseek_err_cnt) {
297: DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64 ", %p, %d) [%"
298: PRId64 "] lseek failed : %d = %s\n",
299: s->fd, bs->filename, offset, buf, count,
300: bs->total_sectors, errno, strerror(errno));
301: }
302: return -EIO;
303: }
304: s->lseek_err_cnt = 0;
305:
306: ret = write(s->fd, buf, count);
307: if (ret == count)
308: goto label__raw_write__success;
309:
310: DEBUG_BLOCK_PRINT("raw_pwrite(%d:%s, %" PRId64 ", %p, %d) [%" PRId64
311: "] write failed %d : %d = %s\n",
312: s->fd, bs->filename, offset, buf, count,
313: bs->total_sectors, ret, errno, strerror(errno));
314:
315: label__raw_write__success:
316:
317: return (ret < 0) ? -errno : ret;
318: }
319:
320:
321: /*
322: * offset and count are in bytes and possibly not aligned. For files opened
323: * with O_DIRECT, necessary alignments are ensured before calling
324: * raw_pread_aligned to do the actual read.
325: */
326: static int raw_pread(BlockDriverState *bs, int64_t offset,
327: uint8_t *buf, int count)
328: {
329: BDRVRawState *s = bs->opaque;
330: int size, ret, shift, sum;
331:
332: sum = 0;
333:
334: if (s->aligned_buf != NULL) {
335:
336: if (offset & 0x1ff) {
337: /* align offset on a 512 bytes boundary */
338:
339: shift = offset & 0x1ff;
340: size = (shift + count + 0x1ff) & ~0x1ff;
341: if (size > ALIGNED_BUFFER_SIZE)
342: size = ALIGNED_BUFFER_SIZE;
343: ret = raw_pread_aligned(bs, offset - shift, s->aligned_buf, size);
344: if (ret < 0)
345: return ret;
346:
347: size = 512 - shift;
348: if (size > count)
349: size = count;
350: memcpy(buf, s->aligned_buf + shift, size);
351:
352: buf += size;
353: offset += size;
354: count -= size;
355: sum += size;
356:
357: if (count == 0)
358: return sum;
359: }
360: if (count & 0x1ff || (uintptr_t) buf & 0x1ff) {
361:
362: /* read on aligned buffer */
363:
364: while (count) {
365:
366: size = (count + 0x1ff) & ~0x1ff;
367: if (size > ALIGNED_BUFFER_SIZE)
368: size = ALIGNED_BUFFER_SIZE;
369:
370: ret = raw_pread_aligned(bs, offset, s->aligned_buf, size);
371: if (ret < 0)
372: return ret;
373:
374: size = ret;
375: if (size > count)
376: size = count;
377:
378: memcpy(buf, s->aligned_buf, size);
379:
380: buf += size;
381: offset += size;
382: count -= size;
383: sum += size;
384: }
385:
386: return sum;
387: }
388: }
389:
390: return raw_pread_aligned(bs, offset, buf, count) + sum;
391: }
392:
393: static int raw_read(BlockDriverState *bs, int64_t sector_num,
394: uint8_t *buf, int nb_sectors)
395: {
396: int ret;
397:
398: ret = raw_pread(bs, sector_num * 512, buf, nb_sectors * 512);
399: if (ret == (nb_sectors * 512))
400: ret = 0;
401: return ret;
402: }
403:
404: /*
405: * offset and count are in bytes and possibly not aligned. For files opened
406: * with O_DIRECT, necessary alignments are ensured before calling
407: * raw_pwrite_aligned to do the actual write.
408: */
409: static int raw_pwrite(BlockDriverState *bs, int64_t offset,
410: const uint8_t *buf, int count)
411: {
412: BDRVRawState *s = bs->opaque;
413: int size, ret, shift, sum;
414:
415: sum = 0;
416:
417: if (s->aligned_buf != NULL) {
418:
419: if (offset & 0x1ff) {
420: /* align offset on a 512 bytes boundary */
421: shift = offset & 0x1ff;
422: ret = raw_pread_aligned(bs, offset - shift, s->aligned_buf, 512);
423: if (ret < 0)
424: return ret;
425:
426: size = 512 - shift;
427: if (size > count)
428: size = count;
429: memcpy(s->aligned_buf + shift, buf, size);
430:
431: ret = raw_pwrite_aligned(bs, offset - shift, s->aligned_buf, 512);
432: if (ret < 0)
433: return ret;
434:
435: buf += size;
436: offset += size;
437: count -= size;
438: sum += size;
439:
440: if (count == 0)
441: return sum;
442: }
443: if (count & 0x1ff || (uintptr_t) buf & 0x1ff) {
444:
445: while ((size = (count & ~0x1ff)) != 0) {
446:
447: if (size > ALIGNED_BUFFER_SIZE)
448: size = ALIGNED_BUFFER_SIZE;
449:
450: memcpy(s->aligned_buf, buf, size);
451:
452: ret = raw_pwrite_aligned(bs, offset, s->aligned_buf, size);
453: if (ret < 0)
454: return ret;
455:
456: buf += ret;
457: offset += ret;
458: count -= ret;
459: sum += ret;
460: }
461: /* here, count < 512 because (count & ~0x1ff) == 0 */
462: if (count) {
463: ret = raw_pread_aligned(bs, offset, s->aligned_buf, 512);
464: if (ret < 0)
465: return ret;
466: memcpy(s->aligned_buf, buf, count);
467:
468: ret = raw_pwrite_aligned(bs, offset, s->aligned_buf, 512);
469: if (ret < 0)
470: return ret;
471: if (count < ret)
472: ret = count;
473:
474: sum += ret;
475: }
476: return sum;
477: }
478: }
479: return raw_pwrite_aligned(bs, offset, buf, count) + sum;
480: }
481:
482: static int raw_write(BlockDriverState *bs, int64_t sector_num,
483: const uint8_t *buf, int nb_sectors)
484: {
485: int ret;
486: ret = raw_pwrite(bs, sector_num * 512, buf, nb_sectors * 512);
487: if (ret == (nb_sectors * 512))
488: ret = 0;
489: return ret;
490: }
491:
492: #ifdef CONFIG_AIO
493: /***********************************************************/
494: /* Unix AIO using POSIX AIO */
495:
496: typedef struct RawAIOCB {
497: BlockDriverAIOCB common;
498: struct qemu_paiocb aiocb;
499: struct RawAIOCB *next;
500: int ret;
501: } RawAIOCB;
502:
503: typedef struct PosixAioState
504: {
505: int rfd, wfd;
506: RawAIOCB *first_aio;
507: } PosixAioState;
508:
509: static void posix_aio_read(void *opaque)
510: {
511: PosixAioState *s = opaque;
512: RawAIOCB *acb, **pacb;
513: int ret;
514: ssize_t len;
515:
516: /* read all bytes from signal pipe */
517: for (;;) {
518: char bytes[16];
519:
520: len = read(s->rfd, bytes, sizeof(bytes));
521: if (len == -1 && errno == EINTR)
522: continue; /* try again */
523: if (len == sizeof(bytes))
524: continue; /* more to read */
525: break;
526: }
527:
528: for(;;) {
529: pacb = &s->first_aio;
530: for(;;) {
531: acb = *pacb;
532: if (!acb)
533: goto the_end;
534: ret = qemu_paio_error(&acb->aiocb);
535: if (ret == ECANCELED) {
536: /* remove the request */
537: *pacb = acb->next;
538: qemu_aio_release(acb);
539: } else if (ret != EINPROGRESS) {
540: /* end of aio */
541: if (ret == 0) {
542: ret = qemu_paio_return(&acb->aiocb);
543: if (ret == acb->aiocb.aio_nbytes)
544: ret = 0;
545: else
546: ret = -EINVAL;
547: } else {
548: ret = -ret;
549: }
550: /* remove the request */
551: *pacb = acb->next;
552: /* call the callback */
553: acb->common.cb(acb->common.opaque, ret);
554: qemu_aio_release(acb);
555: break;
556: } else {
557: pacb = &acb->next;
558: }
559: }
560: }
561: the_end: ;
562: }
563:
564: static int posix_aio_flush(void *opaque)
565: {
566: PosixAioState *s = opaque;
567: return !!s->first_aio;
568: }
569:
570: static PosixAioState *posix_aio_state;
571:
572: static void aio_signal_handler(int signum)
573: {
574: if (posix_aio_state) {
575: char byte = 0;
576:
577: write(posix_aio_state->wfd, &byte, sizeof(byte));
578: }
579:
580: qemu_service_io();
581: }
582:
583: static int posix_aio_init(void)
584: {
585: struct sigaction act;
586: PosixAioState *s;
587: int fds[2];
588: struct qemu_paioinit ai;
589:
590: if (posix_aio_state)
591: return 0;
592:
593: s = qemu_malloc(sizeof(PosixAioState));
594:
595: sigfillset(&act.sa_mask);
596: act.sa_flags = 0; /* do not restart syscalls to interrupt select() */
597: act.sa_handler = aio_signal_handler;
598: sigaction(SIGUSR2, &act, NULL);
599:
600: s->first_aio = NULL;
601: if (pipe(fds) == -1) {
602: fprintf(stderr, "failed to create pipe\n");
603: return -errno;
604: }
605:
606: s->rfd = fds[0];
607: s->wfd = fds[1];
608:
609: fcntl(s->rfd, F_SETFL, O_NONBLOCK);
610: fcntl(s->wfd, F_SETFL, O_NONBLOCK);
611:
612: qemu_aio_set_fd_handler(s->rfd, posix_aio_read, NULL, posix_aio_flush, s);
613:
614: memset(&ai, 0, sizeof(ai));
615: ai.aio_threads = 64;
616: ai.aio_num = 64;
617: qemu_paio_init(&ai);
618:
619: posix_aio_state = s;
620:
621: return 0;
622: }
623:
624: static void raw_aio_remove(RawAIOCB *acb)
625: {
626: RawAIOCB **pacb;
627:
628: /* remove the callback from the queue */
629: pacb = &posix_aio_state->first_aio;
630: for(;;) {
631: if (*pacb == NULL) {
632: fprintf(stderr, "raw_aio_remove: aio request not found!\n");
633: break;
634: } else if (*pacb == acb) {
635: *pacb = acb->next;
636: qemu_aio_release(acb);
637: break;
638: }
639: pacb = &(*pacb)->next;
640: }
641: }
642:
643: static void raw_aio_cancel(BlockDriverAIOCB *blockacb)
644: {
645: int ret;
646: RawAIOCB *acb = (RawAIOCB *)blockacb;
647:
648: ret = qemu_paio_cancel(acb->aiocb.aio_fildes, &acb->aiocb);
649: if (ret == QEMU_PAIO_NOTCANCELED) {
650: /* fail safe: if the aio could not be canceled, we wait for
651: it */
652: while (qemu_paio_error(&acb->aiocb) == EINPROGRESS);
653: }
654:
655: raw_aio_remove(acb);
656: }
657:
658: static AIOPool raw_aio_pool = {
659: .aiocb_size = sizeof(RawAIOCB),
660: .cancel = raw_aio_cancel,
661: };
662:
663: static RawAIOCB *raw_aio_setup(BlockDriverState *bs, int64_t sector_num,
664: QEMUIOVector *qiov, int nb_sectors,
665: BlockDriverCompletionFunc *cb, void *opaque)
666: {
667: BDRVRawState *s = bs->opaque;
668: RawAIOCB *acb;
669:
670: if (fd_open(bs) < 0)
671: return NULL;
672:
673: acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);
674: if (!acb)
675: return NULL;
676: acb->aiocb.aio_fildes = s->fd;
677: acb->aiocb.ev_signo = SIGUSR2;
678: acb->aiocb.aio_iov = qiov->iov;
679: acb->aiocb.aio_niov = qiov->niov;
680: acb->aiocb.aio_nbytes = nb_sectors * 512;
681: acb->aiocb.aio_offset = sector_num * 512;
682: acb->aiocb.aio_flags = 0;
683:
684: /*
685: * If O_DIRECT is used the buffer needs to be aligned on a sector
686: * boundary. Tell the low level code to ensure that in case it's
687: * not done yet.
688: */
689: if (s->aligned_buf)
690: acb->aiocb.aio_flags |= QEMU_AIO_SECTOR_ALIGNED;
691:
692: acb->next = posix_aio_state->first_aio;
693: posix_aio_state->first_aio = acb;
694: return acb;
695: }
696:
697: static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs,
698: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
699: BlockDriverCompletionFunc *cb, void *opaque)
700: {
701: RawAIOCB *acb;
702:
703: acb = raw_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque);
704: if (!acb)
705: return NULL;
706: if (qemu_paio_read(&acb->aiocb) < 0) {
707: raw_aio_remove(acb);
708: return NULL;
709: }
710: return &acb->common;
711: }
712:
713: static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs,
714: int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
715: BlockDriverCompletionFunc *cb, void *opaque)
716: {
717: RawAIOCB *acb;
718:
719: acb = raw_aio_setup(bs, sector_num, qiov, nb_sectors, cb, opaque);
720: if (!acb)
721: return NULL;
722: if (qemu_paio_write(&acb->aiocb) < 0) {
723: raw_aio_remove(acb);
724: return NULL;
725: }
726: return &acb->common;
727: }
728: #else /* CONFIG_AIO */
729: static int posix_aio_init(void)
730: {
731: return 0;
732: }
733: #endif /* CONFIG_AIO */
734:
735:
736: static void raw_close(BlockDriverState *bs)
737: {
738: BDRVRawState *s = bs->opaque;
739: if (s->fd >= 0) {
740: close(s->fd);
741: s->fd = -1;
742: if (s->aligned_buf != NULL)
743: qemu_free(s->aligned_buf);
744: }
745: }
746:
747: static int raw_truncate(BlockDriverState *bs, int64_t offset)
748: {
749: BDRVRawState *s = bs->opaque;
750: if (s->type != FTYPE_FILE)
751: return -ENOTSUP;
752: if (ftruncate(s->fd, offset) < 0)
753: return -errno;
754: return 0;
755: }
756:
757: #ifdef __OpenBSD__
758: static int64_t raw_getlength(BlockDriverState *bs)
759: {
760: BDRVRawState *s = bs->opaque;
761: int fd = s->fd;
762: struct stat st;
763:
764: if (fstat(fd, &st))
765: return -1;
766: if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
767: struct disklabel dl;
768:
769: if (ioctl(fd, DIOCGDINFO, &dl))
770: return -1;
771: return (uint64_t)dl.d_secsize *
772: dl.d_partitions[DISKPART(st.st_rdev)].p_size;
773: } else
774: return st.st_size;
775: }
776: #else /* !__OpenBSD__ */
777: static int64_t raw_getlength(BlockDriverState *bs)
778: {
779: BDRVRawState *s = bs->opaque;
780: int fd = s->fd;
781: int64_t size;
782: #ifdef HOST_BSD
783: struct stat sb;
784: #ifdef __FreeBSD__
785: int reopened = 0;
786: #endif
787: #endif
788: #ifdef __sun__
789: struct dk_minfo minfo;
790: int rv;
791: #endif
792: int ret;
793:
794: ret = fd_open(bs);
795: if (ret < 0)
796: return ret;
797:
798: #ifdef HOST_BSD
799: #ifdef __FreeBSD__
800: again:
801: #endif
802: if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
803: #ifdef DIOCGMEDIASIZE
804: if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
805: #elif defined(DIOCGPART)
806: {
807: struct partinfo pi;
808: if (ioctl(fd, DIOCGPART, &pi) == 0)
809: size = pi.media_size;
810: else
811: size = 0;
812: }
813: if (size == 0)
814: #endif
815: #ifdef CONFIG_COCOA
816: size = LONG_LONG_MAX;
817: #else
818: size = lseek(fd, 0LL, SEEK_END);
819: #endif
820: #ifdef __FreeBSD__
821: switch(s->type) {
822: case FTYPE_CD:
823: /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
824: if (size == 2048LL * (unsigned)-1)
825: size = 0;
826: /* XXX no disc? maybe we need to reopen... */
827: if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
828: reopened = 1;
829: goto again;
830: }
831: }
832: #endif
833: } else
834: #endif
835: #ifdef __sun__
836: /*
837: * use the DKIOCGMEDIAINFO ioctl to read the size.
838: */
839: rv = ioctl ( fd, DKIOCGMEDIAINFO, &minfo );
840: if ( rv != -1 ) {
841: size = minfo.dki_lbsize * minfo.dki_capacity;
842: } else /* there are reports that lseek on some devices
843: fails, but irc discussion said that contingency
844: on contingency was overkill */
845: #endif
846: {
847: size = lseek(fd, 0, SEEK_END);
848: }
849: return size;
850: }
851: #endif
852:
853: static int raw_create(const char *filename, QEMUOptionParameter *options)
854: {
855: int fd;
856: int result = 0;
857: int64_t total_size = 0;
858:
859: /* Read out options */
860: while (options && options->name) {
861: if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
862: total_size = options->value.n / 512;
863: }
864: options++;
865: }
866:
867: fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
868: 0644);
869: if (fd < 0) {
870: result = -errno;
871: } else {
872: if (ftruncate(fd, total_size * 512) != 0) {
873: result = -errno;
874: }
875: if (close(fd) != 0) {
876: result = -errno;
877: }
878: }
879: return result;
880: }
881:
882: static void raw_flush(BlockDriverState *bs)
883: {
884: BDRVRawState *s = bs->opaque;
885: fsync(s->fd);
886: }
887:
888:
889: static QEMUOptionParameter raw_create_options[] = {
890: {
891: .name = BLOCK_OPT_SIZE,
892: .type = OPT_SIZE,
893: .help = "Virtual disk size"
894: },
895: { NULL }
896: };
897:
898: static BlockDriver bdrv_raw = {
899: .format_name = "raw",
900: .instance_size = sizeof(BDRVRawState),
901: .bdrv_probe = NULL, /* no probe for protocols */
902: .bdrv_open = raw_open,
903: .bdrv_read = raw_read,
904: .bdrv_write = raw_write,
905: .bdrv_close = raw_close,
906: .bdrv_create = raw_create,
907: .bdrv_flush = raw_flush,
908:
909: #ifdef CONFIG_AIO
910: .bdrv_aio_readv = raw_aio_readv,
911: .bdrv_aio_writev = raw_aio_writev,
912: #endif
913:
914: .bdrv_truncate = raw_truncate,
915: .bdrv_getlength = raw_getlength,
916:
917: .create_options = raw_create_options,
918: };
919:
920: /***********************************************/
921: /* host device */
922:
923: #ifdef CONFIG_COCOA
924: static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator );
925: static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize );
926:
927: kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
928: {
929: kern_return_t kernResult;
930: mach_port_t masterPort;
931: CFMutableDictionaryRef classesToMatch;
932:
933: kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
934: if ( KERN_SUCCESS != kernResult ) {
935: printf( "IOMasterPort returned %d\n", kernResult );
936: }
937:
938: classesToMatch = IOServiceMatching( kIOCDMediaClass );
939: if ( classesToMatch == NULL ) {
940: printf( "IOServiceMatching returned a NULL dictionary.\n" );
941: } else {
942: CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue );
943: }
944: kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator );
945: if ( KERN_SUCCESS != kernResult )
946: {
947: printf( "IOServiceGetMatchingServices returned %d\n", kernResult );
948: }
949:
950: return kernResult;
951: }
952:
953: kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize )
954: {
955: io_object_t nextMedia;
956: kern_return_t kernResult = KERN_FAILURE;
957: *bsdPath = '\0';
958: nextMedia = IOIteratorNext( mediaIterator );
959: if ( nextMedia )
960: {
961: CFTypeRef bsdPathAsCFString;
962: bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
963: if ( bsdPathAsCFString ) {
964: size_t devPathLength;
965: strcpy( bsdPath, _PATH_DEV );
966: strcat( bsdPath, "r" );
967: devPathLength = strlen( bsdPath );
968: if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
969: kernResult = KERN_SUCCESS;
970: }
971: CFRelease( bsdPathAsCFString );
972: }
973: IOObjectRelease( nextMedia );
974: }
975:
976: return kernResult;
977: }
978:
979: #endif
980:
981: static int hdev_probe_device(const char *filename)
982: {
983: struct stat st;
984:
985: /* allow a dedicated CD-ROM driver to match with a higher priority */
986: if (strstart(filename, "/dev/cdrom", NULL))
987: return 50;
988:
989: if (stat(filename, &st) >= 0 &&
990: (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
991: return 100;
992: }
993:
994: return 0;
995: }
996:
997: static int hdev_open(BlockDriverState *bs, const char *filename, int flags)
998: {
999: BDRVRawState *s = bs->opaque;
1000:
1001: #ifdef CONFIG_COCOA
1002: if (strstart(filename, "/dev/cdrom", NULL)) {
1003: kern_return_t kernResult;
1004: io_iterator_t mediaIterator;
1005: char bsdPath[ MAXPATHLEN ];
1006: int fd;
1007:
1008: kernResult = FindEjectableCDMedia( &mediaIterator );
1009: kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );
1010:
1011: if ( bsdPath[ 0 ] != '\0' ) {
1012: strcat(bsdPath,"s0");
1013: /* some CDs don't have a partition 0 */
1014: fd = open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
1015: if (fd < 0) {
1016: bsdPath[strlen(bsdPath)-1] = '1';
1017: } else {
1018: close(fd);
1019: }
1020: filename = bsdPath;
1021: }
1022:
1023: if ( mediaIterator )
1024: IOObjectRelease( mediaIterator );
1025: }
1026: #endif
1027:
1028: s->type = FTYPE_FILE;
1029: #if defined(__linux__) && defined(CONFIG_AIO)
1030: if (strstart(filename, "/dev/sg", NULL)) {
1031: bs->sg = 1;
1032: }
1033: #endif
1034:
1035: return raw_open_common(bs, filename, flags, 0);
1036: }
1037:
1038: #if defined(__linux__)
1039: /* Note: we do not have a reliable method to detect if the floppy is
1040: present. The current method is to try to open the floppy at every
1041: I/O and to keep it opened during a few hundreds of ms. */
1042: static int fd_open(BlockDriverState *bs)
1043: {
1044: BDRVRawState *s = bs->opaque;
1045: int last_media_present;
1046:
1047: if (s->type != FTYPE_FD)
1048: return 0;
1049: last_media_present = (s->fd >= 0);
1050: if (s->fd >= 0 &&
1051: (qemu_get_clock(rt_clock) - s->fd_open_time) >= FD_OPEN_TIMEOUT) {
1052: close(s->fd);
1053: s->fd = -1;
1054: #ifdef DEBUG_FLOPPY
1055: printf("Floppy closed\n");
1056: #endif
1057: }
1058: if (s->fd < 0) {
1059: if (s->fd_got_error &&
1060: (qemu_get_clock(rt_clock) - s->fd_error_time) < FD_OPEN_TIMEOUT) {
1061: #ifdef DEBUG_FLOPPY
1062: printf("No floppy (open delayed)\n");
1063: #endif
1064: return -EIO;
1065: }
1066: s->fd = open(bs->filename, s->open_flags & ~O_NONBLOCK);
1067: if (s->fd < 0) {
1068: s->fd_error_time = qemu_get_clock(rt_clock);
1069: s->fd_got_error = 1;
1070: if (last_media_present)
1071: s->fd_media_changed = 1;
1072: #ifdef DEBUG_FLOPPY
1073: printf("No floppy\n");
1074: #endif
1075: return -EIO;
1076: }
1077: #ifdef DEBUG_FLOPPY
1078: printf("Floppy opened\n");
1079: #endif
1080: }
1081: if (!last_media_present)
1082: s->fd_media_changed = 1;
1083: s->fd_open_time = qemu_get_clock(rt_clock);
1084: s->fd_got_error = 0;
1085: return 0;
1086: }
1087:
1088: static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1089: {
1090: BDRVRawState *s = bs->opaque;
1091:
1092: return ioctl(s->fd, req, buf);
1093: }
1094:
1095: #ifdef CONFIG_AIO
1096: static BlockDriverAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
1097: unsigned long int req, void *buf,
1098: BlockDriverCompletionFunc *cb, void *opaque)
1099: {
1100: BDRVRawState *s = bs->opaque;
1101: RawAIOCB *acb;
1102:
1103: if (fd_open(bs) < 0)
1104: return NULL;
1105:
1106: acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);
1107: if (!acb)
1108: return NULL;
1109: acb->aiocb.aio_fildes = s->fd;
1110: acb->aiocb.ev_signo = SIGUSR2;
1111: acb->aiocb.aio_offset = 0;
1112: acb->aiocb.aio_flags = 0;
1113:
1114: acb->next = posix_aio_state->first_aio;
1115: posix_aio_state->first_aio = acb;
1116:
1117: acb->aiocb.aio_ioctl_buf = buf;
1118: acb->aiocb.aio_ioctl_cmd = req;
1119: if (qemu_paio_ioctl(&acb->aiocb) < 0) {
1120: raw_aio_remove(acb);
1121: return NULL;
1122: }
1123:
1124: return &acb->common;
1125: }
1126: #endif
1127:
1128: #elif defined(__FreeBSD__)
1129: static int fd_open(BlockDriverState *bs)
1130: {
1131: BDRVRawState *s = bs->opaque;
1132:
1133: /* this is just to ensure s->fd is sane (its called by io ops) */
1134: if (s->fd >= 0)
1135: return 0;
1136: return -EIO;
1137: }
1138: #else /* !linux && !FreeBSD */
1139:
1140: static int fd_open(BlockDriverState *bs)
1141: {
1142: return 0;
1143: }
1144:
1145: #endif /* !linux && !FreeBSD */
1146:
1147: static int hdev_create(const char *filename, QEMUOptionParameter *options)
1148: {
1149: int fd;
1150: int ret = 0;
1151: struct stat stat_buf;
1152: int64_t total_size = 0;
1153:
1154: /* Read out options */
1155: while (options && options->name) {
1156: if (!strcmp(options->name, "size")) {
1157: total_size = options->value.n / 512;
1158: }
1159: options++;
1160: }
1161:
1162: fd = open(filename, O_WRONLY | O_BINARY);
1163: if (fd < 0)
1164: return -EIO;
1165:
1166: if (fstat(fd, &stat_buf) < 0)
1167: ret = -EIO;
1168: else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode))
1169: ret = -EIO;
1170: else if (lseek(fd, 0, SEEK_END) < total_size * 512)
1171: ret = -ENOSPC;
1172:
1173: close(fd);
1174: return ret;
1175: }
1176:
1177: static BlockDriver bdrv_host_device = {
1178: .format_name = "host_device",
1179: .instance_size = sizeof(BDRVRawState),
1180: .bdrv_probe_device = hdev_probe_device,
1181: .bdrv_open = hdev_open,
1182: .bdrv_close = raw_close,
1183: .bdrv_create = hdev_create,
1184: .bdrv_flush = raw_flush,
1185:
1186: #ifdef CONFIG_AIO
1187: .bdrv_aio_readv = raw_aio_readv,
1188: .bdrv_aio_writev = raw_aio_writev,
1189: #endif
1190:
1191: .bdrv_read = raw_read,
1192: .bdrv_write = raw_write,
1193: .bdrv_getlength = raw_getlength,
1194:
1195: /* generic scsi device */
1196: #ifdef __linux__
1197: .bdrv_ioctl = hdev_ioctl,
1198: #ifdef CONFIG_AIO
1199: .bdrv_aio_ioctl = hdev_aio_ioctl,
1200: #endif
1201: #endif
1202: };
1203:
1204: #ifdef __linux__
1205: static int floppy_open(BlockDriverState *bs, const char *filename, int flags)
1206: {
1207: BDRVRawState *s = bs->opaque;
1208: int ret;
1209:
1210: posix_aio_init();
1211:
1212: s->type = FTYPE_FD;
1213:
1214: /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */
1215: ret = raw_open_common(bs, filename, flags, O_NONBLOCK);
1216: if (ret)
1217: return ret;
1218:
1219: /* close fd so that we can reopen it as needed */
1220: close(s->fd);
1221: s->fd = -1;
1222: s->fd_media_changed = 1;
1223:
1224: return 0;
1225: }
1226:
1227: static int floppy_probe_device(const char *filename)
1228: {
1229: if (strstart(filename, "/dev/fd", NULL))
1230: return 100;
1231: return 0;
1232: }
1233:
1234:
1235: static int floppy_is_inserted(BlockDriverState *bs)
1236: {
1237: return fd_open(bs) >= 0;
1238: }
1239:
1240: static int floppy_media_changed(BlockDriverState *bs)
1241: {
1242: BDRVRawState *s = bs->opaque;
1243: int ret;
1244:
1245: /*
1246: * XXX: we do not have a true media changed indication.
1247: * It does not work if the floppy is changed without trying to read it.
1248: */
1249: fd_open(bs);
1250: ret = s->fd_media_changed;
1251: s->fd_media_changed = 0;
1252: #ifdef DEBUG_FLOPPY
1253: printf("Floppy changed=%d\n", ret);
1254: #endif
1255: return ret;
1256: }
1257:
1258: static int floppy_eject(BlockDriverState *bs, int eject_flag)
1259: {
1260: BDRVRawState *s = bs->opaque;
1261: int fd;
1262:
1263: if (s->fd >= 0) {
1264: close(s->fd);
1265: s->fd = -1;
1266: }
1267: fd = open(bs->filename, s->open_flags | O_NONBLOCK);
1268: if (fd >= 0) {
1269: if (ioctl(fd, FDEJECT, 0) < 0)
1270: perror("FDEJECT");
1271: close(fd);
1272: }
1273:
1274: return 0;
1275: }
1276:
1277: static BlockDriver bdrv_host_floppy = {
1278: .format_name = "host_floppy",
1279: .instance_size = sizeof(BDRVRawState),
1280: .bdrv_probe_device = floppy_probe_device,
1281: .bdrv_open = floppy_open,
1282: .bdrv_close = raw_close,
1283: .bdrv_create = hdev_create,
1284: .bdrv_flush = raw_flush,
1285:
1286: #ifdef CONFIG_AIO
1287: .bdrv_aio_readv = raw_aio_readv,
1288: .bdrv_aio_writev = raw_aio_writev,
1289: #endif
1290:
1291: .bdrv_read = raw_read,
1292: .bdrv_write = raw_write,
1293: .bdrv_getlength = raw_getlength,
1294:
1295: /* removable device support */
1296: .bdrv_is_inserted = floppy_is_inserted,
1297: .bdrv_media_changed = floppy_media_changed,
1298: .bdrv_eject = floppy_eject,
1299: };
1300:
1301: static int cdrom_open(BlockDriverState *bs, const char *filename, int flags)
1302: {
1303: BDRVRawState *s = bs->opaque;
1304:
1305: s->type = FTYPE_CD;
1306:
1307: /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
1308: return raw_open_common(bs, filename, flags, O_NONBLOCK);
1309: }
1310:
1311: static int cdrom_probe_device(const char *filename)
1312: {
1313: if (strstart(filename, "/dev/cd", NULL))
1314: return 100;
1315: return 0;
1316: }
1317:
1318: static int cdrom_is_inserted(BlockDriverState *bs)
1319: {
1320: BDRVRawState *s = bs->opaque;
1321: int ret;
1322:
1323: ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
1324: if (ret == CDS_DISC_OK)
1325: return 1;
1326: return 0;
1327: }
1328:
1329: static int cdrom_eject(BlockDriverState *bs, int eject_flag)
1330: {
1331: BDRVRawState *s = bs->opaque;
1332:
1333: if (eject_flag) {
1334: if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
1335: perror("CDROMEJECT");
1336: } else {
1337: if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
1338: perror("CDROMEJECT");
1339: }
1340:
1341: return 0;
1342: }
1343:
1344: static int cdrom_set_locked(BlockDriverState *bs, int locked)
1345: {
1346: BDRVRawState *s = bs->opaque;
1347:
1348: if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
1349: /*
1350: * Note: an error can happen if the distribution automatically
1351: * mounts the CD-ROM
1352: */
1353: /* perror("CDROM_LOCKDOOR"); */
1354: }
1355:
1356: return 0;
1357: }
1358:
1359: static BlockDriver bdrv_host_cdrom = {
1360: .format_name = "host_cdrom",
1361: .instance_size = sizeof(BDRVRawState),
1362: .bdrv_probe_device = cdrom_probe_device,
1363: .bdrv_open = cdrom_open,
1364: .bdrv_close = raw_close,
1365: .bdrv_create = hdev_create,
1366: .bdrv_flush = raw_flush,
1367:
1368: #ifdef CONFIG_AIO
1369: .bdrv_aio_readv = raw_aio_readv,
1370: .bdrv_aio_writev = raw_aio_writev,
1371: #endif
1372:
1373: .bdrv_read = raw_read,
1374: .bdrv_write = raw_write,
1375: .bdrv_getlength = raw_getlength,
1376:
1377: /* removable device support */
1378: .bdrv_is_inserted = cdrom_is_inserted,
1379: .bdrv_eject = cdrom_eject,
1380: .bdrv_set_locked = cdrom_set_locked,
1381:
1382: /* generic scsi device */
1383: .bdrv_ioctl = hdev_ioctl,
1384: #ifdef CONFIG_AIO
1385: .bdrv_aio_ioctl = hdev_aio_ioctl,
1386: #endif
1387: };
1388: #endif /* __linux__ */
1389:
1390: #ifdef __FreeBSD__
1391: static int cdrom_open(BlockDriverState *bs, const char *filename, int flags)
1392: {
1393: BDRVRawState *s = bs->opaque;
1394: int ret;
1395:
1396: s->type = FTYPE_CD;
1397:
1398: ret = raw_open_common(bs, filename, flags, 0);
1399: if (ret)
1400: return ret;
1401:
1402: /* make sure the door isnt locked at this time */
1403: ioctl(s->fd, CDIOCALLOW);
1404: return 0;
1405: }
1406:
1407: static int cdrom_probe_device(const char *filename)
1408: {
1409: if (strstart(filename, "/dev/cd", NULL) ||
1410: strstart(filename, "/dev/acd", NULL))
1411: return 100;
1412: return 0;
1413: }
1414:
1415: static int cdrom_reopen(BlockDriverState *bs)
1416: {
1417: BDRVRawState *s = bs->opaque;
1418: int fd;
1419:
1420: /*
1421: * Force reread of possibly changed/newly loaded disc,
1422: * FreeBSD seems to not notice sometimes...
1423: */
1424: if (s->fd >= 0)
1425: close(s->fd);
1426: fd = open(bs->filename, s->open_flags, 0644);
1427: if (fd < 0) {
1428: s->fd = -1;
1429: return -EIO;
1430: }
1431: s->fd = fd;
1432:
1433: /* make sure the door isnt locked at this time */
1434: ioctl(s->fd, CDIOCALLOW);
1435: return 0;
1436: }
1437:
1438: static int cdrom_is_inserted(BlockDriverState *bs)
1439: {
1440: return raw_getlength(bs) > 0;
1441: }
1442:
1443: static int cdrom_eject(BlockDriverState *bs, int eject_flag)
1444: {
1445: BDRVRawState *s = bs->opaque;
1446:
1447: if (s->fd < 0)
1448: return -ENOTSUP;
1449:
1450: (void) ioctl(s->fd, CDIOCALLOW);
1451:
1452: if (eject_flag) {
1453: if (ioctl(s->fd, CDIOCEJECT) < 0)
1454: perror("CDIOCEJECT");
1455: } else {
1456: if (ioctl(s->fd, CDIOCCLOSE) < 0)
1457: perror("CDIOCCLOSE");
1458: }
1459:
1460: if (cdrom_reopen(bs) < 0)
1461: return -ENOTSUP;
1462: return 0;
1463: }
1464:
1465: static int cdrom_set_locked(BlockDriverState *bs, int locked)
1466: {
1467: BDRVRawState *s = bs->opaque;
1468:
1469: if (s->fd < 0)
1470: return -ENOTSUP;
1471: if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
1472: /*
1473: * Note: an error can happen if the distribution automatically
1474: * mounts the CD-ROM
1475: */
1476: /* perror("CDROM_LOCKDOOR"); */
1477: }
1478:
1479: return 0;
1480: }
1481:
1482: static BlockDriver bdrv_host_cdrom = {
1483: .format_name = "host_cdrom",
1484: .instance_size = sizeof(BDRVRawState),
1485: .bdrv_probe_device = cdrom_probe_device,
1486: .bdrv_open = cdrom_open,
1487: .bdrv_close = raw_close,
1488: .bdrv_create = hdev_create,
1489: .bdrv_flush = raw_flush,
1490:
1491: #ifdef CONFIG_AIO
1492: .bdrv_aio_readv = raw_aio_readv,
1493: .bdrv_aio_writev = raw_aio_writev,
1494: #endif
1495:
1496: .bdrv_read = raw_read,
1497: .bdrv_write = raw_write,
1498: .bdrv_getlength = raw_getlength,
1499:
1500: /* removable device support */
1501: .bdrv_is_inserted = cdrom_is_inserted,
1502: .bdrv_eject = cdrom_eject,
1503: .bdrv_set_locked = cdrom_set_locked,
1504: };
1505: #endif /* __FreeBSD__ */
1506:
1507: static void bdrv_raw_init(void)
1508: {
1509: /*
1510: * Register all the drivers. Note that order is important, the driver
1511: * registered last will get probed first.
1512: */
1513: bdrv_register(&bdrv_raw);
1514: bdrv_register(&bdrv_host_device);
1515: #ifdef __linux__
1516: bdrv_register(&bdrv_host_floppy);
1517: bdrv_register(&bdrv_host_cdrom);
1518: #endif
1519: #ifdef __FreeBSD__
1520: bdrv_register(&bdrv_host_cdrom);
1521: #endif
1522: }
1523:
1524: block_init(bdrv_raw_init);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.