From: Fam Zheng <famz@redhat.com>

We could hit lock failure if there is a signal that makes fcntl return

-1 and errno set to EINTR. In this case we should retry.

Cc: qemu-stable@nongnu.org

Signed-off-by: Fam Zheng <famz@redhat.com>

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

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

---

util/osdep.c | 4 +++-

1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/util/osdep.c b/util/osdep.c

index XXXXXXX..XXXXXXX 100644

--- a/util/osdep.c

+++ b/util/osdep.c

@@ -XXX,XX +XXX,XX @@ static int qemu_lock_fcntl(int fd, int64_t start, int64_t len, int fl_type)

.l_type = fl_type,

};

qemu_probe_lock_ops();

- ret = fcntl(fd, fcntl_op_setlk, &fl);

+ do {

+ ret = fcntl(fd, fcntl_op_setlk, &fl);

+ } while (ret == -1 && errno == EINTR);

return ret == -1 ? -errno : 0;

}

--

2.13.6

From: Hikaru Nishida <hikarupsp@gmail.com>

Pin-based interrupt of NVMe controller did not work properly

because using an obsolated function pci_irq_pulse().

To fix this, change to use pci_irq_assert() / pci_irq_deassert()

instead of pci_irq_pulse().

Signed-off-by: Hikaru Nishida <hikarupsp@gmail.com>

Reviewed-by: Keith Busch <keith.busch@intel.com>

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

---

hw/block/nvme.h | 1 +

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

2 files changed, 35 insertions(+), 5 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

--- a/hw/block/nvme.h

+++ b/hw/block/nvme.h

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

uint32_t cmbsz;

uint32_t cmbloc;

uint8_t *cmbuf;

+ uint64_t irq_status;

char *serial;

NvmeNamespace *namespaces;

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 uint8_t nvme_sq_empty(NvmeSQueue *sq)

return sq->head == sq->tail;

}

-static void nvme_isr_notify(NvmeCtrl *n, NvmeCQueue *cq)

+static void nvme_irq_check(NvmeCtrl *n)

+{

+ if (msix_enabled(&(n->parent_obj))) {

+ return;

+ }

+ if (~n->bar.intms & n->irq_status) {

+ pci_irq_assert(&n->parent_obj);

+ } else {

+ pci_irq_deassert(&n->parent_obj);

+ }

+}

+

+static void nvme_irq_assert(NvmeCtrl *n, NvmeCQueue *cq)

{

if (cq->irq_enabled) {

if (msix_enabled(&(n->parent_obj))) {

@@ -XXX,XX +XXX,XX @@ static void nvme_isr_notify(NvmeCtrl *n, NvmeCQueue *cq)

msix_notify(&(n->parent_obj), cq->vector);

} else {

trace_nvme_irq_pin();

- pci_irq_pulse(&n->parent_obj);

+ assert(cq->cqid < 64);

+ n->irq_status |= 1 << cq->cqid;

+ nvme_irq_check(n);

}

} else {

trace_nvme_irq_masked();

}

}

+static void nvme_irq_deassert(NvmeCtrl *n, NvmeCQueue *cq)

+{

+ if (cq->irq_enabled) {

+ if (msix_enabled(&(n->parent_obj))) {

+ return;

+ } else {

+ assert(cq->cqid < 64);

+ n->irq_status &= ~(1 << cq->cqid);

+ nvme_irq_check(n);

+ }

+ }

+}

+

static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,

uint64_t prp2, uint32_t len, NvmeCtrl *n)

{

@@ -XXX,XX +XXX,XX @@ static void nvme_post_cqes(void *opaque)

sizeof(req->cqe));

QTAILQ_INSERT_TAIL(&sq->req_list, req, entry);

}

- nvme_isr_notify(n, cq);

+ nvme_irq_assert(n, cq);

}

static void nvme_enqueue_req_completion(NvmeCQueue *cq, NvmeRequest *req)

@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,

n->bar.intmc = n->bar.intms;

trace_nvme_mmio_intm_set(data & 0xffffffff,

n->bar.intmc);

