The following changes since commit 22dbfdecc3c52228d3489da3fe81da92b21197bf:

Merge remote-tracking branch 'remotes/awilliam/tags/vfio-update-20191010.0' into staging (2019-10-14 15:09:08 +0100)

for you to fetch changes up to a1406a9262a087d9ec9627b88da13c4590b61dae:

iotests: Test large write request to qcow2 file (2019-10-14 17:12:48 +0200)

Block layer patches:

- block: Fix crash with qcow2 partial cluster COW with small cluster

sizes (misaligned write requests with BDRV_REQ_NO_FALLBACK)

- qcow2: Fix integer overflow potentially causing corruption with huge

requests

- vhdx: Detect truncated image files

- tools: Support help options for --object

- Various block-related replay improvements

- iotests/028: Fix for long $TEST_DIRs

Alberto Garcia (1):

block: Reject misaligned write requests with BDRV_REQ_NO_FALLBACK

Kevin Wolf (4):

vl: Split off user_creatable_print_help()

qemu-io: Support help options for --object

qemu-img: Support help options for --object

qemu-nbd: Support help options for --object

Max Reitz (3):

iotests/028: Fix for long $TEST_DIRs

qcow2: Limit total allocation range to INT_MAX

iotests: Test large write request to qcow2 file

Pavel Dovgaluk (6):

block: implement bdrv_snapshot_goto for blkreplay

replay: disable default snapshot for record/replay

replay: update docs for record/replay with block devices

replay: don't drain/flush bdrv queue while RR is working

replay: finish record/replay before closing the disks

replay: add BH oneshot event for block layer

Peter Lieven (1):

block/vhdx: add check for truncated image files

docs/replay.txt | 12 +++-

include/qom/object_interfaces.h | 12 ++++

include/sysemu/replay.h | 4 ++

replay/replay-internal.h | 1 +

block/blkreplay.c | 8 +++

block/block-backend.c | 9 ++-

block/io.c | 39 ++++++++++++-

block/iscsi.c | 5 +-

block/nfs.c | 6 +-

block/null.c | 4 +-

block/nvme.c | 6 +-

block/qcow2-cluster.c | 5 +-

block/rbd.c | 5 +-

block/vhdx.c | 120 ++++++++++++++++++++++++++++++++++------

block/vxhs.c | 5 +-

cpus.c | 2 -

qemu-img.c | 34 +++++++-----

qemu-io.c | 9 ++-

qemu-nbd.c | 9 ++-

qom/object_interfaces.c | 61 ++++++++++++++++++++

replay/replay-events.c | 16 ++++++

replay/replay.c | 2 +

stubs/replay-user.c | 9 +++

vl.c | 63 ++++-----------------

stubs/Makefile.objs | 1 +

tests/qemu-iotests/028 | 11 +++-

tests/qemu-iotests/028.out | 1 -

tests/qemu-iotests/268 | 55 ++++++++++++++++++

tests/qemu-iotests/268.out | 7 +++

tests/qemu-iotests/270 | 83 +++++++++++++++++++++++++++

tests/qemu-iotests/270.out | 9 +++

tests/qemu-iotests/group | 2 +

32 files changed, 504 insertions(+), 111 deletions(-)

create mode 100644 stubs/replay-user.c

create mode 100755 tests/qemu-iotests/268

create mode 100644 tests/qemu-iotests/268.out

create mode 100755 tests/qemu-iotests/270

create mode 100644 tests/qemu-iotests/270.out

From: Pavel Dovgalyuk <pavel.dovgaluk@ispras.ru>

This patch enables making snapshots with blkreplay used in

block devices.

This function is required to make bdrv_snapshot_goto without

calling .bdrv_open which is not implemented.

Signed-off-by: Pavel Dovgalyuk <pavel.dovgaluk@ispras.ru>

Acked-by: Kevin Wolf <kwolf@redhat.com>

block/blkreplay.c | 8 ++++++++

1 file changed, 8 insertions(+)

diff --git a/block/blkreplay.c b/block/blkreplay.c

--- a/block/blkreplay.c

+++ b/block/blkreplay.c

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blkreplay_co_flush(BlockDriverState *bs)

