The following changes since commit 754f756cc4c6d9d14b7230c62b5bb20f9d655888:

Merge tag 'pull-target-arm-20220422-1' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-04-22 08:03:18 -0700)

https://gitlab.com/hreitz/qemu.git tags/pull-block-2022-04-25

for you to fetch changes up to 348a0740afc5b313599533eb69bbb2b95d2f1bba:

iotests/108: Fix when missing user_allow_other (2022-04-25 14:46:45 +0200)

Block patches:

- New @force parameter for blockdev-change-medium

- Improvements to the iotests to help with debugging

- Fix iotest 108 on systems without user_allow_other in fuse.conf

Hanna Reitz (1):

iotests/108: Fix when missing user_allow_other

John Snow (12):

iotests: replace calls to log(qemu_io(...)) with qemu_io_log()

iotests/163: Fix broken qemu-io invocation

iotests: Don't check qemu_io() output for specific error strings

iotests/040: Don't check image pattern on zero-length image

iotests/040: Fix TestCommitWithFilters test

iotests: create generic qemu_tool() function

iotests: rebase qemu_io() on top of qemu_tool()

iotests/migration-permissions: use assertRaises() for qemu_io()

negative test

iotests/image-fleecing: switch to qemu_io()

iotests: remove qemu_io_pipe_and_status()

iotests: remove qemu_io_silent() and qemu_io_silent_check().

iotests: make qemu_io_log() check return codes by default

qapi/block.json | 6 ++

block/qapi-sysemu.c | 3 +-

monitor/hmp-cmds.c | 4 +-

hmp-commands.hx | 11 ++-

tests/qemu-iotests/030 | 85 +++++++++++--------

tests/qemu-iotests/040 | 53 +++++++-----

tests/qemu-iotests/056 | 2 +-

tests/qemu-iotests/108 | 2 +-

tests/qemu-iotests/149 | 6 +-

tests/qemu-iotests/163 | 5 +-

tests/qemu-iotests/205 | 4 +-

tests/qemu-iotests/216 | 12 +--

tests/qemu-iotests/218 | 5 +-

tests/qemu-iotests/224 | 4 +-

tests/qemu-iotests/242 | 6 +-

tests/qemu-iotests/245 | 17 ++--

tests/qemu-iotests/255 | 4 +-

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

tests/qemu-iotests/298 | 17 ++--

tests/qemu-iotests/303 | 4 +-

tests/qemu-iotests/310 | 22 ++---

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

tests/qemu-iotests/tests/image-fleecing | 30 ++++---

.../qemu-iotests/tests/migration-permissions | 28 +++---

.../tests/mirror-ready-cancel-error | 2 +-

.../qemu-iotests/tests/nbd-reconnect-on-open | 2 +-

.../qemu-iotests/tests/stream-error-on-reset | 4 +-

ui/cocoa.m | 1 +

28 files changed, 231 insertions(+), 188 deletions(-)

2.35.1

From: "Denis V. Lunev" <den@openvz.org>

'blockdev-change-medium' is a convinient wrapper for the following

sequence of commands:

* blockdev-open-tray

* blockdev-remove-medium

* blockdev-insert-medium

* blockdev-close-tray

and should be used f.e. to change ISO image inside the CD-ROM tray.

Though the guest could lock the tray and some linux guests like

CentOS 8.5 actually does that. In this case the execution if this

command results in the error like the following:

Device 'scsi0-0-1-0' is locked and force was not specified,

wait for tray to open and try again.

This situation is could be resolved 'blockdev-open-tray' by passing

flag 'force' inside. Thus is seems reasonable to add the same

capability for 'blockdev-change-medium' too.

Signed-off-by: Denis V. Lunev <den@openvz.org>

Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@openvz.org>

Acked-by: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

CC: Kevin Wolf <kwolf@redhat.com>

CC: Hanna Reitz <hreitz@redhat.com>

CC: Eric Blake <eblake@redhat.com>

CC: Markus Armbruster <armbru@redhat.com>

Message-Id: <20220412221846.280723-1-den@openvz.org>

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>

Signed-off-by: Hanna Reitz <hreitz@redhat.com>

qapi/block.json | 6 ++++++

block/qapi-sysemu.c | 3 ++-

monitor/hmp-cmds.c | 4 +++-

hmp-commands.hx | 11 +++++++----

ui/cocoa.m | 1 +

5 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/qapi/block.json b/qapi/block.json