+ nvme_irq_check(n);

break;

case 0x10: /* INTMC */

if (unlikely(msix_enabled(&(n->parent_obj)))) {

@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,

n->bar.intmc = n->bar.intms;

trace_nvme_mmio_intm_clr(data & 0xffffffff,

n->bar.intmc);

+ nvme_irq_check(n);

break;

case 0x14: /* CC */

trace_nvme_mmio_cfg(data & 0xffffffff);

@@ -XXX,XX +XXX,XX @@ static void nvme_process_db(NvmeCtrl *n, hwaddr addr, int val)

timer_mod(cq->timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 500);

}

- if (cq->tail != cq->head) {

- nvme_isr_notify(n, cq);

+ if (cq->tail == cq->head) {

+ nvme_irq_deassert(n, cq);

}

} else {

/* Submission queue doorbell write */

--

2.13.6

Commit 881cfd17 added a new test binary, include it in .gitignore.

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

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

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

---

tests/.gitignore | 1 +

1 file changed, 1 insertion(+)

diff --git a/tests/.gitignore b/tests/.gitignore

index XXXXXXX..XXXXXXX 100644

--- a/tests/.gitignore

+++ b/tests/.gitignore

@@ -XXX,XX +XXX,XX @@ test-aio

test-aio-multithread

test-arm-mptimer

test-base64

+test-bdrv-drain

test-bitops

test-bitcnt

test-blockjob

--

2.13.6

From: Daniel Henrique Barboza <danielhb@linux.vnet.ibm.com>

This patch implements a test case for the scenario that was failing

prior to the patch "migration/ram.c: do not set 'postcopy_running' in

POSTCOPY_INCOMING_END", commit acab30b85d.

This new test file 201 was derived from the test file 181 authored

by Kevin Wolf.

CC: Kevin Wolf <kwolf@redhat.com>

CC: Max Reitz <mreitz@redhat.com>

CC: Cleber Rosa <crosa@redhat.com>

Signed-off-by: Daniel Henrique Barboza <danielhb@linux.vnet.ibm.com>

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

---

tests/qemu-iotests/201 | 120 +++++++++++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/201.out | 23 +++++++++

tests/qemu-iotests/group | 1 +

3 files changed, 144 insertions(+)

create mode 100755 tests/qemu-iotests/201

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

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

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/201

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

+#!/bin/bash

+#

+# Test savevm and loadvm after live migration with postcopy flag

+#

+# Copyright (C) 2017, IBM Corporation.

+#

+# This file is derived from tests/qemu-iotests/181 by Kevin Wolf

+#

+# 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/>.

+

+seq=`basename $0`

+echo "QA output created by $seq"

+

+status=1    # failure is the default!

+

+MIG_SOCKET="${TEST_DIR}/migrate"

+

+# get standard environment, filters and checks

+. ./common.rc

+. ./common.filter

+. ./common.qemu

+

+_cleanup()

+{

+ rm -f "${MIG_SOCKET}"

+ _cleanup_test_img

+ _cleanup_qemu

+}

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

+

+_supported_fmt qcow2

+_supported_proto generic

+_supported_os Linux

+

+# Internal snapshots are (currently) impossible with refcount_bits=1

+# This was taken from test 080

+_unsupported_imgopts 'refcount_bits=1[^0-9]'

+

+size=64M

+_make_test_img $size

+

+echo

+echo === Starting VMs ===

+echo

+

+qemu_comm_method="monitor"

+

+if [ "$IMGOPTSSYNTAX" = "true" ]; then

+ _launch_qemu \

+ -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk

+else

+ _launch_qemu \

+ -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk

+fi

+src=$QEMU_HANDLE

+

+if [ "$IMGOPTSSYNTAX" = "true" ]; then

+ _launch_qemu \

+ -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk \

+ -incoming "unix:${MIG_SOCKET}"

+else

+ _launch_qemu \

+ -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk \

+ -incoming "unix:${MIG_SOCKET}"

+fi

+dest=$QEMU_HANDLE

+

+echo

+echo === Set \'migrate_set_capability postcopy-ram on\' and migrate ===

+echo

+

+silent=yes

+_send_qemu_cmd $dest 'migrate_set_capability postcopy-ram on' "(qemu)"

+_send_qemu_cmd $src 'migrate_set_capability postcopy-ram on' "(qemu)"

+_send_qemu_cmd $src "migrate -d unix:${MIG_SOCKET}" "(qemu)"

+

+QEMU_COMM_TIMEOUT=1 qemu_cmd_repeat=10 silent=yes \

+ _send_qemu_cmd $src "info migrate" "completed\|failed"

+silent=yes _send_qemu_cmd $src "" "(qemu)"

+

+echo

+echo === Check if migration was successful ===

+echo

+

+QEMU_COMM_TIMEOUT=1 silent=yes \

+ _send_qemu_cmd $src "info migrate" "completed"

+silent=yes _send_qemu_cmd $src "" "(qemu)"

+

+echo

+echo === On destination, execute savevm and loadvm ===

+echo

+

+silent=

+_send_qemu_cmd $dest 'savevm state1' "(qemu)"

+_send_qemu_cmd $dest 'loadvm state1' "(qemu)"

+

+echo

+echo === Shut down and check image ===

+echo

+

+_send_qemu_cmd $src 'quit' ""

+_send_qemu_cmd $dest 'quit' ""

+wait=1 _cleanup_qemu

+

+_check_test_img

+

+# success, all done

+echo "*** done"

+status=0

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

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

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

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

+QA output created by 201

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

+

+=== Starting VMs ===

+

+

+=== Set 'migrate_set_capability postcopy-ram on' and migrate ===

+

+

+=== Check if migration was successful ===

+

+

+=== On destination, execute savevm and loadvm ===

+

+(qemu) savevm state1

+(qemu) loadvm state1

+

+=== Shut down and check image ===

+

+(qemu) quit

+(qemu) quit

+No errors were found on the image.

+*** 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 @@

197 rw auto quick

198 rw auto

200 rw auto

+201 rw auto migration

202 rw auto quick

203 rw auto

--

2.13.6

From: Max Reitz <mreitz@redhat.com>

We can easily repair unaligned preallocated zero clusters by discarding

them, so why not do it?

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

Message-id: 20171110203759.14018-2-mreitz@redhat.com

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

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

---

block/qcow2-refcount.c | 70 ++++++++++++++++++++++++++++++++++++++--------

tests/qemu-iotests/060 | 3 +-

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

3 files changed, 69 insertions(+), 13 deletions(-)

diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2-refcount.c

+++ b/block/qcow2-refcount.c

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

static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,

void **refcount_table,

int64_t *refcount_table_size, int64_t l2_offset,

- int flags)

