The following changes since commit 411ad78115ebeb3411cf4b7622784b93dfabe259:

Merge remote-tracking branch 'remotes/stefanberger/tags/pull-tpm-2017-12-15-1' into staging (2017-12-17 15:27:41 +0000)

git://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 585426c518958aa768564596091474be786aae51:

qemu-iotests: add 203 savevm with IOThreads test (2017-12-18 13:12:53 +0000)

Mao Zhongyi (4):

hw/block/nvme: Convert to realize

hw/block: Fix the return type

hw/block: Use errp directly rather than local_err

dev-storage: Fix the unusual function name

Mark Kanda (2):

virtio-blk: make queue size configurable

virtio-blk: reject configs with logical block size > physical block

size

Paolo Bonzini (1):

block: avoid recursive AioContext acquire in bdrv_inactivate_all()

Stefan Hajnoczi (16):

coroutine: simplify co_aio_sleep_ns() prototype

qdev: drop unused #include "sysemu/iothread.h"

blockdev: hold AioContext for bdrv_unref() in

external_snapshot_clean()

block: don't keep AioContext acquired after

external_snapshot_prepare()

block: don't keep AioContext acquired after drive_backup_prepare()

block: don't keep AioContext acquired after blockdev_backup_prepare()

block: don't keep AioContext acquired after

internal_snapshot_prepare()

block: drop unused BlockDirtyBitmapState->aio_context field

iothread: add iothread_by_id() API

blockdev: add x-blockdev-set-iothread testing command

qemu-iotests: add 202 external snapshots IOThread test

docs: mark nested AioContext locking as a legacy API

blockdev: add x-blockdev-set-iothread force boolean

iotests: add VM.add_object()

iothread: fix iothread_stop() race condition

qemu-iotests: add 203 savevm with IOThreads test

docs/devel/multiple-iothreads.txt | 7 +-

qapi/block-core.json | 40 ++++++

hw/block/dataplane/virtio-blk.h | 2 +-

include/hw/block/block.h | 4 +-

include/hw/virtio/virtio-blk.h | 1 +

include/qemu/coroutine.h | 6 +-

include/sysemu/iothread.h | 4 +-

block.c | 14 ++-

block/null.c | 3 +-

block/sheepdog.c | 3 +-

blockdev.c | 259 +++++++++++++++++++++++++++-----------

hw/block/block.c | 15 ++-

hw/block/dataplane/virtio-blk.c | 12 +-

hw/block/fdc.c | 17 +--

hw/block/nvme.c | 23 ++--

hw/block/virtio-blk.c | 35 ++++--

hw/core/qdev-properties-system.c | 1 -

hw/ide/qdev.c | 12 +-

hw/scsi/scsi-disk.c | 13 +-

hw/usb/dev-storage.c | 29 ++---

iothread.c | 27 +++-

util/qemu-coroutine-sleep.c | 4 +-

tests/qemu-iotests/202 | 95 ++++++++++++++

tests/qemu-iotests/202.out | 11 ++

tests/qemu-iotests/203 | 59 +++++++++

tests/qemu-iotests/203.out | 6 +

tests/qemu-iotests/group | 2 +

tests/qemu-iotests/iotests.py | 5 +

28 files changed, 532 insertions(+), 177 deletions(-)

create mode 100755 tests/qemu-iotests/202

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

create mode 100755 tests/qemu-iotests/203

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

2.14.3

From: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>

Cc: John Snow <jsnow@redhat.com>

Cc: Kevin Wolf <kwolf@redhat.com>

Cc: Max Reitz <mreitz@redhat.com>

Cc: Keith Busch <keith.busch@intel.com>

Cc: Stefan Hajnoczi <stefanha@redhat.com>

Cc: "Michael S. Tsirkin" <mst@redhat.com>

Cc: Paolo Bonzini <pbonzini@redhat.com>

Cc: Gerd Hoffmann <kraxel@redhat.com>

Cc: Markus Armbruster <armbru@redhat.com>

Signed-off-by: Mao Zhongyi <maozy.fnst@cn.fujitsu.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-id: e77848d3735ba590f23ffbf8094379c646c33d79.1511317952.git.maozy.fnst@cn.fujitsu.com

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

