raw-posix.c 58.1 KB
Newer Older
B
bellard 已提交
1
/*
2
 * Block driver for RAW files (posix)
3
 *
B
bellard 已提交
4
 * Copyright (c) 2006 Fabrice Bellard
5
 *
B
bellard 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
P
pbrook 已提交
24
#include "qemu-common.h"
25 26
#include "qemu/timer.h"
#include "qemu/log.h"
27
#include "block/block_int.h"
28
#include "qemu/module.h"
29
#include "trace.h"
30
#include "block/thread-pool.h"
31
#include "qemu/iov.h"
32
#include "raw-aio.h"
B
bellard 已提交
33

34
#if defined(__APPLE__) && (__MACH__)
B
bellard 已提交
35 36 37 38 39 40 41 42 43 44 45 46
#include <paths.h>
#include <sys/param.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/IOBSD.h>
#include <IOKit/storage/IOMediaBSDClient.h>
#include <IOKit/storage/IOMedia.h>
#include <IOKit/storage/IOCDMedia.h>
//#include <IOKit/storage/IOCDTypes.h>
#include <CoreFoundation/CoreFoundation.h>
#endif

#ifdef __sun__
47
#define _POSIX_PTHREAD_SEMANTICS 1
B
bellard 已提交
48 49
#include <sys/dkio.h>
#endif
B
bellard 已提交
50
#ifdef __linux__
51 52
#include <sys/types.h>
#include <sys/stat.h>
B
bellard 已提交
53
#include <sys/ioctl.h>
54
#include <sys/param.h>
B
bellard 已提交
55 56
#include <linux/cdrom.h>
#include <linux/fd.h>
57 58 59 60
#include <linux/fs.h>
#endif
#ifdef CONFIG_FIEMAP
#include <linux/fiemap.h>
B
bellard 已提交
61
#endif
62 63 64
#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
#include <linux/falloc.h>
#endif
A
Aurelien Jarno 已提交
65
#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
66
#include <sys/disk.h>
B
blueswir1 已提交
67
#include <sys/cdio.h>
68
#endif
B
bellard 已提交
69

70 71 72 73 74 75
#ifdef __OpenBSD__
#include <sys/ioctl.h>
#include <sys/disklabel.h>
#include <sys/dkio.h>
#endif

76 77 78 79 80 81 82
#ifdef __NetBSD__
#include <sys/ioctl.h>
#include <sys/disklabel.h>
#include <sys/dkio.h>
#include <sys/disk.h>
#endif

83 84 85 86 87
#ifdef __DragonFly__
#include <sys/ioctl.h>
#include <sys/diskslice.h>
#endif

C
Christoph Hellwig 已提交
88 89 90 91
#ifdef CONFIG_XFS
#include <xfs/xfs.h>
#endif

B
bellard 已提交
92
//#define DEBUG_FLOPPY
B
bellard 已提交
93

P
pbrook 已提交
94
//#define DEBUG_BLOCK
95
#if defined(DEBUG_BLOCK)
96 97
#define DEBUG_BLOCK_PRINT(formatCstr, ...) do { if (qemu_log_enabled()) \
    { qemu_log(formatCstr, ## __VA_ARGS__); qemu_log_flush(); } } while (0)
T
ths 已提交
98
#else
99
#define DEBUG_BLOCK_PRINT(formatCstr, ...)
T
ths 已提交
100 101
#endif

A
aliguori 已提交
102 103
/* OS X does not have O_DSYNC */
#ifndef O_DSYNC
104
#ifdef O_SYNC
105
#define O_DSYNC O_SYNC
106 107 108
#elif defined(O_FSYNC)
#define O_DSYNC O_FSYNC
#endif
A
aliguori 已提交
109 110
#endif

111 112 113 114 115
/* Approximate O_DIRECT with O_DSYNC if O_DIRECT isn't available */
#ifndef O_DIRECT
#define O_DIRECT O_DSYNC
#endif

B
bellard 已提交
116 117 118
#define FTYPE_FILE   0
#define FTYPE_CD     1
#define FTYPE_FD     2
B
bellard 已提交
119

120
/* if the FD is not accessed during that time (in ns), we try to
B
bellard 已提交
121
   reopen it to see if the disk has been changed */
122
#define FD_OPEN_TIMEOUT (1000000000)
B
bellard 已提交
123

124 125
#define MAX_BLOCKSIZE	4096

B
bellard 已提交
126 127 128
typedef struct BDRVRawState {
    int fd;
    int type;
129
    int open_flags;
130 131
    size_t buf_align;

B
bellard 已提交
132 133 134 135 136 137
#if defined(__linux__)
    /* linux floppy specific */
    int64_t fd_open_time;
    int64_t fd_error_time;
    int fd_got_error;
    int fd_media_changed;
B
bellard 已提交
138
#endif
139
#ifdef CONFIG_LINUX_AIO
140
    int use_aio;
K
Kevin Wolf 已提交
141
    void *aio_ctx;
142
#endif
C
Christoph Hellwig 已提交
143
#ifdef CONFIG_XFS
144
    bool is_xfs:1;
C
Christoph Hellwig 已提交
145
#endif
146
    bool has_discard:1;
147
    bool has_write_zeroes:1;
148
    bool discard_zeroes:1;
B
bellard 已提交
149 150
} BDRVRawState;

J
Jeff Cody 已提交
151 152 153 154 155 156 157 158
typedef struct BDRVRawReopenState {
    int fd;
    int open_flags;
#ifdef CONFIG_LINUX_AIO
    int use_aio;
#endif
} BDRVRawReopenState;

B
bellard 已提交
159
static int fd_open(BlockDriverState *bs);
160
static int64_t raw_getlength(BlockDriverState *bs);
B
bellard 已提交
161

162 163 164 165 166 167 168 169
typedef struct RawPosixAIOData {
    BlockDriverState *bs;
    int aio_fildes;
    union {
        struct iovec *aio_iov;
        void *aio_ioctl_buf;
    };
    int aio_niov;
P
Paolo Bonzini 已提交
170
    uint64_t aio_nbytes;
171 172 173 174 175
#define aio_ioctl_cmd   aio_nbytes /* for QEMU_AIO_IOCTL */
    off_t aio_offset;
    int aio_type;
} RawPosixAIOData;

A
Aurelien Jarno 已提交
176
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
177
static int cdrom_reopen(BlockDriverState *bs);
B
blueswir1 已提交
178 179
#endif

180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
#if defined(__NetBSD__)
static int raw_normalize_devicepath(const char **filename)
{
    static char namebuf[PATH_MAX];
    const char *dp, *fname;
    struct stat sb;

    fname = *filename;
    dp = strrchr(fname, '/');
    if (lstat(fname, &sb) < 0) {
        fprintf(stderr, "%s: stat failed: %s\n",
            fname, strerror(errno));
        return -errno;
    }

    if (!S_ISBLK(sb.st_mode)) {
        return 0;
    }

    if (dp == NULL) {
        snprintf(namebuf, PATH_MAX, "r%s", fname);
    } else {
        snprintf(namebuf, PATH_MAX, "%.*s/r%s",
            (int)(dp - fname), fname, dp + 1);
    }
    fprintf(stderr, "%s is a block device", fname);
    *filename = namebuf;
    fprintf(stderr, ", using %s\n", *filename);

    return 0;
}
#else
static int raw_normalize_devicepath(const char **filename)
{
    return 0;
}
#endif

218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
static void raw_probe_alignment(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
    char *buf;
    unsigned int sector_size;

    /* For /dev/sg devices the alignment is not really used.
       With buffered I/O, we don't have any restrictions. */
    if (bs->sg || !(s->open_flags & O_DIRECT)) {
        bs->request_alignment = 1;
        s->buf_align = 1;
        return;
    }

    /* Try a few ioctls to get the right size */
    bs->request_alignment = 0;
    s->buf_align = 0;

#ifdef BLKSSZGET
    if (ioctl(s->fd, BLKSSZGET, &sector_size) >= 0) {
        bs->request_alignment = sector_size;
    }
#endif
#ifdef DKIOCGETBLOCKSIZE
    if (ioctl(s->fd, DKIOCGETBLOCKSIZE, &sector_size) >= 0) {
        bs->request_alignment = sector_size;
    }
#endif
#ifdef DIOCGSECTORSIZE
    if (ioctl(s->fd, DIOCGSECTORSIZE, &sector_size) >= 0) {
        bs->request_alignment = sector_size;
    }
#endif
#ifdef CONFIG_XFS
    if (s->is_xfs) {
        struct dioattr da;
        if (xfsctl(NULL, s->fd, XFS_IOC_DIOINFO, &da) >= 0) {
            bs->request_alignment = da.d_miniosz;
            /* The kernel returns wrong information for d_mem */
            /* s->buf_align = da.d_mem; */
        }
    }
#endif

    /* If we could not get the sizes so far, we can only guess them */
    if (!s->buf_align) {
        size_t align;
        buf = qemu_memalign(MAX_BLOCKSIZE, 2 * MAX_BLOCKSIZE);
        for (align = 512; align <= MAX_BLOCKSIZE; align <<= 1) {
            if (pread(s->fd, buf + align, MAX_BLOCKSIZE, 0) >= 0) {
                s->buf_align = align;
                break;
            }
        }
        qemu_vfree(buf);
    }

    if (!bs->request_alignment) {
        size_t align;
        buf = qemu_memalign(s->buf_align, MAX_BLOCKSIZE);
        for (align = 512; align <= MAX_BLOCKSIZE; align <<= 1) {
            if (pread(s->fd, buf, align, 0) >= 0) {
                bs->request_alignment = align;
                break;
            }
        }
        qemu_vfree(buf);
    }
}

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
static void raw_parse_flags(int bdrv_flags, int *open_flags)
{
    assert(open_flags != NULL);

    *open_flags |= O_BINARY;
    *open_flags &= ~O_ACCMODE;
    if (bdrv_flags & BDRV_O_RDWR) {
        *open_flags |= O_RDWR;
    } else {
        *open_flags |= O_RDONLY;
    }

    /* Use O_DSYNC for write-through caching, no flags for write-back caching,
     * and O_DIRECT for no caching. */
    if ((bdrv_flags & BDRV_O_NOCACHE)) {
        *open_flags |= O_DIRECT;
    }
}

