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/log.h"
  27 #include "block/block_int.h"
  28 #include "qemu/module.h"
  29 #include "trace.h"
  30 #include "block/thread-pool.h"
  31 #include "qemu/iov.h"
  32 #include "raw-aio.h"
  33 #include "qapi/util.h"
  34
  35 #if defined(__APPLE__) && (__MACH__)
  36 #include <paths.h>
  37 #include <sys/param.h>
  38 #include <IOKit/IOKitLib.h>
  39 #include <IOKit/IOBSD.h>
  40 #include <IOKit/storage/IOMediaBSDClient.h>
  41 #include <IOKit/storage/IOMedia.h>
  42 #include <IOKit/storage/IOCDMedia.h>
  43 //#include <IOKit/storage/IOCDTypes.h>
  44 #include <CoreFoundation/CoreFoundation.h>
  45 #endif
  46
  47 #ifdef __sun__
  48 #define _POSIX_PTHREAD_SEMANTICS 1
  49 #include <sys/dkio.h>
  50 #endif
  51 #ifdef __linux__
  52 #include <sys/types.h>
  53 #include <sys/stat.h>
  54 #include <sys/ioctl.h>
  55 #include <sys/param.h>
  56 #include <linux/cdrom.h>
  57 #include <linux/fd.h>
  58 #include <linux/fs.h>
  59 #include <linux/hdreg.h>
  60 #ifdef __s390__
  61 #include <asm/dasd.h>
  62 #endif
  63 #ifndef FS_NOCOW_FL
  64 #define FS_NOCOW_FL                     0x00800000 /* Do not cow file */
  65 #endif
  66 #endif
  67 #if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
  68 #include <linux/falloc.h>
  69 #endif
  70 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
  71 #include <sys/disk.h>
  72 #include <sys/cdio.h>
  73 #endif
  74
  75 #ifdef __OpenBSD__
  76 #include <sys/ioctl.h>
  77 #include <sys/disklabel.h>
  78 #include <sys/dkio.h>
  79 #endif
  80
  81 #ifdef __NetBSD__
  82 #include <sys/ioctl.h>
  83 #include <sys/disklabel.h>
  84 #include <sys/dkio.h>
  85 #include <sys/disk.h>
  86 #endif
  87
  88 #ifdef __DragonFly__
  89 #include <sys/ioctl.h>
  90 #include <sys/diskslice.h>
  91 #endif
  92
  93 #ifdef CONFIG_XFS
  94 #include <xfs/xfs.h>
  95 #endif
  96
  97 //#define DEBUG_FLOPPY
  98
  99 //#define DEBUG_BLOCK
 100 #if defined(DEBUG_BLOCK)
 101 #define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \
 102     { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0)
 103 #else
 104 #define DEBUG_BLOCK_PRINT(formatCstr, ...)
 105 #endif
 106
 107 /* OS X does not have O_DSYNC */
 108 #ifndef O_DSYNC
 109 #ifdef O_SYNC
 110 #define O_DSYNC O_SYNC
 111 #elif defined(O_FSYNC)
 112 #define O_DSYNC O_FSYNC
 113 #endif
 114 #endif
 115
 116 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
 117 #ifndef O_DIRECT
 118 #define O_DIRECT O_DSYNC
 119 #endif
 120
 121 #define FTYPE_FILE   0
 122 #define FTYPE_CD     1
 123 #define FTYPE_FD     2
 124
 125 /* if the FD is not accessed during that time (in ns), we try to
 126    reopen it to see if the disk has been changed */
 127 #define FD_OPEN_TIMEOUT (1000000000)
 128
 129 #define MAX_BLOCKSIZE   4096
 130
 131 typedef struct BDRVRawState {
 132     int fd;
 133     int type;
 134     int open_flags;
 135     size_t buf_align;
 136
 137 #if defined(__linux__)
 138     /* linux floppy specific */
 139     int64_t fd_open_time;
 140     int64_t fd_error_time;
 141     int fd_got_error;
 142     int fd_media_changed;
 143 #endif
 144 #ifdef CONFIG_LINUX_AIO
 145     int use_aio;
 146     void *aio_ctx;
 147 #endif
 148 #ifdef CONFIG_XFS
 149     bool is_xfs:1;
 150 #endif
 151     bool has_discard:1;
 152     bool has_write_zeroes:1;
 153     bool discard_zeroes:1;
 154     bool has_fallocate;
 155     bool needs_alignment;
 156 } BDRVRawState;
 157
 158 typedef struct BDRVRawReopenState {
 159     int fd;
 160     int open_flags;
 161 #ifdef CONFIG_LINUX_AIO
 162     int use_aio;
 163 #endif
 164 } BDRVRawReopenState;
 165
 166 static int fd_open(BlockDriverState *bs);
 167 static int64_t raw_getlength(BlockDriverState *bs);
 168
 169 typedef struct RawPosixAIOData {
 170     BlockDriverState *bs;
 171     int aio_fildes;
 172     union {
 173         struct iovec *aio_iov;
 174         void *aio_ioctl_buf;
 175     };
 176     int aio_niov;
 177     uint64_t aio_nbytes;
 178 #define aio_ioctl_cmd   aio_nbytes /* for QEMU_AIO_IOCTL */
 179     off_t aio_offset;
 180     int aio_type;
 181 } RawPosixAIOData;
 182
 183 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 184 static int cdrom_reopen(BlockDriverState *bs);
 185 #endif
 186
 187 #if defined(__NetBSD__)
 188 static int raw_normalize_devicepath(const char **filename)
 189 {
 190     static char namebuf[PATH_MAX];
 191     const char *dp, *fname;
 192     struct stat sb;
 193
 194     fname = *filename;
 195     dp = strrchr(fname, '/');
 196     if (lstat(fname, &sb) < 0) {
 197         fprintf(stderr, "%s: stat failed: %s\n",
 198             fname, strerror(errno));
 199         return -errno;
 200     }
 201
 202     if (!S_ISBLK(sb.st_mode)) {
 203         return 0;
 204     }
 205
 206     if (dp == NULL) {
 207         snprintf(namebuf, PATH_MAX, "r%s", fname);
 208     } else {
 209         snprintf(namebuf, PATH_MAX, "%.*s/r%s",
 210             (int)(dp - fname), fname, dp + 1);
 211     }
 212     fprintf(stderr, "%s is a block device", fname);
 213     *filename = namebuf;
 214     fprintf(stderr, ", using %s\n", *filename);
 215
 216     return 0;
 217 }
 218 #else
 219 static int raw_normalize_devicepath(const char **filename)
 220 {
 221     return 0;
 222 }
 223 #endif
 224
 225 /*
 226  * Get logical block size via ioctl. On success store it in @sector_size_p.
 227  */
 228 static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
 229 {
 230     unsigned int sector_size;
 231     bool success = false;
 232
 233     errno = ENOTSUP;
 234
 235     /* Try a few ioctls to get the right size */
 236 #ifdef BLKSSZGET
 237     if (ioctl(fd, BLKSSZGET, &sector_size) >= 0) {
 238         *sector_size_p = sector_size;
 239         success = true;
 240     }
 241 #endif
 242 #ifdef DKIOCGETBLOCKSIZE
 243     if (ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) >= 0) {
 244         *sector_size_p = sector_size;
 245         success = true;
 246     }
 247 #endif
 248 #ifdef DIOCGSECTORSIZE
 249     if (ioctl(fd, DIOCGSECTORSIZE, &sector_size) >= 0) {
 250         *sector_size_p = sector_size;
 251         success = true;
 252     }
 253 #endif
 254
 255     return success ? 0 : -errno;
 256 }
 257
 258 /**
 259  * Get physical block size of @fd.
 260  * On success, store it in @blk_size and return 0.
 261  * On failure, return -errno.
 262  */
 263 static int probe_physical_blocksize(int fd, unsigned int *blk_size)
 264 {
 265 #ifdef BLKPBSZGET
 266     if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
 267         return -errno;
 268     }
 269     return 0;
 270 #else
 271     return -ENOTSUP;
 272 #endif
 273 }
 274
 275 /* Check if read is allowed with given memory buffer and length.
 276  *
 277  * This function is used to check O_DIRECT memory buffer and request alignment.
 278  */
 279 static bool raw_is_io_aligned(int fd, void *buf, size_t len)
 280 {
 281     ssize_t ret = pread(fd, buf, len, 0);
 282
 283     if (ret >= 0) {
 284         return true;
 285     }
 286
 287 #ifdef __linux__
 288     /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads.  Ignore
 289      * other errors (e.g. real I/O error), which could happen on a failed
 290      * drive, since we only care about probing alignment.
 291      */
 292     if (errno != EINVAL) {
 293         return true;
 294     }
 295 #endif
 296
 297     return false;
 298 }
 299
 300 static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
 301 {
 302     BDRVRawState *s = bs->opaque;
 303     char *buf;
 304
 305     /* For /dev/sg devices the alignment is not really used.
 306        With buffered I/O, we don't have any restrictions. */
 307     if (bs->sg || !s->needs_alignment) {
 308         bs->request_alignment = 1;
 309         s->buf_align = 1;
 310         return;
 311     }
 312
 313     bs->request_alignment = 0;
 314     s->buf_align = 0;
 315     /* Let's try to use the logical blocksize for the alignment. */
 316     if (probe_logical_blocksize(fd, &bs->request_alignment) < 0) {
 317         bs->request_alignment = 0;
 318     }
 319 #ifdef CONFIG_XFS
 320     if (s->is_xfs) {
 321         struct dioattr da;
 322         if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {
 323             bs->request_alignment = da.d_miniosz;
 324             /* The kernel returns wrong information for d_mem */
 325             /* s->buf_align = da.d_mem; */
 326         }
 327     }
 328 #endif
 329
 330     /* If we could not get the sizes so far, we can only guess them */
 331     if (!s->buf_align) {
 332         size_t align;
 333         buf = qemu_memalign(MAX_BLOCKSIZE, 2 * MAX_BLOCKSIZE);
 334         for (align = 512; align <= MAX_BLOCKSIZE; align <<= 1) {
 335             if (raw_is_io_aligned(fd, buf + align, MAX_BLOCKSIZE)) {
 336                 s->buf_align = align;
 337                 break;
 338             }
 339         }
 340         qemu_vfree(buf);
 341     }
 342
 343     if (!bs->request_alignment) {
 344         size_t align;
 345         buf = qemu_memalign(s->buf_align, MAX_BLOCKSIZE);
 346         for (align = 512; align <= MAX_BLOCKSIZE; align <<= 1) {
 347             if (raw_is_io_aligned(fd, buf, align)) {
 348                 bs->request_alignment = align;
 349                 break;
 350             }
 351         }
 352         qemu_vfree(buf);
 353     }
 354
 355     if (!s->buf_align || !bs->request_alignment) {
 356         error_setg(errp, "Could not find working O_DIRECT alignment. "
 357                          "Try cache.direct=off.");
 358     }
 359 }
 360
 361 static void raw_parse_flags(int bdrv_flags, int *open_flags)
 362 {
 363     assert(open_flags != NULL);
 364
 365     *open_flags |= O_BINARY;
 366     *open_flags &= ~O_ACCMODE;
 367     if (bdrv_flags & BDRV_O_RDWR) {
 368         *open_flags |= O_RDWR;
 369     } else {
 370         *open_flags |= O_RDONLY;
 371     }
 372
 373     /* Use O_DSYNC for write-through caching, no flags for write-back caching,
 374      * and O_DIRECT for no caching. */
 375     if ((bdrv_flags & BDRV_O_NOCACHE)) {
 376         *open_flags |= O_DIRECT;
 377     }
 378 }
 379
 380 static void raw_detach_aio_context(BlockDriverState *bs)
 381 {
 382 #ifdef CONFIG_LINUX_AIO
 383     BDRVRawState *s = bs->opaque;
 384
 385     if (s->use_aio) {
 386         laio_detach_aio_context(s->aio_ctx, bdrv_get_aio_context(bs));
 387     }
 388 #endif
 389 }
 390
 391 static void raw_attach_aio_context(BlockDriverState *bs,
 392                                    AioContext *new_context)
 393 {
 394 #ifdef CONFIG_LINUX_AIO
 395     BDRVRawState *s = bs->opaque;
 396
 397     if (s->use_aio) {
 398         laio_attach_aio_context(s->aio_ctx, new_context);
 399     }
 400 #endif
 401 }
 402
 403 #ifdef CONFIG_LINUX_AIO
 404 static int raw_set_aio(void **aio_ctx, int *use_aio, int bdrv_flags)
 405 {
 406     int ret = -1;
 407     assert(aio_ctx != NULL);
 408     assert(use_aio != NULL);
 409     /*
 410      * Currently Linux do AIO only for files opened with O_DIRECT
 411      * specified so check NOCACHE flag too
 412      */
 413     if ((bdrv_flags & (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) ==
 414                       (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) {
 415
 416         /* if non-NULL, laio_init() has already been run */
 417         if (*aio_ctx == NULL) {
 418             *aio_ctx = laio_init();
 419             if (!*aio_ctx) {
 420                 goto error;
 421             }
 422         }
 423         *use_aio = 1;
 424     } else {
 425         *use_aio = 0;
 426     }
 427
 428     ret = 0;
 429
 430 error:
 431     return ret;
 432 }
 433 #endif
 434
 435 static void raw_parse_filename(const char *filename, QDict *options,
 436                                Error **errp)
 437 {
 438     /* The filename does not have to be prefixed by the protocol name, since
 439      * "file" is the default protocol; therefore, the return value of this
 440      * function call can be ignored. */
 441     strstart(filename, "file:", &filename);
 442
 443     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
 444 }
 445
 446 static QemuOptsList raw_runtime_opts = {
 447     .name = "raw",
 448     .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
 449     .desc = {
 450         {
 451             .name = "filename",
 452             .type = QEMU_OPT_STRING,
 453             .help = "File name of the image",
 454         },
 455         { /* end of list */ }
 456     },
 457 };
 458
 459 static int raw_open_common(BlockDriverState *bs, QDict *options,
 460                            int bdrv_flags, int open_flags, Error **errp)
 461 {
 462     BDRVRawState *s = bs->opaque;
 463     QemuOpts *opts;
 464     Error *local_err = NULL;
 465     const char *filename = NULL;
 466     int fd, ret;
 467     struct stat st;
 468
 469     opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
 470     qemu_opts_absorb_qdict(opts, options, &local_err);
 471     if (local_err) {
 472         error_propagate(errp, local_err);
 473         ret = -EINVAL;
 474         goto fail;
 475     }
 476
 477     filename = qemu_opt_get(opts, "filename");
 478
 479     ret = raw_normalize_devicepath(&filename);
 480     if (ret != 0) {
 481         error_setg_errno(errp, -ret, "Could not normalize device path");
 482         goto fail;
 483     }
 484
 485     s->open_flags = open_flags;
 486     raw_parse_flags(bdrv_flags, &s->open_flags);
 487
 488     s->fd = -1;
 489     fd = qemu_open(filename, s->open_flags, 0644);
 490     if (fd < 0) {
 491         ret = -errno;
 492         if (ret == -EROFS) {
 493             ret = -EACCES;
 494         }
 495         goto fail;
 496     }
 497     s->fd = fd;
 498
 499 #ifdef CONFIG_LINUX_AIO
 500     if (raw_set_aio(&s->aio_ctx, &s->use_aio, bdrv_flags)) {
 501         qemu_close(fd);
 502         ret = -errno;
 503         error_setg_errno(errp, -ret, "Could not set AIO state");
 504         goto fail;
 505     }
 506 #endif
 507
 508     s->has_discard = true;
 509     s->has_write_zeroes = true;
 510     if ((bs->open_flags & BDRV_O_NOCACHE) != 0) {
 511         s->needs_alignment = true;
 512     }
 513
 514     if (fstat(s->fd, &st) < 0) {
 515         ret = -errno;
 516         error_setg_errno(errp, errno, "Could not stat file");
 517         goto fail;
 518     }
 519     if (S_ISREG(st.st_mode)) {
 520         s->discard_zeroes = true;
 521         s->has_fallocate = true;
 522     }
 523     if (S_ISBLK(st.st_mode)) {
 524 #ifdef BLKDISCARDZEROES
 525         unsigned int arg;
 526         if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
 527             s->discard_zeroes = true;
 528         }
 529 #endif
 530 #ifdef __linux__
 531         /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache.  Do
 532          * not rely on the contents of discarded blocks unless using O_DIRECT.
 533          * Same for BLKZEROOUT.
 534          */
 535         if (!(bs->open_flags & BDRV_O_NOCACHE)) {
 536             s->discard_zeroes = false;
 537             s->has_write_zeroes = false;
 538         }
 539 #endif
 540     }
 541 #ifdef __FreeBSD__
 542     if (S_ISCHR(st.st_mode)) {
 543         /*
 544          * The file is a char device (disk), which on FreeBSD isn't behind
 545          * a pager, so force all requests to be aligned. This is needed
 546          * so QEMU makes sure all IO operations on the device are aligned
 547          * to sector size, or else FreeBSD will reject them with EINVAL.
 548          */
 549         s->needs_alignment = true;
 550     }
 551 #endif
 552
 553 #ifdef CONFIG_XFS
 554     if (platform_test_xfs_fd(s->fd)) {
 555         s->is_xfs = true;
 556     }
 557 #endif
 558
 559     raw_attach_aio_context(bs, bdrv_get_aio_context(bs));
 560
 561     ret = 0;
 562 fail:
 563     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
 564         unlink(filename);
 565     }
 566     qemu_opts_del(opts);
 567     return ret;
 568 }
 569
 570 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
 571                     Error **errp)
 572 {
 573     BDRVRawState *s = bs->opaque;
 574     Error *local_err = NULL;
 575     int ret;
 576
 577     s->type = FTYPE_FILE;
 578     ret = raw_open_common(bs, options, flags, 0, &local_err);
 579     if (local_err) {
 580         error_propagate(errp, local_err);
 581     }
 582     return ret;
 583 }
 584
 585 static int raw_reopen_prepare(BDRVReopenState *state,
 586                               BlockReopenQueue *queue, Error **errp)
 587 {
 588     BDRVRawState *s;
 589     BDRVRawReopenState *raw_s;
 590     int ret = 0;
 591     Error *local_err = NULL;
 592
 593     assert(state != NULL);
 594     assert(state->bs != NULL);
 595
 596     s = state->bs->opaque;
 597
 598     state->opaque = g_new0(BDRVRawReopenState, 1);
 599     raw_s = state->opaque;
 600
 601 #ifdef CONFIG_LINUX_AIO
 602     raw_s->use_aio = s->use_aio;
 603
 604     /* we can use s->aio_ctx instead of a copy, because the use_aio flag is
 605      * valid in the 'false' condition even if aio_ctx is set, and raw_set_aio()
 606      * won't override aio_ctx if aio_ctx is non-NULL */
 607     if (raw_set_aio(&s->aio_ctx, &raw_s->use_aio, state->flags)) {
 608         error_setg(errp, "Could not set AIO state");
 609         return -1;
 610     }
 611 #endif
 612
 613     if (s->type == FTYPE_FD || s->type == FTYPE_CD) {
 614         raw_s->open_flags |= O_NONBLOCK;
 615     }
 616
 617     raw_parse_flags(state->flags, &raw_s->open_flags);
 618
 619     raw_s->fd = -1;
 620
 621     int fcntl_flags = O_APPEND | O_NONBLOCK;
 622 #ifdef O_NOATIME
 623     fcntl_flags |= O_NOATIME;
 624 #endif
 625
 626 #ifdef O_ASYNC
 627     /* Not all operating systems have O_ASYNC, and those that don't
 628      * will not let us track the state into raw_s->open_flags (typically
 629      * you achieve the same effect with an ioctl, for example I_SETSIG
 630      * on Solaris). But we do not use O_ASYNC, so that's fine.
 631      */
 632     assert((s->open_flags & O_ASYNC) == 0);
 633 #endif
 634
 635     if ((raw_s->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
 636         /* dup the original fd */
 637         /* TODO: use qemu fcntl wrapper */
 638 #ifdef F_DUPFD_CLOEXEC
 639         raw_s->fd = fcntl(s->fd, F_DUPFD_CLOEXEC, 0);
 640 #else
 641         raw_s->fd = dup(s->fd);
 642         if (raw_s->fd != -1) {
 643             qemu_set_cloexec(raw_s->fd);
 644         }
 645 #endif
 646         if (raw_s->fd >= 0) {
 647             ret = fcntl_setfl(raw_s->fd, raw_s->open_flags);
 648             if (ret) {
 649                 qemu_close(raw_s->fd);
 650                 raw_s->fd = -1;
 651             }
 652         }
 653     }
 654
 655     /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
 656     if (raw_s->fd == -1) {
 657         assert(!(raw_s->open_flags & O_CREAT));
 658         raw_s->fd = qemu_open(state->bs->filename, raw_s->open_flags);
 659         if (raw_s->fd == -1) {
 660             error_setg_errno(errp, errno, "Could not reopen file");
 661             ret = -1;
 662         }
 663     }
 664
 665     /* Fail already reopen_prepare() if we can't get a working O_DIRECT
 666      * alignment with the new fd. */
 667     if (raw_s->fd != -1) {
 668         raw_probe_alignment(state->bs, raw_s->fd, &local_err);
 669         if (local_err) {
 670             qemu_close(raw_s->fd);
 671             raw_s->fd = -1;
 672             error_propagate(errp, local_err);
 673             ret = -EINVAL;
 674         }
 675     }
 676
 677     return ret;
 678 }
 679
 680 static void raw_reopen_commit(BDRVReopenState *state)
 681 {
 682     BDRVRawReopenState *raw_s = state->opaque;
 683     BDRVRawState *s = state->bs->opaque;
 684
 685     s->open_flags = raw_s->open_flags;
 686
 687     qemu_close(s->fd);
 688     s->fd = raw_s->fd;
 689 #ifdef CONFIG_LINUX_AIO
 690     s->use_aio = raw_s->use_aio;
 691 #endif
 692
 693     g_free(state->opaque);
 694     state->opaque = NULL;
 695 }
 696
 697
 698 static void raw_reopen_abort(BDRVReopenState *state)
 699 {
 700     BDRVRawReopenState *raw_s = state->opaque;
 701
 702      /* nothing to do if NULL, we didn't get far enough */
 703     if (raw_s == NULL) {
 704         return;
 705     }
 706
 707     if (raw_s->fd >= 0) {
 708         qemu_close(raw_s->fd);
 709         raw_s->fd = -1;
 710     }
 711     g_free(state->opaque);
 712     state->opaque = NULL;
 713 }
 714
 715 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
 716 {
 717     BDRVRawState *s = bs->opaque;
 718
 719     raw_probe_alignment(bs, s->fd, errp);
 720     bs->bl.opt_mem_alignment = s->buf_align;
 721 }
 722
 723 static int check_for_dasd(int fd)
 724 {
 725 #ifdef BIODASDINFO2
 726     struct dasd_information2_t info = {0};
 727
 728     return ioctl(fd, BIODASDINFO2, &info);
 729 #else
 730     return -1;
 731 #endif
 732 }
 733
 734 /**
 735  * Try to get @bs's logical and physical block size.
 736  * On success, store them in @bsz and return zero.
 737  * On failure, return negative errno.
 738  */
 739 static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
 740 {
 741     BDRVRawState *s = bs->opaque;
 742     int ret;
 743
 744     /* If DASD, get blocksizes */
 745     if (check_for_dasd(s->fd) < 0) {
 746         return -ENOTSUP;
 747     }
 748     ret = probe_logical_blocksize(s->fd, &bsz->log);
 749     if (ret < 0) {
 750         return ret;
 751     }
 752     return probe_physical_blocksize(s->fd, &bsz->phys);
 753 }
 754
 755 /**
 756  * Try to get @bs's geometry: cyls, heads, sectors.
 757  * On success, store them in @geo and return 0.
 758  * On failure return -errno.
 759  * (Allows block driver to assign default geometry values that guest sees)
 760  */
 761 #ifdef __linux__
 762 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
 763 {
 764     BDRVRawState *s = bs->opaque;
 765     struct hd_geometry ioctl_geo = {0};
 766     uint32_t blksize;
 767
 768     /* If DASD, get its geometry */
 769     if (check_for_dasd(s->fd) < 0) {
 770         return -ENOTSUP;
 771     }
 772     if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
 773         return -errno;
 774     }
 775     /* HDIO_GETGEO may return success even though geo contains zeros
 776        (e.g. certain multipath setups) */
 777     if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
 778         return -ENOTSUP;
 779     }
 780     /* Do not return a geometry for partition */
 781     if (ioctl_geo.start != 0) {
 782         return -ENOTSUP;
 783     }
 784     geo->heads = ioctl_geo.heads;
 785     geo->sectors = ioctl_geo.sectors;
 786     if (!probe_physical_blocksize(s->fd, &blksize)) {
 787         /* overwrite cyls: HDIO_GETGEO result is incorrect for big drives */
 788         geo->cylinders = bdrv_nb_sectors(bs) / (blksize / BDRV_SECTOR_SIZE)
 789                                              / (geo->heads * geo->sectors);
 790         return 0;
 791     }
 792     geo->cylinders = ioctl_geo.cylinders;
 793
 794     return 0;
 795 }
 796 #else /* __linux__ */
 797 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
 798 {
 799     return -ENOTSUP;
 800 }
 801 #endif
 802
 803 static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb)
 804 {
 805     int ret;
 806
 807     ret = ioctl(aiocb->aio_fildes, aiocb->aio_ioctl_cmd, aiocb->aio_ioctl_buf);
 808     if (ret == -1) {
 809         return -errno;
 810     }
 811
 812     return 0;
 813 }
 814
 815 static ssize_t handle_aiocb_flush(RawPosixAIOData *aiocb)
 816 {
 817     int ret;
 818
 819     ret = qemu_fdatasync(aiocb->aio_fildes);
 820     if (ret == -1) {
 821         return -errno;
 822     }
 823     return 0;
 824 }
 825
 826 #ifdef CONFIG_PREADV
 827
 828 static bool preadv_present = true;
 829
 830 static ssize_t
 831 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
 832 {
 833     return preadv(fd, iov, nr_iov, offset);
 834 }
 835
 836 static ssize_t
 837 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
 838 {
 839     return pwritev(fd, iov, nr_iov, offset);
 840 }
 841
 842 #else
 843
 844 static bool preadv_present = false;
 845
 846 static ssize_t
 847 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
 848 {
 849     return -ENOSYS;
 850 }
 851
 852 static ssize_t
 853 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
 854 {
 855     return -ENOSYS;
 856 }
 857
 858 #endif
 859
 860 static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
 861 {
 862     ssize_t len;
 863
 864     do {
 865         if (aiocb->aio_type & QEMU_AIO_WRITE)
 866             len = qemu_pwritev(aiocb->aio_fildes,
 867                                aiocb->aio_iov,
 868                                aiocb->aio_niov,
 869                                aiocb->aio_offset);
 870          else
 871             len = qemu_preadv(aiocb->aio_fildes,
 872                               aiocb->aio_iov,
 873                               aiocb->aio_niov,
 874                               aiocb->aio_offset);
 875     } while (len == -1 && errno == EINTR);
 876
 877     if (len == -1) {
 878         return -errno;
 879     }
 880     return len;
 881 }
 882
 883 /*
 884  * Read/writes the data to/from a given linear buffer.
 885  *
 886  * Returns the number of bytes handles or -errno in case of an error. Short
 887  * reads are only returned if the end of the file is reached.
 888  */
 889 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
 890 {
 891     ssize_t offset = 0;
 892     ssize_t len;
 893
 894     while (offset < aiocb->aio_nbytes) {
 895         if (aiocb->aio_type & QEMU_AIO_WRITE) {
 896             len = pwrite(aiocb->aio_fildes,
 897                          (const char *)buf + offset,
 898                          aiocb->aio_nbytes - offset,
 899                          aiocb->aio_offset + offset);
 900         } else {
 901             len = pread(aiocb->aio_fildes,
 902                         buf + offset,
 903                         aiocb->aio_nbytes - offset,
 904                         aiocb->aio_offset + offset);
 905         }
 906         if (len == -1 && errno == EINTR) {
 907             continue;
 908         } else if (len == -1 && errno == EINVAL &&
 909                    (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
 910                    !(aiocb->aio_type & QEMU_AIO_WRITE) &&
 911                    offset > 0) {
 912             /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
 913              * after a short read.  Assume that O_DIRECT short reads only occur
 914              * at EOF.  Therefore this is a short read, not an I/O error.
 915              */
 916             break;
 917         } else if (len == -1) {
 918             offset = -errno;
 919             break;
 920         } else if (len == 0) {
 921             break;
 922         }
 923         offset += len;
 924     }
 925
 926     return offset;
 927 }
 928
 929 static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
 930 {
 931     ssize_t nbytes;
 932     char *buf;
 933
 934     if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
 935         /*
 936          * If there is just a single buffer, and it is properly aligned
 937          * we can just use plain pread/pwrite without any problems.
 938          */
 939         if (aiocb->aio_niov == 1) {
 940              return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base);
 941         }
 942         /*
 943          * We have more than one iovec, and all are properly aligned.
 944          *
 945          * Try preadv/pwritev first and fall back to linearizing the
 946          * buffer if it's not supported.
 947          */
 948         if (preadv_present) {
 949             nbytes = handle_aiocb_rw_vector(aiocb);
 950             if (nbytes == aiocb->aio_nbytes ||
 951                 (nbytes < 0 && nbytes != -ENOSYS)) {
 952                 return nbytes;
 953             }
 954             preadv_present = false;
 955         }
 956
 957         /*
 958          * XXX(hch): short read/write.  no easy way to handle the reminder
 959          * using these interfaces.  For now retry using plain
 960          * pread/pwrite?
 961          */
 962     }
 963
 964     /*
 965      * Ok, we have to do it the hard way, copy all segments into
 966      * a single aligned buffer.
 967      */
 968     buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
 969     if (buf == NULL) {
 970         return -ENOMEM;
 971     }
 972
 973     if (aiocb->aio_type & QEMU_AIO_WRITE) {
 974         char *p = buf;
 975         int i;
 976
 977         for (i = 0; i < aiocb->aio_niov; ++i) {
 978             memcpy(p, aiocb->aio_iov[i].iov_base, aiocb->aio_iov[i].iov_len);
 979             p += aiocb->aio_iov[i].iov_len;
 980         }
 981         assert(p - buf == aiocb->aio_nbytes);
 982     }
 983
 984     nbytes = handle_aiocb_rw_linear(aiocb, buf);
 985     if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
 986         char *p = buf;
 987         size_t count = aiocb->aio_nbytes, copy;
 988         int i;
 989
 990         for (i = 0; i < aiocb->aio_niov && count; ++i) {
 991             copy = count;
 992             if (copy > aiocb->aio_iov[i].iov_len) {
 993                 copy = aiocb->aio_iov[i].iov_len;
 994             }
 995             memcpy(aiocb->aio_iov[i].iov_base, p, copy);
 996             assert(count >= copy);
 997             p     += copy;
 998             count -= copy;
 999         }