--- a/qapi/block.json

+++ b/qapi/block.json

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

# @read-only-mode: change the read-only mode of the device; defaults

# to 'retain'

#

+# @force: if false (the default), an eject request through blockdev-open-tray

+# will be sent to the guest if it has locked the tray (and the tray

+# will not be opened immediately); if true, the tray will be opened

+# regardless of whether it is locked. (since 7.1)

+#

# Features:

# @deprecated: Member @device is deprecated. Use @id instead.

#

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

'*id': 'str',

'filename': 'str',

'*format': 'str',

+ '*force': 'bool',

'*read-only-mode': 'BlockdevChangeReadOnlyMode' } }

diff --git a/block/qapi-sysemu.c b/block/qapi-sysemu.c

index XXXXXXX..XXXXXXX 100644

--- a/block/qapi-sysemu.c

+++ b/block/qapi-sysemu.c

@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_change_medium(bool has_device, const char *device,

bool has_id, const char *id,

const char *filename,

bool has_format, const char *format,

+ bool has_force, bool force,

bool has_read_only,

BlockdevChangeReadOnlyMode read_only,

Error **errp)

@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_change_medium(bool has_device, const char *device,

rc = do_open_tray(has_device ? device : NULL,

has_id ? id : NULL,

- false, &err);

+ force, &err);

if (rc && rc != -ENOSYS) {

error_propagate(errp, err);

goto fail;

diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c

index XXXXXXX..XXXXXXX 100644

--- a/monitor/hmp-cmds.c

+++ b/monitor/hmp-cmds.c

@@ -XXX,XX +XXX,XX @@ void hmp_change(Monitor *mon, const QDict *qdict)

const char *target = qdict_get_str(qdict, "target");

const char *arg = qdict_get_try_str(qdict, "arg");

const char *read_only = qdict_get_try_str(qdict, "read-only-mode");

+ bool force = qdict_get_try_bool(qdict, "force", false);

BlockdevChangeReadOnlyMode read_only_mode = 0;

Error *err = NULL;

@@ -XXX,XX +XXX,XX @@ void hmp_change(Monitor *mon, const QDict *qdict)

}

qmp_blockdev_change_medium(true, device, false, NULL, target,

- !!arg, arg, !!read_only, read_only_mode,

+ !!arg, arg, true, force,

+ !!read_only, read_only_mode,

&err);

diff --git a/hmp-commands.hx b/hmp-commands.hx

index XXXXXXX..XXXXXXX 100644

--- a/hmp-commands.hx

+++ b/hmp-commands.hx

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

{

.name = "change",

- .args_type = "device:B,target:F,arg:s?,read-only-mode:s?",

- .params = "device filename [format [read-only-mode]]",

- .help = "change a removable medium, optional format",

+ .args_type = "device:B,force:-f,target:F,arg:s?,read-only-mode:s?",

+ .params = "device [-f] filename [format [read-only-mode]]",

+ .help = "change a removable medium, optional format, use -f to force the operation",

.cmd = hmp_change,

},

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

``change`` *device* *setting*

Change the configuration of a device.

- ``change`` *diskdevice* *filename* [*format* [*read-only-mode*]]

+ ``change`` *diskdevice* [-f] *filename* [*format* [*read-only-mode*]]

Change the medium for a removable disk device to point to *filename*. eg::

(qemu) change ide1-cd0 /path/to/some.iso

+ ``-f``

+ forces the operation even if the guest has locked the tray.

+

*format* is optional.

*read-only-mode* may be used to change the read-only status of the device.

diff --git a/ui/cocoa.m b/ui/cocoa.m

index XXXXXXX..XXXXXXX 100644

--- a/ui/cocoa.m

+++ b/ui/cocoa.m

@@ -XXX,XX +XXX,XX @@ - (void)changeDeviceMedia:(id)sender

[file cStringUsingEncoding:

NSASCIIStringEncoding],

true, "raw",

+ true, false,

false, 0,

&err);

});

2.35.1

From: John Snow <jsnow@redhat.com>

qemu-io fails on read/write beyond end-of-file on raw images, so skip

these invocations when running the zero-length image tests.

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

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

Reviewed-by: Hanna Reitz <hreitz@redhat.com>

Message-Id: <20220418211504.943969-5-jsnow@redhat.com>

Signed-off-by: Hanna Reitz <hreitz@redhat.com>

---

tests/qemu-iotests/040 | 14 ++++++++++++--

