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