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
  25 #include "qemu/osdep.h"
  26 #include "qapi/error.h"
  27 #include "qemu/cutils.h"
  28 #include "qemu/error-report.h"
  29 #include "block/block_int.h"
  30 #include "qemu/module.h"
  31 #include "qemu/option.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/qmp/qdict.h"
  37 #include "qapi/qmp/qstring.h"
  38
  39 #include "scsi/pr-manager.h"
  40 #include "scsi/constants.h"
  41
  42 #if defined(__APPLE__) && (__MACH__)
  43 #include <paths.h>
  44 #include <sys/param.h>
  45 #include <IOKit/IOKitLib.h>
  46 #include <IOKit/IOBSD.h>
  47 #include <IOKit/storage/IOMediaBSDClient.h>
  48 #include <IOKit/storage/IOMedia.h>
  49 #include <IOKit/storage/IOCDMedia.h>
  50 //#include <IOKit/storage/IOCDTypes.h>
  51 #include <IOKit/storage/IODVDMedia.h>
  52 #include <CoreFoundation/CoreFoundation.h>
  53 #endif
  54
  55 #ifdef __sun__
  56 #define _POSIX_PTHREAD_SEMANTICS 1
  57 #include <sys/dkio.h>
  58 #endif
  59 #ifdef __linux__
  60 #include <sys/ioctl.h>
  61 #include <sys/param.h>
  62 #include <sys/syscall.h>
  63 #include <linux/cdrom.h>
  64 #include <linux/fd.h>
  65 #include <linux/fs.h>
  66 #include <linux/hdreg.h>
  67 #include <scsi/sg.h>
  68 #ifdef __s390__
  69 #include <asm/dasd.h>
  70 #endif
  71 #ifndef FS_NOCOW_FL
  72 #define FS_NOCOW_FL                     0x00800000 /* Do not cow file */
  73 #endif
  74 #endif
  75 #if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
  76 #include <linux/falloc.h>
  77 #endif
  78 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
  79 #include <sys/disk.h>
  80 #include <sys/cdio.h>
  81 #endif
  82
  83 #ifdef __OpenBSD__
  84 #include <sys/ioctl.h>
  85 #include <sys/disklabel.h>
  86 #include <sys/dkio.h>
  87 #endif
  88
  89 #ifdef __NetBSD__
  90 #include <sys/ioctl.h>
  91 #include <sys/disklabel.h>
  92 #include <sys/dkio.h>
  93 #include <sys/disk.h>
  94 #endif
  95
  96 #ifdef __DragonFly__
  97 #include <sys/ioctl.h>
  98 #include <sys/diskslice.h>
  99 #endif
 100
 101 #ifdef CONFIG_XFS
 102 #include <xfs/xfs.h>
 103 #endif
 104
 105 //#define DEBUG_BLOCK
 106
 107 #ifdef DEBUG_BLOCK
 108 # define DEBUG_BLOCK_PRINT 1
 109 #else
 110 # define DEBUG_BLOCK_PRINT 0
 111 #endif
 112 #define DPRINTF(fmt, ...) \
 113 do { \
 114     if (DEBUG_BLOCK_PRINT) { \
 115         printf(fmt, ## __VA_ARGS__); \
 116     } \
 117 } while (0)
 118
 119 /* OS X does not have O_DSYNC */
 120 #ifndef O_DSYNC
 121 #ifdef O_SYNC
 122 #define O_DSYNC O_SYNC
 123 #elif defined(O_FSYNC)
 124 #define O_DSYNC O_FSYNC
 125 #endif
 126 #endif
 127
 128 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
 129 #ifndef O_DIRECT
 130 #define O_DIRECT O_DSYNC
 131 #endif
 132
 133 #define FTYPE_FILE   0
 134 #define FTYPE_CD     1
 135
 136 #define MAX_BLOCKSIZE   4096
 137
 138 /* Posix file locking bytes. Libvirt takes byte 0, we start from higher bytes,
 139  * leaving a few more bytes for its future use. */
 140 #define RAW_LOCK_PERM_BASE             100
 141 #define RAW_LOCK_SHARED_BASE           200
 142
 143 typedef struct BDRVRawState {
 144     int fd;
 145     int lock_fd;
 146     bool use_lock;
 147     int type;
 148     int open_flags;
 149     size_t buf_align;
 150
 151     /* The current permissions. */
 152     uint64_t perm;
 153     uint64_t shared_perm;
 154
 155 #ifdef CONFIG_XFS
 156     bool is_xfs:1;
 157 #endif
 158     bool has_discard:1;
 159     bool has_write_zeroes:1;
 160     bool discard_zeroes:1;
 161     bool use_linux_aio:1;
 162     bool page_cache_inconsistent:1;
 163     bool has_fallocate;
 164     bool needs_alignment;
 165     bool check_cache_dropped;
 166
 167     PRManager *pr_mgr;
 168 } BDRVRawState;
 169
 170 typedef struct BDRVRawReopenState {
 171     int fd;
 172     int open_flags;
 173     bool check_cache_dropped;
 174 } BDRVRawReopenState;
 175
 176 static int fd_open(BlockDriverState *bs);
 177 static int64_t raw_getlength(BlockDriverState *bs);
 178
 179 typedef struct RawPosixAIOData {
 180     BlockDriverState *bs;
 181     int aio_fildes;
 182     union {
 183         struct iovec *aio_iov;
 184         void *aio_ioctl_buf;
 185     };
 186     int aio_niov;
 187     uint64_t aio_nbytes;
 188 #define aio_ioctl_cmd   aio_nbytes /* for QEMU_AIO_IOCTL */
 189     off_t aio_offset;
 190     int aio_type;
 191     union {
 192         struct {
 193             int aio_fd2;
 194             off_t aio_offset2;
 195         };
 196         struct {
 197             PreallocMode prealloc;
 198             Error **errp;
 199         };
 200     };
 201 } RawPosixAIOData;
 202
 203 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 204 static int cdrom_reopen(BlockDriverState *bs);
 205 #endif
 206
 207 #if defined(__NetBSD__)
 208 static int raw_normalize_devicepath(const char **filename)
 209 {
 210     static char namebuf[PATH_MAX];
 211     const char *dp, *fname;
 212     struct stat sb;
 213
 214     fname = *filename;
 215     dp = strrchr(fname, '/');
 216     if (lstat(fname, &sb) < 0) {
 217         fprintf(stderr, "%s: stat failed: %s\n",
 218             fname, strerror(errno));
 219         return -errno;
 220     }
 221
 222     if (!S_ISBLK(sb.st_mode)) {
 223         return 0;
 224     }
 225
 226     if (dp == NULL) {
 227         snprintf(namebuf, PATH_MAX, "r%s", fname);
 228     } else {
 229         snprintf(namebuf, PATH_MAX, "%.*s/r%s",
 230             (int)(dp - fname), fname, dp + 1);
 231     }
 232     fprintf(stderr, "%s is a block device", fname);
 233     *filename = namebuf;
 234     fprintf(stderr, ", using %s\n", *filename);
 235
 236     return 0;
 237 }
 238 #else
 239 static int raw_normalize_devicepath(const char **filename)
 240 {
 241     return 0;
 242 }
 243 #endif
 244
 245 /*
 246  * Get logical block size via ioctl. On success store it in @sector_size_p.
 247  */
 248 static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
 249 {
 250     unsigned int sector_size;
 251     bool success = false;
 252     int i;
 253
 254     errno = ENOTSUP;
 255     static const unsigned long ioctl_list[] = {
 256 #ifdef BLKSSZGET
 257         BLKSSZGET,
 258 #endif
 259 #ifdef DKIOCGETBLOCKSIZE
 260         DKIOCGETBLOCKSIZE,
 261 #endif
 262 #ifdef DIOCGSECTORSIZE
 263         DIOCGSECTORSIZE,
 264 #endif
 265     };
 266
 267     /* Try a few ioctls to get the right size */
 268     for (i = 0; i < (int)ARRAY_SIZE(ioctl_list); i++) {
 269         if (ioctl(fd, ioctl_list[i], &sector_size) >= 0) {
 270             *sector_size_p = sector_size;
 271             success = true;
 272         }
 273     }
 274
 275     return success ? 0 : -errno;
 276 }
 277
 278 /**
 279  * Get physical block size of @fd.
 280  * On success, store it in @blk_size and return 0.
 281  * On failure, return -errno.
 282  */
 283 static int probe_physical_blocksize(int fd, unsigned int *blk_size)
 284 {
 285 #ifdef BLKPBSZGET
 286     if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
 287         return -errno;
 288     }
 289     return 0;
 290 #else
 291     return -ENOTSUP;
 292 #endif
 293 }
 294
 295 /* Check if read is allowed with given memory buffer and length.
 296  *
 297  * This function is used to check O_DIRECT memory buffer and request alignment.
 298  */
 299 static bool raw_is_io_aligned(int fd, void *buf, size_t len)
 300 {
 301     ssize_t ret = pread(fd, buf, len, 0);
 302
 303     if (ret >= 0) {
 304         return true;
 305     }
 306
 307 #ifdef __linux__
 308     /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads.  Ignore
 309      * other errors (e.g. real I/O error), which could happen on a failed
 310      * drive, since we only care about probing alignment.
 311      */
 312     if (errno != EINVAL) {
 313         return true;
 314     }
 315 #endif
 316
 317     return false;
 318 }
 319
 320 static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
 321 {
 322     BDRVRawState *s = bs->opaque;
 323     char *buf;
 324     size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
 325
 326     /* For SCSI generic devices the alignment is not really used.
 327        With buffered I/O, we don't have any restrictions. */
 328     if (bdrv_is_sg(bs) || !s->needs_alignment) {
 329         bs->bl.request_alignment = 1;
 330         s->buf_align = 1;
 331         return;
 332     }
 333
 334     bs->bl.request_alignment = 0;
 335     s->buf_align = 0;
 336     /* Let's try to use the logical blocksize for the alignment. */
 337     if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) {
 338         bs->bl.request_alignment = 0;
 339     }
 340 #ifdef CONFIG_XFS
 341     if (s->is_xfs) {
 342         struct dioattr da;
 343         if (xfsctl(NULL, fd, XFS_IOC_DIOINFO, &da) >= 0) {
 344             bs->bl.request_alignment = da.d_miniosz;
 345             /* The kernel returns wrong information for d_mem */
 346             /* s->buf_align = da.d_mem; */
 347         }
 348     }
 349 #endif
 350
 351     /* If we could not get the sizes so far, we can only guess them */
 352     if (!s->buf_align) {
 353         size_t align;
 354         buf = qemu_memalign(max_align, 2 * max_align);
 355         for (align = 512; align <= max_align; align <<= 1) {
 356             if (raw_is_io_aligned(fd, buf + align, max_align)) {
 357                 s->buf_align = align;
 358                 break;
 359             }
 360         }
 361         qemu_vfree(buf);
 362     }
 363
 364     if (!bs->bl.request_alignment) {
 365         size_t align;
 366         buf = qemu_memalign(s->buf_align, max_align);
 367         for (align = 512; align <= max_align; align <<= 1) {
 368             if (raw_is_io_aligned(fd, buf, align)) {
 369                 bs->bl.request_alignment = align;
 370                 break;
 371             }
 372         }
 373         qemu_vfree(buf);
 374     }
 375
 376     if (!s->buf_align || !bs->bl.request_alignment) {
 377         error_setg(errp, "Could not find working O_DIRECT alignment");
 378         error_append_hint(errp, "Try cache.direct=off\n");
 379     }
 380 }
 381
 382 static void raw_parse_flags(int bdrv_flags, int *open_flags)
 383 {
 384     assert(open_flags != NULL);
 385
 386     *open_flags |= O_BINARY;
 387     *open_flags &= ~O_ACCMODE;
 388     if (bdrv_flags & BDRV_O_RDWR) {
 389         *open_flags |= O_RDWR;
 390     } else {
 391         *open_flags |= O_RDONLY;
 392     }
 393
 394     /* Use O_DSYNC for write-through caching, no flags for write-back caching,
 395      * and O_DIRECT for no caching. */
 396     if ((bdrv_flags & BDRV_O_NOCACHE)) {
 397         *open_flags |= O_DIRECT;
 398     }
 399 }
 400
 401 static void raw_parse_filename(const char *filename, QDict *options,
 402                                Error **errp)
 403 {
 404     bdrv_parse_filename_strip_prefix(filename, "file:", options);
 405 }
 406
 407 static QemuOptsList raw_runtime_opts = {
 408     .name = "raw",
 409     .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
 410     .desc = {
 411         {
 412             .name = "filename",
 413             .type = QEMU_OPT_STRING,
 414             .help = "File name of the image",
 415         },
 416         {
 417             .name = "aio",
 418             .type = QEMU_OPT_STRING,
 419             .help = "host AIO implementation (threads, native)",
 420         },
 421         {
 422             .name = "locking",
 423             .type = QEMU_OPT_STRING,
 424             .help = "file locking mode (on/off/auto, default: auto)",
 425         },
 426         {
 427             .name = "pr-manager",
 428             .type = QEMU_OPT_STRING,
 429             .help = "id of persistent reservation manager object (default: none)",
 430         },
 431         {
 432             .name = "x-check-cache-dropped",
 433             .type = QEMU_OPT_BOOL,
 434             .help = "check that page cache was dropped on live migration (default: off)"
 435         },
 436         { /* end of list */ }
 437     },
 438 };
 439
 440 static int raw_open_common(BlockDriverState *bs, QDict *options,
 441                            int bdrv_flags, int open_flags, Error **errp)
 442 {
 443     BDRVRawState *s = bs->opaque;
 444     QemuOpts *opts;
 445     Error *local_err = NULL;
 446     const char *filename = NULL;
 447     const char *str;
 448     BlockdevAioOptions aio, aio_default;
 449     int fd, ret;
 450     struct stat st;
 451     OnOffAuto locking;
 452
 453     opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
 454     qemu_opts_absorb_qdict(opts, options, &local_err);
 455     if (local_err) {
 456         error_propagate(errp, local_err);
 457         ret = -EINVAL;
 458         goto fail;
 459     }
 460
 461     filename = qemu_opt_get(opts, "filename");
 462
 463     ret = raw_normalize_devicepath(&filename);
 464     if (ret != 0) {
 465         error_setg_errno(errp, -ret, "Could not normalize device path");
 466         goto fail;
 467     }
 468
 469     aio_default = (bdrv_flags & BDRV_O_NATIVE_AIO)
 470                   ? BLOCKDEV_AIO_OPTIONS_NATIVE
 471                   : BLOCKDEV_AIO_OPTIONS_THREADS;
 472     aio = qapi_enum_parse(&BlockdevAioOptions_lookup,
 473                           qemu_opt_get(opts, "aio"),
 474                           aio_default, &local_err);
 475     if (local_err) {
 476         error_propagate(errp, local_err);
 477         ret = -EINVAL;
 478         goto fail;
 479     }
 480     s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
 481
 482     locking = qapi_enum_parse(&OnOffAuto_lookup,
 483                               qemu_opt_get(opts, "locking"),
 484                               ON_OFF_AUTO_AUTO, &local_err);
 485     if (local_err) {
 486         error_propagate(errp, local_err);
 487         ret = -EINVAL;
 488         goto fail;
 489     }
 490     switch (locking) {
 491     case ON_OFF_AUTO_ON:
 492         s->use_lock = true;
 493         if (!qemu_has_ofd_lock()) {
 494             fprintf(stderr,
 495                     "File lock requested but OFD locking syscall is "
 496                     "unavailable, falling back to POSIX file locks.\n"
 497                     "Due to the implementation, locks can be lost "
 498                     "unexpectedly.\n");
 499         }
 500         break;
 501     case ON_OFF_AUTO_OFF:
 502         s->use_lock = false;
 503         break;
 504     case ON_OFF_AUTO_AUTO:
 505         s->use_lock = qemu_has_ofd_lock();
 506         break;
 507     default:
 508         abort();
 509     }
 510
 511     str = qemu_opt_get(opts, "pr-manager");
 512     if (str) {
 513         s->pr_mgr = pr_manager_lookup(str, &local_err);
 514         if (local_err) {
 515             error_propagate(errp, local_err);
 516             ret = -EINVAL;
 517             goto fail;
 518         }
 519     }
 520
 521     s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped",
 522                                                false);
 523
 524     s->open_flags = open_flags;
 525     raw_parse_flags(bdrv_flags, &s->open_flags);
 526
 527     s->fd = -1;
 528     fd = qemu_open(filename, s->open_flags, 0644);
 529     if (fd < 0) {
 530         ret = -errno;
 531         error_setg_errno(errp, errno, "Could not open '%s'", filename);
 532         if (ret == -EROFS) {
 533             ret = -EACCES;
 534         }
 535         goto fail;
 536     }
 537     s->fd = fd;
 538
 539     s->lock_fd = -1;
 540     if (s->use_lock) {
 541         fd = qemu_open(filename, s->open_flags);
 542         if (fd < 0) {
 543             ret = -errno;
 544             error_setg_errno(errp, errno, "Could not open '%s' for locking",
 545                              filename);
 546             qemu_close(s->fd);
 547             goto fail;
 548         }
 549         s->lock_fd = fd;
 550     }
 551     s->perm = 0;
 552     s->shared_perm = BLK_PERM_ALL;
 553
 554 #ifdef CONFIG_LINUX_AIO
 555      /* Currently Linux does AIO only for files opened with O_DIRECT */
 556     if (s->use_linux_aio) {
 557         if (!(s->open_flags & O_DIRECT)) {
 558             error_setg(errp, "aio=native was specified, but it requires "
 559                              "cache.direct=on, which was not specified.");
 560             ret = -EINVAL;
 561             goto fail;
 562         }
 563         if (!aio_setup_linux_aio(bdrv_get_aio_context(bs), errp)) {
 564             error_prepend(errp, "Unable to use native AIO: ");
 565             goto fail;
 566         }
 567     }
 568 #else
 569     if (s->use_linux_aio) {
 570         error_setg(errp, "aio=native was specified, but is not supported "
 571                          "in this build.");
 572         ret = -EINVAL;
 573         goto fail;
 574     }
 575 #endif /* !defined(CONFIG_LINUX_AIO) */
 576
 577     s->has_discard = true;
 578     s->has_write_zeroes = true;
 579     if ((bs->open_flags & BDRV_O_NOCACHE) != 0) {
 580         s->needs_alignment = true;
 581     }
 582
 583     if (fstat(s->fd, &st) < 0) {
 584         ret = -errno;
 585         error_setg_errno(errp, errno, "Could not stat file");
 586         goto fail;
 587     }
 588     if (S_ISREG(st.st_mode)) {
 589         s->discard_zeroes = true;
 590         s->has_fallocate = true;
 591     }
 592     if (S_ISBLK(st.st_mode)) {
 593 #ifdef BLKDISCARDZEROES
 594         unsigned int arg;
 595         if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
 596             s->discard_zeroes = true;
 597         }
 598 #endif
 599 #ifdef __linux__
 600         /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache.  Do
 601          * not rely on the contents of discarded blocks unless using O_DIRECT.
 602          * Same for BLKZEROOUT.
 603          */
 604         if (!(bs->open_flags & BDRV_O_NOCACHE)) {
 605             s->discard_zeroes = false;
 606             s->has_write_zeroes = false;
 607         }
 608 #endif
 609     }
 610 #ifdef __FreeBSD__
 611     if (S_ISCHR(st.st_mode)) {
 612         /*
 613          * The file is a char device (disk), which on FreeBSD isn't behind
 614          * a pager, so force all requests to be aligned. This is needed
 615          * so QEMU makes sure all IO operations on the device are aligned
 616          * to sector size, or else FreeBSD will reject them with EINVAL.
 617          */
 618         s->needs_alignment = true;
 619     }
 620 #endif
 621
 622 #ifdef CONFIG_XFS
 623     if (platform_test_xfs_fd(s->fd)) {
 624         s->is_xfs = true;
 625     }
 626 #endif
 627
 628     bs->supported_zero_flags = s->discard_zeroes ? BDRV_REQ_MAY_UNMAP : 0;
 629     ret = 0;
 630 fail:
 631     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
 632         unlink(filename);
 633     }
 634     qemu_opts_del(opts);
 635     return ret;
 636 }
 637
 638 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
 639                     Error **errp)
 640 {
 641     BDRVRawState *s = bs->opaque;
 642
 643     s->type = FTYPE_FILE;
 644     return raw_open_common(bs, options, flags, 0, errp);
 645 }
 646
 647 typedef enum {
 648     RAW_PL_PREPARE,
 649     RAW_PL_COMMIT,
 650     RAW_PL_ABORT,
 651 } RawPermLockOp;
 652
 653 #define PERM_FOREACH(i) \
 654     for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++)
 655
 656 /* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the
 657  * file; if @unlock == true, also unlock the unneeded bytes.
 658  * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
 659  */
 660 static int raw_apply_lock_bytes(int fd,
 661                                 uint64_t perm_lock_bits,
 662                                 uint64_t shared_perm_lock_bits,
 663                                 bool unlock, Error **errp)
 664 {
 665     int ret;
 666     int i;
 667
 668     PERM_FOREACH(i) {
 669         int off = RAW_LOCK_PERM_BASE + i;
 670         if (perm_lock_bits & (1ULL << i)) {
 671             ret = qemu_lock_fd(fd, off, 1, false);
 672             if (ret) {
 673                 error_setg(errp, "Failed to lock byte %d", off);
 674                 return ret;
 675             }
 676         } else if (unlock) {
 677             ret = qemu_unlock_fd(fd, off, 1);
 678             if (ret) {
 679                 error_setg(errp, "Failed to unlock byte %d", off);
 680                 return ret;
 681             }
 682         }
 683     }
 684     PERM_FOREACH(i) {
 685         int off = RAW_LOCK_SHARED_BASE + i;
 686         if (shared_perm_lock_bits & (1ULL << i)) {
 687             ret = qemu_lock_fd(fd, off, 1, false);
 688             if (ret) {
 689                 error_setg(errp, "Failed to lock byte %d", off);
 690                 return ret;
 691             }
 692         } else if (unlock) {
 693             ret = qemu_unlock_fd(fd, off, 1);
 694             if (ret) {
 695                 error_setg(errp, "Failed to unlock byte %d", off);
 696                 return ret;
 697             }
 698         }
 699     }
 700     return 0;
 701 }
 702
 703 /* Check "unshared" bytes implied by @perm and ~@shared_perm in the file. */
 704 static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm,
 705                                 Error **errp)
 706 {
 707     int ret;
 708     int i;
 709
 710     PERM_FOREACH(i) {
 711         int off = RAW_LOCK_SHARED_BASE + i;
 712         uint64_t p = 1ULL << i;
 713         if (perm & p) {
 714             ret = qemu_lock_fd_test(fd, off, 1, true);
 715             if (ret) {
 716                 char *perm_name = bdrv_perm_names(p);
 717                 error_setg(errp,
 718                            "Failed to get \"%s\" lock",
 719                            perm_name);
 720                 g_free(perm_name);
 721                 error_append_hint(errp,
 722                                   "Is another process using the image?\n");
 723                 return ret;
 724             }
 725         }
 726     }
 727     PERM_FOREACH(i) {
 728         int off = RAW_LOCK_PERM_BASE + i;
 729         uint64_t p = 1ULL << i;
 730         if (!(shared_perm & p)) {
 731             ret = qemu_lock_fd_test(fd, off, 1, true);
 732             if (ret) {
 733                 char *perm_name = bdrv_perm_names(p);
 734                 error_setg(errp,
 735                            "Failed to get shared \"%s\" lock",
 736                            perm_name);
 737                 g_free(perm_name);
 738                 error_append_hint(errp,
 739                                   "Is another process using the image?\n");
 740                 return ret;
 741             }
 742         }
 743     }
 744     return 0;
 745 }
 746
 747 static int raw_handle_perm_lock(BlockDriverState *bs,
 748                                 RawPermLockOp op,
 749                                 uint64_t new_perm, uint64_t new_shared,
 750                                 Error **errp)
 751 {
 752     BDRVRawState *s = bs->opaque;
 753     int ret = 0;
 754     Error *local_err = NULL;
 755
 756     if (!s->use_lock) {
 757         return 0;
 758     }
 759
 760     if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) {
 761         return 0;
 762     }
 763
 764     assert(s->lock_fd > 0);
 765
 766     switch (op) {
 767     case RAW_PL_PREPARE:
 768         ret = raw_apply_lock_bytes(s->lock_fd, s->perm | new_perm,
 769                                    ~s->shared_perm | ~new_shared,
 770                                    false, errp);
 771         if (!ret) {
 772             ret = raw_check_lock_bytes(s->lock_fd, new_perm, new_shared, errp);
 773             if (!ret) {
 774                 return 0;
 775             }
 776         }
 777         op = RAW_PL_ABORT;
 778         /* fall through to unlock bytes. */
 779     case RAW_PL_ABORT:
 780         raw_apply_lock_bytes(s->lock_fd, s->perm, ~s->shared_perm,
 781                              true, &local_err);
 782         if (local_err) {
 783             /* Theoretically the above call only unlocks bytes and it cannot
 784              * fail. Something weird happened, report it.
 785              */
 786             error_report_err(local_err);
 787         }
 788         break;
 789     case RAW_PL_COMMIT:
 790         raw_apply_lock_bytes(s->lock_fd, new_perm, ~new_shared,
 791                              true, &local_err);
 792         if (local_err) {
 793             /* Theoretically the above call only unlocks bytes and it cannot
 794              * fail. Something weird happened, report it.
 795              */
 796             error_report_err(local_err);
 797         }
 798         break;
 799     }
 800     return ret;
 801 }
 802
 803 static int raw_reopen_prepare(BDRVReopenState *state,
 804                               BlockReopenQueue *queue, Error **errp)
 805 {
 806     BDRVRawState *s;
 807     BDRVRawReopenState *rs;
 808     QemuOpts *opts;
 809     int ret = 0;
 810     Error *local_err = NULL;
 811
 812     assert(state != NULL);
 813     assert(state->bs != NULL);
 814
 815     s = state->bs->opaque;
 816
 817     state->opaque = g_new0(BDRVRawReopenState, 1);
 818     rs = state->opaque;
 819     rs->fd = -1;
 820
 821     /* Handle options changes */
 822     opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
 823     qemu_opts_absorb_qdict(opts, state->options, &local_err);
 824     if (local_err) {
 825         error_propagate(errp, local_err);
 826         ret = -EINVAL;
 827         goto out;
 828     }
 829
 830     rs->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped",
 831                                                 s->check_cache_dropped);
 832
 833     if (s->type == FTYPE_CD) {
 834         rs->open_flags |= O_NONBLOCK;
 835     }
 836
 837     raw_parse_flags(state->flags, &rs->open_flags);
 838
 839     int fcntl_flags = O_APPEND | O_NONBLOCK;
 840 #ifdef O_NOATIME
 841     fcntl_flags |= O_NOATIME;
 842 #endif
 843
 844 #ifdef O_ASYNC
 845     /* Not all operating systems have O_ASYNC, and those that don't
 846      * will not let us track the state into rs->open_flags (typically
 847      * you achieve the same effect with an ioctl, for example I_SETSIG
 848      * on Solaris). But we do not use O_ASYNC, so that's fine.
 849      */
 850     assert((s->open_flags & O_ASYNC) == 0);
 851 #endif
 852
 853     if ((rs->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
 854         /* dup the original fd */
 855         rs->fd = qemu_dup(s->fd);
 856         if (rs->fd >= 0) {
 857             ret = fcntl_setfl(rs->fd, rs->open_flags);
 858             if (ret) {
 859                 qemu_close(rs->fd);
 860                 rs->fd = -1;
 861             }
 862         }
 863     }
 864
 865     /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
 866     if (rs->fd == -1) {
 867         const char *normalized_filename = state->bs->filename;
 868         ret = raw_normalize_devicepath(&normalized_filename);
 869         if (ret < 0) {
 870             error_setg_errno(errp, -ret, "Could not normalize device path");
 871         } else {
 872             assert(!(rs->open_flags & O_CREAT));
 873             rs->fd = qemu_open(normalized_filename, rs->open_flags);
 874             if (rs->fd == -1) {
 875                 error_setg_errno(errp, errno, "Could not reopen file");
 876                 ret = -1;
 877             }
 878         }
 879     }
 880
 881     /* Fail already reopen_prepare() if we can't get a working O_DIRECT
 882      * alignment with the new fd. */
 883     if (rs->fd != -1) {
 884         raw_probe_alignment(state->bs, rs->fd, &local_err);
 885         if (local_err) {
 886             qemu_close(rs->fd);
 887             rs->fd = -1;
 888             error_propagate(errp, local_err);
 889             ret = -EINVAL;
 890         }
 891     }
 892
 893 out:
 894     qemu_opts_del(opts);
 895     return ret;
 896 }
 897
 898 static void raw_reopen_commit(BDRVReopenState *state)
 899 {
 900     BDRVRawReopenState *rs = state->opaque;
 901     BDRVRawState *s = state->bs->opaque;
 902
 903     s->check_cache_dropped = rs->check_cache_dropped;
 904     s->open_flags = rs->open_flags;
 905
 906     qemu_close(s->fd);
 907     s->fd = rs->fd;
 908
 909     g_free(state->opaque);
 910     state->opaque = NULL;
 911 }
 912
 913
 914 static void raw_reopen_abort(BDRVReopenState *state)
 915 {
 916     BDRVRawReopenState *rs = state->opaque;
 917
 918      /* nothing to do if NULL, we didn't get far enough */
 919     if (rs == NULL) {
 920         return;
 921     }
 922
 923     if (rs->fd >= 0) {
 924         qemu_close(rs->fd);
 925         rs->fd = -1;
 926     }
 927     g_free(state->opaque);
 928     state->opaque = NULL;
 929 }
 930
 931 static int hdev_get_max_transfer_length(BlockDriverState *bs, int fd)
 932 {
 933 #ifdef BLKSECTGET
 934     int max_bytes = 0;
 935     short max_sectors = 0;
 936     if (bs->sg && ioctl(fd, BLKSECTGET, &max_bytes) == 0) {
 937         return max_bytes;
 938     } else if (!bs->sg && ioctl(fd, BLKSECTGET, &max_sectors) == 0) {
 939         return max_sectors << BDRV_SECTOR_BITS;
 940     } else {
 941         return -errno;
 942     }
 943 #else
 944     return -ENOSYS;
 945 #endif
 946 }
 947
 948 static int hdev_get_max_segments(const struct stat *st)
 949 {
 950 #ifdef CONFIG_LINUX
 951     char buf[32];
 952     const char *end;
 953     char *sysfspath;
 954     int ret;
 955     int fd = -1;
 956     long max_segments;
 957
 958     sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments",
 959                                 major(st->st_rdev), minor(st->st_rdev));
 960     fd = open(sysfspath, O_RDONLY);
 961     if (fd == -1) {
 962         ret = -errno;
 963         goto out;
 964     }
 965     do {
 966         ret = read(fd, buf, sizeof(buf) - 1);
 967     } while (ret == -1 && errno == EINTR);
 968     if (ret < 0) {
 969         ret = -errno;
 970         goto out;
 971     } else if (ret == 0) {
 972         ret = -EIO;
 973         goto out;
 974     }
 975     buf[ret] = 0;
 976     /* The file is ended with '\n', pass 'end' to accept that. */
 977     ret = qemu_strtol(buf, &end, 10, &max_segments);
 978     if (ret == 0 && end && *end == '\n') {
 979         ret = max_segments;
 980     }
 981
 982 out:
 983     if (fd != -1) {
 984         close(fd);
 985     }
 986     g_free(sysfspath);
 987     return ret;
 988 #else
 989     return -ENOTSUP;
 990 #endif
 991 }
 992
 993 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
 994 {
 995     BDRVRawState *s = bs->opaque;
 996     struct stat st;
 997
 998     if (!fstat(s->fd, &st)) {
 999         if (S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode)) {
1000             int ret = hdev_get_max_transfer_length(bs, s->fd);
1001             if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) {
1002                 bs->bl.max_transfer = pow2floor(ret);
1003             }
1004             ret = hdev_get_max_segments(&st);
1005             if (ret > 0) {
1006                 bs->bl.max_transfer = MIN(bs->bl.max_transfer,
1007                                           ret * getpagesize());
1008             }
1009         }
1010     }
1011
1012     raw_probe_alignment(bs, s->fd, errp);
1013     bs->bl.min_mem_alignment = s->buf_align;
1014     bs->bl.opt_mem_alignment = MAX(s->buf_align, getpagesize());
1015 }
1016
1017 static int check_for_dasd(int fd)
1018 {
1019 #ifdef BIODASDINFO2
1020     struct dasd_information2_t info = {0};
1021
1022     return ioctl(fd, BIODASDINFO2, &info);
1023 #else
1024     return -1;
1025 #endif
1026 }
1027
1028 /**
1029  * Try to get @bs's logical and physical block size.
1030  * On success, store them in @bsz and return zero.
1031  * On failure, return negative errno.
1032  */
1033 static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
1034 {
1035     BDRVRawState *s = bs->opaque;
1036     int ret;
1037
1038     /* If DASD, get blocksizes */
1039     if (check_for_dasd(s->fd) < 0) {
1040         return -ENOTSUP;
1041     }
1042     ret = probe_logical_blocksize(s->fd, &bsz->log);
1043     if (ret < 0) {
1044         return ret;
1045     }
1046     return probe_physical_blocksize(s->fd, &bsz->phys);
1047 }
1048
1049 /**
1050  * Try to get @bs's geometry: cyls, heads, sectors.
1051  * On success, store them in @geo and return 0.
1052  * On failure return -errno.
1053  * (Allows block driver to assign default geometry values that guest sees)
1054  */
1055 #ifdef __linux__
1056 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1057 {
1058     BDRVRawState *s = bs->opaque;
1059     struct hd_geometry ioctl_geo = {0};
1060
1061     /* If DASD, get its geometry */
1062     if (check_for_dasd(s->fd) < 0) {
1063         return -ENOTSUP;
1064     }
1065     if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
1066         return -errno;
1067     }
1068     /* HDIO_GETGEO may return success even though geo contains zeros
1069        (e.g. certain multipath setups) */
1070     if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
1071         return -ENOTSUP;
1072     }
1073     /* Do not return a geometry for partition */
1074     if (ioctl_geo.start != 0) {
1075         return -ENOTSUP;
1076     }
1077     geo->heads = ioctl_geo.heads;
1078     geo->sectors = ioctl_geo.sectors;
1079     geo->cylinders = ioctl_geo.cylinders;
1080
1081     return 0;
1082 }
1083 #else /* __linux__ */
1084 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1085 {
1086     return -ENOTSUP;
1087 }
1088 #endif
1089
1090 static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb)
1091 {
1092     int ret;
1093
1094     ret = ioctl(aiocb->aio_fildes, aiocb->aio_ioctl_cmd, aiocb->aio_ioctl_buf);
1095     if (ret == -1) {
1096         return -errno;
1097     }
1098
1099     return 0;
1100 }
1101
1102 static ssize_t handle_aiocb_flush(RawPosixAIOData *aiocb)
1103 {
1104     BDRVRawState *s = aiocb->bs->opaque;
1105     int ret;
1106
1107     if (s->page_cache_inconsistent) {
1108         return -EIO;
1109     }
1110
1111     ret = qemu_fdatasync(aiocb->aio_fildes);
1112     if (ret == -1) {
1113         /* There is no clear definition of the semantics of a failing fsync(),
1114          * so we may have to assume the worst. The sad truth is that this
1115          * assumption is correct for Linux. Some pages are now probably marked
1116          * clean in the page cache even though they are inconsistent with the
1117          * on-disk contents. The next fdatasync() call would succeed, but no
1118          * further writeback attempt will be made. We can't get back to a state
1119          * in which we know what is on disk (we would have to rewrite
1120          * everything that was touched since the last fdatasync() at least), so
1121          * make bdrv_flush() fail permanently. Given that the behaviour isn't
1122          * really defined, I have little hope that other OSes are doing better.
1123          *
1124          * Obviously, this doesn't affect O_DIRECT, which bypasses the page
1125          * cache. */
1126         if ((s->open_flags & O_DIRECT) == 0) {
1127             s->page_cache_inconsistent = true;
1128         }
1129         return -errno;
1130     }
1131     return 0;
1132 }
1133
1134 #ifdef CONFIG_PREADV
1135
1136 static bool preadv_present = true;
1137
1138 static ssize_t
1139 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1140 {
1141     return preadv(fd, iov, nr_iov, offset);
1142 }
1143
1144 static ssize_t
1145 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1146 {
1147     return pwritev(fd, iov, nr_iov, offset);
1148 }
1149
1150 #else
1151
1152 static bool preadv_present = false;
1153
1154 static ssize_t
1155 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1156 {
1157     return -ENOSYS;
1158 }
1159
1160 static ssize_t
1161 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1162 {
1163     return -ENOSYS;
1164 }
1165
1166 #endif
1167
1168 static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
1169 {
1170     ssize_t len;
1171
1172     do {
1173         if (aiocb->aio_type & QEMU_AIO_WRITE)
1174             len = qemu_pwritev(aiocb->aio_fildes,
1175                                aiocb->aio_iov,
1176                                aiocb->aio_niov,
1177                                aiocb->aio_offset);
1178          else
1179             len = qemu_preadv(aiocb->aio_fildes,
1180                               aiocb->aio_iov,
1181                               aiocb->aio_niov,
1182                               aiocb->aio_offset);
1183     } while (len == -1 && errno == EINTR);
1184
1185     if (len == -1) {
1186         return -errno;
1187     }
1188     return len;
1189 }
1190
1191 /*
1192  * Read/writes the data to/from a given linear buffer.
1193  *
1194  * Returns the number of bytes handles or -errno in case of an error. Short
1195  * reads are only returned if the end of the file is reached.
1196  */
1197 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
1198 {
1199     ssize_t offset = 0;
1200     ssize_t len;
1201
1202     while (offset < aiocb->aio_nbytes) {
1203         if (aiocb->aio_type & QEMU_AIO_WRITE) {
1204             len = pwrite(aiocb->aio_fildes,
1205                          (const char *)buf + offset,
1206                          aiocb->aio_nbytes - offset,
1207                          aiocb->aio_offset + offset);
1208         } else {
1209             len = pread(aiocb->aio_fildes,
1210                         buf + offset,
1211                         aiocb->aio_nbytes - offset,
1212                         aiocb->aio_offset + offset);
1213         }
1214         if (len == -1 && errno == EINTR) {
1215             continue;
1216         } else if (len == -1 && errno == EINVAL &&
1217                    (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
1218                    !(aiocb->aio_type & QEMU_AIO_WRITE) &&
1219                    offset > 0) {
1220             /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
1221              * after a short read.  Assume that O_DIRECT short reads only occur
1222              * at EOF.  Therefore this is a short read, not an I/O error.
1223              */
1224             break;
1225         } else if (len == -1) {
1226             offset = -errno;
1227             break;
1228         } else if (len == 0) {
1229             break;
1230         }
1231         offset += len;
1232     }
1233
1234     return offset;
1235 }
1236
1237 static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
1238 {
1239     ssize_t nbytes;
1240     char *buf;
1241
1242     if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
1243         /*
1244          * If there is just a single buffer, and it is properly aligned
1245          * we can just use plain pread/pwrite without any problems.
1246          */
1247         if (aiocb->aio_niov == 1) {
1248              return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base);
1249         }
1250         /*
1251          * We have more than one iovec, and all are properly aligned.
1252          *
1253          * Try preadv/pwritev first and fall back to linearizing the
1254          * buffer if it's not supported.
1255          */
1256         if (preadv_present) {
1257             nbytes = handle_aiocb_rw_vector(aiocb);
1258             if (nbytes == aiocb->aio_nbytes ||
1259                 (nbytes < 0 && nbytes != -ENOSYS)) {
1260                 return nbytes;
1261             }
1262             preadv_present = false;
1263         }
1264
1265         /*
1266          * XXX(hch): short read/write.  no easy way to handle the reminder
1267          * using these interfaces.  For now retry using plain
1268          * pread/pwrite?
1269          */
1270     }
1271
1272     /*
1273      * Ok, we have to do it the hard way, copy all segments into
1274      * a single aligned buffer.
1275      */
1276     buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
1277     if (buf == NULL) {
1278         return -ENOMEM;
1279     }
1280
1281     if (aiocb->aio_type & QEMU_AIO_WRITE) {
1282         char *p = buf;
1283         int i;
1284
1285         for (i = 0; i < aiocb->aio_niov; ++i) {
1286             memcpy(p, aiocb->aio_iov[i].iov_base, aiocb->aio_iov[i].iov_len);
1287             p += aiocb->aio_iov[i].iov_len;
1288         }
1289         assert(p - buf == aiocb->aio_nbytes);
1290     }
1291
1292     nbytes = handle_aiocb_rw_linear(aiocb, buf);
1293     if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
1294         char *p = buf;
1295         size_t count = aiocb->aio_nbytes, copy;
1296         int i;
1297
1298         for (i = 0; i < aiocb->aio_niov && count; ++i) {
1299             copy = count;
1300             if (copy > aiocb->aio_iov[i].iov_len) {
1301                 copy = aiocb->aio_iov[i].iov_len;
1302             }
1303             memcpy(aiocb->aio_iov[i].iov_base, p, copy);
1304             assert(count >= copy);
1305             p     += copy;
1306             count -= copy;
1307         }
1308         assert(count == 0);
1309     }
1310     qemu_vfree(buf);
1311
1312     return nbytes;
1313 }
1314
1315 #ifdef CONFIG_XFS
1316 static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes)
1317 {
1318     struct xfs_flock64 fl;
1319     int err;
1320
1321     memset(&fl, 0, sizeof(fl));
1322     fl.l_whence = SEEK_SET;
1323     fl.l_start = offset;
1324     fl.l_len = bytes;
1325
1326     if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) {
1327         err = errno;
1328         DPRINTF("cannot write zero range (%s)\n", strerror(errno));
1329         return -err;
1330     }
1331
1332     return 0;
1333 }
1334
1335 static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes)
1336 {
1337     struct xfs_flock64 fl;
1338     int err;
1339
1340     memset(&fl, 0, sizeof(fl));
1341     fl.l_whence = SEEK_SET;
1342     fl.l_start = offset;
1343     fl.l_len = bytes;
1344
1345     if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {
1346         err = errno;
1347         DPRINTF("cannot punch hole (%s)\n", strerror(errno));
1348         return -err;
1349     }
1350
1351     return 0;
1352 }
1353 #endif
1354
1355 static int translate_err(int err)
1356 {
1357     if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1358         err == -ENOTTY) {
1359         err = -ENOTSUP;
1360     }
1361     return err;
1362 }
1363
1364 #ifdef CONFIG_FALLOCATE
1365 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1366 {
1367     do {
1368         if (fallocate(fd, mode, offset, len) == 0) {
1369             return 0;
1370         }
1371     } while (errno == EINTR);
1372     return translate_err(-errno);
1373 }
1374 #endif
1375
1376 static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1377 {
1378     int ret = -ENOTSUP;
1379     BDRVRawState *s = aiocb->bs->opaque;
1380
1381     if (!s->has_write_zeroes) {
1382         return -ENOTSUP;
1383     }
1384
1385 #ifdef BLKZEROOUT
1386     do {
1387         uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1388         if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1389             return 0;
1390         }
1391     } while (errno == EINTR);
1392
1393     ret = translate_err(-errno);
1394 #endif
1395
1396     if (ret == -ENOTSUP) {
1397         s->has_write_zeroes = false;
1398     }
1399     return ret;
1400 }
1401
1402 static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb)
1403 {
1404 #if defined(CONFIG_FALLOCATE) || defined(CONFIG_XFS)
1405     BDRVRawState *s = aiocb->bs->opaque;
1406 #endif
1407 #ifdef CONFIG_FALLOCATE
1408     int64_t len;
1409 #endif
1410
1411     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1412         return handle_aiocb_write_zeroes_block(aiocb);
1413     }
1414
1415 #ifdef CONFIG_XFS
1416     if (s->is_xfs) {
1417         return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes);
1418     }
1419 #endif
1420
1421 #ifdef CONFIG_FALLOCATE_ZERO_RANGE
1422     if (s->has_write_zeroes) {
1423         int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1424                                aiocb->aio_offset, aiocb->aio_nbytes);
1425         if (ret == 0 || ret != -ENOTSUP) {
1426             return ret;
1427         }
1428         s->has_write_zeroes = false;
1429     }
1430 #endif
1431
1432 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1433     if (s->has_discard && s->has_fallocate) {
1434         int ret = do_fallocate(s->fd,
1435                                FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1436                                aiocb->aio_offset, aiocb->aio_nbytes);
1437         if (ret == 0) {
1438             ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1439             if (ret == 0 || ret != -ENOTSUP) {
1440                 return ret;
1441             }
1442             s->has_fallocate = false;
1443         } else if (ret != -ENOTSUP) {
1444             return ret;
1445         } else {
1446             s->has_discard = false;
1447         }
1448     }
1449 #endif
1450
1451 #ifdef CONFIG_FALLOCATE
1452     /* Last resort: we are trying to extend the file with zeroed data. This
1453      * can be done via fallocate(fd, 0) */
1454     len = bdrv_getlength(aiocb->bs);
1455     if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
1456         int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1457         if (ret == 0 || ret != -ENOTSUP) {
1458             return ret;
1459         }
1460         s->has_fallocate = false;
1461     }
1462 #endif
1463
1464     return -ENOTSUP;
1465 }
1466
1467 #ifndef HAVE_COPY_FILE_RANGE
1468 static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
1469                              off_t *out_off, size_t len, unsigned int flags)
1470 {
1471 #ifdef __NR_copy_file_range
1472     return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
1473                    out_off, len, flags);
1474 #else
1475     errno = ENOSYS;
1476     return -1;
1477 #endif
1478 }
1479 #endif
1480
1481 static ssize_t handle_aiocb_copy_range(RawPosixAIOData *aiocb)
1482 {
1483     uint64_t bytes = aiocb->aio_nbytes;
1484     off_t in_off = aiocb->aio_offset;
1485     off_t out_off = aiocb->aio_offset2;
1486
1487     while (bytes) {
1488         ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
1489                                       aiocb->aio_fd2, &out_off,
1490                                       bytes, 0);
1491         if (ret == 0) {
1492             /* No progress (e.g. when beyond EOF), let the caller fall back to
1493              * buffer I/O. */
1494             return -ENOSPC;
1495         }
1496         if (ret < 0) {
1497             switch (errno) {
1498             case ENOSYS:
1499                 return -ENOTSUP;
1500             case EINTR:
1501                 continue;
1502             default:
1503                 return -errno;
1504             }
1505         }
1506         bytes -= ret;
1507     }
1508     return 0;
1509 }
1510
1511 static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb)
1512 {
1513     int ret = -EOPNOTSUPP;
1514     BDRVRawState *s = aiocb->bs->opaque;
1515
1516     if (!s->has_discard) {
1517         return -ENOTSUP;
1518     }
1519
1520     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1521 #ifdef BLKDISCARD
1522         do {
1523             uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1524             if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1525                 return 0;
1526             }
1527         } while (errno == EINTR);
1528
1529         ret = -errno;
1530 #endif
1531     } else {
1532 #ifdef CONFIG_XFS
1533         if (s->is_xfs) {
1534             return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1535         }
1536 #endif
1537
1538 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1539         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1540                            aiocb->aio_offset, aiocb->aio_nbytes);
1541 #endif
1542     }
1543
1544     ret = translate_err(ret);
1545     if (ret == -ENOTSUP) {
1546         s->has_discard = false;
1547     }
1548     return ret;
1549 }
1550
1551 static int handle_aiocb_truncate(RawPosixAIOData *aiocb)
1552 {
1553     int result = 0;
1554     int64_t current_length = 0;
1555     char *buf = NULL;
1556     struct stat st;
1557     int fd = aiocb->aio_fildes;
1558     int64_t offset = aiocb->aio_offset;
1559     Error **errp = aiocb->errp;
1560
1561     if (fstat(fd, &st) < 0) {
1562         result = -errno;
1563         error_setg_errno(errp, -result, "Could not stat file");
1564         return result;
1565     }
1566
1567     current_length = st.st_size;
1568     if (current_length > offset && aiocb->prealloc != PREALLOC_MODE_OFF) {
1569         error_setg(errp, "Cannot use preallocation for shrinking files");
1570         return -ENOTSUP;
1571     }
1572
1573     switch (aiocb->prealloc) {
1574 #ifdef CONFIG_POSIX_FALLOCATE
1575     case PREALLOC_MODE_FALLOC:
1576         /*
1577          * Truncating before posix_fallocate() makes it about twice slower on
1578          * file systems that do not support fallocate(), trying to check if a
1579          * block is allocated before allocating it, so don't do that here.
1580          */
1581         if (offset != current_length) {
1582             result = -posix_fallocate(fd, current_length,
1583                                       offset - current_length);
1584             if (result != 0) {
1585                 /* posix_fallocate() doesn't set errno. */
1586                 error_setg_errno(errp, -result,
1587                                  "Could not preallocate new data");
1588             }
1589         } else {
1590             result = 0;
1591         }
1592         goto out;
1593 #endif
1594     case PREALLOC_MODE_FULL:
1595     {
1596         int64_t num = 0, left = offset - current_length;
1597         off_t seek_result;
1598
1599         /*
1600          * Knowing the final size from the beginning could allow the file
1601          * system driver to do less allocations and possibly avoid
1602          * fragmentation of the file.
1603          */
1604         if (ftruncate(fd, offset) != 0) {
1605             result = -errno;
1606             error_setg_errno(errp, -result, "Could not resize file");
1607             goto out;
1608         }
1609
1610         buf = g_malloc0(65536);
1611
1612         seek_result = lseek(fd, current_length, SEEK_SET);
1613         if (seek_result < 0) {
1614             result = -errno;
1615             error_setg_errno(errp, -result,
1616                              "Failed to seek to the old end of file");
1617             goto out;
1618         }
1619
1620         while (left > 0) {
1621             num = MIN(left, 65536);
1622             result = write(fd, buf, num);
1623             if (result < 0) {
1624                 result = -errno;
1625                 error_setg_errno(errp, -result,
1626                                  "Could not write zeros for preallocation");
1627                 goto out;
1628             }
1629             left -= result;
1630         }
1631         if (result >= 0) {
1632             result = fsync(fd);
1633             if (result < 0) {
1634                 result = -errno;
1635                 error_setg_errno(errp, -result,
1636                                  "Could not flush file to disk");
1637                 goto out;
1638             }
1639         }
1640         goto out;
1641     }
1642     case PREALLOC_MODE_OFF:
1643         if (ftruncate(fd, offset) != 0) {
1644             result = -errno;
1645             error_setg_errno(errp, -result, "Could not resize file");
1646         }
1647         return result;
1648     default:
1649         result = -ENOTSUP;
1650         error_setg(errp, "Unsupported preallocation mode: %s",
1651                    PreallocMode_str(aiocb->prealloc));
1652         return result;
1653     }
1654
1655 out:
1656     if (result < 0) {
1657         if (ftruncate(fd, current_length) < 0) {
1658             error_report("Failed to restore old file length: %s",
1659                          strerror(errno));
1660         }
1661     }
1662
1663     g_free(buf);
1664     return result;
1665 }
1666
1667 static int aio_worker(void *arg)
1668 {
1669     RawPosixAIOData *aiocb = arg;
1670     ssize_t ret = 0;
1671
1672     switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
1673     case QEMU_AIO_READ:
1674         ret = handle_aiocb_rw(aiocb);
1675         if (ret >= 0 && ret < aiocb->aio_nbytes) {
1676             iov_memset(aiocb->aio_iov, aiocb->aio_niov, ret,
1677                       0, aiocb->aio_nbytes - ret);
1678
1679             ret = aiocb->aio_nbytes;
1680         }
1681         if (ret == aiocb->aio_nbytes) {
1682             ret = 0;
1683         } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1684             ret = -EINVAL;
1685         }
1686         break;
1687     case QEMU_AIO_WRITE:
1688         ret = handle_aiocb_rw(aiocb);
1689         if (ret == aiocb->aio_nbytes) {
1690             ret = 0;
1691         } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
1692             ret = -EINVAL;
1693         }
1694         break;
1695     case QEMU_AIO_FLUSH:
1696         ret = handle_aiocb_flush(aiocb);
1697         break;
1698     case QEMU_AIO_IOCTL:
1699         ret = handle_aiocb_ioctl(aiocb);
1700         break;
1701     case QEMU_AIO_DISCARD:
1702         ret = handle_aiocb_discard(aiocb);
1703         break;
1704     case QEMU_AIO_WRITE_ZEROES:
1705         ret = handle_aiocb_write_zeroes(aiocb);
1706         break;
1707     case QEMU_AIO_COPY_RANGE:
1708         ret = handle_aiocb_copy_range(aiocb);
1709         break;
1710     case QEMU_AIO_TRUNCATE:
1711         ret = handle_aiocb_truncate(aiocb);
1712         break;
1713     default:
1714         fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
1715         ret = -EINVAL;
1716         break;
1717     }
1718
1719     g_free(aiocb);
1720     return ret;
1721 }
1722
1723 static int paio_submit_co_full(BlockDriverState *bs, int fd,
1724                                int64_t offset, int fd2, int64_t offset2,
1725                                QEMUIOVector *qiov,
1726                                int bytes, int type)
1727 {
1728     RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
1729     ThreadPool *pool;
1730
1731     acb->bs = bs;
1732     acb->aio_type = type;
1733     acb->aio_fildes = fd;
1734     acb->aio_fd2 = fd2;
1735     acb->aio_offset2 = offset2;
1736
1737     acb->aio_nbytes = bytes;
1738     acb->aio_offset = offset;
1739
1740     if (qiov) {
1741         acb->aio_iov = qiov->iov;
1742         acb->aio_niov = qiov->niov;
1743         assert(qiov->size == bytes);
1744     }
1745
1746     trace_paio_submit_co(offset, bytes, type);
1747     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1748     return thread_pool_submit_co(pool, aio_worker, acb);
1749 }
1750
1751 static inline int paio_submit_co(BlockDriverState *bs, int fd,
1752                                  int64_t offset, QEMUIOVector *qiov,
1753                                  int bytes, int type)
1754 {
1755     return paio_submit_co_full(bs, fd, offset, -1, 0, qiov, bytes, type);
1756 }
1757
1758 static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
1759                                    uint64_t bytes, QEMUIOVector *qiov, int type)
1760 {
1761     BDRVRawState *s = bs->opaque;
1762
1763     if (fd_open(bs) < 0)
1764         return -EIO;
1765
1766     /*
1767      * Check if the underlying device requires requests to be aligned,
1768      * and if the request we are trying to submit is aligned or not.
1769      * If this is the case tell the low-level driver that it needs
1770      * to copy the buffer.
1771      */
1772     if (s->needs_alignment) {
1773         if (!bdrv_qiov_is_aligned(bs, qiov)) {
1774             type |= QEMU_AIO_MISALIGNED;
1775 #ifdef CONFIG_LINUX_AIO
1776         } else if (s->use_linux_aio) {
1777             LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1778             assert(qiov->size == bytes);
1779             return laio_co_submit(bs, aio, s->fd, offset, qiov, type);
1780 #endif
1781         }
1782     }
1783
1784     return paio_submit_co(bs, s->fd, offset, qiov, bytes, type);
1785 }
1786
1787 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
1788                                       uint64_t bytes, QEMUIOVector *qiov,
1789                                       int flags)
1790 {
1791     return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
1792 }
1793
1794 static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
1795                                        uint64_t bytes, QEMUIOVector *qiov,
1796                                        int flags)
1797 {
1798     assert(flags == 0);
1799     return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
1800 }
1801
1802 static void raw_aio_plug(BlockDriverState *bs)
1803 {
1804 #ifdef CONFIG_LINUX_AIO
1805     BDRVRawState *s = bs->opaque;
1806     if (s->use_linux_aio) {
1807         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1808         laio_io_plug(bs, aio);
1809     }
1810 #endif
1811 }
1812
1813 static void raw_aio_unplug(BlockDriverState *bs)
1814 {
1815 #ifdef CONFIG_LINUX_AIO
1816     BDRVRawState *s = bs->opaque;
1817     if (s->use_linux_aio) {
1818         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1819         laio_io_unplug(bs, aio);
1820     }
1821 #endif
1822 }
1823
1824 static int raw_co_flush_to_disk(BlockDriverState *bs)
1825 {
1826     BDRVRawState *s = bs->opaque;
1827     int ret;
1828
1829     ret = fd_open(bs);
1830     if (ret < 0) {
1831         return ret;
1832     }
1833
1834     return paio_submit_co(bs, s->fd, 0, NULL, 0, QEMU_AIO_FLUSH);
1835 }
1836
1837 static void raw_aio_attach_aio_context(BlockDriverState *bs,
1838                                        AioContext *new_context)
1839 {
1840 #ifdef CONFIG_LINUX_AIO
1841     BDRVRawState *s = bs->opaque;
1842     if (s->use_linux_aio) {
1843         Error *local_err;
1844         if (!aio_setup_linux_aio(new_context, &local_err)) {
1845             error_reportf_err(local_err, "Unable to use native AIO, "
1846                                          "falling back to thread pool: ");
1847             s->use_linux_aio = false;
1848         }
1849     }
1850 #endif
1851 }
1852
1853 static void raw_close(BlockDriverState *bs)
1854 {
1855     BDRVRawState *s = bs->opaque;
1856
1857     if (s->fd >= 0) {
1858         qemu_close(s->fd);
1859         s->fd = -1;
1860     }
1861     if (s->lock_fd >= 0) {
1862         qemu_close(s->lock_fd);
1863         s->lock_fd = -1;
1864     }
1865 }
1866
1867 /**
1868  * Truncates the given regular file @fd to @offset and, when growing, fills the
1869  * new space according to @prealloc.
1870  *
1871  * Returns: 0 on success, -errno on failure.
1872  */
1873 static int coroutine_fn
1874 raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
1875                      PreallocMode prealloc, Error **errp)
1876 {
1877     RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
1878     ThreadPool *pool;
1879
1880     *acb = (RawPosixAIOData) {
1881         .bs             = bs,
1882         .aio_fildes     = fd,
1883         .aio_type       = QEMU_AIO_TRUNCATE,
1884         .aio_offset     = offset,
1885         .prealloc       = prealloc,
1886         .errp           = errp,
1887     };
1888
1889     /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */
1890     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1891     return thread_pool_submit_co(pool, aio_worker, acb);
1892 }
1893
1894 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
1895                                         PreallocMode prealloc, Error **errp)
1896 {
1897     BDRVRawState *s = bs->opaque;
1898     struct stat st;
1899     int ret;
1900
1901     if (fstat(s->fd, &st)) {
1902         ret = -errno;
1903         error_setg_errno(errp, -ret, "Failed to fstat() the file");
1904         return ret;
1905     }
1906
1907     if (S_ISREG(st.st_mode)) {
1908         return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
1909     }
1910
1911     if (prealloc != PREALLOC_MODE_OFF) {
1912         error_setg(errp, "Preallocation mode '%s' unsupported for this "
1913                    "non-regular file", PreallocMode_str(prealloc));
1914         return -ENOTSUP;
1915     }
1916
1917     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1918         if (offset > raw_getlength(bs)) {
1919             error_setg(errp, "Cannot grow device files");
1920             return -EINVAL;
1921         }
1922     } else {
1923         error_setg(errp, "Resizing this file is not supported");
1924         return -ENOTSUP;
1925     }
1926
1927     return 0;
1928 }
1929
1930 #ifdef __OpenBSD__
1931 static int64_t raw_getlength(BlockDriverState *bs)
1932 {
1933     BDRVRawState *s = bs->opaque;
1934     int fd = s->fd;
1935     struct stat st;
1936
1937     if (fstat(fd, &st))
1938         return -errno;
1939     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1940         struct disklabel dl;
1941
1942         if (ioctl(fd, DIOCGDINFO, &dl))
1943             return -errno;
1944         return (uint64_t)dl.d_secsize *
1945             dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1946     } else
1947         return st.st_size;
1948 }
1949 #elif defined(__NetBSD__)
1950 static int64_t raw_getlength(BlockDriverState *bs)
1951 {
1952     BDRVRawState *s = bs->opaque;
1953     int fd = s->fd;
1954     struct stat st;
1955
1956     if (fstat(fd, &st))
1957         return -errno;
1958     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1959         struct dkwedge_info dkw;
1960
1961         if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
1962             return dkw.dkw_size * 512;
1963         } else {
1964             struct disklabel dl;
1965
1966             if (ioctl(fd, DIOCGDINFO, &dl))
1967                 return -errno;
1968             return (uint64_t)dl.d_secsize *
1969                 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
1970         }
1971     } else
1972         return st.st_size;
1973 }
1974 #elif defined(__sun__)
1975 static int64_t raw_getlength(BlockDriverState *bs)
1976 {
1977     BDRVRawState *s = bs->opaque;
1978     struct dk_minfo minfo;
1979     int ret;
1980     int64_t size;
1981
1982     ret = fd_open(bs);
1983     if (ret < 0) {
1984         return ret;
1985     }
1986
1987     /*
1988      * Use the DKIOCGMEDIAINFO ioctl to read the size.
1989      */
1990     ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
1991     if (ret != -1) {
1992         return minfo.dki_lbsize * minfo.dki_capacity;
1993     }
1994
1995     /*
1996      * There are reports that lseek on some devices fails, but
1997      * irc discussion said that contingency on contingency was overkill.
1998      */
1999     size = lseek(s->fd, 0, SEEK_END);
2000     if (size < 0) {
2001         return -errno;
2002     }
2003     return size;
2004 }
2005 #elif defined(CONFIG_BSD)
2006 static int64_t raw_getlength(BlockDriverState *bs)
2007 {
2008     BDRVRawState *s = bs->opaque;
2009     int fd = s->fd;
2010     int64_t size;
2011     struct stat sb;
2012 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2013     int reopened = 0;
2014 #endif
2015     int ret;
2016
2017     ret = fd_open(bs);
2018     if (ret < 0)
2019         return ret;
2020
2021 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2022 again:
2023 #endif
2024     if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2025 #ifdef DIOCGMEDIASIZE
2026         if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
2027 #elif defined(DIOCGPART)
2028         {
2029                 struct partinfo pi;
2030                 if (ioctl(fd, DIOCGPART, &pi) == 0)
2031                         size = pi.media_size;
2032                 else
2033                         size = 0;
2034         }
2035         if (size == 0)
2036 #endif
2037 #if defined(__APPLE__) && defined(__MACH__)
2038         {
2039             uint64_t sectors = 0;
2040             uint32_t sector_size = 0;
2041
2042             if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
2043                && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
2044                 size = sectors * sector_size;
2045             } else {
2046                 size = lseek(fd, 0LL, SEEK_END);
2047                 if (size < 0) {
2048                     return -errno;
2049                 }
2050             }
2051         }
2052 #else
2053         size = lseek(fd, 0LL, SEEK_END);
2054         if (size < 0) {
2055             return -errno;
2056         }
2057 #endif
2058 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2059         switch(s->type) {
2060         case FTYPE_CD:
2061             /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
2062             if (size == 2048LL * (unsigned)-1)
2063                 size = 0;
2064             /* XXX no disc?  maybe we need to reopen... */
2065             if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
2066                 reopened = 1;
2067                 goto again;
2068             }
2069         }
2070 #endif
2071     } else {
2072         size = lseek(fd, 0, SEEK_END);
2073         if (size < 0) {
2074             return -errno;
2075         }
2076     }
2077     return size;
2078 }
2079 #else
2080 static int64_t raw_getlength(BlockDriverState *bs)
2081 {
2082     BDRVRawState *s = bs->opaque;
2083     int ret;
2084     int64_t size;
2085
2086     ret = fd_open(bs);
2087     if (ret < 0) {
2088         return ret;
2089     }
2090
2091     size = lseek(s->fd, 0, SEEK_END);
2092     if (size < 0) {
2093         return -errno;
2094     }
2095     return size;
2096 }
2097 #endif
2098
2099 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
2100 {
2101     struct stat st;
2102     BDRVRawState *s = bs->opaque;
2103
2104     if (fstat(s->fd, &st) < 0) {
2105         return -errno;
2106     }
2107     return (int64_t)st.st_blocks * 512;
2108 }
2109
2110 static int coroutine_fn
2111 raw_co_create(BlockdevCreateOptions *options, Error **errp)
2112 {
2113     BlockdevCreateOptionsFile *file_opts;
2114     Error *local_err = NULL;
2115     int fd;
2116     uint64_t perm, shared;
2117     int result = 0;
2118
2119     /* Validate options and set default values */
2120     assert(options->driver == BLOCKDEV_DRIVER_FILE);
2121     file_opts = &options->u.file;
2122
2123     if (!file_opts->has_nocow) {
2124         file_opts->nocow = false;
2125     }
2126     if (!file_opts->has_preallocation) {
2127         file_opts->preallocation = PREALLOC_MODE_OFF;
2128     }
2129
2130     /* Create file */
2131     fd = qemu_open(file_opts->filename, O_RDWR | O_CREAT | O_BINARY, 0644);
2132     if (fd < 0) {
2133         result = -errno;
2134         error_setg_errno(errp, -result, "Could not create file");
2135         goto out;
2136     }
2137
2138     /* Take permissions: We want to discard everything, so we need
2139      * BLK_PERM_WRITE; and truncation to the desired size requires
2140      * BLK_PERM_RESIZE.
2141      * On the other hand, we cannot share the RESIZE permission
2142      * because we promise that after this function, the file has the
2143      * size given in the options.  If someone else were to resize it
2144      * concurrently, we could not guarantee that.
2145      * Note that after this function, we can no longer guarantee that
2146      * the file is not touched by a third party, so it may be resized
2147      * then. */
2148     perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2149     shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2150
2151     /* Step one: Take locks */
2152     result = raw_apply_lock_bytes(fd, perm, ~shared, false, errp);
2153     if (result < 0) {
2154         goto out_close;
2155     }
2156
2157     /* Step two: Check that nobody else has taken conflicting locks */
2158     result = raw_check_lock_bytes(fd, perm, shared, errp);
2159     if (result < 0) {
2160         goto out_unlock;
2161     }
2162
2163     /* Clear the file by truncating it to 0 */
2164     result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
2165     if (result < 0) {
2166         goto out_unlock;
2167     }
2168
2169     if (file_opts->nocow) {
2170 #ifdef __linux__
2171         /* Set NOCOW flag to solve performance issue on fs like btrfs.
2172          * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
2173          * will be ignored since any failure of this operation should not
2174          * block the left work.
2175          */
2176         int attr;
2177         if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2178             attr |= FS_NOCOW_FL;
2179             ioctl(fd, FS_IOC_SETFLAGS, &attr);
2180         }
2181 #endif
2182     }
2183
2184     /* Resize and potentially preallocate the file to the desired
2185      * final size */
2186     result = raw_regular_truncate(NULL, fd, file_opts->size,
2187                                   file_opts->preallocation, errp);
2188     if (result < 0) {
2189         goto out_unlock;
2190     }
2191
2192 out_unlock:
2193     raw_apply_lock_bytes(fd, 0, 0, true, &local_err);
2194     if (local_err) {
2195         /* The above call should not fail, and if it does, that does
2196          * not mean the whole creation operation has failed.  So
2197          * report it the user for their convenience, but do not report
2198          * it to the caller. */
2199         error_report_err(local_err);
2200     }
2201
2202 out_close:
2203     if (qemu_close(fd) != 0 && result == 0) {
2204         result = -errno;
2205         error_setg_errno(errp, -result, "Could not close the new file");
2206     }
2207 out:
2208     return result;
2209 }
2210
2211 static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,
2212                                            Error **errp)
2213 {
2214     BlockdevCreateOptions options;
2215     int64_t total_size = 0;
2216     bool nocow = false;
2217     PreallocMode prealloc;
2218     char *buf = NULL;
2219     Error *local_err = NULL;
2220
2221     /* Skip file: protocol prefix */
2222     strstart(filename, "file:", &filename);
2223
2224     /* Read out options */
2225     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2226                           BDRV_SECTOR_SIZE);
2227     nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
2228     buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2229     prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
2230                                PREALLOC_MODE_OFF, &local_err);
2231     g_free(buf);
2232     if (local_err) {
2233         error_propagate(errp, local_err);
2234         return -EINVAL;
2235     }
2236
2237     options = (BlockdevCreateOptions) {
2238         .driver     = BLOCKDEV_DRIVER_FILE,
2239         .u.file     = {
2240             .filename           = (char *) filename,
2241             .size               = total_size,
2242             .has_preallocation  = true,
2243             .preallocation      = prealloc,
2244             .has_nocow          = true,
2245             .nocow              = nocow,
2246         },
2247     };
2248     return raw_co_create(&options, errp);
2249 }
2250
2251 /*
2252  * Find allocation range in @bs around offset @start.
2253  * May change underlying file descriptor's file offset.
2254  * If @start is not in a hole, store @start in @data, and the
2255  * beginning of the next hole in @hole, and return 0.
2256  * If @start is in a non-trailing hole, store @start in @hole and the
2257  * beginning of the next non-hole in @data, and return 0.
2258  * If @start is in a trailing hole or beyond EOF, return -ENXIO.
2259  * If we can't find out, return a negative errno other than -ENXIO.
2260  */
2261 static int find_allocation(BlockDriverState *bs, off_t start,
2262                            off_t *data, off_t *hole)
2263 {
2264 #if defined SEEK_HOLE && defined SEEK_DATA
2265     BDRVRawState *s = bs->opaque;
2266     off_t offs;
2267
2268     /*
2269      * SEEK_DATA cases:
2270      * D1. offs == start: start is in data
2271      * D2. offs > start: start is in a hole, next data at offs
2272      * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
2273      *                              or start is beyond EOF
2274      *     If the latter happens, the file has been truncated behind
2275      *     our back since we opened it.  All bets are off then.
2276      *     Treating like a trailing hole is simplest.
2277      * D4. offs < 0, errno != ENXIO: we learned nothing
2278      */
2279     offs = lseek(s->fd, start, SEEK_DATA);
2280     if (offs < 0) {
2281         return -errno;          /* D3 or D4 */
2282     }
2283
2284     if (offs < start) {
2285         /* This is not a valid return by lseek().  We are safe to just return
2286          * -EIO in this case, and we'll treat it like D4. */
2287         return -EIO;
2288     }
2289
2290     if (offs > start) {
2291         /* D2: in hole, next data at offs */
2292         *hole = start;
2293         *data = offs;
2294         return 0;
2295     }
2296
2297     /* D1: in data, end not yet known */
2298
2299     /*
2300      * SEEK_HOLE cases:
2301      * H1. offs == start: start is in a hole
2302      *     If this happens here, a hole has been dug behind our back
2303      *     since the previous lseek().
2304      * H2. offs > start: either start is in data, next hole at offs,
2305      *                   or start is in trailing hole, EOF at offs
2306      *     Linux treats trailing holes like any other hole: offs ==
2307      *     start.  Solaris seeks to EOF instead: offs > start (blech).
2308      *     If that happens here, a hole has been dug behind our back
2309      *     since the previous lseek().
2310      * H3. offs < 0, errno = ENXIO: start is beyond EOF
2311      *     If this happens, the file has been truncated behind our
2312      *     back since we opened it.  Treat it like a trailing hole.
2313      * H4. offs < 0, errno != ENXIO: we learned nothing
2314      *     Pretend we know nothing at all, i.e. "forget" about D1.
2315      */
2316     offs = lseek(s->fd, start, SEEK_HOLE);
2317     if (offs < 0) {
2318         return -errno;          /* D1 and (H3 or H4) */
2319     }
2320
2321     if (offs < start) {
2322         /* This is not a valid return by lseek().  We are safe to just return
2323          * -EIO in this case, and we'll treat it like H4. */
2324         return -EIO;
2325     }
2326
2327     if (offs > start) {
2328         /*
2329          * D1 and H2: either in data, next hole at offs, or it was in
2330          * data but is now in a trailing hole.  In the latter case,
2331          * all bets are off.  Treating it as if it there was data all
2332          * the way to EOF is safe, so simply do that.
2333          */
2334         *data = start;
2335         *hole = offs;
2336         return 0;
2337     }
2338
2339     /* D1 and H1 */
2340     return -EBUSY;
2341 #else
2342     return -ENOTSUP;
2343 #endif
2344 }
2345
2346 /*
2347  * Returns the allocation status of the specified offset.
2348  *
2349  * The block layer guarantees 'offset' and 'bytes' are within bounds.
2350  *
2351  * 'pnum' is set to the number of bytes (including and immediately following
2352  * the specified offset) that are known to be in the same
2353  * allocated/unallocated state.
2354  *
2355  * 'bytes' is the max value 'pnum' should be set to.
2356  */
2357 static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
2358                                             bool want_zero,
2359                                             int64_t offset,
2360                                             int64_t bytes, int64_t *pnum,
2361                                             int64_t *map,
2362                                             BlockDriverState **file)
2363 {
2364     off_t data = 0, hole = 0;
2365     int ret;
2366
2367     ret = fd_open(bs);
2368     if (ret < 0) {
2369         return ret;
2370     }
2371
2372     if (!want_zero) {
2373         *pnum = bytes;
2374         *map = offset;
2375         *file = bs;
2376         return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
2377     }
2378
2379     ret = find_allocation(bs, offset, &data, &hole);
2380     if (ret == -ENXIO) {
2381         /* Trailing hole */
2382         *pnum = bytes;
2383         ret = BDRV_BLOCK_ZERO;
2384     } else if (ret < 0) {
2385         /* No info available, so pretend there are no holes */
2386         *pnum = bytes;
2387         ret = BDRV_BLOCK_DATA;
2388     } else if (data == offset) {
2389         /* On a data extent, compute bytes to the end of the extent,
2390          * possibly including a partial sector at EOF. */
2391         *pnum = MIN(bytes, hole - offset);
2392         ret = BDRV_BLOCK_DATA;
2393     } else {
2394         /* On a hole, compute bytes to the beginning of the next extent.  */
2395         assert(hole == offset);
2396         *pnum = MIN(bytes, data - offset);
2397         ret = BDRV_BLOCK_ZERO;
2398     }
2399     *map = offset;
2400     *file = bs;
2401     return ret | BDRV_BLOCK_OFFSET_VALID;
2402 }
2403
2404 #if defined(__linux__)
2405 /* Verify that the file is not in the page cache */
2406 static void check_cache_dropped(BlockDriverState *bs, Error **errp)
2407 {
2408     const size_t window_size = 128 * 1024 * 1024;
2409     BDRVRawState *s = bs->opaque;
2410     void *window = NULL;
2411     size_t length = 0;
2412     unsigned char *vec;
2413     size_t page_size;
2414     off_t offset;
2415     off_t end;
2416
2417     /* mincore(2) page status information requires 1 byte per page */
2418     page_size = sysconf(_SC_PAGESIZE);
2419     vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
2420
2421     end = raw_getlength(bs);
2422
2423     for (offset = 0; offset < end; offset += window_size) {
2424         void *new_window;
2425         size_t new_length;
2426         size_t vec_end;
2427         size_t i;
2428         int ret;
2429
2430         /* Unmap previous window if size has changed */
2431         new_length = MIN(end - offset, window_size);
2432         if (new_length != length) {
2433             munmap(window, length);
2434             window = NULL;
2435             length = 0;
2436         }
2437
2438         new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
2439                           s->fd, offset);
2440         if (new_window == MAP_FAILED) {
2441             error_setg_errno(errp, errno, "mmap failed");
2442             break;
2443         }
2444
2445         window = new_window;
2446         length = new_length;
2447
2448         ret = mincore(window, length, vec);
2449         if (ret < 0) {
2450             error_setg_errno(errp, errno, "mincore failed");
2451             break;
2452         }
2453
2454         vec_end = DIV_ROUND_UP(length, page_size);
2455         for (i = 0; i < vec_end; i++) {
2456             if (vec[i] & 0x1) {
2457                 error_setg(errp, "page cache still in use!");
2458                 break;
2459             }
2460         }
2461     }
2462
2463     if (window) {
2464         munmap(window, length);
2465     }
2466
2467     g_free(vec);
2468 }
2469 #endif /* __linux__ */
2470
2471 static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs,
2472                                                  Error **errp)
2473 {
2474     BDRVRawState *s = bs->opaque;
2475     int ret;
2476
2477     ret = fd_open(bs);
2478     if (ret < 0) {
2479         error_setg_errno(errp, -ret, "The file descriptor is not open");
2480         return;
2481     }
2482
2483     if (s->open_flags & O_DIRECT) {
2484         return; /* No host kernel page cache */
2485     }
2486
2487 #if defined(__linux__)
2488     /* This sets the scene for the next syscall... */
2489     ret = bdrv_co_flush(bs);
2490     if (ret < 0) {
2491         error_setg_errno(errp, -ret, "flush failed");
2492         return;
2493     }
2494
2495     /* Linux does not invalidate pages that are dirty, locked, or mmapped by a
2496      * process.  These limitations are okay because we just fsynced the file,
2497      * we don't use mmap, and the file should not be in use by other processes.
2498      */
2499     ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
2500     if (ret != 0) { /* the return value is a positive errno */
2501         error_setg_errno(errp, ret, "fadvise failed");
2502         return;
2503     }
2504
2505     if (s->check_cache_dropped) {
2506         check_cache_dropped(bs, errp);
2507     }
2508 #else /* __linux__ */
2509     /* Do nothing.  Live migration to a remote host with cache.direct=off is
2510      * unsupported on other host operating systems.  Cache consistency issues
2511      * may occur but no error is reported here, partly because that's the
2512      * historical behavior and partly because it's hard to differentiate valid
2513      * configurations that should not cause errors.
2514      */
2515 #endif /* !__linux__ */
2516 }
2517
2518 static coroutine_fn int
2519 raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
2520 {
2521     BDRVRawState *s = bs->opaque;
2522
2523     return paio_submit_co(bs, s->fd, offset, NULL, bytes, QEMU_AIO_DISCARD);
2524 }
2525
2526 static int coroutine_fn raw_co_pwrite_zeroes(
2527     BlockDriverState *bs, int64_t offset,
2528     int bytes, BdrvRequestFlags flags)
2529 {
2530     BDRVRawState *s = bs->opaque;
2531
2532     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
2533         return paio_submit_co(bs, s->fd, offset, NULL, bytes,
2534                               QEMU_AIO_WRITE_ZEROES);
2535     } else if (s->discard_zeroes) {
2536         return paio_submit_co(bs, s->fd, offset, NULL, bytes,
2537                               QEMU_AIO_DISCARD);
2538     }
2539     return -ENOTSUP;
2540 }
2541
2542 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2543 {
2544     BDRVRawState *s = bs->opaque;
2545
2546     bdi->unallocated_blocks_are_zero = s->discard_zeroes;
2547     return 0;
2548 }
2549
2550 static QemuOptsList raw_create_opts = {
2551     .name = "raw-create-opts",
2552     .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
2553     .desc = {
2554         {
2555             .name = BLOCK_OPT_SIZE,
2556             .type = QEMU_OPT_SIZE,
2557             .help = "Virtual disk size"
2558         },
2559         {
2560             .name = BLOCK_OPT_NOCOW,
2561             .type = QEMU_OPT_BOOL,
2562             .help = "Turn off copy-on-write (valid only on btrfs)"
2563         },
2564         {
2565             .name = BLOCK_OPT_PREALLOC,
2566             .type = QEMU_OPT_STRING,
2567             .help = "Preallocation mode (allowed values: off, falloc, full)"
2568         },
2569         { /* end of list */ }
2570     }
2571 };
2572
2573 static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
2574                           Error **errp)
2575 {
2576     return raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
2577 }
2578
2579 static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
2580 {
2581     BDRVRawState *s = bs->opaque;
2582     raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
2583     s->perm = perm;
2584     s->shared_perm = shared;
2585 }
2586
2587 static void raw_abort_perm_update(BlockDriverState *bs)
2588 {
2589     raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
2590 }
2591
2592 static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
2593                                                BdrvChild *src, uint64_t src_offset,
2594                                                BdrvChild *dst, uint64_t dst_offset,
2595                                                uint64_t bytes, BdrvRequestFlags flags)
2596 {
2597     return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes, flags);
2598 }
2599
2600 static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
2601                                              BdrvChild *src, uint64_t src_offset,
2602                                              BdrvChild *dst, uint64_t dst_offset,
2603                                              uint64_t bytes, BdrvRequestFlags flags)
2604 {
2605     BDRVRawState *s = bs->opaque;
2606     BDRVRawState *src_s;
2607
2608     assert(dst->bs == bs);
2609     if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
2610         return -ENOTSUP;
2611     }
2612
2613     src_s = src->bs->opaque;
2614     if (fd_open(bs) < 0 || fd_open(bs) < 0) {
2615         return -EIO;
2616     }
2617     return paio_submit_co_full(bs, src_s->fd, src_offset, s->fd, dst_offset,
2618                                NULL, bytes, QEMU_AIO_COPY_RANGE);
2619 }
2620
2621 BlockDriver bdrv_file = {
2622     .format_name = "file",
2623     .protocol_name = "file",
2624     .instance_size = sizeof(BDRVRawState),
2625     .bdrv_needs_filename = true,
2626     .bdrv_probe = NULL, /* no probe for protocols */
2627     .bdrv_parse_filename = raw_parse_filename,
2628     .bdrv_file_open = raw_open,
2629     .bdrv_reopen_prepare = raw_reopen_prepare,
2630     .bdrv_reopen_commit = raw_reopen_commit,
2631     .bdrv_reopen_abort = raw_reopen_abort,
2632     .bdrv_close = raw_close,
2633     .bdrv_co_create = raw_co_create,
2634     .bdrv_co_create_opts = raw_co_create_opts,
2635     .bdrv_has_zero_init = bdrv_has_zero_init_1,
2636     .bdrv_co_block_status = raw_co_block_status,
2637     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
2638     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
2639
2640     .bdrv_co_preadv         = raw_co_preadv,
2641     .bdrv_co_pwritev        = raw_co_pwritev,
2642     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
2643     .bdrv_co_pdiscard       = raw_co_pdiscard,
2644     .bdrv_co_copy_range_from = raw_co_copy_range_from,
2645     .bdrv_co_copy_range_to  = raw_co_copy_range_to,
2646     .bdrv_refresh_limits = raw_refresh_limits,
2647     .bdrv_io_plug = raw_aio_plug,
2648     .bdrv_io_unplug = raw_aio_unplug,
2649     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
2650
2651     .bdrv_co_truncate = raw_co_truncate,
2652     .bdrv_getlength = raw_getlength,
2653     .bdrv_get_info = raw_get_info,
2654     .bdrv_get_allocated_file_size
2655                         = raw_get_allocated_file_size,
2656     .bdrv_check_perm = raw_check_perm,
2657     .bdrv_set_perm   = raw_set_perm,
2658     .bdrv_abort_perm_update = raw_abort_perm_update,
2659     .create_opts = &raw_create_opts,
2660 };
2661
2662 /***********************************************/
2663 /* host device */
2664
2665 #if defined(__APPLE__) && defined(__MACH__)
2666 static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
2667                                 CFIndex maxPathSize, int flags);
2668 static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
2669 {
2670     kern_return_t kernResult = KERN_FAILURE;
2671     mach_port_t     masterPort;
2672     CFMutableDictionaryRef  classesToMatch;
2673     const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
2674     char *mediaType = NULL;
2675
2676     kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
2677     if ( KERN_SUCCESS != kernResult ) {
2678         printf( "IOMasterPort returned %d\n", kernResult );
2679     }
2680
2681     int index;
2682     for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
2683         classesToMatch = IOServiceMatching(matching_array[index]);
2684         if (classesToMatch == NULL) {
2685             error_report("IOServiceMatching returned NULL for %s",
2686                          matching_array[index]);
2687             continue;
2688         }
2689         CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
2690                              kCFBooleanTrue);
2691         kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
2692                                                   mediaIterator);
2693         if (kernResult != KERN_SUCCESS) {
2694             error_report("Note: IOServiceGetMatchingServices returned %d",
2695                          kernResult);
2696             continue;
2697         }
2698
2699         /* If a match was found, leave the loop */
2700         if (*mediaIterator != 0) {
2701             DPRINTF("Matching using %s\n", matching_array[index]);
2702             mediaType = g_strdup(matching_array[index]);
2703             break;
2704         }
2705     }
2706     return mediaType;
2707 }
2708
2709 kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
2710                          CFIndex maxPathSize, int flags)
2711 {
2712     io_object_t     nextMedia;
2713     kern_return_t   kernResult = KERN_FAILURE;
2714     *bsdPath = '\0';
2715     nextMedia = IOIteratorNext( mediaIterator );
2716     if ( nextMedia )
2717     {
2718         CFTypeRef   bsdPathAsCFString;
2719     bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
2720         if ( bsdPathAsCFString ) {
2721             size_t devPathLength;
2722             strcpy( bsdPath, _PATH_DEV );
2723             if (flags & BDRV_O_NOCACHE) {
2724                 strcat(bsdPath, "r");
2725             }
2726             devPathLength = strlen( bsdPath );
2727             if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
2728                 kernResult = KERN_SUCCESS;
2729             }
2730             CFRelease( bsdPathAsCFString );
2731         }
2732         IOObjectRelease( nextMedia );
2733     }
2734
2735     return kernResult;
2736 }
2737
2738 /* Sets up a real cdrom for use in QEMU */
2739 static bool setup_cdrom(char *bsd_path, Error **errp)
2740 {
2741     int index, num_of_test_partitions = 2, fd;
2742     char test_partition[MAXPATHLEN];
2743     bool partition_found = false;
2744
2745     /* look for a working partition */
2746     for (index = 0; index < num_of_test_partitions; index++) {
2747         snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
2748                  index);
2749         fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE);
2750         if (fd >= 0) {
2751             partition_found = true;
2752             qemu_close(fd);
2753             break;
2754         }
2755     }
2756
2757     /* if a working partition on the device was not found */
2758     if (partition_found == false) {
2759         error_setg(errp, "Failed to find a working partition on disc");
2760     } else {
2761         DPRINTF("Using %s as optical disc\n", test_partition);
2762         pstrcpy(bsd_path, MAXPATHLEN, test_partition);
2763     }
2764     return partition_found;
2765 }
2766
2767 /* Prints directions on mounting and unmounting a device */
2768 static void print_unmounting_directions(const char *file_name)
2769 {
2770     error_report("If device %s is mounted on the desktop, unmount"
2771                  " it first before using it in QEMU", file_name);
2772     error_report("Command to unmount device: diskutil unmountDisk %s",
2773                  file_name);
2774     error_report("Command to mount device: diskutil mountDisk %s", file_name);
2775 }
2776
2777 #endif /* defined(__APPLE__) && defined(__MACH__) */
2778
2779 static int hdev_probe_device(const char *filename)
2780 {
2781     struct stat st;
2782
2783     /* allow a dedicated CD-ROM driver to match with a higher priority */
2784     if (strstart(filename, "/dev/cdrom", NULL))
2785         return 50;
2786
2787     if (stat(filename, &st) >= 0 &&
2788             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
2789         return 100;
2790     }
2791
2792     return 0;
2793 }
2794
2795 static int check_hdev_writable(BDRVRawState *s)
2796 {
2797 #if defined(BLKROGET)
2798     /* Linux block devices can be configured "read-only" using blockdev(8).
2799      * This is independent of device node permissions and therefore open(2)
2800      * with O_RDWR succeeds.  Actual writes fail with EPERM.
2801      *
2802      * bdrv_open() is supposed to fail if the disk is read-only.  Explicitly
2803      * check for read-only block devices so that Linux block devices behave
2804      * properly.
2805      */
2806     struct stat st;
2807     int readonly = 0;
2808
2809     if (fstat(s->fd, &st)) {
2810         return -errno;
2811     }
2812
2813     if (!S_ISBLK(st.st_mode)) {
2814         return 0;
2815     }
2816
2817     if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
2818         return -errno;
2819     }
2820
2821     if (readonly) {
2822         return -EACCES;
2823     }
2824 #endif /* defined(BLKROGET) */
2825     return 0;
2826 }
2827
2828 static void hdev_parse_filename(const char *filename, QDict *options,
2829                                 Error **errp)
2830 {
2831     bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
2832 }
2833
2834 static bool hdev_is_sg(BlockDriverState *bs)
2835 {
2836
2837 #if defined(__linux__)
2838
2839     BDRVRawState *s = bs->opaque;
2840     struct stat st;
2841     struct sg_scsi_id scsiid;
2842     int sg_version;
2843     int ret;
2844
2845     if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
2846         return false;
2847     }
2848
2849     ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
2850     if (ret < 0) {
2851         return false;
2852     }
2853
2854     ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
2855     if (ret >= 0) {
2856         DPRINTF("SG device found: type=%d, version=%d\n",
2857             scsiid.scsi_type, sg_version);
2858         return true;
2859     }
2860
2861 #endif
2862
2863     return false;
2864 }
2865
2866 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
2867                      Error **errp)
2868 {
2869     BDRVRawState *s = bs->opaque;
2870     Error *local_err = NULL;
2871     int ret;
2872
2873 #if defined(__APPLE__) && defined(__MACH__)
2874     /*
2875      * Caution: while qdict_get_str() is fine, getting non-string types
2876      * would require more care.  When @options come from -blockdev or
2877      * blockdev_add, its members are typed according to the QAPI
2878      * schema, but when they come from -drive, they're all QString.
2879      */
2880     const char *filename = qdict_get_str(options, "filename");
2881     char bsd_path[MAXPATHLEN] = "";
2882     bool error_occurred = false;
2883
2884     /* If using a real cdrom */
2885     if (strcmp(filename, "/dev/cdrom") == 0) {
2886         char *mediaType = NULL;
2887         kern_return_t ret_val;
2888         io_iterator_t mediaIterator = 0;
2889
2890         mediaType = FindEjectableOpticalMedia(&mediaIterator);
2891         if (mediaType == NULL) {
2892             error_setg(errp, "Please make sure your CD/DVD is in the optical"
2893                        " drive");
2894             error_occurred = true;
2895             goto hdev_open_Mac_error;
2896         }
2897
2898         ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
2899         if (ret_val != KERN_SUCCESS) {
2900             error_setg(errp, "Could not get BSD path for optical drive");
2901             error_occurred = true;
2902             goto hdev_open_Mac_error;
2903         }
2904
2905         /* If a real optical drive was not found */
2906         if (bsd_path[0] == '\0') {
2907             error_setg(errp, "Failed to obtain bsd path for optical drive");
2908             error_occurred = true;
2909             goto hdev_open_Mac_error;
2910         }
2911
2912         /* If using a cdrom disc and finding a partition on the disc failed */
2913         if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
2914             setup_cdrom(bsd_path, errp) == false) {
2915             print_unmounting_directions(bsd_path);
2916             error_occurred = true;
2917             goto hdev_open_Mac_error;
2918         }
2919
2920         qdict_put_str(options, "filename", bsd_path);
2921
2922 hdev_open_Mac_error:
2923         g_free(mediaType);
2924         if (mediaIterator) {
2925             IOObjectRelease(mediaIterator);
2926         }
2927         if (error_occurred) {
2928             return -ENOENT;
2929         }
2930     }
2931 #endif /* defined(__APPLE__) && defined(__MACH__) */
2932
2933     s->type = FTYPE_FILE;
2934
2935     ret = raw_open_common(bs, options, flags, 0, &local_err);
2936     if (ret < 0) {
2937         error_propagate(errp, local_err);
2938 #if defined(__APPLE__) && defined(__MACH__)
2939         if (*bsd_path) {
2940             filename = bsd_path;
2941         }
2942         /* if a physical device experienced an error while being opened */
2943         if (strncmp(filename, "/dev/", 5) == 0) {
2944             print_unmounting_directions(filename);
2945         }
2946 #endif /* defined(__APPLE__) && defined(__MACH__) */
2947         return ret;
2948     }
2949
2950     /* Since this does ioctl the device must be already opened */
2951     bs->sg = hdev_is_sg(bs);
2952
2953     if (flags & BDRV_O_RDWR) {
2954         ret = check_hdev_writable(s);
2955         if (ret < 0) {
2956             raw_close(bs);
2957             error_setg_errno(errp, -ret, "The device is not writable");
2958             return ret;
2959         }
2960     }
2961
2962     return ret;
2963 }
2964
2965 #if defined(__linux__)
2966
2967 static BlockAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
2968         unsigned long int req, void *buf,
2969         BlockCompletionFunc *cb, void *opaque)
2970 {
2971     BDRVRawState *s = bs->opaque;
2972     RawPosixAIOData *acb;
2973     ThreadPool *pool;
2974
2975     if (fd_open(bs) < 0)
2976         return NULL;
2977
2978     if (req == SG_IO && s->pr_mgr) {
2979         struct sg_io_hdr *io_hdr = buf;
2980         if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
2981             io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
2982             return pr_manager_execute(s->pr_mgr, bdrv_get_aio_context(bs),
2983                                       s->fd, io_hdr, cb, opaque);
2984         }
2985     }
2986
2987     acb = g_new(RawPosixAIOData, 1);
2988     acb->bs = bs;
2989     acb->aio_type = QEMU_AIO_IOCTL;
2990     acb->aio_fildes = s->fd;
2991     acb->aio_offset = 0;
2992     acb->aio_ioctl_buf = buf;
2993     acb->aio_ioctl_cmd = req;
2994     pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
2995     return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
2996 }
2997 #endif /* linux */
2998
2999 static int fd_open(BlockDriverState *bs)
3000 {
3001     BDRVRawState *s = bs->opaque;
3002
3003     /* this is just to ensure s->fd is sane (its called by io ops) */
3004     if (s->fd >= 0)
3005         return 0;
3006     return -EIO;
3007 }
3008
3009 static coroutine_fn int
3010 hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
3011 {
3012     BDRVRawState *s = bs->opaque;
3013     int ret;
3014
3015     ret = fd_open(bs);
3016     if (ret < 0) {
3017         return ret;
3018     }
3019     return paio_submit_co(bs, s->fd, offset, NULL, bytes,
3020                           QEMU_AIO_DISCARD | QEMU_AIO_BLKDEV);
3021 }
3022
3023 static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
3024     int64_t offset, int bytes, BdrvRequestFlags flags)
3025 {
3026     BDRVRawState *s = bs->opaque;
3027     int rc;
3028
3029     rc = fd_open(bs);
3030     if (rc < 0) {
3031         return rc;
3032     }
3033     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
3034         return paio_submit_co(bs, s->fd, offset, NULL, bytes,
3035                               QEMU_AIO_WRITE_ZEROES|QEMU_AIO_BLKDEV);
3036     } else if (s->discard_zeroes) {
3037         return paio_submit_co(bs, s->fd, offset, NULL, bytes,
3038                               QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
3039     }
3040     return -ENOTSUP;
3041 }
3042
3043 static int coroutine_fn hdev_co_create_opts(const char *filename, QemuOpts *opts,
3044                                             Error **errp)
3045 {
3046     int fd;
3047     int ret = 0;
3048     struct stat stat_buf;
3049     int64_t total_size = 0;
3050     bool has_prefix;
3051
3052     /* This function is used by both protocol block drivers and therefore either
3053      * of these prefixes may be given.
3054      * The return value has to be stored somewhere, otherwise this is an error
3055      * due to -Werror=unused-value. */
3056     has_prefix =
3057         strstart(filename, "host_device:", &filename) ||
3058         strstart(filename, "host_cdrom:" , &filename);
3059
3060     (void)has_prefix;
3061
3062     ret = raw_normalize_devicepath(&filename);
3063     if (ret < 0) {
3064         error_setg_errno(errp, -ret, "Could not normalize device path");
3065         return ret;
3066     }
3067
3068     /* Read out options */
3069     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
3070                           BDRV_SECTOR_SIZE);
3071
3072     fd = qemu_open(filename, O_WRONLY | O_BINARY);
3073     if (fd < 0) {
3074         ret = -errno;
3075         error_setg_errno(errp, -ret, "Could not open device");
3076         return ret;
3077     }
3078
3079     if (fstat(fd, &stat_buf) < 0) {
3080         ret = -errno;
3081         error_setg_errno(errp, -ret, "Could not stat device");
3082     } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
3083         error_setg(errp,
3084                    "The given file is neither a block nor a character device");
3085         ret = -ENODEV;
3086     } else if (lseek(fd, 0, SEEK_END) < total_size) {
3087         error_setg(errp, "Device is too small");
3088         ret = -ENOSPC;
3089     }
3090
3091     if (!ret && total_size) {
3092         uint8_t buf[BDRV_SECTOR_SIZE] = { 0 };
3093         int64_t zero_size = MIN(BDRV_SECTOR_SIZE, total_size);
3094         if (lseek(fd, 0, SEEK_SET) == -1) {
3095             ret = -errno;
3096         } else {
3097             ret = qemu_write_full(fd, buf, zero_size);
3098             ret = ret == zero_size ? 0 : -errno;
3099         }
3100     }
3101     qemu_close(fd);
3102     return ret;
3103 }
3104
3105 static BlockDriver bdrv_host_device = {
3106     .format_name        = "host_device",
3107     .protocol_name        = "host_device",
3108     .instance_size      = sizeof(BDRVRawState),
3109     .bdrv_needs_filename = true,
3110     .bdrv_probe_device  = hdev_probe_device,
3111     .bdrv_parse_filename = hdev_parse_filename,
3112     .bdrv_file_open     = hdev_open,
3113     .bdrv_close         = raw_close,
3114     .bdrv_reopen_prepare = raw_reopen_prepare,
3115     .bdrv_reopen_commit  = raw_reopen_commit,
3116     .bdrv_reopen_abort   = raw_reopen_abort,
3117     .bdrv_co_create_opts = hdev_co_create_opts,
3118     .create_opts         = &raw_create_opts,
3119     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3120     .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
3121
3122     .bdrv_co_preadv         = raw_co_preadv,
3123     .bdrv_co_pwritev        = raw_co_pwritev,
3124     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
3125     .bdrv_co_pdiscard       = hdev_co_pdiscard,
3126     .bdrv_co_copy_range_from = raw_co_copy_range_from,
3127     .bdrv_co_copy_range_to  = raw_co_copy_range_to,
3128     .bdrv_refresh_limits = raw_refresh_limits,
3129     .bdrv_io_plug = raw_aio_plug,
3130     .bdrv_io_unplug = raw_aio_unplug,
3131
3132     .bdrv_co_truncate       = raw_co_truncate,
3133     .bdrv_getlength     = raw_getlength,
3134     .bdrv_get_info = raw_get_info,
3135     .bdrv_get_allocated_file_size
3136                         = raw_get_allocated_file_size,
3137     .bdrv_check_perm = raw_check_perm,
3138     .bdrv_set_perm   = raw_set_perm,
3139     .bdrv_abort_perm_update = raw_abort_perm_update,
3140     .bdrv_probe_blocksizes = hdev_probe_blocksizes,
3141     .bdrv_probe_geometry = hdev_probe_geometry,
3142
3143     /* generic scsi device */
3144 #ifdef __linux__
3145     .bdrv_aio_ioctl     = hdev_aio_ioctl,
3146 #endif
3147 };
3148
3149 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3150 static void cdrom_parse_filename(const char *filename, QDict *options,
3151                                  Error **errp)
3152 {
3153     bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
3154 }
3155 #endif
3156
3157 #ifdef __linux__
3158 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3159                       Error **errp)
3160 {
3161     BDRVRawState *s = bs->opaque;
3162
3163     s->type = FTYPE_CD;
3164
3165     /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
3166     return raw_open_common(bs, options, flags, O_NONBLOCK, errp);
3167 }
3168
3169 static int cdrom_probe_device(const char *filename)
3170 {
3171     int fd, ret;
3172     int prio = 0;
3173     struct stat st;
3174
3175     fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
3176     if (fd < 0) {
3177         goto out;
3178     }
3179     ret = fstat(fd, &st);
3180     if (ret == -1 || !S_ISBLK(st.st_mode)) {
3181         goto outc;
3182     }
3183
3184     /* Attempt to detect via a CDROM specific ioctl */
3185     ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3186     if (ret >= 0)
3187         prio = 100;
3188
3189 outc:
3190     qemu_close(fd);
3191 out:
3192     return prio;
3193 }
3194
3195 static bool cdrom_is_inserted(BlockDriverState *bs)
3196 {
3197     BDRVRawState *s = bs->opaque;
3198     int ret;
3199
3200     ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3201     return ret == CDS_DISC_OK;
3202 }
3203
3204 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3205 {
3206     BDRVRawState *s = bs->opaque;
3207
3208     if (eject_flag) {
3209         if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
3210             perror("CDROMEJECT");
3211     } else {
3212         if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
3213             perror("CDROMEJECT");
3214     }
3215 }
3216
3217 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3218 {
3219     BDRVRawState *s = bs->opaque;
3220
3221     if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
3222         /*
3223          * Note: an error can happen if the distribution automatically
3224          * mounts the CD-ROM
3225          */
3226         /* perror("CDROM_LOCKDOOR"); */
3227     }
3228 }
3229
3230 static BlockDriver bdrv_host_cdrom = {
3231     .format_name        = "host_cdrom",
3232     .protocol_name      = "host_cdrom",
3233     .instance_size      = sizeof(BDRVRawState),
3234     .bdrv_needs_filename = true,
3235     .bdrv_probe_device  = cdrom_probe_device,
3236     .bdrv_parse_filename = cdrom_parse_filename,
3237     .bdrv_file_open     = cdrom_open,
3238     .bdrv_close         = raw_close,
3239     .bdrv_reopen_prepare = raw_reopen_prepare,
3240     .bdrv_reopen_commit  = raw_reopen_commit,
3241     .bdrv_reopen_abort   = raw_reopen_abort,
3242     .bdrv_co_create_opts = hdev_co_create_opts,
3243     .create_opts         = &raw_create_opts,
3244     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3245
3246
3247     .bdrv_co_preadv         = raw_co_preadv,
3248     .bdrv_co_pwritev        = raw_co_pwritev,
3249     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
3250     .bdrv_refresh_limits = raw_refresh_limits,
3251     .bdrv_io_plug = raw_aio_plug,
3252     .bdrv_io_unplug = raw_aio_unplug,
3253
3254     .bdrv_co_truncate    = raw_co_truncate,
3255     .bdrv_getlength      = raw_getlength,
3256     .has_variable_length = true,
3257     .bdrv_get_allocated_file_size
3258                         = raw_get_allocated_file_size,
3259
3260     /* removable device support */
3261     .bdrv_is_inserted   = cdrom_is_inserted,
3262     .bdrv_eject         = cdrom_eject,
3263     .bdrv_lock_medium   = cdrom_lock_medium,
3264
3265     /* generic scsi device */
3266     .bdrv_aio_ioctl     = hdev_aio_ioctl,
3267 };
3268 #endif /* __linux__ */
3269
3270 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
3271 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3272                       Error **errp)
3273 {
3274     BDRVRawState *s = bs->opaque;
3275     Error *local_err = NULL;
3276     int ret;
3277
3278     s->type = FTYPE_CD;
3279
3280     ret = raw_open_common(bs, options, flags, 0, &local_err);
3281     if (ret) {
3282         error_propagate(errp, local_err);
3283         return ret;
3284     }
3285
3286     /* make sure the door isn't locked at this time */
3287     ioctl(s->fd, CDIOCALLOW);
3288     return 0;
3289 }
3290
3291 static int cdrom_probe_device(const char *filename)
3292 {
3293     if (strstart(filename, "/dev/cd", NULL) ||
3294             strstart(filename, "/dev/acd", NULL))
3295         return 100;
3296     return 0;
3297 }
3298
3299 static int cdrom_reopen(BlockDriverState *bs)
3300 {
3301     BDRVRawState *s = bs->opaque;
3302     int fd;
3303
3304     /*
3305      * Force reread of possibly changed/newly loaded disc,
3306      * FreeBSD seems to not notice sometimes...
3307      */
3308     if (s->fd >= 0)
3309         qemu_close(s->fd);
3310     fd = qemu_open(bs->filename, s->open_flags, 0644);
3311     if (fd < 0) {
3312         s->fd = -1;
3313         return -EIO;
3314     }
3315     s->fd = fd;
3316
3317     /* make sure the door isn't locked at this time */
3318     ioctl(s->fd, CDIOCALLOW);
3319     return 0;
3320 }
3321
3322 static bool cdrom_is_inserted(BlockDriverState *bs)
3323 {
3324     return raw_getlength(bs) > 0;
3325 }
3326
3327 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3328 {
3329     BDRVRawState *s = bs->opaque;
3330
3331     if (s->fd < 0)
3332         return;
3333
3334     (void) ioctl(s->fd, CDIOCALLOW);
3335
3336     if (eject_flag) {
3337         if (ioctl(s->fd, CDIOCEJECT) < 0)
3338             perror("CDIOCEJECT");
3339     } else {
3340         if (ioctl(s->fd, CDIOCCLOSE) < 0)
3341             perror("CDIOCCLOSE");
3342     }
3343
3344     cdrom_reopen(bs);
3345 }
3346
3347 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3348 {
3349     BDRVRawState *s = bs->opaque;
3350
3351     if (s->fd < 0)
3352         return;
3353     if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
3354         /*
3355          * Note: an error can happen if the distribution automatically
3356          * mounts the CD-ROM
3357          */
3358         /* perror("CDROM_LOCKDOOR"); */
3359     }
3360 }
3361
3362 static BlockDriver bdrv_host_cdrom = {
3363     .format_name        = "host_cdrom",
3364     .protocol_name      = "host_cdrom",
3365     .instance_size      = sizeof(BDRVRawState),
3366     .bdrv_needs_filename = true,
3367     .bdrv_probe_device  = cdrom_probe_device,
3368     .bdrv_parse_filename = cdrom_parse_filename,
3369     .bdrv_file_open     = cdrom_open,
3370     .bdrv_close         = raw_close,
3371     .bdrv_reopen_prepare = raw_reopen_prepare,
3372     .bdrv_reopen_commit  = raw_reopen_commit,
3373     .bdrv_reopen_abort   = raw_reopen_abort,
3374     .bdrv_co_create_opts = hdev_co_create_opts,
3375     .create_opts        = &raw_create_opts,
3376
3377     .bdrv_co_preadv         = raw_co_preadv,
3378     .bdrv_co_pwritev        = raw_co_pwritev,
3379     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
3380     .bdrv_refresh_limits = raw_refresh_limits,
3381     .bdrv_io_plug = raw_aio_plug,
3382     .bdrv_io_unplug = raw_aio_unplug,
3383
3384     .bdrv_co_truncate    = raw_co_truncate,
3385     .bdrv_getlength      = raw_getlength,
3386     .has_variable_length = true,
3387     .bdrv_get_allocated_file_size
3388                         = raw_get_allocated_file_size,
3389
3390     /* removable device support */
3391     .bdrv_is_inserted   = cdrom_is_inserted,
3392     .bdrv_eject         = cdrom_eject,
3393     .bdrv_lock_medium   = cdrom_lock_medium,
3394 };
3395 #endif /* __FreeBSD__ */
3396
3397 static void bdrv_file_init(void)
3398 {
3399     /*
3400      * Register all the drivers.  Note that order is important, the driver
3401      * registered last will get probed first.
3402      */
3403     bdrv_register(&bdrv_file);
3404     bdrv_register(&bdrv_host_device);
3405 #ifdef __linux__
3406     bdrv_register(&bdrv_host_cdrom);
3407 #endif
3408 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3409     bdrv_register(&bdrv_host_cdrom);
3410 #endif
3411 }
3412
3413 block_init(bdrv_file_init);