307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
#ifdef CONFIG_LINUX_AIO
static int raw_set_aio(void **aio_ctx, int *use_aio, int bdrv_flags)
{
    int ret = -1;
    assert(aio_ctx != NULL);
    assert(use_aio != NULL);
    /*
     * Currently Linux do AIO only for files opened with O_DIRECT
     * specified so check NOCACHE flag too
     */
    if ((bdrv_flags & (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) ==
                      (BDRV_O_NOCACHE|BDRV_O_NATIVE_AIO)) {

        /* if non-NULL, laio_init() has already been run */
        if (*aio_ctx == NULL) {
            *aio_ctx = laio_init();
            if (!*aio_ctx) {
                goto error;
            }
        }
        *use_aio = 1;
    } else {
        *use_aio = 0;
    }

    ret = 0;

error:
    return ret;
}
#endif

339 340 341 342 343 344 345 346 347 348 349 350 351 352
static QemuOptsList raw_runtime_opts = {
    .name = "raw",
    .head = QTAILQ_HEAD_INITIALIZER(raw_runtime_opts.head),
    .desc = {
        {
            .name = "filename",
            .type = QEMU_OPT_STRING,
            .help = "File name of the image",
        },
        { /* end of list */ }
    },
};

static int raw_open_common(BlockDriverState *bs, QDict *options,
353
                           int bdrv_flags, int open_flags, Error **errp)
B
bellard 已提交
354 355
{
    BDRVRawState *s = bs->opaque;
356 357 358
    QemuOpts *opts;
    Error *local_err = NULL;
    const char *filename;
359
    int fd, ret;
360
    struct stat st;
B
bellard 已提交
361

362
    opts = qemu_opts_create(&raw_runtime_opts, NULL, 0, &error_abort);
363
    qemu_opts_absorb_qdict(opts, options, &local_err);
364
    if (local_err) {
365
        error_propagate(errp, local_err);
366 367 368 369 370 371
        ret = -EINVAL;
        goto fail;
    }

    filename = qemu_opt_get(opts, "filename");

372 373
    ret = raw_normalize_devicepath(&filename);
    if (ret != 0) {
374
        error_setg_errno(errp, -ret, "Could not normalize device path");
375
        goto fail;
376 377
    }

378 379
    s->open_flags = open_flags;
    raw_parse_flags(bdrv_flags, &s->open_flags);
B
bellard 已提交
380

381
    s->fd = -1;
K
Kevin Wolf 已提交
382
    fd = qemu_open(filename, s->open_flags, 0644);
B
bellard 已提交
383 384
    if (fd < 0) {
        ret = -errno;
385
        if (ret == -EROFS) {
B
bellard 已提交
386
            ret = -EACCES;
387 388
        }
        goto fail;
B
bellard 已提交
389
    }
B
bellard 已提交
390
    s->fd = fd;
391

392
#ifdef CONFIG_LINUX_AIO
393
    if (raw_set_aio(&s->aio_ctx, &s->use_aio, bdrv_flags)) {
394
        qemu_close(fd);
395
        ret = -errno;
396
        error_setg_errno(errp, -ret, "Could not set AIO state");
397
        goto fail;
398
    }
399
#endif
400

401
    s->has_discard = true;
402
    s->has_write_zeroes = true;
403 404 405 406 407 408 409 410

    if (fstat(s->fd, &st) < 0) {
        error_setg_errno(errp, errno, "Could not stat file");
        goto fail;
    }
    if (S_ISREG(st.st_mode)) {
        s->discard_zeroes = true;
    }
411 412 413 414 415 416 417 418 419 420
    if (S_ISBLK(st.st_mode)) {
#ifdef BLKDISCARDZEROES
        unsigned int arg;
        if (ioctl(s->fd, BLKDISCARDZEROES, &arg) == 0 && arg) {
            s->discard_zeroes = true;
        }
#endif
#ifdef __linux__
        /* On Linux 3.10, BLKDISCARD leaves stale data in the page cache.  Do
         * not rely on the contents of discarded blocks unless using O_DIRECT.
421
         * Same for BLKZEROOUT.
422 423 424
         */
        if (!(bs->open_flags & BDRV_O_NOCACHE)) {
            s->discard_zeroes = false;
425
            s->has_write_zeroes = false;
426 427 428
        }
#endif
    }
429

C
Christoph Hellwig 已提交
430 431
#ifdef CONFIG_XFS
    if (platform_test_xfs_fd(s->fd)) {
432
        s->is_xfs = true;
C
Christoph Hellwig 已提交
433 434 435
    }
#endif

436 437 438 439
    ret = 0;
fail:
    qemu_opts_del(opts);
    return ret;
B
bellard 已提交
440 441
}

M
Max Reitz 已提交
442 443
static int raw_open(BlockDriverState *bs, QDict *options, int flags,
                    Error **errp)
444 445
{
    BDRVRawState *s = bs->opaque;
446 447
    Error *local_err = NULL;
    int ret;
448 449

    s->type = FTYPE_FILE;
450
    ret = raw_open_common(bs, options, flags, 0, &local_err);
451
    if (local_err) {
452 453 454
        error_propagate(errp, local_err);
    }
    return ret;
455 456
}

J
Jeff Cody 已提交
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
static int raw_reopen_prepare(BDRVReopenState *state,
                              BlockReopenQueue *queue, Error **errp)
{
    BDRVRawState *s;
    BDRVRawReopenState *raw_s;
    int ret = 0;

    assert(state != NULL);
    assert(state->bs != NULL);

    s = state->bs->opaque;

    state->opaque = g_malloc0(sizeof(BDRVRawReopenState));
    raw_s = state->opaque;

#ifdef CONFIG_LINUX_AIO
    raw_s->use_aio = s->use_aio;

    /* we can use s->aio_ctx instead of a copy, because the use_aio flag is
     * valid in the 'false' condition even if aio_ctx is set, and raw_set_aio()
     * won't override aio_ctx if aio_ctx is non-NULL */
    if (raw_set_aio(&s->aio_ctx, &raw_s->use_aio, state->flags)) {
479
        error_setg(errp, "Could not set AIO state");
J
Jeff Cody 已提交
480 481 482 483
        return -1;
    }
#endif

484 485 486 487
    if (s->type == FTYPE_FD || s->type == FTYPE_CD) {
        raw_s->open_flags |= O_NONBLOCK;
    }

J
Jeff Cody 已提交
488 489 490 491
    raw_parse_flags(state->flags, &raw_s->open_flags);

    raw_s->fd = -1;

492
    int fcntl_flags = O_APPEND | O_NONBLOCK;
J
Jeff Cody 已提交
493 494 495 496
#ifdef O_NOATIME
    fcntl_flags |= O_NOATIME;
#endif

497 498 499 500 501 502 503 504 505
#ifdef O_ASYNC
    /* Not all operating systems have O_ASYNC, and those that don't
     * will not let us track the state into raw_s->open_flags (typically
     * you achieve the same effect with an ioctl, for example I_SETSIG
     * on Solaris). But we do not use O_ASYNC, so that's fine.
     */
    assert((s->open_flags & O_ASYNC) == 0);
#endif

J
Jeff Cody 已提交
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
    if ((raw_s->open_flags & ~fcntl_flags) == (s->open_flags & ~fcntl_flags)) {
        /* dup the original fd */
        /* TODO: use qemu fcntl wrapper */
#ifdef F_DUPFD_CLOEXEC
        raw_s->fd = fcntl(s->fd, F_DUPFD_CLOEXEC, 0);
#else
        raw_s->fd = dup(s->fd);
        if (raw_s->fd != -1) {
            qemu_set_cloexec(raw_s->fd);
        }
#endif
        if (raw_s->fd >= 0) {
            ret = fcntl_setfl(raw_s->fd, raw_s->open_flags);
            if (ret) {
                qemu_close(raw_s->fd);
                raw_s->fd = -1;
            }
        }
    }

    /* If we cannot use fcntl, or fcntl failed, fall back to qemu_open() */
    if (raw_s->fd == -1) {
        assert(!(raw_s->open_flags & O_CREAT));
        raw_s->fd = qemu_open(state->bs->filename, raw_s->open_flags);
        if (raw_s->fd == -1) {
531
            error_setg_errno(errp, errno, "Could not reopen file");
J
Jeff Cody 已提交
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
            ret = -1;
        }
    }
    return ret;
}

static void raw_reopen_commit(BDRVReopenState *state)
{
    BDRVRawReopenState *raw_s = state->opaque;
    BDRVRawState *s = state->bs->opaque;

    s->open_flags = raw_s->open_flags;

    qemu_close(s->fd);
    s->fd = raw_s->fd;
#ifdef CONFIG_LINUX_AIO
    s->use_aio = raw_s->use_aio;
#endif

    g_free(state->opaque);
    state->opaque = NULL;
}


static void raw_reopen_abort(BDRVReopenState *state)
{
    BDRVRawReopenState *raw_s = state->opaque;

     /* nothing to do if NULL, we didn't get far enough */
    if (raw_s == NULL) {
        return;
    }

    if (raw_s->fd >= 0) {
        qemu_close(raw_s->fd);
        raw_s->fd = -1;
    }
    g_free(state->opaque);
    state->opaque = NULL;
}

573 574 575
static int raw_refresh_limits(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
J
Jeff Cody 已提交
576

577 578 579 580 581
    raw_probe_alignment(bs);
    bs->bl.opt_mem_alignment = s->buf_align;

    return 0;
}
B
bellard 已提交
582

583 584 585 586 587 588 589 590 591
static ssize_t handle_aiocb_ioctl(RawPosixAIOData *aiocb)
{
    int ret;

    ret = ioctl(aiocb->aio_fildes, aiocb->aio_ioctl_cmd, aiocb->aio_ioctl_buf);
    if (ret == -1) {
        return -errno;
    }

P
Paolo Bonzini 已提交
592
    return 0;
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
}

static ssize_t handle_aiocb_flush(RawPosixAIOData *aiocb)
{
    int ret;

    ret = qemu_fdatasync(aiocb->aio_fildes);
    if (ret == -1) {
        return -errno;
    }
    return 0;
}

#ifdef CONFIG_PREADV

static bool preadv_present = true;

static ssize_t
qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
{
    return preadv(fd, iov, nr_iov, offset);
}

static ssize_t
qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
{
    return pwritev(fd, iov, nr_iov, offset);
}

#else

static bool preadv_present = false;

static ssize_t
qemu_preadv(int fd, const struct iovec *iov, int nr_iov, off_t offset)
{
    return -ENOSYS;
}

static ssize_t
qemu_pwritev(int fd, const struct iovec *iov, int nr_iov, off_t offset)
{
    return -ENOSYS;
}

#endif

static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
{
    ssize_t len;

    do {
        if (aiocb->aio_type & QEMU_AIO_WRITE)
            len = qemu_pwritev(aiocb->aio_fildes,
                               aiocb->aio_iov,
                               aiocb->aio_niov,
                               aiocb->aio_offset);
         else
            len = qemu_preadv(aiocb->aio_fildes,
                              aiocb->aio_iov,
                              aiocb->aio_niov,
                              aiocb->aio_offset);
    } while (len == -1 && errno == EINTR);

    if (len == -1) {
        return -errno;
    }
    return len;
}

/*
 * Read/writes the data to/from a given linear buffer.
 *
 * Returns the number of bytes handles or -errno in case of an error. Short
 * reads are only returned if the end of the file is reached.
 */
static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
{
    ssize_t offset = 0;
    ssize_t len;

    while (offset < aiocb->aio_nbytes) {
        if (aiocb->aio_type & QEMU_AIO_WRITE) {
            len = pwrite(aiocb->aio_fildes,
                         (const char *)buf + offset,
                         aiocb->aio_nbytes - offset,
                         aiocb->aio_offset + offset);
        } else {
            len = pread(aiocb->aio_fildes,
                        buf + offset,
                        aiocb->aio_nbytes - offset,
                        aiocb->aio_offset + offset);
        }
        if (len == -1 && errno == EINTR) {
            continue;
        } else if (len == -1) {
            offset = -errno;
            break;
        } else if (len == 0) {
            break;
        }
        offset += len;
    }

    return offset;
}

static ssize_t handle_aiocb_rw(RawPosixAIOData *aiocb)
{
    ssize_t nbytes;
    char *buf;

    if (!(aiocb->aio_type & QEMU_AIO_MISALIGNED)) {
        /*
         * If there is just a single buffer, and it is properly aligned
         * we can just use plain pread/pwrite without any problems.
         */
        if (aiocb->aio_niov == 1) {
             return handle_aiocb_rw_linear(aiocb, aiocb->aio_iov->iov_base);
        }
        /*
         * We have more than one iovec, and all are properly aligned.
         *
         * Try preadv/pwritev first and fall back to linearizing the
         * buffer if it's not supported.
         */
        if (preadv_present) {
            nbytes = handle_aiocb_rw_vector(aiocb);
            if (nbytes == aiocb->aio_nbytes ||
                (nbytes < 0 && nbytes != -ENOSYS)) {
                return nbytes;
            }
            preadv_present = false;
        }

        /*
         * XXX(hch): short read/write.  no easy way to handle the reminder
         * using these interfaces.  For now retry using plain
         * pread/pwrite?
         */
    }

    /*
     * Ok, we have to do it the hard way, copy all segments into
     * a single aligned buffer.
     */
    buf = qemu_blockalign(aiocb->bs, aiocb->aio_nbytes);
    if (aiocb->aio_type & QEMU_AIO_WRITE) {
        char *p = buf;
        int i;

        for (i = 0; i < aiocb->aio_niov; ++i) {
            memcpy(p, aiocb->aio_iov[i].iov_base, aiocb->aio_iov[i].iov_len);
            p += aiocb->aio_iov[i].iov_len;
        }
    }

    nbytes = handle_aiocb_rw_linear(aiocb, buf);
    if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
        char *p = buf;
        size_t count = aiocb->aio_nbytes, copy;
        int i;

        for (i = 0; i < aiocb->aio_niov && count; ++i) {
            copy = count;
            if (copy > aiocb->aio_iov[i].iov_len) {
                copy = aiocb->aio_iov[i].iov_len;
            }
            memcpy(aiocb->aio_iov[i].iov_base, p, copy);
            p     += copy;
            count -= copy;
        }
    }
    qemu_vfree(buf);

    return nbytes;
}

