block/file-posix.c

   1 /*
   2  * Block driver for RAW files (posix)
   3  *
   4  * Copyright (c) 2006 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "qapi/error.h"
  27 #include "qemu/cutils.h"
  28 #include "qemu/error-report.h"
  29 #include "block/block-io.h"
  30 #include "block/block_int.h"
  31 #include "qemu/module.h"
  32 #include "qemu/option.h"
  33 #include "qemu/units.h"
  34 #include "qemu/memalign.h"
  35 #include "trace.h"
  36 #include "block/thread-pool.h"
  37 #include "qemu/iov.h"
  38 #include "block/raw-aio.h"
  39 #include "qapi/qmp/qdict.h"
  40 #include "qapi/qmp/qstring.h"
  41
  42 #include "scsi/pr-manager.h"
  43 #include "scsi/constants.h"
  44
  45 #if defined(__APPLE__) && (__MACH__)
  46 #include <sys/ioctl.h>
  47 #if defined(HAVE_HOST_BLOCK_DEVICE)
  48 #include <paths.h>
  49 #include <sys/param.h>
  50 #include <sys/mount.h>
  51 #include <IOKit/IOKitLib.h>
  52 #include <IOKit/IOBSD.h>
  53 #include <IOKit/storage/IOMediaBSDClient.h>
  54 #include <IOKit/storage/IOMedia.h>
  55 #include <IOKit/storage/IOCDMedia.h>
  56 //#include <IOKit/storage/IOCDTypes.h>
  57 #include <IOKit/storage/IODVDMedia.h>
  58 #include <CoreFoundation/CoreFoundation.h>
  59 #endif /* defined(HAVE_HOST_BLOCK_DEVICE) */
  60 #endif
  61
  62 #ifdef __sun__
  63 #define _POSIX_PTHREAD_SEMANTICS 1
  64 #include <sys/dkio.h>
  65 #endif
  66 #ifdef __linux__
  67 #include <sys/ioctl.h>
  68 #include <sys/param.h>
  69 #include <sys/syscall.h>
  70 #include <sys/vfs.h>
  71 #if defined(CONFIG_BLKZONED)
  72 #include <linux/blkzoned.h>
  73 #endif
  74 #include <linux/cdrom.h>
  75 #include <linux/fd.h>
  76 #include <linux/fs.h>
  77 #include <linux/hdreg.h>
  78 #include <linux/magic.h>
  79 #include <scsi/sg.h>
  80 #ifdef __s390__
  81 #include <asm/dasd.h>
  82 #endif
  83 #ifndef FS_NOCOW_FL
  84 #define FS_NOCOW_FL                     0x00800000 /* Do not cow file */
  85 #endif
  86 #endif
  87 #if defined(CONFIG_FALLOCATE_PUNCH_HOLE) || defined(CONFIG_FALLOCATE_ZERO_RANGE)
  88 #include <linux/falloc.h>
  89 #endif
  90 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
  91 #include <sys/disk.h>
  92 #include <sys/cdio.h>
  93 #endif
  94
  95 #ifdef __OpenBSD__
  96 #include <sys/ioctl.h>
  97 #include <sys/disklabel.h>
  98 #include <sys/dkio.h>
  99 #endif
 100
 101 #ifdef __NetBSD__
 102 #include <sys/ioctl.h>
 103 #include <sys/disklabel.h>
 104 #include <sys/dkio.h>
 105 #include <sys/disk.h>
 106 #endif
 107
 108 #ifdef __DragonFly__
 109 #include <sys/ioctl.h>
 110 #include <sys/diskslice.h>
 111 #endif
 112
 113 /* OS X does not have O_DSYNC */
 114 #ifndef O_DSYNC
 115 #ifdef O_SYNC
 116 #define O_DSYNC O_SYNC
 117 #elif defined(O_FSYNC)
 118 #define O_DSYNC O_FSYNC
 119 #endif
 120 #endif
 121
 122 /* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
 123 #ifndef O_DIRECT
 124 #define O_DIRECT O_DSYNC
 125 #endif
 126
 127 #define FTYPE_FILE   0
 128 #define FTYPE_CD     1
 129
 130 #define MAX_BLOCKSIZE   4096
 131
 132 /* Posix file locking bytes. Libvirt takes byte 0, we start from higher bytes,
 133  * leaving a few more bytes for its future use. */
 134 #define RAW_LOCK_PERM_BASE             100
 135 #define RAW_LOCK_SHARED_BASE           200
 136
 137 typedef struct BDRVRawState {
 138     int fd;
 139     bool use_lock;
 140     int type;
 141     int open_flags;
 142     size_t buf_align;
 143
 144     /* The current permissions. */
 145     uint64_t perm;
 146     uint64_t shared_perm;
 147
 148     /* The perms bits whose corresponding bytes are already locked in
 149      * s->fd. */
 150     uint64_t locked_perm;
 151     uint64_t locked_shared_perm;
 152
 153     uint64_t aio_max_batch;
 154
 155     int perm_change_fd;
 156     int perm_change_flags;
 157     BDRVReopenState *reopen_state;
 158
 159     bool has_discard:1;
 160     bool has_write_zeroes:1;
 161     bool use_linux_aio:1;
 162     bool use_linux_io_uring:1;
 163     int page_cache_inconsistent; /* errno from fdatasync failure */
 164     bool has_fallocate;
 165     bool needs_alignment;
 166     bool force_alignment;
 167     bool drop_cache;
 168     bool check_cache_dropped;
 169     struct {
 170         uint64_t discard_nb_ok;
 171         uint64_t discard_nb_failed;
 172         uint64_t discard_bytes_ok;
 173     } stats;
 174
 175     PRManager *pr_mgr;
 176 } BDRVRawState;
 177
 178 typedef struct BDRVRawReopenState {
 179     int open_flags;
 180     bool drop_cache;
 181     bool check_cache_dropped;
 182 } BDRVRawReopenState;
 183
 184 static int fd_open(BlockDriverState *bs)
 185 {
 186     BDRVRawState *s = bs->opaque;
 187
 188     /* this is just to ensure s->fd is sane (its called by io ops) */
 189     if (s->fd >= 0) {
 190         return 0;
 191     }
 192     return -EIO;
 193 }
 194
 195 static int64_t raw_getlength(BlockDriverState *bs);
 196
 197 typedef struct RawPosixAIOData {
 198     BlockDriverState *bs;
 199     int aio_type;
 200     int aio_fildes;
 201
 202     off_t aio_offset;
 203     uint64_t aio_nbytes;
 204
 205     union {
 206         struct {
 207             struct iovec *iov;
 208             int niov;
 209         } io;
 210         struct {
 211             uint64_t cmd;
 212             void *buf;
 213         } ioctl;
 214         struct {
 215             int aio_fd2;
 216             off_t aio_offset2;
 217         } copy_range;
 218         struct {
 219             PreallocMode prealloc;
 220             Error **errp;
 221         } truncate;
 222         struct {
 223             unsigned int *nr_zones;
 224             BlockZoneDescriptor *zones;
 225         } zone_report;
 226         struct {
 227             unsigned long op;
 228         } zone_mgmt;
 229     };
 230 } RawPosixAIOData;
 231
 232 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 233 static int cdrom_reopen(BlockDriverState *bs);
 234 #endif
 235
 236 /*
 237  * Elide EAGAIN and EACCES details when failing to lock, as this
 238  * indicates that the specified file region is already locked by
 239  * another process, which is considered a common scenario.
 240  */
 241 #define raw_lock_error_setg_errno(errp, err, fmt, ...)                  \
 242     do {                                                                \
 243         if ((err) == EAGAIN || (err) == EACCES) {                       \
 244             error_setg((errp), (fmt), ## __VA_ARGS__);                  \
 245         } else {                                                        \
 246             error_setg_errno((errp), (err), (fmt), ## __VA_ARGS__);     \
 247         }                                                               \
 248     } while (0)
 249
 250 #if defined(__NetBSD__)
 251 static int raw_normalize_devicepath(const char **filename, Error **errp)
 252 {
 253     static char namebuf[PATH_MAX];
 254     const char *dp, *fname;
 255     struct stat sb;
 256
 257     fname = *filename;
 258     dp = strrchr(fname, '/');
 259     if (lstat(fname, &sb) < 0) {
 260         error_setg_file_open(errp, errno, fname);
 261         return -errno;
 262     }
 263
 264     if (!S_ISBLK(sb.st_mode)) {
 265         return 0;
 266     }
 267
 268     if (dp == NULL) {
 269         snprintf(namebuf, PATH_MAX, "r%s", fname);
 270     } else {
 271         snprintf(namebuf, PATH_MAX, "%.*s/r%s",
 272             (int)(dp - fname), fname, dp + 1);
 273     }
 274     *filename = namebuf;
 275     warn_report("%s is a block device, using %s", fname, *filename);
 276
 277     return 0;
 278 }
 279 #else
 280 static int raw_normalize_devicepath(const char **filename, Error **errp)
 281 {
 282     return 0;
 283 }
 284 #endif
 285
 286 /*
 287  * Get logical block size via ioctl. On success store it in @sector_size_p.
 288  */
 289 static int probe_logical_blocksize(int fd, unsigned int *sector_size_p)
 290 {
 291     unsigned int sector_size;
 292     bool success = false;
 293     int i;
 294
 295     errno = ENOTSUP;
 296     static const unsigned long ioctl_list[] = {
 297 #ifdef BLKSSZGET
 298         BLKSSZGET,
 299 #endif
 300 #ifdef DKIOCGETBLOCKSIZE
 301         DKIOCGETBLOCKSIZE,
 302 #endif
 303 #ifdef DIOCGSECTORSIZE
 304         DIOCGSECTORSIZE,
 305 #endif
 306     };
 307
 308     /* Try a few ioctls to get the right size */
 309     for (i = 0; i < (int)ARRAY_SIZE(ioctl_list); i++) {
 310         if (ioctl(fd, ioctl_list[i], &sector_size) >= 0) {
 311             *sector_size_p = sector_size;
 312             success = true;
 313         }
 314     }
 315
 316     return success ? 0 : -errno;
 317 }
 318
 319 /**
 320  * Get physical block size of @fd.
 321  * On success, store it in @blk_size and return 0.
 322  * On failure, return -errno.
 323  */
 324 static int probe_physical_blocksize(int fd, unsigned int *blk_size)
 325 {
 326 #ifdef BLKPBSZGET
 327     if (ioctl(fd, BLKPBSZGET, blk_size) < 0) {
 328         return -errno;
 329     }
 330     return 0;
 331 #else
 332     return -ENOTSUP;
 333 #endif
 334 }
 335
 336 /*
 337  * Returns true if no alignment restrictions are necessary even for files
 338  * opened with O_DIRECT.
 339  *
 340  * raw_probe_alignment() probes the required alignment and assume that 1 means
 341  * the probing failed, so it falls back to a safe default of 4k. This can be
 342  * avoided if we know that byte alignment is okay for the file.
 343  */
 344 static bool dio_byte_aligned(int fd)
 345 {
 346 #ifdef __linux__
 347     struct statfs buf;
 348     int ret;
 349
 350     ret = fstatfs(fd, &buf);
 351     if (ret == 0 && buf.f_type == NFS_SUPER_MAGIC) {
 352         return true;
 353     }
 354 #endif
 355     return false;
 356 }
 357
 358 static bool raw_needs_alignment(BlockDriverState *bs)
 359 {
 360     BDRVRawState *s = bs->opaque;
 361
 362     if ((bs->open_flags & BDRV_O_NOCACHE) != 0 && !dio_byte_aligned(s->fd)) {
 363         return true;
 364     }
 365
 366     return s->force_alignment;
 367 }
 368
 369 /* Check if read is allowed with given memory buffer and length.
 370  *
 371  * This function is used to check O_DIRECT memory buffer and request alignment.
 372  */
 373 static bool raw_is_io_aligned(int fd, void *buf, size_t len)
 374 {
 375     ssize_t ret = pread(fd, buf, len, 0);
 376
 377     if (ret >= 0) {
 378         return true;
 379     }
 380
 381 #ifdef __linux__
 382     /* The Linux kernel returns EINVAL for misaligned O_DIRECT reads.  Ignore
 383      * other errors (e.g. real I/O error), which could happen on a failed
 384      * drive, since we only care about probing alignment.
 385      */
 386     if (errno != EINVAL) {
 387         return true;
 388     }
 389 #endif
 390
 391     return false;
 392 }
 393
 394 static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
 395 {
 396     BDRVRawState *s = bs->opaque;
 397     char *buf;
 398     size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size());
 399     size_t alignments[] = {1, 512, 1024, 2048, 4096};
 400
 401     /* For SCSI generic devices the alignment is not really used.
 402        With buffered I/O, we don't have any restrictions. */
 403     if (bdrv_is_sg(bs) || !s->needs_alignment) {
 404         bs->bl.request_alignment = 1;
 405         s->buf_align = 1;
 406         return;
 407     }
 408
 409     bs->bl.request_alignment = 0;
 410     s->buf_align = 0;
 411     /* Let's try to use the logical blocksize for the alignment. */
 412     if (probe_logical_blocksize(fd, &bs->bl.request_alignment) < 0) {
 413         bs->bl.request_alignment = 0;
 414     }
 415
 416 #ifdef __linux__
 417     /*
 418      * The XFS ioctl definitions are shipped in extra packages that might
 419      * not always be available. Since we just need the XFS_IOC_DIOINFO ioctl
 420      * here, we simply use our own definition instead:
 421      */
 422     struct xfs_dioattr {
 423         uint32_t d_mem;
 424         uint32_t d_miniosz;
 425         uint32_t d_maxiosz;
 426     } da;
 427     if (ioctl(fd, _IOR('X', 30, struct xfs_dioattr), &da) >= 0) {
 428         bs->bl.request_alignment = da.d_miniosz;
 429         /* The kernel returns wrong information for d_mem */
 430         /* s->buf_align = da.d_mem; */
 431     }
 432 #endif
 433
 434     /*
 435      * If we could not get the sizes so far, we can only guess them. First try
 436      * to detect request alignment, since it is more likely to succeed. Then
 437      * try to detect buf_align, which cannot be detected in some cases (e.g.
 438      * Gluster). If buf_align cannot be detected, we fallback to the value of
 439      * request_alignment.
 440      */
 441
 442     if (!bs->bl.request_alignment) {
 443         int i;
 444         size_t align;
 445         buf = qemu_memalign(max_align, max_align);
 446         for (i = 0; i < ARRAY_SIZE(alignments); i++) {
 447             align = alignments[i];
 448             if (raw_is_io_aligned(fd, buf, align)) {
 449                 /* Fallback to safe value. */
 450                 bs->bl.request_alignment = (align != 1) ? align : max_align;
 451                 break;
 452             }
 453         }
 454         qemu_vfree(buf);
 455     }
 456
 457     if (!s->buf_align) {
 458         int i;
 459         size_t align;
 460         buf = qemu_memalign(max_align, 2 * max_align);
 461         for (i = 0; i < ARRAY_SIZE(alignments); i++) {
 462             align = alignments[i];
 463             if (raw_is_io_aligned(fd, buf + align, max_align)) {
 464                 /* Fallback to request_alignment. */
 465                 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
 466                 break;
 467             }
 468         }
 469         qemu_vfree(buf);
 470     }
 471
 472     if (!s->buf_align || !bs->bl.request_alignment) {
 473         error_setg(errp, "Could not find working O_DIRECT alignment");
 474         error_append_hint(errp, "Try cache.direct=off\n");
 475     }
 476 }
 477
 478 static int check_hdev_writable(int fd)
 479 {
 480 #if defined(BLKROGET)
 481     /* Linux block devices can be configured "read-only" using blockdev(8).
 482      * This is independent of device node permissions and therefore open(2)
 483      * with O_RDWR succeeds.  Actual writes fail with EPERM.
 484      *
 485      * bdrv_open() is supposed to fail if the disk is read-only.  Explicitly
 486      * check for read-only block devices so that Linux block devices behave
 487      * properly.
 488      */
 489     struct stat st;
 490     int readonly = 0;
 491
 492     if (fstat(fd, &st)) {
 493         return -errno;
 494     }
 495
 496     if (!S_ISBLK(st.st_mode)) {
 497         return 0;
 498     }
 499
 500     if (ioctl(fd, BLKROGET, &readonly) < 0) {
 501         return -errno;
 502     }
 503
 504     if (readonly) {
 505         return -EACCES;
 506     }
 507 #endif /* defined(BLKROGET) */
 508     return 0;
 509 }
 510
 511 static void raw_parse_flags(int bdrv_flags, int *open_flags, bool has_writers)
 512 {
 513     bool read_write = false;
 514     assert(open_flags != NULL);
 515
 516     *open_flags |= O_BINARY;
 517     *open_flags &= ~O_ACCMODE;
 518
 519     if (bdrv_flags & BDRV_O_AUTO_RDONLY) {
 520         read_write = has_writers;
 521     } else if (bdrv_flags & BDRV_O_RDWR) {
 522         read_write = true;
 523     }
 524
 525     if (read_write) {
 526         *open_flags |= O_RDWR;
 527     } else {
 528         *open_flags |= O_RDONLY;
 529     }
 530
 531     /* Use O_DSYNC for write-through caching, no flags for write-back caching,
 532      * and O_DIRECT for no caching. */
 533     if ((bdrv_flags & BDRV_O_NOCACHE)) {
 534         *open_flags |= O_DIRECT;
 535     }
 536 }
 537
 538 static void raw_parse_filename(const char *filename, QDict *options,
 539                                Error **errp)
 540 {
 541     bdrv_parse_filename_strip_prefix(filename, "file:", options);
 542 }
 543
 544 static QemuOptsList raw_runtime_opts = {
 545     .name = "raw",
 546     .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
 547     .desc = {
 548         {
 549             .name = "filename",
 550             .type = QEMU_OPT_STRING,
 551             .help = "File name of the image",
 552         },
 553         {
 554             .name = "aio",
 555             .type = QEMU_OPT_STRING,
 556             .help = "host AIO implementation (threads, native, io_uring)",
 557         },
 558         {
 559             .name = "aio-max-batch",
 560             .type = QEMU_OPT_NUMBER,
 561             .help = "AIO max batch size (0 = auto handled by AIO backend, default: 0)",
 562         },
 563         {
 564             .name = "locking",
 565             .type = QEMU_OPT_STRING,
 566             .help = "file locking mode (on/off/auto, default: auto)",
 567         },
 568         {
 569             .name = "pr-manager",
 570             .type = QEMU_OPT_STRING,
 571             .help = "id of persistent reservation manager object (default: none)",
 572         },
 573 #if defined(__linux__)
 574         {
 575             .name = "drop-cache",
 576             .type = QEMU_OPT_BOOL,
 577             .help = "invalidate page cache during live migration (default: on)",
 578         },
 579 #endif
 580         {
 581             .name = "x-check-cache-dropped",
 582             .type = QEMU_OPT_BOOL,
 583             .help = "check that page cache was dropped on live migration (default: off)"
 584         },
 585         { /* end of list */ }
 586     },
 587 };
 588
 589 static const char *const mutable_opts[] = { "x-check-cache-dropped", NULL };
 590
 591 static int raw_open_common(BlockDriverState *bs, QDict *options,
 592                            int bdrv_flags, int open_flags,
 593                            bool device, Error **errp)
 594 {
 595     BDRVRawState *s = bs->opaque;
 596     QemuOpts *opts;
 597     Error *local_err = NULL;
 598     const char *filename = NULL;
 599     const char *str;
 600     BlockdevAioOptions aio, aio_default;
 601     int fd, ret;
 602     struct stat st;
 603     OnOffAuto locking;
 604
 605     opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
 606     if (!qemu_opts_absorb_qdict(opts, options, errp)) {
 607         ret = -EINVAL;
 608         goto fail;
 609     }
 610
 611     filename = qemu_opt_get(opts, "filename");
 612
 613     ret = raw_normalize_devicepath(&filename, errp);
 614     if (ret != 0) {
 615         goto fail;
 616     }
 617
 618     if (bdrv_flags & BDRV_O_NATIVE_AIO) {
 619         aio_default = BLOCKDEV_AIO_OPTIONS_NATIVE;
 620 #ifdef CONFIG_LINUX_IO_URING
 621     } else if (bdrv_flags & BDRV_O_IO_URING) {
 622         aio_default = BLOCKDEV_AIO_OPTIONS_IO_URING;
 623 #endif
 624     } else {
 625         aio_default = BLOCKDEV_AIO_OPTIONS_THREADS;
 626     }
 627
 628     aio = qapi_enum_parse(&BlockdevAioOptions_lookup,
 629                           qemu_opt_get(opts, "aio"),
 630                           aio_default, &local_err);
 631     if (local_err) {
 632         error_propagate(errp, local_err);
 633         ret = -EINVAL;
 634         goto fail;
 635     }
 636
 637     s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
 638 #ifdef CONFIG_LINUX_IO_URING
 639     s->use_linux_io_uring = (aio == BLOCKDEV_AIO_OPTIONS_IO_URING);
 640 #endif
 641
 642     s->aio_max_batch = qemu_opt_get_number(opts, "aio-max-batch", 0);
 643
 644     locking = qapi_enum_parse(&OnOffAuto_lookup,
 645                               qemu_opt_get(opts, "locking"),
 646                               ON_OFF_AUTO_AUTO, &local_err);
 647     if (local_err) {
 648         error_propagate(errp, local_err);
 649         ret = -EINVAL;
 650         goto fail;
 651     }
 652     switch (locking) {
 653     case ON_OFF_AUTO_ON:
 654         s->use_lock = true;
 655         if (!qemu_has_ofd_lock()) {
 656             warn_report("File lock requested but OFD locking syscall is "
 657                         "unavailable, falling back to POSIX file locks");
 658             error_printf("Due to the implementation, locks can be lost "
 659                          "unexpectedly.\n");
 660         }
 661         break;
 662     case ON_OFF_AUTO_OFF:
 663         s->use_lock = false;
 664         break;
 665     case ON_OFF_AUTO_AUTO:
 666         s->use_lock = qemu_has_ofd_lock();
 667         break;
 668     default:
 669         abort();
 670     }
 671
 672     str = qemu_opt_get(opts, "pr-manager");
 673     if (str) {
 674         s->pr_mgr = pr_manager_lookup(str, &local_err);
 675         if (local_err) {
 676             error_propagate(errp, local_err);
 677             ret = -EINVAL;
 678             goto fail;
 679         }
 680     }
 681
 682     s->drop_cache = qemu_opt_get_bool(opts, "drop-cache", true);
 683     s->check_cache_dropped = qemu_opt_get_bool(opts, "x-check-cache-dropped",
 684                                                false);
 685
 686     s->open_flags = open_flags;
 687     raw_parse_flags(bdrv_flags, &s->open_flags, false);
 688
 689     s->fd = -1;
 690     fd = qemu_open(filename, s->open_flags, errp);
 691     ret = fd < 0 ? -errno : 0;
 692
 693     if (ret < 0) {
 694         if (ret == -EROFS) {
 695             ret = -EACCES;
 696         }
 697         goto fail;
 698     }
 699     s->fd = fd;
 700
 701     /* Check s->open_flags rather than bdrv_flags due to auto-read-only */
 702     if (s->open_flags & O_RDWR) {
 703         ret = check_hdev_writable(s->fd);
 704         if (ret < 0) {
 705             error_setg_errno(errp, -ret, "The device is not writable");
 706             goto fail;
 707         }
 708     }
 709
 710     s->perm = 0;
 711     s->shared_perm = BLK_PERM_ALL;
 712
 713 #ifdef CONFIG_LINUX_AIO
 714      /* Currently Linux does AIO only for files opened with O_DIRECT */
 715     if (s->use_linux_aio && !(s->open_flags & O_DIRECT)) {
 716         error_setg(errp, "aio=native was specified, but it requires "
 717                          "cache.direct=on, which was not specified.");
 718         ret = -EINVAL;
 719         goto fail;
 720     }
 721 #else
 722     if (s->use_linux_aio) {
 723         error_setg(errp, "aio=native was specified, but is not supported "
 724                          "in this build.");
 725         ret = -EINVAL;
 726         goto fail;
 727     }
 728 #endif /* !defined(CONFIG_LINUX_AIO) */
 729
 730 #ifndef CONFIG_LINUX_IO_URING
 731     if (s->use_linux_io_uring) {
 732         error_setg(errp, "aio=io_uring was specified, but is not supported "
 733                          "in this build.");
 734         ret = -EINVAL;
 735         goto fail;
 736     }
 737 #endif /* !defined(CONFIG_LINUX_IO_URING) */
 738
 739     s->has_discard = true;
 740     s->has_write_zeroes = true;
 741
 742     if (fstat(s->fd, &st) < 0) {
 743         ret = -errno;
 744         error_setg_errno(errp, errno, "Could not stat file");
 745         goto fail;
 746     }
 747
 748     if (!device) {
 749         if (!S_ISREG(st.st_mode)) {
 750             error_setg(errp, "'%s' driver requires '%s' to be a regular file",
 751                        bs->drv->format_name, bs->filename);
 752             ret = -EINVAL;
 753             goto fail;
 754         } else {
 755             s->has_fallocate = true;
 756         }
 757     } else {
 758         if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
 759             error_setg(errp, "'%s' driver requires '%s' to be either "
 760                        "a character or block device",
 761                        bs->drv->format_name, bs->filename);
 762             ret = -EINVAL;
 763             goto fail;
 764         }
 765     }
 766 #ifdef CONFIG_BLKZONED
 767     /*
 768      * The kernel page cache does not reliably work for writes to SWR zones
 769      * of zoned block device because it can not guarantee the order of writes.
 770      */
 771     if ((bs->bl.zoned != BLK_Z_NONE) &&
 772         (!(s->open_flags & O_DIRECT))) {
 773         error_setg(errp, "The driver supports zoned devices, and it requires "
 774                          "cache.direct=on, which was not specified.");
 775         return -EINVAL; /* No host kernel page cache */
 776     }
 777 #endif
 778
 779     if (S_ISBLK(st.st_mode)) {
 780 #ifdef __linux__
 781         /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache.  Do
 782          * not rely on the contents of discarded blocks unless using O_DIRECT.
 783          * Same for BLKZEROOUT.
 784          */
 785         if (!(bs->open_flags & BDRV_O_NOCACHE)) {
 786             s->has_write_zeroes = false;
 787         }
 788 #endif
 789     }
 790 #ifdef __FreeBSD__
 791     if (S_ISCHR(st.st_mode)) {
 792         /*
 793          * The file is a char device (disk), which on FreeBSD isn't behind
 794          * a pager, so force all requests to be aligned. This is needed
 795          * so QEMU makes sure all IO operations on the device are aligned
 796          * to sector size, or else FreeBSD will reject them with EINVAL.
 797          */
 798         s->force_alignment = true;
 799     }
 800 #endif
 801     s->needs_alignment = raw_needs_alignment(bs);
 802
 803     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
 804     if (S_ISREG(st.st_mode)) {
 805         /* When extending regular files, we get zeros from the OS */
 806         bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
 807     }
 808     ret = 0;
 809 fail:
 810     if (ret < 0 && s->fd != -1) {
 811         qemu_close(s->fd);
 812     }
 813     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
 814         unlink(filename);
 815     }
 816     qemu_opts_del(opts);
 817     return ret;
 818 }
 819
 820 static int raw_open(BlockDriverState *bs, QDict *options, int flags,
 821                     Error **errp)
 822 {
 823     BDRVRawState *s = bs->opaque;
 824
 825     s->type = FTYPE_FILE;
 826     return raw_open_common(bs, options, flags, 0, false, errp);
 827 }
 828
 829 typedef enum {
 830     RAW_PL_PREPARE,
 831     RAW_PL_COMMIT,
 832     RAW_PL_ABORT,
 833 } RawPermLockOp;
 834
 835 #define PERM_FOREACH(i) \
 836     for ((i) = 0; (1ULL << (i)) <= BLK_PERM_ALL; i++)
 837
 838 /* Lock bytes indicated by @perm_lock_bits and @shared_perm_lock_bits in the
 839  * file; if @unlock == true, also unlock the unneeded bytes.
 840  * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
 841  */
 842 static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
 843                                 uint64_t perm_lock_bits,
 844                                 uint64_t shared_perm_lock_bits,
 845                                 bool unlock, Error **errp)
 846 {
 847     int ret;
 848     int i;
 849     uint64_t locked_perm, locked_shared_perm;
 850
 851     if (s) {
 852         locked_perm = s->locked_perm;
 853         locked_shared_perm = s->locked_shared_perm;
 854     } else {
 855         /*
 856          * We don't have the previous bits, just lock/unlock for each of the
 857          * requested bits.
 858          */
 859         if (unlock) {
 860             locked_perm = BLK_PERM_ALL;
 861             locked_shared_perm = BLK_PERM_ALL;
 862         } else {
 863             locked_perm = 0;
 864             locked_shared_perm = 0;
 865         }
 866     }
 867
 868     PERM_FOREACH(i) {
 869         int off = RAW_LOCK_PERM_BASE + i;
 870         uint64_t bit = (1ULL << i);
 871         if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
 872             ret = qemu_lock_fd(fd, off, 1, false);
 873             if (ret) {
 874                 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d",
 875                                           off);
 876                 return ret;
 877             } else if (s) {
 878                 s->locked_perm |= bit;
 879             }
 880         } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
 881             ret = qemu_unlock_fd(fd, off, 1);
 882             if (ret) {
 883                 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off);
 884                 return ret;
 885             } else if (s) {
 886                 s->locked_perm &= ~bit;
 887             }
 888         }
 889     }
 890     PERM_FOREACH(i) {
 891         int off = RAW_LOCK_SHARED_BASE + i;
 892         uint64_t bit = (1ULL << i);
 893         if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
 894             ret = qemu_lock_fd(fd, off, 1, false);
 895             if (ret) {
 896                 raw_lock_error_setg_errno(errp, -ret, "Failed to lock byte %d",
 897                                           off);
 898                 return ret;
 899             } else if (s) {
 900                 s->locked_shared_perm |= bit;
 901             }
 902         } else if (unlock && (locked_shared_perm & bit) &&
 903                    !(shared_perm_lock_bits & bit)) {
 904             ret = qemu_unlock_fd(fd, off, 1);
 905             if (ret) {
 906                 error_setg_errno(errp, -ret, "Failed to unlock byte %d", off);
 907                 return ret;
 908             } else if (s) {
 909                 s->locked_shared_perm &= ~bit;
 910             }
 911         }
 912     }
 913     return 0;
 914 }
 915
 916 /* Check "unshared" bytes implied by @perm and ~@shared_perm in the file. */
 917 static int raw_check_lock_bytes(int fd, uint64_t perm, uint64_t shared_perm,
 918                                 Error **errp)
 919 {
 920     int ret;
 921     int i;
 922
 923     PERM_FOREACH(i) {
 924         int off = RAW_LOCK_SHARED_BASE + i;
 925         uint64_t p = 1ULL << i;
 926         if (perm & p) {
 927             ret = qemu_lock_fd_test(fd, off, 1, true);
 928             if (ret) {
 929                 char *perm_name = bdrv_perm_names(p);
 930
 931                 raw_lock_error_setg_errno(errp, -ret,
 932                                           "Failed to get \"%s\" lock",
 933                                           perm_name);
 934                 g_free(perm_name);
 935                 return ret;
 936             }
 937         }
 938     }
 939     PERM_FOREACH(i) {
 940         int off = RAW_LOCK_PERM_BASE + i;
 941         uint64_t p = 1ULL << i;
 942         if (!(shared_perm & p)) {
 943             ret = qemu_lock_fd_test(fd, off, 1, true);
 944             if (ret) {
 945                 char *perm_name = bdrv_perm_names(p);
 946
 947                 raw_lock_error_setg_errno(errp, -ret,
 948                                           "Failed to get shared \"%s\" lock",
 949                                           perm_name);
 950                 g_free(perm_name);
 951                 return ret;
 952             }
 953         }
 954     }
 955     return 0;
 956 }
 957
 958 static int raw_handle_perm_lock(BlockDriverState *bs,
 959                                 RawPermLockOp op,
 960                                 uint64_t new_perm, uint64_t new_shared,
 961                                 Error **errp)
 962 {
 963     BDRVRawState *s = bs->opaque;
 964     int ret = 0;
 965     Error *local_err = NULL;
 966
 967     if (!s->use_lock) {
 968         return 0;
 969     }
 970
 971     if (bdrv_get_flags(bs) & BDRV_O_INACTIVE) {
 972         return 0;
 973     }
 974
 975     switch (op) {
 976     case RAW_PL_PREPARE:
 977         if ((s->perm | new_perm) == s->perm &&
 978             (s->shared_perm & new_shared) == s->shared_perm)
 979         {
 980             /*
 981              * We are going to unlock bytes, it should not fail. If it fail due
 982              * to some fs-dependent permission-unrelated reasons (which occurs
 983              * sometimes on NFS and leads to abort in bdrv_replace_child) we
 984              * can't prevent such errors by any check here. And we ignore them
 985              * anyway in ABORT and COMMIT.
 986              */
 987             return 0;
 988         }
 989         ret = raw_apply_lock_bytes(s, s->fd, s->perm | new_perm,
 990                                    ~s->shared_perm | ~new_shared,
 991                                    false, errp);
 992         if (!ret) {
 993             ret = raw_check_lock_bytes(s->fd, new_perm, new_shared, errp);
 994             if (!ret) {
 995                 return 0;
 996             }
 997             error_append_hint(errp,
 998                               "Is another process using the image [%s]?\n",
 999                               bs->filename);
1000         }
1001         /* fall through to unlock bytes. */
1002     case RAW_PL_ABORT:
1003         raw_apply_lock_bytes(s, s->fd, s->perm, ~s->shared_perm,
1004                              true, &local_err);
1005         if (local_err) {
1006             /* Theoretically the above call only unlocks bytes and it cannot
1007              * fail. Something weird happened, report it.
1008              */
1009             warn_report_err(local_err);
1010         }
1011         break;
1012     case RAW_PL_COMMIT:
1013         raw_apply_lock_bytes(s, s->fd, new_perm, ~new_shared,
1014                              true, &local_err);
1015         if (local_err) {
1016             /* Theoretically the above call only unlocks bytes and it cannot
1017              * fail. Something weird happened, report it.
1018              */
1019             warn_report_err(local_err);
1020         }
1021         break;
1022     }
1023     return ret;
1024 }
1025
1026 /* Sets a specific flag */
1027 static int fcntl_setfl(int fd, int flag)
1028 {
1029     int flags;
1030
1031     flags = fcntl(fd, F_GETFL);
1032     if (flags == -1) {
1033         return -errno;
1034     }
1035     if (fcntl(fd, F_SETFL, flags | flag) == -1) {
1036         return -errno;
1037     }
1038     return 0;
1039 }
1040
1041 static int raw_reconfigure_getfd(BlockDriverState *bs, int flags,
1042                                  int *open_flags, uint64_t perm, bool force_dup,
1043                                  Error **errp)
1044 {
1045     BDRVRawState *s = bs->opaque;
1046     int fd = -1;
1047     int ret;
1048     bool has_writers = perm &
1049         (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_RESIZE);
1050     int fcntl_flags = O_APPEND | O_NONBLOCK;
1051 #ifdef O_NOATIME
1052     fcntl_flags |= O_NOATIME;
1053 #endif
1054
1055     *open_flags = 0;
1056     if (s->type == FTYPE_CD) {
1057         *open_flags |= O_NONBLOCK;
1058     }
1059
1060     raw_parse_flags(flags, open_flags, has_writers);
1061
1062 #ifdef O_ASYNC
1063     /* Not all operating systems have O_ASYNC, and those that don't
1064      * will not let us track the state into rs->open_flags (typically
1065      * you achieve the same effect with an ioctl, for example I_SETSIG
1066      * on Solaris). But we do not use O_ASYNC, so that's fine.
1067      */
1068     assert((s->open_flags & O_ASYNC) == 0);
1069 #endif
1070
1071     if (!force_dup && *open_flags == s->open_flags) {
1072         /* We're lucky, the existing fd is fine */
1073         return s->fd;
1074     }
1075
1076     if ((*open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
1077         /* dup the original fd */
1078         fd = qemu_dup(s->fd);
1079         if (fd >= 0) {
1080             ret = fcntl_setfl(fd, *open_flags);
1081             if (ret) {
1082                 qemu_close(fd);
1083                 fd = -1;
1084             }
1085         }
1086     }
1087
1088     /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
1089     if (fd == -1) {
1090         const char *normalized_filename = bs->filename;
1091         ret = raw_normalize_devicepath(&normalized_filename, errp);
1092         if (ret >= 0) {
1093             fd = qemu_open(normalized_filename, *open_flags, errp);
1094             if (fd == -1) {
1095                 return -1;
1096             }
1097         }
1098     }
1099
1100     if (fd != -1 && (*open_flags & O_RDWR)) {
1101         ret = check_hdev_writable(fd);
1102         if (ret < 0) {
1103             qemu_close(fd);
1104             error_setg_errno(errp, -ret, "The device is not writable");
1105             return -1;
1106         }
1107     }
1108
1109     return fd;
1110 }
1111
1112 static int raw_reopen_prepare(BDRVReopenState *state,
1113                               BlockReopenQueue *queue, Error **errp)
1114 {
1115     BDRVRawState *s;
1116     BDRVRawReopenState *rs;
1117     QemuOpts *opts;
1118     int ret;
1119
1120     assert(state != NULL);
1121     assert(state->bs != NULL);
1122
1123     s = state->bs->opaque;
1124
1125     state->opaque = g_new0(BDRVRawReopenState, 1);
1126     rs = state->opaque;
1127
1128     /* Handle options changes */
1129     opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
1130     if (!qemu_opts_absorb_qdict(opts, state->options, errp)) {
1131         ret = -EINVAL;
1132         goto out;
1133     }
1134
1135     rs->drop_cache = qemu_opt_get_bool_del(opts, "drop-cache", true);
1136     rs->check_cache_dropped =
1137         qemu_opt_get_bool_del(opts, "x-check-cache-dropped", false);
1138
1139     /* This driver's reopen function doesn't currently allow changing
1140      * other options, so let's put them back in the original QDict and
1141      * bdrv_reopen_prepare() will detect changes and complain. */
1142     qemu_opts_to_qdict(opts, state->options);
1143
1144     /*
1145      * As part of reopen prepare we also want to create new fd by
1146      * raw_reconfigure_getfd(). But it wants updated "perm", when in
1147      * bdrv_reopen_multiple() .bdrv_reopen_prepare() callback called prior to
1148      * permission update. Happily, permission update is always a part
1149      * (a separate stage) of bdrv_reopen_multiple() so we can rely on this
1150      * fact and reconfigure fd in raw_check_perm().
1151      */
1152
1153     s->reopen_state = state;
1154     ret = 0;
1155
1156 out:
1157     qemu_opts_del(opts);
1158     return ret;
1159 }
1160
1161 static void raw_reopen_commit(BDRVReopenState *state)
1162 {
1163     BDRVRawReopenState *rs = state->opaque;
1164     BDRVRawState *s = state->bs->opaque;
1165
1166     s->drop_cache = rs->drop_cache;
1167     s->check_cache_dropped = rs->check_cache_dropped;
1168     s->open_flags = rs->open_flags;
1169     g_free(state->opaque);
1170     state->opaque = NULL;
1171
1172     assert(s->reopen_state == state);
1173     s->reopen_state = NULL;
1174 }
1175
1176
1177 static void raw_reopen_abort(BDRVReopenState *state)
1178 {
1179     BDRVRawReopenState *rs = state->opaque;
1180     BDRVRawState *s = state->bs->opaque;
1181
1182      /* nothing to do if NULL, we didn't get far enough */
1183     if (rs == NULL) {
1184         return;
1185     }
1186
1187     g_free(state->opaque);
1188     state->opaque = NULL;
1189
1190     assert(s->reopen_state == state);
1191     s->reopen_state = NULL;
1192 }
1193
1194 static int hdev_get_max_hw_transfer(int fd, struct stat *st)
1195 {
1196 #ifdef BLKSECTGET
1197     if (S_ISBLK(st->st_mode)) {
1198         unsigned short max_sectors = 0;
1199         if (ioctl(fd, BLKSECTGET, &max_sectors) == 0) {
1200             return max_sectors * 512;
1201         }
1202     } else {
1203         int max_bytes = 0;
1204         if (ioctl(fd, BLKSECTGET, &max_bytes) == 0) {
1205             return max_bytes;
1206         }
1207     }
1208     return -errno;
1209 #else
1210     return -ENOSYS;
1211 #endif
1212 }
1213
1214 /*
1215  * Get a sysfs attribute value as character string.
1216  */
1217 #ifdef CONFIG_LINUX
1218 static int get_sysfs_str_val(struct stat *st, const char *attribute,
1219                              char **val) {
1220     g_autofree char *sysfspath = NULL;
1221     size_t len;
1222
1223     if (!S_ISBLK(st->st_mode)) {
1224         return -ENOTSUP;
1225     }
1226
1227     sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/%s",
1228                                 major(st->st_rdev), minor(st->st_rdev),
1229                                 attribute);
1230     if (!g_file_get_contents(sysfspath, val, &len, NULL)) {
1231         return -ENOENT;
1232     }
1233
1234     /* The file is ended with '\n' */
1235     char *p;
1236     p = *val;
1237     if (*(p + len - 1) == '\n') {
1238         *(p + len - 1) = '\0';
1239     }
1240     return 0;
1241 }
1242 #endif
1243
1244 #if defined(CONFIG_BLKZONED)
1245 static int get_sysfs_zoned_model(struct stat *st, BlockZoneModel *zoned)
1246 {
1247     g_autofree char *val = NULL;
1248     int ret;
1249
1250     ret = get_sysfs_str_val(st, "zoned", &val);
1251     if (ret < 0) {
1252         return ret;
1253     }
1254
1255     if (strcmp(val, "host-managed") == 0) {
1256         *zoned = BLK_Z_HM;
1257     } else if (strcmp(val, "host-aware") == 0) {
1258         *zoned = BLK_Z_HA;
1259     } else if (strcmp(val, "none") == 0) {
1260         *zoned = BLK_Z_NONE;
1261     } else {
1262         return -ENOTSUP;
1263     }
1264     return 0;
1265 }
1266 #endif /* defined(CONFIG_BLKZONED) */
1267
1268 /*
1269  * Get a sysfs attribute value as a long integer.
1270  */
1271 #ifdef CONFIG_LINUX
1272 static long get_sysfs_long_val(struct stat *st, const char *attribute)
1273 {
1274     g_autofree char *str = NULL;
1275     const char *end;
1276     long val;
1277     int ret;
1278
1279     ret = get_sysfs_str_val(st, attribute, &str);
1280     if (ret < 0) {
1281         return ret;
1282     }
1283
1284     /* The file is ended with '\n', pass 'end' to accept that. */
1285     ret = qemu_strtol(str, &end, 10, &val);
1286     if (ret == 0 && end && *end == '\0') {
1287         ret = val;
1288     }
1289     return ret;
1290 }
1291 #endif
1292
1293 static int hdev_get_max_segments(int fd, struct stat *st)
1294 {
1295 #ifdef CONFIG_LINUX
1296     int ret;
1297
1298     if (S_ISCHR(st->st_mode)) {
1299         if (ioctl(fd, SG_GET_SG_TABLESIZE, &ret) == 0) {
1300             return ret;
1301         }
1302         return -ENOTSUP;
1303     }
1304     return get_sysfs_long_val(st, "max_segments");
1305 #else
1306     return -ENOTSUP;
1307 #endif
1308 }
1309
1310 #if defined(CONFIG_BLKZONED)
1311 /*
1312  * If the reset_all flag is true, then the wps of zone whose state is
1313  * not readonly or offline should be all reset to the start sector.
1314  * Else, take the real wp of the device.
1315  */
1316 static int get_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
1317                         unsigned int nrz, bool reset_all)
1318 {
1319     struct blk_zone *blkz;
1320     size_t rep_size;
1321     uint64_t sector = offset >> BDRV_SECTOR_BITS;
1322     BlockZoneWps *wps = bs->wps;
1323     unsigned int j = offset / bs->bl.zone_size;
1324     unsigned int n = 0, i = 0;
1325     int ret;
1326     rep_size = sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_zone);
1327     g_autofree struct blk_zone_report *rep = NULL;
1328
1329     rep = g_malloc(rep_size);
1330     blkz = (struct blk_zone *)(rep + 1);
1331     while (n < nrz) {
1332         memset(rep, 0, rep_size);
1333         rep->sector = sector;
1334         rep->nr_zones = nrz - n;
1335
1336         do {
1337             ret = ioctl(fd, BLKREPORTZONE, rep);
1338         } while (ret != 0 && errno == EINTR);
1339         if (ret != 0) {
1340             error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d",
1341                     fd, offset, errno);
1342             return -errno;
1343         }
1344
1345         if (!rep->nr_zones) {
1346             break;
1347         }
1348
1349         for (i = 0; i < rep->nr_zones; ++i, ++n, ++j) {
1350             /*
1351              * The wp tracking cares only about sequential writes required and
1352              * sequential write preferred zones so that the wp can advance to
1353              * the right location.
1354              * Use the most significant bit of the wp location to indicate the
1355              * zone type: 0 for SWR/SWP zones and 1 for conventional zones.
1356              */
1357             if (blkz[i].type == BLK_ZONE_TYPE_CONVENTIONAL) {
1358                 wps->wp[j] |= 1ULL << 63;
1359             } else {
1360                 switch(blkz[i].cond) {
1361                 case BLK_ZONE_COND_FULL:
1362                 case BLK_ZONE_COND_READONLY:
1363                     /* Zone not writable */
1364                     wps->wp[j] = (blkz[i].start + blkz[i].len) << BDRV_SECTOR_BITS;
1365                     break;
1366                 case BLK_ZONE_COND_OFFLINE:
1367                     /* Zone not writable nor readable */
1368                     wps->wp[j] = (blkz[i].start) << BDRV_SECTOR_BITS;
1369                     break;
1370                 default:
1371                     if (reset_all) {
1372                         wps->wp[j] = blkz[i].start << BDRV_SECTOR_BITS;
1373                     } else {
1374                         wps->wp[j] = blkz[i].wp << BDRV_SECTOR_BITS;
1375                     }
1376                     break;
1377                 }
1378             }
1379         }
1380         sector = blkz[i - 1].start + blkz[i - 1].len;
1381     }
1382
1383     return 0;
1384 }
1385
1386 static void update_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
1387                             unsigned int nrz)
1388 {
1389     if (get_zones_wp(bs, fd, offset, nrz, 0) < 0) {
1390         error_report("update zone wp failed");
1391     }
1392 }
1393
1394 static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
1395                                      Error **errp)
1396 {
1397     BDRVRawState *s = bs->opaque;
1398     BlockZoneModel zoned;
1399     int ret;
1400
1401     ret = get_sysfs_zoned_model(st, &zoned);
1402     if (ret < 0 || zoned == BLK_Z_NONE) {
1403         goto no_zoned;
1404     }
1405     bs->bl.zoned = zoned;
1406
1407     ret = get_sysfs_long_val(st, "max_open_zones");
1408     if (ret >= 0) {
1409         bs->bl.max_open_zones = ret;
1410     }
1411
1412     ret = get_sysfs_long_val(st, "max_active_zones");
1413     if (ret >= 0) {
1414         bs->bl.max_active_zones = ret;
1415     }
1416
1417     /*
1418      * The zoned device must at least have zone size and nr_zones fields.
1419      */
1420     ret = get_sysfs_long_val(st, "chunk_sectors");
1421     if (ret < 0) {
1422         error_setg_errno(errp, -ret, "Unable to read chunk_sectors "
1423                                      "sysfs attribute");
1424         goto no_zoned;
1425     } else if (!ret) {
1426         error_setg(errp, "Read 0 from chunk_sectors sysfs attribute");
1427         goto no_zoned;
1428     }
1429     bs->bl.zone_size = ret << BDRV_SECTOR_BITS;
1430
1431     ret = get_sysfs_long_val(st, "nr_zones");
1432     if (ret < 0) {
1433         error_setg_errno(errp, -ret, "Unable to read nr_zones "
1434                                      "sysfs attribute");
1435         goto no_zoned;
1436     } else if (!ret) {
1437         error_setg(errp, "Read 0 from nr_zones sysfs attribute");
1438         goto no_zoned;
1439     }
1440     bs->bl.nr_zones = ret;
1441
1442     ret = get_sysfs_long_val(st, "zone_append_max_bytes");
1443     if (ret > 0) {
1444         bs->bl.max_append_sectors = ret >> BDRV_SECTOR_BITS;
1445     }
1446
1447     ret = get_sysfs_long_val(st, "physical_block_size");
1448     if (ret >= 0) {
1449         bs->bl.write_granularity = ret;
1450     }
1451
1452     /* The refresh_limits() function can be called multiple times. */
1453     g_free(bs->wps);
1454     bs->wps = g_malloc(sizeof(BlockZoneWps) +
1455             sizeof(int64_t) * bs->bl.nr_zones);
1456     ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0);
1457     if (ret < 0) {
1458         error_setg_errno(errp, -ret, "report wps failed");
1459         goto no_zoned;
1460     }
1461     qemu_co_mutex_init(&bs->wps->colock);
1462     return;
1463
1464 no_zoned:
1465     bs->bl.zoned = BLK_Z_NONE;
1466     g_free(bs->wps);
1467     bs->wps = NULL;
1468 }
1469 #else /* !defined(CONFIG_BLKZONED) */
1470 static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
1471                                      Error **errp)
1472 {
1473     bs->bl.zoned = BLK_Z_NONE;
1474 }
1475 #endif /* !defined(CONFIG_BLKZONED) */
1476
1477 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
1478 {
1479     BDRVRawState *s = bs->opaque;
1480     struct stat st;
1481
1482     s->needs_alignment = raw_needs_alignment(bs);
1483     raw_probe_alignment(bs, s->fd, errp);
1484
1485     bs->bl.min_mem_alignment = s->buf_align;
1486     bs->bl.opt_mem_alignment = MAX(s->buf_align, qemu_real_host_page_size());
1487
1488     /*
1489      * Maximum transfers are best effort, so it is okay to ignore any
1490      * errors.  That said, based on the man page errors in fstat would be
1491      * very much unexpected; the only possible case seems to be ENOMEM.
1492      */
1493     if (fstat(s->fd, &st)) {
1494         return;
1495     }
1496
1497 #if defined(__APPLE__) && (__MACH__)
1498     struct statfs buf;
1499
1500     if (!fstatfs(s->fd, &buf)) {
1501         bs->bl.opt_transfer = buf.f_iosize;
1502         bs->bl.pdiscard_alignment = buf.f_bsize;
1503     }
1504 #endif
1505
1506     if (bdrv_is_sg(bs) || S_ISBLK(st.st_mode)) {
1507         int ret = hdev_get_max_hw_transfer(s->fd, &st);
1508
1509         if (ret > 0 && ret <= BDRV_REQUEST_MAX_BYTES) {
1510             bs->bl.max_hw_transfer = ret;
1511         }
1512
1513         ret = hdev_get_max_segments(s->fd, &st);
1514         if (ret > 0) {
1515             bs->bl.max_hw_iov = ret;
1516         }
1517     }
1518
1519     raw_refresh_zoned_limits(bs, &st, errp);
1520 }
1521
1522 static int check_for_dasd(int fd)
1523 {
1524 #ifdef BIODASDINFO2
1525     struct dasd_information2_t info = {0};
1526
1527     return ioctl(fd, BIODASDINFO2, &info);
1528 #else
1529     return -1;
1530 #endif
1531 }
1532
1533 /**
1534  * Try to get @bs's logical and physical block size.
1535  * On success, store them in @bsz and return zero.
1536  * On failure, return negative errno.
1537  */
1538 static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)
1539 {
1540     BDRVRawState *s = bs->opaque;
1541     int ret;
1542
1543     /* If DASD or zoned devices, get blocksizes */
1544     if (check_for_dasd(s->fd) < 0) {
1545         /* zoned devices are not DASD */
1546         if (bs->bl.zoned == BLK_Z_NONE) {
1547             return -ENOTSUP;
1548         }
1549     }
1550     ret = probe_logical_blocksize(s->fd, &bsz->log);
1551     if (ret < 0) {
1552         return ret;
1553     }
1554     return probe_physical_blocksize(s->fd, &bsz->phys);
1555 }
1556
1557 /**
1558  * Try to get @bs's geometry: cyls, heads, sectors.
1559  * On success, store them in @geo and return 0.
1560  * On failure return -errno.
1561  * (Allows block driver to assign default geometry values that guest sees)
1562  */
1563 #ifdef __linux__
1564 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1565 {
1566     BDRVRawState *s = bs->opaque;
1567     struct hd_geometry ioctl_geo = {0};
1568
1569     /* If DASD, get its geometry */
1570     if (check_for_dasd(s->fd) < 0) {
1571         return -ENOTSUP;
1572     }
1573     if (ioctl(s->fd, HDIO_GETGEO, &ioctl_geo) < 0) {
1574         return -errno;
1575     }
1576     /* HDIO_GETGEO may return success even though geo contains zeros
1577        (e.g. certain multipath setups) */
1578     if (!ioctl_geo.heads || !ioctl_geo.sectors || !ioctl_geo.cylinders) {
1579         return -ENOTSUP;
1580     }
1581     /* Do not return a geometry for partition */
1582     if (ioctl_geo.start != 0) {
1583         return -ENOTSUP;
1584     }
1585     geo->heads = ioctl_geo.heads;
1586     geo->sectors = ioctl_geo.sectors;
1587     geo->cylinders = ioctl_geo.cylinders;
1588
1589     return 0;
1590 }
1591 #else /* __linux__ */
1592 static int hdev_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
1593 {
1594     return -ENOTSUP;
1595 }
1596 #endif
1597
1598 #if defined(__linux__)
1599 static int handle_aiocb_ioctl(void *opaque)
1600 {
1601     RawPosixAIOData *aiocb = opaque;
1602     int ret;
1603
1604     ret = RETRY_ON_EINTR(
1605         ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf)
1606     );
1607     if (ret == -1) {
1608         return -errno;
1609     }
1610
1611     return 0;
1612 }
1613 #endif /* linux */
1614
1615 static int handle_aiocb_flush(void *opaque)
1616 {
1617     RawPosixAIOData *aiocb = opaque;
1618     BDRVRawState *s = aiocb->bs->opaque;
1619     int ret;
1620
1621     if (s->page_cache_inconsistent) {
1622         return -s->page_cache_inconsistent;
1623     }
1624
1625     ret = qemu_fdatasync(aiocb->aio_fildes);
1626     if (ret == -1) {
1627         trace_file_flush_fdatasync_failed(errno);
1628
1629         /* There is no clear definition of the semantics of a failing fsync(),
1630          * so we may have to assume the worst. The sad truth is that this
1631          * assumption is correct for Linux. Some pages are now probably marked
1632          * clean in the page cache even though they are inconsistent with the
1633          * on-disk contents. The next fdatasync() call would succeed, but no
1634          * further writeback attempt will be made. We can't get back to a state
1635          * in which we know what is on disk (we would have to rewrite
1636          * everything that was touched since the last fdatasync() at least), so
1637          * make bdrv_flush() fail permanently. Given that the behaviour isn't
1638          * really defined, I have little hope that other OSes are doing better.
1639          *
1640          * Obviously, this doesn't affect O_DIRECT, which bypasses the page
1641          * cache. */
1642         if ((s->open_flags & O_DIRECT) == 0) {
1643             s->page_cache_inconsistent = errno;
1644         }
1645         return -errno;
1646     }
1647     return 0;
1648 }
1649
1650 #ifdef CONFIG_PREADV
1651
1652 static bool preadv_present = true;
1653
1654 static ssize_t
1655 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1656 {
1657     return preadv(fd, iov, nr_iov, offset);
1658 }
1659
1660 static ssize_t
1661 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1662 {
1663     return pwritev(fd, iov, nr_iov, offset);
1664 }
1665
1666 #else
1667
1668 static bool preadv_present = false;
1669
1670 static ssize_t
1671 qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1672 {
1673     return -ENOSYS;
1674 }
1675
1676 static ssize_t
1677 qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
1678 {
1679     return -ENOSYS;
1680 }
1681
1682 #endif
1683
1684 static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
1685 {
1686     ssize_t len;
1687
1688     len = RETRY_ON_EINTR(
1689         (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) ?
1690             qemu_pwritev(aiocb->aio_fildes,
1691                            aiocb->io.iov,
1692                            aiocb->io.niov,
1693                            aiocb->aio_offset) :
1694             qemu_preadv(aiocb->aio_fildes,
1695                           aiocb->io.iov,
1696                           aiocb->io.niov,
1697                           aiocb->aio_offset)
1698     );
1699
1700     if (len == -1) {
1701         return -errno;
1702     }
1703     return len;
1704 }
1705
1706 /*
1707  * Read/writes the data to/from a given linear buffer.
1708  *
1709  * Returns the number of bytes handles or -errno in case of an error. Short
1710  * reads are only returned if the end of the file is reached.
1711  */
1712 static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
1713 {
1714     ssize_t offset = 0;
1715     ssize_t len;
1716
1717     while (offset < aiocb->aio_nbytes) {
1718         if (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) {
1719             len = pwrite(aiocb->aio_fildes,
1720                          (const char *)buf + offset,
1721                          aiocb->aio_nbytes - offset,
1722                          aiocb->aio_offset + offset);
1723         } else {
1724             len = pread(aiocb->aio_fildes,
1725                         buf + offset,
1726                         aiocb->aio_nbytes - offset,
1727                         aiocb->aio_offset + offset);
1728         }
1729         if (len == -1 && errno == EINTR) {
1730             continue;
1731         } else if (len == -1 && errno == EINVAL &&
1732                    (aiocb->bs->open_flags & BDRV_O_NOCACHE) &&
1733                    !(aiocb->aio_type & QEMU_AIO_WRITE) &&
1734                    offset > 0) {
1735             /* O_DIRECT pread() may fail with EINVAL when offset is unaligned
1736              * after a short read.  Assume that O_DIRECT short reads only occur
1737              * at EOF.  Therefore this is a short read, not an I/O error.
1738              */
1739             break;
1740         } else if (len == -1) {
1741             offset = -errno;
1742             break;
1743         } else if (len == 0) {
1744             break;
1745         }
1746         offset += len;
1747     }
1748
1749     return offset;
1750 }
1751
1752 static int handle_aiocb_rw(void *opaque)
1753 {
1754     RawPosixAIOData *aiocb = opaque;
1755     ssize_t nbytes;
1756     char *buf;
1757
1758     if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
1759         /*
1760          * If there is just a single buffer, and it is properly aligned
1761          * we can just use plain pread/pwrite without any problems.
1762          */
1763         if (aiocb->io.niov == 1) {
1764             nbytes = handle_aiocb_rw_linear(aiocb, aiocb->io.iov->iov_base);
1765             goto out;
1766         }
1767         /*
1768          * We have more than one iovec, and all are properly aligned.
1769          *
1770          * Try preadv/pwritev first and fall back to linearizing the
1771          * buffer if it's not supported.
1772          */
1773         if (preadv_present) {
1774             nbytes = handle_aiocb_rw_vector(aiocb);
1775             if (nbytes == aiocb->aio_nbytes ||
1776                 (nbytes < 0 && nbytes != -ENOSYS)) {
1777                 goto out;
1778             }
1779             preadv_present = false;
1780         }
1781
1782         /*
1783          * XXX(hch): short read/write.  no easy way to handle the reminder
1784          * using these interfaces.  For now retry using plain
1785          * pread/pwrite?
1786          */
1787     }
1788
1789     /*
1790      * Ok, we have to do it the hard way, copy all segments into
1791      * a single aligned buffer.
1792      */
1793     buf = qemu_try_blockalign(aiocb->bs, aiocb->aio_nbytes);
1794     if (buf == NULL) {
1795         nbytes = -ENOMEM;
1796         goto out;
1797     }
1798
1799     if (aiocb->aio_type & QEMU_AIO_WRITE) {
1800         char *p = buf;
1801         int i;
1802
1803         for (i = 0; i < aiocb->io.niov; ++i) {
1804             memcpy(p, aiocb->io.iov[i].iov_base, aiocb->io.iov[i].iov_len);
1805             p += aiocb->io.iov[i].iov_len;
1806         }
1807         assert(p - buf == aiocb->aio_nbytes);
1808     }
1809
1810     nbytes = handle_aiocb_rw_linear(aiocb, buf);
1811     if (!(aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))) {
1812         char *p = buf;
1813         size_t count = aiocb->aio_nbytes, copy;
1814         int i;
1815
1816         for (i = 0; i < aiocb->io.niov && count; ++i) {
1817             copy = count;
1818             if (copy > aiocb->io.iov[i].iov_len) {
1819                 copy = aiocb->io.iov[i].iov_len;
1820             }
1821             memcpy(aiocb->io.iov[i].iov_base, p, copy);
1822             assert(count >= copy);
1823             p     += copy;
1824             count -= copy;
1825         }
1826         assert(count == 0);
1827     }
1828     qemu_vfree(buf);
1829
1830 out:
1831     if (nbytes == aiocb->aio_nbytes) {
1832         return 0;
1833     } else if (nbytes >= 0 && nbytes < aiocb->aio_nbytes) {
1834         if (aiocb->aio_type & QEMU_AIO_WRITE) {
1835             return -EINVAL;
1836         } else {
1837             iov_memset(aiocb->io.iov, aiocb->io.niov, nbytes,
1838                       0, aiocb->aio_nbytes - nbytes);
1839             return 0;
1840         }
1841     } else {
1842         assert(nbytes < 0);
1843         return nbytes;
1844     }
1845 }
1846
1847 #if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
1848 static int translate_err(int err)
1849 {
1850     if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
1851         err == -ENOTTY) {
1852         err = -ENOTSUP;
1853     }
1854     return err;
1855 }
1856 #endif
1857
1858 #ifdef CONFIG_FALLOCATE
1859 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
1860 {
1861     do {
1862         if (fallocate(fd, mode, offset, len) == 0) {
1863             return 0;
1864         }
1865     } while (errno == EINTR);
1866     return translate_err(-errno);
1867 }
1868 #endif
1869
1870 static ssize_t handle_aiocb_write_zeroes_block(RawPosixAIOData *aiocb)
1871 {
1872     int ret = -ENOTSUP;
1873     BDRVRawState *s = aiocb->bs->opaque;
1874
1875     if (!s->has_write_zeroes) {
1876         return -ENOTSUP;
1877     }
1878
1879 #ifdef BLKZEROOUT
1880     /* The BLKZEROOUT implementation in the kernel doesn't set
1881      * BLKDEV_ZERO_NOFALLBACK, so we can't call this if we have to avoid slow
1882      * fallbacks. */
1883     if (!(aiocb->aio_type & QEMU_AIO_NO_FALLBACK)) {
1884         do {
1885             uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
1886             if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
1887                 return 0;
1888             }
1889         } while (errno == EINTR);
1890
1891         ret = translate_err(-errno);
1892         if (ret == -ENOTSUP) {
1893             s->has_write_zeroes = false;
1894         }
1895     }
1896 #endif
1897
1898     return ret;
1899 }
1900
1901 static int handle_aiocb_write_zeroes(void *opaque)
1902 {
1903     RawPosixAIOData *aiocb = opaque;
1904 #ifdef CONFIG_FALLOCATE
1905     BDRVRawState *s = aiocb->bs->opaque;
1906     int64_t len;
1907 #endif
1908
1909     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
1910         return handle_aiocb_write_zeroes_block(aiocb);
1911     }
1912
1913 #ifdef CONFIG_FALLOCATE_ZERO_RANGE
1914     if (s->has_write_zeroes) {
1915         int ret = do_fallocate(s->fd, FALLOC_FL_ZERO_RANGE,
1916                                aiocb->aio_offset, aiocb->aio_nbytes);
1917         if (ret == -ENOTSUP) {
1918             s->has_write_zeroes = false;
1919         } else if (ret == 0 || ret != -EINVAL) {
1920             return ret;
1921         }
1922         /*
1923          * Note: Some file systems do not like unaligned byte ranges, and
1924          * return EINVAL in such a case, though they should not do it according
1925          * to the man-page of fallocate(). Thus we simply ignore this return
1926          * value and try the other fallbacks instead.
1927          */
1928     }
1929 #endif
1930
1931 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1932     if (s->has_discard && s->has_fallocate) {
1933         int ret = do_fallocate(s->fd,
1934                                FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1935                                aiocb->aio_offset, aiocb->aio_nbytes);
1936         if (ret == 0) {
1937             ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1938             if (ret == 0 || ret != -ENOTSUP) {
1939                 return ret;
1940             }
1941             s->has_fallocate = false;
1942         } else if (ret == -EINVAL) {
1943             /*
1944              * Some file systems like older versions of GPFS do not like un-
1945              * aligned byte ranges, and return EINVAL in such a case, though
1946              * they should not do it according to the man-page of fallocate().
1947              * Warn about the bad filesystem and try the final fallback instead.
1948              */
1949             warn_report_once("Your file system is misbehaving: "
1950                              "fallocate(FALLOC_FL_PUNCH_HOLE) returned EINVAL. "
1951                              "Please report this bug to your file system "
1952                              "vendor.");
1953         } else if (ret != -ENOTSUP) {
1954             return ret;
1955         } else {
1956             s->has_discard = false;
1957         }
1958     }
1959 #endif
1960
1961 #ifdef CONFIG_FALLOCATE
1962     /* Last resort: we are trying to extend the file with zeroed data. This
1963      * can be done via fallocate(fd, 0) */
1964     len = raw_getlength(aiocb->bs);
1965     if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
1966         int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
1967         if (ret == 0 || ret != -ENOTSUP) {
1968             return ret;
1969         }
1970         s->has_fallocate = false;
1971     }
1972 #endif
1973
1974     return -ENOTSUP;
1975 }
1976
1977 static int handle_aiocb_write_zeroes_unmap(void *opaque)
1978 {
1979     RawPosixAIOData *aiocb = opaque;
1980     BDRVRawState *s G_GNUC_UNUSED = aiocb->bs->opaque;
1981
1982     /* First try to write zeros and unmap at the same time */
1983
1984 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
1985     int ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
1986                            aiocb->aio_offset, aiocb->aio_nbytes);
1987     switch (ret) {
1988     case -ENOTSUP:
1989     case -EINVAL:
1990     case -EBUSY:
1991         break;
1992     default:
1993         return ret;
1994     }
1995 #endif
1996
1997     /* If we couldn't manage to unmap while guaranteed that the area reads as
1998      * all-zero afterwards, just write zeroes without unmapping */
1999     return handle_aiocb_write_zeroes(aiocb);
2000 }
2001
2002 #ifndef HAVE_COPY_FILE_RANGE
2003 static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
2004                              off_t *out_off, size_t len, unsigned int flags)
2005 {
2006 #ifdef __NR_copy_file_range
2007     return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
2008                    out_off, len, flags);
2009 #else
2010     errno = ENOSYS;
2011     return -1;
2012 #endif
2013 }
2014 #endif
2015
2016 /*
2017  * parse_zone - Fill a zone descriptor
2018  */
2019 #if defined(CONFIG_BLKZONED)
2020 static inline int parse_zone(struct BlockZoneDescriptor *zone,
2021                               const struct blk_zone *blkz) {
2022     zone->start = blkz->start << BDRV_SECTOR_BITS;
2023     zone->length = blkz->len << BDRV_SECTOR_BITS;
2024     zone->wp = blkz->wp << BDRV_SECTOR_BITS;
2025
2026 #ifdef HAVE_BLK_ZONE_REP_CAPACITY
2027     zone->cap = blkz->capacity << BDRV_SECTOR_BITS;
2028 #else
2029     zone->cap = blkz->len << BDRV_SECTOR_BITS;
2030 #endif
2031
2032     switch (blkz->type) {
2033     case BLK_ZONE_TYPE_SEQWRITE_REQ:
2034         zone->type = BLK_ZT_SWR;
2035         break;
2036     case BLK_ZONE_TYPE_SEQWRITE_PREF:
2037         zone->type = BLK_ZT_SWP;
2038         break;
2039     case BLK_ZONE_TYPE_CONVENTIONAL:
2040         zone->type = BLK_ZT_CONV;
2041         break;
2042     default:
2043         error_report("Unsupported zone type: 0x%x", blkz->type);
2044         return -ENOTSUP;
2045     }
2046
2047     switch (blkz->cond) {
2048     case BLK_ZONE_COND_NOT_WP:
2049         zone->state = BLK_ZS_NOT_WP;
2050         break;
2051     case BLK_ZONE_COND_EMPTY:
2052         zone->state = BLK_ZS_EMPTY;
2053         break;
2054     case BLK_ZONE_COND_IMP_OPEN:
2055         zone->state = BLK_ZS_IOPEN;
2056         break;
2057     case BLK_ZONE_COND_EXP_OPEN:
2058         zone->state = BLK_ZS_EOPEN;
2059         break;
2060     case BLK_ZONE_COND_CLOSED:
2061         zone->state = BLK_ZS_CLOSED;
2062         break;
2063     case BLK_ZONE_COND_READONLY:
2064         zone->state = BLK_ZS_RDONLY;
2065         break;
2066     case BLK_ZONE_COND_FULL:
2067         zone->state = BLK_ZS_FULL;
2068         break;
2069     case BLK_ZONE_COND_OFFLINE:
2070         zone->state = BLK_ZS_OFFLINE;
2071         break;
2072     default:
2073         error_report("Unsupported zone state: 0x%x", blkz->cond);
2074         return -ENOTSUP;
2075     }
2076     return 0;
2077 }
2078 #endif
2079
2080 #if defined(CONFIG_BLKZONED)
2081 static int handle_aiocb_zone_report(void *opaque)
2082 {
2083     RawPosixAIOData *aiocb = opaque;
2084     int fd = aiocb->aio_fildes;
2085     unsigned int *nr_zones = aiocb->zone_report.nr_zones;
2086     BlockZoneDescriptor *zones = aiocb->zone_report.zones;
2087     /* zoned block devices use 512-byte sectors */
2088     uint64_t sector = aiocb->aio_offset / 512;
2089
2090     struct blk_zone *blkz;
2091     size_t rep_size;
2092     unsigned int nrz;
2093     int ret;
2094     unsigned int n = 0, i = 0;
2095
2096     nrz = *nr_zones;
2097     rep_size = sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_zone);
2098     g_autofree struct blk_zone_report *rep = NULL;
2099     rep = g_malloc(rep_size);
2100
2101     blkz = (struct blk_zone *)(rep + 1);
2102     while (n < nrz) {
2103         memset(rep, 0, rep_size);
2104         rep->sector = sector;
2105         rep->nr_zones = nrz - n;
2106
2107         do {
2108             ret = ioctl(fd, BLKREPORTZONE, rep);
2109         } while (ret != 0 && errno == EINTR);
2110         if (ret != 0) {
2111             error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d",
2112                          fd, sector, errno);
2113             return -errno;
2114         }
2115
2116         if (!rep->nr_zones) {
2117             break;
2118         }
2119
2120         for (i = 0; i < rep->nr_zones; i++, n++) {
2121             ret = parse_zone(&zones[n], &blkz[i]);
2122             if (ret != 0) {
2123                 return ret;
2124             }
2125
2126             /* The next report should start after the last zone reported */
2127             sector = blkz[i].start + blkz[i].len;
2128         }
2129     }
2130
2131     *nr_zones = n;
2132     return 0;
2133 }
2134 #endif
2135
2136 #if defined(CONFIG_BLKZONED)
2137 static int handle_aiocb_zone_mgmt(void *opaque)
2138 {
2139     RawPosixAIOData *aiocb = opaque;
2140     int fd = aiocb->aio_fildes;
2141     uint64_t sector = aiocb->aio_offset / 512;
2142     int64_t nr_sectors = aiocb->aio_nbytes / 512;
2143     struct blk_zone_range range;
2144     int ret;
2145
2146     /* Execute the operation */
2147     range.sector = sector;
2148     range.nr_sectors = nr_sectors;
2149     do {
2150         ret = ioctl(fd, aiocb->zone_mgmt.op, &range);
2151     } while (ret != 0 && errno == EINTR);
2152
2153     return ret < 0 ? -errno : ret;
2154 }
2155 #endif
2156
2157 static int handle_aiocb_copy_range(void *opaque)
2158 {
2159     RawPosixAIOData *aiocb = opaque;
2160     uint64_t bytes = aiocb->aio_nbytes;
2161     off_t in_off = aiocb->aio_offset;
2162     off_t out_off = aiocb->copy_range.aio_offset2;
2163
2164     while (bytes) {
2165         ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
2166                                       aiocb->copy_range.aio_fd2, &out_off,
2167                                       bytes, 0);
2168         trace_file_copy_file_range(aiocb->bs, aiocb->aio_fildes, in_off,
2169                                    aiocb->copy_range.aio_fd2, out_off, bytes,
2170                                    0, ret);
2171         if (ret == 0) {
2172             /* No progress (e.g. when beyond EOF), let the caller fall back to
2173              * buffer I/O. */
2174             return -ENOSPC;
2175         }
2176         if (ret < 0) {
2177             switch (errno) {
2178             case ENOSYS:
2179                 return -ENOTSUP;
2180             case EINTR:
2181                 continue;
2182             default:
2183                 return -errno;
2184             }
2185         }
2186         bytes -= ret;
2187     }
2188     return 0;
2189 }
2190
2191 static int handle_aiocb_discard(void *opaque)
2192 {
2193     RawPosixAIOData *aiocb = opaque;
2194     int ret = -ENOTSUP;
2195     BDRVRawState *s = aiocb->bs->opaque;
2196
2197     if (!s->has_discard) {
2198         return -ENOTSUP;
2199     }
2200
2201     if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
2202 #ifdef BLKDISCARD
2203         do {
2204             uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
2205             if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
2206                 return 0;
2207             }
2208         } while (errno == EINTR);
2209
2210         ret = translate_err(-errno);
2211 #endif
2212     } else {
2213 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
2214         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
2215                            aiocb->aio_offset, aiocb->aio_nbytes);
2216         ret = translate_err(ret);
2217 #elif defined(__APPLE__) && (__MACH__)
2218         fpunchhole_t fpunchhole;
2219         fpunchhole.fp_flags = 0;
2220         fpunchhole.reserved = 0;
2221         fpunchhole.fp_offset = aiocb->aio_offset;
2222         fpunchhole.fp_length = aiocb->aio_nbytes;
2223         if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
2224             ret = errno == ENODEV ? -ENOTSUP : -errno;
2225         } else {
2226             ret = 0;
2227         }
2228 #endif
2229     }
2230
2231     if (ret == -ENOTSUP) {
2232         s->has_discard = false;
2233     }
2234     return ret;
2235 }
2236
2237 /*
2238  * Help alignment probing by allocating the first block.
2239  *
2240  * When reading with direct I/O from unallocated area on Gluster backed by XFS,
2241  * reading succeeds regardless of request length. In this case we fallback to
2242  * safe alignment which is not optimal. Allocating the first block avoids this
2243  * fallback.
2244  *
2245  * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
2246  * request alignment, so we use safe values.
2247  *
2248  * Returns: 0 on success, -errno on failure. Since this is an optimization,
2249  * caller may ignore failures.
2250  */
2251 static int allocate_first_block(int fd, size_t max_size)
2252 {
2253     size_t write_size = (max_size < MAX_BLOCKSIZE)
2254         ? BDRV_SECTOR_SIZE
2255         : MAX_BLOCKSIZE;
2256     size_t max_align = MAX(MAX_BLOCKSIZE, qemu_real_host_page_size());
2257     void *buf;
2258     ssize_t n;
2259     int ret;
2260
2261     buf = qemu_memalign(max_align, write_size);
2262     memset(buf, 0, write_size);
2263
2264     n = RETRY_ON_EINTR(pwrite(fd, buf, write_size, 0));
2265
2266     ret = (n == -1) ? -errno : 0;
2267
2268     qemu_vfree(buf);
2269     return ret;
2270 }
2271
2272 static int handle_aiocb_truncate(void *opaque)
2273 {
2274     RawPosixAIOData *aiocb = opaque;
2275     int result = 0;
2276     int64_t current_length = 0;
2277     char *buf = NULL;
2278     struct stat st;
2279     int fd = aiocb->aio_fildes;
2280     int64_t offset = aiocb->aio_offset;
2281     PreallocMode prealloc = aiocb->truncate.prealloc;
2282     Error **errp = aiocb->truncate.errp;
2283
2284     if (fstat(fd, &st) < 0) {
2285         result = -errno;
2286         error_setg_errno(errp, -result, "Could not stat file");
2287         return result;
2288     }
2289
2290     current_length = st.st_size;
2291     if (current_length > offset && prealloc != PREALLOC_MODE_OFF) {
2292         error_setg(errp, "Cannot use preallocation for shrinking files");
2293         return -ENOTSUP;
2294     }
2295
2296     switch (prealloc) {
2297 #ifdef CONFIG_POSIX_FALLOCATE
2298     case PREALLOC_MODE_FALLOC:
2299         /*
2300          * Truncating before posix_fallocate() makes it about twice slower on
2301          * file systems that do not support fallocate(), trying to check if a
2302          * block is allocated before allocating it, so don't do that here.
2303          */
2304         if (offset != current_length) {
2305             result = -posix_fallocate(fd, current_length,
2306                                       offset - current_length);
2307             if (result != 0) {
2308                 /* posix_fallocate() doesn't set errno. */
2309                 error_setg_errno(errp, -result,
2310                                  "Could not preallocate new data");
2311             } else if (current_length == 0) {
2312                 /*
2313                  * posix_fallocate() uses fallocate() if the filesystem
2314                  * supports it, or fallback to manually writing zeroes. If
2315                  * fallocate() was used, unaligned reads from the fallocated
2316                  * area in raw_probe_alignment() will succeed, hence we need to
2317                  * allocate the first block.
2318                  *
2319                  * Optimize future alignment probing; ignore failures.
2320                  */
2321                 allocate_first_block(fd, offset);
2322             }
2323         } else {
2324             result = 0;
2325         }
2326         goto out;
2327 #endif
2328     case PREALLOC_MODE_FULL:
2329     {
2330         int64_t num = 0, left = offset - current_length;
2331         off_t seek_result;
2332
2333         /*
2334          * Knowing the final size from the beginning could allow the file
2335          * system driver to do less allocations and possibly avoid
2336          * fragmentation of the file.
2337          */
2338         if (ftruncate(fd, offset) != 0) {
2339             result = -errno;
2340             error_setg_errno(errp, -result, "Could not resize file");
2341             goto out;
2342         }
2343
2344         buf = g_malloc0(65536);
2345
2346         seek_result = lseek(fd, current_length, SEEK_SET);
2347         if (seek_result < 0) {
2348             result = -errno;
2349             error_setg_errno(errp, -result,
2350                              "Failed to seek to the old end of file");
2351             goto out;
2352         }
2353
2354         while (left > 0) {
2355             num = MIN(left, 65536);
2356             result = write(fd, buf, num);
2357             if (result < 0) {
2358                 if (errno == EINTR) {
2359                     continue;
2360                 }
2361                 result = -errno;
2362                 error_setg_errno(errp, -result,
2363                                  "Could not write zeros for preallocation");
2364                 goto out;
2365             }
2366             left -= result;
2367         }
2368         if (result >= 0) {
2369             result = fsync(fd);
2370             if (result < 0) {
2371                 result = -errno;
2372                 error_setg_errno(errp, -result,
2373                                  "Could not flush file to disk");
2374                 goto out;
2375             }
2376         }
2377         goto out;
2378     }
2379     case PREALLOC_MODE_OFF:
2380         if (ftruncate(fd, offset) != 0) {
2381             result = -errno;
2382             error_setg_errno(errp, -result, "Could not resize file");
2383         } else if (current_length == 0 && offset > current_length) {
2384             /* Optimize future alignment probing; ignore failures. */
2385             allocate_first_block(fd, offset);
2386         }
2387         return result;
2388     default:
2389         result = -ENOTSUP;
2390         error_setg(errp, "Unsupported preallocation mode: %s",
2391                    PreallocMode_str(prealloc));
2392         return result;
2393     }
2394
2395 out:
2396     if (result < 0) {
2397         if (ftruncate(fd, current_length) < 0) {
2398             error_report("Failed to restore old file length: %s",
2399                          strerror(errno));
2400         }
2401     }
2402
2403     g_free(buf);
2404     return result;
2405 }
2406
2407 static int coroutine_fn raw_thread_pool_submit(ThreadPoolFunc func, void *arg)
2408 {
2409     return thread_pool_submit_co(func, arg);
2410 }
2411
2412 /*
2413  * Check if all memory in this vector is sector aligned.
2414  */
2415 static bool bdrv_qiov_is_aligned(BlockDriverState *bs, QEMUIOVector *qiov)
2416 {
2417     int i;
2418     size_t alignment = bdrv_min_mem_align(bs);
2419     size_t len = bs->bl.request_alignment;
2420     IO_CODE();
2421
2422     for (i = 0; i < qiov->niov; i++) {
2423         if ((uintptr_t) qiov->iov[i].iov_base % alignment) {
2424             return false;
2425         }
2426         if (qiov->iov[i].iov_len % len) {
2427             return false;
2428         }
2429     }
2430
2431     return true;
2432 }
2433
2434 #ifdef CONFIG_LINUX_IO_URING
2435 static inline bool raw_check_linux_io_uring(BDRVRawState *s)
2436 {
2437     Error *local_err = NULL;
2438     AioContext *ctx;
2439
2440     if (!s->use_linux_io_uring) {
2441         return false;
2442     }
2443
2444     ctx = qemu_get_current_aio_context();
2445     if (unlikely(!aio_setup_linux_io_uring(ctx, &local_err))) {
2446         error_reportf_err(local_err, "Unable to use linux io_uring, "
2447                                      "falling back to thread pool: ");
2448         s->use_linux_io_uring = false;
2449         return false;
2450     }
2451     return true;
2452 }
2453 #endif
2454
2455 #ifdef CONFIG_LINUX_AIO
2456 static inline bool raw_check_linux_aio(BDRVRawState *s)
2457 {
2458     Error *local_err = NULL;
2459     AioContext *ctx;
2460
2461     if (!s->use_linux_aio) {
2462         return false;
2463     }
2464
2465     ctx = qemu_get_current_aio_context();
2466     if (unlikely(!aio_setup_linux_aio(ctx, &local_err))) {
2467         error_reportf_err(local_err, "Unable to use Linux AIO, "
2468                                      "falling back to thread pool: ");
2469         s->use_linux_aio = false;
2470         return false;
2471     }
2472     return true;
2473 }
2474 #endif
2475
2476 static int coroutine_fn raw_co_prw(BlockDriverState *bs, int64_t *offset_ptr,
2477                                    uint64_t bytes, QEMUIOVector *qiov, int type)
2478 {
2479     BDRVRawState *s = bs->opaque;
2480     RawPosixAIOData acb;
2481     int ret;
2482     uint64_t offset = *offset_ptr;
2483
2484     if (fd_open(bs) < 0)
2485         return -EIO;
2486 #if defined(CONFIG_BLKZONED)
2487     if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
2488         bs->bl.zoned != BLK_Z_NONE) {
2489         qemu_co_mutex_lock(&bs->wps->colock);
2490         if (type & QEMU_AIO_ZONE_APPEND) {
2491             int index = offset / bs->bl.zone_size;
2492             offset = bs->wps->wp[index];
2493         }
2494     }
2495 #endif
2496
2497     /*
2498      * When using O_DIRECT, the request must be aligned to be able to use
2499      * either libaio or io_uring interface. If not fail back to regular thread
2500      * pool read/write code which emulates this for us if we
2501      * set QEMU_AIO_MISALIGNED.
2502      */
2503     if (s->needs_alignment && !bdrv_qiov_is_aligned(bs, qiov)) {
2504         type |= QEMU_AIO_MISALIGNED;
2505 #ifdef CONFIG_LINUX_IO_URING
2506     } else if (raw_check_linux_io_uring(s)) {
2507         assert(qiov->size == bytes);
2508         ret = luring_co_submit(bs, s->fd, offset, qiov, type);
2509         goto out;
2510 #endif
2511 #ifdef CONFIG_LINUX_AIO
2512     } else if (raw_check_linux_aio(s)) {
2513         assert(qiov->size == bytes);
2514         ret = laio_co_submit(s->fd, offset, qiov, type,
2515                               s->aio_max_batch);
2516         goto out;
2517 #endif
2518     }
2519
2520     acb = (RawPosixAIOData) {
2521         .bs             = bs,
2522         .aio_fildes     = s->fd,
2523         .aio_type       = type,
2524         .aio_offset     = offset,
2525         .aio_nbytes     = bytes,
2526         .io             = {
2527             .iov            = qiov->iov,
2528             .niov           = qiov->niov,
2529         },
2530     };
2531
2532     assert(qiov->size == bytes);
2533     ret = raw_thread_pool_submit(handle_aiocb_rw, &acb);
2534     goto out; /* Avoid the compiler err of unused label */
2535
2536 out:
2537 #if defined(CONFIG_BLKZONED)
2538     if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) &&
2539         bs->bl.zoned != BLK_Z_NONE) {
2540         BlockZoneWps *wps = bs->wps;
2541         if (ret == 0) {
2542             uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
2543             if (!BDRV_ZT_IS_CONV(*wp)) {
2544                 if (type & QEMU_AIO_ZONE_APPEND) {
2545                     *offset_ptr = *wp;
2546                     trace_zbd_zone_append_complete(bs, *offset_ptr
2547                         >> BDRV_SECTOR_BITS);
2548                 }
2549                 /* Advance the wp if needed */
2550                 if (offset + bytes > *wp) {
2551                     *wp = offset + bytes;
2552                 }
2553             }
2554         } else {
2555             /*
2556              * write and append write are not allowed to cross zone boundaries
2557              */
2558             update_zones_wp(bs, s->fd, offset, 1);
2559         }
2560
2561         qemu_co_mutex_unlock(&wps->colock);
2562     }
2563 #endif
2564     return ret;
2565 }
2566
2567 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
2568                                       int64_t bytes, QEMUIOVector *qiov,
2569                                       BdrvRequestFlags flags)
2570 {
2571     return raw_co_prw(bs, &offset, bytes, qiov, QEMU_AIO_READ);
2572 }
2573
2574 static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, int64_t offset,
2575                                        int64_t bytes, QEMUIOVector *qiov,
2576                                        BdrvRequestFlags flags)
2577 {
2578     return raw_co_prw(bs, &offset, bytes, qiov, QEMU_AIO_WRITE);
2579 }
2580
2581 static int coroutine_fn raw_co_flush_to_disk(BlockDriverState *bs)
2582 {
2583     BDRVRawState *s = bs->opaque;
2584     RawPosixAIOData acb;
2585     int ret;
2586
2587     ret = fd_open(bs);
2588     if (ret < 0) {
2589         return ret;
2590     }
2591
2592     acb = (RawPosixAIOData) {
2593         .bs             = bs,
2594         .aio_fildes     = s->fd,
2595         .aio_type       = QEMU_AIO_FLUSH,
2596     };
2597
2598 #ifdef CONFIG_LINUX_IO_URING
2599     if (raw_check_linux_io_uring(s)) {
2600         return luring_co_submit(bs, s->fd, 0, NULL, QEMU_AIO_FLUSH);
2601     }
2602 #endif
2603     return raw_thread_pool_submit(handle_aiocb_flush, &acb);
2604 }
2605
2606 static void raw_close(BlockDriverState *bs)
2607 {
2608     BDRVRawState *s = bs->opaque;
2609
2610     if (s->fd >= 0) {
2611 #if defined(CONFIG_BLKZONED)
2612         g_free(bs->wps);
2613 #endif
2614         qemu_close(s->fd);
2615         s->fd = -1;
2616     }
2617 }
2618
2619 /**
2620  * Truncates the given regular file @fd to @offset and, when growing, fills the
2621  * new space according to @prealloc.
2622  *
2623  * Returns: 0 on success, -errno on failure.
2624  */
2625 static int coroutine_fn
2626 raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
2627                      PreallocMode prealloc, Error **errp)
2628 {
2629     RawPosixAIOData acb;
2630
2631     acb = (RawPosixAIOData) {
2632         .bs             = bs,
2633         .aio_fildes     = fd,
2634         .aio_type       = QEMU_AIO_TRUNCATE,
2635         .aio_offset     = offset,
2636         .truncate       = {
2637             .prealloc       = prealloc,
2638             .errp           = errp,
2639         },
2640     };
2641
2642     return raw_thread_pool_submit(handle_aiocb_truncate, &acb);
2643 }
2644
2645 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
2646                                         bool exact, PreallocMode prealloc,
2647                                         BdrvRequestFlags flags, Error **errp)
2648 {
2649     BDRVRawState *s = bs->opaque;
2650     struct stat st;
2651     int ret;
2652
2653     if (fstat(s->fd, &st)) {
2654         ret = -errno;
2655         error_setg_errno(errp, -ret, "Failed to fstat() the file");
2656         return ret;
2657     }
2658
2659     if (S_ISREG(st.st_mode)) {
2660         /* Always resizes to the exact @offset */
2661         return raw_regular_truncate(bs, s->fd, offset, prealloc, errp);
2662     }
2663
2664     if (prealloc != PREALLOC_MODE_OFF) {
2665         error_setg(errp, "Preallocation mode '%s' unsupported for this "
2666                    "non-regular file", PreallocMode_str(prealloc));
2667         return -ENOTSUP;
2668     }
2669
2670     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2671         int64_t cur_length = raw_getlength(bs);
2672
2673         if (offset != cur_length && exact) {
2674             error_setg(errp, "Cannot resize device files");
2675             return -ENOTSUP;
2676         } else if (offset > cur_length) {
2677             error_setg(errp, "Cannot grow device files");
2678             return -EINVAL;
2679         }
2680     } else {
2681         error_setg(errp, "Resizing this file is not supported");
2682         return -ENOTSUP;
2683     }
2684
2685     return 0;
2686 }
2687
2688 #ifdef __OpenBSD__
2689 static int64_t raw_getlength(BlockDriverState *bs)
2690 {
2691     BDRVRawState *s = bs->opaque;
2692     int fd = s->fd;
2693     struct stat st;
2694
2695     if (fstat(fd, &st))
2696         return -errno;
2697     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2698         struct disklabel dl;
2699
2700         if (ioctl(fd, DIOCGDINFO, &dl))
2701             return -errno;
2702         return (uint64_t)dl.d_secsize *
2703             dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2704     } else
2705         return st.st_size;
2706 }
2707 #elif defined(__NetBSD__)
2708 static int64_t raw_getlength(BlockDriverState *bs)
2709 {
2710     BDRVRawState *s = bs->opaque;
2711     int fd = s->fd;
2712     struct stat st;
2713
2714     if (fstat(fd, &st))
2715         return -errno;
2716     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
2717         struct dkwedge_info dkw;
2718
2719         if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
2720             return dkw.dkw_size * 512;
2721         } else {
2722             struct disklabel dl;
2723
2724             if (ioctl(fd, DIOCGDINFO, &dl))
2725                 return -errno;
2726             return (uint64_t)dl.d_secsize *
2727                 dl.d_partitions[DISKPART(st.st_rdev)].p_size;
2728         }
2729     } else
2730         return st.st_size;
2731 }
2732 #elif defined(__sun__)
2733 static int64_t raw_getlength(BlockDriverState *bs)
2734 {
2735     BDRVRawState *s = bs->opaque;
2736     struct dk_minfo minfo;
2737     int ret;
2738     int64_t size;
2739
2740     ret = fd_open(bs);
2741     if (ret < 0) {
2742         return ret;
2743     }
2744
2745     /*
2746      * Use the DKIOCGMEDIAINFO ioctl to read the size.
2747      */
2748     ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
2749     if (ret != -1) {
2750         return minfo.dki_lbsize * minfo.dki_capacity;
2751     }
2752
2753     /*
2754      * There are reports that lseek on some devices fails, but
2755      * irc discussion said that contingency on contingency was overkill.
2756      */
2757     size = lseek(s->fd, 0, SEEK_END);
2758     if (size < 0) {
2759         return -errno;
2760     }
2761     return size;
2762 }
2763 #elif defined(CONFIG_BSD)
2764 static int64_t raw_getlength(BlockDriverState *bs)
2765 {
2766     BDRVRawState *s = bs->opaque;
2767     int fd = s->fd;
2768     int64_t size;
2769     struct stat sb;
2770 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2771     int reopened = 0;
2772 #endif
2773     int ret;
2774
2775     ret = fd_open(bs);
2776     if (ret < 0)
2777         return ret;
2778
2779 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2780 again:
2781 #endif
2782     if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
2783         size = 0;
2784 #ifdef DIOCGMEDIASIZE
2785         if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size)) {
2786             size = 0;
2787         }
2788 #endif
2789 #ifdef DIOCGPART
2790         if (size == 0) {
2791             struct partinfo pi;
2792             if (ioctl(fd, DIOCGPART, &pi) == 0) {
2793                 size = pi.media_size;
2794             }
2795         }
2796 #endif
2797 #if defined(DKIOCGETBLOCKCOUNT) && defined(DKIOCGETBLOCKSIZE)
2798         if (size == 0) {
2799             uint64_t sectors = 0;
2800             uint32_t sector_size = 0;
2801
2802             if (ioctl(fd, DKIOCGETBLOCKCOUNT, &sectors) == 0
2803                && ioctl(fd, DKIOCGETBLOCKSIZE, &sector_size) == 0) {
2804                 size = sectors * sector_size;
2805             }
2806         }
2807 #endif
2808         if (size == 0) {
2809             size = lseek(fd, 0LL, SEEK_END);
2810         }
2811         if (size < 0) {
2812             return -errno;
2813         }
2814 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2815         switch(s->type) {
2816         case FTYPE_CD:
2817             /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
2818             if (size == 2048LL * (unsigned)-1)
2819                 size = 0;
2820             /* XXX no disc?  maybe we need to reopen... */
2821             if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
2822                 reopened = 1;
2823                 goto again;
2824             }
2825         }
2826 #endif
2827     } else {
2828         size = lseek(fd, 0, SEEK_END);
2829         if (size < 0) {
2830             return -errno;
2831         }
2832     }
2833     return size;
2834 }
2835 #else
2836 static int64_t raw_getlength(BlockDriverState *bs)
2837 {
2838     BDRVRawState *s = bs->opaque;
2839     int ret;
2840     int64_t size;
2841
2842     ret = fd_open(bs);
2843     if (ret < 0) {
2844         return ret;
2845     }
2846
2847     size = lseek(s->fd, 0, SEEK_END);
2848     if (size < 0) {
2849         return -errno;
2850     }
2851     return size;
2852 }
2853 #endif
2854
2855 static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
2856 {
2857     return raw_getlength(bs);
2858 }
2859
2860 static int64_t coroutine_fn raw_co_get_allocated_file_size(BlockDriverState *bs)
2861 {
2862     struct stat st;
2863     BDRVRawState *s = bs->opaque;
2864
2865     if (fstat(s->fd, &st) < 0) {
2866         return -errno;
2867     }
2868     return (int64_t)st.st_blocks * 512;
2869 }
2870
2871 static int coroutine_fn
2872 raw_co_create(BlockdevCreateOptions *options, Error **errp)
2873 {
2874     BlockdevCreateOptionsFile *file_opts;
2875     Error *local_err = NULL;
2876     int fd;
2877     uint64_t perm, shared;
2878     int result = 0;
2879
2880     /* Validate options and set default values */
2881     assert(options->driver == BLOCKDEV_DRIVER_FILE);
2882     file_opts = &options->u.file;
2883
2884     if (!file_opts->has_nocow) {
2885         file_opts->nocow = false;
2886     }
2887     if (!file_opts->has_preallocation) {
2888         file_opts->preallocation = PREALLOC_MODE_OFF;
2889     }
2890     if (!file_opts->has_extent_size_hint) {
2891         file_opts->extent_size_hint = 1 * MiB;
2892     }
2893     if (file_opts->extent_size_hint > UINT32_MAX) {
2894         result = -EINVAL;
2895         error_setg(errp, "Extent size hint is too large");
2896         goto out;
2897     }
2898
2899     /* Create file */
2900     fd = qemu_create(file_opts->filename, O_RDWR | O_BINARY, 0644, errp);
2901     if (fd < 0) {
2902         result = -errno;
2903         goto out;
2904     }
2905
2906     /* Take permissions: We want to discard everything, so we need
2907      * BLK_PERM_WRITE; and truncation to the desired size requires
2908      * BLK_PERM_RESIZE.
2909      * On the other hand, we cannot share the RESIZE permission
2910      * because we promise that after this function, the file has the
2911      * size given in the options.  If someone else were to resize it
2912      * concurrently, we could not guarantee that.
2913      * Note that after this function, we can no longer guarantee that
2914      * the file is not touched by a third party, so it may be resized
2915      * then. */
2916     perm = BLK_PERM_WRITE | BLK_PERM_RESIZE;
2917     shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
2918
2919     /* Step one: Take locks */
2920     result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
2921     if (result < 0) {
2922         goto out_close;
2923     }
2924
2925     /* Step two: Check that nobody else has taken conflicting locks */
2926     result = raw_check_lock_bytes(fd, perm, shared, errp);
2927     if (result < 0) {
2928         error_append_hint(errp,
2929                           "Is another process using the image [%s]?\n",
2930                           file_opts->filename);
2931         goto out_unlock;
2932     }
2933
2934     /* Clear the file by truncating it to 0 */
2935     result = raw_regular_truncate(NULL, fd, 0, PREALLOC_MODE_OFF, errp);
2936     if (result < 0) {
2937         goto out_unlock;
2938     }
2939
2940     if (file_opts->nocow) {
2941 #ifdef __linux__
2942         /* Set NOCOW flag to solve performance issue on fs like btrfs.
2943          * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value
2944          * will be ignored since any failure of this operation should not
2945          * block the left work.
2946          */
2947         int attr;
2948         if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {
2949             attr |= FS_NOCOW_FL;
2950             ioctl(fd, FS_IOC_SETFLAGS, &attr);
2951         }
2952 #endif
2953     }
2954 #ifdef FS_IOC_FSSETXATTR
2955     /*
2956      * Try to set the extent size hint. Failure is not fatal, and a warning is
2957      * only printed if the option was explicitly specified.
2958      */
2959     {
2960         struct fsxattr attr;
2961         result = ioctl(fd, FS_IOC_FSGETXATTR, &attr);
2962         if (result == 0) {
2963             attr.fsx_xflags |= FS_XFLAG_EXTSIZE;
2964             attr.fsx_extsize = file_opts->extent_size_hint;
2965             result = ioctl(fd, FS_IOC_FSSETXATTR, &attr);
2966         }
2967         if (result < 0 && file_opts->has_extent_size_hint &&
2968             file_opts->extent_size_hint)
2969         {
2970             warn_report("Failed to set extent size hint: %s",
2971                         strerror(errno));
2972         }
2973     }
2974 #endif
2975
2976     /* Resize and potentially preallocate the file to the desired
2977      * final size */
2978     result = raw_regular_truncate(NULL, fd, file_opts->size,
2979                                   file_opts->preallocation, errp);
2980     if (result < 0) {
2981         goto out_unlock;
2982     }
2983
2984 out_unlock:
2985     raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
2986     if (local_err) {
2987         /* The above call should not fail, and if it does, that does
2988          * not mean the whole creation operation has failed.  So
2989          * report it the user for their convenience, but do not report
2990          * it to the caller. */
2991         warn_report_err(local_err);
2992     }
2993
2994 out_close:
2995     if (qemu_close(fd) != 0 && result == 0) {
2996         result = -errno;
2997         error_setg_errno(errp, -result, "Could not close the new file");
2998     }
2999 out:
3000     return result;
3001 }
3002
3003 static int coroutine_fn GRAPH_RDLOCK
3004 raw_co_create_opts(BlockDriver *drv, const char *filename,
3005                    QemuOpts *opts, Error **errp)
3006 {
3007     BlockdevCreateOptions options;
3008     int64_t total_size = 0;
3009     int64_t extent_size_hint = 0;
3010     bool has_extent_size_hint = false;
3011     bool nocow = false;
3012     PreallocMode prealloc;
3013     char *buf = NULL;
3014     Error *local_err = NULL;
3015
3016     /* Skip file: protocol prefix */
3017     strstart(filename, "file:", &filename);
3018
3019     /* Read out options */
3020     total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
3021                           BDRV_SECTOR_SIZE);
3022     if (qemu_opt_get(opts, BLOCK_OPT_EXTENT_SIZE_HINT)) {
3023         has_extent_size_hint = true;
3024         extent_size_hint =
3025             qemu_opt_get_size_del(opts, BLOCK_OPT_EXTENT_SIZE_HINT, -1);
3026     }
3027     nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);
3028     buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
3029     prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
3030                                PREALLOC_MODE_OFF, &local_err);
3031     g_free(buf);
3032     if (local_err) {
3033         error_propagate(errp, local_err);
3034         return -EINVAL;
3035     }
3036
3037     options = (BlockdevCreateOptions) {
3038         .driver     = BLOCKDEV_DRIVER_FILE,
3039         .u.file     = {
3040             .filename           = (char *) filename,
3041             .size               = total_size,
3042             .has_preallocation  = true,
3043             .preallocation      = prealloc,
3044             .has_nocow          = true,
3045             .nocow              = nocow,
3046             .has_extent_size_hint = has_extent_size_hint,
3047             .extent_size_hint   = extent_size_hint,
3048         },
3049     };
3050     return raw_co_create(&options, errp);
3051 }
3052
3053 static int coroutine_fn raw_co_delete_file(BlockDriverState *bs,
3054                                            Error **errp)
3055 {
3056     struct stat st;
3057     int ret;
3058
3059     if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) {
3060         error_setg_errno(errp, ENOENT, "%s is not a regular file",
3061                          bs->filename);
3062         return -ENOENT;
3063     }
3064
3065     ret = unlink(bs->filename);
3066     if (ret < 0) {
3067         ret = -errno;
3068         error_setg_errno(errp, -ret, "Error when deleting file %s",
3069                          bs->filename);
3070     }
3071
3072     return ret;
3073 }
3074
3075 /*
3076  * Find allocation range in @bs around offset @start.
3077  * May change underlying file descriptor's file offset.
3078  * If @start is not in a hole, store @start in @data, and the
3079  * beginning of the next hole in @hole, and return 0.
3080  * If @start is in a non-trailing hole, store @start in @hole and the
3081  * beginning of the next non-hole in @data, and return 0.
3082  * If @start is in a trailing hole or beyond EOF, return -ENXIO.
3083  * If we can't find out, return a negative errno other than -ENXIO.
3084  */
3085 static int find_allocation(BlockDriverState *bs, off_t start,
3086                            off_t *data, off_t *hole)
3087 {
3088 #if defined SEEK_HOLE && defined SEEK_DATA
3089     BDRVRawState *s = bs->opaque;
3090     off_t offs;
3091
3092     /*
3093      * SEEK_DATA cases:
3094      * D1. offs == start: start is in data
3095      * D2. offs > start: start is in a hole, next data at offs
3096      * D3. offs < 0, errno = ENXIO: either start is in a trailing hole
3097      *                              or start is beyond EOF
3098      *     If the latter happens, the file has been truncated behind
3099      *     our back since we opened it.  All bets are off then.
3100      *     Treating like a trailing hole is simplest.
3101      * D4. offs < 0, errno != ENXIO: we learned nothing
3102      */
3103     offs = lseek(s->fd, start, SEEK_DATA);
3104     if (offs < 0) {
3105         return -errno;          /* D3 or D4 */
3106     }
3107
3108     if (offs < start) {
3109         /* This is not a valid return by lseek().  We are safe to just return
3110          * -EIO in this case, and we'll treat it like D4. */
3111         return -EIO;
3112     }
3113
3114     if (offs > start) {
3115         /* D2: in hole, next data at offs */
3116         *hole = start;
3117         *data = offs;
3118         return 0;
3119     }
3120
3121     /* D1: in data, end not yet known */
3122
3123     /*
3124      * SEEK_HOLE cases:
3125      * H1. offs == start: start is in a hole
3126      *     If this happens here, a hole has been dug behind our back
3127      *     since the previous lseek().
3128      * H2. offs > start: either start is in data, next hole at offs,
3129      *                   or start is in trailing hole, EOF at offs
3130      *     Linux treats trailing holes like any other hole: offs ==
3131      *     start.  Solaris seeks to EOF instead: offs > start (blech).
3132      *     If that happens here, a hole has been dug behind our back
3133      *     since the previous lseek().
3134      * H3. offs < 0, errno = ENXIO: start is beyond EOF
3135      *     If this happens, the file has been truncated behind our
3136      *     back since we opened it.  Treat it like a trailing hole.
3137      * H4. offs < 0, errno != ENXIO: we learned nothing
3138      *     Pretend we know nothing at all, i.e. "forget" about D1.
3139      */
3140     offs = lseek(s->fd, start, SEEK_HOLE);
3141     if (offs < 0) {
3142         return -errno;          /* D1 and (H3 or H4) */
3143     }
3144
3145     if (offs < start) {
3146         /* This is not a valid return by lseek().  We are safe to just return
3147          * -EIO in this case, and we'll treat it like H4. */
3148         return -EIO;
3149     }
3150
3151     if (offs > start) {
3152         /*
3153          * D1 and H2: either in data, next hole at offs, or it was in
3154          * data but is now in a trailing hole.  In the latter case,
3155          * all bets are off.  Treating it as if it there was data all
3156          * the way to EOF is safe, so simply do that.
3157          */
3158         *data = start;
3159         *hole = offs;
3160         return 0;
3161     }
3162
3163     /* D1 and H1 */
3164     return -EBUSY;
3165 #else
3166     return -ENOTSUP;
3167 #endif
3168 }
3169
3170 /*
3171  * Returns the allocation status of the specified offset.
3172  *
3173  * The block layer guarantees 'offset' and 'bytes' are within bounds.
3174  *
3175  * 'pnum' is set to the number of bytes (including and immediately following
3176  * the specified offset) that are known to be in the same
3177  * allocated/unallocated state.
3178  *
3179  * 'bytes' is a soft cap for 'pnum'.  If the information is free, 'pnum' may
3180  * well exceed it.
3181  */
3182 static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
3183                                             bool want_zero,
3184                                             int64_t offset,
3185                                             int64_t bytes, int64_t *pnum,
3186                                             int64_t *map,
3187                                             BlockDriverState **file)
3188 {
3189     off_t data = 0, hole = 0;
3190     int ret;
3191
3192     assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));
3193
3194     ret = fd_open(bs);
3195     if (ret < 0) {
3196         return ret;
3197     }
3198
3199     if (!want_zero) {
3200         *pnum = bytes;
3201         *map = offset;
3202         *file = bs;
3203         return BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID;
3204     }
3205
3206     ret = find_allocation(bs, offset, &data, &hole);
3207     if (ret == -ENXIO) {
3208         /* Trailing hole */
3209         *pnum = bytes;
3210         ret = BDRV_BLOCK_ZERO;
3211     } else if (ret < 0) {
3212         /* No info available, so pretend there are no holes */
3213         *pnum = bytes;
3214         ret = BDRV_BLOCK_DATA;
3215     } else if (data == offset) {
3216         /* On a data extent, compute bytes to the end of the extent,
3217          * possibly including a partial sector at EOF. */
3218         *pnum = hole - offset;
3219
3220         /*
3221          * We are not allowed to return partial sectors, though, so
3222          * round up if necessary.
3223          */
3224         if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
3225             int64_t file_length = raw_getlength(bs);
3226             if (file_length > 0) {
3227                 /* Ignore errors, this is just a safeguard */
3228                 assert(hole == file_length);
3229             }
3230             *pnum = ROUND_UP(*pnum, bs->bl.request_alignment);
3231         }
3232
3233         ret = BDRV_BLOCK_DATA;
3234     } else {
3235         /* On a hole, compute bytes to the beginning of the next extent.  */
3236         assert(hole == offset);
3237         *pnum = data - offset;
3238         ret = BDRV_BLOCK_ZERO;
3239     }
3240     *map = offset;
3241     *file = bs;
3242     return ret | BDRV_BLOCK_OFFSET_VALID;
3243 }
3244
3245 #if defined(__linux__)
3246 /* Verify that the file is not in the page cache */
3247 static void check_cache_dropped(BlockDriverState *bs, Error **errp)
3248 {
3249     const size_t window_size = 128 * 1024 * 1024;
3250     BDRVRawState *s = bs->opaque;
3251     void *window = NULL;
3252     size_t length = 0;
3253     unsigned char *vec;
3254     size_t page_size;
3255     off_t offset;
3256     off_t end;
3257
3258     /* mincore(2) page status information requires 1 byte per page */
3259     page_size = sysconf(_SC_PAGESIZE);
3260     vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
3261
3262     end = raw_getlength(bs);
3263
3264     for (offset = 0; offset < end; offset += window_size) {
3265         void *new_window;
3266         size_t new_length;
3267         size_t vec_end;
3268         size_t i;
3269         int ret;
3270
3271         /* Unmap previous window if size has changed */
3272         new_length = MIN(end - offset, window_size);
3273         if (new_length != length) {
3274             munmap(window, length);
3275             window = NULL;
3276             length = 0;
3277         }
3278
3279         new_window = mmap(window, new_length, PROT_NONE, MAP_PRIVATE,
3280                           s->fd, offset);
3281         if (new_window == MAP_FAILED) {
3282             error_setg_errno(errp, errno, "mmap failed");
3283             break;
3284         }
3285
3286         window = new_window;
3287         length = new_length;
3288
3289         ret = mincore(window, length, vec);
3290         if (ret < 0) {
3291             error_setg_errno(errp, errno, "mincore failed");
3292             break;
3293         }
3294
3295         vec_end = DIV_ROUND_UP(length, page_size);
3296         for (i = 0; i < vec_end; i++) {
3297             if (vec[i] & 0x1) {
3298                 break;
3299             }
3300         }
3301         if (i < vec_end) {
3302             error_setg(errp, "page cache still in use!");
3303             break;
3304         }
3305     }
3306
3307     if (window) {
3308         munmap(window, length);
3309     }
3310
3311     g_free(vec);
3312 }
3313 #endif /* __linux__ */
3314
3315 static void coroutine_fn GRAPH_RDLOCK
3316 raw_co_invalidate_cache(BlockDriverState *bs, Error **errp)
3317 {
3318     BDRVRawState *s = bs->opaque;
3319     int ret;
3320
3321     ret = fd_open(bs);
3322     if (ret < 0) {
3323         error_setg_errno(errp, -ret, "The file descriptor is not open");
3324         return;
3325     }
3326
3327     if (!s->drop_cache) {
3328         return;
3329     }
3330
3331     if (s->open_flags & O_DIRECT) {
3332         return; /* No host kernel page cache */
3333     }
3334
3335 #if defined(__linux__)
3336     /* This sets the scene for the next syscall... */
3337     ret = bdrv_co_flush(bs);
3338     if (ret < 0) {
3339         error_setg_errno(errp, -ret, "flush failed");
3340         return;
3341     }
3342
3343     /* Linux does not invalidate pages that are dirty, locked, or mmapped by a
3344      * process.  These limitations are okay because we just fsynced the file,
3345      * we don't use mmap, and the file should not be in use by other processes.
3346      */
3347     ret = posix_fadvise(s->fd, 0, 0, POSIX_FADV_DONTNEED);
3348     if (ret != 0) { /* the return value is a positive errno */
3349         error_setg_errno(errp, ret, "fadvise failed");
3350         return;
3351     }
3352
3353     if (s->check_cache_dropped) {
3354         check_cache_dropped(bs, errp);
3355     }
3356 #else /* __linux__ */
3357     /* Do nothing.  Live migration to a remote host with cache.direct=off is
3358      * unsupported on other host operating systems.  Cache consistency issues
3359      * may occur but no error is reported here, partly because that's the
3360      * historical behavior and partly because it's hard to differentiate valid
3361      * configurations that should not cause errors.
3362      */
3363 #endif /* !__linux__ */
3364 }
3365
3366 static void raw_account_discard(BDRVRawState *s, uint64_t nbytes, int ret)
3367 {
3368     if (ret) {
3369         s->stats.discard_nb_failed++;
3370     } else {
3371         s->stats.discard_nb_ok++;
3372         s->stats.discard_bytes_ok += nbytes;
3373     }
3374 }
3375
3376 /*
3377  * zone report - Get a zone block device's information in the form
3378  * of an array of zone descriptors.
3379  * zones is an array of zone descriptors to hold zone information on reply;
3380  * offset can be any byte within the entire size of the device;
3381  * nr_zones is the maximum number of sectors the command should operate on.
3382  */
3383 #if defined(CONFIG_BLKZONED)
3384 static int coroutine_fn raw_co_zone_report(BlockDriverState *bs, int64_t offset,
3385                                            unsigned int *nr_zones,
3386                                            BlockZoneDescriptor *zones) {
3387     BDRVRawState *s = bs->opaque;
3388     RawPosixAIOData acb = (RawPosixAIOData) {
3389         .bs         = bs,
3390         .aio_fildes = s->fd,
3391         .aio_type   = QEMU_AIO_ZONE_REPORT,
3392         .aio_offset = offset,
3393         .zone_report    = {
3394             .nr_zones       = nr_zones,
3395             .zones          = zones,
3396         },
3397     };
3398
3399     trace_zbd_zone_report(bs, *nr_zones, offset >> BDRV_SECTOR_BITS);
3400     return raw_thread_pool_submit(handle_aiocb_zone_report, &acb);
3401 }
3402 #endif
3403
3404 /*
3405  * zone management operations - Execute an operation on a zone
3406  */
3407 #if defined(CONFIG_BLKZONED)
3408 static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
3409         int64_t offset, int64_t len) {
3410     BDRVRawState *s = bs->opaque;
3411     RawPosixAIOData acb;
3412     int64_t zone_size, zone_size_mask;
3413     const char *op_name;
3414     unsigned long zo;
3415     int ret;
3416     BlockZoneWps *wps = bs->wps;
3417     int64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS;
3418
3419     zone_size = bs->bl.zone_size;
3420     zone_size_mask = zone_size - 1;
3421     if (offset & zone_size_mask) {
3422         error_report("sector offset %" PRId64 " is not aligned to zone size "
3423                      "%" PRId64 "", offset / 512, zone_size / 512);
3424         return -EINVAL;
3425     }
3426
3427     if (((offset + len) < capacity && len & zone_size_mask) ||
3428         offset + len > capacity) {
3429         error_report("number of sectors %" PRId64 " is not aligned to zone size"
3430                       " %" PRId64 "", len / 512, zone_size / 512);
3431         return -EINVAL;
3432     }
3433
3434     uint32_t i = offset / bs->bl.zone_size;
3435     uint32_t nrz = len / bs->bl.zone_size;
3436     uint64_t *wp = &wps->wp[i];
3437     if (BDRV_ZT_IS_CONV(*wp) && len != capacity) {
3438         error_report("zone mgmt operations are not allowed for conventional zones");
3439         return -EIO;
3440     }
3441
3442     switch (op) {
3443     case BLK_ZO_OPEN:
3444         op_name = "BLKOPENZONE";
3445         zo = BLKOPENZONE;
3446         break;
3447     case BLK_ZO_CLOSE:
3448         op_name = "BLKCLOSEZONE";
3449         zo = BLKCLOSEZONE;
3450         break;
3451     case BLK_ZO_FINISH:
3452         op_name = "BLKFINISHZONE";
3453         zo = BLKFINISHZONE;
3454         break;
3455     case BLK_ZO_RESET:
3456         op_name = "BLKRESETZONE";
3457         zo = BLKRESETZONE;
3458         break;
3459     default:
3460         error_report("Unsupported zone op: 0x%x", op);
3461         return -ENOTSUP;
3462     }
3463
3464     acb = (RawPosixAIOData) {
3465         .bs             = bs,
3466         .aio_fildes     = s->fd,
3467         .aio_type       = QEMU_AIO_ZONE_MGMT,
3468         .aio_offset     = offset,
3469         .aio_nbytes     = len,
3470         .zone_mgmt  = {
3471             .op = zo,
3472         },
3473     };
3474
3475     trace_zbd_zone_mgmt(bs, op_name, offset >> BDRV_SECTOR_BITS,
3476                         len >> BDRV_SECTOR_BITS);
3477     ret = raw_thread_pool_submit(handle_aiocb_zone_mgmt, &acb);
3478     if (ret != 0) {
3479         update_zones_wp(bs, s->fd, offset, nrz);
3480         error_report("ioctl %s failed %d", op_name, ret);
3481         return ret;
3482     }
3483
3484     if (zo == BLKRESETZONE && len == capacity) {
3485         ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 1);
3486         if (ret < 0) {
3487             error_report("reporting single wp failed");
3488             return ret;
3489         }
3490     } else if (zo == BLKRESETZONE) {
3491         for (unsigned int j = 0; j < nrz; ++j) {
3492             wp[j] = offset + j * zone_size;
3493         }
3494     } else if (zo == BLKFINISHZONE) {
3495         for (unsigned int j = 0; j < nrz; ++j) {
3496             /* The zoned device allows the last zone smaller that the
3497              * zone size. */
3498             wp[j] = MIN(offset + (j + 1) * zone_size, offset + len);
3499         }
3500     }
3501
3502     return ret;
3503 }
3504 #endif
3505
3506 #if defined(CONFIG_BLKZONED)
3507 static int coroutine_fn raw_co_zone_append(BlockDriverState *bs,
3508                                            int64_t *offset,
3509                                            QEMUIOVector *qiov,
3510                                            BdrvRequestFlags flags) {
3511     assert(flags == 0);
3512     int64_t zone_size_mask = bs->bl.zone_size - 1;
3513     int64_t iov_len = 0;
3514     int64_t len = 0;
3515
3516     if (*offset & zone_size_mask) {
3517         error_report("sector offset %" PRId64 " is not aligned to zone size "
3518                      "%" PRId32 "", *offset / 512, bs->bl.zone_size / 512);
3519         return -EINVAL;
3520     }
3521
3522     int64_t wg = bs->bl.write_granularity;
3523     int64_t wg_mask = wg - 1;
3524     for (int i = 0; i < qiov->niov; i++) {
3525         iov_len = qiov->iov[i].iov_len;
3526         if (iov_len & wg_mask) {
3527             error_report("len of IOVector[%d] %" PRId64 " is not aligned to "
3528                          "block size %" PRId64 "", i, iov_len, wg);
3529             return -EINVAL;
3530         }
3531         len += iov_len;
3532     }
3533
3534     trace_zbd_zone_append(bs, *offset >> BDRV_SECTOR_BITS);
3535     return raw_co_prw(bs, offset, len, qiov, QEMU_AIO_ZONE_APPEND);
3536 }
3537 #endif
3538
3539 static coroutine_fn int
3540 raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes,
3541                 bool blkdev)
3542 {
3543     BDRVRawState *s = bs->opaque;
3544     RawPosixAIOData acb;
3545     int ret;
3546
3547     acb = (RawPosixAIOData) {
3548         .bs             = bs,
3549         .aio_fildes     = s->fd,
3550         .aio_type       = QEMU_AIO_DISCARD,
3551         .aio_offset     = offset,
3552         .aio_nbytes     = bytes,
3553     };
3554
3555     if (blkdev) {
3556         acb.aio_type |= QEMU_AIO_BLKDEV;
3557     }
3558
3559     ret = raw_thread_pool_submit(handle_aiocb_discard, &acb);
3560     raw_account_discard(s, bytes, ret);
3561     return ret;
3562 }
3563
3564 static coroutine_fn int
3565 raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
3566 {
3567     return raw_do_pdiscard(bs, offset, bytes, false);
3568 }
3569
3570 static int coroutine_fn
3571 raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
3572                      BdrvRequestFlags flags, bool blkdev)
3573 {
3574     BDRVRawState *s = bs->opaque;
3575     RawPosixAIOData acb;
3576     ThreadPoolFunc *handler;
3577
3578 #ifdef CONFIG_FALLOCATE
3579     if (offset + bytes > bs->total_sectors * BDRV_SECTOR_SIZE) {
3580         BdrvTrackedRequest *req;
3581
3582         /*
3583          * This is a workaround for a bug in the Linux XFS driver,
3584          * where writes submitted through the AIO interface will be
3585          * discarded if they happen beyond a concurrently running
3586          * fallocate() that increases the file length (i.e., both the
3587          * write and the fallocate() happen beyond the EOF).
3588          *
3589          * To work around it, we extend the tracked request for this
3590          * zero write until INT64_MAX (effectively infinity), and mark
3591          * it as serializing.
3592          *
3593          * We have to enable this workaround for all filesystems and
3594          * AIO modes (not just XFS with aio=native), because for
3595          * remote filesystems we do not know the host configuration.
3596          */
3597
3598         req = bdrv_co_get_self_request(bs);
3599         assert(req);
3600         assert(req->type == BDRV_TRACKED_WRITE);
3601         assert(req->offset <= offset);
3602         assert(req->offset + req->bytes >= offset + bytes);
3603
3604         req->bytes = BDRV_MAX_LENGTH - req->offset;
3605
3606         bdrv_check_request(req->offset, req->bytes, &error_abort);
3607
3608         bdrv_make_request_serialising(req, bs->bl.request_alignment);
3609     }
3610 #endif
3611
3612     acb = (RawPosixAIOData) {
3613         .bs             = bs,
3614         .aio_fildes     = s->fd,
3615         .aio_type       = QEMU_AIO_WRITE_ZEROES,
3616         .aio_offset     = offset,
3617         .aio_nbytes     = bytes,
3618     };
3619
3620     if (blkdev) {
3621         acb.aio_type |= QEMU_AIO_BLKDEV;
3622     }
3623     if (flags & BDRV_REQ_NO_FALLBACK) {
3624         acb.aio_type |= QEMU_AIO_NO_FALLBACK;
3625     }
3626
3627     if (flags & BDRV_REQ_MAY_UNMAP) {
3628         acb.aio_type |= QEMU_AIO_DISCARD;
3629         handler = handle_aiocb_write_zeroes_unmap;
3630     } else {
3631         handler = handle_aiocb_write_zeroes;
3632     }
3633
3634     return raw_thread_pool_submit(handler, &acb);
3635 }
3636
3637 static int coroutine_fn raw_co_pwrite_zeroes(
3638     BlockDriverState *bs, int64_t offset,
3639     int64_t bytes, BdrvRequestFlags flags)
3640 {
3641     return raw_do_pwrite_zeroes(bs, offset, bytes, flags, false);
3642 }
3643
3644 static int coroutine_fn
3645 raw_co_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
3646 {
3647     return 0;
3648 }
3649
3650 static ImageInfoSpecific *raw_get_specific_info(BlockDriverState *bs,
3651                                                 Error **errp)
3652 {
3653     ImageInfoSpecificFile *file_info = g_new0(ImageInfoSpecificFile, 1);
3654     ImageInfoSpecific *spec_info = g_new(ImageInfoSpecific, 1);
3655
3656     *spec_info = (ImageInfoSpecific){
3657         .type = IMAGE_INFO_SPECIFIC_KIND_FILE,
3658         .u.file.data = file_info,
3659     };
3660
3661 #ifdef FS_IOC_FSGETXATTR
3662     {
3663         BDRVRawState *s = bs->opaque;
3664         struct fsxattr attr;
3665         int ret;
3666
3667         ret = ioctl(s->fd, FS_IOC_FSGETXATTR, &attr);
3668         if (!ret && attr.fsx_extsize != 0) {
3669             file_info->has_extent_size_hint = true;
3670             file_info->extent_size_hint = attr.fsx_extsize;
3671         }
3672     }
3673 #endif
3674
3675     return spec_info;
3676 }
3677
3678 static BlockStatsSpecificFile get_blockstats_specific_file(BlockDriverState *bs)
3679 {
3680     BDRVRawState *s = bs->opaque;
3681     return (BlockStatsSpecificFile) {
3682         .discard_nb_ok = s->stats.discard_nb_ok,
3683         .discard_nb_failed = s->stats.discard_nb_failed,
3684         .discard_bytes_ok = s->stats.discard_bytes_ok,
3685     };
3686 }
3687
3688 static BlockStatsSpecific *raw_get_specific_stats(BlockDriverState *bs)
3689 {
3690     BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3691
3692     stats->driver = BLOCKDEV_DRIVER_FILE;
3693     stats->u.file = get_blockstats_specific_file(bs);
3694
3695     return stats;
3696 }
3697
3698 #if defined(HAVE_HOST_BLOCK_DEVICE)
3699 static BlockStatsSpecific *hdev_get_specific_stats(BlockDriverState *bs)
3700 {
3701     BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
3702
3703     stats->driver = BLOCKDEV_DRIVER_HOST_DEVICE;
3704     stats->u.host_device = get_blockstats_specific_file(bs);
3705
3706     return stats;
3707 }
3708 #endif /* HAVE_HOST_BLOCK_DEVICE */
3709
3710 static QemuOptsList raw_create_opts = {
3711     .name = "raw-create-opts",
3712     .head = QTAILQ_HEAD_INITIALIZER(raw_create_opts.head),
3713     .desc = {
3714         {
3715             .name = BLOCK_OPT_SIZE,
3716             .type = QEMU_OPT_SIZE,
3717             .help = "Virtual disk size"
3718         },
3719         {
3720             .name = BLOCK_OPT_NOCOW,
3721             .type = QEMU_OPT_BOOL,
3722             .help = "Turn off copy-on-write (valid only on btrfs)"
3723         },
3724         {
3725             .name = BLOCK_OPT_PREALLOC,
3726             .type = QEMU_OPT_STRING,
3727             .help = "Preallocation mode (allowed values: off"
3728 #ifdef CONFIG_POSIX_FALLOCATE
3729                     ", falloc"
3730 #endif
3731                     ", full)"
3732         },
3733         {
3734             .name = BLOCK_OPT_EXTENT_SIZE_HINT,
3735             .type = QEMU_OPT_SIZE,
3736             .help = "Extent size hint for the image file, 0 to disable"
3737         },
3738         { /* end of list */ }
3739     }
3740 };
3741
3742 static int raw_check_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared,
3743                           Error **errp)
3744 {
3745     BDRVRawState *s = bs->opaque;
3746     int input_flags = s->reopen_state ? s->reopen_state->flags : bs->open_flags;
3747     int open_flags;
3748     int ret;
3749
3750     /* We may need a new fd if auto-read-only switches the mode */
3751     ret = raw_reconfigure_getfd(bs, input_flags, &open_flags, perm,
3752                                 false, errp);
3753     if (ret < 0) {
3754         return ret;
3755     } else if (ret != s->fd) {
3756         Error *local_err = NULL;
3757
3758         /*
3759          * Fail already check_perm() if we can't get a working O_DIRECT
3760          * alignment with the new fd.
3761          */
3762         raw_probe_alignment(bs, ret, &local_err);
3763         if (local_err) {
3764             error_propagate(errp, local_err);
3765             return -EINVAL;
3766         }
3767
3768         s->perm_change_fd = ret;
3769         s->perm_change_flags = open_flags;
3770     }
3771
3772     /* Prepare permissions on old fd to avoid conflicts between old and new,
3773      * but keep everything locked that new will need. */
3774     ret = raw_handle_perm_lock(bs, RAW_PL_PREPARE, perm, shared, errp);
3775     if (ret < 0) {
3776         goto fail;
3777     }
3778
3779     /* Copy locks to the new fd */
3780     if (s->perm_change_fd && s->use_lock) {
3781         ret = raw_apply_lock_bytes(NULL, s->perm_change_fd, perm, ~shared,
3782                                    false, errp);
3783         if (ret < 0) {
3784             raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3785             goto fail;
3786         }
3787     }
3788     return 0;
3789
3790 fail:
3791     if (s->perm_change_fd) {
3792         qemu_close(s->perm_change_fd);
3793     }
3794     s->perm_change_fd = 0;
3795     return ret;
3796 }
3797
3798 static void raw_set_perm(BlockDriverState *bs, uint64_t perm, uint64_t shared)
3799 {
3800     BDRVRawState *s = bs->opaque;
3801
3802     /* For reopen, we have already switched to the new fd (.bdrv_set_perm is
3803      * called after .bdrv_reopen_commit) */
3804     if (s->perm_change_fd && s->fd != s->perm_change_fd) {
3805         qemu_close(s->fd);
3806         s->fd = s->perm_change_fd;
3807         s->open_flags = s->perm_change_flags;
3808     }
3809     s->perm_change_fd = 0;
3810
3811     raw_handle_perm_lock(bs, RAW_PL_COMMIT, perm, shared, NULL);
3812     s->perm = perm;
3813     s->shared_perm = shared;
3814 }
3815
3816 static void raw_abort_perm_update(BlockDriverState *bs)
3817 {
3818     BDRVRawState *s = bs->opaque;
3819
3820     /* For reopen, .bdrv_reopen_abort is called afterwards and will close
3821      * the file descriptor. */
3822     if (s->perm_change_fd) {
3823         qemu_close(s->perm_change_fd);
3824     }
3825     s->perm_change_fd = 0;
3826
3827     raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
3828 }
3829
3830 static int coroutine_fn GRAPH_RDLOCK raw_co_copy_range_from(
3831         BlockDriverState *bs, BdrvChild *src, int64_t src_offset,
3832         BdrvChild *dst, int64_t dst_offset, int64_t bytes,
3833         BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
3834 {
3835     return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
3836                                  read_flags, write_flags);
3837 }
3838
3839 static int coroutine_fn GRAPH_RDLOCK
3840 raw_co_copy_range_to(BlockDriverState *bs,
3841                      BdrvChild *src, int64_t src_offset,
3842                      BdrvChild *dst, int64_t dst_offset,
3843                      int64_t bytes, BdrvRequestFlags read_flags,
3844                      BdrvRequestFlags write_flags)
3845 {
3846     RawPosixAIOData acb;
3847     BDRVRawState *s = bs->opaque;
3848     BDRVRawState *src_s;
3849
3850     assert(dst->bs == bs);
3851     if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
3852         return -ENOTSUP;
3853     }
3854
3855     src_s = src->bs->opaque;
3856     if (fd_open(src->bs) < 0 || fd_open(dst->bs) < 0) {
3857         return -EIO;
3858     }
3859
3860     acb = (RawPosixAIOData) {
3861         .bs             = bs,
3862         .aio_type       = QEMU_AIO_COPY_RANGE,
3863         .aio_fildes     = src_s->fd,
3864         .aio_offset     = src_offset,
3865         .aio_nbytes     = bytes,
3866         .copy_range     = {
3867             .aio_fd2        = s->fd,
3868             .aio_offset2    = dst_offset,
3869         },
3870     };
3871
3872     return raw_thread_pool_submit(handle_aiocb_copy_range, &acb);
3873 }
3874
3875 BlockDriver bdrv_file = {
3876     .format_name = "file",
3877     .protocol_name = "file",
3878     .instance_size = sizeof(BDRVRawState),
3879     .bdrv_needs_filename = true,
3880     .bdrv_probe = NULL, /* no probe for protocols */
3881     .bdrv_parse_filename = raw_parse_filename,
3882     .bdrv_file_open = raw_open,
3883     .bdrv_reopen_prepare = raw_reopen_prepare,
3884     .bdrv_reopen_commit = raw_reopen_commit,
3885     .bdrv_reopen_abort = raw_reopen_abort,
3886     .bdrv_close = raw_close,
3887     .bdrv_co_create = raw_co_create,
3888     .bdrv_co_create_opts = raw_co_create_opts,
3889     .bdrv_has_zero_init = bdrv_has_zero_init_1,
3890     .bdrv_co_block_status = raw_co_block_status,
3891     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
3892     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
3893     .bdrv_co_delete_file = raw_co_delete_file,
3894
3895     .bdrv_co_preadv         = raw_co_preadv,
3896     .bdrv_co_pwritev        = raw_co_pwritev,
3897     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
3898     .bdrv_co_pdiscard       = raw_co_pdiscard,
3899     .bdrv_co_copy_range_from = raw_co_copy_range_from,
3900     .bdrv_co_copy_range_to  = raw_co_copy_range_to,
3901     .bdrv_refresh_limits = raw_refresh_limits,
3902
3903     .bdrv_co_truncate                   = raw_co_truncate,
3904     .bdrv_co_getlength                  = raw_co_getlength,
3905     .bdrv_co_get_info                   = raw_co_get_info,
3906     .bdrv_get_specific_info             = raw_get_specific_info,
3907     .bdrv_co_get_allocated_file_size    = raw_co_get_allocated_file_size,
3908     .bdrv_get_specific_stats = raw_get_specific_stats,
3909     .bdrv_check_perm = raw_check_perm,
3910     .bdrv_set_perm   = raw_set_perm,
3911     .bdrv_abort_perm_update = raw_abort_perm_update,
3912     .create_opts = &raw_create_opts,
3913     .mutable_opts = mutable_opts,
3914 };
3915
3916 /***********************************************/
3917 /* host device */
3918
3919 #if defined(HAVE_HOST_BLOCK_DEVICE)
3920
3921 #if defined(__APPLE__) && defined(__MACH__)
3922 static kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3923                                 CFIndex maxPathSize, int flags);
3924
3925 #if !defined(MAC_OS_VERSION_12_0) \
3926     || (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_12_0)
3927 #define IOMainPort IOMasterPort
3928 #endif
3929
3930 static char *FindEjectableOpticalMedia(io_iterator_t *mediaIterator)
3931 {
3932     kern_return_t kernResult = KERN_FAILURE;
3933     mach_port_t mainPort;
3934     CFMutableDictionaryRef  classesToMatch;
3935     const char *matching_array[] = {kIODVDMediaClass, kIOCDMediaClass};
3936     char *mediaType = NULL;
3937
3938     kernResult = IOMainPort(MACH_PORT_NULL, &mainPort);
3939     if ( KERN_SUCCESS != kernResult ) {
3940         printf("IOMainPort returned %d\n", kernResult);
3941     }
3942
3943     int index;
3944     for (index = 0; index < ARRAY_SIZE(matching_array); index++) {
3945         classesToMatch = IOServiceMatching(matching_array[index]);
3946         if (classesToMatch == NULL) {
3947             error_report("IOServiceMatching returned NULL for %s",
3948                          matching_array[index]);
3949             continue;
3950         }
3951         CFDictionarySetValue(classesToMatch, CFSTR(kIOMediaEjectableKey),
3952                              kCFBooleanTrue);
3953         kernResult = IOServiceGetMatchingServices(mainPort, classesToMatch,
3954                                                   mediaIterator);
3955         if (kernResult != KERN_SUCCESS) {
3956             error_report("Note: IOServiceGetMatchingServices returned %d",
3957                          kernResult);
3958             continue;
3959         }
3960
3961         /* If a match was found, leave the loop */
3962         if (*mediaIterator != 0) {
3963             trace_file_FindEjectableOpticalMedia(matching_array[index]);
3964             mediaType = g_strdup(matching_array[index]);
3965             break;
3966         }
3967     }
3968     return mediaType;
3969 }
3970
3971 kern_return_t GetBSDPath(io_iterator_t mediaIterator, char *bsdPath,
3972                          CFIndex maxPathSize, int flags)
3973 {
3974     io_object_t     nextMedia;
3975     kern_return_t   kernResult = KERN_FAILURE;
3976     *bsdPath = '\0';
3977     nextMedia = IOIteratorNext( mediaIterator );
3978     if ( nextMedia )
3979     {
3980         CFTypeRef   bsdPathAsCFString;
3981     bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
3982         if ( bsdPathAsCFString ) {
3983             size_t devPathLength;
3984             strcpy( bsdPath, _PATH_DEV );
3985             if (flags & BDRV_O_NOCACHE) {
3986                 strcat(bsdPath, "r");
3987             }
3988             devPathLength = strlen( bsdPath );
3989             if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
3990                 kernResult = KERN_SUCCESS;
3991             }
3992             CFRelease( bsdPathAsCFString );
3993         }
3994         IOObjectRelease( nextMedia );
3995     }
3996
3997     return kernResult;
3998 }
3999
4000 /* Sets up a real cdrom for use in QEMU */
4001 static bool setup_cdrom(char *bsd_path, Error **errp)
4002 {
4003     int index, num_of_test_partitions = 2, fd;
4004     char test_partition[MAXPATHLEN];
4005     bool partition_found = false;
4006
4007     /* look for a working partition */
4008     for (index = 0; index < num_of_test_partitions; index++) {
4009         snprintf(test_partition, sizeof(test_partition), "%ss%d", bsd_path,
4010                  index);
4011         fd = qemu_open(test_partition, O_RDONLY | O_BINARY | O_LARGEFILE, NULL);
4012         if (fd >= 0) {
4013             partition_found = true;
4014             qemu_close(fd);
4015             break;
4016         }
4017     }
4018
4019     /* if a working partition on the device was not found */
4020     if (partition_found == false) {
4021         error_setg(errp, "Failed to find a working partition on disc");
4022     } else {
4023         trace_file_setup_cdrom(test_partition);
4024         pstrcpy(bsd_path, MAXPATHLEN, test_partition);
4025     }
4026     return partition_found;
4027 }
4028
4029 /* Prints directions on mounting and unmounting a device */
4030 static void print_unmounting_directions(const char *file_name)
4031 {
4032     error_report("If device %s is mounted on the desktop, unmount"
4033                  " it first before using it in QEMU", file_name);
4034     error_report("Command to unmount device: diskutil unmountDisk %s",
4035                  file_name);
4036     error_report("Command to mount device: diskutil mountDisk %s", file_name);
4037 }
4038
4039 #endif /* defined(__APPLE__) && defined(__MACH__) */
4040
4041 static int hdev_probe_device(const char *filename)
4042 {
4043     struct stat st;
4044
4045     /* allow a dedicated CD-ROM driver to match with a higher priority */
4046     if (strstart(filename, "/dev/cdrom", NULL))
4047         return 50;
4048
4049     if (stat(filename, &st) >= 0 &&
4050             (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
4051         return 100;
4052     }
4053
4054     return 0;
4055 }
4056
4057 static void hdev_parse_filename(const char *filename, QDict *options,
4058                                 Error **errp)
4059 {
4060     bdrv_parse_filename_strip_prefix(filename, "host_device:", options);
4061 }
4062
4063 static bool hdev_is_sg(BlockDriverState *bs)
4064 {
4065
4066 #if defined(__linux__)
4067
4068     BDRVRawState *s = bs->opaque;
4069     struct stat st;
4070     struct sg_scsi_id scsiid;
4071     int sg_version;
4072     int ret;
4073
4074     if (stat(bs->filename, &st) < 0 || !S_ISCHR(st.st_mode)) {
4075         return false;
4076     }
4077
4078     ret = ioctl(s->fd, SG_GET_VERSION_NUM, &sg_version);
4079     if (ret < 0) {
4080         return false;
4081     }
4082
4083     ret = ioctl(s->fd, SG_GET_SCSI_ID, &scsiid);
4084     if (ret >= 0) {
4085         trace_file_hdev_is_sg(scsiid.scsi_type, sg_version);
4086         return true;
4087     }
4088
4089 #endif
4090
4091     return false;
4092 }
4093
4094 static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
4095                      Error **errp)
4096 {
4097     BDRVRawState *s = bs->opaque;
4098     int ret;
4099
4100 #if defined(__APPLE__) && defined(__MACH__)
4101     /*
4102      * Caution: while qdict_get_str() is fine, getting non-string types
4103      * would require more care.  When @options come from -blockdev or
4104      * blockdev_add, its members are typed according to the QAPI
4105      * schema, but when they come from -drive, they're all QString.
4106      */
4107     const char *filename = qdict_get_str(options, "filename");
4108     char bsd_path[MAXPATHLEN] = "";
4109     bool error_occurred = false;
4110
4111     /* If using a real cdrom */
4112     if (strcmp(filename, "/dev/cdrom") == 0) {
4113         char *mediaType = NULL;
4114         kern_return_t ret_val;
4115         io_iterator_t mediaIterator = 0;
4116
4117         mediaType = FindEjectableOpticalMedia(&mediaIterator);
4118         if (mediaType == NULL) {
4119             error_setg(errp, "Please make sure your CD/DVD is in the optical"
4120                        " drive");
4121             error_occurred = true;
4122             goto hdev_open_Mac_error;
4123         }
4124
4125         ret_val = GetBSDPath(mediaIterator, bsd_path, sizeof(bsd_path), flags);
4126         if (ret_val != KERN_SUCCESS) {
4127             error_setg(errp, "Could not get BSD path for optical drive");
4128             error_occurred = true;
4129             goto hdev_open_Mac_error;
4130         }
4131
4132         /* If a real optical drive was not found */
4133         if (bsd_path[0] == '\0') {
4134             error_setg(errp, "Failed to obtain bsd path for optical drive");
4135             error_occurred = true;
4136             goto hdev_open_Mac_error;
4137         }
4138
4139         /* If using a cdrom disc and finding a partition on the disc failed */
4140         if (strncmp(mediaType, kIOCDMediaClass, 9) == 0 &&
4141             setup_cdrom(bsd_path, errp) == false) {
4142             print_unmounting_directions(bsd_path);
4143             error_occurred = true;
4144             goto hdev_open_Mac_error;
4145         }
4146
4147         qdict_put_str(options, "filename", bsd_path);
4148
4149 hdev_open_Mac_error:
4150         g_free(mediaType);
4151         if (mediaIterator) {
4152             IOObjectRelease(mediaIterator);
4153         }
4154         if (error_occurred) {
4155             return -ENOENT;
4156         }
4157     }
4158 #endif /* defined(__APPLE__) && defined(__MACH__) */
4159
4160     s->type = FTYPE_FILE;
4161
4162     ret = raw_open_common(bs, options, flags, 0, true, errp);
4163     if (ret < 0) {
4164 #if defined(__APPLE__) && defined(__MACH__)
4165         if (*bsd_path) {
4166             filename = bsd_path;
4167         }
4168         /* if a physical device experienced an error while being opened */
4169         if (strncmp(filename, "/dev/", 5) == 0) {
4170             print_unmounting_directions(filename);
4171         }
4172 #endif /* defined(__APPLE__) && defined(__MACH__) */
4173         return ret;
4174     }
4175
4176     /* Since this does ioctl the device must be already opened */
4177     bs->sg = hdev_is_sg(bs);
4178
4179     return ret;
4180 }
4181
4182 #if defined(__linux__)
4183 static int coroutine_fn
4184 hdev_co_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
4185 {
4186     BDRVRawState *s = bs->opaque;
4187     RawPosixAIOData acb;
4188     int ret;
4189
4190     ret = fd_open(bs);
4191     if (ret < 0) {
4192         return ret;
4193     }
4194
4195     if (req == SG_IO && s->pr_mgr) {
4196         struct sg_io_hdr *io_hdr = buf;
4197         if (io_hdr->cmdp[0] == PERSISTENT_RESERVE_OUT ||
4198             io_hdr->cmdp[0] == PERSISTENT_RESERVE_IN) {
4199             return pr_manager_execute(s->pr_mgr, qemu_get_current_aio_context(),
4200                                       s->fd, io_hdr);
4201         }
4202     }
4203
4204     acb = (RawPosixAIOData) {
4205         .bs         = bs,
4206         .aio_type   = QEMU_AIO_IOCTL,
4207         .aio_fildes = s->fd,
4208         .aio_offset = 0,
4209         .ioctl      = {
4210             .buf        = buf,
4211             .cmd        = req,
4212         },
4213     };
4214
4215     return raw_thread_pool_submit(handle_aiocb_ioctl, &acb);
4216 }
4217 #endif /* linux */
4218
4219 static coroutine_fn int
4220 hdev_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
4221 {
4222     BDRVRawState *s = bs->opaque;
4223     int ret;
4224
4225     ret = fd_open(bs);
4226     if (ret < 0) {
4227         raw_account_discard(s, bytes, ret);
4228         return ret;
4229     }
4230     return raw_do_pdiscard(bs, offset, bytes, true);
4231 }
4232
4233 static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
4234     int64_t offset, int64_t bytes, BdrvRequestFlags flags)
4235 {
4236     int rc;
4237
4238     rc = fd_open(bs);
4239     if (rc < 0) {
4240         return rc;
4241     }
4242
4243     return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
4244 }
4245
4246 static BlockDriver bdrv_host_device = {
4247     .format_name        = "host_device",
4248     .protocol_name        = "host_device",
4249     .instance_size      = sizeof(BDRVRawState),
4250     .bdrv_needs_filename = true,
4251     .bdrv_probe_device  = hdev_probe_device,
4252     .bdrv_parse_filename = hdev_parse_filename,
4253     .bdrv_file_open     = hdev_open,
4254     .bdrv_close         = raw_close,
4255     .bdrv_reopen_prepare = raw_reopen_prepare,
4256     .bdrv_reopen_commit  = raw_reopen_commit,
4257     .bdrv_reopen_abort   = raw_reopen_abort,
4258     .bdrv_co_create_opts = bdrv_co_create_opts_simple,
4259     .create_opts         = &bdrv_create_opts_simple,
4260     .mutable_opts        = mutable_opts,
4261     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
4262     .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
4263
4264     .bdrv_co_preadv         = raw_co_preadv,
4265     .bdrv_co_pwritev        = raw_co_pwritev,
4266     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
4267     .bdrv_co_pdiscard       = hdev_co_pdiscard,
4268     .bdrv_co_copy_range_from = raw_co_copy_range_from,
4269     .bdrv_co_copy_range_to  = raw_co_copy_range_to,
4270     .bdrv_refresh_limits = raw_refresh_limits,
4271
4272     .bdrv_co_truncate                   = raw_co_truncate,
4273     .bdrv_co_getlength                  = raw_co_getlength,
4274     .bdrv_co_get_info                   = raw_co_get_info,
4275     .bdrv_get_specific_info             = raw_get_specific_info,
4276     .bdrv_co_get_allocated_file_size    = raw_co_get_allocated_file_size,
4277     .bdrv_get_specific_stats = hdev_get_specific_stats,
4278     .bdrv_check_perm = raw_check_perm,
4279     .bdrv_set_perm   = raw_set_perm,
4280     .bdrv_abort_perm_update = raw_abort_perm_update,
4281     .bdrv_probe_blocksizes = hdev_probe_blocksizes,
4282     .bdrv_probe_geometry = hdev_probe_geometry,
4283
4284     /* generic scsi device */
4285 #ifdef __linux__
4286     .bdrv_co_ioctl          = hdev_co_ioctl,
4287 #endif
4288
4289     /* zoned device */
4290 #if defined(CONFIG_BLKZONED)
4291     /* zone management operations */
4292     .bdrv_co_zone_report = raw_co_zone_report,
4293     .bdrv_co_zone_mgmt = raw_co_zone_mgmt,
4294     .bdrv_co_zone_append = raw_co_zone_append,
4295 #endif
4296 };
4297
4298 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
4299 static void cdrom_parse_filename(const char *filename, QDict *options,
4300                                  Error **errp)
4301 {
4302     bdrv_parse_filename_strip_prefix(filename, "host_cdrom:", options);
4303 }
4304
4305 static void cdrom_refresh_limits(BlockDriverState *bs, Error **errp)
4306 {
4307     bs->bl.has_variable_length = true;
4308     raw_refresh_limits(bs, errp);
4309 }
4310 #endif
4311
4312 #ifdef __linux__
4313 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
4314                       Error **errp)
4315 {
4316     BDRVRawState *s = bs->opaque;
4317
4318     s->type = FTYPE_CD;
4319
4320     /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
4321     return raw_open_common(bs, options, flags, O_NONBLOCK, true, errp);
4322 }
4323
4324 static int cdrom_probe_device(const char *filename)
4325 {
4326     int fd, ret;
4327     int prio = 0;
4328     struct stat st;
4329
4330     fd = qemu_open(filename, O_RDONLY | O_NONBLOCK, NULL);
4331     if (fd < 0) {
4332         goto out;
4333     }
4334     ret = fstat(fd, &st);
4335     if (ret == -1 || !S_ISBLK(st.st_mode)) {
4336         goto outc;
4337     }
4338
4339     /* Attempt to detect via a CDROM specific ioctl */
4340     ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
4341     if (ret >= 0)
4342         prio = 100;
4343
4344 outc:
4345     qemu_close(fd);
4346 out:
4347     return prio;
4348 }
4349
4350 static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs)
4351 {
4352     BDRVRawState *s = bs->opaque;
4353     int ret;
4354
4355     ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
4356     return ret == CDS_DISC_OK;
4357 }
4358
4359 static void coroutine_fn cdrom_co_eject(BlockDriverState *bs, bool eject_flag)
4360 {
4361     BDRVRawState *s = bs->opaque;
4362
4363     if (eject_flag) {
4364         if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
4365             perror("CDROMEJECT");
4366     } else {
4367         if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
4368             perror("CDROMEJECT");
4369     }
4370 }
4371
4372 static void coroutine_fn cdrom_co_lock_medium(BlockDriverState *bs, bool locked)
4373 {
4374     BDRVRawState *s = bs->opaque;
4375
4376     if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
4377         /*
4378          * Note: an error can happen if the distribution automatically
4379          * mounts the CD-ROM
4380          */
4381         /* perror("CDROM_LOCKDOOR"); */
4382     }
4383 }
4384
4385 static BlockDriver bdrv_host_cdrom = {
4386     .format_name        = "host_cdrom",
4387     .protocol_name      = "host_cdrom",
4388     .instance_size      = sizeof(BDRVRawState),
4389     .bdrv_needs_filename = true,
4390     .bdrv_probe_device  = cdrom_probe_device,
4391     .bdrv_parse_filename = cdrom_parse_filename,
4392     .bdrv_file_open     = cdrom_open,
4393     .bdrv_close         = raw_close,
4394     .bdrv_reopen_prepare = raw_reopen_prepare,
4395     .bdrv_reopen_commit  = raw_reopen_commit,
4396     .bdrv_reopen_abort   = raw_reopen_abort,
4397     .bdrv_co_create_opts = bdrv_co_create_opts_simple,
4398     .create_opts         = &bdrv_create_opts_simple,
4399     .mutable_opts        = mutable_opts,
4400     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
4401
4402     .bdrv_co_preadv         = raw_co_preadv,
4403     .bdrv_co_pwritev        = raw_co_pwritev,
4404     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
4405     .bdrv_refresh_limits    = cdrom_refresh_limits,
4406
4407     .bdrv_co_truncate                   = raw_co_truncate,
4408     .bdrv_co_getlength                  = raw_co_getlength,
4409     .bdrv_co_get_allocated_file_size    = raw_co_get_allocated_file_size,
4410
4411     /* removable device support */
4412     .bdrv_co_is_inserted    = cdrom_co_is_inserted,
4413     .bdrv_co_eject          = cdrom_co_eject,
4414     .bdrv_co_lock_medium    = cdrom_co_lock_medium,
4415
4416     /* generic scsi device */
4417     .bdrv_co_ioctl      = hdev_co_ioctl,
4418 };
4419 #endif /* __linux__ */
4420
4421 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
4422 static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
4423                       Error **errp)
4424 {
4425     BDRVRawState *s = bs->opaque;
4426     int ret;
4427
4428     s->type = FTYPE_CD;
4429
4430     ret = raw_open_common(bs, options, flags, 0, true, errp);
4431     if (ret) {
4432         return ret;
4433     }
4434
4435     /* make sure the door isn't locked at this time */
4436     ioctl(s->fd, CDIOCALLOW);
4437     return 0;
4438 }
4439
4440 static int cdrom_probe_device(const char *filename)
4441 {
4442     if (strstart(filename, "/dev/cd", NULL) ||
4443             strstart(filename, "/dev/acd", NULL))
4444         return 100;
4445     return 0;
4446 }
4447
4448 static int cdrom_reopen(BlockDriverState *bs)
4449 {
4450     BDRVRawState *s = bs->opaque;
4451     int fd;
4452
4453     /*
4454      * Force reread of possibly changed/newly loaded disc,
4455      * FreeBSD seems to not notice sometimes...
4456      */
4457     if (s->fd >= 0)
4458         qemu_close(s->fd);
4459     fd = qemu_open(bs->filename, s->open_flags, NULL);
4460     if (fd < 0) {
4461         s->fd = -1;
4462         return -EIO;
4463     }
4464     s->fd = fd;
4465
4466     /* make sure the door isn't locked at this time */
4467     ioctl(s->fd, CDIOCALLOW);
4468     return 0;
4469 }
4470
4471 static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs)
4472 {
4473     return raw_getlength(bs) > 0;
4474 }
4475
4476 static void coroutine_fn cdrom_co_eject(BlockDriverState *bs, bool eject_flag)
4477 {
4478     BDRVRawState *s = bs->opaque;
4479
4480     if (s->fd < 0)
4481         return;
4482
4483     (void) ioctl(s->fd, CDIOCALLOW);
4484
4485     if (eject_flag) {
4486         if (ioctl(s->fd, CDIOCEJECT) < 0)
4487             perror("CDIOCEJECT");
4488     } else {
4489         if (ioctl(s->fd, CDIOCCLOSE) < 0)
4490             perror("CDIOCCLOSE");
4491     }
4492
4493     cdrom_reopen(bs);
4494 }
4495
4496 static void coroutine_fn cdrom_co_lock_medium(BlockDriverState *bs, bool locked)
4497 {
4498     BDRVRawState *s = bs->opaque;
4499
4500     if (s->fd < 0)
4501         return;
4502     if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
4503         /*
4504          * Note: an error can happen if the distribution automatically
4505          * mounts the CD-ROM
4506          */
4507         /* perror("CDROM_LOCKDOOR"); */
4508     }
4509 }
4510
4511 static BlockDriver bdrv_host_cdrom = {
4512     .format_name        = "host_cdrom",
4513     .protocol_name      = "host_cdrom",
4514     .instance_size      = sizeof(BDRVRawState),
4515     .bdrv_needs_filename = true,
4516     .bdrv_probe_device  = cdrom_probe_device,
4517     .bdrv_parse_filename = cdrom_parse_filename,
4518     .bdrv_file_open     = cdrom_open,
4519     .bdrv_close         = raw_close,
4520     .bdrv_reopen_prepare = raw_reopen_prepare,
4521     .bdrv_reopen_commit  = raw_reopen_commit,
4522     .bdrv_reopen_abort   = raw_reopen_abort,
4523     .bdrv_co_create_opts = bdrv_co_create_opts_simple,
4524     .create_opts         = &bdrv_create_opts_simple,
4525     .mutable_opts       = mutable_opts,
4526
4527     .bdrv_co_preadv         = raw_co_preadv,
4528     .bdrv_co_pwritev        = raw_co_pwritev,
4529     .bdrv_co_flush_to_disk  = raw_co_flush_to_disk,
4530     .bdrv_refresh_limits    = cdrom_refresh_limits,
4531
4532     .bdrv_co_truncate                   = raw_co_truncate,
4533     .bdrv_co_getlength                  = raw_co_getlength,
4534     .bdrv_co_get_allocated_file_size    = raw_co_get_allocated_file_size,
4535
4536     /* removable device support */
4537     .bdrv_co_is_inserted     = cdrom_co_is_inserted,
4538     .bdrv_co_eject           = cdrom_co_eject,
4539     .bdrv_co_lock_medium     = cdrom_co_lock_medium,
4540 };
4541 #endif /* __FreeBSD__ */
4542
4543 #endif /* HAVE_HOST_BLOCK_DEVICE */
4544
4545 static void bdrv_file_init(void)
4546 {
4547     /*
4548      * Register all the drivers.  Note that order is important, the driver
4549      * registered last will get probed first.
4550      */
4551     bdrv_register(&bdrv_file);
4552 #if defined(HAVE_HOST_BLOCK_DEVICE)
4553     bdrv_register(&bdrv_host_device);
4554 #ifdef __linux__
4555     bdrv_register(&bdrv_host_cdrom);
4556 #endif
4557 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
4558     bdrv_register(&bdrv_host_cdrom);
4559 #endif
4560 #endif /* HAVE_HOST_BLOCK_DEVICE */
4561 }
4562
4563 block_init(bdrv_file_init);