block/raw-posix.c

   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 #include "block/raw-posix-aio.h"
  31
  32 #ifdef CONFIG_COCOA
  33 #include <paths.h>
  34 #include <sys/param.h>
  35 #include <IOKit/IOKitLib.h>
  36 #include <IOKit/IOBSD.h>
  37 #include <IOKit/storage/IOMediaBSDClient.h>
  38 #include <IOKit/storage/IOMedia.h>
  39 #include <IOKit/storage/IOCDMedia.h>
  40 //#include <IOKit/storage/IOCDTypes.h>
  41 #include <CoreFoundation/CoreFoundation.h>
  42 #endif
  43
  44 #ifdef __sun__
  45 #define _POSIX_PTHREAD_SEMANTICS 1
  46 #include <sys/dkio.h>
  47 #endif
  48 #ifdef __linux__
  49 #include <sys/types.h>
  50 #include <sys/stat.h>
  51 #include <sys/ioctl.h>
  52 #include <sys/param.h>
  53 #include <linux/cdrom.h>
  54 #include <linux/fd.h>
  55 #endif
  56 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
  57 #include <sys/disk.h>
  58 #include <sys/cdio.h>
  59 #endif
  60
  61 #ifdef __OpenBSD__
  62 #include <sys/ioctl.h>
  63 #include <sys/disklabel.h>
  64 #include <sys/dkio.h>
  65 #endif
  66
  67 #ifdef __NetBSD__
  68 #include <sys/ioctl.h>
  69 #include <sys/disklabel.h>
  70 #include <sys/dkio.h>
  71 #include <sys/disk.h>
  72 #endif
  73
  74 #ifdef __DragonFly__
  75 #include <sys/ioctl.h>
  76 #include <sys/diskslice.h>
  77 #endif
  78
  79 #ifdef CONFIG_XFS
  80 #include <xfs/xfs.h>
  81 #endif
  82
  83 //#define DEBUG_FLOPPY
  84
  85 //#define DEBUG_BLOCK
  86 #if defined(DEBUG_BLOCK)
  87 #define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \
  88     { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0)
  89 #else
  90 #define DEBUG_BLOCK_PRINT(formatCstr, ...)
  91 #endif
  92
  93 /* OS X does not have O_DSYNC */
  94 #ifndef O_DSYNC
  95 #ifdef O_SYNC
  96 #define O_DSYNC O_SYNC
  97 #elif defined(O_FSYNC)
  98 #define O_DSYNC O_FSYNC
  99 #endif
 100 #endif
 101
 102 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
 103 #ifndef O_DIRECT
 104 #define O_DIRECT O_DSYNC
 105 #endif
 106
 107 #define FTYPE_FILE   0
 108 #define FTYPE_CD     1
 109 #define FTYPE_FD     2
 110
 111 /* if the FD is not accessed during that time (in ns), we try to
 112    reopen it to see if the disk has been changed */
 113 #define FD_OPEN_TIMEOUT (1000000000)
 114
 115 #define MAX_BLOCKSIZE   4096
 116
 117 typedef struct BDRVRawState {
 118     int fd;
 119     int type;
 120     int open_flags;
 121 #if defined(__linux__)
 122     /* linux floppy specific */
 123     int64_t fd_open_time;
 124     int64_t fd_error_time;
 125     int fd_got_error;
 126     int fd_media_changed;
 127 #endif
 128 #ifdef CONFIG_LINUX_AIO
 129     int use_aio;
 130     void *aio_ctx;
 131 #endif
 132     uint8_t *aligned_buf;
 133     unsigned aligned_buf_size;
 134 #ifdef CONFIG_XFS
 135     bool is_xfs : 1;
 136 #endif
 137 } BDRVRawState;
 138
 139 static int fd_open(BlockDriverState *bs);
 140 static int64_t raw_getlength(BlockDriverState *bs);
 141
 142 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 143 static int cdrom_reopen(BlockDriverState *bs);
 144 #endif
 145
 146 #if defined(__NetBSD__)
 147 static int raw_normalize_devicepath(const char **filename)
 148 {
 149     static char namebuf[PATH_MAX];
 150     const char *dp, *fname;
 151     struct stat sb;
 152
 153     fname = *filename;
 154     dp = strrchr(fname, '/');
 155     if (lstat(fname, &sb) < 0) {
 156         fprintf(stderr, "%s: stat failed: %s\n",
 157             fname, strerror(errno));
 158         return -errno;
 159     }
 160
 161     if (!S_ISBLK(sb.st_mode)) {
 162         return 0;
 163     }
 164
 165     if (dp == NULL) {
 166         snprintf(namebuf, PATH_MAX, "r%s", fname);
 167     } else {
 168         snprintf(namebuf, PATH_MAX, "%.*s/r%s",
 169             (int)(dp - fname), fname, dp + 1);
 170     }
 171     fprintf(stderr, "%s is a block device", fname);
 172     *filename = namebuf;
 173     fprintf(stderr, ", using %s\n", *filename);
 174
 175     return 0;
 176 }
 177 #else
 178 static int raw_normalize_devicepath(const char **filename)
 179 {
 180     return 0;
 181 }
 182 #endif
 183
 184 static int raw_open_common(BlockDriverState *bs, const char *filename,
 185                            int bdrv_flags, int open_flags)
 186 {
 187     BDRVRawState *s = bs->opaque;
 188     int fd, ret;
 189
 190     ret = raw_normalize_devicepath(&filename);
 191     if (ret != 0) {
 192         return ret;
 193     }
 194
 195     s->open_flags = open_flags | O_BINARY;
 196     s->open_flags &= ~O_ACCMODE;
 197     if (bdrv_flags & BDRV_O_RDWR) {
 198         s->open_flags |= O_RDWR;
 199     } else {
 200         s->open_flags |= O_RDONLY;
 201     }
 202
 203     /* Use O_DSYNC for write-through caching, no flags for write-back caching,
 204      * and O_DIRECT for no caching. */
 205     if ((bdrv_flags & BDRV_O_NOCACHE))
 206         s->open_flags |= O_DIRECT;
 207     if (!(bdrv_flags & BDRV_O_CACHE_WB))
 208         s->open_flags |= O_DSYNC;
 209
 210     s->fd = -1;
 211     fd = qemu_open(filename, s->open_flags, 0644);
 212     if (fd < 0) {
 213         ret = -errno;
 214         if (ret == -EROFS)
 215             ret = -EACCES;
 216         return ret;
 217     }
 218     s->fd = fd;
 219     s->aligned_buf = NULL;
 220
 221     if ((bdrv_flags & BDRV_O_NOCACHE)) {
 222         /*
 223          * Allocate a buffer for read/modify/write cycles.  Chose the size
 224          * pessimistically as we don't know the block size yet.
 225          */
 226         s->aligned_buf_size = 32 * MAX_BLOCKSIZE;
 227         s->aligned_buf = qemu_memalign(MAX_BLOCKSIZE, s->aligned_buf_size);
 228         if (s->aligned_buf == NULL) {
 229             goto out_close;
 230         }
 231     }
 232
 233     /* We're falling back to POSIX AIO in some cases so init always */
 234     if (paio_init() < 0) {
 235         goto out_free_buf;
 236     }
 237
 238 #ifdef CONFIG_LINUX_AIO
 239     /*
 240      * Currently Linux do AIO only for files opened with O_DIRECT
 241      * specified so check NOCACHE flag too
 242      */
 243     if ((bdrv_flags & (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) ==
 244                       (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) {
 245
 246         s->aio_ctx = laio_init();
 247         if (!s->aio_ctx) {
 248             goto out_free_buf;
 249         }
 250         s->use_aio = 1;
 251     } else
 252 #endif
 253     {
 254 #ifdef CONFIG_LINUX_AIO
 255         s->use_aio = 0;
 256 #endif
 257     }
 258
 259 #ifdef CONFIG_XFS
 260     if (platform_test_xfs_fd(s->fd)) {
 261         s->is_xfs = 1;
 262     }
 263 #endif
 264
 265     return 0;
 266
 267 out_free_buf:
 268     qemu_vfree(s->aligned_buf);
 269 out_close:
 270     close(fd);
 271     return -errno;
 272 }
 273
 274 static int raw_open(BlockDriverState *bs, const char *filename, int flags)
 275 {
 276     BDRVRawState *s = bs->opaque;
 277
 278     s->type = FTYPE_FILE;
 279     return raw_open_common(bs, filename, flags, 0);
 280 }
 281
 282 /* XXX: use host sector size if necessary with:
 283 #ifdef DIOCGSECTORSIZE
 284         {
 285             unsigned int sectorsize = 512;
 286             if (!ioctl(fd, DIOCGSECTORSIZE, &sectorsize) &&
 287                 sectorsize > bufsize)
 288                 bufsize = sectorsize;
 289         }
 290 #endif
 291 #ifdef CONFIG_COCOA
 292         uint32_t blockSize = 512;
 293         if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) {
 294             bufsize = blockSize;
 295         }
 296 #endif
 297 */
 298
 299 /*
 300  * Check if all memory in this vector is sector aligned.
 301  */
 302 static int qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
 303 {
 304     int i;
 305
 306     for (i = 0; i < qiov->niov; i++) {
 307         if ((uintptr_t) qiov->iov[i].iov_base % bs->buffer_alignment) {
 308             return 0;
 309         }
 310     }
 311
 312     return 1;
 313 }
 314
 315 static BlockDriverAIOCB *raw_aio_submit(BlockDriverState *bs,
 316         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 317         BlockDriverCompletionFunc *cb, void *opaque, int type)
 318 {
 319     BDRVRawState *s = bs->opaque;
 320
 321     if (fd_open(bs) < 0)
 322         return NULL;
 323
 324     /*
 325      * If O_DIRECT is used the buffer needs to be aligned on a sector
 326      * boundary.  Check if this is the case or tell the low-level
 327      * driver that it needs to copy the buffer.
 328      */
 329     if (s->aligned_buf) {
 330         if (!qiov_is_aligned(bs, qiov)) {
 331             type |= QEMU_AIO_MISALIGNED;
 332 #ifdef CONFIG_LINUX_AIO
 333         } else if (s->use_aio) {
 334             return laio_submit(bs, s->aio_ctx, s->fd, sector_num, qiov,
 335                                nb_sectors, cb, opaque, type);
 336 #endif
 337         }
 338     }
 339
 340     return paio_submit(bs, s->fd, sector_num, qiov, nb_sectors,
 341                        cb, opaque, type);
 342 }
 343
 344 static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs,
 345         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 346         BlockDriverCompletionFunc *cb, void *opaque)
 347 {
 348     return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
 349                           cb, opaque, QEMU_AIO_READ);
 350 }
 351
 352 static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs,
 353         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 354         BlockDriverCompletionFunc *cb, void *opaque)
 355 {
 356     return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
 357                           cb, opaque, QEMU_AIO_WRITE);
 358 }
 359
 360 static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs,
 361         BlockDriverCompletionFunc *cb, void *opaque)
 362 {
 363     BDRVRawState *s = bs->opaque;
 364
 365     if (fd_open(bs) < 0)
 366         return NULL;
 367
 368     return paio_submit(bs, s->fd, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
 369 }
 370
 371 static void raw_close(BlockDriverState *bs)
 372 {
 373     BDRVRawState *s = bs->opaque;
 374     if (s->fd >= 0) {
 375         close(s->fd);
 376         s->fd = -1;
 377         if (s->aligned_buf != NULL)
 378             qemu_vfree(s->aligned_buf);
 379     }
 380 }
 381
 382 static int raw_truncate(BlockDriverState *bs, int64_t offset)
 383 {
 384     BDRVRawState *s = bs->opaque;
 385     struct stat st;
 386
 387     if (fstat(s->fd, &st)) {
 388         return -errno;
 389     }
 390
 391     if (S_ISREG(st.st_mode)) {
 392         if (ftruncate(s->fd, offset) < 0) {
 393             return -errno;
 394         }
 395     } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
 396        if (offset > raw_getlength(bs)) {
 397            return -EINVAL;
 398        }
 399     } else {
 400         return -ENOTSUP;
 401     }
 402
 403     return 0;
 404 }
 405
 406 #ifdef __OpenBSD__
 407 static int64_t raw_getlength(BlockDriverState *bs)
 408 {
 409     BDRVRawState *s = bs->opaque;
 410     int fd = s->fd;
 411     struct stat st;
 412
 413     if (fstat(fd, &st))
 414         return -1;
 415     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
 416         struct disklabel dl;
 417
 418         if (ioctl(fd, DIOCGDINFO, &dl))
 419             return -1;
 420         return (uint64_t)dl.d_secsize *
 421             dl.d_partitions[DISKPART(st.st_rdev)].p_size;
 422     } else
 423         return st.st_size;
 424 }
 425 #elif defined(__NetBSD__)
 426 static int64_t raw_getlength(BlockDriverState *bs)
 427 {
 428     BDRVRawState *s = bs->opaque;
 429     int fd = s->fd;
 430     struct stat st;
 431
 432     if (fstat(fd, &st))
 433         return -1;
 434     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
 435         struct dkwedge_info dkw;
 436
 437         if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
 438             return dkw.dkw_size * 512;
 439         } else {
 440             struct disklabel dl;
 441
 442             if (ioctl(fd, DIOCGDINFO, &dl))
 443                 return -1;
 444             return (uint64_t)dl.d_secsize *
 445                 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
 446         }
 447     } else
 448         return st.st_size;
 449 }
 450 #elif defined(__sun__)
 451 static int64_t raw_getlength(BlockDriverState *bs)
 452 {
 453     BDRVRawState *s = bs->opaque;
 454     struct dk_minfo minfo;
 455     int ret;
 456
 457     ret = fd_open(bs);
 458     if (ret < 0) {
 459         return ret;
 460     }
 461
 462     /*
 463      * Use the DKIOCGMEDIAINFO ioctl to read the size.
 464      */
 465     ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
 466     if (ret != -1) {
 467         return minfo.dki_lbsize * minfo.dki_capacity;
 468     }
 469
 470     /*
 471      * There are reports that lseek on some devices fails, but
 472      * irc discussion said that contingency on contingency was overkill.
 473      */
 474     return lseek(s->fd, 0, SEEK_END);
 475 }
 476 #elif defined(CONFIG_BSD)
 477 static int64_t raw_getlength(BlockDriverState *bs)
 478 {
 479     BDRVRawState *s = bs->opaque;
 480     int fd = s->fd;
 481     int64_t size;
 482     struct stat sb;
 483 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
 484     int reopened = 0;
 485 #endif
 486     int ret;
 487
 488     ret = fd_open(bs);
 489     if (ret < 0)
 490         return ret;
 491
 492 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
 493 again:
 494 #endif
 495     if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
 496 #ifdef DIOCGMEDIASIZE
 497         if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
 498 #elif defined(DIOCGPART)
 499         {
 500                 struct partinfo pi;
 501                 if (ioctl(fd, DIOCGPART, &pi) == 0)
 502                         size = pi.media_size;
 503                 else
 504                         size = 0;
 505         }
 506         if (size == 0)
 507 #endif
 508 #ifdef CONFIG_COCOA
 509         size = LONG_LONG_MAX;
 510 #else
 511         size = lseek(fd, 0LL, SEEK_END);
 512 #endif
 513 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 514         switch(s->type) {
 515         case FTYPE_CD:
 516             /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
 517             if (size == 2048LL * (unsigned)-1)
 518                 size = 0;
 519             /* XXX no disc?  maybe we need to reopen... */
 520             if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
 521                 reopened = 1;
 522                 goto again;
 523             }
 524         }
 525 #endif
 526     } else {
 527         size = lseek(fd, 0, SEEK_END);
 528     }
 529     return size;
 530 }
 531 #else
 532 static int64_t raw_getlength(BlockDriverState *bs)
 533 {
 534     BDRVRawState *s = bs->opaque;
 535     int ret;
 536
 537     ret = fd_open(bs);
 538     if (ret < 0) {
 539         return ret;
 540     }
 541
 542     return lseek(s->fd, 0, SEEK_END);
 543 }
 544 #endif
 545
 546 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
 547 {
 548     struct stat st;
 549     BDRVRawState *s = bs->opaque;
 550
 551     if (fstat(s->fd, &st) < 0) {
 552         return -errno;
 553     }
 554     return (int64_t)st.st_blocks * 512;
 555 }
 556
 557 static int raw_create(const char *filename, QEMUOptionParameter *options)
 558 {
 559     int fd;
 560     int result = 0;
 561     int64_t total_size = 0;
 562
 563     /* Read out options */
 564     while (options && options->name) {
 565         if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
 566             total_size = options->value.n / BDRV_SECTOR_SIZE;
 567         }
 568         options++;
 569     }
 570
 571     fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
 572               0644);
 573     if (fd < 0) {
 574         result = -errno;
 575     } else {
 576         if (ftruncate(fd, total_size * BDRV_SECTOR_SIZE) != 0) {
 577             result = -errno;
 578         }
 579         if (close(fd) != 0) {
 580             result = -errno;
 581         }
 582     }
 583     return result;
 584 }
 585
 586 #ifdef CONFIG_XFS
 587 static int xfs_discard(BDRVRawState *s, int64_t sector_num, int nb_sectors)
 588 {
 589     struct xfs_flock64 fl;
 590
 591     memset(&fl, 0, sizeof(fl));
 592     fl.l_whence = SEEK_SET;
 593     fl.l_start = sector_num << 9;
 594     fl.l_len = (int64_t)nb_sectors << 9;
 595
 596     if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {
 597         DEBUG_BLOCK_PRINT("cannot punch hole (%s)\n", strerror(errno));
 598         return -errno;
 599     }
 600
 601     return 0;
 602 }
 603 #endif
 604
 605 static coroutine_fn int raw_co_discard(BlockDriverState *bs,
 606     int64_t sector_num, int nb_sectors)
 607 {
 608 #ifdef CONFIG_XFS
 609     BDRVRawState *s = bs->opaque;
 610
 611     if (s->is_xfs) {
 612         return xfs_discard(s, sector_num, nb_sectors);
 613     }
 614 #endif
 615
 616     return 0;
 617 }
 618
 619 static QEMUOptionParameter raw_create_options[] = {
 620     {
 621         .name = BLOCK_OPT_SIZE,
 622         .type = OPT_SIZE,
 623         .help = "Virtual disk size"
 624     },
 625     { NULL }
 626 };
 627
 628 static BlockDriver bdrv_file = {
 629     .format_name = "file",
 630     .protocol_name = "file",
 631     .instance_size = sizeof(BDRVRawState),
 632     .bdrv_probe = NULL, /* no probe for protocols */
 633     .bdrv_file_open = raw_open,
 634     .bdrv_close = raw_close,
 635     .bdrv_create = raw_create,
 636     .bdrv_co_discard = raw_co_discard,
 637
 638     .bdrv_aio_readv = raw_aio_readv,
 639     .bdrv_aio_writev = raw_aio_writev,
 640     .bdrv_aio_flush = raw_aio_flush,
 641
 642     .bdrv_truncate = raw_truncate,
 643     .bdrv_getlength = raw_getlength,
 644     .bdrv_get_allocated_file_size
 645                         = raw_get_allocated_file_size,
 646
 647     .create_options = raw_create_options,
 648 };
 649
 650 /***********************************************/
 651 /* host device */
 652
 653 #ifdef CONFIG_COCOA
 654 static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator );
 655 static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize );
 656
 657 kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
 658 {
 659     kern_return_t       kernResult;
 660     mach_port_t     masterPort;
 661     CFMutableDictionaryRef  classesToMatch;
 662
 663     kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
 664     if ( KERN_SUCCESS != kernResult ) {
 665         printf( "IOMasterPort returned %d\n", kernResult );
 666     }
 667
 668     classesToMatch = IOServiceMatching( kIOCDMediaClass );
 669     if ( classesToMatch == NULL ) {
 670         printf( "IOServiceMatching returned a NULL dictionary.\n" );
 671     } else {
 672     CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue );
 673     }
 674     kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator );
 675     if ( KERN_SUCCESS != kernResult )
 676     {
 677         printf( "IOServiceGetMatchingServices returned %d\n", kernResult );
 678     }
 679
 680     return kernResult;
 681 }
 682
 683 kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize )
 684 {
 685     io_object_t     nextMedia;
 686     kern_return_t   kernResult = KERN_FAILURE;
 687     *bsdPath = '\0';
 688     nextMedia = IOIteratorNext( mediaIterator );
 689     if ( nextMedia )
 690     {
 691         CFTypeRef   bsdPathAsCFString;
 692     bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
 693         if ( bsdPathAsCFString ) {
 694             size_t devPathLength;
 695             strcpy( bsdPath, _PATH_DEV );
 696             strcat( bsdPath, "r" );
 697             devPathLength = strlen( bsdPath );
 698             if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
 699                 kernResult = KERN_SUCCESS;
 700             }
 701             CFRelease( bsdPathAsCFString );
 702         }
 703         IOObjectRelease( nextMedia );
 704     }
 705
 706     return kernResult;
 707 }
 708
 709 #endif
 710
 711 static int hdev_probe_device(const char *filename)
 712 {
 713     struct stat st;
 714
 715     /* allow a dedicated CD-ROM driver to match with a higher priority */
 716     if (strstart(filename, "/dev/cdrom", NULL))
 717         return 50;
 718
 719     if (stat(filename, &st) >= 0 &&
 720             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
 721         return 100;
 722     }
 723
 724     return 0;
 725 }
 726
 727 static int hdev_open(BlockDriverState *bs, const char *filename, int flags)
 728 {
 729     BDRVRawState *s = bs->opaque;
 730
 731 #ifdef CONFIG_COCOA
 732     if (strstart(filename, "/dev/cdrom", NULL)) {
 733         kern_return_t kernResult;
 734         io_iterator_t mediaIterator;
 735         char bsdPath[ MAXPATHLEN ];
 736         int fd;
 737
 738         kernResult = FindEjectableCDMedia( &mediaIterator );
 739         kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );
 740
 741         if ( bsdPath[ 0 ] != '\0' ) {
 742             strcat(bsdPath,"s0");
 743             /* some CDs don't have a partition 0 */
 744             fd = open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
 745             if (fd < 0) {
 746                 bsdPath[strlen(bsdPath)-1] = '1';
 747             } else {
 748                 close(fd);
 749             }
 750             filename = bsdPath;
 751         }
 752
 753         if ( mediaIterator )
 754             IOObjectRelease( mediaIterator );
 755     }
 756 #endif
 757
 758     s->type = FTYPE_FILE;
 759 #if defined(__linux__)
 760     {
 761         char resolved_path[ MAXPATHLEN ], *temp;
 762
 763         temp = realpath(filename, resolved_path);
 764         if (temp && strstart(temp, "/dev/sg", NULL)) {
 765             bs->sg = 1;
 766         }
 767     }
 768 #endif
 769
 770     return raw_open_common(bs, filename, flags, 0);
 771 }
 772
 773 #if defined(__linux__)
 774 /* Note: we do not have a reliable method to detect if the floppy is
 775    present. The current method is to try to open the floppy at every
 776    I/O and to keep it opened during a few hundreds of ms. */
 777 static int fd_open(BlockDriverState *bs)
 778 {
 779     BDRVRawState *s = bs->opaque;
 780     int last_media_present;
 781
 782     if (s->type != FTYPE_FD)
 783         return 0;
 784     last_media_present = (s->fd >= 0);
 785     if (s->fd >= 0 &&
 786         (get_clock() - s->fd_open_time) >= FD_OPEN_TIMEOUT) {
 787         close(s->fd);
 788         s->fd = -1;
 789 #ifdef DEBUG_FLOPPY
 790         printf("Floppy closed\n");
 791 #endif
 792     }
 793     if (s->fd < 0) {
 794         if (s->fd_got_error &&
 795             (get_clock() - s->fd_error_time) < FD_OPEN_TIMEOUT) {
 796 #ifdef DEBUG_FLOPPY
 797             printf("No floppy (open delayed)\n");
 798 #endif
 799             return -EIO;
 800         }
 801         s->fd = open(bs->filename, s->open_flags & ~O_NONBLOCK);
 802         if (s->fd < 0) {
 803             s->fd_error_time = get_clock();
 804             s->fd_got_error = 1;
 805             if (last_media_present)
 806                 s->fd_media_changed = 1;
 807 #ifdef DEBUG_FLOPPY
 808             printf("No floppy\n");
 809 #endif
 810             return -EIO;
 811         }
 812 #ifdef DEBUG_FLOPPY
 813         printf("Floppy opened\n");
 814 #endif
 815     }
 816     if (!last_media_present)
 817         s->fd_media_changed = 1;
 818     s->fd_open_time = get_clock();
 819     s->fd_got_error = 0;
 820     return 0;
 821 }
 822
 823 static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
 824 {
 825     BDRVRawState *s = bs->opaque;
 826
 827     return ioctl(s->fd, req, buf);
 828 }
 829
 830 static BlockDriverAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
 831         unsigned long int req, void *buf,
 832         BlockDriverCompletionFunc *cb, void *opaque)
 833 {
 834     BDRVRawState *s = bs->opaque;
 835
 836     if (fd_open(bs) < 0)
 837         return NULL;
 838     return paio_ioctl(bs, s->fd, req, buf, cb, opaque);
 839 }
 840
 841 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 842 static int fd_open(BlockDriverState *bs)
 843 {
 844     BDRVRawState *s = bs->opaque;
 845
 846     /* this is just to ensure s->fd is sane (its called by io ops) */
 847     if (s->fd >= 0)
 848         return 0;
 849     return -EIO;
 850 }
 851 #else /* !linux && !FreeBSD */
 852
 853 static int fd_open(BlockDriverState *bs)
 854 {
 855     return 0;
 856 }
 857
 858 #endif /* !linux && !FreeBSD */
 859
 860 static int hdev_create(const char *filename, QEMUOptionParameter *options)
 861 {
 862     int fd;
 863     int ret = 0;
 864     struct stat stat_buf;
 865     int64_t total_size = 0;
 866
 867     /* Read out options */
 868     while (options && options->name) {
 869         if (!strcmp(options->name, "size")) {
 870             total_size = options->value.n / BDRV_SECTOR_SIZE;
 871         }
 872         options++;
 873     }
 874
 875     fd = open(filename, O_WRONLY | O_BINARY);
 876     if (fd < 0)
 877         return -errno;
 878
 879     if (fstat(fd, &stat_buf) < 0)
 880         ret = -errno;
 881     else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode))
 882         ret = -ENODEV;
 883     else if (lseek(fd, 0, SEEK_END) < total_size * BDRV_SECTOR_SIZE)
 884         ret = -ENOSPC;
 885
 886     close(fd);
 887     return ret;
 888 }
 889
 890 static int hdev_has_zero_init(BlockDriverState *bs)
 891 {
 892     return 0;
 893 }
 894
 895 static BlockDriver bdrv_host_device = {
 896     .format_name        = "host_device",
 897     .protocol_name        = "host_device",
 898     .instance_size      = sizeof(BDRVRawState),
 899     .bdrv_probe_device  = hdev_probe_device,
 900     .bdrv_file_open     = hdev_open,
 901     .bdrv_close         = raw_close,
 902     .bdrv_create        = hdev_create,
 903     .create_options     = raw_create_options,
 904     .bdrv_has_zero_init = hdev_has_zero_init,
 905
 906     .bdrv_aio_readv     = raw_aio_readv,
 907     .bdrv_aio_writev    = raw_aio_writev,
 908     .bdrv_aio_flush     = raw_aio_flush,
 909
 910     .bdrv_truncate      = raw_truncate,
 911     .bdrv_getlength     = raw_getlength,
 912     .bdrv_get_allocated_file_size
 913                         = raw_get_allocated_file_size,
 914
 915     /* generic scsi device */
 916 #ifdef __linux__
 917     .bdrv_ioctl         = hdev_ioctl,
 918     .bdrv_aio_ioctl     = hdev_aio_ioctl,
 919 #endif
 920 };
 921
 922 #ifdef __linux__
 923 static int floppy_open(BlockDriverState *bs, const char *filename, int flags)
 924 {
 925     BDRVRawState *s = bs->opaque;
 926     int ret;
 927
 928     s->type = FTYPE_FD;
 929
 930     /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */
 931     ret = raw_open_common(bs, filename, flags, O_NONBLOCK);
 932     if (ret)
 933         return ret;
 934
 935     /* close fd so that we can reopen it as needed */
 936     close(s->fd);
 937     s->fd = -1;
 938     s->fd_media_changed = 1;
 939
 940     return 0;
 941 }
 942
 943 static int floppy_probe_device(const char *filename)
 944 {
 945     int fd, ret;
 946     int prio = 0;
 947     struct floppy_struct fdparam;
 948     struct stat st;
 949
 950     if (strstart(filename, "/dev/fd", NULL))
 951         prio = 50;
 952
 953     fd = open(filename, O_RDONLY | O_NONBLOCK);
 954     if (fd < 0) {
 955         goto out;
 956     }
 957     ret = fstat(fd, &st);
 958     if (ret == -1 || !S_ISBLK(st.st_mode)) {
 959         goto outc;
 960     }
 961
 962     /* Attempt to detect via a floppy specific ioctl */
 963     ret = ioctl(fd, FDGETPRM, &fdparam);
 964     if (ret >= 0)
 965         prio = 100;
 966
 967 outc:
 968     close(fd);
 969 out:
 970     return prio;
 971 }
 972
 973
 974 static int floppy_is_inserted(BlockDriverState *bs)
 975 {
 976     return fd_open(bs) >= 0;
 977 }
 978
 979 static int floppy_media_changed(BlockDriverState *bs)
 980 {
 981     BDRVRawState *s = bs->opaque;
 982     int ret;
 983
 984     /*
 985      * XXX: we do not have a true media changed indication.
 986      * It does not work if the floppy is changed without trying to read it.
 987      */
 988     fd_open(bs);
 989     ret = s->fd_media_changed;
 990     s->fd_media_changed = 0;
 991 #ifdef DEBUG_FLOPPY
 992     printf("Floppy changed=%d\n", ret);
 993 #endif
 994     return ret;
 995 }
 996
 997 static void floppy_eject(BlockDriverState *bs, int eject_flag)
 998 {
 999     BDRVRawState *s = bs->opaque;
1000     int fd;
1001
1002     if (s->fd >= 0) {
1003         close(s->fd);
1004         s->fd = -1;
1005     }
1006     fd = open(bs->filename, s->open_flags | O_NONBLOCK);
1007     if (fd >= 0) {
1008         if (ioctl(fd, FDEJECT, 0) < 0)
1009             perror("FDEJECT");
1010         close(fd);
1011     }
1012 }
1013
1014 static BlockDriver bdrv_host_floppy = {
1015     .format_name        = "host_floppy",
1016     .protocol_name      = "host_floppy",
1017     .instance_size      = sizeof(BDRVRawState),
1018     .bdrv_probe_device  = floppy_probe_device,
1019     .bdrv_file_open     = floppy_open,
1020     .bdrv_close         = raw_close,
1021     .bdrv_create        = hdev_create,
1022     .create_options     = raw_create_options,
1023     .bdrv_has_zero_init = hdev_has_zero_init,
1024
1025     .bdrv_aio_readv     = raw_aio_readv,
1026     .bdrv_aio_writev    = raw_aio_writev,
1027     .bdrv_aio_flush     = raw_aio_flush,
1028
1029     .bdrv_truncate      = raw_truncate,
1030     .bdrv_getlength     = raw_getlength,
1031     .bdrv_get_allocated_file_size
1032                         = raw_get_allocated_file_size,
1033
1034     /* removable device support */
1035     .bdrv_is_inserted   = floppy_is_inserted,
1036     .bdrv_media_changed = floppy_media_changed,
1037     .bdrv_eject         = floppy_eject,
1038 };
1039
1040 static int cdrom_open(BlockDriverState *bs, const char *filename, int flags)
1041 {
1042     BDRVRawState *s = bs->opaque;
1043
1044     s->type = FTYPE_CD;
1045
1046     /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
1047     return raw_open_common(bs, filename, flags, O_NONBLOCK);
1048 }
1049
1050 static int cdrom_probe_device(const char *filename)
1051 {
1052     int fd, ret;
1053     int prio = 0;
1054     struct stat st;
1055
1056     fd = open(filename, O_RDONLY | O_NONBLOCK);
1057     if (fd < 0) {
1058         goto out;
1059     }
1060     ret = fstat(fd, &st);
1061     if (ret == -1 || !S_ISBLK(st.st_mode)) {
1062         goto outc;
1063     }
1064
1065     /* Attempt to detect via a CDROM specific ioctl */
1066     ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
1067     if (ret >= 0)
1068         prio = 100;
1069
1070 outc:
1071     close(fd);
1072 out:
1073     return prio;
1074 }
1075
1076 static int cdrom_is_inserted(BlockDriverState *bs)
1077 {
1078     BDRVRawState *s = bs->opaque;
1079     int ret;
1080
1081     ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
1082     if (ret == CDS_DISC_OK)
1083         return 1;
1084     return 0;
1085 }
1086
1087 static void cdrom_eject(BlockDriverState *bs, int eject_flag)
1088 {
1089     BDRVRawState *s = bs->opaque;
1090
1091     if (eject_flag) {
1092         if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
1093             perror("CDROMEJECT");
1094     } else {
1095         if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
1096             perror("CDROMEJECT");
1097     }
1098 }
1099
1100 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
1101 {
1102     BDRVRawState *s = bs->opaque;
1103
1104     if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
1105         /*
1106          * Note: an error can happen if the distribution automatically
1107          * mounts the CD-ROM
1108          */
1109         /* perror("CDROM_LOCKDOOR"); */
1110     }
1111 }
1112
1113 static BlockDriver bdrv_host_cdrom = {
1114     .format_name        = "host_cdrom",
1115     .protocol_name      = "host_cdrom",
1116     .instance_size      = sizeof(BDRVRawState),
1117     .bdrv_probe_device  = cdrom_probe_device,
1118     .bdrv_file_open     = cdrom_open,
1119     .bdrv_close         = raw_close,
1120     .bdrv_create        = hdev_create,
1121     .create_options     = raw_create_options,
1122     .bdrv_has_zero_init = hdev_has_zero_init,
1123
1124     .bdrv_aio_readv     = raw_aio_readv,
1125     .bdrv_aio_writev    = raw_aio_writev,
1126     .bdrv_aio_flush     = raw_aio_flush,
1127
1128     .bdrv_truncate      = raw_truncate,
1129     .bdrv_getlength     = raw_getlength,
1130     .bdrv_get_allocated_file_size
1131                         = raw_get_allocated_file_size,
1132
1133     /* removable device support */
1134     .bdrv_is_inserted   = cdrom_is_inserted,
1135     .bdrv_eject         = cdrom_eject,
1136     .bdrv_lock_medium   = cdrom_lock_medium,
1137
1138     /* generic scsi device */
1139     .bdrv_ioctl         = hdev_ioctl,
1140     .bdrv_aio_ioctl     = hdev_aio_ioctl,
1141 };
1142 #endif /* __linux__ */
1143
1144 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1145 static int cdrom_open(BlockDriverState *bs, const char *filename, int flags)
1146 {
1147     BDRVRawState *s = bs->opaque;
1148     int ret;
1149
1150     s->type = FTYPE_CD;
1151
1152     ret = raw_open_common(bs, filename, flags, 0);
1153     if (ret)
1154         return ret;
1155
1156     /* make sure the door isn't locked at this time */
1157     ioctl(s->fd, CDIOCALLOW);
1158     return 0;
1159 }
1160
1161 static int cdrom_probe_device(const char *filename)
1162 {
1163     if (strstart(filename, "/dev/cd", NULL) ||
1164             strstart(filename, "/dev/acd", NULL))
1165         return 100;
1166     return 0;
1167 }
1168
1169 static int cdrom_reopen(BlockDriverState *bs)
1170 {
1171     BDRVRawState *s = bs->opaque;
1172     int fd;
1173
1174     /*
1175      * Force reread of possibly changed/newly loaded disc,
1176      * FreeBSD seems to not notice sometimes...
1177      */
1178     if (s->fd >= 0)
1179         close(s->fd);
1180     fd = open(bs->filename, s->open_flags, 0644);
1181     if (fd < 0) {
1182         s->fd = -1;
1183         return -EIO;
1184     }
1185     s->fd = fd;
1186
1187     /* make sure the door isn't locked at this time */
1188     ioctl(s->fd, CDIOCALLOW);
1189     return 0;
1190 }
1191
1192 static int cdrom_is_inserted(BlockDriverState *bs)
1193 {
1194     return raw_getlength(bs) > 0;
1195 }
1196
1197 static void cdrom_eject(BlockDriverState *bs, int eject_flag)
1198 {
1199     BDRVRawState *s = bs->opaque;
1200
1201     if (s->fd < 0)
1202         return;
1203
1204     (void) ioctl(s->fd, CDIOCALLOW);
1205
1206     if (eject_flag) {
1207         if (ioctl(s->fd, CDIOCEJECT) < 0)
1208             perror("CDIOCEJECT");
1209     } else {
1210         if (ioctl(s->fd, CDIOCCLOSE) < 0)
1211             perror("CDIOCCLOSE");
1212     }
1213
1214     cdrom_reopen(bs);
1215 }
1216
1217 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
1218 {
1219     BDRVRawState *s = bs->opaque;
1220
1221     if (s->fd < 0)
1222         return;
1223     if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
1224         /*
1225          * Note: an error can happen if the distribution automatically
1226          * mounts the CD-ROM
1227          */
1228         /* perror("CDROM_LOCKDOOR"); */
1229     }
1230 }
1231
1232 static BlockDriver bdrv_host_cdrom = {
1233     .format_name        = "host_cdrom",
1234     .protocol_name      = "host_cdrom",
1235     .instance_size      = sizeof(BDRVRawState),
1236     .bdrv_probe_device  = cdrom_probe_device,
1237     .bdrv_file_open     = cdrom_open,
1238     .bdrv_close         = raw_close,
1239     .bdrv_create        = hdev_create,
1240     .create_options     = raw_create_options,
1241     .bdrv_has_zero_init = hdev_has_zero_init,
1242
1243     .bdrv_aio_readv     = raw_aio_readv,
1244     .bdrv_aio_writev    = raw_aio_writev,
1245     .bdrv_aio_flush     = raw_aio_flush,
1246
1247     .bdrv_truncate      = raw_truncate,
1248     .bdrv_getlength     = raw_getlength,
1249     .bdrv_get_allocated_file_size
1250                         = raw_get_allocated_file_size,
1251
1252     /* removable device support */
1253     .bdrv_is_inserted   = cdrom_is_inserted,
1254     .bdrv_eject         = cdrom_eject,
1255     .bdrv_lock_medium   = cdrom_lock_medium,
1256 };
1257 #endif /* __FreeBSD__ */
1258
1259 static void bdrv_file_init(void)
1260 {
1261     /*
1262      * Register all the drivers.  Note that order is important, the driver
1263      * registered last will get probed first.
1264      */
1265     bdrv_register(&bdrv_file);
1266     bdrv_register(&bdrv_host_device);
1267 #ifdef __linux__
1268     bdrv_register(&bdrv_host_floppy);
1269     bdrv_register(&bdrv_host_cdrom);
1270 #endif
1271 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1272     bdrv_register(&bdrv_host_cdrom);
1273 #endif
1274 }
1275
1276 block_init(bdrv_file_init);