P
Paolo Bonzini 已提交
771
#ifdef CONFIG_XFS
772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
static int xfs_write_zeroes(BDRVRawState *s, int64_t offset, uint64_t bytes)
{
    struct xfs_flock64 fl;

    memset(&fl, 0, sizeof(fl));
    fl.l_whence = SEEK_SET;
    fl.l_start = offset;
    fl.l_len = bytes;

    if (xfsctl(NULL, s->fd, XFS_IOC_ZERO_RANGE, &fl) < 0) {
        DEBUG_BLOCK_PRINT("cannot write zero range (%s)\n", strerror(errno));
        return -errno;
    }

    return 0;
}

P
Paolo Bonzini 已提交
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
static int xfs_discard(BDRVRawState *s, int64_t offset, uint64_t bytes)
{
    struct xfs_flock64 fl;

    memset(&fl, 0, sizeof(fl));
    fl.l_whence = SEEK_SET;
    fl.l_start = offset;
    fl.l_len = bytes;

    if (xfsctl(NULL, s->fd, XFS_IOC_UNRESVSP64, &fl) < 0) {
        DEBUG_BLOCK_PRINT("cannot punch hole (%s)\n", strerror(errno));
        return -errno;
    }

    return 0;
}
#endif

807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb)
{
    int ret = -EOPNOTSUPP;
    BDRVRawState *s = aiocb->bs->opaque;

    if (s->has_write_zeroes == 0) {
        return -ENOTSUP;
    }

    if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
#ifdef BLKZEROOUT
        do {
            uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
            if (ioctl(aiocb->aio_fildes, BLKZEROOUT, range) == 0) {
                return 0;
            }
        } while (errno == EINTR);

        ret = -errno;
#endif
    } else {
#ifdef CONFIG_XFS
        if (s->is_xfs) {
            return xfs_write_zeroes(s, aiocb->aio_offset, aiocb->aio_nbytes);
        }
#endif
    }

    if (ret == -ENODEV || ret == -ENOSYS || ret == -EOPNOTSUPP ||
        ret == -ENOTTY) {
        s->has_write_zeroes = false;
        ret = -ENOTSUP;
    }
    return ret;
}

P
Paolo Bonzini 已提交
843 844 845 846 847
static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb)
{
    int ret = -EOPNOTSUPP;
    BDRVRawState *s = aiocb->bs->opaque;

848 849
    if (!s->has_discard) {
        return -ENOTSUP;
P
Paolo Bonzini 已提交
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883
    }

    if (aiocb->aio_type & QEMU_AIO_BLKDEV) {
#ifdef BLKDISCARD
        do {
            uint64_t range[2] = { aiocb->aio_offset, aiocb->aio_nbytes };
            if (ioctl(aiocb->aio_fildes, BLKDISCARD, range) == 0) {
                return 0;
            }
        } while (errno == EINTR);

        ret = -errno;
#endif
    } else {
#ifdef CONFIG_XFS
        if (s->is_xfs) {
            return xfs_discard(s, aiocb->aio_offset, aiocb->aio_nbytes);
        }
#endif

#ifdef CONFIG_FALLOCATE_PUNCH_HOLE
        do {
            if (fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
                          aiocb->aio_offset, aiocb->aio_nbytes) == 0) {
                return 0;
            }
        } while (errno == EINTR);

        ret = -errno;
#endif
    }

    if (ret == -ENODEV || ret == -ENOSYS || ret == -EOPNOTSUPP ||
        ret == -ENOTTY) {
884 885
        s->has_discard = false;
        ret = -ENOTSUP;
P
Paolo Bonzini 已提交
886 887 888 889
    }
    return ret;
}