1000         assert(count == 0);
1001     }
1002     qemu_vfree(buf);
1003
1004     return nbytes;
1005 }
1006
1007 #ifdef CONFIG_XFS
1008 static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes)
1009 {
1010     struct xfs_flock64 fl;
1011
1012     memset(&fl, 0, sizeof(fl));
1013     fl.l_whence = SEEK_SET;
1014     fl.l_start = offset;
1015     fl.l_len = bytes;
1016
1017     if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) {
1018         DEBUG_BLOCK_PRINT("cannot write zero range (%s)\n", strerror(errno));
1019         return -errno;
1020     }
1021
1022     return 0;
1023 }
1024
1025 static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes)
1026 {
1027     struct xfs_flock64 fl;
1028
1029     memset(&fl, 0, sizeof(fl));
1030     fl.l_whence = SEEK_SET;
1031     fl.l_start = offset;
1032     fl.l_len = bytes;
1033
1034     if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {
1035         DEBUG_BLOCK_PRINT("cannot punch hole (%s)\n", strerror(errno));
1036         return -errno;
1037     }
1038
1039     return 0;
1040 }
1041 #endif
1042
1043 static int translate_err(int err)
1044 {
1045     if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1046         err == -ENOTTY) {
1047         err = -ENOTSUP;
1048     }
1049     return err;
1050 }
1051
1052 #ifdef CONFIG_FALLOCATE
1053 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1054 {
1055     do {
1056         if (fallocate(fd, mode, offset, len) == 0) {
1057             return 0;
1058         }
1059     } while (errno == EINTR);
1060     return translate_err(-errno);
1061 }
1062 #endif
1063
1064 static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1065 {
1066     int ret = -ENOTSUP;
1067     BDRVRawState *s = aiocb->bs->opaque;
1068
1069     if (!s->has_write_zeroes) {
1070         return -ENOTSUP;
1071     }
1072
1073 #ifdef BLKZEROOUT
1074     do {
1075         uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1076         if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1077             return 0;
1078         }
1079     } while (errno == EINTR);
1080
1081     ret = translate_err(-errno);
1082 #endif
1083
1084     if (ret == -ENOTSUP) {
1085         s->has_write_zeroes = false;
1086     }
1087     return ret;
1088 }
1089
1090 static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb)
1091 {
1092 #if defined(CONFIG_FALLOCATE) || defined(CONFIG_XFS)
1093     BDRVRawState *s = aiocb->bs->opaque;
1094 #endif
1095
1096     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1097         return handle_aiocb_write_zeroes_block(aiocb);
1098     }
1099
1100 #ifdef CONFIG_XFS
1101     if (s->is_xfs) {
1102         return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes);
1103     }
1104 #endif
1105
1106 #ifdef CONFIG_FALLOCATE_ZERO_RANGE
1107     if (s->has_write_zeroes) {
1108         int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1109                                aiocb->aio_offset, aiocb->aio_nbytes);
1110         if (ret == 0 || ret != -ENOTSUP) {
1111             return ret;
1112         }
1113         s->has_write_zeroes = false;
1114     }
1115 #endif
1116
1117 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1118     if (s->has_discard && s->has_fallocate) {
1119         int ret = do_fallocate(s->fd,
1120                                FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1121                                aiocb->aio_offset, aiocb->aio_nbytes);
1122         if (ret == 0) {
1123             ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1124             if (ret == 0 || ret != -ENOTSUP) {
1125                 return ret;
1126             }
1127             s->has_fallocate = false;
1128         } else if (ret != -ENOTSUP) {
1129             return ret;
1130         } else {
1131             s->has_discard = false;
1132         }
1133     }
1134 #endif
1135
1136 #ifdef CONFIG_FALLOCATE
1137     if (s->has_fallocate && aiocb->aio_offset >= bdrv_getlength(aiocb->bs)) {
1138         int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1139         if (ret == 0 || ret != -ENOTSUP) {
1140             return ret;
1141         }
1142         s->has_fallocate = false;
1143     }
1144 #endif
1145
1146     return -ENOTSUP;
1147 }
1148
1149 static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb)
1150 {
1151     int ret = -EOPNOTSUPP;
1152     BDRVRawState *s = aiocb->bs->opaque;
1153
1154     if (!s->has_discard) {
1155         return -ENOTSUP;
1156     }
1157
1158     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1159 #ifdef BLKDISCARD
1160         do {
1161             uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1162             if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1163                 return 0;
1164             }
1165         } while (errno == EINTR);
1166
1167         ret = -errno;
1168 #endif
1169     } else {
1170 #ifdef CONFIG_XFS
1171         if (s->is_xfs) {
1172             return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1173         }
1174 #endif
1175
1176 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1177         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1178                            aiocb->aio_offset, aiocb->aio_nbytes);
1179 #endif
1180     }
1181
1182     ret = translate_err(ret);
1183     if (ret == -ENOTSUP) {
1184         s->has_discard = false;
1185     }
1186     return ret;
1187 }
1188
1189 static int aio_worker(void *arg)
1190 {
1191     RawPosixAIOData *aiocb = arg;
1192     ssize_t ret = 0;
1193
1194     switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
1195     case QEMU_AIO_READ:
1196         ret = handle_aiocb_rw(aiocb);
1197         if (ret >= 0 && ret < aiocb->aio_nbytes) {
1198             iov_memset(aiocb->aio_iov, aiocb->aio_niov, ret,
1199                       0, aiocb->aio_nbytes - ret);
1200
1201             ret = aiocb->aio_nbytes;
1202         }
1203         if (ret == aiocb->aio_nbytes) {
1204             ret = 0;
1205         } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1206             ret = -EINVAL;
1207         }
1208         break;
1209     case QEMU_AIO_WRITE:
1210         ret = handle_aiocb_rw(aiocb);
1211         if (ret == aiocb->aio_nbytes) {
1212             ret = 0;
1213         } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1214             ret = -EINVAL;
1215         }
1216         break;
1217     case QEMU_AIO_FLUSH:
1218         ret = handle_aiocb_flush(aiocb);
1219         break;
1220     case QEMU_AIO_IOCTL:
1221         ret = handle_aiocb_ioctl(aiocb);
1222         break;
1223     case QEMU_AIO_DISCARD:
1224         ret = handle_aiocb_discard(aiocb);
1225         break;
1226     case QEMU_AIO_WRITE_ZEROES:
1227         ret = handle_aiocb_write_zeroes(aiocb);
1228         break;
1229     default:
1230         fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
1231         ret = -EINVAL;
1232         break;
1233     }
1234
1235     g_slice_free(RawPosixAIOData, aiocb);
1236     return ret;
1237 }
1238
1239 static int paio_submit_co(BlockDriverState *bs, int fd,
1240         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1241         int type)
1242 {
1243     RawPosixAIOData *acb = g_slice_new(RawPosixAIOData);
1244     ThreadPool *pool;
1245
1246     acb->bs = bs;
1247     acb->aio_type = type;
1248     acb->aio_fildes = fd;
1249
1250     acb->aio_nbytes = nb_sectors * BDRV_SECTOR_SIZE;
1251     acb->aio_offset = sector_num * BDRV_SECTOR_SIZE;
1252
1253     if (qiov) {
1254         acb->aio_iov = qiov->iov;
1255         acb->aio_niov = qiov->niov;
1256         assert(qiov->size == acb->aio_nbytes);
1257     }
1258
1259     trace_paio_submit_co(sector_num, nb_sectors, type);
1260     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1261     return thread_pool_submit_co(pool, aio_worker, acb);
1262 }
1263
1264 static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd,
1265         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1266         BlockCompletionFunc *cb, void *opaque, int type)
1267 {
1268     RawPosixAIOData *acb = g_slice_new(RawPosixAIOData);
1269     ThreadPool *pool;
1270
1271     acb->bs = bs;
1272     acb->aio_type = type;
1273     acb->aio_fildes = fd;
1274
1275     acb->aio_nbytes = nb_sectors * BDRV_SECTOR_SIZE;
1276     acb->aio_offset = sector_num * BDRV_SECTOR_SIZE;
1277
1278     if (qiov) {
1279         acb->aio_iov = qiov->iov;
1280         acb->aio_niov = qiov->niov;
1281         assert(qiov->size == acb->aio_nbytes);
1282     }
1283
1284     trace_paio_submit(acb, opaque, sector_num, nb_sectors, type);
1285     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1286     return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
1287 }
1288
1289 static BlockAIOCB *raw_aio_submit(BlockDriverState *bs,
1290         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1291         BlockCompletionFunc *cb, void *opaque, int type)
1292 {
1293     BDRVRawState *s = bs->opaque;
1294
1295     if (fd_open(bs) < 0)
1296         return NULL;
1297
1298     /*
1299      * Check if the underlying device requires requests to be aligned,
1300      * and if the request we are trying to submit is aligned or not.
1301      * If this is the case tell the low-level driver that it needs
1302      * to copy the buffer.
1303      */
1304     if (s->needs_alignment) {
1305         if (!bdrv_qiov_is_aligned(bs, qiov)) {
1306             type |= QEMU_AIO_MISALIGNED;
1307 #ifdef CONFIG_LINUX_AIO
1308         } else if (s->use_aio) {
1309             return laio_submit(bs, s->aio_ctx, s->fd, sector_num, qiov,
1310                                nb_sectors, cb, opaque, type);
1311 #endif
1312         }
1313     }
1314
1315     return paio_submit(bs, s->fd, sector_num, qiov, nb_sectors,
1316                        cb, opaque, type);
1317 }
1318
1319 static void raw_aio_plug(BlockDriverState *bs)
1320 {
1321 #ifdef CONFIG_LINUX_AIO
1322     BDRVRawState *s = bs->opaque;
1323     if (s->use_aio) {
1324         laio_io_plug(bs, s->aio_ctx);
1325     }
1326 #endif
1327 }
1328
1329 static void raw_aio_unplug(BlockDriverState *bs)
1330 {
1331 #ifdef CONFIG_LINUX_AIO
1332     BDRVRawState *s = bs->opaque;
1333     if (s->use_aio) {
1334         laio_io_unplug(bs, s->aio_ctx, true);
1335     }
1336 #endif
1337 }
1338
1339 static void raw_aio_flush_io_queue(BlockDriverState *bs)
1340 {
1341 #ifdef CONFIG_LINUX_AIO
1342     BDRVRawState *s = bs->opaque;
1343     if (s->use_aio) {
1344         laio_io_unplug(bs, s->aio_ctx, false);
1345     }
1346 #endif
1347 }
1348
1349 static BlockAIOCB *raw_aio_readv(BlockDriverState *bs,
1350         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1351         BlockCompletionFunc *cb, void *opaque)
1352 {
1353     return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
1354                           cb, opaque, QEMU_AIO_READ);
1355 }
1356
1357 static BlockAIOCB *raw_aio_writev(BlockDriverState *bs,
1358         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1359         BlockCompletionFunc *cb, void *opaque)
1360 {
1361     return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
1362                           cb, opaque, QEMU_AIO_WRITE);
1363 }
1364
1365 static BlockAIOCB *raw_aio_flush(BlockDriverState *bs,
1366         BlockCompletionFunc *cb, void *opaque)
1367 {
1368     BDRVRawState *s = bs->opaque;
1369
1370     if (fd_open(bs) < 0)
1371         return NULL;
1372
1373     return paio_submit(bs, s->fd, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
1374 }
1375
1376 static void raw_close(BlockDriverState *bs)
1377 {
1378     BDRVRawState *s = bs->opaque;
1379
1380     raw_detach_aio_context(bs);
1381
1382 #ifdef CONFIG_LINUX_AIO
1383     if (s->use_aio) {
1384         laio_cleanup(s->aio_ctx);
1385     }
1386 #endif
1387     if (s->fd >= 0) {
1388         qemu_close(s->fd);
1389         s->fd = -1;
1390     }
1391 }
1392
1393 static int raw_truncate(BlockDriverState *bs, int64_t offset)
1394 {
1395     BDRVRawState *s = bs->opaque;
1396     struct stat st;
1397
1398     if (fstat(s->fd, &st)) {
1399         return -errno;
1400     }
1401
1402     if (S_ISREG(st.st_mode)) {
1403         if (ftruncate(s->fd, offset) < 0) {
1404             return -errno;
1405         }
1406     } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1407        if (offset > raw_getlength(bs)) {
1408            return -EINVAL;
1409        }
1410     } else {
1411         return -ENOTSUP;
1412     }
1413
1414     return 0;
1415 }
1416
1417 #ifdef __OpenBSD__
1418 static int64_t raw_getlength(BlockDriverState *bs)
1419 {
1420     BDRVRawState *s = bs->opaque;
1421     int fd = s->fd;
1422     struct stat st;
1423
1424     if (fstat(fd, &st))
1425         return -errno;
1426     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1427         struct disklabel dl;
1428
1429         if (ioctl(fd, DIOCGDINFO, &dl))
1430             return -errno;
1431         return (uint64_t)dl.d_secsize *
1432             dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1433     } else
1434         return st.st_size;
1435 }
1436 #elif defined(__NetBSD__)
1437 static int64_t raw_getlength(BlockDriverState *bs)
1438 {
1439     BDRVRawState *s = bs->opaque;
1440     int fd = s->fd;
1441     struct stat st;
1442
1443     if (fstat(fd, &st))
1444         return -errno;
1445     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1446         struct dkwedge_info dkw;
1447
1448         if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
1449             return dkw.dkw_size * 512;
1450         } else {
1451             struct disklabel dl;
1452
1453             if (ioctl(fd, DIOCGDINFO, &dl))
1454                 return -errno;
1455             return (uint64_t)dl.d_secsize *
1456                 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1457         }
1458     } else
1459         return st.st_size;
1460 }
1461 #elif defined(__sun__)
1462 static int64_t raw_getlength(BlockDriverState *bs)
1463 {
1464     BDRVRawState *s = bs->opaque;
1465     struct dk_minfo minfo;
1466     int ret;
1467     int64_t size;
1468
1469     ret = fd_open(bs);
1470     if (ret < 0) {
1471         return ret;
1472     }
1473
1474     /*
1475      * Use the DKIOCGMEDIAINFO ioctl to read the size.
1476      */
1477     ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
1478     if (ret != -1) {
1479         return minfo.dki_lbsize * minfo.dki_capacity;
1480     }
1481
1482     /*
1483      * There are reports that lseek on some devices fails, but
1484      * irc discussion said that contingency on contingency was overkill.
1485      */
1486     size = lseek(s->fd, 0, SEEK_END);
1487     if (size < 0) {
1488         return -errno;
1489     }
1490     return size;
1491 }
1492 #elif defined(CONFIG_BSD)
1493 static int64_t raw_getlength(BlockDriverState *bs)
1494 {
1495     BDRVRawState *s = bs->opaque;
1496     int fd = s->fd;
1497     int64_t size;
1498     struct stat sb;
1499 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1500     int reopened = 0;
1501 #endif
1502     int ret;
1503
1504     ret = fd_open(bs);
1505     if (ret < 0)
1506         return ret;
1507
1508 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
1509 again:
1510 #endif
1511     if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
1512 #ifdef DIOCGMEDIASIZE
1513         if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
1514 #elif defined(DIOCGPART)
1515         {
1516                 struct partinfo pi;
1517                 if (ioctl(fd, DIOCGPART, &pi) == 0)
1518                         size = pi.media_size;
1519                 else
1520                         size = 0;
1521         }
1522         if (size == 0)
1523 #endif
1524 #if defined(__APPLE__) && defined(__MACH__)
1525         {
1526             uint64_t sectors = 0;
1527             uint32_t sector_size = 0;
1528
1529             if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
1530                && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
1531                 size = sectors * sector_size;
1532             } else {
1533                 size = lseek(fd, 0LL, SEEK_END);
1534                 if (size < 0) {
1535                     return -errno;
1536                 }
1537             }
1538         }
1539 #else
1540         size = lseek(fd, 0LL, SEEK_END);
1541         if (size < 0) {
1542             return -errno;
1543         }
1544 #endif
1545 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1546         switch(s->type) {
1547         case FTYPE_CD:
1548             /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
1549             if (size == 2048LL * (unsigned)-1)
1550                 size = 0;
1551             /* XXX no disc?  maybe we need to reopen... */
1552             if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
1553                 reopened = 1;
1554                 goto again;
1555             }
1556         }
1557 #endif
1558     } else {
1559         size = lseek(fd, 0, SEEK_END);
1560         if (size < 0) {
1561             return -errno;
1562         }
1563     }
1564     return size;
1565 }
1566 #else
1567 static int64_t raw_getlength(BlockDriverState *bs)
1568 {
1569     BDRVRawState *s = bs->opaque;
1570     int ret;
1571     int64_t size;
1572
1573     ret = fd_open(bs);
1574     if (ret < 0) {
1575         return ret;
1576     }
1577
1578     size = lseek(s->fd, 0, SEEK_END);
1579     if (size < 0) {
1580         return -errno;
1581     }
1582     return size;
1583 }
1584 #endif
1585
1586 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
1587 {
1588     struct stat st;
1589     BDRVRawState *s = bs->opaque;
1590
1591     if (fstat(s->fd, &st) < 0) {
1592         return -errno;
1593     }
1594     return (int64_t)st.st_blocks * 512;
1595 }
1596
1597 static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
1598 {
1599     int fd;
1600     int result = 0;
1601     int64_t total_size = 0;
1602     bool nocow = false;
1603     PreallocMode prealloc;
1604     char *buf = NULL;
1605     Error *local_err = NULL;
1606
1607     strstart(filename, "file:", &filename);
1608
1609     /* Read out options */
1610     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
1611                           BDRV_SECTOR_SIZE);
1612     nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
1613     buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
1614     prealloc = qapi_enum_parse(PreallocMode_lookup, buf,
1615                                PREALLOC_MODE_MAX, PREALLOC_MODE_OFF,
1616                                &local_err);
1617     g_free(buf);
1618     if (local_err) {
1619         error_propagate(errp, local_err);
1620         result = -EINVAL;
1621         goto out;
1622     }
1623
1624     fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
1625                    0644);
1626     if (fd < 0) {
1627         result = -errno;
1628         error_setg_errno(errp, -result, "Could not create file");
1629         goto out;
1630     }
1631
1632     if (nocow) {
1633 #ifdef __linux__
1634         /* Set NOCOW flag to solve performance issue on fs like btrfs.
1635          * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
1636          * will be ignored since any failure of this operation should not
1637          * block the left work.
1638          */
1639         int attr;
1640         if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
1641             attr |= FS_NOCOW_FL;
1642             ioctl(fd, FS_IOC_SETFLAGS, &attr);
1643         }
1644 #endif
1645     }
1646
1647     if (ftruncate(fd, total_size) != 0) {
1648         result = -errno;
1649         error_setg_errno(errp, -result, "Could not resize file");
1650         goto out_close;
1651     }
1652
1653     switch (prealloc) {
1654 #ifdef CONFIG_POSIX_FALLOCATE
1655     case PREALLOC_MODE_FALLOC:
1656         /* posix_fallocate() doesn't set errno. */
1657         result = -posix_fallocate(fd, 0, total_size);
1658         if (result != 0) {
1659             error_setg_errno(errp, -result,
1660                              "Could not preallocate data for the new file");
1661         }
1662         break;
1663 #endif
1664     case PREALLOC_MODE_FULL:
1665     {
1666         int64_t num = 0, left = total_size;
1667         buf = g_malloc0(65536);
1668
1669         while (left > 0) {
1670             num = MIN(left, 65536);
1671             result = write(fd, buf, num);
1672             if (result < 0) {
1673                 result = -errno;
1674                 error_setg_errno(errp, -result,
1675                                  "Could not write to the new file");
1676                 break;
1677             }
1678             left -= result;
1679         }
1680         if (result >= 0) {
1681             result = fsync(fd);
1682             if (result < 0) {
1683                 result = -errno;
1684                 error_setg_errno(errp, -result,
1685                                  "Could not flush new file to disk");
1686             }
1687         }
1688         g_free(buf);
1689         break;
1690     }
1691     case PREALLOC_MODE_OFF:
1692         break;
1693     default:
1694         result = -EINVAL;
1695         error_setg(errp, "Unsupported preallocation mode: %s",
1696                    PreallocMode_lookup[prealloc]);
1697         break;
1698     }
1699
1700 out_close:
1701     if (qemu_close(fd) != 0 && result == 0) {
1702         result = -errno;
1703         error_setg_errno(errp, -result, "Could not close the new file");
1704     }
1705 out:
1706     return result;
1707 }
1708
1709 /*
1710  * Find allocation range in @bs around offset @start.
1711  * May change underlying file descriptor's file offset.
1712  * If @start is not in a hole, store @start in @data, and the
1713  * beginning of the next hole in @hole, and return 0.
1714  * If @start is in a non-trailing hole, store @start in @hole and the
1715  * beginning of the next non-hole in @data, and return 0.
1716  * If @start is in a trailing hole or beyond EOF, return -ENXIO.
1717  * If we can't find out, return a negative errno other than -ENXIO.
1718  */
1719 static int find_allocation(BlockDriverState *bs, off_t start,
1720                            off_t *data, off_t *hole)
1721 {
1722 #if defined SEEK_HOLE && defined SEEK_DATA
1723     BDRVRawState *s = bs->opaque;
1724     off_t offs;
1725
1726     /*
1727      * SEEK_DATA cases:
1728      * D1. offs == start: start is in data
1729      * D2. offs > start: start is in a hole, next data at offs
1730      * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
1731      *                              or start is beyond EOF
1732      *     If the latter happens, the file has been truncated behind
1733      *     our back since we opened it.  All bets are off then.
1734      *     Treating like a trailing hole is simplest.
1735      * D4. offs < 0, errno != ENXIO: we learned nothing
1736      */
1737     offs = lseek(s->fd, start, SEEK_DATA);
1738     if (offs < 0) {
1739         return -errno;          /* D3 or D4 */
1740     }
1741     assert(offs >= start);
1742
1743     if (offs > start) {
1744         /* D2: in hole, next data at offs */
1745         *hole = start;
1746         *data = offs;
1747         return 0;
1748     }
1749
1750     /* D1: in data, end not yet known */
1751
1752     /*
1753      * SEEK_HOLE cases:
1754      * H1. offs == start: start is in a hole
1755      *     If this happens here, a hole has been dug behind our back
1756      *     since the previous lseek().
1757      * H2. offs > start: either start is in data, next hole at offs,
1758      *                   or start is in trailing hole, EOF at offs
1759      *     Linux treats trailing holes like any other hole: offs ==
1760      *     start.  Solaris seeks to EOF instead: offs > start (blech).
1761      *     If that happens here, a hole has been dug behind our back
1762      *     since the previous lseek().
1763      * H3. offs < 0, errno = ENXIO: start is beyond EOF
1764      *     If this happens, the file has been truncated behind our
1765      *     back since we opened it.  Treat it like a trailing hole.
1766      * H4. offs < 0, errno != ENXIO: we learned nothing
1767      *     Pretend we know nothing at all, i.e. "forget" about D1.
1768      */
1769     offs = lseek(s->fd, start, SEEK_HOLE);
1770     if (offs < 0) {
1771         return -errno;          /* D1 and (H3 or H4) */
1772     }
1773     assert(offs >= start);
1774
1775     if (offs > start) {
1776         /*
1777          * D1 and H2: either in data, next hole at offs, or it was in
1778          * data but is now in a trailing hole.  In the latter case,
1779          * all bets are off.  Treating it as if it there was data all
1780          * the way to EOF is safe, so simply do that.
1781          */
1782         *data = start;
1783         *hole = offs;
1784         return 0;
1785     }
1786
1787     /* D1 and H1 */
1788     return -EBUSY;
1789 #else
1790     return -ENOTSUP;
1791 #endif
1792 }
1793
1794 /*
1795  * Returns the allocation status of the specified sectors.
1796  *
1797  * If 'sector_num' is beyond the end of the disk image the return value is 0
1798  * and 'pnum' is set to 0.
1799  *
1800  * 'pnum' is set to the number of sectors (including and immediately following
1801  * the specified sector) that are known to be in the same
1802  * allocated/unallocated state.
1803  *
1804  * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
1805  * beyond the end of the disk image it will be clamped.
1806  */
1807 static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
1808                                                     int64_t sector_num,
1809                                                     int nb_sectors, int *pnum)
1810 {
1811     off_t start, data = 0, hole = 0;
1812     int64_t total_size;
1813     int ret;
1814
1815     ret = fd_open(bs);
1816     if (ret < 0) {
1817         return ret;
1818     }
1819
1820     start = sector_num * BDRV_SECTOR_SIZE;
1821     total_size = bdrv_getlength(bs);
1822     if (total_size < 0) {
1823         return total_size;
1824     } else if (start >= total_size) {
1825         *pnum = 0;
1826         return 0;
1827     } else if (start + nb_sectors * BDRV_SECTOR_SIZE > total_size) {
1828         nb_sectors = DIV_ROUND_UP(total_size - start, BDRV_SECTOR_SIZE);
1829     }
1830
1831     ret = find_allocation(bs, start, &data, &hole);
1832     if (ret == -ENXIO) {
1833         /* Trailing hole */
1834         *pnum = nb_sectors;
1835         ret = BDRV_BLOCK_ZERO;
1836     } else if (ret < 0) {
1837         /* No info available, so pretend there are no holes */
1838         *pnum = nb_sectors;
1839         ret = BDRV_BLOCK_DATA;
1840     } else if (data == start) {
1841         /* On a data extent, compute sectors to the end of the extent.  */
1842         *pnum = MIN(nb_sectors, (hole - start) / BDRV_SECTOR_SIZE);
1843         ret = BDRV_BLOCK_DATA;
1844     } else {
1845         /* On a hole, compute sectors to the beginning of the next extent.  */
1846         assert(hole == start);
1847         *pnum = MIN(nb_sectors, (data - start) / BDRV_SECTOR_SIZE);
1848         ret = BDRV_BLOCK_ZERO;
1849     }
1850     return ret | BDRV_BLOCK_OFFSET_VALID | start;
1851 }
1852
1853 static coroutine_fn BlockAIOCB *raw_aio_discard(BlockDriverState *bs,
1854     int64_t sector_num, int nb_sectors,
1855     BlockCompletionFunc *cb, void *opaque)
1856 {
1857     BDRVRawState *s = bs->opaque;
1858
1859     return paio_submit(bs, s->fd, sector_num, NULL, nb_sectors,
1860                        cb, opaque, QEMU_AIO_DISCARD);
1861 }
1862
1863 static int coroutine_fn raw_co_write_zeroes(
1864     BlockDriverState *bs, int64_t sector_num,
1865     int nb_sectors, BdrvRequestFlags flags)
1866 {
1867     BDRVRawState *s = bs->opaque;
1868
1869     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
1870         return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1871                               QEMU_AIO_WRITE_ZEROES);
1872     } else if (s->discard_zeroes) {
1873         return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
1874                               QEMU_AIO_DISCARD);
1875     }
1876     return -ENOTSUP;
1877 }
1878
1879 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
1880 {
1881     BDRVRawState *s = bs->opaque;
1882
1883     bdi->unallocated_blocks_are_zero = s->discard_zeroes;
1884     bdi->can_write_zeroes_with_unmap = s->discard_zeroes;
1885     return 0;
1886 }
1887
1888 static QemuOptsList raw_create_opts = {
1889     .name = "raw-create-opts",
1890     .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
1891     .desc = {
1892         {
1893             .name = BLOCK_OPT_SIZE,
1894             .type = QEMU_OPT_SIZE,
1895             .help = "Virtual disk size"
1896         },
1897         {
1898             .name = BLOCK_OPT_NOCOW,
1899             .type = QEMU_OPT_BOOL,
1900             .help = "Turn off copy-on-write (valid only on btrfs)"
1901         },
1902         {
1903             .name = BLOCK_OPT_PREALLOC,
1904             .type = QEMU_OPT_STRING,
1905             .help = "Preallocation mode (allowed values: off, falloc, full)"
1906         },
1907         { /* end of list */ }
1908     }
1909 };
1910
1911 BlockDriver bdrv_file = {
1912     .format_name = "file",
1913     .protocol_name = "file",
1914     .instance_size = sizeof(BDRVRawState),
1915     .bdrv_needs_filename = true,
1916     .bdrv_probe = NULL, /* no probe for protocols */
1917     .bdrv_parse_filename = raw_parse_filename,
1918     .bdrv_file_open = raw_open,
1919     .bdrv_reopen_prepare = raw_reopen_prepare,
1920     .bdrv_reopen_commit = raw_reopen_commit,
1921     .bdrv_reopen_abort = raw_reopen_abort,
1922     .bdrv_close = raw_close,
1923     .bdrv_create = raw_create,
1924     .bdrv_has_zero_init = bdrv_has_zero_init_1,
1925     .bdrv_co_get_block_status = raw_co_get_block_status,
1926     .bdrv_co_write_zeroes = raw_co_write_zeroes,
1927
1928     .bdrv_aio_readv = raw_aio_readv,
1929     .bdrv_aio_writev = raw_aio_writev,
1930     .bdrv_aio_flush = raw_aio_flush,
1931     .bdrv_aio_discard = raw_aio_discard,
1932     .bdrv_refresh_limits = raw_refresh_limits,
1933     .bdrv_io_plug = raw_aio_plug,
1934     .bdrv_io_unplug = raw_aio_unplug,
1935     .bdrv_flush_io_queue = raw_aio_flush_io_queue,
1936
1937     .bdrv_truncate = raw_truncate,
1938     .bdrv_getlength = raw_getlength,
1939     .bdrv_get_info = raw_get_info,
1940     .bdrv_get_allocated_file_size
1941                         = raw_get_allocated_file_size,
1942
1943     .bdrv_detach_aio_context = raw_detach_aio_context,
1944     .bdrv_attach_aio_context = raw_attach_aio_context,
1945
1946     .create_opts = &raw_create_opts,
1947 };
1948
1949 /***********************************************/
1950 /* host device */
1951
1952 #if defined(__APPLE__) && defined(__MACH__)
1953 static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator );
1954 static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize );
1955
1956 kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
1957 {
1958     kern_return_t       kernResult;
1959     mach_port_t     masterPort;
1960     CFMutableDictionaryRef  classesToMatch;
1961
1962     kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
1963     if ( KERN_SUCCESS != kernResult ) {
1964         printf( "IOMasterPort returned %d\n", kernResult );
1965     }
1966
1967     classesToMatch = IOServiceMatching( kIOCDMediaClass );
1968     if ( classesToMatch == NULL ) {
1969         printf( "IOServiceMatching returned a NULL dictionary.\n" );
1970     } else {
1971     CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue );
1972     }
1973     kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator );
1974     if ( KERN_SUCCESS != kernResult )
1975     {
1976         printf( "IOServiceGetMatchingServices returned %d\n", kernResult );
1977     }
1978
1979     return kernResult;
1980 }
1981
1982 kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize )
1983 {
1984     io_object_t     nextMedia;
1985     kern_return_t   kernResult = KERN_FAILURE;
1986     *bsdPath = '\0';
1987     nextMedia = IOIteratorNext( mediaIterator );
1988     if ( nextMedia )
1989     {
1990         CFTypeRef   bsdPathAsCFString;
1991     bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
1992         if ( bsdPathAsCFString ) {
1993             size_t devPathLength;
1994             strcpy( bsdPath, _PATH_DEV );
1995             strcat( bsdPath, "r" );
1996             devPathLength = strlen( bsdPath );
1997             if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
1998                 kernResult = KERN_SUCCESS;
1999             }
2000             CFRelease( bsdPathAsCFString );
2001         }
2002         IOObjectRelease( nextMedia );
2003     }
2004
2005     return kernResult;
2006 }
2007
2008 #endif
2009
2010 static int hdev_probe_device(const char *filename)
2011 {
2012     struct stat st;
2013
2014     /* allow a dedicated CD-ROM driver to match with a higher priority */
2015     if (strstart(filename, "/dev/cdrom", NULL))
2016         return 50;
2017
2018     if (stat(filename, &st) >= 0 &&
2019             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
2020         return 100;
2021     }
2022
2023     return 0;
2024 }
2025
2026 static int check_hdev_writable(BDRVRawState *s)
2027 {
2028 #if defined(BLKROGET)
2029     /* Linux block devices can be configured "read-only" using blockdev(8).
2030      * This is independent of device node permissions and therefore open(2)
2031      * with O_RDWR succeeds.  Actual writes fail with EPERM.
2032      *
2033      * bdrv_open() is supposed to fail if the disk is read-only.  Explicitly
2034      * check for read-only block devices so that Linux block devices behave
2035      * properly.
2036      */
2037     struct stat st;
2038     int readonly = 0;
2039
2040     if (fstat(s->fd, &st)) {
2041         return -errno;
2042     }
2043
2044     if (!S_ISBLK(st.st_mode)) {
2045         return 0;
2046     }
2047
2048     if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
2049         return -errno;
2050     }
2051
2052     if (readonly) {
2053         return -EACCES;
2054     }
2055 #endif /* defined(BLKROGET) */
2056     return 0;
2057 }
2058
2059 static void hdev_parse_filename(const char *filename, QDict *options,
2060                                 Error **errp)
2061 {
2062     /* The prefix is optional, just as for "file". */
2063     strstart(filename, "host_device:", &filename);
2064
2065     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
2066 }
2067
2068 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
2069                      Error **errp)
2070 {
2071     BDRVRawState *s = bs->opaque;
2072     Error *local_err = NULL;
2073     int ret;
2074     const char *filename = qdict_get_str(options, "filename");
2075
2076 #if defined(__APPLE__) && defined(__MACH__)
2077     if (strstart(filename, "/dev/cdrom", NULL)) {
2078         kern_return_t kernResult;
2079         io_iterator_t mediaIterator;
2080         char bsdPath[ MAXPATHLEN ];
2081         int fd;
2082
2083         kernResult = FindEjectableCDMedia( &mediaIterator );
2084         kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );
2085
2086         if ( bsdPath[ 0 ] != '\0' ) {
2087             strcat(bsdPath,"s0");
2088             /* some CDs don't have a partition 0 */
2089             fd = qemu_open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
2090             if (fd < 0) {
2091                 bsdPath[strlen(bsdPath)-1] = '1';
2092             } else {
2093                 qemu_close(fd);
2094             }
2095             filename = bsdPath;
2096             qdict_put(options, "filename", qstring_from_str(filename));
2097         }
2098
2099         if ( mediaIterator )
2100             IOObjectRelease( mediaIterator );
2101     }
2102 #endif
2103
2104     s->type = FTYPE_FILE;
2105 #if defined(__linux__)
2106     {
2107         char resolved_path[ MAXPATHLEN ], *temp;
2108
2109         temp = realpath(filename, resolved_path);
2110         if (temp && strstart(temp, "/dev/sg", NULL)) {
2111             bs->sg = 1;
2112         }
2113     }
2114 #endif
2115
2116     ret = raw_open_common(bs, options, flags, 0, &local_err);
2117     if (ret < 0) {
2118         if (local_err) {
2119             error_propagate(errp, local_err);
2120         }
2121         return ret;
2122     }
2123
2124     if (flags & BDRV_O_RDWR) {
2125         ret = check_hdev_writable(s);
2126         if (ret < 0) {
2127             raw_close(bs);
2128             error_setg_errno(errp, -ret, "The device is not writable");
2129             return ret;
2130         }
2131     }
2132
2133     return ret;
2134 }
2135
2136 #if defined(__linux__)
2137 /* Note: we do not have a reliable method to detect if the floppy is
2138    present. The current method is to try to open the floppy at every
2139    I/O and to keep it opened during a few hundreds of ms. */
2140 static int fd_open(BlockDriverState *bs)
2141 {
2142     BDRVRawState *s = bs->opaque;
2143     int last_media_present;
2144
2145     if (s->type != FTYPE_FD)
2146         return 0;
2147     last_media_present = (s->fd >= 0);
2148     if (s->fd >= 0 &&
2149         (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - s->fd_open_time) >= FD_OPEN_TIMEOUT) {
2150         qemu_close(s->fd);
2151         s->fd = -1;
2152 #ifdef DEBUG_FLOPPY
2153         printf("Floppy closed\n");
2154 #endif
2155     }
2156     if (s->fd < 0) {
2157         if (s->fd_got_error &&
2158             (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - s->fd_error_time) < FD_OPEN_TIMEOUT) {
2159 #ifdef DEBUG_FLOPPY
2160             printf("No floppy (open delayed)\n");
2161 #endif
2162             return -EIO;
2163         }
2164         s->fd = qemu_open(bs->filename, s->open_flags & ~O_NONBLOCK);
2165         if (s->fd < 0) {
2166             s->fd_error_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
2167             s->fd_got_error = 1;
2168             if (last_media_present)
2169                 s->fd_media_changed = 1;
2170 #ifdef DEBUG_FLOPPY
2171             printf("No floppy\n");
2172 #endif
2173             return -EIO;
2174         }
2175 #ifdef DEBUG_FLOPPY
2176         printf("Floppy opened\n");
2177 #endif
2178     }
2179     if (!last_media_present)
2180         s->fd_media_changed = 1;
2181     s->fd_open_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
2182     s->fd_got_error = 0;
2183     return 0;
2184 }
2185
2186 static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
2187 {
2188     BDRVRawState *s = bs->opaque;
2189
2190     return ioctl(s->fd, req, buf);
2191 }
2192
2193 static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
2194         unsigned long int req, void *buf,
2195         BlockCompletionFunc *cb, void *opaque)
2196 {
2197     BDRVRawState *s = bs->opaque;
2198     RawPosixAIOData *acb;
2199     ThreadPool *pool;
2200
2201     if (fd_open(bs) < 0)
2202         return NULL;
2203
2204     acb = g_slice_new(RawPosixAIOData);
2205     acb->bs = bs;
2206     acb->aio_type = QEMU_AIO_IOCTL;
2207     acb->aio_fildes = s->fd;
2208     acb->aio_offset = 0;
2209     acb->aio_ioctl_buf = buf;
2210     acb->aio_ioctl_cmd = req;
2211     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
2212     return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
2213 }
2214
2215 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2216 static int fd_open(BlockDriverState *bs)
2217 {
2218     BDRVRawState *s = bs->opaque;
2219
2220     /* this is just to ensure s->fd is sane (its called by io ops) */
2221     if (s->fd >= 0)
2222         return 0;
2223     return -EIO;
2224 }
2225 #else /* !linux && !FreeBSD */
2226
2227 static int fd_open(BlockDriverState *bs)
2228 {
2229     return 0;
2230 }
2231
2232 #endif /* !linux && !FreeBSD */
2233
2234 static coroutine_fn BlockAIOCB *hdev_aio_discard(BlockDriverState *bs,
2235     int64_t sector_num, int nb_sectors,
2236     BlockCompletionFunc *cb, void *opaque)
2237 {
2238     BDRVRawState *s = bs->opaque;
2239
2240     if (fd_open(bs) < 0) {
2241         return NULL;
2242     }
2243     return paio_submit(bs, s->fd, sector_num, NULL, nb_sectors,
2244                        cb, opaque, QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
2245 }
2246
2247 static coroutine_fn int hdev_co_write_zeroes(BlockDriverState *bs,
2248     int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
2249 {
2250     BDRVRawState *s = bs->opaque;
2251     int rc;
2252
2253     rc = fd_open(bs);
2254     if (rc < 0) {
2255         return rc;
2256     }
2257     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
2258         return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
2259                               QEMU_AIO_WRITE_ZEROES|QEMU_AIO_BLKDEV);
2260     } else if (s->discard_zeroes) {
2261         return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
2262                               QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
2263     }
2264     return -ENOTSUP;
2265 }
2266
2267 static int hdev_create(const char *filename, QemuOpts *opts,
2268                        Error **errp)
2269 {
2270     int fd;
2271     int ret = 0;
2272     struct stat stat_buf;
2273     int64_t total_size = 0;
2274     bool has_prefix;
2275
2276     /* This function is used by all three protocol block drivers and therefore
2277      * any of these three prefixes may be given.
2278      * The return value has to be stored somewhere, otherwise this is an error
2279      * due to -Werror=unused-value. */
2280     has_prefix =
2281         strstart(filename, "host_device:", &filename) ||
2282         strstart(filename, "host_cdrom:" , &filename) ||
2283         strstart(filename, "host_floppy:", &filename);
2284
2285     (void)has_prefix;
2286
2287     /* Read out options */
2288     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2289                           BDRV_SECTOR_SIZE);
2290
2291     fd = qemu_open(filename, O_WRONLY | O_BINARY);
2292     if (fd < 0) {
2293         ret = -errno;
2294         error_setg_errno(errp, -ret, "Could not open device");
2295         return ret;
2296     }
2297
2298     if (fstat(fd, &stat_buf) < 0) {
2299         ret = -errno;
2300         error_setg_errno(errp, -ret, "Could not stat device");
2301     } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
2302         error_setg(errp,
2303                    "The given file is neither a block nor a character device");
2304         ret = -ENODEV;
2305     } else if (lseek(fd, 0, SEEK_END) < total_size) {
2306         error_setg(errp, "Device is too small");
2307         ret = -ENOSPC;
2308     }
2309
2310     qemu_close(fd);
2311     return ret;
2312 }
2313
2314 static BlockDriver bdrv_host_device = {
2315     .format_name        = "host_device",
2316     .protocol_name        = "host_device",
2317     .instance_size      = sizeof(BDRVRawState),
2318     .bdrv_needs_filename = true,
2319     .bdrv_probe_device  = hdev_probe_device,
2320     .bdrv_parse_filename = hdev_parse_filename,
2321     .bdrv_file_open     = hdev_open,
2322     .bdrv_close         = raw_close,
2323     .bdrv_reopen_prepare = raw_reopen_prepare,
2324     .bdrv_reopen_commit  = raw_reopen_commit,
2325     .bdrv_reopen_abort   = raw_reopen_abort,
2326     .bdrv_create         = hdev_create,
2327     .create_opts         = &raw_create_opts,
2328     .bdrv_co_write_zeroes = hdev_co_write_zeroes,
2329
2330     .bdrv_aio_readv     = raw_aio_readv,
2331     .bdrv_aio_writev    = raw_aio_writev,
2332     .bdrv_aio_flush     = raw_aio_flush,
2333     .bdrv_aio_discard   = hdev_aio_discard,
2334     .bdrv_refresh_limits = raw_refresh_limits,
2335     .bdrv_io_plug = raw_aio_plug,
2336     .bdrv_io_unplug = raw_aio_unplug,
2337     .bdrv_flush_io_queue = raw_aio_flush_io_queue,
2338
2339     .bdrv_truncate      = raw_truncate,
2340     .bdrv_getlength     = raw_getlength,
2341     .bdrv_get_info = raw_get_info,
2342     .bdrv_get_allocated_file_size
2343                         = raw_get_allocated_file_size,
2344     .bdrv_probe_blocksizes = hdev_probe_blocksizes,
2345     .bdrv_probe_geometry = hdev_probe_geometry,
2346
2347     .bdrv_detach_aio_context = raw_detach_aio_context,
2348     .bdrv_attach_aio_context = raw_attach_aio_context,
2349
2350     /* generic scsi device */
2351 #ifdef __linux__
2352     .bdrv_ioctl         = hdev_ioctl,
2353     .bdrv_aio_ioctl     = hdev_aio_ioctl,
2354 #endif
2355 };
2356
2357 #ifdef __linux__
2358 static void floppy_parse_filename(const char *filename, QDict *options,
2359                                   Error **errp)
2360 {
2361     /* The prefix is optional, just as for "file". */
2362     strstart(filename, "host_floppy:", &filename);
2363
2364     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
2365 }
2366
2367 static int floppy_open(BlockDriverState *bs, QDict *options, int flags,
2368                        Error **errp)
2369 {
2370     BDRVRawState *s = bs->opaque;
2371     Error *local_err = NULL;
2372     int ret;
2373
2374     s->type = FTYPE_FD;
2375
2376     /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */
2377     ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
2378     if (ret) {
2379         if (local_err) {
2380             error_propagate(errp, local_err);
2381         }
2382         return ret;
2383     }
2384
2385     /* close fd so that we can reopen it as needed */
2386     qemu_close(s->fd);
2387     s->fd = -1;
2388     s->fd_media_changed = 1;
2389
2390     return 0;
2391 }
2392
2393 static int floppy_probe_device(const char *filename)
2394 {
2395     int fd, ret;
2396     int prio = 0;
2397     struct floppy_struct fdparam;
2398     struct stat st;
2399
2400     if (strstart(filename, "/dev/fd", NULL) &&
2401         !strstart(filename, "/dev/fdset/", NULL)) {
2402         prio = 50;
2403     }
2404
2405     fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
2406     if (fd < 0) {
2407         goto out;
2408     }
2409     ret = fstat(fd, &st);
2410     if (ret == -1 || !S_ISBLK(st.st_mode)) {
2411         goto outc;
2412     }
2413
2414     /* Attempt to detect via a floppy specific ioctl */
2415     ret = ioctl(fd, FDGETPRM, &fdparam);
2416     if (ret >= 0)
2417         prio = 100;
2418
2419 outc:
2420     qemu_close(fd);
2421 out:
2422     return prio;
2423 }
2424
2425
2426 static int floppy_is_inserted(BlockDriverState *bs)
2427 {
2428     return fd_open(bs) >= 0;
2429 }
2430
2431 static int floppy_media_changed(BlockDriverState *bs)
2432 {
2433     BDRVRawState *s = bs->opaque;
2434     int ret;
2435
2436     /*
2437      * XXX: we do not have a true media changed indication.
2438      * It does not work if the floppy is changed without trying to read it.
2439      */
2440     fd_open(bs);
2441     ret = s->fd_media_changed;
2442     s->fd_media_changed = 0;
2443 #ifdef DEBUG_FLOPPY
2444     printf("Floppy changed=%d\n", ret);
2445 #endif
2446     return ret;
2447 }
2448
2449 static void floppy_eject(BlockDriverState *bs, bool eject_flag)
2450 {
2451     BDRVRawState *s = bs->opaque;
2452     int fd;
2453
2454     if (s->fd >= 0) {
2455         qemu_close(s->fd);
2456         s->fd = -1;
2457     }
2458     fd = qemu_open(bs->filename, s->open_flags | O_NONBLOCK);
2459     if (fd >= 0) {
2460         if (ioctl(fd, FDEJECT, 0) < 0)
2461             perror("FDEJECT");
2462         qemu_close(fd);
2463     }
2464 }
2465
2466 static BlockDriver bdrv_host_floppy = {
2467     .format_name        = "host_floppy",
2468     .protocol_name      = "host_floppy",
2469     .instance_size      = sizeof(BDRVRawState),
2470     .bdrv_needs_filename = true,
2471     .bdrv_probe_device  = floppy_probe_device,
2472     .bdrv_parse_filename = floppy_parse_filename,
2473     .bdrv_file_open     = floppy_open,
2474     .bdrv_close         = raw_close,
2475     .bdrv_reopen_prepare = raw_reopen_prepare,
2476     .bdrv_reopen_commit  = raw_reopen_commit,
2477     .bdrv_reopen_abort   = raw_reopen_abort,
2478     .bdrv_create         = hdev_create,
2479     .create_opts         = &raw_create_opts,
2480
2481     .bdrv_aio_readv     = raw_aio_readv,
2482     .bdrv_aio_writev    = raw_aio_writev,
2483     .bdrv_aio_flush     = raw_aio_flush,
2484     .bdrv_refresh_limits = raw_refresh_limits,
2485     .bdrv_io_plug = raw_aio_plug,
2486     .bdrv_io_unplug = raw_aio_unplug,
2487     .bdrv_flush_io_queue = raw_aio_flush_io_queue,
2488
2489     .bdrv_truncate      = raw_truncate,
2490     .bdrv_getlength      = raw_getlength,
2491     .has_variable_length = true,
2492     .bdrv_get_allocated_file_size
2493                         = raw_get_allocated_file_size,
2494
2495     .bdrv_detach_aio_context = raw_detach_aio_context,
2496     .bdrv_attach_aio_context = raw_attach_aio_context,
2497
2498     /* removable device support */
2499     .bdrv_is_inserted   = floppy_is_inserted,
2500     .bdrv_media_changed = floppy_media_changed,
2501     .bdrv_eject         = floppy_eject,
2502 };
2503 #endif
2504
2505 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2506 static void cdrom_parse_filename(const char *filename, QDict *options,
2507                                  Error **errp)
2508 {
2509     /* The prefix is optional, just as for "file". */
2510     strstart(filename, "host_cdrom:", &filename);
2511
2512     qdict_put_obj(options, "filename", QOBJECT(qstring_from_str(filename)));
2513 }
2514 #endif
2515
2516 #ifdef __linux__
2517 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
2518                       Error **errp)
2519 {
2520     BDRVRawState *s = bs->opaque;
2521     Error *local_err = NULL;
2522     int ret;
2523
2524     s->type = FTYPE_CD;
2525
2526     /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
2527     ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
2528     if (local_err) {
2529         error_propagate(errp, local_err);
2530     }
2531     return ret;
2532 }
2533
2534 static int cdrom_probe_device(const char *filename)
2535 {
2536     int fd, ret;
2537     int prio = 0;
2538     struct stat st;
2539
2540     fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
2541     if (fd < 0) {
2542         goto out;
2543     }
2544     ret = fstat(fd, &st);
2545     if (ret == -1 || !S_ISBLK(st.st_mode)) {
2546         goto outc;
2547     }
2548
2549     /* Attempt to detect via a CDROM specific ioctl */
2550     ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2551     if (ret >= 0)
2552         prio = 100;
2553
2554 outc:
2555     qemu_close(fd);
2556 out:
2557     return prio;
2558 }
2559
2560 static int cdrom_is_inserted(BlockDriverState *bs)
2561 {
2562     BDRVRawState *s = bs->opaque;
2563     int ret;
2564
2565     ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
2566     if (ret == CDS_DISC_OK)
2567         return 1;
2568     return 0;
2569 }
2570
2571 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2572 {
2573     BDRVRawState *s = bs->opaque;
2574
2575     if (eject_flag) {
2576         if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
2577             perror("CDROMEJECT");
2578     } else {
2579         if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
2580             perror("CDROMEJECT");
2581     }
2582 }
2583
2584 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2585 {
2586     BDRVRawState *s = bs->opaque;
2587
2588     if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
2589         /*
2590          * Note: an error can happen if the distribution automatically
2591          * mounts the CD-ROM
2592          */
2593         /* perror("CDROM_LOCKDOOR"); */
2594     }
2595 }
2596
2597 static BlockDriver bdrv_host_cdrom = {
2598     .format_name        = "host_cdrom",
2599     .protocol_name      = "host_cdrom",
2600     .instance_size      = sizeof(BDRVRawState),
2601     .bdrv_needs_filename = true,
2602     .bdrv_probe_device  = cdrom_probe_device,
2603     .bdrv_parse_filename = cdrom_parse_filename,
2604     .bdrv_file_open     = cdrom_open,
2605     .bdrv_close         = raw_close,
2606     .bdrv_reopen_prepare = raw_reopen_prepare,
2607     .bdrv_reopen_commit  = raw_reopen_commit,
2608     .bdrv_reopen_abort   = raw_reopen_abort,
2609     .bdrv_create         = hdev_create,
2610     .create_opts         = &raw_create_opts,
2611
2612     .bdrv_aio_readv     = raw_aio_readv,
2613     .bdrv_aio_writev    = raw_aio_writev,
2614     .bdrv_aio_flush     = raw_aio_flush,
2615     .bdrv_refresh_limits = raw_refresh_limits,
2616     .bdrv_io_plug = raw_aio_plug,
2617     .bdrv_io_unplug = raw_aio_unplug,
2618     .bdrv_flush_io_queue = raw_aio_flush_io_queue,
2619
2620     .bdrv_truncate      = raw_truncate,
2621     .bdrv_getlength      = raw_getlength,
2622     .has_variable_length = true,
2623     .bdrv_get_allocated_file_size
2624                         = raw_get_allocated_file_size,
2625
2626     .bdrv_detach_aio_context = raw_detach_aio_context,
2627     .bdrv_attach_aio_context = raw_attach_aio_context,
2628
2629     /* removable device support */
2630     .bdrv_is_inserted   = cdrom_is_inserted,
2631     .bdrv_eject         = cdrom_eject,
2632     .bdrv_lock_medium   = cdrom_lock_medium,
2633
2634     /* generic scsi device */
2635     .bdrv_ioctl         = hdev_ioctl,
2636     .bdrv_aio_ioctl     = hdev_aio_ioctl,
2637 };
2638 #endif /* __linux__ */
2639
2640 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2641 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
2642                       Error **errp)
2643 {
2644     BDRVRawState *s = bs->opaque;
2645     Error *local_err = NULL;
2646     int ret;
2647
2648     s->type = FTYPE_CD;
2649
2650     ret = raw_open_common(bs, options, flags, 0, &local_err);
2651     if (ret) {
2652         if (local_err) {
2653             error_propagate(errp, local_err);
2654         }
2655         return ret;
2656     }
2657
2658     /* make sure the door isn't locked at this time */
2659     ioctl(s->fd, CDIOCALLOW);
2660     return 0;
2661 }
2662
2663 static int cdrom_probe_device(const char *filename)
2664 {
2665     if (strstart(filename, "/dev/cd", NULL) ||
2666             strstart(filename, "/dev/acd", NULL))
2667         return 100;
2668     return 0;
2669 }
2670
2671 static int cdrom_reopen(BlockDriverState *bs)
2672 {
2673     BDRVRawState *s = bs->opaque;
2674     int fd;
2675
2676     /*
2677      * Force reread of possibly changed/newly loaded disc,
2678      * FreeBSD seems to not notice sometimes...
2679      */
2680     if (s->fd >= 0)
2681         qemu_close(s->fd);
2682     fd = qemu_open(bs->filename, s->open_flags, 0644);
2683     if (fd < 0) {
2684         s->fd = -1;
2685         return -EIO;
2686     }
2687     s->fd = fd;
2688
2689     /* make sure the door isn't locked at this time */
2690     ioctl(s->fd, CDIOCALLOW);
2691     return 0;
2692 }
2693
2694 static int cdrom_is_inserted(BlockDriverState *bs)
2695 {
2696     return raw_getlength(bs) > 0;
2697 }
2698
2699 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2700 {
2701     BDRVRawState *s = bs->opaque;
2702
2703     if (s->fd < 0)
2704         return;
2705
2706     (void) ioctl(s->fd, CDIOCALLOW);
2707
2708     if (eject_flag) {
2709         if (ioctl(s->fd, CDIOCEJECT) < 0)
2710             perror("CDIOCEJECT");
2711     } else {
2712         if (ioctl(s->fd, CDIOCCLOSE) < 0)
2713             perror("CDIOCCLOSE");
2714     }
2715
2716     cdrom_reopen(bs);
2717 }
2718
2719 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2720 {
2721     BDRVRawState *s = bs->opaque;
2722
2723     if (s->fd < 0)
2724         return;
2725     if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
2726         /*
2727          * Note: an error can happen if the distribution automatically
2728          * mounts the CD-ROM
2729          */
2730         /* perror("CDROM_LOCKDOOR"); */
2731     }
2732 }
2733
2734 static BlockDriver bdrv_host_cdrom = {
2735     .format_name        = "host_cdrom",
2736     .protocol_name      = "host_cdrom",
2737     .instance_size      = sizeof(BDRVRawState),
2738     .bdrv_needs_filename = true,
2739     .bdrv_probe_device  = cdrom_probe_device,
2740     .bdrv_parse_filename = cdrom_parse_filename,
2741     .bdrv_file_open     = cdrom_open,
2742     .bdrv_close         = raw_close,
2743     .bdrv_reopen_prepare = raw_reopen_prepare,
2744     .bdrv_reopen_commit  = raw_reopen_commit,
2745     .bdrv_reopen_abort   = raw_reopen_abort,
2746     .bdrv_create        = hdev_create,
2747     .create_opts        = &raw_create_opts,
2748
2749     .bdrv_aio_readv     = raw_aio_readv,
2750     .bdrv_aio_writev    = raw_aio_writev,
2751     .bdrv_aio_flush     = raw_aio_flush,
2752     .bdrv_refresh_limits = raw_refresh_limits,
2753     .bdrv_io_plug = raw_aio_plug,
2754     .bdrv_io_unplug = raw_aio_unplug,
2755     .bdrv_flush_io_queue = raw_aio_flush_io_queue,
2756
2757     .bdrv_truncate      = raw_truncate,
2758     .bdrv_getlength      = raw_getlength,
2759     .has_variable_length = true,
2760     .bdrv_get_allocated_file_size
2761                         = raw_get_allocated_file_size,
2762
2763     .bdrv_detach_aio_context = raw_detach_aio_context,
2764     .bdrv_attach_aio_context = raw_attach_aio_context,
2765
2766     /* removable device support */
2767     .bdrv_is_inserted   = cdrom_is_inserted,
2768     .bdrv_eject         = cdrom_eject,
2769     .bdrv_lock_medium   = cdrom_lock_medium,
2770 };
2771 #endif /* __FreeBSD__ */
2772
2773 static void bdrv_file_init(void)
2774 {
2775     /*
2776      * Register all the drivers.  Note that order is important, the driver
2777      * registered last will get probed first.
2778      */
2779     bdrv_register(&bdrv_file);
2780     bdrv_register(&bdrv_host_device);
2781 #ifdef __linux__
2782     bdrv_register(&bdrv_host_floppy);
2783     bdrv_register(&bdrv_host_cdrom);
2784 #endif
2785 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2786     bdrv_register(&bdrv_host_cdrom);
2787 #endif
2788 }
2789
2790 block_init(bdrv_file_init);