+ int flags, BdrvCheckMode fix)

{

BDRVQcow2State *s = bs->opaque;

uint64_t *l2_table, l2_entry;

@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,

next_contiguous_offset = offset + s->cluster_size;

}

+ /* Correct offsets are cluster aligned */

+ if (offset_into_cluster(s, offset)) {

+ if (qcow2_get_cluster_type(l2_entry) ==

+ QCOW2_CLUSTER_ZERO_ALLOC)

+ {

+ fprintf(stderr, "%s offset=%" PRIx64 ": Preallocated zero "

+ "cluster is not properly aligned; L2 entry "

+ "corrupted.\n",

+ fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR",

+ offset);

+ if (fix & BDRV_FIX_ERRORS) {

+ uint64_t l2e_offset =

+ l2_offset + (uint64_t)i * sizeof(uint64_t);

+

+ l2_entry = QCOW_OFLAG_ZERO;

+ l2_table[i] = cpu_to_be64(l2_entry);

+ ret = qcow2_pre_write_overlap_check(bs,

+ QCOW2_OL_ACTIVE_L2 | QCOW2_OL_INACTIVE_L2,

+ l2e_offset, sizeof(uint64_t));

+ if (ret < 0) {

+ fprintf(stderr, "ERROR: Overlap check failed\n");

+ res->check_errors++;

+ /* Something is seriously wrong, so abort checking

+ * this L2 table */

+ goto fail;

+ }

+

+ ret = bdrv_pwrite_sync(bs->file, l2e_offset,

+ &l2_table[i], sizeof(uint64_t));

+ if (ret < 0) {

+ fprintf(stderr, "ERROR: Failed to overwrite L2 "

+ "table entry: %s\n", strerror(-ret));

+ res->check_errors++;

+ /* Do not abort, continue checking the rest of this

+ * L2 table's entries */

+ } else {

+ res->corruptions_fixed++;

+ /* Skip marking the cluster as used

+ * (it is unused now) */

+ continue;

+ }

+ } else {

+ res->corruptions++;

+ }

+ } else {

+ fprintf(stderr, "ERROR offset=%" PRIx64 ": Data cluster is "

+ "not properly aligned; L2 entry corrupted.\n", offset);

+ res->corruptions++;

+ }

+ }

