Commit 2926375c 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 Tue 06 Sep 2016 11:38:01 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: (36 commits)
  block: Allow node name for 'qemu-io' HMP command
  qemu-iotests: Log QMP traffic in debug mode
  block jobs: Improve error message for missing job ID
  coroutine: Assert that no locks are held on termination
  coroutine: Let CoMutex remember who holds it
  qcow2: fix iovec size at qcow2_co_pwritev_compressed
  test-coroutine: Fix coroutine pool corruption
  qemu-iotests: add vmdk for test backup compression in 055
  qemu-iotests: test backup compression in 055
  blockdev-backup: added support for data compression
  drive-backup: added support for data compression
  block: simplify blockdev-backup
  block: simplify drive-backup
  block/io: turn on dirty_bitmaps for the compressed writes
  block: remove BlockDriver.bdrv_write_compressed
  qcow: cleanup qcow_co_pwritev_compressed to avoid the recursion
  qcow: add qcow_co_pwritev_compressed
  vmdk: add vmdk_co_pwritev_compressed
  qcow2: cleanup qcow2_co_pwritev_compressed to avoid the recursion
  qcow2: add qcow2_co_pwritev_compressed
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents f9ae6bcf e7f98f2f

block.c

+2 −0
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include "trace.h"

#include "block/block_int.h"

#include "block/blockjob.h"

#include "block/nbd.h"

#include "qemu/error-report.h"

#include "qemu/module.h"

#include "qapi/qmp/qerror.h"
@@ -2206,6 +2207,7 @@ static void bdrv_close(BlockDriverState *bs) 
void bdrv_close_all(void)

{

    block_job_cancel_sync_all();

    nbd_export_close_all();



    /* Drop references from requests still in flight, such as canceled block

     * jobs whose AIO context has not been polled yet */

block/backup.c

+11 −1
Original line number Diff line number Diff line
@@ -47,6 +47,7 @@ typedef struct BackupBlockJob { 
    uint64_t sectors_read;

    unsigned long *done_bitmap;

    int64_t cluster_size;

    bool compress;

    NotifierWithReturn before_write;

    QLIST_HEAD(, CowRequest) inflight_reqs;

} BackupBlockJob;
@@ -154,7 +155,8 @@ static int coroutine_fn backup_do_cow(BackupBlockJob *job, 
                                       bounce_qiov.size, BDRV_REQ_MAY_UNMAP);

        } else {

            ret = blk_co_pwritev(job->target, start * job->cluster_size,

                                 bounce_qiov.size, &bounce_qiov, 0);

                                 bounce_qiov.size, &bounce_qiov,

                                 job->compress ? BDRV_REQ_WRITE_COMPRESSED : 0);

        }

        if (ret < 0) {

            trace_backup_do_cow_write_fail(job, start, ret);
@@ -477,6 +479,7 @@ static void coroutine_fn backup_run(void *opaque) 
void backup_start(const char *job_id, BlockDriverState *bs,

                  BlockDriverState *target, int64_t speed,

                  MirrorSyncMode sync_mode, BdrvDirtyBitmap *sync_bitmap,

                  bool compress,

                  BlockdevOnError on_source_error,

                  BlockdevOnError on_target_error,

                  BlockCompletionFunc *cb, void *opaque,
@@ -507,6 +510,12 @@ void backup_start(const char *job_id, BlockDriverState *bs, 
        return;

    }



    if (compress && target->drv->bdrv_co_pwritev_compressed == NULL) {

        error_setg(errp, "Compression is not supported for this drive %s",

                   bdrv_get_device_name(target));

        return;

    }



    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {

        return;

    }
@@ -555,6 +564,7 @@ void backup_start(const char *job_id, BlockDriverState *bs, 
    job->sync_mode = sync_mode;

    job->sync_bitmap = sync_mode == MIRROR_SYNC_MODE_INCREMENTAL ?

                       sync_bitmap : NULL;

    job->compress = compress;



    /* If there is no backing file on the target, we cannot rely on COW if our

     * backup cluster size is smaller than the target cluster size. Even for

block/block-backend.c

+20 −23
Original line number Diff line number Diff line
@@ -409,6 +409,22 @@ bool bdrv_has_blk(BlockDriverState *bs) 
    return bdrv_first_blk(bs) != NULL;

}



/*

 * Returns true if @bs has only BlockBackends as parents.

 */

bool bdrv_is_root_node(BlockDriverState *bs)

{

    BdrvChild *c;



    QLIST_FOREACH(c, &bs->parents, next_parent) {

        if (c->role != &child_root) {

            return false;

        }

    }



    return true;

}



/*

 * Return @blk's DriveInfo if any, else null.

 */
@@ -727,21 +743,6 @@ static int blk_check_byte_request(BlockBackend *blk, int64_t offset, 
    return 0;

}



static int blk_check_request(BlockBackend *blk, int64_t sector_num,

                             int nb_sectors)

{

    if (sector_num < 0 || sector_num > INT64_MAX / BDRV_SECTOR_SIZE) {

        return -EIO;

    }



    if (nb_sectors < 0 || nb_sectors > INT_MAX / BDRV_SECTOR_SIZE) {

        return -EIO;

    }



    return blk_check_byte_request(blk, sector_num * BDRV_SECTOR_SIZE,

                                  nb_sectors * BDRV_SECTOR_SIZE);

}



int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,

                               unsigned int bytes, QEMUIOVector *qiov,

                               BdrvRequestFlags flags)
@@ -1484,15 +1485,11 @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset, 
                          flags | BDRV_REQ_ZERO_WRITE);

}