hw/block/fdc.c | 17 ++++++-----------

hw/block/nvme.c | 7 ++-----

hw/block/virtio-blk.c | 18 ++++++------------

hw/ide/qdev.c | 12 ++++--------

hw/scsi/scsi-disk.c | 13 ++++---------

hw/usb/dev-storage.c | 9 +++------

6 files changed, 25 insertions(+), 51 deletions(-)

diff --git a/hw/block/fdc.c b/hw/block/fdc.c

--- a/hw/block/fdc.c

+++ b/hw/block/fdc.c

@@ -XXX,XX +XXX,XX @@ static void fd_revalidate(FDrive *drv)

static void fd_change_cb(void *opaque, bool load, Error **errp)

FDrive *drive = opaque;

- Error *local_err = NULL;

if (!load) {

blk_set_perm(drive->blk, 0, BLK_PERM_ALL, &error_abort);

} else {

- blkconf_apply_backend_options(drive->conf,

- blk_is_read_only(drive->blk), false,

- &local_err);

- if (local_err) {

- error_propagate(errp, local_err);

+ if (!blkconf_apply_backend_options(drive->conf,

+ blk_is_read_only(drive->blk), false,

+ errp)) {

return;

@@ -XXX,XX +XXX,XX @@ static void floppy_drive_realize(DeviceState *qdev, Error **errp)

FloppyDrive *dev = FLOPPY_DRIVE(qdev);

FloppyBus *bus = FLOPPY_BUS(qdev->parent_bus);

FDrive *drive;

- Error *local_err = NULL;

int ret;

if (dev->unit == -1) {

@@ -XXX,XX +XXX,XX @@ static void floppy_drive_realize(DeviceState *qdev, Error **errp)

dev->conf.rerror = BLOCKDEV_ON_ERROR_AUTO;

dev->conf.werror = BLOCKDEV_ON_ERROR_AUTO;

- blkconf_apply_backend_options(&dev->conf, blk_is_read_only(dev->conf.blk),

- false, &local_err);

- if (local_err) {

- error_propagate(errp, local_err);

+ if (!blkconf_apply_backend_options(&dev->conf,

+ blk_is_read_only(dev->conf.blk),

+ false, errp)) {

return;

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

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/nvme.c

+++ b/hw/block/nvme.c

@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)

int i;

int64_t bs_size;

uint8_t *pci_conf;

- Error *local_err = NULL;

if (!n->conf.blk) {

error_setg(errp, "drive property not set");

@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)

return;

}

blkconf_blocksizes(&n->conf);

- blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk),

- false, &local_err);

- if (local_err) {

- error_propagate(errp, local_err);

+ if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk),

+ false, errp)) {

return;

}

diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/virtio-blk.c

+++ b/hw/block/virtio-blk.c

@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)

VirtIODevice *vdev = VIRTIO_DEVICE(dev);

VirtIOBlock *s = VIRTIO_BLK(dev);

VirtIOBlkConf *conf = &s->conf;

- Error *err = NULL;

unsigned i;

if (!conf->conf.blk) {

@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)

}

blkconf_serial(&conf->conf, &conf->serial);

- blkconf_apply_backend_options(&conf->conf,

- blk_is_read_only(conf->conf.blk), true,

- &err);

- if (err) {

- error_propagate(errp, err);

+ if (!blkconf_apply_backend_options(&conf->conf,

+ blk_is_read_only(conf->conf.blk), true,

+ errp)) {

return;

}

s->original_wce = blk_enable_write_cache(conf->conf.blk);

- blkconf_geometry(&conf->conf, NULL, 65535, 255, 255, &err);

- if (err) {

- error_propagate(errp, err);

+ if (!blkconf_geometry(&conf->conf, NULL, 65535, 255, 255, errp)) {

return;

}

+

blkconf_blocksizes(&conf->conf);

virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK,

@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)

for (i = 0; i < conf->num_queues; i++) {

virtio_add_queue(vdev, 128, virtio_blk_handle_output);

}

- virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err);