+

/* Mark cluster as used */

ret = qcow2_inc_refcounts_imrt(bs, res,

refcount_table, refcount_table_size,

@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,

if (ret < 0) {

goto fail;

}

-

- /* Correct offsets are cluster aligned */

- if (offset_into_cluster(s, offset)) {

- fprintf(stderr, "ERROR offset=%" PRIx64 ": Cluster is not "

- "properly aligned; L2 entry corrupted.\n", offset);

- res->corruptions++;

- }

break;

}

@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,

void **refcount_table,

int64_t *refcount_table_size,

int64_t l1_table_offset, int l1_size,

- int flags)

+ int flags, BdrvCheckMode fix)

{

BDRVQcow2State *s = bs->opaque;

uint64_t *l1_table = NULL, l2_offset, l1_size2;

@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,

/* Process and check L2 entries */

ret = check_refcounts_l2(bs, res, refcount_table,

- refcount_table_size, l2_offset, flags);

+ refcount_table_size, l2_offset, flags,

+ fix);

if (ret < 0) {

goto fail;

}

@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,

/* current L1 table */

ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,

- s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO);

+ s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO,

+ fix);

if (ret < 0) {

return ret;

}

@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,

for (i = 0; i < s->nb_snapshots; i++) {

sn = s->snapshots + i;

ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,

- sn->l1_table_offset, sn->l1_size, 0);

+ sn->l1_table_offset, sn->l1_size, 0, fix);

if (ret < 0) {

return ret;

}

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/060

+++ b/tests/qemu-iotests/060

@@ -XXX,XX +XXX,XX @@ poke_file "$TEST_IMG" "$l2_offset" "\x80\x00\x00\x00\x00\x00\x2a\x01"

# Let's write to it!

$QEMU_IO -c "write 0 64k" "$TEST_IMG" | _filter_qemu_io

-# Can't repair this yet (TODO: We can just deallocate the cluster)

+echo '--- Repairing ---'

+_check_test_img -r all

echo

echo '=== Discarding with an unaligned refblock ==='

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

index XXXXXXX..XXXXXXX 100644

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

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

@@ -XXX,XX +XXX,XX @@ discard 65536/65536 bytes at offset 0

64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

qcow2: Marking image as corrupt: Preallocated zero cluster offset 0x2a00 unaligned (guest offset: 0); further corruption events will be suppressed

write failed: Input/output error

+--- Repairing ---

+Repairing offset=2a00: Preallocated zero cluster is not properly aligned; L2 entry corrupted.

+The following inconsistencies were found and repaired:

+

+ 0 leaked clusters

+ 1 corruptions

+

+Double checking the fixed image now...

+No errors were found on the image.

=== Discarding with an unaligned refblock ===

--

2.13.6

From: Max Reitz <mreitz@redhat.com>

In some cases, these commands still use the deprecated @device

parameter. Fix that so we can later drop that parameter from their

interface.

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

Message-id: 20171110224302.14424-2-mreitz@redhat.com

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

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

---

tests/qemu-iotests/118 | 184 +++++++++++++++++++++++--------------------------