1 file changed, 12 insertions(+), 2 deletions(-)

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/040

+++ b/tests/qemu-iotests/040

@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(ImageCommitTestCase):

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

'-o', 'backing_file=%s' % mid_img,

'-F', iotests.imgfmt, test_img)

- qemu_io('-f', 'raw', '-c', 'write -P 0xab 0 524288', backing_img)

- qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xef 524288 524288', mid_img)

+ if self.image_len:

+ qemu_io('-f', 'raw', '-c', 'write -P 0xab 0 524288', backing_img)

+ qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xef 524288 524288',

+ mid_img)

self.vm = iotests.VM().add_drive(test_img, "node-name=top,backing.node-name=mid,backing.backing.node-name=base", interface="none")

self.vm.add_device('virtio-scsi')

self.vm.add_device("scsi-hd,id=scsi0,drive=drive0")

@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(ImageCommitTestCase):

def test_commit(self):

self.run_commit_test(mid_img, backing_img)

+ if not self.image_len:

+ return

qemu_io('-f', 'raw', '-c', 'read -P 0xab 0 524288', backing_img)

qemu_io('-f', 'raw', '-c', 'read -P 0xef 524288 524288', backing_img)

def test_commit_node(self):

self.run_commit_test("mid", "base", node_names=True)

+ if not self.image_len:

+ return

qemu_io('-f', 'raw', '-c', 'read -P 0xab 0 524288', backing_img)

qemu_io('-f', 'raw', '-c', 'read -P 0xef 524288 524288', backing_img)

@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(ImageCommitTestCase):

def test_top_is_active(self):

self.run_commit_test(test_img, backing_img, need_ready=True)

+ if not self.image_len:

+ return

qemu_io('-f', 'raw', '-c', 'read -P 0xab 0 524288', backing_img)

qemu_io('-f', 'raw', '-c', 'read -P 0xef 524288 524288', backing_img)

def test_top_is_default_active(self):

self.run_default_commit_test()

+ if not self.image_len:

+ return

qemu_io('-f', 'raw', '-c', 'read -P 0xab 0 524288', backing_img)

qemu_io('-f', 'raw', '-c', 'read -P 0xef 524288 524288', backing_img)

2.35.1

From: John Snow <jsnow@redhat.com>

Without this change, asserting that qemu_io always returns 0 causes this

test to fail in a way we happened not to be catching previously:

qemu.utils.VerboseProcessError: Command

'('/home/jsnow/src/qemu/bin/git/tests/qemu-iotests/../../qemu-io',

'--cache', 'writeback', '--aio', 'threads', '-f', 'qcow2', '-c',

'read -P 4 3M 1M',

'/home/jsnow/src/qemu/bin/git/tests/qemu-iotests/scratch/3.img')'

returned non-zero exit status 1.

┏━ output ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

┃ qemu-io: can't open device

┃ /home/jsnow/src/qemu/bin/git/tests/qemu-iotests/scratch/3.img:

┃ Could not open backing file: Could not open backing file: Throttle

┃ group 'tg' does not exist

┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The commit jobs changes the backing file string stored in the image file

header belonging to the node above the commit’s top node to point to the

commit target (the base node). QEMU tries to be as accurate as

possible, and so in these test cases will include the filter that is

part of the block graph in that backing file string (by virtue of making

it a json:{} description of the post-commit subgraph). This makes

little sense outside of QEMU, though: Specifically, the throttle node in

that subgraph will dearly miss its supposedly associated throttle group

object.

When starting the commit job, we can specify a custom backing file

string to write into said image file, so let’s use that feature to write

the plain filename of the backing chain’s next actual image file there.

Explicitly provide the backing file so that opening the file outside of

QEMU (Where we will not have throttle groups) will succeed.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>

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

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

Message-Id: <20220418211504.943969-6-jsnow@redhat.com>

tests/qemu-iotests/040 | 6 ++++--

1 file changed, 4 insertions(+), 2 deletions(-)

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/040

+++ b/tests/qemu-iotests/040

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

job_id='commit',

device='top-filter',

top_node='cow-2',

- base_node='cow-1')

+ base_node='cow-1',

+ backing_file=self.img1)

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

self.wait_until_completed(drive='commit')

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

job_id='commit',

device='top-filter',

top_node='cow-1',

- base_node='cow-0')

+ base_node='cow-0',

+ backing_file=self.img0)

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

self.wait_until_completed(drive='commit')

