Commit dc278c58 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging 



Block layer patches

# gpg: Signature made Thu 16 Jun 2016 15:01:27 BST
# gpg:                using RSA key 0x7F09B272C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>"
# Primary key fingerprint: DC3D EB15 9A9A F95D 3D74  56FE 7F09 B272 C88F 2FD6

* remotes/kevin/tags/for-upstream: (39 commits)
  hbitmap: add 'pos < size' asserts
  iotests: Add test for oVirt-like storage migration
  iotests: Add test for post-mirror backing chains
  block/null: Implement bdrv_refresh_filename()
  block/mirror: Fix target backing BDS
  block: Allow replacement of a BDS by its overlay
  rbd:change error_setg() to error_setg_errno()
  iotests: 095: Clean up QEMU before showing image info
  block: Create the commit block job before reopening any image
  block: Prevent sleeping jobs from resuming if they have been paused
  block: use the block job list in qmp_query_block_jobs()
  block: use the block job list in bdrv_drain_all()
  block: Fix snapshot=on with aio=native
  block: Remove bs->zero_beyond_eof
  qcow2: Let vmstate call qcow2_co_preadv/pwrite directly
  block: Make bdrv_load/save_vmstate coroutine_fns
  block: Allow .bdrv_load/save_vmstate() to return 0/-errno
  block: Make .bdrv_load_vmstate() vectored
  block: Introduce bdrv_preadv()
  doc: Fix mailing list address in tests/qemu-iotests/README
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents a66370b0 60251f4d

block.c

+20 −12
Original line number Diff line number Diff line
@@ -684,6 +684,10 @@ static void bdrv_temp_snapshot_options(int *child_flags, QDict *child_options, 
    /* For temporary files, unconditional cache=unsafe is fine */

    qdict_set_default_str(child_options, BDRV_OPT_CACHE_DIRECT, "off");

    qdict_set_default_str(child_options, BDRV_OPT_CACHE_NO_FLUSH, "on");



    /* aio=native doesn't work for cache.direct=off, so disable it for the

     * temporary snapshot */

    *child_flags &= ~BDRV_O_NATIVE_AIO;

}



/*
@@ -937,8 +941,7 @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file, 
        goto fail_opts;

    }



    bs->request_alignment = 512;

    bs->zero_beyond_eof = true;

    bs->request_alignment = drv->bdrv_co_preadv ? 1 : 512;

    bs->read_only = !(bs->open_flags & BDRV_O_RDWR);



    if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
@@ -2192,7 +2195,6 @@ static void bdrv_close(BlockDriverState *bs) 
        bs->encrypted = 0;

        bs->valid_key = 0;

        bs->sg = 0;

        bs->zero_beyond_eof = false;

        QDECREF(bs->options);

        QDECREF(bs->explicit_options);

        bs->options = NULL;
@@ -2224,9 +2226,23 @@ void bdrv_close_all(void) 
static void change_parent_backing_link(BlockDriverState *from,

                                       BlockDriverState *to)

{

    BdrvChild *c, *next;

    BdrvChild *c, *next, *to_c;



    QLIST_FOREACH_SAFE(c, &from->parents, next_parent, next) {

        if (c->role == &child_backing) {

            /* @from is generally not allowed to be a backing file, except for

             * when @to is the overlay. In that case, @from may not be replaced

             * by @to as @to's backing node. */

            QLIST_FOREACH(to_c, &to->children, next) {

                if (to_c == c) {

                    break;

                }

            }

            if (to_c) {

                continue;

            }

        }



        assert(c->role != &child_backing);

        bdrv_ref(to);

        bdrv_replace_child(c, to);
@@ -2275,14 +2291,6 @@ void bdrv_replace_in_backing_chain(BlockDriverState *old, BlockDriverState *new) 


    change_parent_backing_link(old, new);



    /* Change backing files if a previously independent node is added to the

     * chain. For active commit, we replace top by its own (indirect) backing

     * file and don't do anything here so we don't build a loop. */

    if (new->backing == NULL && !bdrv_chain_contains(backing_bs(old), new)) {

        bdrv_set_backing_hd(new, backing_bs(old));

        bdrv_set_backing_hd(old, NULL);

    }



    bdrv_unref(old);

}