+static int blkreplay_snapshot_goto(BlockDriverState *bs,

+ const char *snapshot_id)

+ return bdrv_snapshot_goto(bs->file->bs, snapshot_id, NULL);

static BlockDriver bdrv_blkreplay = {

.format_name = "blkreplay",

.instance_size = 0,

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_blkreplay = {

.bdrv_co_pwrite_zeroes = blkreplay_co_pwrite_zeroes,

.bdrv_co_pdiscard = blkreplay_co_pdiscard,

.bdrv_co_flush = blkreplay_co_flush,

+

+ .bdrv_snapshot_goto = blkreplay_snapshot_goto,

};

static void bdrv_blkreplay_init(void)

2.20.1

From: Pavel Dovgalyuk <Pavel.Dovgaluk@ispras.ru>

In record/replay mode bdrv queue is controlled by replay mechanism.

It does not allow saving or loading the snapshots

when bdrv queue is not empty. Stopping the VM is not blocked by nonempty

queue, but flushing the queue is still impossible there,

because it may cause deadlocks in replay mode.

This patch disables bdrv_drain_all and bdrv_flush_all in

record/replay mode.

Stopping the machine when the IO requests are not finished is needed

for the debugging. E.g., breakpoint may be set at the specified step,

and forcing the IO requests to finish may break the determinism

of the execution.

Signed-off-by: Pavel Dovgalyuk <pavel.dovgaluk@ispras.ru>

Acked-by: Kevin Wolf <kwolf@redhat.com>

block/io.c | 28 ++++++++++++++++++++++++++++

cpus.c | 2 --

2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/block/io.c b/block/io.c

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@

#include "qapi/error.h"

#include "qemu/error-report.h"

#include "qemu/main-loop.h"

+#include "sysemu/replay.h"

#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */

@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)

return;

+ /*

+ * bdrv queue is managed by record/replay,

+ * waiting for finishing the I/O requests may

+ * be infinite

+ */

+ if (replay_events_enabled()) {

+ return;

+ }

+

/* AIO_WAIT_WHILE() with a NULL context can only be called from the main

* loop AioContext, so make sure we're in the main context. */

assert(qemu_get_current_aio_context() == qemu_get_aio_context());

@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)

BlockDriverState *bs = NULL;

int drained_end_counter = 0;

+ /*

+ * bdrv queue is managed by record/replay,

+ * waiting for finishing the I/O requests may

+ * be endless

+ */

+ if (replay_events_enabled()) {

+ return;

+ }

+