890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
static int aio_worker(void *arg)
{
    RawPosixAIOData *aiocb = arg;
    ssize_t ret = 0;

    switch (aiocb->aio_type & QEMU_AIO_TYPE_MASK) {
    case QEMU_AIO_READ:
        ret = handle_aiocb_rw(aiocb);
        if (ret >= 0 && ret < aiocb->aio_nbytes && aiocb->bs->growable) {
            iov_memset(aiocb->aio_iov, aiocb->aio_niov, ret,
                      0, aiocb->aio_nbytes - ret);

            ret = aiocb->aio_nbytes;
        }
        if (ret == aiocb->aio_nbytes) {
            ret = 0;
        } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
            ret = -EINVAL;
        }
        break;
    case QEMU_AIO_WRITE:
        ret = handle_aiocb_rw(aiocb);
        if (ret == aiocb->aio_nbytes) {
            ret = 0;
        } else if (ret >= 0 && ret < aiocb->aio_nbytes) {
            ret = -EINVAL;
        }
        break;
    case QEMU_AIO_FLUSH:
        ret = handle_aiocb_flush(aiocb);
        break;
    case QEMU_AIO_IOCTL:
        ret = handle_aiocb_ioctl(aiocb);
        break;
P
Paolo Bonzini 已提交
924 925 926
    case QEMU_AIO_DISCARD:
        ret = handle_aiocb_discard(aiocb);
        break;
927 928 929
    case QEMU_AIO_WRITE_ZEROES:
        ret = handle_aiocb_write_zeroes(aiocb);
        break;
930 931 932 933 934 935 936 937 938 939
    default:
        fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
        ret = -EINVAL;
        break;
    }

    g_slice_free(RawPosixAIOData, aiocb);
    return ret;
}

940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
static int paio_submit_co(BlockDriverState *bs, int fd,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
        int type)
{
    RawPosixAIOData *acb = g_slice_new(RawPosixAIOData);
    ThreadPool *pool;

    acb->bs = bs;
    acb->aio_type = type;
    acb->aio_fildes = fd;

    if (qiov) {
        acb->aio_iov = qiov->iov;
        acb->aio_niov = qiov->niov;
    }
    acb->aio_nbytes = nb_sectors * 512;
    acb->aio_offset = sector_num * 512;

    trace_paio_submit_co(sector_num, nb_sectors, type);
    pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
    return thread_pool_submit_co(pool, aio_worker, acb);
}

963 964 965 966 967
static BlockDriverAIOCB *paio_submit(BlockDriverState *bs, int fd,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque, int type)
{
    RawPosixAIOData *acb = g_slice_new(RawPosixAIOData);
968
    ThreadPool *pool;
969 970 971 972 973 974 975 976 977 978 979 980 981

    acb->bs = bs;
    acb->aio_type = type;
    acb->aio_fildes = fd;

    if (qiov) {
        acb->aio_iov = qiov->iov;
        acb->aio_niov = qiov->niov;
    }
    acb->aio_nbytes = nb_sectors * 512;
    acb->aio_offset = sector_num * 512;

    trace_paio_submit(acb, opaque, sector_num, nb_sectors, type);
982 983
    pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
    return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
984 985
}

986 987 988
static BlockDriverAIOCB *raw_aio_submit(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
        BlockDriverCompletionFunc *cb, void *opaque, int type)
B
bellard 已提交
989
{
990 991
    BDRVRawState *s = bs->opaque;

B
bellard 已提交
992 993 994
    if (fd_open(bs) < 0)
        return NULL;

995 996
    /*
     * If O_DIRECT is used the buffer needs to be aligned on a sector
F
Frediano Ziglio 已提交
997
     * boundary.  Check if this is the case or tell the low-level
998
     * driver that it needs to copy the buffer.
999
     */
1000
    if ((bs->open_flags & BDRV_O_NOCACHE)) {
1001
        if (!bdrv_qiov_is_aligned(bs, qiov)) {
1002
            type |= QEMU_AIO_MISALIGNED;
1003
#ifdef CONFIG_LINUX_AIO
1004 1005
        } else if (s->use_aio) {
            return laio_submit(bs, s->aio_ctx, s->fd, sector_num, qiov,
1006 1007
                               nb_sectors, cb, opaque, type);
#endif
1008
        }
1009
    }
1010

K
Kevin Wolf 已提交
1011
    return paio_submit(bs, s->fd, sector_num, qiov, nb_sectors,
1012
                       cb, opaque, type);
B
bellard 已提交
1013 1014
}

1015 1016
static BlockDriverAIOCB *raw_aio_readv(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1017
        BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
1018
{
1019 1020
    return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
                          cb, opaque, QEMU_AIO_READ);
B
bellard 已提交
1021 1022
}

1023 1024
static BlockDriverAIOCB *raw_aio_writev(BlockDriverState *bs,
        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
1025
        BlockDriverCompletionFunc *cb, void *opaque)
B
bellard 已提交
1026
{
1027 1028
    return raw_aio_submit(bs, sector_num, qiov, nb_sectors,
                          cb, opaque, QEMU_AIO_WRITE);
B
bellard 已提交
1029
}
1030

1031 1032 1033 1034 1035 1036 1037 1038
static BlockDriverAIOCB *raw_aio_flush(BlockDriverState *bs,
        BlockDriverCompletionFunc *cb, void *opaque)
{
    BDRVRawState *s = bs->opaque;

    if (fd_open(bs) < 0)
        return NULL;

K
Kevin Wolf 已提交
1039
    return paio_submit(bs, s->fd, 0, NULL, 0, cb, opaque, QEMU_AIO_FLUSH);
1040 1041
}

B
bellard 已提交
1042 1043 1044
static void raw_close(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
B
bellard 已提交
1045
    if (s->fd >= 0) {
1046
        qemu_close(s->fd);
B
bellard 已提交
1047 1048
        s->fd = -1;
    }
B
bellard 已提交
1049 1050 1051 1052 1053
}

static int raw_truncate(BlockDriverState *bs, int64_t offset)
{
    BDRVRawState *s = bs->opaque;
1054 1055 1056
    struct stat st;

    if (fstat(s->fd, &st)) {
B
bellard 已提交
1057
        return -errno;
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
    }

    if (S_ISREG(st.st_mode)) {
        if (ftruncate(s->fd, offset) < 0) {
            return -errno;
        }
    } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
       if (offset > raw_getlength(bs)) {
           return -EINVAL;
       }
    } else {
        return -ENOTSUP;
    }

B
bellard 已提交
1072 1073 1074
    return 0;
}

1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
#ifdef __OpenBSD__
static int64_t raw_getlength(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
    int fd = s->fd;
    struct stat st;

    if (fstat(fd, &st))
        return -1;
    if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
        struct disklabel dl;

        if (ioctl(fd, DIOCGDINFO, &dl))
            return -1;
        return (uint64_t)dl.d_secsize *
            dl.d_partitions[DISKPART(st.st_rdev)].p_size;
    } else
        return st.st_size;
}
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
#elif defined(__NetBSD__)
static int64_t raw_getlength(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
    int fd = s->fd;
    struct stat st;

    if (fstat(fd, &st))
        return -1;
    if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
        struct dkwedge_info dkw;

        if (ioctl(fd, DIOCGWEDGEINFO, &dkw) != -1) {
            return dkw.dkw_size * 512;
        } else {
            struct disklabel dl;

            if (ioctl(fd, DIOCGDINFO, &dl))
                return -1;
            return (uint64_t)dl.d_secsize *
                dl.d_partitions[DISKPART(st.st_rdev)].p_size;
        }
    } else
        return st.st_size;
}
C
Christoph Hellwig 已提交
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
#elif defined(__sun__)
static int64_t raw_getlength(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
    struct dk_minfo minfo;
    int ret;

    ret = fd_open(bs);
    if (ret < 0) {
        return ret;
    }

    /*
     * Use the DKIOCGMEDIAINFO ioctl to read the size.
     */
    ret = ioctl(s->fd, DKIOCGMEDIAINFO, &minfo);
    if (ret != -1) {
        return minfo.dki_lbsize * minfo.dki_capacity;
    }

    /*
     * There are reports that lseek on some devices fails, but
     * irc discussion said that contingency on contingency was overkill.
     */
    return lseek(s->fd, 0, SEEK_END);
}
#elif defined(CONFIG_BSD)
static int64_t raw_getlength(BlockDriverState *bs)
B
bellard 已提交
1147 1148 1149 1150 1151
{
    BDRVRawState *s = bs->opaque;
    int fd = s->fd;
    int64_t size;
    struct stat sb;
A
Aurelien Jarno 已提交
1152
#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
B
blueswir1 已提交
1153
    int reopened = 0;
B
bellard 已提交
1154
#endif
B
bellard 已提交
1155 1156 1157 1158 1159
    int ret;

    ret = fd_open(bs);
    if (ret < 0)
        return ret;
B
bellard 已提交
1160

A
Aurelien Jarno 已提交
1161
#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
B
blueswir1 已提交
1162 1163
again:
#endif
B
bellard 已提交
1164 1165 1166
    if (!fstat(fd, &sb) && (S_IFCHR & sb.st_mode)) {
#ifdef DIOCGMEDIASIZE
	if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
1167 1168 1169 1170 1171 1172 1173 1174 1175
#elif defined(DIOCGPART)
        {
                struct partinfo pi;
                if (ioctl(fd, DIOCGPART, &pi) == 0)
                        size = pi.media_size;
                else
                        size = 0;
        }
        if (size == 0)
B
bellard 已提交
1176
#endif
1177
#if defined(__APPLE__) && defined(__MACH__)
B
bellard 已提交
1178 1179 1180
        size = LONG_LONG_MAX;
#else
        size = lseek(fd, 0LL, SEEK_END);
B
blueswir1 已提交
1181
#endif
A
Aurelien Jarno 已提交
1182
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
B
blueswir1 已提交
1183 1184 1185 1186 1187 1188
        switch(s->type) {
        case FTYPE_CD:
            /* XXX FreeBSD acd returns UINT_MAX sectors for an empty drive */
            if (size == 2048LL * (unsigned)-1)
                size = 0;
            /* XXX no disc?  maybe we need to reopen... */
1189
            if (size <= 0 && !reopened && cdrom_reopen(bs) >= 0) {
B
blueswir1 已提交
1190 1191 1192 1193
                reopened = 1;
                goto again;
            }
        }
B
bellard 已提交
1194
#endif
C
Christoph Hellwig 已提交
1195
    } else {
B
bellard 已提交
1196 1197 1198 1199
        size = lseek(fd, 0, SEEK_END);
    }
    return size;
}
C
Christoph Hellwig 已提交
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
#else
static int64_t raw_getlength(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
    int ret;

    ret = fd_open(bs);
    if (ret < 0) {
        return ret;
    }

    return lseek(s->fd, 0, SEEK_END);
}
1213
#endif
B
bellard 已提交
1214

