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

Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging 



Pull request

# gpg: Signature made Fri 22 Feb 2019 14:07:01 GMT
# gpg:                using RSA key 9CA4ABB381AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>" [full]
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>" [full]
# Primary key fingerprint: 8695 A8BF D3F9 7CDA AC35  775A 9CA4 ABB3 81AB 73C8

* remotes/stefanha/tags/block-pull-request: (27 commits)
  tests/virtio-blk: add test for DISCARD command
  tests/virtio-blk: add test for WRITE_ZEROES command
  tests/virtio-blk: add virtio_blk_fix_dwz_hdr() function
  tests/virtio-blk: change assert on data_size in virtio_blk_request()
  virtio-blk: add DISCARD and WRITE_ZEROES features
  virtio-blk: set config size depending on the features enabled
  virtio-net: make VirtIOFeature usable for other virtio devices
  virtio-blk: add "discard" and "write-zeroes" properties
  virtio-blk: add host_features field in VirtIOBlock
  virtio-blk: add acct_failed param to virtio_blk_handle_rw_error()
  hw/ide: drop iov field from IDEDMA
  hw/ide: drop iov field from IDEBufferedRequest
  hw/ide: drop iov field from IDEState
  tests/test-bdrv-drain: use QEMU_IOVEC_INIT_BUF
  migration/block: use qemu_iovec_init_buf
  qemu-img: use qemu_iovec_init_buf
  block/vmdk: use qemu_iovec_init_buf
  block/qed: use qemu_iovec_init_buf
  block/qcow2: use qemu_iovec_init_buf
  block/qcow: use qemu_iovec_init_buf
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents ef80b99c 9a9f4b74

block/backup.c

+1 −4
Original line number Diff line number Diff line
@@ -107,7 +107,6 @@ static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job, 
                                                      void **bounce_buffer)

{

    int ret;

    struct iovec iov;

    QEMUIOVector qiov;

    BlockBackend *blk = job->common.blk;

    int nbytes;
@@ -119,9 +118,7 @@ static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job, 
    if (!*bounce_buffer) {

        *bounce_buffer = blk_blockalign(blk, job->cluster_size);

    }

    iov.iov_base = *bounce_buffer;

    iov.iov_len = nbytes;

    qemu_iovec_init_external(&qiov, &iov, 1);

    qemu_iovec_init_buf(&qiov, *bounce_buffer, nbytes);



    ret = blk_co_preadv(blk, start, qiov.size, &qiov, read_flags);

    if (ret < 0) {

block/block-backend.c

+2 −11
Original line number Diff line number Diff line
@@ -1204,17 +1204,8 @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf, 
                   int64_t bytes, CoroutineEntry co_entry,

                   BdrvRequestFlags flags)

{

    QEMUIOVector qiov;

    struct iovec iov;

    BlkRwCo rwco;



    iov = (struct iovec) {

        .iov_base = buf,

        .iov_len = bytes,

    };

    qemu_iovec_init_external(&qiov, &iov, 1);



    rwco = (BlkRwCo) {

    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);

    BlkRwCo rwco = {

        .blk    = blk,

        .offset = offset,

        .iobuf  = &qiov,

block/commit.c

+1 −6
Original line number Diff line number Diff line
@@ -47,14 +47,9 @@ static int coroutine_fn commit_populate(BlockBackend *bs, BlockBackend *base, 
                                        void *buf)

{

    int ret = 0;

    QEMUIOVector qiov;

    struct iovec iov = {

        .iov_base = buf,

        .iov_len = bytes,

    };

    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);



    assert(bytes < SIZE_MAX);

    qemu_iovec_init_external(&qiov, &iov, 1);



    ret = blk_co_preadv(bs, offset, qiov.size, &qiov, 0);

    if (ret < 0) {

block/io.c

+20 −69
Original line number Diff line number Diff line
@@ -843,17 +843,13 @@ static int bdrv_prwv_co(BdrvChild *child, int64_t offset, 
static int bdrv_rw_co(BdrvChild *child, int64_t sector_num, uint8_t *buf,

                      int nb_sectors, bool is_write, BdrvRequestFlags flags)

{

    QEMUIOVector qiov;

    struct iovec iov = {

        .iov_base = (void *)buf,

        .iov_len = nb_sectors * BDRV_SECTOR_SIZE,

    };

    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf,

                                            nb_sectors * BDRV_SECTOR_SIZE);



    if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {

        return -EINVAL;

    }



    qemu_iovec_init_external(&qiov, &iov, 1);

    return bdrv_prwv_co(child, sector_num << BDRV_SECTOR_BITS,

                        &qiov, is_write, flags);

}
@@ -880,13 +876,8 @@ int bdrv_write(BdrvChild *child, int64_t sector_num, 
int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,

                       int bytes, BdrvRequestFlags flags)

{

    QEMUIOVector qiov;

    struct iovec iov = {

        .iov_base = NULL,

        .iov_len = bytes,

    };

    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, bytes);



    qemu_iovec_init_external(&qiov, &iov, 1);

    return bdrv_prwv_co(child, offset, &qiov, true,

                        BDRV_REQ_ZERO_WRITE | flags);

}
@@ -950,17 +941,12 @@ int bdrv_preadv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov) 


int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int bytes)

{

    QEMUIOVector qiov;

    struct iovec iov = {

        .iov_base = (void *)buf,

        .iov_len = bytes,

    };

    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);



    if (bytes < 0) {

        return -EINVAL;

    }



    qemu_iovec_init_external(&qiov, &iov, 1);

    return bdrv_preadv(child, offset, &qiov);

}
@@ -978,17 +964,12 @@ int bdrv_pwritev(BdrvChild *child, int64_t offset, QEMUIOVector *qiov) 