block/commit.c

+6 −5
Original line number Diff line number Diff line
@@ -236,6 +236,11 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base, 
        return;

    }



    s = block_job_create(&commit_job_driver, bs, speed, cb, opaque, errp);

    if (!s) {

        return;

    }



    orig_base_flags    = bdrv_get_flags(base);

    orig_overlay_flags = bdrv_get_flags(overlay_bs);
@@ -252,16 +257,12 @@ void commit_start(BlockDriverState *bs, BlockDriverState *base, 
        bdrv_reopen_multiple(reopen_queue, &local_err);

        if (local_err != NULL) {

            error_propagate(errp, local_err);

            block_job_unref(&s->common);

            return;

        }

    }





    s = block_job_create(&commit_job_driver, bs, speed, cb, opaque, errp);

    if (!s) {

        return;

    }



    s->base = blk_new();

    blk_insert_bs(s->base, base);

block/io.c

+196 −110
Original line number Diff line number Diff line
@@ -289,15 +289,21 @@ void bdrv_drain_all(void) 
    bool busy = true;

    BlockDriverState *bs;

    BdrvNextIterator it;

    BlockJob *job = NULL;

    GSList *aio_ctxs = NULL, *ctx;



    while ((job = block_job_next(job))) {

        AioContext *aio_context = blk_get_aio_context(job->blk);



        aio_context_acquire(aio_context);

        block_job_pause(job);

        aio_context_release(aio_context);

    }



    for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {

        AioContext *aio_context = bdrv_get_aio_context(bs);



        aio_context_acquire(aio_context);

        if (bs->job) {

            block_job_pause(bs->job);

        }

        bdrv_parent_drained_begin(bs);

        bdrv_io_unplugged_begin(bs);

        bdrv_drain_recurse(bs);
@@ -340,12 +346,18 @@ void bdrv_drain_all(void) 
        aio_context_acquire(aio_context);

        bdrv_io_unplugged_end(bs);

        bdrv_parent_drained_end(bs);

        if (bs->job) {

            block_job_resume(bs->job);

        }

        aio_context_release(aio_context);

    }

    g_slist_free(aio_ctxs);



    job = NULL;

    while ((job = block_job_next(job))) {

        AioContext *aio_context = blk_get_aio_context(job->blk);



        aio_context_acquire(aio_context);

        block_job_resume(job);

        aio_context_release(aio_context);

    }

}



/**
@@ -404,9 +416,9 @@ static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align) 
}



/**

 * Round a region to cluster boundaries

 * Round a region to cluster boundaries (sector-based)

 */

void bdrv_round_to_clusters(BlockDriverState *bs,

void bdrv_round_sectors_to_clusters(BlockDriverState *bs,

                                    int64_t sector_num, int nb_sectors,

                                    int64_t *cluster_sector_num,

                                    int *cluster_nb_sectors)
@@ -424,6 +436,26 @@ void bdrv_round_to_clusters(BlockDriverState *bs, 
    }

}



/**

 * Round a region to cluster boundaries

 */

void bdrv_round_to_clusters(BlockDriverState *bs,

                            int64_t offset, unsigned int bytes,

                            int64_t *cluster_offset,

                            unsigned int *cluster_bytes)

{

    BlockDriverInfo bdi;



    if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0) {

        *cluster_offset = offset;

        *cluster_bytes = bytes;

    } else {

        int64_t c = bdi.cluster_size;

        *cluster_offset = QEMU_ALIGN_DOWN(offset, c);

        *cluster_bytes = QEMU_ALIGN_UP(offset - *cluster_offset + bytes, c);

    }

}



static int bdrv_get_cluster_size(BlockDriverState *bs)

{

    BlockDriverInfo bdi;
@@ -680,6 +712,18 @@ int bdrv_make_zero(BlockDriverState *bs, BdrvRequestFlags flags) 
    }

}



int bdrv_preadv(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)

{

    int ret;



    ret = bdrv_prwv_co(bs, offset, qiov, false, 0);

    if (ret < 0) {

        return ret;

    }



    return qiov->size;

}



int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes)