1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
{
    struct stat st;
    BDRVRawState *s = bs->opaque;

    if (fstat(s->fd, &st) < 0) {
        return -errno;
    }
    return (int64_t)st.st_blocks * 512;
}

1226 1227
static int raw_create(const char *filename, QEMUOptionParameter *options,
                      Error **errp)
B
bellard 已提交
1228 1229
{
    int fd;
1230
    int result = 0;
1231
    int64_t total_size = 0;
B
bellard 已提交
1232

1233 1234 1235
    /* Read out options */
    while (options && options->name) {
        if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
1236
            total_size = options->value.n / BDRV_SECTOR_SIZE;
1237 1238 1239
        }
        options++;
    }
B
bellard 已提交
1240

1241 1242
    fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
                   0644);
1243 1244
    if (fd < 0) {
        result = -errno;
1245
        error_setg_errno(errp, -result, "Could not create file");
1246
    } else {
1247
        if (ftruncate(fd, total_size * BDRV_SECTOR_SIZE) != 0) {
1248
            result = -errno;
1249
            error_setg_errno(errp, -result, "Could not resize file");
1250
        }
1251
        if (qemu_close(fd) != 0) {
1252
            result = -errno;
1253
            error_setg_errno(errp, -result, "Could not close the new file");
1254 1255 1256
        }
    }
    return result;
B
bellard 已提交
1257 1258
}

1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
/*
 * Returns true iff the specified sector is present in the disk image. Drivers
 * not implementing the functionality are assumed to not support backing files,
 * hence all their sectors are reported as allocated.
 *
 * If 'sector_num' is beyond the end of the disk image the return value is 0
 * and 'pnum' is set to 0.
 *
 * 'pnum' is set to the number of sectors (including and immediately following
 * the specified sector) that are known to be in the same
 * allocated/unallocated state.
 *
 * 'nb_sectors' is the max value 'pnum' should be set to.  If nb_sectors goes
 * beyond the end of the disk image it will be clamped.
 */
1274
static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs,
1275 1276 1277 1278
                                            int64_t sector_num,
                                            int nb_sectors, int *pnum)
{
    off_t start, data, hole;
1279
    int64_t ret;
1280 1281 1282 1283 1284 1285 1286

    ret = fd_open(bs);
    if (ret < 0) {
        return ret;
    }

    start = sector_num * BDRV_SECTOR_SIZE;
1287
    ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | start;
1288

1289
#ifdef CONFIG_FIEMAP
1290 1291

    BDRVRawState *s = bs->opaque;
1292 1293 1294 1295
    struct {
        struct fiemap fm;
        struct fiemap_extent fe;
    } f;
1296

1297 1298 1299 1300 1301 1302 1303 1304
    f.fm.fm_start = start;
    f.fm.fm_length = (int64_t)nb_sectors * BDRV_SECTOR_SIZE;
    f.fm.fm_flags = 0;
    f.fm.fm_extent_count = 1;
    f.fm.fm_reserved = 0;
    if (ioctl(s->fd, FS_IOC_FIEMAP, &f) == -1) {
        /* Assume everything is allocated.  */
        *pnum = nb_sectors;
1305
        return ret;
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
    }

    if (f.fm.fm_mapped_extents == 0) {
        /* No extents found, data is beyond f.fm.fm_start + f.fm.fm_length.
         * f.fm.fm_start + f.fm.fm_length must be clamped to the file size!
         */
        off_t length = lseek(s->fd, 0, SEEK_END);
        hole = f.fm.fm_start;
        data = MIN(f.fm.fm_start + f.fm.fm_length, length);
    } else {
        data = f.fe.fe_logical;
        hole = f.fe.fe_logical + f.fe.fe_length;
1318 1319 1320
        if (f.fe.fe_flags & FIEMAP_EXTENT_UNWRITTEN) {
            ret |= BDRV_BLOCK_ZERO;
        }
1321
    }
1322

1323
#elif defined SEEK_HOLE && defined SEEK_DATA
1324 1325 1326

    BDRVRawState *s = bs->opaque;

1327 1328 1329 1330 1331 1332 1333 1334
    hole = lseek(s->fd, start, SEEK_HOLE);
    if (hole == -1) {
        /* -ENXIO indicates that sector_num was past the end of the file.
         * There is a virtual hole there.  */
        assert(errno != -ENXIO);

        /* Most likely EINVAL.  Assume everything is allocated.  */
        *pnum = nb_sectors;
1335
        return ret;
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
    }

    if (hole > start) {
        data = start;
    } else {
        /* On a hole.  We need another syscall to find its end.  */
        data = lseek(s->fd, start, SEEK_DATA);
        if (data == -1) {
            data = lseek(s->fd, 0, SEEK_END);
        }
    }
#else
1348 1349
    data = 0;
    hole = start + nb_sectors * BDRV_SECTOR_SIZE;
1350 1351 1352 1353 1354 1355 1356 1357
#endif

    if (data <= start) {
        /* On a data extent, compute sectors to the end of the extent.  */
        *pnum = MIN(nb_sectors, (hole - start) / BDRV_SECTOR_SIZE);
    } else {
        /* On a hole, compute sectors to the beginning of the next extent.  */
        *pnum = MIN(nb_sectors, (data - start) / BDRV_SECTOR_SIZE);
1358 1359
        ret &= ~BDRV_BLOCK_DATA;
        ret |= BDRV_BLOCK_ZERO;
1360
    }
1361 1362

    return ret;
1363 1364
}

P
Paolo Bonzini 已提交
1365 1366 1367
static coroutine_fn BlockDriverAIOCB *raw_aio_discard(BlockDriverState *bs,
    int64_t sector_num, int nb_sectors,
    BlockDriverCompletionFunc *cb, void *opaque)
C
Christoph Hellwig 已提交
1368 1369 1370
{
    BDRVRawState *s = bs->opaque;

P
Paolo Bonzini 已提交
1371 1372
    return paio_submit(bs, s->fd, sector_num, NULL, nb_sectors,
                       cb, opaque, QEMU_AIO_DISCARD);
C
Christoph Hellwig 已提交
1373
}
1374

1375 1376 1377 1378 1379 1380 1381
static int coroutine_fn raw_co_write_zeroes(
    BlockDriverState *bs, int64_t sector_num,
    int nb_sectors, BdrvRequestFlags flags)
{
    BDRVRawState *s = bs->opaque;

    if (!(flags & BDRV_REQ_MAY_UNMAP)) {
1382 1383 1384 1385 1386
        return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
                              QEMU_AIO_WRITE_ZEROES);
    } else if (s->discard_zeroes) {
        return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
                              QEMU_AIO_DISCARD);
1387
    }
1388
    return -ENOTSUP;
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
}

static int raw_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
    BDRVRawState *s = bs->opaque;

    bdi->unallocated_blocks_are_zero = s->discard_zeroes;
    bdi->can_write_zeroes_with_unmap = s->discard_zeroes;
    return 0;
}

1400
static QEMUOptionParameter raw_create_options[] = {
1401 1402 1403 1404 1405
    {
        .name = BLOCK_OPT_SIZE,
        .type = OPT_SIZE,
        .help = "Virtual disk size"
    },
1406 1407 1408
    { NULL }
};

1409 1410 1411
static BlockDriver bdrv_file = {
    .format_name = "file",
    .protocol_name = "file",
B
blueswir1 已提交
1412
    .instance_size = sizeof(BDRVRawState),
1413
    .bdrv_needs_filename = true,
B
blueswir1 已提交
1414
    .bdrv_probe = NULL, /* no probe for protocols */
1415
    .bdrv_file_open = raw_open,
J
Jeff Cody 已提交
1416 1417 1418
    .bdrv_reopen_prepare = raw_reopen_prepare,
    .bdrv_reopen_commit = raw_reopen_commit,
    .bdrv_reopen_abort = raw_reopen_abort,
B
blueswir1 已提交
1419 1420
    .bdrv_close = raw_close,
    .bdrv_create = raw_create,
1421
    .bdrv_has_zero_init = bdrv_has_zero_init_1,
1422
    .bdrv_co_get_block_status = raw_co_get_block_status,
1423
    .bdrv_co_write_zeroes = raw_co_write_zeroes,
1424

1425 1426
    .bdrv_aio_readv = raw_aio_readv,
    .bdrv_aio_writev = raw_aio_writev,
1427
    .bdrv_aio_flush = raw_aio_flush,
P
Paolo Bonzini 已提交
1428
    .bdrv_aio_discard = raw_aio_discard,
1429
    .bdrv_refresh_limits = raw_refresh_limits,
1430

B
bellard 已提交
1431 1432
    .bdrv_truncate = raw_truncate,
    .bdrv_getlength = raw_getlength,
1433
    .bdrv_get_info = raw_get_info,
1434 1435
    .bdrv_get_allocated_file_size
                        = raw_get_allocated_file_size,
1436 1437

    .create_options = raw_create_options,
B
bellard 已提交
1438 1439
};

