Re: [Qemu-devel] [RFC PATCH v8 17/21] replay: replay aio requests

[Paolo Bonzini <pbonzini@redhat.com>]

On 22/01/2015 09:53, Pavel Dovgalyuk wrote:
> This patch adds identifier to aio requests. ID is used for creating bottom
> halves and identifying them while replaying.
> The patch also introduces several functions that make possible replaying
> of the aio requests.
> 
> Signed-off-by: Pavel Dovgalyuk <pavel.dovgaluk@ispras.ru>

Ah, some obscure parts of patch 16 now get clearer. :)

But it's still not clear what is the design.  You have to document this
too, then I (or others) can start reviewing the patches.

Paolo

> ---
>  block.c                        |   81 ++++++++++++++++++++++++++++++++++++----
>  block/block-backend.c          |   30 ++++++++++++++-
>  block/qcow2.c                  |    4 ++
>  dma-helpers.c                  |    6 ++-
>  hw/block/virtio-blk.c          |   10 ++---
>  hw/ide/atapi.c                 |   10 +++--
>  hw/ide/core.c                  |   14 ++++---
>  include/block/block.h          |   15 +++++++
>  include/qemu-common.h          |    2 +
>  include/sysemu/block-backend.h |   10 +++++
>  qemu-io-cmds.c                 |    2 -
>  stubs/replay.c                 |    5 ++
>  trace-events                   |    2 +
>  util/iov.c                     |    4 ++
>  14 files changed, 167 insertions(+), 28 deletions(-)
> 
> diff --git a/block.c b/block.c
> index a4f45c3..7f6fa8b 100644
> --- a/block.c
> +++ b/block.c
> @@ -83,7 +83,8 @@ static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
>                                           BdrvRequestFlags flags,
>                                           BlockCompletionFunc *cb,
>                                           void *opaque,
> -                                         bool is_write);
> +                                         bool is_write,
> +                                         bool aio_replay);
>  static void coroutine_fn bdrv_co_do_rw(void *opaque);
>  static int coroutine_fn bdrv_co_do_write_zeroes(BlockDriverState *bs,
>      int64_t sector_num, int nb_sectors, BdrvRequestFlags flags);
> @@ -4425,7 +4426,19 @@ BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
>      trace_bdrv_aio_readv(bs, sector_num, nb_sectors, opaque);
>  
>      return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
> -                                 cb, opaque, false);
> +                                 cb, opaque, false, false);
> +}
> +
> +BlockAIOCB *bdrv_aio_readv_replay(BlockDriverState *bs,
> +                                  int64_t sector_num,
> +                                  QEMUIOVector *qiov, int nb_sectors,
> +                                  BlockCompletionFunc *cb,
> +                                  void *opaque)
> +{
> +    trace_bdrv_aio_readv_replay(bs, sector_num, nb_sectors, opaque);
> +
> +    return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
> +                                 cb, opaque, false, true);
>  }
>  
>  BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
> @@ -4435,7 +4448,19 @@ BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
>      trace_bdrv_aio_writev(bs, sector_num, nb_sectors, opaque);
>  
>      return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
> -                                 cb, opaque, true);
> +                                 cb, opaque, true, false);
> +}
> +
> +BlockAIOCB *bdrv_aio_writev_replay(BlockDriverState *bs,
> +                                   int64_t sector_num,
> +                                   QEMUIOVector *qiov, int nb_sectors,
> +                                   BlockCompletionFunc *cb,
> +                                   void *opaque)
> +{
> +    trace_bdrv_aio_writev_replay(bs, sector_num, nb_sectors, opaque);
> +
> +    return bdrv_co_aio_rw_vector(bs, sector_num, qiov, nb_sectors, 0,
> +                                 cb, opaque, true, true);
>  }
>  
>  BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
> @@ -4446,7 +4471,7 @@ BlockAIOCB *bdrv_aio_write_zeroes(BlockDriverState *bs,
>  
>      return bdrv_co_aio_rw_vector(bs, sector_num, NULL, nb_sectors,
>                                   BDRV_REQ_ZERO_WRITE | flags,
> -                                 cb, opaque, true);
> +                                 cb, opaque, true, true);
>  }
>  
>  
> @@ -4593,7 +4618,8 @@ static int multiwrite_merge(BlockDriverState *bs, BlockRequest *reqs,
>   * requests. However, the fields opaque and error are left unmodified as they
>   * are used to signal failure for a single request to the caller.
>   */
> -int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
> +int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs,
> +                        bool replay)
>  {
>      MultiwriteCB *mcb;
>      int i;
> @@ -4631,7 +4657,7 @@ int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
>          bdrv_co_aio_rw_vector(bs, reqs[i].sector, reqs[i].qiov,
>                                reqs[i].nb_sectors, reqs[i].flags,
>                                multiwrite_cb, mcb,
> -                              true);
> +                              true, replay);
>      }
>  
>      return 0;
> @@ -4776,7 +4802,12 @@ static void coroutine_fn bdrv_co_do_rw(void *opaque)
>              acb->req.nb_sectors, acb->req.qiov, acb->req.flags);
>      }
>  
> -    acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
> +    if (acb->common.replay) {
> +        acb->bh = aio_bh_new_replay(bdrv_get_aio_context(bs), bdrv_co_em_bh,
> +                                    acb, acb->common.replay_step);
> +    } else {
> +        acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
> +    }
>      qemu_bh_schedule(acb->bh);
>  }
>  
> @@ -4787,7 +4818,8 @@ static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
>                                           BdrvRequestFlags flags,
>                                           BlockCompletionFunc *cb,
>                                           void *opaque,
> -                                         bool is_write)
> +                                         bool is_write,
> +                                         bool aio_replay)
>  {
>      Coroutine *co;
>      BlockAIOCBCoroutine *acb;
> @@ -4798,6 +4830,11 @@ static BlockAIOCB *bdrv_co_aio_rw_vector(BlockDriverState *bs,
>      acb->req.qiov = qiov;
>      acb->req.flags = flags;
>      acb->is_write = is_write;
> +    acb->done = NULL;
> +    acb->common.replay = aio_replay;
> +    if (aio_replay) {
> +        acb->common.replay_step = replay_get_current_step();
> +    }
>  
>      co = qemu_coroutine_create(bdrv_co_do_rw);
>      qemu_coroutine_enter(co, acb);
> @@ -4811,7 +4848,12 @@ static void coroutine_fn bdrv_aio_flush_co_entry(void *opaque)
>      BlockDriverState *bs = acb->common.bs;
>  
>      acb->req.error = bdrv_co_flush(bs);
> -    acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
> +    if (acb->common.replay) {
> +        acb->bh = aio_bh_new_replay(bdrv_get_aio_context(bs), bdrv_co_em_bh,
> +                                    acb, acb->common.replay_step);
> +    } else {
> +        acb->bh = aio_bh_new(bdrv_get_aio_context(bs), bdrv_co_em_bh, acb);
> +    }
>      qemu_bh_schedule(acb->bh);
>  }
>  
> @@ -4831,6 +4873,25 @@ BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
>      return &acb->common;
>  }
>  
> +BlockAIOCB *bdrv_aio_flush_replay(BlockDriverState *bs,
> +        BlockCompletionFunc *cb, void *opaque)
> +{
> +    trace_bdrv_aio_flush(bs, opaque);
> +
> +    Coroutine *co;
> +    BlockAIOCBCoroutine *acb;
> +
> +    acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
> +    acb->done = NULL;
> +    acb->common.replay = true;
> +    acb->common.replay_step = replay_get_current_step();
> +
> +    co = qemu_coroutine_create(bdrv_aio_flush_co_entry);
> +    qemu_coroutine_enter(co, acb);
> +
> +    return &acb->common;
> +}
> +
>  static void coroutine_fn bdrv_aio_discard_co_entry(void *opaque)
>  {
>      BlockAIOCBCoroutine *acb = opaque;
> @@ -4881,6 +4942,8 @@ void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
>      acb->cb = cb;
>      acb->opaque = opaque;
>      acb->refcnt = 1;
> +    acb->replay_step = 0;
> +    acb->replay = false;
>      return acb;
>  }
>  
> diff --git a/block/block-backend.c b/block/block-backend.c
> index d00c129..451041a 100644
> --- a/block/block-backend.c
> +++ b/block/block-backend.c
> @@ -447,6 +447,14 @@ BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num,
>      return bdrv_aio_readv(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
>  }
>  
> +BlockAIOCB *blk_aio_readv_replay(BlockBackend *blk, int64_t sector_num,
> +                                 QEMUIOVector *iov, int nb_sectors,
> +                                 BlockCompletionFunc *cb, void *opaque)
> +{
> +    return bdrv_aio_readv_replay(blk->bs, sector_num, iov, nb_sectors,
> +                                 cb, opaque);
> +}
> +
>  BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
>                             QEMUIOVector *iov, int nb_sectors,
>                             BlockCompletionFunc *cb, void *opaque)
> @@ -454,12 +462,26 @@ BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
>      return bdrv_aio_writev(blk->bs, sector_num, iov, nb_sectors, cb, opaque);
>  }
>  
> +BlockAIOCB *blk_aio_writev_replay(BlockBackend *blk, int64_t sector_num,
> +                                  QEMUIOVector *iov, int nb_sectors,
> +                                  BlockCompletionFunc *cb, void *opaque)
> +{
> +    return bdrv_aio_writev_replay(blk->bs, sector_num, iov, nb_sectors,
> +                                  cb, opaque);
> +}
> +
>  BlockAIOCB *blk_aio_flush(BlockBackend *blk,
>                            BlockCompletionFunc *cb, void *opaque)
>  {
>      return bdrv_aio_flush(blk->bs, cb, opaque);
>  }
>  
> +BlockAIOCB *blk_aio_flush_replay(BlockBackend *blk,
> +                                 BlockCompletionFunc *cb, void *opaque)
> +{
> +    return bdrv_aio_flush_replay(blk->bs, cb, opaque);
> +}
> +
>  BlockAIOCB *blk_aio_discard(BlockBackend *blk,
>                              int64_t sector_num, int nb_sectors,
>                              BlockCompletionFunc *cb, void *opaque)
> @@ -479,7 +501,13 @@ void blk_aio_cancel_async(BlockAIOCB *acb)
>  
>  int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs)
>  {
> -    return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs);
> +    return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs, false);
> +}
> +
> +int blk_aio_multiwrite_replay(BlockBackend *blk, BlockRequest *reqs,
> +                              int num_reqs)
> +{
> +    return bdrv_aio_multiwrite(blk->bs, reqs, num_reqs, true);
>  }
>  
>  int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
> diff --git a/block/qcow2.c b/block/qcow2.c
> index e4e690a..4a2f6ae 100644
> --- a/block/qcow2.c
> +++ b/block/qcow2.c
> @@ -1140,6 +1140,8 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,
>      uint8_t *cluster_data = NULL;
>  
>      qemu_iovec_init(&hd_qiov, qiov->niov);
> +    hd_qiov.replay = qiov->replay;
> +    hd_qiov.replay_step = qiov->replay_step;
>  
>      qemu_co_mutex_lock(&s->lock);
>  
> @@ -1297,6 +1299,8 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,
>                                   remaining_sectors);
>  
>      qemu_iovec_init(&hd_qiov, qiov->niov);
> +    hd_qiov.replay = qiov->replay;
> +    hd_qiov.replay_step = qiov->replay_step;
>  
>      s->cluster_cache_offset = -1; /* disable compressed cache */
>  
> diff --git a/dma-helpers.c b/dma-helpers.c
> index 357d7e9..4faf6d3 100644
> --- a/dma-helpers.c
> +++ b/dma-helpers.c
> @@ -212,6 +212,8 @@ BlockAIOCB *dma_blk_io(
>      dbs->io_func = io_func;
>      dbs->bh = NULL;
>      qemu_iovec_init(&dbs->iov, sg->nsg);
> +    dbs->iov.replay = true;
> +    dbs->iov.replay_step = replay_get_current_step();
>      dma_blk_cb(dbs, 0);
>      return &dbs->common;
>  }
> @@ -221,7 +223,7 @@ BlockAIOCB *dma_blk_read(BlockBackend *blk,
>                           QEMUSGList *sg, uint64_t sector,
>                           void (*cb)(void *opaque, int ret), void *opaque)
>  {
> -    return dma_blk_io(blk, sg, sector, blk_aio_readv, cb, opaque,
> +    return dma_blk_io(blk, sg, sector, blk_aio_readv_replay, cb, opaque,
>                        DMA_DIRECTION_FROM_DEVICE);
>  }
>  
> @@ -229,7 +231,7 @@ BlockAIOCB *dma_blk_write(BlockBackend *blk,
>                            QEMUSGList *sg, uint64_t sector,
>                            void (*cb)(void *opaque, int ret), void *opaque)
>  {
> -    return dma_blk_io(blk, sg, sector, blk_aio_writev, cb, opaque,
> +    return dma_blk_io(blk, sg, sector, blk_aio_writev_replay, cb, opaque,
>                        DMA_DIRECTION_TO_DEVICE);
>  }
>  
> diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
> index b19b102..2413cbe 100644
> --- a/hw/block/virtio-blk.c
> +++ b/hw/block/virtio-blk.c
> @@ -265,7 +265,7 @@ void virtio_submit_multiwrite(BlockBackend *blk, MultiReqBuffer *mrb)
>          return;
>      }
>  
> -    ret = blk_aio_multiwrite(blk, mrb->blkreq, mrb->num_writes);
> +    ret = blk_aio_multiwrite_replay(blk, mrb->blkreq, mrb->num_writes);
>      if (ret != 0) {
>          for (i = 0; i < mrb->num_writes; i++) {
>              if (mrb->blkreq[i].error) {
> @@ -286,7 +286,7 @@ static void virtio_blk_handle_flush(VirtIOBlockReq *req, MultiReqBuffer *mrb)
>       * Make sure all outstanding writes are posted to the backing device.
>       */
>      virtio_submit_multiwrite(req->dev->blk, mrb);
> -    blk_aio_flush(req->dev->blk, virtio_blk_flush_complete, req);
> +    blk_aio_flush_replay(req->dev->blk, virtio_blk_flush_complete, req);
>  }
>  
>  static bool virtio_blk_sect_range_ok(VirtIOBlock *dev,
> @@ -357,9 +357,9 @@ static void virtio_blk_handle_read(VirtIOBlockReq *req)
>  
>      block_acct_start(blk_get_stats(req->dev->blk), &req->acct, req->qiov.size,
>                       BLOCK_ACCT_READ);
> -    blk_aio_readv(req->dev->blk, sector, &req->qiov,
> -                  req->qiov.size / BDRV_SECTOR_SIZE,
> -                  virtio_blk_rw_complete, req);
> +    blk_aio_readv_replay(req->dev->blk, sector, &req->qiov,
> +                          req->qiov.size / BDRV_SECTOR_SIZE,
> +                          virtio_blk_rw_complete, req);
>  }
>  
>  void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
> diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c
> index a71e6e0..a69b620 100644
> --- a/hw/ide/atapi.c
> +++ b/hw/ide/atapi.c
> @@ -25,7 +25,7 @@
>  
>  #include "hw/ide/internal.h"
>  #include "hw/scsi/scsi.h"
> -#include "sysemu/block-backend.h"
> +#include "replay/replay.h"
>  
>  static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret);
>  
> @@ -350,10 +350,12 @@ static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
>      s->bus->dma->iov.iov_base = (void *)(s->io_buffer + data_offset);
>      s->bus->dma->iov.iov_len = n * 4 * 512;
>      qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1);
> +    s->bus->dma->qiov.replay = true;
> +    s->bus->dma->qiov.replay_step = replay_get_current_step();
>  
> -    s->bus->dma->aiocb = blk_aio_readv(s->blk, (int64_t)s->lba << 2,
> -                                       &s->bus->dma->qiov, n * 4,
> -                                       ide_atapi_cmd_read_dma_cb, s);
> +    s->bus->dma->aiocb = blk_aio_readv_replay(s->blk, (int64_t)s->lba << 2,
> +                                              &s->bus->dma->qiov, n * 4,
> +                                              ide_atapi_cmd_read_dma_cb, s);
>      return;
>  
>  eot:
> diff --git a/hw/ide/core.c b/hw/ide/core.c
> index d76244a..1fff193 100644
> --- a/hw/ide/core.c
> +++ b/hw/ide/core.c
> @@ -630,11 +630,13 @@ void ide_sector_read(IDEState *s)
>      s->iov.iov_base = s->io_buffer;
>      s->iov.iov_len  = n * BDRV_SECTOR_SIZE;
>      qemu_iovec_init_external(&s->qiov, &s->iov, 1);
> +    s->qiov.replay = true;
> +    s->qiov.replay_step = replay_get_current_step();
>  
>      block_acct_start(blk_get_stats(s->blk), &s->acct,
>                       n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
> -    s->pio_aiocb = blk_aio_readv(s->blk, sector_num, &s->qiov, n,
> -                                 ide_sector_read_cb, s);
> +    s->pio_aiocb = blk_aio_readv_replay(s->blk, sector_num, &s->qiov, n,
> +                                        ide_sector_read_cb, s);
>  }
>  
>  static void dma_buf_commit(IDEState *s, uint32_t tx_bytes)
> @@ -888,11 +890,13 @@ void ide_sector_write(IDEState *s)
>      s->iov.iov_base = s->io_buffer;
>      s->iov.iov_len  = n * BDRV_SECTOR_SIZE;
>      qemu_iovec_init_external(&s->qiov, &s->iov, 1);
> +    s->qiov.replay = true;
> +    s->qiov.replay_step = replay_get_current_step();
>  
>      block_acct_start(blk_get_stats(s->blk), &s->acct,
>                       n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
> -    s->pio_aiocb = blk_aio_writev(s->blk, sector_num, &s->qiov, n,
> -                                  ide_sector_write_cb, s);
> +    s->pio_aiocb = blk_aio_writev_replay(s->blk, sector_num, &s->qiov, n,
> +                                         ide_sector_write_cb, s);
>  }
>  
>  static void ide_flush_cb(void *opaque, int ret)
> @@ -928,7 +932,7 @@ void ide_flush_cache(IDEState *s)
>  
>      s->status |= BUSY_STAT;
>      block_acct_start(blk_get_stats(s->blk), &s->acct, 0, BLOCK_ACCT_FLUSH);
> -    s->pio_aiocb = blk_aio_flush(s->blk, ide_flush_cb, s);
> +    s->pio_aiocb = blk_aio_flush_replay(s->blk, ide_flush_cb, s);
>  }
>  
>  static void ide_cfata_metadata_inquiry(IDEState *s)
> diff --git a/include/block/block.h b/include/block/block.h
> index 3082d2b..06ce097 100644
> --- a/include/block/block.h
> +++ b/include/block/block.h
> @@ -293,11 +293,24 @@ typedef void BlockDriverDirtyHandler(BlockDriverState *bs, int64_t sector,
>  BlockAIOCB *bdrv_aio_readv(BlockDriverState *bs, int64_t sector_num,
>                             QEMUIOVector *iov, int nb_sectors,
>                             BlockCompletionFunc *cb, void *opaque);
> +BlockAIOCB *bdrv_aio_readv_replay(BlockDriverState *bs,
> +                                  int64_t sector_num,
> +                                  QEMUIOVector *iov, int nb_sectors,
> +                                  BlockCompletionFunc *cb,
> +                                  void *opaque);
>  BlockAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
>                              QEMUIOVector *iov, int nb_sectors,
>                              BlockCompletionFunc *cb, void *opaque);
> +BlockAIOCB *bdrv_aio_writev_replay(BlockDriverState *bs,
> +                                   int64_t sector_num,
> +                                   QEMUIOVector *iov, int nb_sectors,
> +                                   BlockCompletionFunc *cb,
> +                                   void *opaque);
>  BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
>                             BlockCompletionFunc *cb, void *opaque);
> +BlockAIOCB *bdrv_aio_flush_replay(BlockDriverState *bs,
> +                                  BlockCompletionFunc *cb,
> +                                  void *opaque);
>  BlockAIOCB *bdrv_aio_discard(BlockDriverState *bs,
>                               int64_t sector_num, int nb_sectors,
>                               BlockCompletionFunc *cb, void *opaque);
> @@ -318,7 +331,7 @@ typedef struct BlockRequest {
>  } BlockRequest;
>  
>  int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs,
> -    int num_reqs);
> +                        int num_reqs, bool replay);
>  
>  /* sg packet commands */
>  int bdrv_ioctl(BlockDriverState *bs, unsigned long int req, void *buf);
> diff --git a/include/qemu-common.h b/include/qemu-common.h
> index 8c9957e..016556a 100644
> --- a/include/qemu-common.h
> +++ b/include/qemu-common.h
> @@ -320,6 +320,8 @@ typedef struct QEMUIOVector {
>      int niov;
>      int nalloc;
>      size_t size;
> +    bool replay;
> +    uint64_t replay_step;
>  } QEMUIOVector;
>  
>  void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
> diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
> index 8871a02..c34855e 100644
> --- a/include/sysemu/block-backend.h
> +++ b/include/sysemu/block-backend.h
> @@ -94,17 +94,27 @@ void blk_get_geometry(BlockBackend *blk, uint64_t *nb_sectors_ptr);
>  BlockAIOCB *blk_aio_readv(BlockBackend *blk, int64_t sector_num,
>                            QEMUIOVector *iov, int nb_sectors,
>                            BlockCompletionFunc *cb, void *opaque);
> +BlockAIOCB *blk_aio_readv_replay(BlockBackend *blk, int64_t sector_num,
> +                                 QEMUIOVector *iov, int nb_sectors,
> +                                 BlockCompletionFunc *cb, void *opaque);
>  BlockAIOCB *blk_aio_writev(BlockBackend *blk, int64_t sector_num,
>                             QEMUIOVector *iov, int nb_sectors,
>                             BlockCompletionFunc *cb, void *opaque);
> +BlockAIOCB *blk_aio_writev_replay(BlockBackend *blk, int64_t sector_num,
> +                                  QEMUIOVector *iov, int nb_sectors,
> +                                  BlockCompletionFunc *cb, void *opaque);
>  BlockAIOCB *blk_aio_flush(BlockBackend *blk,
>                            BlockCompletionFunc *cb, void *opaque);
> +BlockAIOCB *blk_aio_flush_replay(BlockBackend *blk,
> +                                 BlockCompletionFunc *cb, void *opaque);
>  BlockAIOCB *blk_aio_discard(BlockBackend *blk,
>                              int64_t sector_num, int nb_sectors,
>                              BlockCompletionFunc *cb, void *opaque);
>  void blk_aio_cancel(BlockAIOCB *acb);
>  void blk_aio_cancel_async(BlockAIOCB *acb);
>  int blk_aio_multiwrite(BlockBackend *blk, BlockRequest *reqs, int num_reqs);
> +int blk_aio_multiwrite_replay(BlockBackend *blk, BlockRequest *reqs,
> +                              int num_reqs);
>  int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
>  BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
>                            BlockCompletionFunc *cb, void *opaque);
> diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
> index e708552..a7d8d4e 100644
> --- a/qemu-io-cmds.c
> +++ b/qemu-io-cmds.c
> @@ -583,7 +583,7 @@ static int do_aio_multiwrite(BlockDriverState *bs, BlockRequest* reqs,
>          *total += reqs[i].qiov->size;
>      }
>  
> -    ret = bdrv_aio_multiwrite(bs, reqs, num_reqs);
> +    ret = bdrv_aio_multiwrite(bs, reqs, num_reqs, false);
>      if (ret < 0) {
>          return ret;
>      }
> diff --git a/stubs/replay.c b/stubs/replay.c
> index 268f3e0..95b43f3 100755
> --- a/stubs/replay.c
> +++ b/stubs/replay.c
> @@ -25,3 +25,8 @@ int runstate_is_running(void)
>  void replay_add_bh_event(void *bh, uint64_t id)
>  {
>  }
> +
> +uint64_t replay_get_current_step(void)
> +{
> +    return 0;
> +}
> diff --git a/trace-events b/trace-events
> index 4ec81eb..2dd21ef 100644
> --- a/trace-events
> +++ b/trace-events
> @@ -64,7 +64,9 @@ bdrv_aio_multiwrite(void *mcb, int num_callbacks, int num_reqs) "mcb %p num_call
>  bdrv_aio_discard(void *bs, int64_t sector_num, int nb_sectors, void *opaque) "bs %p sector_num %"PRId64" nb_sectors %d opaque %p"
>  bdrv_aio_flush(void *bs, void *opaque) "bs %p opaque %p"
>  bdrv_aio_readv(void *bs, int64_t sector_num, int nb_sectors, void *opaque) "bs %p sector_num %"PRId64" nb_sectors %d opaque %p"
> +bdrv_aio_readv_replay(void *bs, int64_t sector_num, int nb_sectors, void *opaque) "bs %p sector_num %"PRId64" nb_sectors %d opaque %p"
>  bdrv_aio_writev(void *bs, int64_t sector_num, int nb_sectors, void *opaque) "bs %p sector_num %"PRId64" nb_sectors %d opaque %p"
> +bdrv_aio_writev_replay(void *bs, int64_t sector_num, int nb_sectors, void *opaque) "bs %p sector_num %"PRId64" nb_sectors %d opaque %p"
>  bdrv_aio_write_zeroes(void *bs, int64_t sector_num, int nb_sectors, int flags, void *opaque) "bs %p sector_num %"PRId64" nb_sectors %d flags %#x opaque %p"
>  bdrv_lock_medium(void *bs, bool locked) "bs %p locked %d"
>  bdrv_co_readv(void *bs, int64_t sector_num, int nb_sector) "bs %p sector_num %"PRId64" nb_sectors %d"
> diff --git a/util/iov.c b/util/iov.c
> index 2fb18e6..96517e7 100644
> --- a/util/iov.c
> +++ b/util/iov.c
> @@ -257,6 +257,8 @@ void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
>      qiov->niov = 0;
>      qiov->nalloc = alloc_hint;
>      qiov->size = 0;
> +    qiov->replay = false;
> +    qiov->replay_step = 0;
>  }
>  
>  void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
> @@ -267,6 +269,8 @@ void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
>      qiov->niov = niov;
>      qiov->nalloc = -1;
>      qiov->size = 0;
> +    qiov->replay = false;
> +    qiov->replay_step = 0;
>      for (i = 0; i < niov; i++)
>          qiov->size += iov[i].iov_len;
>  }
> 
> 
>