while ((bs = bdrv_next_all_states(bs))) {

AioContext *aio_context = bdrv_get_aio_context(bs);

@@ -XXX,XX +XXX,XX @@ int bdrv_flush_all(void)

BlockDriverState *bs = NULL;

int result = 0;

+ /*

+ * bdrv queue is managed by record/replay,

+ * creating new flush request for stopping

+ * the VM may break the determinism

+ */

+ if (replay_events_enabled()) {

+ return result;

+ }

+

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

AioContext *aio_context = bdrv_get_aio_context(bs);

int ret;

diff --git a/cpus.c b/cpus.c

index XXXXXXX..XXXXXXX 100644

--- a/cpus.c

+++ b/cpus.c

@@ -XXX,XX +XXX,XX @@ static int do_vm_stop(RunState state, bool send_stop)

2.20.1

From: Alberto Garcia <berto@igalia.com>

The BDRV_REQ_NO_FALLBACK flag means that an operation should only be

performed if it can be offloaded or otherwise performed efficiently.

However a misaligned write request requires a RMW so we should return

an error and let the caller decide how to proceed.

This hits an assertion since commit c8bb23cbdb if the required

alignment is larger than the cluster size:

qemu-img create -f qcow2 -o cluster_size=2k img.qcow2 4G

qemu-io -c "open -o driver=qcow2,file.align=4k blkdebug::img.qcow2" \

-c 'write 0 512'

qemu-io: block/io.c:1127: bdrv_driver_pwritev: Assertion `!(flags & BDRV_REQ_NO_FALLBACK)' failed.

Aborted

The reason is that when writing to an unallocated cluster we try to

skip the copy-on-write part and zeroize it using BDRV_REQ_NO_FALLBACK

instead, resulting in a write request that is too small (2KB cluster

size vs 4KB required alignment).

Signed-off-by: Alberto Garcia <berto@igalia.com>

block/io.c | 7 +++++

tests/qemu-iotests/268 | 55 ++++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/268.out | 7 +++++

tests/qemu-iotests/group | 1 +

4 files changed, 70 insertions(+)

create mode 100755 tests/qemu-iotests/268

create mode 100644 tests/qemu-iotests/268.out

diff --git a/block/io.c b/block/io.c

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,

return ret;

}

+ /* If the request is misaligned then we can't make it efficient */

+ if ((flags & BDRV_REQ_NO_FALLBACK) &&

+ !QEMU_IS_ALIGNED(offset | bytes, align))

+ {

+ return -ENOTSUP;

bdrv_inc_in_flight(bs);

/*

* Align write if necessary by performing a read-modify-write cycle.

diff --git a/tests/qemu-iotests/268 b/tests/qemu-iotests/268

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/268

@@ -XXX,XX +XXX,XX @@

+#!/usr/bin/env bash

+#

+# Test write request with required alignment larger than the cluster size

+#

+# Copyright (C) 2019 Igalia, S.L.

+# Author: Alberto Garcia <berto@igalia.com>

+#

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program. If not, see <http://www.gnu.org/licenses/>.

+#

+# creator

+owner=berto@igalia.com

+seq=`basename $0`

+echo "QA output created by $seq"

+

+status=1    # failure is the default!

+

+_cleanup()

+{

+ _cleanup_test_img

+}

+trap "_cleanup; exit \$status" 0 1 2 3 15

+

+# get standard environment, filters and checks

+. ./common.rc

+. ./common.filter

+

+_supported_fmt qcow2

+_supported_proto file

+

+echo

+echo "== Required alignment larger than cluster size =="

+

+CLUSTER_SIZE=2k _make_test_img 1M

+# Since commit c8bb23cbdb writing to an unallocated cluster fills the

+# empty COW areas with bdrv_write_zeroes(flags=BDRV_REQ_NO_FALLBACK)

+$QEMU_IO -c "open -o driver=$IMGFMT,file.align=4k blkdebug::$TEST_IMG" \

+ -c "write 0 512" | _filter_qemu_io

+

+# success, all done

+echo "*** done"

+rm -f $seq.full

+status=0

diff --git a/tests/qemu-iotests/268.out b/tests/qemu-iotests/268.out

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/268.out

@@ -XXX,XX +XXX,XX @@

+QA output created by 268

+

+== Required alignment larger than cluster size ==

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576

+wrote 512/512 bytes at offset 0

+512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+*** done

diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/group

+++ b/tests/qemu-iotests/group

@@ -XXX,XX +XXX,XX @@

265 rw auto quick

266 rw quick

267 rw auto quick snapshot

+268 rw auto quick

2.20.1

From: Pavel Dovgalyuk <Pavel.Dovgaluk@ispras.ru>

Replay is capable of recording normal BH events, but sometimes

there are single use callbacks scheduled with aio_bh_schedule_oneshot

function. This patch enables recording and replaying such callbacks.

Block layer uses these events for calling the completion function.

Replaying these calls makes the execution deterministic.

Signed-off-by: Pavel Dovgalyuk <Pavel.Dovgaluk@ispras.ru>

Acked-by: Kevin Wolf <kwolf@redhat.com>

include/sysemu/replay.h | 4 ++++

replay/replay-internal.h | 1 +

block/block-backend.c | 9 ++++++---

block/io.c | 4 ++--

block/iscsi.c | 5 +++--

block/nfs.c | 6 ++++--

block/null.c | 4 +++-

block/nvme.c | 6 ++++--

block/rbd.c | 5 +++--

block/vxhs.c | 5 +++--

replay/replay-events.c | 16 ++++++++++++++++

stubs/replay-user.c | 9 +++++++++

stubs/Makefile.objs | 1 +

13 files changed, 59 insertions(+), 16 deletions(-)

create mode 100644 stubs/replay-user.c

diff --git a/include/sysemu/replay.h b/include/sysemu/replay.h

--- a/include/sysemu/replay.h

+++ b/include/sysemu/replay.h

@@ -XXX,XX +XXX,XX @@

#include "qapi/qapi-types-misc.h"

#include "qapi/qapi-types-run-state.h"

#include "qapi/qapi-types-ui.h"

+#include "block/aio.h"

/* replay clock kinds */

enum ReplayClockKind {

@@ -XXX,XX +XXX,XX @@ void replay_enable_events(void);

bool replay_events_enabled(void);

/*! Adds bottom half event to the queue */

void replay_bh_schedule_event(QEMUBH *bh);

+/* Adds oneshot bottom half event to the queue */

+void replay_bh_schedule_oneshot_event(AioContext *ctx,

+ QEMUBHFunc *cb, void *opaque);

/*! Adds input event to the queue */

void replay_input_event(QemuConsole *src, InputEvent *evt);

/*! Adds input sync event to the queue */

diff --git a/replay/replay-internal.h b/replay/replay-internal.h

--- a/replay/replay-internal.h

+++ b/replay/replay-internal.h

@@ -XXX,XX +XXX,XX @@ enum ReplayEvents {

enum ReplayAsyncEventKind {

REPLAY_ASYNC_EVENT_BH,

+ REPLAY_ASYNC_EVENT_BH_ONESHOT,

REPLAY_ASYNC_EVENT_INPUT,

REPLAY_ASYNC_EVENT_INPUT_SYNC,

REPLAY_ASYNC_EVENT_CHAR_READ,

@@ -XXX,XX +XXX,XX @@

#include "hw/qdev-core.h"

#include "sysemu/blockdev.h"

#include "sysemu/runstate.h"

+#include "sysemu/sysemu.h"

+#include "sysemu/replay.h"

#include "qapi/error.h"

#include "qapi/qapi-events-block.h"

#include "qemu/id.h"

@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_abort_aio_request(BlockBackend *blk,

acb->blk = blk;

acb->ret = ret;

- aio_bh_schedule_oneshot(blk_get_aio_context(blk), error_callback_bh, acb);

+ replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),

+ error_callback_bh, acb);

return &acb->common;

@@ -XXX,XX +XXX,XX @@ static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,

acb->has_returned = true;

if (acb->rwco.ret != NOT_DONE) {

- aio_bh_schedule_oneshot(blk_get_aio_context(blk),

- blk_aio_complete_bh, acb);

+ replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),

+ blk_aio_complete_bh, acb);

return &acb->common;

@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,

if (bs) {

bdrv_inc_in_flight(bs);

}

- aio_bh_schedule_oneshot(bdrv_get_aio_context(bs),

- bdrv_co_drain_bh_cb, &data);

+ replay_bh_schedule_oneshot_event(bdrv_get_aio_context(bs),

+ bdrv_co_drain_bh_cb, &data);

qemu_coroutine_yield();

/* If we are resumed from some other event (such as an aio completion or a

diff --git a/block/iscsi.c b/block/iscsi.c

--- a/block/iscsi.c

+++ b/block/iscsi.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/module.h"

#include "qemu/option.h"

#include "qemu/uuid.h"

+#include "sysemu/replay.h"

#include "qapi/error.h"

#include "qapi/qapi-commands-misc.h"

#include "qapi/qmp/qdict.h"

@@ -XXX,XX +XXX,XX @@ iscsi_co_generic_cb(struct iscsi_context *iscsi, int status,

}

if (iTask->co) {

- aio_bh_schedule_oneshot(iTask->iscsilun->aio_context,

- iscsi_co_generic_bh_cb, iTask);

+ replay_bh_schedule_oneshot_event(iTask->iscsilun->aio_context,

+ iscsi_co_generic_bh_cb, iTask);

} else {

iTask->complete = 1;

}

diff --git a/block/nfs.c b/block/nfs.c

index XXXXXXX..XXXXXXX 100644

--- a/block/nfs.c

+++ b/block/nfs.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/option.h"

#include "qemu/uri.h"

#include "qemu/cutils.h"

+#include "sysemu/sysemu.h"

+#include "sysemu/replay.h"

#include "qapi/qapi-visit-block-core.h"

#include "qapi/qmp/qdict.h"

#include "qapi/qmp/qstring.h"

@@ -XXX,XX +XXX,XX @@ nfs_co_generic_cb(int ret, struct nfs_context *nfs, void *data,

if (task->ret < 0) {

error_report("NFS Error: %s", nfs_get_error(nfs));

}

- aio_bh_schedule_oneshot(task->client->aio_context,

- nfs_co_generic_bh_cb, task);

+ replay_bh_schedule_oneshot_event(task->client->aio_context,

+ nfs_co_generic_bh_cb, task);

}

static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, uint64_t offset,

diff --git a/block/null.c b/block/null.c

index XXXXXXX..XXXXXXX 100644

--- a/block/null.c

+++ b/block/null.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/module.h"

#include "qemu/option.h"

#include "block/block_int.h"

+#include "sysemu/replay.h"

#define NULL_OPT_LATENCY "latency-ns"

#define NULL_OPT_ZEROES "read-zeroes"

@@ -XXX,XX +XXX,XX @@ static inline BlockAIOCB *null_aio_common(BlockDriverState *bs,

timer_mod_ns(&acb->timer,

qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + s->latency_ns);

} else {

- aio_bh_schedule_oneshot(bdrv_get_aio_context(bs), null_bh_cb, acb);

+ replay_bh_schedule_oneshot_event(bdrv_get_aio_context(bs),

+ null_bh_cb, acb);

}

return &acb->common;

}

diff --git a/block/nvme.c b/block/nvme.c

index XXXXXXX..XXXXXXX 100644

--- a/block/nvme.c

+++ b/block/nvme.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/option.h"

#include "qemu/vfio-helpers.h"

#include "block/block_int.h"

+#include "sysemu/replay.h"

#include "trace.h"

#include "block/nvme.h"

@@ -XXX,XX +XXX,XX @@ static bool nvme_process_completion(BDRVNVMeState *s, NVMeQueuePair *q)

smp_mb_release();

*q->cq.doorbell = cpu_to_le32(q->cq.head);

if (!qemu_co_queue_empty(&q->free_req_queue)) {

- aio_bh_schedule_oneshot(s->aio_context, nvme_free_req_queue_cb, q);

+ replay_bh_schedule_oneshot_event(s->aio_context,

+ nvme_free_req_queue_cb, q);

}

}

q->busy = false;

@@ -XXX,XX +XXX,XX @@ static void nvme_rw_cb(void *opaque, int ret)

/* The rw coroutine hasn't yielded, don't try to enter. */

return;

}

- aio_bh_schedule_oneshot(data->ctx, nvme_rw_cb_bh, data);

+ replay_bh_schedule_oneshot_event(data->ctx, nvme_rw_cb_bh, data);

}

static coroutine_fn int nvme_co_prw_aligned(BlockDriverState *bs,

diff --git a/block/rbd.c b/block/rbd.c

index XXXXXXX..XXXXXXX 100644

--- a/block/rbd.c

+++ b/block/rbd.c

@@ -XXX,XX +XXX,XX @@

#include "block/qdict.h"

#include "crypto/secret.h"

#include "qemu/cutils.h"

+#include "sysemu/replay.h"

#include "qapi/qmp/qstring.h"

#include "qapi/qmp/qdict.h"

#include "qapi/qmp/qjson.h"

@@ -XXX,XX +XXX,XX @@ static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb)

rcb->ret = rbd_aio_get_return_value(c);

rbd_aio_release(c);

- aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs),

- rbd_finish_bh, rcb);

+ replay_bh_schedule_oneshot_event(bdrv_get_aio_context(acb->common.bs),

+ rbd_finish_bh, rcb);

}

static int rbd_aio_discard_wrapper(rbd_image_t image,

diff --git a/block/vxhs.c b/block/vxhs.c

index XXXXXXX..XXXXXXX 100644

--- a/block/vxhs.c

+++ b/block/vxhs.c

@@ -XXX,XX +XXX,XX @@

#include "qapi/error.h"

#include "qemu/uuid.h"

#include "crypto/tlscredsx509.h"

+#include "sysemu/replay.h"

#define VXHS_OPT_FILENAME "filename"

#define VXHS_OPT_VDISK_ID "vdisk-id"

@@ -XXX,XX +XXX,XX @@ static void vxhs_iio_callback(void *ctx, uint32_t opcode, uint32_t error)

trace_vxhs_iio_callback(error);

}

- aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs),

- vxhs_complete_aio_bh, acb);

+ replay_bh_schedule_oneshot_event(bdrv_get_aio_context(acb->common.bs),

+ vxhs_complete_aio_bh, acb);

break;

default:

diff --git a/replay/replay-events.c b/replay/replay-events.c

index XXXXXXX..XXXXXXX 100644

--- a/replay/replay-events.c

+++ b/replay/replay-events.c

@@ -XXX,XX +XXX,XX @@ static void replay_run_event(Event *event)

case REPLAY_ASYNC_EVENT_BH:

aio_bh_call(event->opaque);

break;

+ case REPLAY_ASYNC_EVENT_BH_ONESHOT:

+ ((QEMUBHFunc *)event->opaque)(event->opaque2);

+ break;

case REPLAY_ASYNC_EVENT_INPUT:

qemu_input_event_send_impl(NULL, (InputEvent *)event->opaque);

qapi_free_InputEvent((InputEvent *)event->opaque);

@@ -XXX,XX +XXX,XX @@ void replay_bh_schedule_event(QEMUBH *bh)

}

}

+void replay_bh_schedule_oneshot_event(AioContext *ctx,

+ QEMUBHFunc *cb, void *opaque)

+{

+ if (events_enabled) {

+ uint64_t id = replay_get_current_icount();

+ replay_add_event(REPLAY_ASYNC_EVENT_BH_ONESHOT, cb, opaque, id);

+ } else {

+ aio_bh_schedule_oneshot(ctx, cb, opaque);

+ }

+}

+

void replay_add_input_event(struct InputEvent *event)

{

replay_add_event(REPLAY_ASYNC_EVENT_INPUT, event, NULL, 0);

@@ -XXX,XX +XXX,XX @@ static void replay_save_event(Event *event, int checkpoint)

/* save event-specific data */

switch (event->event_kind) {

case REPLAY_ASYNC_EVENT_BH:

+ case REPLAY_ASYNC_EVENT_BH_ONESHOT:

replay_put_qword(event->id);

break;

case REPLAY_ASYNC_EVENT_INPUT:

@@ -XXX,XX +XXX,XX @@ static Event *replay_read_event(int checkpoint)

/* Events that has not to be in the queue */

switch (replay_state.read_event_kind) {

case REPLAY_ASYNC_EVENT_BH:

+ case REPLAY_ASYNC_EVENT_BH_ONESHOT:

if (replay_state.read_event_id == -1) {

replay_state.read_event_id = replay_get_qword();

}

diff --git a/stubs/replay-user.c b/stubs/replay-user.c

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/stubs/replay-user.c

@@ -XXX,XX +XXX,XX @@

+#include "qemu/osdep.h"

+#include "sysemu/replay.h"

+#include "sysemu/sysemu.h"

+

+void replay_bh_schedule_oneshot_event(AioContext *ctx,

+ QEMUBHFunc *cb, void *opaque)

+{

+ aio_bh_schedule_oneshot(ctx, cb, opaque);

+}

diff --git a/stubs/Makefile.objs b/stubs/Makefile.objs

index XXXXXXX..XXXXXXX 100644

--- a/stubs/Makefile.objs

+++ b/stubs/Makefile.objs

@@ -XXX,XX +XXX,XX @@ stub-obj-y += monitor.o

stub-obj-y += notify-event.o

stub-obj-y += qtest.o

stub-obj-y += replay.o

+stub-obj-y += replay-user.o

stub-obj-y += runstate-check.o

stub-obj-y += set-fd-handler.o

stub-obj-y += sysbus.o

2.20.1

From: Max Reitz <mreitz@redhat.com>

For long test image paths, the order of the "Formatting" line and the

"(qemu)" prompt after a drive_backup HMP command may be reversed. In

fact, the interaction between the prompt and the line may lead to the

"Formatting" to being greppable at all after "read"-ing it (if the

prompt injects an IFS character into the "Formatting" string).

So just wait until we get a prompt. At that point, the block job must

have been started, so "info block-jobs" will only return "No active

jobs" once it is done.

Reported-by: Thomas Huth <thuth@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

Reviewed-by: John Snow <jsnow@redhat.com>

tests/qemu-iotests/028 | 11 ++++++++---

tests/qemu-iotests/028.out | 1 -

2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028

--- a/tests/qemu-iotests/028

+++ b/tests/qemu-iotests/028

@@ -XXX,XX +XXX,XX @@ fi

# Silence output since it contains the disk image path and QEMU's readline

# character echoing makes it very hard to filter the output. Plus, there

# is no telling how many times the command will repeat before succeeding.

-_send_qemu_cmd $h "drive_backup disk ${TEST_IMG}.copy" "(qemu)" >/dev/null

-_send_qemu_cmd $h "" "Formatting" | _filter_img_create

-qemu_cmd_repeat=20 _send_qemu_cmd $h "info block-jobs" "No active jobs" >/dev/null

+# (Note that creating the image results in a "Formatting..." message over

+# stdout, which is the same channel the monitor uses. We cannot reliably

+# wait for it because the monitor output may interact with it in such a

+# way that _timed_wait_for cannot read it. However, once the block job is

+# done, we know that the "Formatting..." message must have appeared

+# already, so the output is still deterministic.)

+silent=y _send_qemu_cmd $h "drive_backup disk ${TEST_IMG}.copy" "(qemu)"

+silent=y qemu_cmd_repeat=20 _send_qemu_cmd $h "info block-jobs" "No active jobs"

_send_qemu_cmd $h "info block-jobs" "No active jobs"

_send_qemu_cmd $h 'quit' ""

diff --git a/tests/qemu-iotests/028.out b/tests/qemu-iotests/028.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/028.out

+++ b/tests/qemu-iotests/028.out

@@ -XXX,XX +XXX,XX @@ No errors were found on the image.

block-backup

-Formatting 'TEST_DIR/t.IMGFMT.copy', fmt=IMGFMT size=4294968832 backing_file=TEST_DIR/t.IMGFMT.base backing_fmt=IMGFMT

(qemu) info block-jobs

No active jobs

=== IO: pattern 195

2.20.1

From: Pavel Dovgalyuk <Pavel.Dovgaluk@ispras.ru>

After recent updates block devices cannot be closed on qemu exit.

This happens due to the block request polling when replay is not finished.

Therefore now we stop execution recording before closing the block devices.

Signed-off-by: Pavel Dovgalyuk <pavel.dovgaluk@ispras.ru>

replay/replay.c | 2 ++

vl.c | 1 +

2 files changed, 3 insertions(+)

diff --git a/replay/replay.c b/replay/replay.c

index XXXXXXX..XXXXXXX 100644

--- a/replay/replay.c

+++ b/replay/replay.c

@@ -XXX,XX +XXX,XX @@ void replay_finish(void)

g_free(replay_snapshot);

replay_snapshot = NULL;

+ replay_mode = REPLAY_MODE_NONE;

replay_finish_events();

}

diff --git a/vl.c b/vl.c

index XXXXXXX..XXXXXXX 100644

--- a/vl.c

+++ b/vl.c

@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)

/* No more vcpu or device emulation activity beyond this point */

vm_shutdown();

+ replay_finish();

job_cancel_sync_all();

bdrv_close_all();

2.20.1

From: Pavel Dovgalyuk <Pavel.Dovgaluk@ispras.ru>

This patch updates the description of the command lines for using

record/replay with attached block devices.

Signed-off-by: Pavel Dovgalyuk <Pavel.Dovgaluk@ispras.ru>

docs/replay.txt | 12 +++++++++---