tests/qemu-iotests/155 | 60 ++++++++--------

2 files changed, 113 insertions(+), 131 deletions(-)

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/118

+++ b/tests/qemu-iotests/118

@@ -XXX,XX +XXX,XX @@ from iotests import qemu_img

old_img = os.path.join(iotests.test_dir, 'test0.img')

new_img = os.path.join(iotests.test_dir, 'test1.img')

+def interface_to_device_name(interface):

+ if interface == 'ide':

+ return 'ide-cd'

+ elif interface == 'floppy':

+ return 'floppy'

+ else:

+ return None

+

class ChangeBaseClass(iotests.QMPTestCase):

has_opened = False

has_closed = False

@@ -XXX,XX +XXX,XX @@ class ChangeBaseClass(iotests.QMPTestCase):

class GeneralChangeTestsBaseClass(ChangeBaseClass):

- device_name = None

+ device_name = 'qdev0'

def test_change(self):

result = self.vm.qmp('change', device='drive0', target=new_img,

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)

def test_blockdev_change_medium(self):

- if self.device_name is not None:

- result = self.vm.qmp('blockdev-change-medium',

- id=self.device_name, filename=new_img,

- format=iotests.imgfmt)

- else:

- result = self.vm.qmp('blockdev-change-medium',

- device='drive0', filename=new_img,

- format=iotests.imgfmt)

+ result = self.vm.qmp('blockdev-change-medium',

+ id=self.device_name, filename=new_img,

+ format=iotests.imgfmt)

self.assert_qmp(result, 'return', {})

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)

def test_eject(self):

- if self.device_name is not None:

- result = self.vm.qmp('eject', id=self.device_name, force=True)

- else:

- result = self.vm.qmp('eject', device='drive0', force=True)

+ result = self.vm.qmp('eject', id=self.device_name, force=True)

self.assert_qmp(result, 'return', {})

self.wait_for_open()

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp_absent(result, 'return[0]/inserted')

def test_tray_eject_change(self):

- if self.device_name is not None:

- result = self.vm.qmp('eject', id=self.device_name, force=True)

- else:

- result = self.vm.qmp('eject', device='drive0', force=True)

+ result = self.vm.qmp('eject', id=self.device_name, force=True)

self.assert_qmp(result, 'return', {})

self.wait_for_open()

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/tray_open', True)

self.assert_qmp_absent(result, 'return[0]/inserted')

- if self.device_name is not None:

- result = self.vm.qmp('blockdev-change-medium', id=self.device_name,

- filename=new_img, format=iotests.imgfmt)

- else:

- result = self.vm.qmp('blockdev-change-medium', device='drive0',

- filename=new_img, format=iotests.imgfmt)

+ result = self.vm.qmp('blockdev-change-medium', id=self.device_name,

+ filename=new_img, format=iotests.imgfmt)

self.assert_qmp(result, 'return', {})

self.wait_for_close()

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)

def test_tray_open_close(self):

- if self.device_name is not None:

- result = self.vm.qmp('blockdev-open-tray',

- id=self.device_name, force=True)

- else:

- result = self.vm.qmp('blockdev-open-tray',

- device='drive0', force=True)

+ result = self.vm.qmp('blockdev-open-tray',

+ id=self.device_name, force=True)

self.assert_qmp(result, 'return', {})

self.wait_for_open()

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

else:

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

- if self.device_name is not None:

- result = self.vm.qmp('blockdev-close-tray', id=self.device_name)

- else:

- result = self.vm.qmp('blockdev-close-tray', device='drive0')

+ result = self.vm.qmp('blockdev-close-tray', id=self.device_name)

self.assert_qmp(result, 'return', {})

if self.has_real_tray or not self.was_empty:

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

def test_tray_eject_close(self):

- result = self.vm.qmp('eject', device='drive0', force=True)

+ result = self.vm.qmp('eject', id=self.device_name, force=True)

self.assert_qmp(result, 'return', {})

self.wait_for_open()

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/tray_open', True)