{

    QEMUIOVector qiov;
@@ -687,19 +731,13 @@ int bdrv_pread(BlockDriverState *bs, int64_t offset, void *buf, int bytes) 
        .iov_base = (void *)buf,

        .iov_len = bytes,

    };

    int ret;



    if (bytes < 0) {

        return -EINVAL;

    }



    qemu_iovec_init_external(&qiov, &iov, 1);

    ret = bdrv_prwv_co(bs, offset, &qiov, false, 0);

    if (ret < 0) {

        return ret;

    }



    return bytes;

    return bdrv_preadv(bs, offset, &qiov);

}



int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
@@ -776,6 +814,8 @@ static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs, 
    int64_t sector_num;

    unsigned int nb_sectors;



    assert(!(flags & ~BDRV_REQ_MASK));



    if (drv->bdrv_co_preadv) {

        return drv->bdrv_co_preadv(bs, offset, bytes, qiov, flags);

    }
@@ -815,6 +855,8 @@ static int coroutine_fn bdrv_driver_pwritev(BlockDriverState *bs, 
    unsigned int nb_sectors;

    int ret;



    assert(!(flags & ~BDRV_REQ_MASK));



    if (drv->bdrv_co_pwritev) {

        ret = drv->bdrv_co_pwritev(bs, offset, bytes, qiov,

                                   flags & bs->supported_write_flags);
@@ -861,7 +903,7 @@ emulate_flags: 
}



static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,

        int64_t sector_num, int nb_sectors, QEMUIOVector *qiov)

        int64_t offset, unsigned int bytes, QEMUIOVector *qiov)