int blk_write_compressed(BlockBackend *blk, int64_t sector_num,

                         const uint8_t *buf, int nb_sectors)

int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,

                          int count)

{

    int ret = blk_check_request(blk, sector_num, nb_sectors);

    if (ret < 0) {

        return ret;

    }



    return bdrv_write_compressed(blk_bs(blk), sector_num, buf, nb_sectors);

    return blk_prw(blk, offset, (void *) buf, count, blk_write_entry,

                   BDRV_REQ_WRITE_COMPRESSED);

}



int blk_truncate(BlockBackend *blk, int64_t offset)

block/io.c

+15 −33
Original line number Diff line number Diff line
@@ -540,17 +540,6 @@ static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, 
    return 0;

}



static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,

                              int nb_sectors)

{

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

        return -EIO;

    }



    return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,

                                   nb_sectors * BDRV_SECTOR_SIZE);

}



typedef struct RwCo {

    BdrvChild *child;

    int64_t offset;
@@ -897,6 +886,19 @@ emulate_flags: 
    return ret;

}



static int coroutine_fn

bdrv_driver_pwritev_compressed(BlockDriverState *bs, uint64_t offset,

                               uint64_t bytes, QEMUIOVector *qiov)

{

    BlockDriver *drv = bs->drv;



    if (!drv->bdrv_co_pwritev_compressed) {

        return -ENOTSUP;

    }



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

}



static int coroutine_fn bdrv_co_do_copy_on_readv(BlockDriverState *bs,

        int64_t offset, unsigned int bytes, QEMUIOVector *qiov)

{
@@ -1315,6 +1317,8 @@ static int coroutine_fn bdrv_aligned_pwritev(BlockDriverState *bs, 
    } else if (flags & BDRV_REQ_ZERO_WRITE) {

        bdrv_debug_event(bs, BLKDBG_PWRITEV_ZERO);

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

    } else if (flags & BDRV_REQ_WRITE_COMPRESSED) {

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

    } else if (bytes <= max_transfer) {

        bdrv_debug_event(bs, BLKDBG_PWRITEV);

        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, flags);
@@ -1879,28 +1883,6 @@ int bdrv_is_allocated_above(BlockDriverState *top, 
    return 0;

}



int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,

                          const uint8_t *buf, int nb_sectors)

{

    BlockDriver *drv = bs->drv;

    int ret;



    if (!drv) {

        return -ENOMEDIUM;

    }

    if (!drv->bdrv_write_compressed) {

        return -ENOTSUP;

    }

    ret = bdrv_check_request(bs, sector_num, nb_sectors);

    if (ret < 0) {

        return ret;

    }



    assert(QLIST_EMPTY(&bs->dirty_bitmaps));



    return drv->bdrv_write_compressed(bs, sector_num, buf, nb_sectors);

}



typedef struct BdrvVmstateCo {

    BlockDriverState    *bs;

    QEMUIOVector        *qiov;

block/qcow.c

+39 −74
Original line number Diff line number Diff line
@@ -913,75 +913,32 @@ static int qcow_make_empty(BlockDriverState *bs) 
    return 0;

}



typedef struct QcowWriteCo {

    BlockDriverState *bs;

    int64_t sector_num;

    const uint8_t *buf;

    int nb_sectors;

    int ret;

} QcowWriteCo;



static void qcow_write_co_entry(void *opaque)

{

    QcowWriteCo *co = opaque;

    QEMUIOVector qiov;



    struct iovec iov = (struct iovec) {

        .iov_base   = (uint8_t*) co->buf,

        .iov_len    = co->nb_sectors * BDRV_SECTOR_SIZE,

    };

    qemu_iovec_init_external(&qiov, &iov, 1);



    co->ret = qcow_co_writev(co->bs, co->sector_num, co->nb_sectors, &qiov);

}



