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