{

    /* Perform I/O through a temporary buffer so that users who scribble over

     * their read buffer while the operation is in progress do not end up
@@ -873,21 +915,20 @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs, 
    BlockDriver *drv = bs->drv;

    struct iovec iov;

    QEMUIOVector bounce_qiov;

    int64_t cluster_sector_num;

    int cluster_nb_sectors;

    int64_t cluster_offset;

    unsigned int cluster_bytes;

    size_t skip_bytes;

    int ret;



    /* Cover entire cluster so no additional backing file I/O is required when

     * allocating cluster in the image file.

     */

    bdrv_round_to_clusters(bs, sector_num, nb_sectors,

                           &cluster_sector_num, &cluster_nb_sectors);

    bdrv_round_to_clusters(bs, offset, bytes, &cluster_offset, &cluster_bytes);



    trace_bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors,

                                   cluster_sector_num, cluster_nb_sectors);

    trace_bdrv_co_do_copy_on_readv(bs, offset, bytes,

                                   cluster_offset, cluster_bytes);



    iov.iov_len = cluster_nb_sectors * BDRV_SECTOR_SIZE;

    iov.iov_len = cluster_bytes;

    iov.iov_base = bounce_buffer = qemu_try_blockalign(bs, iov.iov_len);

    if (bounce_buffer == NULL) {

        ret = -ENOMEM;
@@ -896,8 +937,7 @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs, 


    qemu_iovec_init_external(&bounce_qiov, &iov, 1);



    ret = bdrv_driver_preadv(bs, cluster_sector_num * BDRV_SECTOR_SIZE,

                             cluster_nb_sectors * BDRV_SECTOR_SIZE,

    ret = bdrv_driver_preadv(bs, cluster_offset, cluster_bytes,

                             &bounce_qiov, 0);

    if (ret < 0) {

        goto err;
@@ -905,16 +945,12 @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs, 


    if (drv->bdrv_co_pwrite_zeroes &&

        buffer_is_zero(bounce_buffer, iov.iov_len)) {

        ret = bdrv_co_do_pwrite_zeroes(bs,

                                       cluster_sector_num * BDRV_SECTOR_SIZE,

                                       cluster_nb_sectors * BDRV_SECTOR_SIZE,

                                       0);

        ret = bdrv_co_do_pwrite_zeroes(bs, cluster_offset, cluster_bytes, 0);

    } else {

        /* This does not change the data on the disk, it is not necessary

         * to flush even in cache=writethrough mode.

         */

        ret = bdrv_driver_pwritev(bs, cluster_sector_num * BDRV_SECTOR_SIZE,

                                  cluster_nb_sectors * BDRV_SECTOR_SIZE,

        ret = bdrv_driver_pwritev(bs, cluster_offset, cluster_bytes,

                                  &bounce_qiov, 0);

    }
@@ -926,9 +962,8 @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs, 
        goto err;

    }



    skip_bytes = (sector_num - cluster_sector_num) * BDRV_SECTOR_SIZE;

    qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes,

                        nb_sectors * BDRV_SECTOR_SIZE);

    skip_bytes = offset - cluster_offset;

    qemu_iovec_from_buf(qiov, 0, bounce_buffer + skip_bytes, bytes);



err:

    qemu_vfree(bounce_buffer);
@@ -944,15 +979,15 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, 
    BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,

    int64_t align, QEMUIOVector *qiov, int flags)

{

    int64_t total_bytes, max_bytes;

    int ret;



    int64_t sector_num = offset >> BDRV_SECTOR_BITS;

    unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;



    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(is_power_of_2(align));

    assert((offset & (align - 1)) == 0);

    assert((bytes & (align - 1)) == 0);

    assert(!qiov || bytes == qiov->size);

    assert((bs->open_flags & BDRV_O_NO_IO) == 0);

    assert(!(flags & ~BDRV_REQ_MASK));



    /* Handle Copy on Read and associated serialisation */

    if (flags & BDRV_REQ_COPY_ON_READ) {
@@ -969,46 +1004,39 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, 
    }



    if (flags & BDRV_REQ_COPY_ON_READ) {

        int64_t start_sector = offset >> BDRV_SECTOR_BITS;

        int64_t end_sector = DIV_ROUND_UP(offset + bytes, BDRV_SECTOR_SIZE);

        unsigned int nb_sectors = end_sector - start_sector;

        int pnum;



        ret = bdrv_is_allocated(bs, sector_num, nb_sectors, &pnum);

        ret = bdrv_is_allocated(bs, start_sector, nb_sectors, &pnum);

        if (ret < 0) {

            goto out;

        }



        if (!ret || pnum != nb_sectors) {

            ret = bdrv_co_do_copy_on_readv(bs, sector_num, nb_sectors, qiov);

            ret = bdrv_co_do_copy_on_readv(bs, offset, bytes, qiov);

            goto out;

        }

    }



    /* Forward the request to the BlockDriver */

    if (!bs->zero_beyond_eof) {

        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0);

    } else {

        /* Read zeros after EOF */

        int64_t total_sectors, max_nb_sectors;



        total_sectors = bdrv_nb_sectors(bs);

        if (total_sectors < 0) {

            ret = total_sectors;

    total_bytes = bdrv_getlength(bs);

    if (total_bytes < 0) {

        ret = total_bytes;

        goto out;

    }



        max_nb_sectors = ROUND_UP(MAX(0, total_sectors - sector_num),

                                  align >> BDRV_SECTOR_BITS);

        if (nb_sectors < max_nb_sectors) {

    max_bytes = ROUND_UP(MAX(0, total_bytes - offset), align);

    if (bytes < max_bytes) {

        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0);

        } else if (max_nb_sectors > 0) {

    } else if (max_bytes > 0) {

        QEMUIOVector local_qiov;



        qemu_iovec_init(&local_qiov, qiov->niov);

            qemu_iovec_concat(&local_qiov, qiov, 0,

                              max_nb_sectors * BDRV_SECTOR_SIZE);

        qemu_iovec_concat(&local_qiov, qiov, 0, max_bytes);



            ret = bdrv_driver_preadv(bs, offset,

                                     max_nb_sectors * BDRV_SECTOR_SIZE,

                                     &local_qiov, 0);

        ret = bdrv_driver_preadv(bs, offset, max_bytes, &local_qiov, 0);



        qemu_iovec_destroy(&local_qiov);

    } else {
@@ -1016,12 +1044,10 @@ static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs, 
    }



    /* Reading beyond end of file is supposed to produce zeroes */

        if (ret == 0 && total_sectors < sector_num + nb_sectors) {

            uint64_t offset = MAX(0, total_sectors - sector_num);

            uint64_t bytes = (sector_num + nb_sectors - offset) *

                              BDRV_SECTOR_SIZE;

            qemu_iovec_memset(qiov, offset * BDRV_SECTOR_SIZE, 0, bytes);

        }

    if (ret == 0 && total_bytes < offset + bytes) {

        uint64_t zero_offset = MAX(0, total_bytes - offset);

        uint64_t zero_bytes = offset + bytes - zero_offset;

        qemu_iovec_memset(qiov, zero_offset, 0, zero_bytes);

    }



out:
@@ -1038,8 +1064,7 @@ int coroutine_fn bdrv_co_preadv(BlockDriverState *bs, 
    BlockDriver *drv = bs->drv;

    BdrvTrackedRequest req;



    /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */

    uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);

    uint64_t align = bs->request_alignment;

    uint8_t *head_buf = NULL;

    uint8_t *tail_buf = NULL;

    QEMUIOVector local_qiov;
@@ -1235,13 +1260,12 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, 
    bool waited;

    int ret;



    int64_t sector_num = offset >> BDRV_SECTOR_BITS;

    unsigned int nb_sectors = bytes >> BDRV_SECTOR_BITS;

    int64_t start_sector = offset >> BDRV_SECTOR_BITS;

    int64_t end_sector = DIV_ROUND_UP(offset + bytes, BDRV_SECTOR_SIZE);



    assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert((bytes & (BDRV_SECTOR_SIZE - 1)) == 0);

    assert(!qiov || bytes == qiov->size);

    assert((bs->open_flags & BDRV_O_NO_IO) == 0);

    assert(!(flags & ~BDRV_REQ_MASK));



    waited = wait_serialising_requests(req);

    assert(!waited || !req->serialising);
@@ -1263,22 +1287,21 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, 
        /* Do nothing, write notifier decided to fail this request */

    } else if (flags & BDRV_REQ_ZERO_WRITE) {

        bdrv_debug_event(bs, BLKDBG_PWRITEV_ZERO);

        ret = bdrv_co_do_pwrite_zeroes(bs, sector_num << BDRV_SECTOR_BITS,

                                       nb_sectors << BDRV_SECTOR_BITS, flags);

        ret = bdrv_co_do_pwrite_zeroes(bs, offset, bytes, flags);

    } else {

        bdrv_debug_event(bs, BLKDBG_PWRITEV);

        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, flags);

    }

    bdrv_debug_event(bs, BLKDBG_PWRITEV_DONE);



    bdrv_set_dirty(bs, sector_num, nb_sectors);

    bdrv_set_dirty(bs, start_sector, end_sector - start_sector);



    if (bs->wr_highest_offset < offset + bytes) {

        bs->wr_highest_offset = offset + bytes;

    }



    if (ret >= 0) {

        bs->total_sectors = MAX(bs->total_sectors, sector_num + nb_sectors);

        bs->total_sectors = MAX(bs->total_sectors, end_sector);

    }



    return ret;
@@ -1293,7 +1316,7 @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BlockDriverState *bs, 
    uint8_t *buf = NULL;

    QEMUIOVector local_qiov;

    struct iovec iov;

    uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);

    uint64_t align = bs->request_alignment;

    unsigned int head_padding_bytes, tail_padding_bytes;

    int ret = 0;
