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