self.assert_qmp_absent(result, 'return[0]/inserted')

- if self.device_name is not None:

- result = self.vm.qmp('blockdev-close-tray', id=self.device_name)

- else:

- result = self.vm.qmp('blockdev-close-tray', device='drive0')

+ result = self.vm.qmp('blockdev-close-tray', id=self.device_name)

self.assert_qmp(result, 'return', {})

self.wait_for_close()

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp_absent(result, 'return[0]/inserted')

def test_tray_open_change(self):

- result = self.vm.qmp('blockdev-open-tray', device='drive0', force=True)

+ result = self.vm.qmp('blockdev-open-tray', id=self.device_name,

+ force=True)

self.assert_qmp(result, 'return', {})

self.wait_for_open()

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

else:

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

- result = self.vm.qmp('blockdev-change-medium', device='drive0',

+ result = self.vm.qmp('blockdev-change-medium', id=self.device_name,

filename=new_img,

format=iotests.imgfmt)

self.assert_qmp(result, 'return', {})

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

'driver': 'file'})

self.assert_qmp(result, 'return', {})

- if self.device_name is not None:

- result = self.vm.qmp('blockdev-open-tray',

- id=self.device_name, force=True)

- else:

- result = self.vm.qmp('blockdev-open-tray',

- device='drive0', force=True)

+ result = self.vm.qmp('blockdev-open-tray',

+ id=self.device_name, force=True)

self.assert_qmp(result, 'return', {})

self.wait_for_open()

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

else:

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

- if self.device_name is not None:

- result = self.vm.qmp('x-blockdev-remove-medium',

- id=self.device_name)

- else:

- result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')

+ result = self.vm.qmp('x-blockdev-remove-medium',

+ id=self.device_name)

self.assert_qmp(result, 'return', {})

result = self.vm.qmp('query-block')

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/tray_open', True)

self.assert_qmp_absent(result, 'return[0]/inserted')

- if self.device_name is not None:

- result = self.vm.qmp('x-blockdev-insert-medium',

- id=self.device_name, node_name='new')

- else:

- result = self.vm.qmp('x-blockdev-insert-medium',

- device='drive0', node_name='new')

+ result = self.vm.qmp('x-blockdev-insert-medium',

+ id=self.device_name, node_name='new')

self.assert_qmp(result, 'return', {})

result = self.vm.qmp('query-block')

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/tray_open', True)

self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)

- if self.device_name is not None:

- result = self.vm.qmp('blockdev-close-tray', id=self.device_name)

- else:

- result = self.vm.qmp('blockdev-close-tray', device='drive0')

+ result = self.vm.qmp('blockdev-close-tray', id=self.device_name)

self.assert_qmp(result, 'return', {})

self.wait_for_close()

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)

def test_close_on_closed(self):

- result = self.vm.qmp('blockdev-close-tray', device='drive0')

+ result = self.vm.qmp('blockdev-close-tray', id=self.device_name)

# Should be a no-op

self.assert_qmp(result, 'return', {})

self.assertEquals(self.vm.get_qmp_events(wait=False), [])

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

if not self.has_real_tray:

return

- result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')

+ result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)

self.assert_qmp(result, 'error/class', 'GenericError')

def test_insert_on_closed(self):

@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):

'driver': 'file'})

self.assert_qmp(result, 'return', {})

- result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',

+ result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,

node_name='new')

self.assert_qmp(result, 'error/class', 'GenericError')

@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):

qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')

qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')

self.vm = iotests.VM()

- if interface == 'ide':

- self.device_name = 'qdev0'

- self.vm.add_drive(old_img, 'media=%s' % media, 'none')

- self.vm.add_device('ide-cd,drive=drive0,id=%s' % self.device_name)

- else:

- self.vm.add_drive(old_img, 'media=%s' % media, interface)

+ self.vm.add_drive(old_img, 'media=%s' % media, 'none')

+ self.vm.add_device('%s,drive=drive0,id=%s' %

+ (interface_to_device_name(interface),

+ self.device_name))

self.vm.launch()

