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