2.35.1

From: John Snow <jsnow@redhat.com>

Rework qemu_io() to be analogous to qemu_img(); a function that requires

a return code of zero by default unless disabled explicitly.

Tests that use qemu_io():

030 040 041 044 055 056 093 124 129 132 136 148 149 151 152 163 165 205

209 219 236 245 248 254 255 257 260 264 280 298 300 302 304

image-fleecing migrate-bitmaps-postcopy-test migrate-bitmaps-test

migrate-during-backup migration-permissions

Test that use qemu_io_log():

242 245 255 274 303 307 nbd-reconnect-on-open

Copy-pastables for testing/verification:

./check -qcow2 030 040 041 044 055 056 124 129 132 151 152 163 165 209 \

219 236 242 245 248 254 255 257 260 264 274 \

280 298 300 302 303 304 307 image-fleecing \

migrate-bitmaps-postcopy-test migrate-bitmaps-test \

migrate-during-backup nbd-reconnect-on-open

./check -raw 093 136 148 migration-permissions

./check -nbd 205

# ./configure configure --disable-gnutls --enable-gcrypt

# this ALSO requires passwordless sudo.

./check -luks 149

# Just the tests that were edited in this commit:

./check -qcow2 030 040 242 245

./check -raw migration-permissions

./check -nbd 205

./check -luks 149

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

Message-Id: <20220418211504.943969-8-jsnow@redhat.com>

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

Signed-off-by: Hanna Reitz <hreitz@redhat.com>

---

tests/qemu-iotests/030 | 85 +++++++++++--------

tests/qemu-iotests/149 | 6 +-

tests/qemu-iotests/205 | 4 +-

tests/qemu-iotests/245 | 17 ++--

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

.../qemu-iotests/tests/migration-permissions | 4 +-

6 files changed, 81 insertions(+), 54 deletions(-)

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/030

+++ b/tests/qemu-iotests/030

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

self.assert_no_active_block_jobs()

self.vm.shutdown()

- self.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img),

- qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img),

- 'image file map does not match backing file after streaming')

+ self.assertEqual(

+ qemu_io('-f', 'raw', '-c', 'map', backing_img).stdout,

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img).stdout,

+ 'image file map does not match backing file after streaming')

def test_stream_intermediate(self):

self.assert_no_active_block_jobs()

- self.assertNotEqual(qemu_io('-f', 'raw', '-rU', '-c', 'map', backing_img),

- qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', mid_img),

- 'image file map matches backing file before streaming')

+ self.assertNotEqual(

+ qemu_io('-f', 'raw', '-rU', '-c', 'map', backing_img).stdout,

+ qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', mid_img).stdout,

+ 'image file map matches backing file before streaming')

result = self.vm.qmp('block-stream', device='mid', job_id='stream-mid')

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

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

self.assert_no_active_block_jobs()

self.vm.shutdown()

- self.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img),

- qemu_io('-f', iotests.imgfmt, '-c', 'map', mid_img),

- 'image file map does not match backing file after streaming')

+ self.assertEqual(

+ qemu_io('-f', 'raw', '-c', 'map', backing_img).stdout,

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', mid_img).stdout,

+ 'image file map does not match backing file after streaming')

def test_stream_pause(self):

self.assert_no_active_block_jobs()

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

self.assert_no_active_block_jobs()

self.vm.shutdown()

- self.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img),

- qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img),

- 'image file map does not match backing file after streaming')

+ self.assertEqual(

+ qemu_io('-f', 'raw', '-c', 'map', backing_img).stdout,

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img).stdout,

+ 'image file map does not match backing file after streaming')

def test_stream_no_op(self):

self.assert_no_active_block_jobs()

# The image map is empty before the operation

- empty_map = qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', test_img)

+ empty_map = qemu_io(

+ '-f', iotests.imgfmt, '-rU', '-c', 'map', test_img).stdout

# This is a no-op: no data should ever be copied from the base image

result = self.vm.qmp('block-stream', device='drive0', base=mid_img)

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

self.assert_no_active_block_jobs()

self.vm.shutdown()

- self.assertEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img),

- empty_map, 'image file map changed after a no-op')

+ self.assertEqual(

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img).stdout,

+ empty_map, 'image file map changed after a no-op')

def test_stream_partial(self):

self.assert_no_active_block_jobs()

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

self.assert_no_active_block_jobs()

self.vm.shutdown()

- self.assertEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', mid_img),

- qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img),