def tearDown(self):

@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):

'driver': 'file'})

self.assert_qmp(result, 'return', {})

- result = self.vm.qmp('blockdev-open-tray', device='drive0')

+ result = self.vm.qmp('blockdev-open-tray', id=self.device_name)

self.assert_qmp(result, 'return', {})

self.wait_for_open()

- result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',

+ result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,

node_name='new')

self.assert_qmp(result, 'error/class', 'GenericError')

@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):

def setUp(self, media, interface):

qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')

- self.vm = iotests.VM().add_drive(None, 'media=%s' % media, interface)

+ self.vm = iotests.VM().add_drive(None, 'media=%s' % media, 'none')

+ self.vm.add_device('%s,drive=drive0,id=%s' %

+ (interface_to_device_name(interface),

+ self.device_name))

self.vm.launch()

def tearDown(self):

@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):

os.remove(new_img)

def test_remove_on_empty(self):

- result = self.vm.qmp('blockdev-open-tray', device='drive0')

+ result = self.vm.qmp('blockdev-open-tray', id=self.device_name)

self.assert_qmp(result, 'return', {})

self.wait_for_open()

- result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')

+ result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)

# Should be a no-op

self.assert_qmp(result, 'return', {})

@@ -XXX,XX +XXX,XX @@ class TestFloppyInitiallyEmpty(TestInitiallyEmpty):

self.has_opened = True

class TestChangeReadOnly(ChangeBaseClass):

+ device_name = 'qdev0'

+

def setUp(self):

qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')

qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

def test_ro_ro_retain(self):

os.chmod(old_img, 0444)

os.chmod(new_img, 0444)

- self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

self.assert_qmp(result, 'return[0]/inserted/ro', True)

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

- result = self.vm.qmp('blockdev-change-medium', device='drive0',

+ result = self.vm.qmp('blockdev-change-medium', id=self.device_name,

filename=new_img,

format=iotests.imgfmt,

read_only_mode='retain')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

def test_ro_rw_retain(self):

os.chmod(old_img, 0444)

- self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

self.assert_qmp(result, 'return[0]/inserted/ro', True)

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

- result = self.vm.qmp('blockdev-change-medium', device='drive0',

+ result = self.vm.qmp('blockdev-change-medium', id=self.device_name,

filename=new_img,

format=iotests.imgfmt,

read_only_mode='retain')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

def test_rw_ro_retain(self):

os.chmod(new_img, 0444)

- self.vm.add_drive(old_img, 'media=disk', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

self.assert_qmp(result, 'return[0]/inserted/ro', False)

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

- result = self.vm.qmp('blockdev-change-medium', device='drive0',

+ result = self.vm.qmp('blockdev-change-medium', id=self.device_name,

filename=new_img,

format=iotests.imgfmt,

read_only_mode='retain')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

def test_ro_rw(self):

os.chmod(old_img, 0444)

- self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

result = self.vm.qmp('blockdev-change-medium',

- device='drive0',

+ id=self.device_name,

filename=new_img,

format=iotests.imgfmt,

read_only_mode='read-write')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

def test_rw_ro(self):

os.chmod(new_img, 0444)

- self.vm.add_drive(old_img, 'media=disk', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

result = self.vm.qmp('blockdev-change-medium',

- device='drive0',

+ id=self.device_name,

filename=new_img,

format=iotests.imgfmt,

read_only_mode='read-only')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)

def test_make_rw_ro(self):

- self.vm.add_drive(old_img, 'media=disk', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

result = self.vm.qmp('blockdev-change-medium',

- device='drive0',

+ id=self.device_name,

filename=new_img,

format=iotests.imgfmt,

read_only_mode='read-only')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

def test_make_ro_rw(self):

os.chmod(new_img, 0444)

- self.vm.add_drive(old_img, 'media=disk', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

result = self.vm.qmp('blockdev-change-medium',

- device='drive0',

+ id=self.device_name,

filename=new_img,

format=iotests.imgfmt,

read_only_mode='read-write')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

def test_make_rw_ro_by_retain(self):

os.chmod(old_img, 0444)

- self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

self.assert_qmp(result, 'return[0]/inserted/ro', True)

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

- result = self.vm.qmp('blockdev-change-medium', device='drive0',

+ result = self.vm.qmp('blockdev-change-medium', id=self.device_name,

filename=new_img,

format=iotests.imgfmt,

read_only_mode='retain')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

def test_make_ro_rw_by_retain(self):

os.chmod(new_img, 0444)

- self.vm.add_drive(old_img, 'media=disk', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

self.assert_qmp(result, 'return[0]/inserted/ro', False)

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

- result = self.vm.qmp('blockdev-change-medium', device='drive0',

+ result = self.vm.qmp('blockdev-change-medium', id=self.device_name,

filename=new_img,

format=iotests.imgfmt,

read_only_mode='retain')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

def test_rw_ro_cycle(self):

os.chmod(new_img, 0444)

- self.vm.add_drive(old_img, 'media=disk', 'floppy')

+ self.vm.add_drive(old_img, 'media=disk', 'none')

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):

self.assert_qmp(result, 'return[0]/inserted/ro', False)

self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)

- result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')

+ result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)

self.assert_qmp(result, 'return', {})

result = self.vm.qmp('query-block')

self.assert_qmp_absent(result, 'return[0]/inserted')

- result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',

+ result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,

node_name='new')

self.assert_qmp(result, 'return', {})

@@ -XXX,XX +XXX,XX @@ TestInitiallyEmpty = None

class TestBlockJobsAfterCycle(ChangeBaseClass):

+ device_name = 'qdev0'

+

def setUp(self):

- qemu_img('create', '-f', iotests.imgfmt, old_img, '1M')

+ qemu_img('create', '-f', iotests.imgfmt, old_img, '1440K')

self.vm = iotests.VM()

self.vm.add_drive_raw("id=drive0,driver=null-co,if=none")

+ self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)

self.vm.launch()

result = self.vm.qmp('query-block')

@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):

# For device-less BBs, calling blockdev-open-tray or blockdev-close-tray

# is not necessary

- result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')

+ result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)

self.assert_qmp(result, 'return', {})

result = self.vm.qmp('query-block')

@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):

'driver': 'file'})