- if (err != NULL) {

- error_propagate(errp, err);

+ if (!virtio_blk_data_plane_create(vdev, conf, &s->dataplane, errp)) {

virtio_cleanup(vdev);

return;

}

diff --git a/hw/ide/qdev.c b/hw/ide/qdev.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/ide/qdev.c

+++ b/hw/ide/qdev.c

@@ -XXX,XX +XXX,XX @@ static void ide_dev_initfn(IDEDevice *dev, IDEDriveKind kind, Error **errp)

{

IDEBus *bus = DO_UPCAST(IDEBus, qbus, dev->qdev.parent_bus);

IDEState *s = bus->ifs + dev->unit;

- Error *err = NULL;

int ret;

if (!dev->conf.blk) {

@@ -XXX,XX +XXX,XX @@ static void ide_dev_initfn(IDEDevice *dev, IDEDriveKind kind, Error **errp)

blkconf_serial(&dev->conf, &dev->serial);

if (kind != IDE_CD) {

- blkconf_geometry(&dev->conf, &dev->chs_trans, 65535, 16, 255, &err);

- if (err) {

- error_propagate(errp, err);

+ if (!blkconf_geometry(&dev->conf, &dev->chs_trans, 65535, 16, 255,

+ errp)) {

return;

}

}

- blkconf_apply_backend_options(&dev->conf, kind == IDE_CD, kind != IDE_CD,

- &err);

- if (err) {

- error_propagate(errp, err);

+ if (!blkconf_apply_backend_options(&dev->conf, kind == IDE_CD,

+ kind != IDE_CD, errp)) {

return;

}

diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/scsi/scsi-disk.c

+++ b/hw/scsi/scsi-disk.c

@@ -XXX,XX +XXX,XX @@ static void scsi_disk_unit_attention_reported(SCSIDevice *dev)

static void scsi_realize(SCSIDevice *dev, Error **errp)

{

SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);

- Error *err = NULL;

if (!s->qdev.conf.blk) {

error_setg(errp, "drive property not set");

@@ -XXX,XX +XXX,XX @@ static void scsi_realize(SCSIDevice *dev, Error **errp)

}

if (dev->type == TYPE_DISK) {

- blkconf_geometry(&dev->conf, NULL, 65535, 255, 255, &err);

- if (err) {

- error_propagate(errp, err);

+ if (!blkconf_geometry(&dev->conf, NULL, 65535, 255, 255, errp)) {

return;

}

}

- blkconf_apply_backend_options(&dev->conf,

- blk_is_read_only(s->qdev.conf.blk),

- dev->type == TYPE_DISK, &err);

- if (err) {

- error_propagate(errp, err);

+ if (!blkconf_apply_backend_options(&dev->conf,

+ blk_is_read_only(s->qdev.conf.blk),

+ dev->type == TYPE_DISK, errp)) {

return;

}

diff --git a/hw/usb/dev-storage.c b/hw/usb/dev-storage.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/usb/dev-storage.c

+++ b/hw/usb/dev-storage.c

@@ -XXX,XX +XXX,XX @@ static void usb_msd_realize_storage(USBDevice *dev, Error **errp)

MSDState *s = USB_STORAGE_DEV(dev);

BlockBackend *blk = s->conf.blk;

SCSIDevice *scsi_dev;

- Error *err = NULL;

if (!blk) {

error_setg(errp, "drive property not set");

@@ -XXX,XX +XXX,XX @@ static void usb_msd_realize_storage(USBDevice *dev, Error **errp)

blkconf_serial(&s->conf, &dev->serial);

blkconf_blocksizes(&s->conf);

- blkconf_apply_backend_options(&s->conf, blk_is_read_only(blk), true, &err);

- if (err) {

- error_propagate(errp, err);

+ if (!blkconf_apply_backend_options(&s->conf, blk_is_read_only(blk), true,

+ errp)) {

return;

}

@@ -XXX,XX +XXX,XX @@ static void usb_msd_realize_storage(USBDevice *dev, Error **errp)

&usb_msd_scsi_info_storage, NULL);

scsi_dev = scsi_bus_legacy_add_drive(&s->bus, blk, 0, !!s->removable,

s->conf.bootindex, dev->serial,

- &err);

+ errp);

blk_unref(blk);

if (!scsi_dev) {

- error_propagate(errp, err);

return;

}

usb_msd_handle_reset(dev);

2.14.3

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

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

Reviewed-by: Eric Blake <eblake@redhat.com>

Message-id: 20171206144550.22295-6-stefanha@redhat.com

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

blockdev.c | 47 +++++++++++++++++++++++++++++++----------------

1 file changed, 31 insertions(+), 16 deletions(-)

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

--- a/blockdev.c

+++ b/blockdev.c

@@ -XXX,XX +XXX,XX @@ struct BlkActionState {

typedef struct InternalSnapshotState {

BlkActionState common;

BlockDriverState *bs;

- AioContext *aio_context;

QEMUSnapshotInfo sn;

bool created;

} InternalSnapshotState;

@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_prepare(BlkActionState *common,

qemu_timeval tv;

BlockdevSnapshotInternal *internal;

InternalSnapshotState *state;

+ AioContext *aio_context;

int ret1;

g_assert(common->action->type ==

@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_prepare(BlkActionState *common,

return;

- /* AioContext is released in .clean() */

- state->aio_context = bdrv_get_aio_context(bs);

- aio_context_acquire(state->aio_context);

+ aio_context = bdrv_get_aio_context(bs);

+ aio_context_acquire(aio_context);

state->bs = bs;

+

+ /* Paired with .clean() */

bdrv_drained_begin(bs);

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

- return;

+ goto out;

}

if (bdrv_is_read_only(bs)) {

error_setg(errp, "Device '%s' is read only", device);

- return;

+ goto out;

}

if (!bdrv_can_snapshot(bs)) {

error_setg(errp, "Block format '%s' used by device '%s' "

"does not support internal snapshots",

bs->drv->format_name, device);

- return;

+ goto out;

}

if (!strlen(name)) {

error_setg(errp, "Name is empty");

- return;

+ goto out;

}

/* check whether a snapshot with name exist */

@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_prepare(BlkActionState *common,

&local_err);

if (local_err) {

error_propagate(errp, local_err);

- return;

+ goto out;

} else if (ret) {

error_setg(errp,

"Snapshot with name '%s' already exists on device '%s'",

name, device);

- return;

+ goto out;

}

/* 3. take the snapshot */

@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_prepare(BlkActionState *common,

error_setg_errno(errp, -ret1,

"Failed to create snapshot '%s' on device '%s'",

name, device);

- return;

+ goto out;

}

/* 4. succeed, mark a snapshot is created */

state->created = true;

+

+out:

+ aio_context_release(aio_context);

static void internal_snapshot_abort(BlkActionState *common)

@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_abort(BlkActionState *common)

DO_UPCAST(InternalSnapshotState, common, common);

BlockDriverState *bs = state->bs;

QEMUSnapshotInfo *sn = &state->sn;

+ AioContext *aio_context;

Error *local_error = NULL;

if (!state->created) {

return;

}

+ aio_context = bdrv_get_aio_context(state->bs);

+ aio_context_acquire(aio_context);

+

if (bdrv_snapshot_delete(bs, sn->id_str, sn->name, &local_error) < 0) {

error_reportf_err(local_error,

"Failed to delete snapshot with id '%s' and "

@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_abort(BlkActionState *common)

sn->id_str, sn->name,

bdrv_get_device_name(bs));

}

+

+ aio_context_release(aio_context);

}

static void internal_snapshot_clean(BlkActionState *common)

{

InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,

common, common);

+ AioContext *aio_context;

- if (state->aio_context) {

- if (state->bs) {

- bdrv_drained_end(state->bs);

- }

- aio_context_release(state->aio_context);

+ if (!state->bs) {

+ return;

}

+

+ aio_context = bdrv_get_aio_context(state->bs);

+ aio_context_acquire(aio_context);

+

+ bdrv_drained_end(state->bs);

+

+ aio_context_release(aio_context);

}

/* external snapshot private data */

2.14.3

It is not necessary to hold AioContext across transactions anymore since

bdrv_drained_begin/end() is used to keep the nodes quiesced. In fact,

using the AioContext lock for this purpose was always buggy.

This patch reduces the scope of AioContext locked regions. This is not

just a cleanup but also fixes hangs that occur in BDRV_POLL_WHILE()

because it is unware of recursive locking and does not release the

AioContext the necessary number of times to allow progress to be made.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

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

Reviewed-by: Eric Blake <eblake@redhat.com>

Message-id: 20171206144550.22295-3-stefanha@redhat.com

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

blockdev.c | 71 ++++++++++++++++++++++++++++++++++++++++++--------------------

1 file changed, 48 insertions(+), 23 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

--- a/blockdev.c

+++ b/blockdev.c

@@ -XXX,XX +XXX,XX @@ typedef struct ExternalSnapshotState {

BlkActionState common;

BlockDriverState *old_bs;

BlockDriverState *new_bs;

- AioContext *aio_context;

bool overlay_appended;

} ExternalSnapshotState;

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,

ExternalSnapshotState *state =

DO_UPCAST(ExternalSnapshotState, common, common);

TransactionAction *action = common->action;

+ AioContext *aio_context;

/* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar

* purpose but a different set of parameters */

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,

return;

+ /* Paired with .clean() */

bdrv_drained_begin(state->old_bs);

if (!bdrv_is_inserted(state->old_bs)) {

error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);

- return;

+ goto out;

if (bdrv_op_is_blocked(state->old_bs,

BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT, errp)) {

- return;

+ goto out;

}

if (!bdrv_is_read_only(state->old_bs)) {

if (bdrv_flush(state->old_bs)) {

error_setg(errp, QERR_IO_ERROR);

- return;

+ goto out;

if (!bdrv_is_first_non_filter(state->old_bs)) {

error_setg(errp, QERR_FEATURE_DISABLED, "snapshot");

- return;

+ goto out;

}

if (action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC) {

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,

if (node_name && !snapshot_node_name) {

error_setg(errp, "New snapshot node name missing");

- return;

+ goto out;

}

if (snapshot_node_name &&

bdrv_lookup_bs(snapshot_node_name, snapshot_node_name, NULL)) {

error_setg(errp, "New snapshot node name already in use");

- return;

+ goto out;

}

flags = state->old_bs->open_flags;

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,

int64_t size = bdrv_getlength(state->old_bs);

if (size < 0) {

error_setg_errno(errp, -size, "bdrv_getlength failed");

- return;

+ goto out;

}

bdrv_img_create(new_image_file, format,

state->old_bs->filename,

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,

NULL, size, flags, false, &local_err);

if (local_err) {

error_propagate(errp, local_err);

- return;

+ goto out;

}

}

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,

errp);

/* We will manually add the backing_hd field to the bs later */

if (!state->new_bs) {

- return;

+ goto out;

}

if (bdrv_has_blk(state->new_bs)) {

error_setg(errp, "The snapshot is already in use");

- return;

+ goto out;

}

if (bdrv_op_is_blocked(state->new_bs, BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,

errp)) {

- return;

+ goto out;

}

if (state->new_bs->backing != NULL) {

error_setg(errp, "The snapshot already has a backing image");

- return;

+ goto out;

}

if (!state->new_bs->drv->supports_backing) {

error_setg(errp, "The snapshot does not support backing images");

- return;

+ goto out;

}

- bdrv_set_aio_context(state->new_bs, state->aio_context);

+ bdrv_set_aio_context(state->new_bs, aio_context);

/* This removes our old bs and adds the new bs. This is an operation that

* can fail, so we need to do it in .prepare; undoing it for abort is

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,

bdrv_append(state->new_bs, state->old_bs, &local_err);

if (local_err) {

error_propagate(errp, local_err);

- return;

+ goto out;

}

state->overlay_appended = true;

+

+out:

+ aio_context_release(aio_context);

}

static void external_snapshot_commit(BlkActionState *common)

{

ExternalSnapshotState *state =

DO_UPCAST(ExternalSnapshotState, common, common);

+ AioContext *aio_context;

+

+ aio_context = bdrv_get_aio_context(state->old_bs);

+ aio_context_acquire(aio_context);

/* We don't need (or want) to use the transactional

* bdrv_reopen_multiple() across all the entries at once, because we

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_commit(BlkActionState *common)

bdrv_reopen(state->old_bs, state->old_bs->open_flags & ~BDRV_O_RDWR,

NULL);

}

+

+ aio_context_release(aio_context);

}

static void external_snapshot_abort(BlkActionState *common)

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_abort(BlkActionState *common)

DO_UPCAST(ExternalSnapshotState, common, common);

if (state->new_bs) {

if (state->overlay_appended) {

+ AioContext *aio_context;

+

+ aio_context = bdrv_get_aio_context(state->old_bs);

+ aio_context_acquire(aio_context);

+

bdrv_ref(state->old_bs); /* we can't let bdrv_set_backind_hd()

close state->old_bs; we need it */

bdrv_set_backing_hd(state->new_bs, NULL, &error_abort);

bdrv_replace_node(state->new_bs, state->old_bs, &error_abort);

bdrv_unref(state->old_bs); /* bdrv_replace_node() ref'ed old_bs */

+

+ aio_context_release(aio_context);

}

}

}

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_clean(BlkActionState *common)

{

ExternalSnapshotState *state =

DO_UPCAST(ExternalSnapshotState, common, common);

- if (state->aio_context) {

- bdrv_drained_end(state->old_bs);

- bdrv_unref(state->new_bs);

- aio_context_release(state->aio_context);

+ AioContext *aio_context;

+

+ if (!state->old_bs) {

+ return;

}

+

+ aio_context = bdrv_get_aio_context(state->old_bs);

+ aio_context_acquire(aio_context);

+

+ bdrv_drained_end(state->old_bs);

+ bdrv_unref(state->new_bs);

+

+ aio_context_release(aio_context);

}

typedef struct DriveBackupState {

2.14.3

This test case will prevent future regressions with savevm and

IOThreads.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-id: 20171207201320.19284-7-stefanha@redhat.com

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

tests/qemu-iotests/203 | 59 ++++++++++++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/203.out | 6 +++++

tests/qemu-iotests/group | 1 +

3 files changed, 66 insertions(+)

create mode 100755 tests/qemu-iotests/203

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

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

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/203

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

+#!/usr/bin/env python

+#

+# Copyright (C) 2017 Red Hat, Inc.

+#

+# 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: Stefan Hajnoczi <stefanha@redhat.com>

+#

+# Check that QMP 'migrate' with multiple drives on a single IOThread completes

+# successfully. This particular command triggered a hang in the source QEMU

+# process due to recursive AioContext locking in bdrv_invalidate_all() and

+# BDRV_POLL_WHILE().

+import iotests

+

+iotests.verify_image_format(supported_fmts=['qcow2'])

+iotests.verify_platform(['linux'])

+

+with iotests.FilePath('disk0.img') as disk0_img_path, \

+ iotests.FilePath('disk1.img') as disk1_img_path, \

+ iotests.VM() as vm:

+

+ img_size = '10M'

+ iotests.qemu_img_pipe('create', '-f', iotests.imgfmt, disk0_img_path, img_size)

+ iotests.qemu_img_pipe('create', '-f', iotests.imgfmt, disk1_img_path, img_size)

+

+ iotests.log('Launching VM...')

+ (vm.add_object('iothread,id=iothread0')

+ .add_drive(disk0_img_path, 'node-name=drive0-node', interface='none')

+ .add_drive(disk1_img_path, 'node-name=drive1-node', interface='none')

+ .launch())

+

+ iotests.log('Setting IOThreads...')

+ iotests.log(vm.qmp('x-blockdev-set-iothread',

+ node_name='drive0-node', iothread='iothread0',

+ force=True))

+ iotests.log(vm.qmp('x-blockdev-set-iothread',

+ node_name='drive1-node', iothread='iothread0',

+ force=True))

+

+ iotests.log('Starting migration...')

+ iotests.log(vm.qmp('migrate', uri='exec:cat >/dev/null'))

+ while True:

+ vm.get_qmp_event(wait=60.0)

+ result = vm.qmp('query-migrate')