block/raw-posix.c

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