self.assert_qmp(result, 'return', {})

- result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',

+ result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,

node_name='node0')

self.assert_qmp(result, 'return', {})

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/155

+++ b/tests/qemu-iotests/155

@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):

target_real_backing = None

def setUp(self):

- qemu_img('create', '-f', iotests.imgfmt, back0_img, '1M')

+ qemu_img('create', '-f', iotests.imgfmt, back0_img, '1440K')

qemu_img('create', '-f', iotests.imgfmt, '-b', back0_img, back1_img)

qemu_img('create', '-f', iotests.imgfmt, '-b', back1_img, back2_img)

qemu_img('create', '-f', iotests.imgfmt, '-b', back2_img, source_img)

self.vm = iotests.VM()

- self.vm.add_drive(None, '', 'none')

- self.vm.launch()

-

# Add the BDS via blockdev-add so it stays around after the mirror block

# job has been completed

- result = self.vm.qmp('blockdev-add',

- node_name='source',

- driver=iotests.imgfmt,

- file={'driver': 'file',

- 'filename': source_img})

- self.assert_qmp(result, 'return', {})

-

- result = self.vm.qmp('x-blockdev-insert-medium',

- device='drive0', node_name='source')

- self.assert_qmp(result, 'return', {})

+ blockdev = {'node-name': 'source',

+ 'driver': iotests.imgfmt,

+ 'file': {'driver': 'file',

+ 'filename': source_img}}

+ self.vm.add_blockdev(self.qmp_to_opts(blockdev))

+ self.vm.add_device('floppy,id=qdev0,drive=source')

+ self.vm.launch()

self.assertIntactSourceBackingChain()

if self.existing:

if self.target_backing:

qemu_img('create', '-f', iotests.imgfmt,

- '-b', self.target_backing, target_img, '1M')