/* Wrapper for non-coroutine contexts */

static int qcow_write(BlockDriverState *bs, int64_t sector_num,

                      const uint8_t *buf, int nb_sectors)

{

    Coroutine *co;

    AioContext *aio_context = bdrv_get_aio_context(bs);

    QcowWriteCo data = {

        .bs         = bs,

        .sector_num = sector_num,

        .buf        = buf,

        .nb_sectors = nb_sectors,

        .ret        = -EINPROGRESS,

    };

    co = qemu_coroutine_create(qcow_write_co_entry, &data);

    qemu_coroutine_enter(co);

    while (data.ret == -EINPROGRESS) {

        aio_poll(aio_context, true);

    }

    return data.ret;

}



/* XXX: put compressed sectors first, then all the cluster aligned

   tables to avoid losing bytes in alignment */

static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num,

                                 const uint8_t *buf, int nb_sectors)

static coroutine_fn int

qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,

                           uint64_t bytes, QEMUIOVector *qiov)

{

    BDRVQcowState *s = bs->opaque;

    QEMUIOVector hd_qiov;

    struct iovec iov;

    z_stream strm;

    int ret, out_len;

    uint8_t *out_buf;

    uint8_t *buf, *out_buf;

    uint64_t cluster_offset;



    if (nb_sectors != s->cluster_sectors) {

        ret = -EINVAL;



        /* Zero-pad last write if image size is not cluster aligned */

        if (sector_num + nb_sectors == bs->total_sectors &&

            nb_sectors < s->cluster_sectors) {

            uint8_t *pad_buf = qemu_blockalign(bs, s->cluster_size);

            memset(pad_buf, 0, s->cluster_size);

            memcpy(pad_buf, buf, nb_sectors * BDRV_SECTOR_SIZE);

            ret = qcow_write_compressed(bs, sector_num,

                                        pad_buf, s->cluster_sectors);

            qemu_vfree(pad_buf);

    buf = qemu_blockalign(bs, s->cluster_size);

    if (bytes != s->cluster_size) {

        if (bytes > s->cluster_size ||

            offset + bytes != bs->total_sectors << BDRV_SECTOR_BITS)

        {

            qemu_vfree(buf);

            return -EINVAL;

        }

        return ret;

        /* Zero-pad last write if image size is not cluster aligned */

        memset(buf + bytes, 0, s->cluster_size - bytes);

    }

    qemu_iovec_to_buf(qiov, 0, buf, qiov->size);



    out_buf = g_malloc(s->cluster_size);
@@ -1012,27 +969,35 @@ static int qcow_write_compressed(BlockDriverState *bs, int64_t sector_num, 


    if (ret != Z_STREAM_END || out_len >= s->cluster_size) {

        /* could not compress: write normal cluster */

        ret = qcow_write(bs, sector_num, buf, s->cluster_sectors);

        ret = qcow_co_writev(bs, offset >> BDRV_SECTOR_BITS,

                             bytes >> BDRV_SECTOR_BITS, qiov);

        if (ret < 0) {

            goto fail;

        }

    } else {

        cluster_offset = get_cluster_offset(bs, sector_num << 9, 2,

                                            out_len, 0, 0);

        goto success;

    }

    qemu_co_mutex_lock(&s->lock);

    cluster_offset = get_cluster_offset(bs, offset, 2, out_len, 0, 0);

    qemu_co_mutex_unlock(&s->lock);

    if (cluster_offset == 0) {

        ret = -EIO;

        goto fail;

    }



    cluster_offset &= s->cluster_offset_mask;

        ret = bdrv_pwrite(bs->file, cluster_offset, out_buf, out_len);



    iov = (struct iovec) {

        .iov_base   = out_buf,

        .iov_len    = out_len,

    };

    qemu_iovec_init_external(&hd_qiov, &iov, 1);

    ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0);

    if (ret < 0) {

        goto fail;

    }

    }



success:

    ret = 0;

fail:

    qemu_vfree(buf);

    g_free(out_buf);

    return ret;

}
@@ -1085,7 +1050,7 @@ static BlockDriver bdrv_qcow = { 


    .bdrv_set_key           = qcow_set_key,

    .bdrv_make_empty        = qcow_make_empty,

    .bdrv_write_compressed  = qcow_write_compressed,

    .bdrv_co_pwritev_compressed = qcow_co_pwritev_compressed,

    .bdrv_get_info          = qcow_get_info,



    .create_opts            = &qcow_create_opts,