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