@@ -1380,8 +1403,7 @@ int coroutine_fn bdrv_co_pwritev(BlockDriverState *bs, 
    BdrvRequestFlags flags)

{

    BdrvTrackedRequest req;

    /* TODO Lift BDRV_SECTOR_SIZE restriction in BlockDriver interface */

    uint64_t align = MAX(BDRV_SECTOR_SIZE, bs->request_alignment);

    uint64_t align = bs->request_alignment;

    uint8_t *head_buf = NULL;

    uint8_t *tail_buf = NULL;

    QEMUIOVector local_qiov;
@@ -1824,6 +1846,62 @@ int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num, 
    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);

}



typedef struct BdrvVmstateCo {

    BlockDriverState    *bs;

    QEMUIOVector        *qiov;

    int64_t             pos;

    bool                is_read;

    int                 ret;

} BdrvVmstateCo;



static int coroutine_fn

bdrv_co_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,

                   bool is_read)

{

    BlockDriver *drv = bs->drv;



    if (!drv) {

        return -ENOMEDIUM;

    } else if (drv->bdrv_load_vmstate) {

        return is_read ? drv->bdrv_load_vmstate(bs, qiov, pos)

                       : drv->bdrv_save_vmstate(bs, qiov, pos);

    } else if (bs->file) {

        return bdrv_co_rw_vmstate(bs->file->bs, qiov, pos, is_read);

    }



    return -ENOTSUP;

}