B
bellard 已提交
1440 1441 1442
/***********************************************/
/* host device */

1443
#if defined(__APPLE__) && defined(__MACH__)
B
bellard 已提交
1444 1445 1446 1447 1448
static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator );
static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize );

kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
{
1449
    kern_return_t       kernResult;
B
bellard 已提交
1450 1451 1452 1453 1454 1455 1456
    mach_port_t     masterPort;
    CFMutableDictionaryRef  classesToMatch;

    kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
    if ( KERN_SUCCESS != kernResult ) {
        printf( "IOMasterPort returned %d\n", kernResult );
    }
1457

1458
    classesToMatch = IOServiceMatching( kIOCDMediaClass );
B
bellard 已提交
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
    if ( classesToMatch == NULL ) {
        printf( "IOServiceMatching returned a NULL dictionary.\n" );
    } else {
    CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue );
    }
    kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator );
    if ( KERN_SUCCESS != kernResult )
    {
        printf( "IOServiceGetMatchingServices returned %d\n", kernResult );
    }
1469

B
bellard 已提交
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494
    return kernResult;
}

kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize )
{
    io_object_t     nextMedia;
    kern_return_t   kernResult = KERN_FAILURE;
    *bsdPath = '\0';
    nextMedia = IOIteratorNext( mediaIterator );
    if ( nextMedia )
    {
        CFTypeRef   bsdPathAsCFString;
    bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
        if ( bsdPathAsCFString ) {
            size_t devPathLength;
            strcpy( bsdPath, _PATH_DEV );
            strcat( bsdPath, "r" );
            devPathLength = strlen( bsdPath );
            if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
                kernResult = KERN_SUCCESS;
            }
            CFRelease( bsdPathAsCFString );
        }
        IOObjectRelease( nextMedia );
    }
1495

B
bellard 已提交
1496 1497 1498 1499 1500
    return kernResult;
}

#endif

1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
static int hdev_probe_device(const char *filename)
{
    struct stat st;

    /* allow a dedicated CD-ROM driver to match with a higher priority */
    if (strstart(filename, "/dev/cdrom", NULL))
        return 50;

    if (stat(filename, &st) >= 0 &&
            (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
        return 100;
    }

    return 0;
}

1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549
static int check_hdev_writable(BDRVRawState *s)
{
#if defined(BLKROGET)
    /* Linux block devices can be configured "read-only" using blockdev(8).
     * This is independent of device node permissions and therefore open(2)
     * with O_RDWR succeeds.  Actual writes fail with EPERM.
     *
     * bdrv_open() is supposed to fail if the disk is read-only.  Explicitly
     * check for read-only block devices so that Linux block devices behave
     * properly.
     */
    struct stat st;
    int readonly = 0;

    if (fstat(s->fd, &st)) {
        return -errno;
    }

    if (!S_ISBLK(st.st_mode)) {
        return 0;
    }

    if (ioctl(s->fd, BLKROGET, &readonly) < 0) {
        return -errno;
    }

    if (readonly) {
        return -EACCES;
    }
#endif /* defined(BLKROGET) */
    return 0;
}

M
Max Reitz 已提交
1550 1551
static int hdev_open(BlockDriverState *bs, QDict *options, int flags,
                     Error **errp)
B
bellard 已提交
1552 1553
{
    BDRVRawState *s = bs->opaque;
1554
    Error *local_err = NULL;
1555
    int ret;
1556
    const char *filename = qdict_get_str(options, "filename");
1557

1558
#if defined(__APPLE__) && defined(__MACH__)
B
bellard 已提交
1559 1560 1561 1562 1563
    if (strstart(filename, "/dev/cdrom", NULL)) {
        kern_return_t kernResult;
        io_iterator_t mediaIterator;
        char bsdPath[ MAXPATHLEN ];
        int fd;
1564

B
bellard 已提交
1565 1566
        kernResult = FindEjectableCDMedia( &mediaIterator );
        kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );
1567

B
bellard 已提交
1568 1569 1570
        if ( bsdPath[ 0 ] != '\0' ) {
            strcat(bsdPath,"s0");
            /* some CDs don't have a partition 0 */
1571
            fd = qemu_open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
B
bellard 已提交
1572 1573 1574
            if (fd < 0) {
                bsdPath[strlen(bsdPath)-1] = '1';
            } else {
1575
                qemu_close(fd);
B
bellard 已提交
1576 1577
            }
            filename = bsdPath;
1578
            qdict_put(options, "filename", qstring_from_str(filename));
B
bellard 已提交
1579
        }
1580

B
bellard 已提交
1581 1582 1583 1584 1585 1586
        if ( mediaIterator )
            IOObjectRelease( mediaIterator );
    }
#endif

    s->type = FTYPE_FILE;
C
Christoph Hellwig 已提交
1587
#if defined(__linux__)
1588 1589 1590 1591 1592 1593 1594
    {
        char resolved_path[ MAXPATHLEN ], *temp;

        temp = realpath(filename, resolved_path);
        if (temp && strstart(temp, "/dev/sg", NULL)) {
            bs->sg = 1;
        }
B
bellard 已提交
1595 1596
    }
#endif
1597

1598
    ret = raw_open_common(bs, options, flags, 0, &local_err);
1599
    if (ret < 0) {
1600
        if (local_err) {
1601 1602
            error_propagate(errp, local_err);
        }
1603 1604 1605 1606 1607 1608 1609
        return ret;
    }

    if (flags & BDRV_O_RDWR) {
        ret = check_hdev_writable(s);
        if (ret < 0) {
            raw_close(bs);
1610
            error_setg_errno(errp, -ret, "The device is not writable");
1611 1612 1613 1614 1615
            return ret;
        }
    }

    return ret;
B
bellard 已提交
1616 1617
}

1618
#if defined(__linux__)
B
bellard 已提交
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
/* Note: we do not have a reliable method to detect if the floppy is
   present. The current method is to try to open the floppy at every
   I/O and to keep it opened during a few hundreds of ms. */
static int fd_open(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
    int last_media_present;

    if (s->type != FTYPE_FD)
        return 0;
    last_media_present = (s->fd >= 0);
1630
    if (s->fd >= 0 &&
1631
        (get_clock() - s->fd_open_time) >= FD_OPEN_TIMEOUT) {
1632
        qemu_close(s->fd);
B
bellard 已提交
1633 1634 1635 1636 1637 1638
        s->fd = -1;
#ifdef DEBUG_FLOPPY
        printf("Floppy closed\n");
#endif
    }
    if (s->fd < 0) {
1639
        if (s->fd_got_error &&
1640
            (get_clock() - s->fd_error_time) < FD_OPEN_TIMEOUT) {
B
bellard 已提交
1641 1642 1643 1644 1645
#ifdef DEBUG_FLOPPY
            printf("No floppy (open delayed)\n");
#endif
            return -EIO;
        }
1646
        s->fd = qemu_open(bs->filename, s->open_flags & ~O_NONBLOCK);
B
bellard 已提交
1647
        if (s->fd < 0) {
1648
            s->fd_error_time = get_clock();
B
bellard 已提交
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
            s->fd_got_error = 1;
            if (last_media_present)
                s->fd_media_changed = 1;
#ifdef DEBUG_FLOPPY
            printf("No floppy\n");
#endif
            return -EIO;
        }
#ifdef DEBUG_FLOPPY
        printf("Floppy opened\n");
#endif
    }
    if (!last_media_present)
        s->fd_media_changed = 1;
1663
    s->fd_open_time = get_clock();
B
bellard 已提交
1664 1665 1666 1667
    s->fd_got_error = 0;
    return 0;
}

1668
static int hdev_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
1669 1670 1671 1672 1673
{
    BDRVRawState *s = bs->opaque;

    return ioctl(s->fd, req, buf);
}
1674

1675
static BlockDriverAIOCB *hdev_aio_ioctl(BlockDriverState *bs,
1676 1677 1678
        unsigned long int req, void *buf,
        BlockDriverCompletionFunc *cb, void *opaque)
{
1679
    BDRVRawState *s = bs->opaque;
1680
    RawPosixAIOData *acb;
1681
    ThreadPool *pool;
1682

1683 1684
    if (fd_open(bs) < 0)
        return NULL;
1685 1686 1687 1688 1689 1690 1691 1692

    acb = g_slice_new(RawPosixAIOData);
    acb->bs = bs;
    acb->aio_type = QEMU_AIO_IOCTL;
    acb->aio_fildes = s->fd;
    acb->aio_offset = 0;
    acb->aio_ioctl_buf = buf;
    acb->aio_ioctl_cmd = req;
1693 1694
    pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
    return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
1695 1696
}

A
Aurelien Jarno 已提交
1697
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
B
blueswir1 已提交
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
static int fd_open(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;

    /* this is just to ensure s->fd is sane (its called by io ops) */
    if (s->fd >= 0)
        return 0;
    return -EIO;
}
#else /* !linux && !FreeBSD */
B
bellard 已提交
1708

1709 1710 1711 1712 1713
static int fd_open(BlockDriverState *bs)
{
    return 0;
}

1714
#endif /* !linux && !FreeBSD */
1715

