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