static void coroutine_fn bdrv_co_rw_vmstate_entry(void *opaque)

{

    BdrvVmstateCo *co = opaque;

    co->ret = bdrv_co_rw_vmstate(co->bs, co->qiov, co->pos, co->is_read);

}



static inline int

bdrv_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,

                bool is_read)

{

    if (qemu_in_coroutine()) {

        return bdrv_co_rw_vmstate(bs, qiov, pos, is_read);

    } else {

        BdrvVmstateCo data = {

            .bs         = bs,

            .qiov       = qiov,

            .pos        = pos,

            .is_read    = is_read,

            .ret        = -EINPROGRESS,

        };

        Coroutine *co = qemu_coroutine_create(bdrv_co_rw_vmstate_entry);



        qemu_coroutine_enter(co, &data);

        while (data.ret == -EINPROGRESS) {

            aio_poll(bdrv_get_aio_context(bs), true);

        }

        return data.ret;

    }

}



int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,

                      int64_t pos, int size)

{
@@ -1832,37 +1910,45 @@ int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf, 
        .iov_base   = (void *) buf,

        .iov_len    = size,

    };

    int ret;



    qemu_iovec_init_external(&qiov, &iov, 1);

    return bdrv_writev_vmstate(bs, &qiov, pos);



    ret = bdrv_writev_vmstate(bs, &qiov, pos);

    if (ret < 0) {

        return ret;

    }



    return size;

}



int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)

{

    BlockDriver *drv = bs->drv;

    return bdrv_rw_vmstate(bs, qiov, pos, false);

}



    if (!drv) {

        return -ENOMEDIUM;

    } else if (drv->bdrv_save_vmstate) {

        return drv->bdrv_save_vmstate(bs, qiov, pos);

    } else if (bs->file) {

        return bdrv_writev_vmstate(bs->file->bs, qiov, pos);

int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,

                      int64_t pos, int size)

{

    QEMUIOVector qiov;

    struct iovec iov = {

        .iov_base   = buf,

        .iov_len    = size,

    };

    int ret;



    qemu_iovec_init_external(&qiov, &iov, 1);

    ret = bdrv_readv_vmstate(bs, &qiov, pos);

    if (ret < 0) {

        return ret;

    }



    return -ENOTSUP;

    return size;

}



int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,

                      int64_t pos, int size)

int bdrv_readv_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)

{

    BlockDriver *drv = bs->drv;

    if (!drv)

        return -ENOMEDIUM;

    if (drv->bdrv_load_vmstate)

        return drv->bdrv_load_vmstate(bs, buf, pos, size);

    if (bs->file)

        return bdrv_load_vmstate(bs->file->bs, buf, pos, size);

    return -ENOTSUP;

    return bdrv_rw_vmstate(bs, qiov, pos, true);

}



/**************************************************************/

block/linux-aio.c

+65 −23
Original line number Diff line number Diff line
@@ -11,8 +11,10 @@ 
#include "qemu-common.h"

#include "block/aio.h"

#include "qemu/queue.h"

#include "block/block.h"

#include "block/raw-aio.h"

#include "qemu/event_notifier.h"

#include "qemu/coroutine.h"



#include <libaio.h>
@@ -30,6 +32,7 @@ 


struct qemu_laiocb {

    BlockAIOCB common;

    Coroutine *co;

    LinuxAioState *ctx;

    struct iocb iocb;

    ssize_t ret;
@@ -88,10 +91,15 @@ static void qemu_laio_process_completion(struct qemu_laiocb *laiocb) 
            }

        }

    }

    laiocb->common.cb(laiocb->common.opaque, ret);



    laiocb->ret = ret;

    if (laiocb->co) {

        qemu_coroutine_enter(laiocb->co, NULL);

    } else {

        laiocb->common.cb(laiocb->common.opaque, ret);

        qemu_aio_unref(laiocb);

    }

}