int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf, int bytes)

{

    QEMUIOVector qiov;

    struct iovec iov = {

        .iov_base   = (void *) buf,

        .iov_len    = bytes,

    };

    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);



    if (bytes < 0) {

        return -EINVAL;

    }



    qemu_iovec_init_external(&qiov, &iov, 1);

    return bdrv_pwritev(child, offset, &qiov);

}
@@ -1165,7 +1146,6 @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child, 
    void *bounce_buffer;



    BlockDriver *drv = bs->drv;

    struct iovec iov;

    QEMUIOVector local_qiov;

    int64_t cluster_offset;

    int64_t cluster_bytes;
@@ -1230,9 +1210,8 @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child, 


        if (ret <= 0) {

            /* Must copy-on-read; use the bounce buffer */

            iov.iov_base = bounce_buffer;

            iov.iov_len = pnum = MIN(pnum, MAX_BOUNCE_BUFFER);

            qemu_iovec_init_external(&local_qiov, &iov, 1);

            pnum = MIN(pnum, MAX_BOUNCE_BUFFER);

            qemu_iovec_init_buf(&local_qiov, bounce_buffer, pnum);



            ret = bdrv_driver_preadv(bs, cluster_offset, pnum,

                                     &local_qiov, 0);
@@ -1477,7 +1456,7 @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs, 
{

    BlockDriver *drv = bs->drv;

    QEMUIOVector qiov;

    struct iovec iov = {0};

    void *buf = NULL;

    int ret = 0;

    bool need_flush = false;

    int head = 0;
@@ -1547,16 +1526,14 @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs, 
                need_flush = true;

            }

            num = MIN(num, max_transfer);

            iov.iov_len = num;

            if (iov.iov_base == NULL) {

                iov.iov_base = qemu_try_blockalign(bs, num);

                if (iov.iov_base == NULL) {

            if (buf == NULL) {

                buf = qemu_try_blockalign0(bs, num);

                if (buf == NULL) {

                    ret = -ENOMEM;

                    goto fail;

                }

                memset(iov.iov_base, 0, num);

            }

            qemu_iovec_init_external(&qiov, &iov, 1);

            qemu_iovec_init_buf(&qiov, buf, num);



            ret = bdrv_driver_pwritev(bs, offset, num, &qiov, write_flags);
@@ -1564,8 +1541,8 @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs, 
             * all future requests.

             */

            if (num < max_transfer) {

                qemu_vfree(iov.iov_base);

                iov.iov_base = NULL;

                qemu_vfree(buf);

                buf = NULL;

            }

        }
@@ -1577,7 +1554,7 @@ fail: 
    if (ret == 0 && need_flush) {

        ret = bdrv_co_flush(bs);

    }

    qemu_vfree(iov.iov_base);

    qemu_vfree(buf);

    return ret;

}
@@ -1763,7 +1740,6 @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child, 
    BlockDriverState *bs = child->bs;

    uint8_t *buf = NULL;

    QEMUIOVector local_qiov;

    struct iovec iov;

    uint64_t align = bs->bl.request_alignment;

    unsigned int head_padding_bytes, tail_padding_bytes;

    int ret = 0;
@@ -1775,11 +1751,7 @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child, 
    assert(flags & BDRV_REQ_ZERO_WRITE);

    if (head_padding_bytes || tail_padding_bytes) {

        buf = qemu_blockalign(bs, align);

        iov = (struct iovec) {

            .iov_base   = buf,

            .iov_len    = align,

        };

        qemu_iovec_init_external(&local_qiov, &iov, 1);

        qemu_iovec_init_buf(&local_qiov, buf, align);

    }

    if (head_padding_bytes) {

        uint64_t zero_bytes = MIN(bytes, align - head_padding_bytes);
@@ -1885,17 +1857,12 @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child, 


    if (offset & (align - 1)) {

        QEMUIOVector head_qiov;

        struct iovec head_iov;



        mark_request_serialising(&req, align);

        wait_serialising_requests(&req);



        head_buf = qemu_blockalign(bs, align);

        head_iov = (struct iovec) {

            .iov_base   = head_buf,

            .iov_len    = align,

        };

        qemu_iovec_init_external(&head_qiov, &head_iov, 1);

        qemu_iovec_init_buf(&head_qiov, head_buf, align);



        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);

        ret = bdrv_aligned_preadv(child, &req, offset & ~(align - 1), align,
@@ -1924,7 +1891,6 @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child, 


    if ((offset + bytes) & (align - 1)) {

        QEMUIOVector tail_qiov;

        struct iovec tail_iov;

        size_t tail_bytes;

        bool waited;
@@ -1933,11 +1899,7 @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child, 
        assert(!waited || !use_local_qiov);



        tail_buf = qemu_blockalign(bs, align);

        tail_iov = (struct iovec) {

            .iov_base   = tail_buf,

            .iov_len    = align,

        };

        qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);

        qemu_iovec_init_buf(&tail_qiov, tail_buf, align);



        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);

        ret = bdrv_aligned_preadv(child, &req, (offset + bytes) & ~(align - 1),
@@ -2468,15 +2430,9 @@ bdrv_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos, 
int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,

                      int64_t pos, int size)

{

    QEMUIOVector qiov;

    struct iovec iov = {

        .iov_base   = (void *) buf,

        .iov_len    = size,

    };

    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, size);

    int ret;



    qemu_iovec_init_external(&qiov, &iov, 1);



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

    if (ret < 0) {

        return ret;
@@ -2493,14 +2449,9 @@ int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t 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,

    };

    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, size);

    int ret;



    qemu_iovec_init_external(&qiov, &iov, 1);

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

    if (ret < 0) {

        return ret;

block/parallels.c

+5 −8
Original line number Diff line number Diff line
@@ -220,23 +220,20 @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, 
    if (bs->backing) {

        int64_t nb_cow_sectors = to_allocate * s->tracks;

        int64_t nb_cow_bytes = nb_cow_sectors << BDRV_SECTOR_BITS;

        QEMUIOVector qiov;

        struct iovec iov = {

            .iov_len = nb_cow_bytes,

            .iov_base = qemu_blockalign(bs, nb_cow_bytes)

        };

        qemu_iovec_init_external(&qiov, &iov, 1);

        QEMUIOVector qiov =

            QEMU_IOVEC_INIT_BUF(qiov, qemu_blockalign(bs, nb_cow_bytes),

                                nb_cow_bytes);



        ret = bdrv_co_preadv(bs->backing, idx * s->tracks * BDRV_SECTOR_SIZE,

                             nb_cow_bytes, &qiov, 0);

        if (ret < 0) {

            qemu_vfree(iov.iov_base);

            qemu_vfree(qemu_iovec_buf(&qiov));

            return ret;

        }



        ret = bdrv_co_pwritev(bs->file, s->data_end * BDRV_SECTOR_SIZE,

                              nb_cow_bytes, &qiov, 0);

        qemu_vfree(iov.iov_base);

        qemu_vfree(qemu_iovec_buf(&qiov));

        if (ret < 0) {

            return ret;

        }