1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
static coroutine_fn BlockDriverAIOCB *hdev_aio_discard(BlockDriverState *bs,
    int64_t sector_num, int nb_sectors,
    BlockDriverCompletionFunc *cb, void *opaque)
{
    BDRVRawState *s = bs->opaque;

    if (fd_open(bs) < 0) {
        return NULL;
    }
    return paio_submit(bs, s->fd, sector_num, NULL, nb_sectors,
                       cb, opaque, QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
}

1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739
static coroutine_fn int hdev_co_write_zeroes(BlockDriverState *bs,
    int64_t sector_num, int nb_sectors, BdrvRequestFlags flags)
{
    BDRVRawState *s = bs->opaque;
    int rc;

    rc = fd_open(bs);
    if (rc < 0) {
        return rc;
    }
    if (!(flags & BDRV_REQ_MAY_UNMAP)) {
1740 1741 1742 1743 1744
        return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
                              QEMU_AIO_WRITE_ZEROES|QEMU_AIO_BLKDEV);
    } else if (s->discard_zeroes) {
        return paio_submit_co(bs, s->fd, sector_num, NULL, nb_sectors,
                              QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);
1745
    }
1746
    return -ENOTSUP;
1747 1748
}

1749 1750
static int hdev_create(const char *filename, QEMUOptionParameter *options,
                       Error **errp)
1751 1752 1753 1754
{
    int fd;
    int ret = 0;
    struct stat stat_buf;
1755
    int64_t total_size = 0;
1756

1757 1758 1759
    /* Read out options */
    while (options && options->name) {
        if (!strcmp(options->name, "size")) {
1760
            total_size = options->value.n / BDRV_SECTOR_SIZE;
1761 1762 1763
        }
        options++;
    }
1764

1765
    fd = qemu_open(filename, O_WRONLY | O_BINARY);
1766 1767 1768 1769 1770
    if (fd < 0) {
        ret = -errno;
        error_setg_errno(errp, -ret, "Could not open device");
        return ret;
    }
1771

1772
    if (fstat(fd, &stat_buf) < 0) {
1773
        ret = -errno;
1774 1775 1776 1777
        error_setg_errno(errp, -ret, "Could not stat device");
    } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
        error_setg(errp,
                   "The given file is neither a block nor a character device");
1778
        ret = -ENODEV;
1779 1780
    } else if (lseek(fd, 0, SEEK_END) < total_size * BDRV_SECTOR_SIZE) {
        error_setg(errp, "Device is too small");
1781
        ret = -ENOSPC;
1782
    }
1783

1784
    qemu_close(fd);
1785 1786 1787
    return ret;
}

1788
static BlockDriver bdrv_host_device = {
1789
    .format_name        = "host_device",
1790
    .protocol_name        = "host_device",
1791
    .instance_size      = sizeof(BDRVRawState),
1792
    .bdrv_needs_filename = true,
1793
    .bdrv_probe_device  = hdev_probe_device,
1794
    .bdrv_file_open     = hdev_open,
1795
    .bdrv_close         = raw_close,
1796 1797 1798
    .bdrv_reopen_prepare = raw_reopen_prepare,
    .bdrv_reopen_commit  = raw_reopen_commit,
    .bdrv_reopen_abort   = raw_reopen_abort,
1799
    .bdrv_create        = hdev_create,
1800
    .create_options     = raw_create_options,
1801
    .bdrv_co_write_zeroes = hdev_co_write_zeroes,
1802

1803 1804
    .bdrv_aio_readv	= raw_aio_readv,
    .bdrv_aio_writev	= raw_aio_writev,
1805
    .bdrv_aio_flush	= raw_aio_flush,
P
Paolo Bonzini 已提交
1806
    .bdrv_aio_discard   = hdev_aio_discard,
1807
    .bdrv_refresh_limits = raw_refresh_limits,
1808

1809
    .bdrv_truncate      = raw_truncate,
1810
    .bdrv_getlength	= raw_getlength,
1811
    .bdrv_get_info = raw_get_info,
1812 1813
    .bdrv_get_allocated_file_size
                        = raw_get_allocated_file_size,
B
bellard 已提交
1814

1815
    /* generic scsi device */
1816 1817 1818 1819
#ifdef __linux__
    .bdrv_ioctl         = hdev_ioctl,
    .bdrv_aio_ioctl     = hdev_aio_ioctl,
#endif
1820 1821 1822
};

#ifdef __linux__
M
Max Reitz 已提交
1823 1824
static int floppy_open(BlockDriverState *bs, QDict *options, int flags,
                       Error **errp)
1825 1826
{
    BDRVRawState *s = bs->opaque;
1827
    Error *local_err = NULL;
1828 1829 1830 1831
    int ret;

    s->type = FTYPE_FD;

B
Blue Swirl 已提交
1832
    /* open will not fail even if no floppy is inserted, so add O_NONBLOCK */
1833 1834
    ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
    if (ret) {
1835
        if (local_err) {
1836 1837
            error_propagate(errp, local_err);
        }
1838
        return ret;
1839
    }
1840 1841

    /* close fd so that we can reopen it as needed */
1842
    qemu_close(s->fd);
1843 1844 1845 1846 1847 1848
    s->fd = -1;
    s->fd_media_changed = 1;

    return 0;
}

1849 1850
static int floppy_probe_device(const char *filename)
{
1851 1852 1853
    int fd, ret;
    int prio = 0;
    struct floppy_struct fdparam;
1854
    struct stat st;
1855

1856 1857
    if (strstart(filename, "/dev/fd", NULL) &&
        !strstart(filename, "/dev/fdset/", NULL)) {
1858
        prio = 50;
1859
    }
1860

1861
    fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
1862 1863 1864
    if (fd < 0) {
        goto out;
    }
1865 1866 1867 1868
    ret = fstat(fd, &st);
    if (ret == -1 || !S_ISBLK(st.st_mode)) {
        goto outc;
    }
1869 1870 1871 1872 1873 1874

    /* Attempt to detect via a floppy specific ioctl */
    ret = ioctl(fd, FDGETPRM, &fdparam);
    if (ret >= 0)
        prio = 100;

1875
outc:
1876
    qemu_close(fd);
1877 1878
out:
    return prio;
1879 1880 1881
}


1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904
static int floppy_is_inserted(BlockDriverState *bs)
{
    return fd_open(bs) >= 0;
}

static int floppy_media_changed(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
    int ret;

    /*
     * XXX: we do not have a true media changed indication.
     * It does not work if the floppy is changed without trying to read it.
     */
    fd_open(bs);
    ret = s->fd_media_changed;
    s->fd_media_changed = 0;
#ifdef DEBUG_FLOPPY
    printf("Floppy changed=%d\n", ret);
#endif
    return ret;
}

1905
static void floppy_eject(BlockDriverState *bs, bool eject_flag)
1906 1907 1908 1909 1910
{
    BDRVRawState *s = bs->opaque;
    int fd;

    if (s->fd >= 0) {
1911
        qemu_close(s->fd);
1912 1913
        s->fd = -1;
    }
1914
    fd = qemu_open(bs->filename, s->open_flags | O_NONBLOCK);
1915 1916 1917
    if (fd >= 0) {
        if (ioctl(fd, FDEJECT, 0) < 0)
            perror("FDEJECT");
1918
        qemu_close(fd);
1919 1920 1921 1922 1923
    }
}

static BlockDriver bdrv_host_floppy = {
    .format_name        = "host_floppy",
1924
    .protocol_name      = "host_floppy",
1925
    .instance_size      = sizeof(BDRVRawState),
1926
    .bdrv_needs_filename = true,
1927
    .bdrv_probe_device	= floppy_probe_device,
1928
    .bdrv_file_open     = floppy_open,
1929
    .bdrv_close         = raw_close,
1930 1931 1932
    .bdrv_reopen_prepare = raw_reopen_prepare,
    .bdrv_reopen_commit  = raw_reopen_commit,
    .bdrv_reopen_abort   = raw_reopen_abort,
1933
    .bdrv_create        = hdev_create,
1934
    .create_options     = raw_create_options,
1935 1936 1937

    .bdrv_aio_readv     = raw_aio_readv,
    .bdrv_aio_writev    = raw_aio_writev,
1938
    .bdrv_aio_flush	= raw_aio_flush,
1939
    .bdrv_refresh_limits = raw_refresh_limits,
1940

1941
    .bdrv_truncate      = raw_truncate,
1942 1943
    .bdrv_getlength      = raw_getlength,
    .has_variable_length = true,
1944 1945
    .bdrv_get_allocated_file_size
                        = raw_get_allocated_file_size,
1946 1947 1948 1949 1950 1951 1952

    /* removable device support */
    .bdrv_is_inserted   = floppy_is_inserted,
    .bdrv_media_changed = floppy_media_changed,
    .bdrv_eject         = floppy_eject,
};

M
Max Reitz 已提交
1953 1954
static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
                      Error **errp)
1955 1956
{
    BDRVRawState *s = bs->opaque;
1957 1958
    Error *local_err = NULL;
    int ret;
1959 1960 1961

    s->type = FTYPE_CD;

B
Blue Swirl 已提交
1962
    /* open will not fail even if no CD is inserted, so add O_NONBLOCK */
1963
    ret = raw_open_common(bs, options, flags, O_NONBLOCK, &local_err);
1964
    if (local_err) {
1965 1966 1967
        error_propagate(errp, local_err);
    }
    return ret;
1968 1969
}