/* The completion BH fetches completed I/O requests and invokes their

 * callbacks.
@@ -141,6 +149,8 @@ static void qemu_laio_completion_bh(void *opaque) 
    if (!s->io_q.plugged && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {

        ioq_submit(s);

    }



    qemu_bh_cancel(s->completion_bh);

}



static void qemu_laio_completion_cb(EventNotifier *e)
@@ -148,7 +158,7 @@ static void qemu_laio_completion_cb(EventNotifier *e) 
    LinuxAioState *s = container_of(e, LinuxAioState, e);



    if (event_notifier_test_and_clear(&s->e)) {

        qemu_bh_schedule(s->completion_bh);

        qemu_laio_completion_bh(s);

    }

}
@@ -230,22 +240,12 @@ void laio_io_unplug(BlockDriverState *bs, LinuxAioState *s) 
    }

}



BlockAIOCB *laio_submit(BlockDriverState *bs, LinuxAioState *s, int fd,

        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,

        BlockCompletionFunc *cb, void *opaque, int type)

static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,

                          int type)

{

    struct qemu_laiocb *laiocb;

    struct iocb *iocbs;

    off_t offset = sector_num * 512;



    laiocb = qemu_aio_get(&laio_aiocb_info, bs, cb, opaque);

    laiocb->nbytes = nb_sectors * 512;

    laiocb->ctx = s;

    laiocb->ret = -EINPROGRESS;

    laiocb->is_read = (type == QEMU_AIO_READ);

    laiocb->qiov = qiov;



    iocbs = &laiocb->iocb;

    LinuxAioState *s = laiocb->ctx;

    struct iocb *iocbs = &laiocb->iocb;

    QEMUIOVector *qiov = laiocb->qiov;



    switch (type) {

    case QEMU_AIO_WRITE:
@@ -258,7 +258,7 @@ BlockAIOCB *laio_submit(BlockDriverState *bs, LinuxAioState *s, int fd, 
    default:

        fprintf(stderr, "%s: invalid AIO request type 0x%x.\n",

                        __func__, type);

        goto out_free_aiocb;

        return -EIO;

    }

    io_set_eventfd(&laiocb->iocb, event_notifier_get_fd(&s->e));
@@ -268,13 +268,55 @@ BlockAIOCB *laio_submit(BlockDriverState *bs, LinuxAioState *s, int fd, 
        (!s->io_q.plugged || s->io_q.n >= MAX_QUEUED_IO)) {

        ioq_submit(s);

    }

    return &laiocb->common;



out_free_aiocb:

    return 0;

}



int coroutine_fn laio_co_submit(BlockDriverState *bs, LinuxAioState *s, int fd,

                                uint64_t offset, QEMUIOVector *qiov, int type)

{

    int ret;

    struct qemu_laiocb laiocb = {

        .co         = qemu_coroutine_self(),

        .nbytes     = qiov->size,

        .ctx        = s,

        .is_read    = (type == QEMU_AIO_READ),

        .qiov       = qiov,

    };



    ret = laio_do_submit(fd, &laiocb, offset, type);

    if (ret < 0) {

        return ret;

    }



    qemu_coroutine_yield();

    return laiocb.ret;

}



BlockAIOCB *laio_submit(BlockDriverState *bs, LinuxAioState *s, int fd,

        int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,

        BlockCompletionFunc *cb, void *opaque, int type)

{

    struct qemu_laiocb *laiocb;

    off_t offset = sector_num * BDRV_SECTOR_SIZE;

    int ret;



    laiocb = qemu_aio_get(&laio_aiocb_info, bs, cb, opaque);

    laiocb->nbytes = nb_sectors * BDRV_SECTOR_SIZE;

    laiocb->ctx = s;

    laiocb->ret = -EINPROGRESS;

    laiocb->is_read = (type == QEMU_AIO_READ);

    laiocb->qiov = qiov;



    ret = laio_do_submit(fd, laiocb, offset, type);

    if (ret < 0) {

        qemu_aio_unref(laiocb);

        return NULL;

    }



    return &laiocb->common;

}



void laio_detach_aio_context(LinuxAioState *s, AioContext *old_context)

{

    aio_set_event_notifier(old_context, &s->e, false, NULL);

block/mirror.c

+36 −19

File changed.

Preview size limit exceeded, changes collapsed.