- 'image file map does not match backing file after streaming')

+ self.assertEqual(

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', mid_img).stdout,

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img).stdout,

+ 'image file map does not match backing file after streaming')

def test_device_not_found(self):

result = self.vm.qmp('block-stream', device='nonexistent')

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

# Check that the maps don't match before the streaming operations

for i in range(2, self.num_imgs, 2):

- self.assertNotEqual(qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.imgs[i]),

- qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.imgs[i-1]),

- 'image file map matches backing file before streaming')

+ self.assertNotEqual(

+ qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.imgs[i]).stdout,

+ qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.imgs[i-1]).stdout,

+ 'image file map matches backing file before streaming')

# Create all streaming jobs

pending_jobs = []

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

# Check that all maps match now

for i in range(2, self.num_imgs, 2):

- self.assertEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[i]),

- qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[i-1]),

- 'image file map does not match backing file after streaming')

+ self.assertEqual(

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[i]).stdout,

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[i-1]).stdout,

+ 'image file map does not match backing file after streaming')

# Test that it's not possible to perform two block-stream

# operations if there are nodes involved in both.

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

def test_stream_base_node_name(self):

self.assert_no_active_block_jobs()

- self.assertNotEqual(qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.imgs[4]),

- qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.imgs[3]),

- 'image file map matches backing file before streaming')

+ self.assertNotEqual(

+ qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.imgs[4]).stdout,

+ qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.imgs[3]).stdout,

+ 'image file map matches backing file before streaming')

# Error: the base node does not exist

result = self.vm.qmp('block-stream', device='node4', base_node='none', job_id='stream')

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

self.assert_no_active_block_jobs()

self.vm.shutdown()

- self.assertEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[4]),

- qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[3]),

- 'image file map matches backing file after streaming')

+ self.assertEqual(

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[4]).stdout,

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.imgs[3]).stdout,

+ 'image file map matches backing file after streaming')

class TestQuorum(iotests.QMPTestCase):

num_children = 3

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

os.remove(img)

def test_stream_quorum(self):

- self.assertNotEqual(qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.children[0]),

- qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.backing[0]),

- 'image file map matches backing file before streaming')

+ self.assertNotEqual(

+ qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.children[0]).stdout,

+ qemu_io('-f', iotests.imgfmt, '-rU', '-c', 'map', self.backing[0]).stdout,

+ 'image file map matches backing file before streaming')

self.assert_no_active_block_jobs()

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

self.assert_no_active_block_jobs()

self.vm.shutdown()

- self.assertEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', self.children[0]),

- qemu_io('-f', iotests.imgfmt, '-c', 'map', self.backing[0]),

- 'image file map does not match backing file after streaming')

+ self.assertEqual(

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.children[0]).stdout,

+ qemu_io('-f', iotests.imgfmt, '-c', 'map', self.backing[0]).stdout,

+ 'image file map does not match backing file after streaming')

class TestSmallerBackingFile(iotests.QMPTestCase):

backing_len = 1 * 1024 * 1024 # MB

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/149

+++ b/tests/qemu-iotests/149

@@ -XXX,XX +XXX,XX @@ def qemu_io_write_pattern(config, pattern, offset_mb, size_mb, dev=False):

args = ["-c", "write -P 0x%x %dM %dM" % (pattern, offset_mb, size_mb)]

args.extend(qemu_io_image_args(config, dev))

iotests.log("qemu-io " + " ".join(args), filters=[iotests.filter_test_dir])