1970 1971
static int cdrom_probe_device(const char *filename)
{
1972 1973
    int fd, ret;
    int prio = 0;
1974
    struct stat st;
1975

1976
    fd = qemu_open(filename, O_RDONLY | O_NONBLOCK);
1977 1978 1979
    if (fd < 0) {
        goto out;
    }
1980 1981 1982 1983
    ret = fstat(fd, &st);
    if (ret == -1 || !S_ISBLK(st.st_mode)) {
        goto outc;
    }
1984 1985 1986 1987 1988 1989

    /* Attempt to detect via a CDROM specific ioctl */
    ret = ioctl(fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
    if (ret >= 0)
        prio = 100;

1990
outc:
1991
    qemu_close(fd);
1992 1993
out:
    return prio;
1994 1995
}

1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
static int cdrom_is_inserted(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
    int ret;

    ret = ioctl(s->fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
    if (ret == CDS_DISC_OK)
        return 1;
    return 0;
}

2007
static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
{
    BDRVRawState *s = bs->opaque;

    if (eject_flag) {
        if (ioctl(s->fd, CDROMEJECT, NULL) < 0)
            perror("CDROMEJECT");
    } else {
        if (ioctl(s->fd, CDROMCLOSETRAY, NULL) < 0)
            perror("CDROMEJECT");
    }
}

2020
static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
{
    BDRVRawState *s = bs->opaque;

    if (ioctl(s->fd, CDROM_LOCKDOOR, locked) < 0) {
        /*
         * Note: an error can happen if the distribution automatically
         * mounts the CD-ROM
         */
        /* perror("CDROM_LOCKDOOR"); */
    }
}

static BlockDriver bdrv_host_cdrom = {
    .format_name        = "host_cdrom",
2035
    .protocol_name      = "host_cdrom",
2036
    .instance_size      = sizeof(BDRVRawState),
2037
    .bdrv_needs_filename = true,
2038
    .bdrv_probe_device	= cdrom_probe_device,
2039
    .bdrv_file_open     = cdrom_open,
2040
    .bdrv_close         = raw_close,
2041 2042 2043
    .bdrv_reopen_prepare = raw_reopen_prepare,
    .bdrv_reopen_commit  = raw_reopen_commit,
    .bdrv_reopen_abort   = raw_reopen_abort,
2044
    .bdrv_create        = hdev_create,
2045
    .create_options     = raw_create_options,
2046 2047 2048

    .bdrv_aio_readv     = raw_aio_readv,
    .bdrv_aio_writev    = raw_aio_writev,
2049
    .bdrv_aio_flush	= raw_aio_flush,
2050
    .bdrv_refresh_limits = raw_refresh_limits,
2051

2052
    .bdrv_truncate      = raw_truncate,
2053 2054
    .bdrv_getlength      = raw_getlength,
    .has_variable_length = true,
2055 2056
    .bdrv_get_allocated_file_size
                        = raw_get_allocated_file_size,
2057 2058 2059 2060

    /* removable device support */
    .bdrv_is_inserted   = cdrom_is_inserted,
    .bdrv_eject         = cdrom_eject,
2061
    .bdrv_lock_medium   = cdrom_lock_medium,
2062 2063

    /* generic scsi device */
2064 2065
    .bdrv_ioctl         = hdev_ioctl,
    .bdrv_aio_ioctl     = hdev_aio_ioctl,
2066 2067 2068
};
#endif /* __linux__ */

A
Aurelien Jarno 已提交
2069
#if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
2070 2071
static int cdrom_open(BlockDriverState *bs, QDict *options, int flags,
                      Error **errp)
2072 2073
{
    BDRVRawState *s = bs->opaque;
2074
    Error *local_err = NULL;
2075 2076 2077 2078
    int ret;

    s->type = FTYPE_CD;

2079 2080
    ret = raw_open_common(bs, options, flags, 0, &local_err);
    if (ret) {
2081
        if (local_err) {
2082 2083
            error_propagate(errp, local_err);
        }
2084
        return ret;
2085
    }
2086

D
Dong Xu Wang 已提交
2087
    /* make sure the door isn't locked at this time */
2088 2089 2090 2091
    ioctl(s->fd, CDIOCALLOW);
    return 0;
}

2092 2093 2094 2095 2096 2097 2098 2099
static int cdrom_probe_device(const char *filename)
{
    if (strstart(filename, "/dev/cd", NULL) ||
            strstart(filename, "/dev/acd", NULL))
        return 100;
    return 0;
}

2100 2101 2102 2103 2104 2105 2106 2107 2108 2109
static int cdrom_reopen(BlockDriverState *bs)
{
    BDRVRawState *s = bs->opaque;
    int fd;

    /*
     * Force reread of possibly changed/newly loaded disc,
     * FreeBSD seems to not notice sometimes...
     */
    if (s->fd >= 0)
2110
        qemu_close(s->fd);
2111
    fd = qemu_open(bs->filename, s->open_flags, 0644);
2112 2113 2114 2115 2116 2117
    if (fd < 0) {
        s->fd = -1;
        return -EIO;
    }
    s->fd = fd;

D
Dong Xu Wang 已提交
2118
    /* make sure the door isn't locked at this time */
2119 2120 2121 2122 2123 2124 2125 2126 2127
    ioctl(s->fd, CDIOCALLOW);
    return 0;
}

static int cdrom_is_inserted(BlockDriverState *bs)
{
    return raw_getlength(bs) > 0;
}

2128
static void cdrom_eject(BlockDriverState *bs, bool eject_flag)
2129 2130 2131 2132
{
    BDRVRawState *s = bs->opaque;

    if (s->fd < 0)
2133
        return;
2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144

    (void) ioctl(s->fd, CDIOCALLOW);

    if (eject_flag) {
        if (ioctl(s->fd, CDIOCEJECT) < 0)
            perror("CDIOCEJECT");
    } else {
        if (ioctl(s->fd, CDIOCCLOSE) < 0)
            perror("CDIOCCLOSE");
    }

2145
    cdrom_reopen(bs);
2146 2147
}

2148
static void cdrom_lock_medium(BlockDriverState *bs, bool locked)
2149 2150 2151 2152
{
    BDRVRawState *s = bs->opaque;

    if (s->fd < 0)
2153
        return;
2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164
    if (ioctl(s->fd, (locked ? CDIOCPREVENT : CDIOCALLOW)) < 0) {
        /*
         * Note: an error can happen if the distribution automatically
         * mounts the CD-ROM
         */
        /* perror("CDROM_LOCKDOOR"); */
    }
}

static BlockDriver bdrv_host_cdrom = {
    .format_name        = "host_cdrom",
2165
    .protocol_name      = "host_cdrom",
2166
    .instance_size      = sizeof(BDRVRawState),
2167
    .bdrv_needs_filename = true,
2168
    .bdrv_probe_device	= cdrom_probe_device,
2169
    .bdrv_file_open     = cdrom_open,
2170
    .bdrv_close         = raw_close,
2171 2172 2173
    .bdrv_reopen_prepare = raw_reopen_prepare,
    .bdrv_reopen_commit  = raw_reopen_commit,
    .bdrv_reopen_abort   = raw_reopen_abort,
2174
    .bdrv_create        = hdev_create,
2175
    .create_options     = raw_create_options,
2176 2177 2178

    .bdrv_aio_readv     = raw_aio_readv,
    .bdrv_aio_writev    = raw_aio_writev,
2179
    .bdrv_aio_flush	= raw_aio_flush,
2180
    .bdrv_refresh_limits = raw_refresh_limits,
2181

2182
    .bdrv_truncate      = raw_truncate,
2183 2184
    .bdrv_getlength      = raw_getlength,
    .has_variable_length = true,
2185 2186
    .bdrv_get_allocated_file_size
                        = raw_get_allocated_file_size,
2187

B
bellard 已提交
2188
    /* removable device support */
2189 2190
    .bdrv_is_inserted   = cdrom_is_inserted,
    .bdrv_eject         = cdrom_eject,
2191
    .bdrv_lock_medium   = cdrom_lock_medium,
B
bellard 已提交
2192
};
2193
#endif /* __FreeBSD__ */
2194

2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
#ifdef CONFIG_LINUX_AIO
/**
 * Return the file descriptor for Linux AIO
 *
 * This function is a layering violation and should be removed when it becomes
 * possible to call the block layer outside the global mutex.  It allows the
 * caller to hijack the file descriptor so I/O can be performed outside the
 * block layer.
 */
int raw_get_aio_fd(BlockDriverState *bs)
{
    BDRVRawState *s;

    if (!bs->drv) {
        return -ENOMEDIUM;
    }

    if (bs->drv == bdrv_find_format("raw")) {
        bs = bs->file;
    }

    /* raw-posix has several protocols so just check for raw_aio_readv */
    if (bs->drv->bdrv_aio_readv != raw_aio_readv) {
        return -ENOTSUP;
    }

    s = bs->opaque;
    if (!s->use_aio) {
        return -ENOTSUP;
    }
    return s->fd;
}
#endif /* CONFIG_LINUX_AIO */

2229
static void bdrv_file_init(void)
2230
{
2231 2232 2233 2234
    /*
     * Register all the drivers.  Note that order is important, the driver
     * registered last will get probed first.
     */
2235
    bdrv_register(&bdrv_file);
2236
    bdrv_register(&bdrv_host_device);
2237 2238 2239 2240
#ifdef __linux__
    bdrv_register(&bdrv_host_floppy);
    bdrv_register(&bdrv_host_cdrom);
#endif
A
Aurelien Jarno 已提交
2241
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
2242 2243
    bdrv_register(&bdrv_host_cdrom);
#endif
2244 2245
}

2246
block_init(bdrv_file_init);