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 == 0 || ret != -ENOTSUP) {
1592             return ret;
1593         }
1594         s->has_write_zeroes = false;
1595     }
1596 #endif
1597
1598 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1599     if (s->has_discard && s->has_fallocate) {
1600         int ret = do_fallocate(s->fd,
1601                                FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1602                                aiocb->aio_offset, aiocb->aio_nbytes);
1603         if (ret == 0) {
1604             ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1605             if (ret == 0 || ret != -ENOTSUP) {
1606                 return ret;
1607             }
1608             s->has_fallocate = false;
1609         } else if (ret != -ENOTSUP) {
1610             return ret;
1611         } else {
1612             s->has_discard = false;
1613         }
1614     }
1615 #endif
1616
1617 #ifdef CONFIG_FALLOCATE
1618     /* Last resort: we are trying to extend the file with zeroed data. This
1619      * can be done via fallocate(fd, 0) */
1620     len = bdrv_getlength(aiocb->bs);
1621     if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
1622         int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1623         if (ret == 0 || ret != -ENOTSUP) {
1624             return ret;
1625         }
1626         s->has_fallocate = false;
1627     }
1628 #endif
1629
1630     return -ENOTSUP;
1631 }
1632
1633 static int handle_aiocb_write_zeroes_unmap(void *opaque)
1634 {
1635     RawPosixAIOData *aiocb = opaque;
1636     BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque;
1637     int ret;
1638
1639     /* First try to write zeros and unmap at the same time */
1640
1641 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1642     ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1643                        aiocb->aio_offset, aiocb->aio_nbytes);
1644     if (ret != -ENOTSUP) {
1645         return ret;
1646     }
1647 #endif
1648
1649 #ifdef CONFIG_XFS
1650     if (s->is_xfs) {
1651         /* xfs_discard() guarantees that the discarded area reads as all-zero
1652          * afterwards, so we can use it here. */
1653         return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1654     }
1655 #endif
1656
1657     /* If we couldn't manage to unmap while guaranteed that the area reads as
1658      * all-zero afterwards, just write zeroes without unmapping */
1659     ret = handle_aiocb_write_zeroes(aiocb);
1660     return ret;
1661 }
1662
1663 #ifndef HAVE_COPY_FILE_RANGE
1664 static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
1665                              off_t *out_off, size_t len, unsigned int flags)
1666 {
1667 #ifdef __NR_copy_file_range
1668     return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
1669                    out_off, len, flags);
1670 #else
1671     errno = ENOSYS;
1672     return -1;
1673 #endif
1674 }
1675 #endif
1676
1677 static int handle_aiocb_copy_range(void *opaque)
1678 {
1679     RawPosixAIOData *aiocb = opaque;
1680     uint64_t bytes = aiocb->aio_nbytes;
1681     off_t in_off = aiocb->aio_offset;
1682     off_t out_off = aiocb->copy_range.aio_offset2;
1683
1684     while (bytes) {
1685         ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
1686                                       aiocb->copy_range.aio_fd2, &out_off,
1687                                       bytes, 0);
1688         trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
1689                                    aiocb->copy_range.aio_fd2, out_off, bytes,
1690                                    0, ret);
1691         if (ret == 0) {
1692             /* No progress (e.g. when beyond EOF), let the caller fall back to
1693              * buffer I/O. */
1694             return -ENOSPC;
1695         }
1696         if (ret < 0) {
1697             switch (errno) {
1698             case ENOSYS:
1699                 return -ENOTSUP;
1700             case EINTR:
1701                 continue;
1702             default:
1703                 return -errno;
1704             }
1705         }
1706         bytes -= ret;
1707     }
1708     return 0;
1709 }
1710
1711 static int handle_aiocb_discard(void *opaque)
1712 {
1713     RawPosixAIOData *aiocb = opaque;
1714     int ret = -EOPNOTSUPP;
1715     BDRVRawState *s = aiocb->bs->opaque;
1716
1717     if (!s->has_discard) {
1718         return -ENOTSUP;
1719     }
1720
1721     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1722 #ifdef BLKDISCARD
1723         do {
1724             uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1725             if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
1726                 return 0;
1727             }
1728         } while (errno == EINTR);
1729
1730         ret = -errno;
1731 #endif
1732     } else {
1733 #ifdef CONFIG_XFS
1734         if (s->is_xfs) {
1735             return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
1736         }
1737 #endif
1738
1739 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1740         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1741                            aiocb->aio_offset, aiocb->aio_nbytes);
1742 #endif
1743     }
1744
1745     ret = translate_err(ret);
1746     if (ret == -ENOTSUP) {
1747         s->has_discard = false;
1748     }
1749     return ret;
1750 }
1751
1752 /*
1753  * Help alignment probing by allocating the first block.
1754  *
1755  * When reading with direct I/O from unallocated area on Gluster backed by XFS,
1756  * reading succeeds regardless of request length. In this case we fallback to
1757  * safe alignment which is not optimal. Allocating the first block avoids this
1758  * fallback.
1759  *
1760  * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
1761  * request alignment, so we use safe values.
1762  *
1763  * Returns: 0 on success, -errno on failure. Since this is an optimization,
1764  * caller may ignore failures.
1765  */
1766 static int allocate_first_block(int fd, size_t max_size)
1767 {
1768     size_t write_size = (max_size < MAX_BLOCKSIZE)
1769         ? BDRV_SECTOR_SIZE
1770         : MAX_BLOCKSIZE;
1771     size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
1772     void *buf;
1773     ssize_t n;
1774     int ret;
1775
1776     buf = qemu_memalign(max_align, write_size);
1777     memset(buf, 0, write_size);
1778
1779     do {
1780         n = pwrite(fd, buf, write_size, 0);
1781     } while (n == -1 && errno == EINTR);
1782
1783     ret = (n == -1) ? -errno : 0;
1784
1785     qemu_vfree(buf);
1786     return ret;
1787 }
1788
1789 static int handle_aiocb_truncate(void *opaque)
1790 {
1791     RawPosixAIOData *aiocb = opaque;
1792     int result = 0;
1793     int64_t current_length = 0;
1794     char *buf = NULL;
1795     struct stat st;
1796     int fd = aiocb->aio_fildes;
1797     int64_t offset = aiocb->aio_offset;
1798     PreallocMode prealloc = aiocb->truncate.prealloc;
1799     Error **errp = aiocb->truncate.errp;
1800
1801     if (fstat(fd, &st) < 0) {
1802         result = -errno;
1803         error_setg_errno(errp, -result, "Could not stat file");
1804         return result;
1805     }
1806
1807     current_length = st.st_size;
1808     if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
1809         error_setg(errp, "Cannot use preallocation for shrinking files");
1810         return -ENOTSUP;
1811     }
1812
1813     switch (prealloc) {
1814 #ifdef CONFIG_POSIX_FALLOCATE
1815     case PREALLOC_MODE_FALLOC:
1816         /*
1817          * Truncating before posix_fallocate() makes it about twice slower on
1818          * file systems that do not support fallocate(), trying to check if a
1819          * block is allocated before allocating it, so don't do that here.
1820          */
1821         if (offset != current_length) {
1822             result = -posix_fallocate(fd, current_length,
1823                                       offset - current_length);
1824             if (result != 0) {
1825                 /* posix_fallocate() doesn't set errno. */
1826                 error_setg_errno(errp, -result,
1827                                  "Could not preallocate new data");
1828             } else if (current_length == 0) {
1829                 /*
1830                  * posix_fallocate() uses fallocate() if the filesystem
1831                  * supports it, or fallback to manually writing zeroes. If
1832                  * fallocate() was used, unaligned reads from the fallocated
1833                  * area in raw_probe_alignment() will succeed, hence we need to
1834                  * allocate the first block.
1835                  *
1836                  * Optimize future alignment probing; ignore failures.
1837                  */
1838                 allocate_first_block(fd, offset);
1839             }
1840         } else {
1841             result = 0;
1842         }
1843         goto out;
1844 #endif
1845     case PREALLOC_MODE_FULL:
1846     {
1847         int64_t num = 0, left = offset - current_length;
1848         off_t seek_result;
1849
1850         /*
1851          * Knowing the final size from the beginning could allow the file
1852          * system driver to do less allocations and possibly avoid
1853          * fragmentation of the file.
1854          */
1855         if (ftruncate(fd, offset) != 0) {
1856             result = -errno;
1857             error_setg_errno(errp, -result, "Could not resize file");
1858             goto out;
1859         }
1860
1861         buf = g_malloc0(65536);
1862
1863         seek_result = lseek(fd, current_length, SEEK_SET);
1864         if (seek_result < 0) {
1865             result = -errno;
1866             error_setg_errno(errp, -result,
1867                              "Failed to seek to the old end of file");
1868             goto out;
1869         }
1870
1871         while (left > 0) {
1872             num = MIN(left, 65536);
1873             result = write(fd, buf, num);
1874             if (result < 0) {
1875                 if (errno == EINTR) {
1876                     continue;
1877                 }
1878                 result = -errno;
1879                 error_setg_errno(errp, -result,
1880                                  "Could not write zeros for preallocation");
1881                 goto out;
1882             }
1883             left -= result;
1884         }
1885         if (result >= 0) {
1886             result = fsync(fd);
1887             if (result < 0) {
1888                 result = -errno;
1889                 error_setg_errno(errp, -result,
1890                                  "Could not flush file to disk");
1891                 goto out;
1892             }
1893         }
1894         goto out;
1895     }
1896     case PREALLOC_MODE_OFF:
1897         if (ftruncate(fd, offset) != 0) {
1898             result = -errno;
1899             error_setg_errno(errp, -result, "Could not resize file");
1900         } else if (current_length == 0 && offset > current_length) {
1901             /* Optimize future alignment probing; ignore failures. */
1902             allocate_first_block(fd, offset);
1903         }
1904         return result;
1905     default:
1906         result = -ENOTSUP;
1907         error_setg(errp, "Unsupported preallocation mode: %s",
1908                    PreallocMode_str(prealloc));
1909         return result;
1910     }
1911
1912 out:
1913     if (result < 0) {
1914         if (ftruncate(fd, current_length) < 0) {
1915             error_report("Failed to restore old file length: %s",
1916                          strerror(errno));
1917         }
1918     }
1919
1920     g_free(buf);
1921     return result;
1922 }
1923
1924 static int coroutine_fn raw_thread_pool_submit(BlockDriverState *bs,
1925                                                ThreadPoolFunc func, void *arg)
1926 {
1927     /* @bs can be NULL, bdrv_get_aio_context() returns the main context then */
1928     ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
1929     return thread_pool_submit_co(pool, func, arg);
1930 }
1931
1932 static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
1933                                    uint64_t bytes, QEMUIOVector *qiov, int type)
1934 {
1935     BDRVRawState *s = bs->opaque;
1936     RawPosixAIOData acb;
1937
1938     if (fd_open(bs) < 0)
1939         return -EIO;
1940
1941     /*
1942      * Check if the underlying device requires requests to be aligned,
1943      * and if the request we are trying to submit is aligned or not.
1944      * If this is the case tell the low-level driver that it needs
1945      * to copy the buffer.
1946      */
1947     if (s->needs_alignment) {
1948         if (!bdrv_qiov_is_aligned(bs, qiov)) {
1949             type |= QEMU_AIO_MISALIGNED;
1950 #ifdef CONFIG_LINUX_AIO
1951         } else if (s->use_linux_aio) {
1952             LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1953             assert(qiov->size == bytes);
1954             return laio_co_submit(bs, aio, s->fd, offset, qiov, type);
1955 #endif
1956         }
1957     }
1958
1959     acb = (RawPosixAIOData) {
1960         .bs             = bs,
1961         .aio_fildes     = s->fd,
1962         .aio_type       = type,
1963         .aio_offset     = offset,
1964         .aio_nbytes     = bytes,
1965         .io             = {
1966             .iov            = qiov->iov,
1967             .niov           = qiov->niov,
1968         },
1969     };
1970
1971     assert(qiov->size == bytes);
1972     return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
1973 }
1974
1975 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
1976                                       uint64_t bytes, QEMUIOVector *qiov,
1977                                       int flags)
1978 {
1979     return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_READ);
1980 }
1981
1982 static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
1983                                        uint64_t bytes, QEMUIOVector *qiov,
1984                                        int flags)
1985 {
1986     assert(flags == 0);
1987     return raw_co_prw(bs, offset, bytes, qiov, QEMU_AIO_WRITE);
1988 }
1989
1990 static void raw_aio_plug(BlockDriverState *bs)
1991 {
1992 #ifdef CONFIG_LINUX_AIO
1993     BDRVRawState *s = bs->opaque;
1994     if (s->use_linux_aio) {
1995         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
1996         laio_io_plug(bs, aio);
1997     }
1998 #endif
1999 }
2000
2001 static void raw_aio_unplug(BlockDriverState *bs)
2002 {
2003 #ifdef CONFIG_LINUX_AIO
2004     BDRVRawState *s = bs->opaque;
2005     if (s->use_linux_aio) {
2006         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
2007         laio_io_unplug(bs, aio);
2008     }
2009 #endif
2010 }
2011
2012 static int raw_co_flush_to_disk(BlockDriverState *bs)
2013 {
2014     BDRVRawState *s = bs->opaque;
2015     RawPosixAIOData acb;
2016     int ret;
2017
2018     ret = fd_open(bs);
2019     if (ret < 0) {
2020         return ret;
2021     }
2022
2023     acb = (RawPosixAIOData) {
2024         .bs             = bs,
2025         .aio_fildes     = s->fd,
2026         .aio_type       = QEMU_AIO_FLUSH,
2027     };
2028
2029     return raw_thread_pool_submit(bs, handle_aiocb_flush, &acb);
2030 }
2031
2032 static void raw_aio_attach_aio_context(BlockDriverState *bs,
2033                                        AioContext *new_context)
2034 {
2035 #ifdef CONFIG_LINUX_AIO
2036     BDRVRawState *s = bs->opaque;
2037     if (s->use_linux_aio) {
2038         Error *local_err;
2039         if (!aio_setup_linux_aio(new_context, &local_err)) {
2040             error_reportf_err(local_err, "Unable to use native AIO, "
2041                                          "falling back to thread pool: ");
2042             s->use_linux_aio = false;
2043         }
2044     }
2045 #endif
2046 }
2047
2048 static void raw_close(BlockDriverState *bs)
2049 {
2050     BDRVRawState *s = bs->opaque;
2051
2052     if (s->fd >= 0) {
2053         qemu_close(s->fd);
2054         s->fd = -1;
2055     }
2056 }
2057
2058 /**
2059  * Truncates the given regular file @fd to @offset and, when growing, fills the
2060  * new space according to @prealloc.
2061  *
2062  * Returns: 0 on success, -errno on failure.
2063  */
2064 static int coroutine_fn
2065 raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
2066                      PreallocMode prealloc, Error **errp)
2067 {
2068     RawPosixAIOData acb;
2069
2070     acb = (RawPosixAIOData) {
2071         .bs             = bs,
2072         .aio_fildes     = fd,
2073         .aio_type       = QEMU_AIO_TRUNCATE,
2074         .aio_offset     = offset,
2075         .truncate       = {
2076             .prealloc       = prealloc,
2077             .errp           = errp,
2078         },
2079     };
2080
2081     return raw_thread_pool_submit(bs, handle_aiocb_truncate, &acb);
2082 }
2083
2084 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
2085                                         PreallocMode prealloc, Error **errp)
2086 {
2087     BDRVRawState *s = bs->opaque;
2088     struct stat st;
2089     int ret;
2090
2091     if (fstat(s->fd, &st)) {
2092         ret = -errno;
2093         error_setg_errno(errp, -ret, "Failed to fstat() the file");
2094         return ret;
2095     }
2096
2097     if (S_ISREG(st.st_mode)) {
2098         return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
2099     }
2100
2101     if (prealloc != PREALLOC_MODE_OFF) {
2102         error_setg(errp, "Preallocation mode '%s' unsupported for this "
2103                    "non-regular file", PreallocMode_str(prealloc));
2104         return -ENOTSUP;
2105     }
2106
2107     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2108         if (offset > raw_getlength(bs)) {
2109             error_setg(errp, "Cannot grow device files");
2110             return -EINVAL;
2111         }
2112     } else {
2113         error_setg(errp, "Resizing this file is not supported");
2114         return -ENOTSUP;
2115     }
2116
2117     return 0;
2118 }
2119
2120 #ifdef __OpenBSD__
2121 static int64_t raw_getlength(BlockDriverState *bs)
2122 {
2123     BDRVRawState *s = bs->opaque;
2124     int fd = s->fd;
2125     struct stat st;
2126
2127     if (fstat(fd, &st))
2128         return -errno;
2129     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2130         struct disklabel dl;
2131
2132         if (ioctl(fd, DIOCGDINFO, &dl))
2133             return -errno;
2134         return (uint64_t)dl.d_secsize *
2135             dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2136     } else
2137         return st.st_size;
2138 }
2139 #elif defined(__NetBSD__)
2140 static int64_t raw_getlength(BlockDriverState *bs)
2141 {
2142     BDRVRawState *s = bs->opaque;
2143     int fd = s->fd;
2144     struct stat st;
2145
2146     if (fstat(fd, &st))
2147         return -errno;
2148     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2149         struct dkwedge_info dkw;
2150
2151         if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
2152             return dkw.dkw_size * 512;
2153         } else {
2154             struct disklabel dl;
2155
2156             if (ioctl(fd, DIOCGDINFO, &dl))
2157                 return -errno;
2158             return (uint64_t)dl.d_secsize *
2159                 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2160         }
2161     } else
2162         return st.st_size;
2163 }
2164 #elif defined(__sun__)
2165 static int64_t raw_getlength(BlockDriverState *bs)
2166 {
2167     BDRVRawState *s = bs->opaque;
2168     struct dk_minfo minfo;
2169     int ret;
2170     int64_t size;
2171
2172     ret = fd_open(bs);
2173     if (ret < 0) {
2174         return ret;
2175     }
2176
2177     /*
2178      * Use the DKIOCGMEDIAINFO ioctl to read the size.
2179      */
2180     ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
2181     if (ret != -1) {
2182         return minfo.dki_lbsize * minfo.dki_capacity;
2183     }
2184
2185     /*
2186      * There are reports that lseek on some devices fails, but
2187      * irc discussion said that contingency on contingency was overkill.
2188      */
2189     size = lseek(s->fd, 0, SEEK_END);
2190     if (size < 0) {
2191         return -errno;
2192     }
2193     return size;
2194 }
2195 #elif defined(CONFIG_BSD)
2196 static int64_t raw_getlength(BlockDriverState *bs)
2197 {
2198     BDRVRawState *s = bs->opaque;
2199     int fd = s->fd;
2200     int64_t size;
2201     struct stat sb;
2202 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2203     int reopened = 0;
2204 #endif
2205     int ret;
2206
2207     ret = fd_open(bs);
2208     if (ret < 0)
2209         return ret;
2210
2211 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2212 again:
2213 #endif
2214     if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2215 #ifdef DIOCGMEDIASIZE
2216         if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
2217 #elif defined(DIOCGPART)
2218         {
2219                 struct partinfo pi;
2220                 if (ioctl(fd, DIOCGPART, &pi) == 0)
2221                         size = pi.media_size;
2222                 else
2223                         size = 0;
2224         }
2225         if (size == 0)
2226 #endif
2227 #if defined(__APPLE__) && defined(__MACH__)
2228         {
2229             uint64_t sectors = 0;
2230             uint32_t sector_size = 0;
2231
2232             if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
2233                && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
2234                 size = sectors * sector_size;
2235             } else {
2236                 size = lseek(fd, 0LL, SEEK_END);
2237                 if (size < 0) {
2238                     return -errno;
2239                 }
2240             }
2241         }
2242 #else
2243         size = lseek(fd, 0LL, SEEK_END);
2244         if (size < 0) {
2245             return -errno;
2246         }
2247 #endif
2248 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2249         switch(s->type) {
2250         case FTYPE_CD:
2251             /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
2252             if (size == 2048LL * (unsigned)-1)
2253                 size = 0;
2254             /* XXX no disc?  maybe we need to reopen... */
2255             if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
2256                 reopened = 1;
2257                 goto again;
2258             }
2259         }
2260 #endif
2261     } else {
2262         size = lseek(fd, 0, SEEK_END);
2263         if (size < 0) {
2264             return -errno;
2265         }
2266     }
2267     return size;
2268 }
2269 #else
2270 static int64_t raw_getlength(BlockDriverState *bs)
2271 {
2272     BDRVRawState *s = bs->opaque;
2273     int ret;
2274     int64_t size;
2275
2276     ret = fd_open(bs);
2277     if (ret < 0) {
2278         return ret;
2279     }
2280
2281     size = lseek(s->fd, 0, SEEK_END);
2282     if (size < 0) {
2283         return -errno;
2284     }
2285     return size;
2286 }
2287 #endif
2288
2289 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
2290 {
2291     struct stat st;
2292     BDRVRawState *s = bs->opaque;
2293
2294     if (fstat(s->fd, &st) < 0) {
2295         return -errno;
2296     }
2297     return (int64_t)st.st_blocks * 512;
2298 }
2299
2300 static int coroutine_fn
2301 raw_co_create(BlockdevCreateOptions *options, Error **errp)
2302 {
2303     BlockdevCreateOptionsFile *file_opts;
2304     Error *local_err = NULL;
2305     int fd;
2306     uint64_t perm, shared;
2307     int result = 0;
2308
2309     /* Validate options and set default values */
2310     assert(options->driver == BLOCKDEV_DRIVER_FILE);
2311     file_opts = &options->u.file;
2312
2313     if (!file_opts->has_nocow) {
2314         file_opts->nocow = false;
2315     }
2316     if (!file_opts->has_preallocation) {
2317         file_opts->preallocation = PREALLOC_MODE_OFF;
2318     }
2319
2320     /* Create file */
2321     fd = qemu_open(file_opts->filename, O_RDWR | O_CREAT | O_BINARY, 0644);
2322     if (fd < 0) {
2323         result = -errno;
2324         error_setg_errno(errp, -result, "Could not create file");
2325         goto out;
2326     }
2327
2328     /* Take permissions: We want to discard everything, so we need
2329      * BLK_PERM_WRITE; and truncation to the desired size requires
2330      * BLK_PERM_RESIZE.
2331      * On the other hand, we cannot share the RESIZE permission
2332      * because we promise that after this function, the file has the
2333      * size given in the options.  If someone else were to resize it
2334      * concurrently, we could not guarantee that.
2335      * Note that after this function, we can no longer guarantee that
2336      * the file is not touched by a third party, so it may be resized
2337      * then. */
2338     perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2339     shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2340
2341     /* Step one: Take locks */
2342     result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
2343     if (result < 0) {
2344         goto out_close;
2345     }
2346
2347     /* Step two: Check that nobody else has taken conflicting locks */
2348     result = raw_check_lock_bytes(fd, perm, shared, errp);
2349     if (result < 0) {
2350         error_append_hint(errp,
2351                           "Is another process using the image [%s]?\n",
2352                           file_opts->filename);
2353         goto out_unlock;
2354     }
2355
2356     /* Clear the file by truncating it to 0 */
2357     result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
2358     if (result < 0) {
2359         goto out_unlock;
2360     }
2361
2362     if (file_opts->nocow) {
2363 #ifdef __linux__
2364         /* Set NOCOW flag to solve performance issue on fs like btrfs.
2365          * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
2366          * will be ignored since any failure of this operation should not
2367          * block the left work.
2368          */
2369         int attr;
2370         if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2371             attr |= FS_NOCOW_FL;
2372             ioctl(fd, FS_IOC_SETFLAGS, &attr);
2373         }
2374 #endif
2375     }
2376
2377     /* Resize and potentially preallocate the file to the desired
2378      * final size */
2379     result = raw_regular_truncate(NULL, fd, file_opts->size,
2380                                   file_opts->preallocation, errp);
2381     if (result < 0) {
2382         goto out_unlock;
2383     }
2384
2385 out_unlock:
2386     raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
2387     if (local_err) {
2388         /* The above call should not fail, and if it does, that does
2389          * not mean the whole creation operation has failed.  So
2390          * report it the user for their convenience, but do not report
2391          * it to the caller. */
2392         warn_report_err(local_err);
2393     }
2394
2395 out_close:
2396     if (qemu_close(fd) != 0 && result == 0) {
2397         result = -errno;
2398         error_setg_errno(errp, -result, "Could not close the new file");
2399     }
2400 out:
2401     return result;
2402 }
2403
2404 static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,
2405                                            Error **errp)
2406 {
2407     BlockdevCreateOptions options;
2408     int64_t total_size = 0;
2409     bool nocow = false;
2410     PreallocMode prealloc;
2411     char *buf = NULL;
2412     Error *local_err = NULL;
2413
2414     /* Skip file: protocol prefix */
2415     strstart(filename, "file:", &filename);
2416
2417     /* Read out options */
2418     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
2419                           BDRV_SECTOR_SIZE);
2420     nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
2421     buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
2422     prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
2423                                PREALLOC_MODE_OFF, &local_err);
2424     g_free(buf);
2425     if (local_err) {
2426         error_propagate(errp, local_err);
2427         return -EINVAL;
2428     }
2429
2430     options = (BlockdevCreateOptions) {
2431         .driver     = BLOCKDEV_DRIVER_FILE,
2432         .u.file     = {
2433             .filename           = (char *) filename,
2434             .size               = total_size,
2435             .has_preallocation  = true,
2436             .preallocation      = prealloc,
2437             .has_nocow          = true,
2438             .nocow              = nocow,
2439         },
2440     };
2441     return raw_co_create(&options, errp);
2442 }
2443
2444 /*
2445  * Find allocation range in @bs around offset @start.
2446  * May change underlying file descriptor's file offset.
2447  * If @start is not in a hole, store @start in @data, and the
2448  * beginning of the next hole in @hole, and return 0.
2449  * If @start is in a non-trailing hole, store @start in @hole and the
2450  * beginning of the next non-hole in @data, and return 0.
2451  * If @start is in a trailing hole or beyond EOF, return -ENXIO.
2452  * If we can't find out, return a negative errno other than -ENXIO.
2453  */
2454 static int find_allocation(BlockDriverState *bs, off_t start,
2455                            off_t *data, off_t *hole)
2456 {
2457 #if defined SEEK_HOLE && defined SEEK_DATA
2458     BDRVRawState *s = bs->opaque;
2459     off_t offs;
2460
2461     /*
2462      * SEEK_DATA cases:
2463      * D1. offs == start: start is in data
2464      * D2. offs > start: start is in a hole, next data at offs
2465      * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
2466      *                              or start is beyond EOF
2467      *     If the latter happens, the file has been truncated behind
2468      *     our back since we opened it.  All bets are off then.
2469      *     Treating like a trailing hole is simplest.
2470      * D4. offs < 0, errno != ENXIO: we learned nothing
2471      */
2472     offs = lseek(s->fd, start, SEEK_DATA);
2473     if (offs < 0) {
2474         return -errno;          /* D3 or D4 */
2475     }
2476
2477     if (offs < start) {
2478         /* This is not a valid return by lseek().  We are safe to just return
2479          * -EIO in this case, and we'll treat it like D4. */
2480         return -EIO;
2481     }
2482
2483     if (offs > start) {
2484         /* D2: in hole, next data at offs */
2485         *hole = start;
2486         *data = offs;
2487         return 0;
2488     }
2489
2490     /* D1: in data, end not yet known */
2491
2492     /*
2493      * SEEK_HOLE cases:
2494      * H1. offs == start: start is in a hole
2495      *     If this happens here, a hole has been dug behind our back
2496      *     since the previous lseek().
2497      * H2. offs > start: either start is in data, next hole at offs,
2498      *                   or start is in trailing hole, EOF at offs
2499      *     Linux treats trailing holes like any other hole: offs ==
2500      *     start.  Solaris seeks to EOF instead: offs > start (blech).
2501      *     If that happens here, a hole has been dug behind our back
2502      *     since the previous lseek().
2503      * H3. offs < 0, errno = ENXIO: start is beyond EOF
2504      *     If this happens, the file has been truncated behind our
2505      *     back since we opened it.  Treat it like a trailing hole.
2506      * H4. offs < 0, errno != ENXIO: we learned nothing
2507      *     Pretend we know nothing at all, i.e. "forget" about D1.
2508      */
2509     offs = lseek(s->fd, start, SEEK_HOLE);
2510     if (offs < 0) {
2511         return -errno;          /* D1 and (H3 or H4) */
2512     }
2513
2514     if (offs < start) {
2515         /* This is not a valid return by lseek().  We are safe to just return
2516          * -EIO in this case, and we'll treat it like H4. */
2517         return -EIO;
2518     }
2519
2520     if (offs > start) {
2521         /*
2522          * D1 and H2: either in data, next hole at offs, or it was in
2523          * data but is now in a trailing hole.  In the latter case,
2524          * all bets are off.  Treating it as if it there was data all
2525          * the way to EOF is safe, so simply do that.
2526          */
2527         *data = start;
2528         *hole = offs;
2529         return 0;
2530     }
2531
2532     /* D1 and H1 */
2533     return -EBUSY;
2534 #else
2535     return -ENOTSUP;
2536 #endif
2537 }
2538
2539 /*
2540  * Returns the allocation status of the specified offset.
2541  *
2542  * The block layer guarantees 'offset' and 'bytes' are within bounds.
2543  *
2544  * 'pnum' is set to the number of bytes (including and immediately following
2545  * the specified offset) that are known to be in the same
2546  * allocated/unallocated state.
2547  *
2548  * 'bytes' is the max value 'pnum' should be set to.
2549  */
2550 static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
2551                                             bool want_zero,
2552                                             int64_t offset,
2553                                             int64_t bytes, int64_t *pnum,
2554                                             int64_t *map,
2555                                             BlockDriverState **file)
2556 {
2557     off_t data = 0, hole = 0;
2558     int ret;
2559
2560     assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
2561
2562     ret = fd_open(bs);
2563     if (ret < 0) {
2564         return ret;
2565     }
2566
2567     if (!want_zero) {
2568         *pnum = bytes;
2569         *map = offset;
2570         *file = bs;
2571         return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
2572     }
2573
2574     ret = find_allocation(bs, offset, &data, &hole);
2575     if (ret == -ENXIO) {
2576         /* Trailing hole */
2577         *pnum = bytes;
2578         ret = BDRV_BLOCK_ZERO;
2579     } else if (ret < 0) {
2580         /* No info available, so pretend there are no holes */
2581         *pnum = bytes;
2582         ret = BDRV_BLOCK_DATA;
2583     } else if (data == offset) {
2584         /* On a data extent, compute bytes to the end of the extent,
2585          * possibly including a partial sector at EOF. */
2586         *pnum = MIN(bytes, hole - offset);
2587
2588         /*
2589          * We are not allowed to return partial sectors, though, so
2590          * round up if necessary.
2591          */
2592         if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
2593             int64_t file_length = raw_getlength(bs);
2594             if (file_length > 0) {
2595                 /* Ignore errors, this is just a safeguard */
2596                 assert(hole == file_length);
2597             }
2598             *pnum = ROUND_UP(*pnum, bs->bl.request_alignment);
2599         }
2600
2601         ret = BDRV_BLOCK_DATA;
2602     } else {
2603         /* On a hole, compute bytes to the beginning of the next extent.  */
2604         assert(hole == offset);
2605         *pnum = MIN(bytes, data - offset);
2606         ret = BDRV_BLOCK_ZERO;
2607     }
2608     *map = offset;
2609     *file = bs;
2610     return ret | BDRV_BLOCK_OFFSET_VALID;
2611 }
2612
2613 #if defined(__linux__)
2614 /* Verify that the file is not in the page cache */
2615 static void check_cache_dropped(BlockDriverState *bs, Error **errp)
2616 {
2617     const size_t window_size = 128 * 1024 * 1024;
2618     BDRVRawState *s = bs->opaque;
2619     void *window = NULL;
2620     size_t length = 0;
2621     unsigned char *vec;
2622     size_t page_size;
2623     off_t offset;
2624     off_t end;
2625
2626     /* mincore(2) page status information requires 1 byte per page */
2627     page_size = sysconf(_SC_PAGESIZE);
2628     vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
2629
2630     end = raw_getlength(bs);
2631
2632     for (offset = 0; offset < end; offset += window_size) {
2633         void *new_window;
2634         size_t new_length;
2635         size_t vec_end;
2636         size_t i;
2637         int ret;
2638
2639         /* Unmap previous window if size has changed */
2640         new_length = MIN(end - offset, window_size);
2641         if (new_length != length) {
2642             munmap(window, length);
2643             window = NULL;
2644             length = 0;
2645         }
2646
2647         new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
2648                           s->fd, offset);
2649         if (new_window == MAP_FAILED) {
2650             error_setg_errno(errp, errno, "mmap failed");
2651             break;
2652         }
2653
2654         window = new_window;
2655         length = new_length;
2656
2657         ret = mincore(window, length, vec);
2658         if (ret < 0) {
2659             error_setg_errno(errp, errno, "mincore failed");
2660             break;
2661         }
2662
2663         vec_end = DIV_ROUND_UP(length, page_size);
2664         for (i = 0; i < vec_end; i++) {
2665             if (vec[i] & 0x1) {
2666                 error_setg(errp, "page cache still in use!");
2667                 break;
2668             }
2669         }
2670     }
2671
2672     if (window) {
2673         munmap(window, length);
2674     }
2675
2676     g_free(vec);
2677 }
2678 #endif /* __linux__ */
2679
2680 static void coroutine_fn raw_co_invalidate_cache(BlockDriverState *bs,
2681                                                  Error **errp)
2682 {
2683     BDRVRawState *s = bs->opaque;
2684     int ret;
2685
2686     ret = fd_open(bs);
2687     if (ret < 0) {
2688         error_setg_errno(errp, -ret, "The file descriptor is not open");
2689         return;
2690     }
2691
2692     if (!s->drop_cache) {
2693         return;
2694     }
2695
2696     if (s->open_flags & O_DIRECT) {
2697         return; /* No host kernel page cache */
2698     }
2699
2700 #if defined(__linux__)
2701     /* This sets the scene for the next syscall... */
2702     ret = bdrv_co_flush(bs);
2703     if (ret < 0) {
2704         error_setg_errno(errp, -ret, "flush failed");
2705         return;
2706     }
2707
2708     /* Linux does not invalidate pages that are dirty, locked, or mmapped by a
2709      * process.  These limitations are okay because we just fsynced the file,
2710      * we don't use mmap, and the file should not be in use by other processes.
2711      */
2712     ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
2713     if (ret != 0) { /* the return value is a positive errno */
2714         error_setg_errno(errp, ret, "fadvise failed");
2715         return;
2716     }
2717
2718     if (s->check_cache_dropped) {
2719         check_cache_dropped(bs, errp);
2720     }
2721 #else /* __linux__ */
2722     /* Do nothing.  Live migration to a remote host with cache.direct=off is
2723      * unsupported on other host operating systems.  Cache consistency issues
2724      * may occur but no error is reported here, partly because that's the
2725      * historical behavior and partly because it's hard to differentiate valid
2726      * configurations that should not cause errors.
2727      */
2728 #endif /* !__linux__ */
2729 }
2730
2731 static coroutine_fn int
2732 raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int bytes, bool blkdev)
2733 {
2734     BDRVRawState *s = bs->opaque;
2735     RawPosixAIOData acb;
2736
2737     acb = (RawPosixAIOData) {
2738         .bs             = bs,
2739         .aio_fildes     = s->fd,
2740         .aio_type       = QEMU_AIO_DISCARD,
2741         .aio_offset     = offset,
2742         .aio_nbytes     = bytes,
2743     };
2744
2745     if (blkdev) {
2746         acb.aio_type |= QEMU_AIO_BLKDEV;
2747     }
2748
2749     return raw_thread_pool_submit(bs, handle_aiocb_discard, &acb);
2750 }
2751
2752 static coroutine_fn int
2753 raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
2754 {
2755     return raw_do_pdiscard(bs, offset, bytes, false);
2756 }
2757
2758 static int coroutine_fn
2759 raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
2760                      BdrvRequestFlags flags, bool blkdev)
2761 {
2762     BDRVRawState *s = bs->opaque;
2763     RawPosixAIOData acb;
2764     ThreadPoolFunc *handler;
2765
2766     acb = (RawPosixAIOData) {
2767         .bs             = bs,
2768         .aio_fildes     = s->fd,
2769         .aio_type       = QEMU_AIO_WRITE_ZEROES,
2770         .aio_offset     = offset,
2771         .aio_nbytes     = bytes,
2772     };
2773
2774     if (blkdev) {
2775         acb.aio_type |= QEMU_AIO_BLKDEV;
2776     }
2777     if (flags & BDRV_REQ_NO_FALLBACK) {
2778         acb.aio_type |= QEMU_AIO_NO_FALLBACK;
2779     }
2780
2781     if (flags & BDRV_REQ_MAY_UNMAP) {
2782         acb.aio_type |= QEMU_AIO_DISCARD;
2783         handler = handle_aiocb_write_zeroes_unmap;
2784     } else {
2785         handler = handle_aiocb_write_zeroes;
2786     }
2787
2788     return raw_thread_pool_submit(bs, handler, &acb);
2789 }
2790
2791 static int coroutine_fn raw_co_pwrite_zeroes(
2792     BlockDriverState *bs, int64_t offset,
2793     int bytes, BdrvRequestFlags flags)
2794 {
2795     return raw_do_pwrite_zeroes(bs, offset, bytes, flags, false);
2796 }
2797
2798 static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
2799 {
2800     BDRVRawState *s = bs->opaque;
2801
2802     bdi->unallocated_blocks_are_zero = s->discard_zeroes;
2803     return 0;
2804 }
2805
2806 static QemuOptsList raw_create_opts = {
2807     .name = "raw-create-opts",
2808     .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
2809     .desc = {
2810         {
2811             .name = BLOCK_OPT_SIZE,
2812             .type = QEMU_OPT_SIZE,
2813             .help = "Virtual disk size"
2814         },
2815         {
2816             .name = BLOCK_OPT_NOCOW,
2817             .type = QEMU_OPT_BOOL,
2818             .help = "Turn off copy-on-write (valid only on btrfs)"
2819         },
2820         {
2821             .name = BLOCK_OPT_PREALLOC,
2822             .type = QEMU_OPT_STRING,
2823             .help = "Preallocation mode (allowed values: off"
2824 #ifdef CONFIG_POSIX_FALLOCATE
2825                     ", falloc"
2826 #endif
2827                     ", full)"
2828         },
2829         { /* end of list */ }
2830     }
2831 };
2832
2833 static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
2834                           Error **errp)
2835 {
2836     BDRVRawState *s = bs->opaque;
2837     BDRVRawReopenState *rs = NULL;
2838     int open_flags;
2839     int ret;
2840
2841     if (s->perm_change_fd) {
2842         /*
2843          * In the context of reopen, this function may be called several times
2844          * (directly and recursively while change permissions of the parent).
2845          * This is even true for children that don't inherit from the original
2846          * reopen node, so s->reopen_state is not set.
2847          *
2848          * Ignore all but the first call.
2849          */
2850         return 0;
2851     }
2852
2853     if (s->reopen_state) {
2854         /* We already have a new file descriptor to set permissions for */
2855         assert(s->reopen_state->perm == perm);
2856         assert(s->reopen_state->shared_perm == shared);
2857         rs = s->reopen_state->opaque;
2858         s->perm_change_fd = rs->fd;
2859         s->perm_change_flags = rs->open_flags;
2860     } else {
2861         /* We may need a new fd if auto-read-only switches the mode */
2862         ret = raw_reconfigure_getfd(bs, bs->open_flags, &open_flags, perm,
2863                                     false, errp);
2864         if (ret < 0) {
2865             return ret;
2866         } else if (ret != s->fd) {
2867             s->perm_change_fd = ret;
2868             s->perm_change_flags = open_flags;
2869         }
2870     }
2871
2872     /* Prepare permissions on old fd to avoid conflicts between old and new,
2873      * but keep everything locked that new will need. */
2874     ret = raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
2875     if (ret < 0) {
2876         goto fail;
2877     }
2878
2879     /* Copy locks to the new fd */
2880     if (s->perm_change_fd) {
2881         ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared,
2882                                    false, errp);
2883         if (ret < 0) {
2884             raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
2885             goto fail;
2886         }
2887     }
2888     return 0;
2889
2890 fail:
2891     if (s->perm_change_fd && !s->reopen_state) {
2892         qemu_close(s->perm_change_fd);
2893     }
2894     s->perm_change_fd = 0;
2895     return ret;
2896 }
2897
2898 static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
2899 {
2900     BDRVRawState *s = bs->opaque;
2901
2902     /* For reopen, we have already switched to the new fd (.bdrv_set_perm is
2903      * called after .bdrv_reopen_commit) */
2904     if (s->perm_change_fd && s->fd != s->perm_change_fd) {
2905         qemu_close(s->fd);
2906         s->fd = s->perm_change_fd;
2907         s->open_flags = s->perm_change_flags;
2908     }
2909     s->perm_change_fd = 0;
2910
2911     raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
2912     s->perm = perm;
2913     s->shared_perm = shared;
2914 }
2915
2916 static void raw_abort_perm_update(BlockDriverState *bs)
2917 {
2918     BDRVRawState *s = bs->opaque;
2919
2920     /* For reopen, .bdrv_reopen_abort is called afterwards and will close
2921      * the file descriptor. */
2922     if (s->perm_change_fd && !s->reopen_state) {
2923         qemu_close(s->perm_change_fd);
2924     }
2925     s->perm_change_fd = 0;
2926
2927     raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
2928 }
2929
2930 static int coroutine_fn raw_co_copy_range_from(
2931         BlockDriverState *bs, BdrvChild *src, uint64_t src_offset,
2932         BdrvChild *dst, uint64_t dst_offset, uint64_t bytes,
2933         BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
2934 {
2935     return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
2936                                  read_flags, write_flags);
2937 }
2938
2939 static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
2940                                              BdrvChild *src,
2941                                              uint64_t src_offset,
2942                                              BdrvChild *dst,
2943                                              uint64_t dst_offset,
2944                                              uint64_t bytes,
2945                                              BdrvRequestFlags read_flags,
2946                                              BdrvRequestFlags write_flags)
2947 {
2948     RawPosixAIOData acb;
2949     BDRVRawState *s = bs->opaque;
2950     BDRVRawState *src_s;
2951
2952     assert(dst->bs == bs);
2953     if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
2954         return -ENOTSUP;
2955     }
2956
2957     src_s = src->bs->opaque;
2958     if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) {
2959         return -EIO;
2960     }
2961
2962     acb = (RawPosixAIOData) {
2963         .bs             = bs,
2964         .aio_type       = QEMU_AIO_COPY_RANGE,
2965         .aio_fildes     = src_s->fd,
2966         .aio_offset     = src_offset,
2967         .aio_nbytes     = bytes,
2968         .copy_range     = {
2969             .aio_fd2        = s->fd,
2970             .aio_offset2    = dst_offset,
2971         },
2972     };
2973
2974     return raw_thread_pool_submit(bs, handle_aiocb_copy_range, &acb);
2975 }
2976
2977 BlockDriver bdrv_file = {
2978     .format_name = "file",
2979     .protocol_name = "file",
2980     .instance_size = sizeof(BDRVRawState),
2981     .bdrv_needs_filename = true,
2982     .bdrv_probe = NULL, /* no probe for protocols */
2983     .bdrv_parse_filename = raw_parse_filename,
2984     .bdrv_file_open = raw_open,
2985     .bdrv_reopen_prepare = raw_reopen_prepare,
2986     .bdrv_reopen_commit = raw_reopen_commit,
2987     .bdrv_reopen_abort = raw_reopen_abort,
2988     .bdrv_close = raw_close,
2989     .bdrv_co_create = raw_co_create,
2990     .bdrv_co_create_opts = raw_co_create_opts,
2991     .bdrv_has_zero_init = bdrv_has_zero_init_1,
2992     .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
2993     .bdrv_co_block_status = raw_co_block_status,
2994     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
2995     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
2996
2997     .bdrv_co_preadv         = raw_co_preadv,
2998     .bdrv_co_pwritev        = raw_co_pwritev,
2999     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
3000     .bdrv_co_pdiscard       = raw_co_pdiscard,
3001     .bdrv_co_copy_range_from = raw_co_copy_range_from,
3002     .bdrv_co_copy_range_to  = raw_co_copy_range_to,
3003     .bdrv_refresh_limits = raw_refresh_limits,
3004     .bdrv_io_plug = raw_aio_plug,
3005     .bdrv_io_unplug = raw_aio_unplug,
3006     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3007
3008     .bdrv_co_truncate = raw_co_truncate,
3009     .bdrv_getlength = raw_getlength,
3010     .bdrv_get_info = raw_get_info,
3011     .bdrv_get_allocated_file_size
3012                         = raw_get_allocated_file_size,
3013     .bdrv_check_perm = raw_check_perm,
3014     .bdrv_set_perm   = raw_set_perm,
3015     .bdrv_abort_perm_update = raw_abort_perm_update,
3016     .create_opts = &raw_create_opts,
3017     .mutable_opts = mutable_opts,
3018 };
3019
3020 /***********************************************/
3021 /* host device */
3022
3023 #if defined(__APPLE__) && defined(__MACH__)
3024 static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3025                                 CFIndex maxPathSize, int flags);
3026 static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
3027 {
3028     kern_return_t kernResult = KERN_FAILURE;
3029     mach_port_t     masterPort;
3030     CFMutableDictionaryRef  classesToMatch;
3031     const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
3032     char *mediaType = NULL;
3033
3034     kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
3035     if ( KERN_SUCCESS != kernResult ) {
3036         printf( "IOMasterPort returned %d\n", kernResult );
3037     }
3038
3039     int index;
3040     for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
3041         classesToMatch = IOServiceMatching(matching_array[index]);
3042         if (classesToMatch == NULL) {
3043             error_report("IOServiceMatching returned NULL for %s",
3044                          matching_array[index]);
3045             continue;
3046         }
3047         CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
3048                              kCFBooleanTrue);
3049         kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
3050                                                   mediaIterator);
3051         if (kernResult != KERN_SUCCESS) {
3052             error_report("Note: IOServiceGetMatchingServices returned %d",
3053                          kernResult);
3054             continue;
3055         }
3056
3057         /* If a match was found, leave the loop */
3058         if (*mediaIterator != 0) {
3059             trace_file_FindEjectableOpticalMedia(matching_array[index]);
3060             mediaType = g_strdup(matching_array[index]);
3061             break;
3062         }
3063     }
3064     return mediaType;
3065 }
3066
3067 kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3068                          CFIndex maxPathSize, int flags)
3069 {
3070     io_object_t     nextMedia;
3071     kern_return_t   kernResult = KERN_FAILURE;
3072     *bsdPath = '\0';
3073     nextMedia = IOIteratorNext( mediaIterator );
3074     if ( nextMedia )
3075     {
3076         CFTypeRef   bsdPathAsCFString;
3077     bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
3078         if ( bsdPathAsCFString ) {
3079             size_t devPathLength;
3080             strcpy( bsdPath, _PATH_DEV );
3081             if (flags & BDRV_O_NOCACHE) {
3082                 strcat(bsdPath, "r");
3083             }
3084             devPathLength = strlen( bsdPath );
3085             if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
3086                 kernResult = KERN_SUCCESS;
3087             }
3088             CFRelease( bsdPathAsCFString );
3089         }
3090         IOObjectRelease( nextMedia );
3091     }
3092
3093     return kernResult;
3094 }
3095
3096 /* Sets up a real cdrom for use in QEMU */
3097 static bool setup_cdrom(char *bsd_path, Error **errp)
3098 {
3099     int index, num_of_test_partitions = 2, fd;
3100     char test_partition[MAXPATHLEN];
3101     bool partition_found = false;
3102
3103     /* look for a working partition */
3104     for (index = 0; index < num_of_test_partitions; index++) {
3105         snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
3106                  index);
3107         fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE);
3108         if (fd >= 0) {
3109             partition_found = true;
3110             qemu_close(fd);
3111             break;
3112         }
3113     }
3114
3115     /* if a working partition on the device was not found */
3116     if (partition_found == false) {
3117         error_setg(errp, "Failed to find a working partition on disc");
3118     } else {
3119         trace_file_setup_cdrom(test_partition);
3120         pstrcpy(bsd_path, MAXPATHLEN, test_partition);
3121     }
3122     return partition_found;
3123 }
3124
3125 /* Prints directions on mounting and unmounting a device */
3126 static void print_unmounting_directions(const char *file_name)
3127 {
3128     error_report("If device %s is mounted on the desktop, unmount"
3129                  " it first before using it in QEMU", file_name);
3130     error_report("Command to unmount device: diskutil unmountDisk %s",
3131                  file_name);
3132     error_report("Command to mount device: diskutil mountDisk %s", file_name);
3133 }
3134
3135 #endif /* defined(__APPLE__) && defined(__MACH__) */
3136
3137 static int hdev_probe_device(const char *filename)
3138 {
3139     struct stat st;
3140
3141     /* allow a dedicated CD-ROM driver to match with a higher priority */
3142     if (strstart(filename, "/dev/cdrom", NULL))
3143         return 50;
3144
3145     if (stat(filename, &st) >= 0 &&
3146             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
3147         return 100;
3148     }
3149
3150     return 0;
3151 }
3152
3153 static int check_hdev_writable(BDRVRawState *s)
3154 {
3155 #if defined(BLKROGET)
3156     /* Linux block devices can be configured "read-only" using blockdev(8).
3157      * This is independent of device node permissions and therefore open(2)
3158      * with O_RDWR succeeds.  Actual writes fail with EPERM.
3159      *
3160      * bdrv_open() is supposed to fail if the disk is read-only.  Explicitly
3161      * check for read-only block devices so that Linux block devices behave
3162      * properly.
3163      */
3164     struct stat st;
3165     int readonly = 0;
3166
3167     if (fstat(s->fd, &st)) {
3168         return -errno;
3169     }
3170
3171     if (!S_ISBLK(st.st_mode)) {
3172         return 0;
3173     }
3174
3175     if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
3176         return -errno;
3177     }
3178
3179     if (readonly) {
3180         return -EACCES;
3181     }
3182 #endif /* defined(BLKROGET) */
3183     return 0;
3184 }
3185
3186 static void hdev_parse_filename(const char *filename, QDict *options,
3187                                 Error **errp)
3188 {
3189     bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
3190 }
3191
3192 static bool hdev_is_sg(BlockDriverState *bs)
3193 {
3194
3195 #if defined(__linux__)
3196
3197     BDRVRawState *s = bs->opaque;
3198     struct stat st;
3199     struct sg_scsi_id scsiid;
3200     int sg_version;
3201     int ret;
3202
3203     if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
3204         return false;
3205     }
3206
3207     ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
3208     if (ret < 0) {
3209         return false;
3210     }
3211
3212     ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
3213     if (ret >= 0) {
3214         trace_file_hdev_is_sg(scsiid.scsi_type, sg_version);
3215         return true;
3216     }
3217
3218 #endif
3219
3220     return false;
3221 }
3222
3223 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
3224                      Error **errp)
3225 {
3226     BDRVRawState *s = bs->opaque;
3227     Error *local_err = NULL;
3228     int ret;
3229
3230 #if defined(__APPLE__) && defined(__MACH__)
3231     /*
3232      * Caution: while qdict_get_str() is fine, getting non-string types
3233      * would require more care.  When @options come from -blockdev or
3234      * blockdev_add, its members are typed according to the QAPI
3235      * schema, but when they come from -drive, they're all QString.
3236      */
3237     const char *filename = qdict_get_str(options, "filename");
3238     char bsd_path[MAXPATHLEN] = "";
3239     bool error_occurred = false;
3240
3241     /* If using a real cdrom */
3242     if (strcmp(filename, "/dev/cdrom") == 0) {
3243         char *mediaType = NULL;
3244         kern_return_t ret_val;
3245         io_iterator_t mediaIterator = 0;
3246
3247         mediaType = FindEjectableOpticalMedia(&mediaIterator);
3248         if (mediaType == NULL) {
3249             error_setg(errp, "Please make sure your CD/DVD is in the optical"
3250                        " drive");
3251             error_occurred = true;
3252             goto hdev_open_Mac_error;
3253         }
3254
3255         ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
3256         if (ret_val != KERN_SUCCESS) {
3257             error_setg(errp, "Could not get BSD path for optical drive");
3258             error_occurred = true;
3259             goto hdev_open_Mac_error;
3260         }
3261
3262         /* If a real optical drive was not found */
3263         if (bsd_path[0] == '\0') {
3264             error_setg(errp, "Failed to obtain bsd path for optical drive");
3265             error_occurred = true;
3266             goto hdev_open_Mac_error;
3267         }
3268
3269         /* If using a cdrom disc and finding a partition on the disc failed */
3270         if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
3271             setup_cdrom(bsd_path, errp) == false) {
3272             print_unmounting_directions(bsd_path);
3273             error_occurred = true;
3274             goto hdev_open_Mac_error;
3275         }
3276
3277         qdict_put_str(options, "filename", bsd_path);
3278
3279 hdev_open_Mac_error:
3280         g_free(mediaType);
3281         if (mediaIterator) {
3282             IOObjectRelease(mediaIterator);
3283         }
3284         if (error_occurred) {
3285             return -ENOENT;
3286         }
3287     }
3288 #endif /* defined(__APPLE__) && defined(__MACH__) */
3289
3290     s->type = FTYPE_FILE;
3291
3292     ret = raw_open_common(bs, options, flags, 0, true, &local_err);
3293     if (ret < 0) {
3294         error_propagate(errp, local_err);
3295 #if defined(__APPLE__) && defined(__MACH__)
3296         if (*bsd_path) {
3297             filename = bsd_path;
3298         }
3299         /* if a physical device experienced an error while being opened */
3300         if (strncmp(filename, "/dev/", 5) == 0) {
3301             print_unmounting_directions(filename);
3302         }
3303 #endif /* defined(__APPLE__) && defined(__MACH__) */
3304         return ret;
3305     }
3306
3307     /* Since this does ioctl the device must be already opened */
3308     bs->sg = hdev_is_sg(bs);
3309
3310     if (flags & BDRV_O_RDWR) {
3311         ret = check_hdev_writable(s);
3312         if (ret < 0) {
3313             raw_close(bs);
3314             error_setg_errno(errp, -ret, "The device is not writable");
3315             return ret;
3316         }
3317     }
3318
3319     return ret;
3320 }
3321
3322 #if defined(__linux__)
3323 static int coroutine_fn
3324 hdev_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
3325 {
3326     BDRVRawState *s = bs->opaque;
3327     RawPosixAIOData acb;
3328     int ret;
3329
3330     ret = fd_open(bs);
3331     if (ret < 0) {
3332         return ret;
3333     }
3334
3335     if (req == SG_IO && s->pr_mgr) {
3336         struct sg_io_hdr *io_hdr = buf;
3337         if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
3338             io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
3339             return pr_manager_execute(s->pr_mgr, bdrv_get_aio_context(bs),
3340                                       s->fd, io_hdr);
3341         }
3342     }
3343
3344     acb = (RawPosixAIOData) {
3345         .bs         = bs,
3346         .aio_type   = QEMU_AIO_IOCTL,
3347         .aio_fildes = s->fd,
3348         .aio_offset = 0,
3349         .ioctl      = {
3350             .buf        = buf,
3351             .cmd        = req,
3352         },
3353     };
3354
3355     return raw_thread_pool_submit(bs, handle_aiocb_ioctl, &acb);
3356 }
3357 #endif /* linux */
3358
3359 static int fd_open(BlockDriverState *bs)
3360 {
3361     BDRVRawState *s = bs->opaque;
3362
3363     /* this is just to ensure s->fd is sane (its called by io ops) */
3364     if (s->fd >= 0)
3365         return 0;
3366     return -EIO;
3367 }
3368
3369 static coroutine_fn int
3370 hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
3371 {
3372     int ret;
3373
3374     ret = fd_open(bs);
3375     if (ret < 0) {
3376         return ret;
3377     }
3378     return raw_do_pdiscard(bs, offset, bytes, true);
3379 }
3380
3381 static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
3382     int64_t offset, int bytes, BdrvRequestFlags flags)
3383 {
3384     int rc;
3385
3386     rc = fd_open(bs);
3387     if (rc < 0) {
3388         return rc;
3389     }
3390
3391     return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
3392 }
3393
3394 static int coroutine_fn hdev_co_create_opts(const char *filename, QemuOpts *opts,
3395                                             Error **errp)
3396 {
3397     int fd;
3398     int ret = 0;
3399     struct stat stat_buf;
3400     int64_t total_size = 0;
3401     bool has_prefix;
3402
3403     /* This function is used by both protocol block drivers and therefore either
3404      * of these prefixes may be given.
3405      * The return value has to be stored somewhere, otherwise this is an error
3406      * due to -Werror=unused-value. */
3407     has_prefix =
3408         strstart(filename, "host_device:", &filename) ||
3409         strstart(filename, "host_cdrom:" , &filename);
3410
3411     (void)has_prefix;
3412
3413     ret = raw_normalize_devicepath(&filename, errp);
3414     if (ret < 0) {
3415         return ret;
3416     }
3417
3418     /* Read out options */
3419     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
3420                           BDRV_SECTOR_SIZE);
3421
3422     fd = qemu_open(filename, O_WRONLY | O_BINARY);
3423     if (fd < 0) {
3424         ret = -errno;
3425         error_setg_errno(errp, -ret, "Could not open device");
3426         return ret;
3427     }
3428
3429     if (fstat(fd, &stat_buf) < 0) {
3430         ret = -errno;
3431         error_setg_errno(errp, -ret, "Could not stat device");
3432     } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
3433         error_setg(errp,
3434                    "The given file is neither a block nor a character device");
3435         ret = -ENODEV;
3436     } else if (lseek(fd, 0, SEEK_END) < total_size) {
3437         error_setg(errp, "Device is too small");
3438         ret = -ENOSPC;
3439     }
3440
3441     if (!ret && total_size) {
3442         uint8_t buf[BDRV_SECTOR_SIZE] = { 0 };
3443         int64_t zero_size = MIN(BDRV_SECTOR_SIZE, total_size);
3444         if (lseek(fd, 0, SEEK_SET) == -1) {
3445             ret = -errno;
3446         } else {
3447             ret = qemu_write_full(fd, buf, zero_size);
3448             ret = ret == zero_size ? 0 : -errno;
3449         }
3450     }
3451     qemu_close(fd);
3452     return ret;
3453 }
3454
3455 static BlockDriver bdrv_host_device = {
3456     .format_name        = "host_device",
3457     .protocol_name        = "host_device",
3458     .instance_size      = sizeof(BDRVRawState),
3459     .bdrv_needs_filename = true,
3460     .bdrv_probe_device  = hdev_probe_device,
3461     .bdrv_parse_filename = hdev_parse_filename,
3462     .bdrv_file_open     = hdev_open,
3463     .bdrv_close         = raw_close,
3464     .bdrv_reopen_prepare = raw_reopen_prepare,
3465     .bdrv_reopen_commit  = raw_reopen_commit,
3466     .bdrv_reopen_abort   = raw_reopen_abort,
3467     .bdrv_co_create_opts = hdev_co_create_opts,
3468     .create_opts         = &raw_create_opts,
3469     .mutable_opts        = mutable_opts,
3470     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3471     .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
3472
3473     .bdrv_co_preadv         = raw_co_preadv,
3474     .bdrv_co_pwritev        = raw_co_pwritev,
3475     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
3476     .bdrv_co_pdiscard       = hdev_co_pdiscard,
3477     .bdrv_co_copy_range_from = raw_co_copy_range_from,
3478     .bdrv_co_copy_range_to  = raw_co_copy_range_to,
3479     .bdrv_refresh_limits = raw_refresh_limits,
3480     .bdrv_io_plug = raw_aio_plug,
3481     .bdrv_io_unplug = raw_aio_unplug,
3482     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3483
3484     .bdrv_co_truncate       = raw_co_truncate,
3485     .bdrv_getlength     = raw_getlength,
3486     .bdrv_get_info = raw_get_info,
3487     .bdrv_get_allocated_file_size
3488                         = raw_get_allocated_file_size,
3489     .bdrv_check_perm = raw_check_perm,
3490     .bdrv_set_perm   = raw_set_perm,
3491     .bdrv_abort_perm_update = raw_abort_perm_update,
3492     .bdrv_probe_blocksizes = hdev_probe_blocksizes,
3493     .bdrv_probe_geometry = hdev_probe_geometry,
3494
3495     /* generic scsi device */
3496 #ifdef __linux__
3497     .bdrv_co_ioctl          = hdev_co_ioctl,
3498 #endif
3499 };
3500
3501 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3502 static void cdrom_parse_filename(const char *filename, QDict *options,
3503                                  Error **errp)
3504 {
3505     bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
3506 }
3507 #endif
3508
3509 #ifdef __linux__
3510 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3511                       Error **errp)
3512 {
3513     BDRVRawState *s = bs->opaque;
3514
3515     s->type = FTYPE_CD;
3516
3517     /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
3518     return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp);
3519 }
3520
3521 static int cdrom_probe_device(const char *filename)
3522 {
3523     int fd, ret;
3524     int prio = 0;
3525     struct stat st;
3526
3527     fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
3528     if (fd < 0) {
3529         goto out;
3530     }
3531     ret = fstat(fd, &st);
3532     if (ret == -1 || !S_ISBLK(st.st_mode)) {
3533         goto outc;
3534     }
3535
3536     /* Attempt to detect via a CDROM specific ioctl */
3537     ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3538     if (ret >= 0)
3539         prio = 100;
3540
3541 outc:
3542     qemu_close(fd);
3543 out:
3544     return prio;
3545 }
3546
3547 static bool cdrom_is_inserted(BlockDriverState *bs)
3548 {
3549     BDRVRawState *s = bs->opaque;
3550     int ret;
3551
3552     ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
3553     return ret == CDS_DISC_OK;
3554 }
3555
3556 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3557 {
3558     BDRVRawState *s = bs->opaque;
3559
3560     if (eject_flag) {
3561         if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
3562             perror("CDROMEJECT");
3563     } else {
3564         if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
3565             perror("CDROMEJECT");
3566     }
3567 }
3568
3569 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3570 {
3571     BDRVRawState *s = bs->opaque;
3572
3573     if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
3574         /*
3575          * Note: an error can happen if the distribution automatically
3576          * mounts the CD-ROM
3577          */
3578         /* perror("CDROM_LOCKDOOR"); */
3579     }
3580 }
3581
3582 static BlockDriver bdrv_host_cdrom = {
3583     .format_name        = "host_cdrom",
3584     .protocol_name      = "host_cdrom",
3585     .instance_size      = sizeof(BDRVRawState),
3586     .bdrv_needs_filename = true,
3587     .bdrv_probe_device  = cdrom_probe_device,
3588     .bdrv_parse_filename = cdrom_parse_filename,
3589     .bdrv_file_open     = cdrom_open,
3590     .bdrv_close         = raw_close,
3591     .bdrv_reopen_prepare = raw_reopen_prepare,
3592     .bdrv_reopen_commit  = raw_reopen_commit,
3593     .bdrv_reopen_abort   = raw_reopen_abort,
3594     .bdrv_co_create_opts = hdev_co_create_opts,
3595     .create_opts         = &raw_create_opts,
3596     .mutable_opts        = mutable_opts,
3597     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3598
3599
3600     .bdrv_co_preadv         = raw_co_preadv,
3601     .bdrv_co_pwritev        = raw_co_pwritev,
3602     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
3603     .bdrv_refresh_limits = raw_refresh_limits,
3604     .bdrv_io_plug = raw_aio_plug,
3605     .bdrv_io_unplug = raw_aio_unplug,
3606     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3607
3608     .bdrv_co_truncate    = raw_co_truncate,
3609     .bdrv_getlength      = raw_getlength,
3610     .has_variable_length = true,
3611     .bdrv_get_allocated_file_size
3612                         = raw_get_allocated_file_size,
3613
3614     /* removable device support */
3615     .bdrv_is_inserted   = cdrom_is_inserted,
3616     .bdrv_eject         = cdrom_eject,
3617     .bdrv_lock_medium   = cdrom_lock_medium,
3618
3619     /* generic scsi device */
3620     .bdrv_co_ioctl      = hdev_co_ioctl,
3621 };
3622 #endif /* __linux__ */
3623
3624 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
3625 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
3626                       Error **errp)
3627 {
3628     BDRVRawState *s = bs->opaque;
3629     Error *local_err = NULL;
3630     int ret;
3631
3632     s->type = FTYPE_CD;
3633
3634     ret = raw_open_common(bs, options, flags, 0, true, &local_err);
3635     if (ret) {
3636         error_propagate(errp, local_err);
3637         return ret;
3638     }
3639
3640     /* make sure the door isn't locked at this time */
3641     ioctl(s->fd, CDIOCALLOW);
3642     return 0;
3643 }
3644
3645 static int cdrom_probe_device(const char *filename)
3646 {
3647     if (strstart(filename, "/dev/cd", NULL) ||
3648             strstart(filename, "/dev/acd", NULL))
3649         return 100;
3650     return 0;
3651 }
3652
3653 static int cdrom_reopen(BlockDriverState *bs)
3654 {
3655     BDRVRawState *s = bs->opaque;
3656     int fd;
3657
3658     /*
3659      * Force reread of possibly changed/newly loaded disc,
3660      * FreeBSD seems to not notice sometimes...
3661      */
3662     if (s->fd >= 0)
3663         qemu_close(s->fd);
3664     fd = qemu_open(bs->filename, s->open_flags, 0644);
3665     if (fd < 0) {
3666         s->fd = -1;
3667         return -EIO;
3668     }
3669     s->fd = fd;
3670
3671     /* make sure the door isn't locked at this time */
3672     ioctl(s->fd, CDIOCALLOW);
3673     return 0;
3674 }
3675
3676 static bool cdrom_is_inserted(BlockDriverState *bs)
3677 {
3678     return raw_getlength(bs) > 0;
3679 }
3680
3681 static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
3682 {
3683     BDRVRawState *s = bs->opaque;
3684
3685     if (s->fd < 0)
3686         return;
3687
3688     (void) ioctl(s->fd, CDIOCALLOW);
3689
3690     if (eject_flag) {
3691         if (ioctl(s->fd, CDIOCEJECT) < 0)
3692             perror("CDIOCEJECT");
3693     } else {
3694         if (ioctl(s->fd, CDIOCCLOSE) < 0)
3695             perror("CDIOCCLOSE");
3696     }
3697
3698     cdrom_reopen(bs);
3699 }
3700
3701 static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
3702 {
3703     BDRVRawState *s = bs->opaque;
3704
3705     if (s->fd < 0)
3706         return;
3707     if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
3708         /*
3709          * Note: an error can happen if the distribution automatically
3710          * mounts the CD-ROM
3711          */
3712         /* perror("CDROM_LOCKDOOR"); */
3713     }
3714 }
3715
3716 static BlockDriver bdrv_host_cdrom = {
3717     .format_name        = "host_cdrom",
3718     .protocol_name      = "host_cdrom",
3719     .instance_size      = sizeof(BDRVRawState),
3720     .bdrv_needs_filename = true,
3721     .bdrv_probe_device  = cdrom_probe_device,
3722     .bdrv_parse_filename = cdrom_parse_filename,
3723     .bdrv_file_open     = cdrom_open,
3724     .bdrv_close         = raw_close,
3725     .bdrv_reopen_prepare = raw_reopen_prepare,
3726     .bdrv_reopen_commit  = raw_reopen_commit,
3727     .bdrv_reopen_abort   = raw_reopen_abort,
3728     .bdrv_co_create_opts = hdev_co_create_opts,
3729     .create_opts        = &raw_create_opts,
3730     .mutable_opts       = mutable_opts,
3731
3732     .bdrv_co_preadv         = raw_co_preadv,
3733     .bdrv_co_pwritev        = raw_co_pwritev,
3734     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
3735     .bdrv_refresh_limits = raw_refresh_limits,
3736     .bdrv_io_plug = raw_aio_plug,
3737     .bdrv_io_unplug = raw_aio_unplug,
3738     .bdrv_attach_aio_context = raw_aio_attach_aio_context,
3739
3740     .bdrv_co_truncate    = raw_co_truncate,
3741     .bdrv_getlength      = raw_getlength,
3742     .has_variable_length = true,
3743     .bdrv_get_allocated_file_size
3744                         = raw_get_allocated_file_size,
3745
3746     /* removable device support */
3747     .bdrv_is_inserted   = cdrom_is_inserted,
3748     .bdrv_eject         = cdrom_eject,
3749     .bdrv_lock_medium   = cdrom_lock_medium,
3750 };
3751 #endif /* __FreeBSD__ */
3752
3753 static void bdrv_file_init(void)
3754 {
3755     /*
3756      * Register all the drivers.  Note that order is important, the driver
3757      * registered last will get probed first.
3758      */
3759     bdrv_register(&bdrv_file);
3760     bdrv_register(&bdrv_host_device);
3761 #ifdef __linux__
3762     bdrv_register(&bdrv_host_cdrom);
3763 #endif
3764 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
3765     bdrv_register(&bdrv_host_cdrom);
3766 #endif
3767 }
3768
3769 block_init(bdrv_file_init);