- iotests.log(check_cipher_support(config, iotests.qemu_io(*args)),

+ output = iotests.qemu_io(*args, check=False).stdout

+ iotests.log(check_cipher_support(config, output),

filters=[iotests.filter_test_dir, iotests.filter_qemu_io])

@@ -XXX,XX +XXX,XX @@ def qemu_io_read_pattern(config, pattern, offset_mb, size_mb, dev=False):

args = ["-c", "read -P 0x%x %dM %dM" % (pattern, offset_mb, size_mb)]

args.extend(qemu_io_image_args(config, dev))

iotests.log("qemu-io " + " ".join(args), filters=[iotests.filter_test_dir])

- iotests.log(check_cipher_support(config, iotests.qemu_io(*args)),

+ output = iotests.qemu_io(*args, check=False).stdout

+ iotests.log(check_cipher_support(config, output),

filters=[iotests.filter_test_dir, iotests.filter_qemu_io])

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/205

+++ b/tests/qemu-iotests/205

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

def do_test_connect_after_remove(self, mode=None):

args = ('-r', '-f', 'raw', '-c', 'read 0 512', nbd_uri)

- self.assertReadOk(qemu_io(*args))

+ self.assertReadOk(qemu_io(*args).stdout)

result = self.remove_export('exp', mode)

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

self.assertExportNotFound('exp')

- self.assertConnectFailed(qemu_io(*args))

+ self.assertConnectFailed(qemu_io(*args, check=False).stdout)

def test_connect_after_remove_default(self):

self.do_test_connect_after_remove()

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/245

+++ b/tests/qemu-iotests/245

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

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

#

+import copy

+import json

import os

import re

+from subprocess import CalledProcessError

+

import iotests

-import copy

-import json

from iotests import qemu_img, qemu_io

hd_path = [

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

# Reopen an image several times changing some of its options

def test_reopen(self):

- # Check whether the filesystem supports O_DIRECT

- if 'O_DIRECT' in qemu_io('-f', 'raw', '-t', 'none', '-c', 'quit', hd_path[0]):

- supports_direct = False

- else:

+ try:

+ qemu_io('-f', 'raw', '-t', 'none', '-c', 'quit', hd_path[0])

supports_direct = True

+ except CalledProcessError as exc:

+ if 'O_DIRECT' in exc.stdout:

+ supports_direct = False

+ else:

+ raise

# Open the hd1 image passing all backing options

opts = hd_opts(1)

diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/iotests.py

+++ b/tests/qemu-iotests/iotests.py

@@ -XXX,XX +XXX,XX @@ def qemu_io_wrap_args(args: Sequence[str]) -> List[str]:

def qemu_io_popen(*args):

return qemu_tool_popen(qemu_io_wrap_args(args))

-def qemu_io(*args):

- '''Run qemu-io and return the stdout data'''

- return qemu_tool_pipe_and_status('qemu-io', qemu_io_wrap_args(args))[0]

+def qemu_io(*args: str, check: bool = True, combine_stdio: bool = True

+ ) -> 'subprocess.CompletedProcess[str]':

+ """

+ Run QEMU_IO_PROG and return the status code and console output.

+

+ This function always prepends either QEMU_IO_OPTIONS or

+ QEMU_IO_OPTIONS_NO_FMT.

+ """

+ return qemu_tool(*qemu_io_wrap_args(args),

+ check=check, combine_stdio=combine_stdio)

def qemu_io_pipe_and_status(*args):

return qemu_tool_pipe_and_status('qemu-io', qemu_io_wrap_args(args))

-def qemu_io_log(*args):

- result = qemu_io(*args)

- log(result, filters=[filter_testfiles, filter_qemu_io])

+def qemu_io_log(*args: str) -> 'subprocess.CompletedProcess[str]':

+ result = qemu_io(*args, check=False)

+ log(result.stdout, filters=[filter_testfiles, filter_qemu_io])

return result

def qemu_io_silent(*args):

diff --git a/tests/qemu-iotests/tests/migration-permissions b/tests/qemu-iotests/tests/migration-permissions

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/tests/migration-permissions

+++ b/tests/qemu-iotests/tests/migration-permissions

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

def test_post_migration_permissions(self):

# Try to access the image R/W, which should fail because virtio-blk

# has not been configured with share-rw=on

- log = qemu_io('-f', imgfmt, '-c', 'quit', test_img)

+ log = qemu_io('-f', imgfmt, '-c', 'quit', test_img, check=False).stdout

if not log.strip():

print('ERROR (pre-migration): qemu-io should not be able to '

'access this image, but it reported no error')

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

# Try the same qemu-io access again, verifying that the WRITE

# permission remains unshared

- log = qemu_io('-f', imgfmt, '-c', 'quit', test_img)

+ log = qemu_io('-f', imgfmt, '-c', 'quit', test_img, check=False).stdout

if not log.strip():

print('ERROR (post-migration): qemu-io should not be able to '

'access this image, but it reported no error')

--

2.35.1

From: John Snow <jsnow@redhat.com>

Modify this test to use assertRaises for its negative testing of

qemu_io. If the exception raised does not match the one we tell it to

expect, we get *that* exception unhandled. If we get no exception, we

get a unittest assertion failure and the provided emsg printed to

screen.

If we get the CalledProcessError exception but the output is not what we

expect, we re-raise the original CalledProcessError.

Tidy.