From 88e1f9274522929fc5f9b553df9e68e135d1ef2e Mon Sep 17 00:00:00 2001 From: Eric Blake Date: Mon, 17 Jul 2017 09:26:20 -0500 Subject: iotests: Remove a few tests from 'quick' group A run of './check -qcow2 -g quick' on my machine produced only two tests that took longer than 5 seconds; 178 took 18, and 189 took 7. Remove them from the quick group. Signed-off-by: Eric Blake Reviewed-by: John Snow Reviewed-by: Jeff Cody Reviewed-by: Stefan Hajnoczi Signed-off-by: Kevin Wolf --- tests/qemu-iotests/group | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'tests') diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group index 0961f8c..287f0ea 100644 --- a/tests/qemu-iotests/group +++ b/tests/qemu-iotests/group @@ -175,7 +175,7 @@ 175 auto quick 176 rw auto backing 177 rw auto quick -178 auto quick +178 auto 179 rw auto quick 181 rw auto migration 182 rw auto quick @@ -183,4 +183,4 @@ 185 rw auto 186 rw auto 188 rw auto quick -189 rw auto quick +189 rw auto -- cgit v1.1 From d3c8c67469ee70fcae116d5abc277a7ebc8a19fd Mon Sep 17 00:00:00 2001 From: Kevin Wolf Date: Tue, 18 Jul 2017 17:24:05 +0200 Subject: block: Skip implicit nodes in query-block/blockstats Commits 0db832f and 6cdbceb introduced the automatic insertion of filter nodes above the top layer of mirror and commit block jobs. The assumption made there was that since libvirt doesn't do node-level management of the block layer yet, it shouldn't be affected by added nodes. This is true as far as commands issued by libvirt are concerned. It only uses BlockBackend names to address nodes, so any operations it performs still operate on the root of the tree as intended. However, the assumption breaks down when you consider query commands, which return data for the wrong node now. These commands also return information on some child nodes (bs->file and/or bs->backing), which libvirt does make use of, and which refer to the wrong nodes, too. One of the consequences is that oVirt gets wrong information about the image size and stops the VM in response as long as a mirror or commit job is running: https://bugzilla.redhat.com/show_bug.cgi?id=1470634 This patch fixes the problem by hiding the implicit nodes created automatically by the mirror and commit block jobs in the output of query-block and BlockBackend-based query-blockstats as long as the user doesn't indicate that they are aware of those nodes by providing a node name for them in the QMP command to start the block job. The node-based commands query-named-block-nodes and query-blockstats with query-nodes=true still show all nodes, including implicit ones. This ensures that users that are capable of node-level management can still access the full information; users that only know BlockBackends won't use these commands. Cc: qemu-stable@nongnu.org Signed-off-by: Kevin Wolf Reviewed-by: Peter Krempa Reviewed-by: Max Reitz Tested-by: Eric Blake --- tests/qemu-iotests/040 | 30 +++++++++++++++++++++++++++++- tests/qemu-iotests/040.out | 4 ++-- tests/qemu-iotests/041 | 38 +++++++++++++++++++++++++++++++++++++- tests/qemu-iotests/041.out | 4 ++-- 4 files changed, 70 insertions(+), 6 deletions(-) (limited to 'tests') diff --git a/tests/qemu-iotests/040 b/tests/qemu-iotests/040 index 9d381d9..95b7510 100755 --- a/tests/qemu-iotests/040 +++ b/tests/qemu-iotests/040 @@ -81,7 +81,7 @@ class TestSingleDrive(ImageCommitTestCase): qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % mid_img, 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) - self.vm = iotests.VM().add_drive(test_img, interface="none") + 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-pci") self.vm.add_device("scsi-hd,id=scsi0,drive=drive0") self.vm.launch() @@ -163,6 +163,34 @@ class TestSingleDrive(ImageCommitTestCase): self.assert_no_active_block_jobs() + # Tests that the insertion of the commit_top filter node doesn't make a + # difference to query-blockstat + def test_implicit_node(self): + if self.image_len == 0: + return + + self.assert_no_active_block_jobs() + result = self.vm.qmp('block-commit', device='drive0', top=mid_img, + base=backing_img, speed=(self.image_len / 4)) + self.assert_qmp(result, 'return', {}) + + result = self.vm.qmp('query-block') + self.assert_qmp(result, 'return[0]/inserted/file', test_img) + self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt) + self.assert_qmp(result, 'return[0]/inserted/backing_file', mid_img) + self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 2) + self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img) + self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', mid_img) + self.assert_qmp(result, 'return[0]/inserted/image/backing-image/backing-image/filename', backing_img) + + result = self.vm.qmp('query-blockstats') + self.assert_qmp(result, 'return[0]/node-name', 'top') + self.assert_qmp(result, 'return[0]/backing/node-name', 'mid') + self.assert_qmp(result, 'return[0]/backing/backing/node-name', 'base') + + self.cancel_and_wait() + self.assert_no_active_block_jobs() + class TestRelativePaths(ImageCommitTestCase): image_len = 1 * 1024 * 1024 test_len = 1 * 1024 * 256 diff --git a/tests/qemu-iotests/040.out b/tests/qemu-iotests/040.out index 6d9bee1..e20a75c 100644 --- a/tests/qemu-iotests/040.out +++ b/tests/qemu-iotests/040.out @@ -1,5 +1,5 @@ -........................... +............................. ---------------------------------------------------------------------- -Ran 27 tests +Ran 29 tests OK diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041 index 2f54986..60f09cc 100755 --- a/tests/qemu-iotests/041 +++ b/tests/qemu-iotests/041 @@ -42,7 +42,7 @@ class TestSingleDrive(iotests.QMPTestCase): def setUp(self): iotests.create_image(backing_img, self.image_len) qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img) - self.vm = iotests.VM().add_drive(test_img) + self.vm = iotests.VM().add_drive(test_img, "node-name=top,backing.node-name=base") if iotests.qemu_default_machine == 'pc': self.vm.add_drive(None, 'media=cdrom', 'ide') self.vm.launch() @@ -169,6 +169,42 @@ class TestSingleDrive(iotests.QMPTestCase): self.assertTrue(iotests.compare_images(test_img, target_img), 'target image does not match source after mirroring') + # Tests that the insertion of the mirror_top filter node doesn't make a + # difference to query-block + def test_implicit_node(self): + self.assert_no_active_block_jobs() + + result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full', + target=self.qmp_target) + self.assert_qmp(result, 'return', {}) + + result = self.vm.qmp('query-block') + self.assert_qmp(result, 'return[0]/inserted/file', test_img) + self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt) + self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img) + self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1) + self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img) + self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img) + + result = self.vm.qmp('query-blockstats') + self.assert_qmp(result, 'return[0]/node-name', 'top') + self.assert_qmp(result, 'return[0]/backing/node-name', 'base') + + self.cancel_and_wait(force=True) + result = self.vm.qmp('query-block') + self.assert_qmp(result, 'return[0]/inserted/file', test_img) + self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt) + self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img) + self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1) + self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img) + self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img) + + result = self.vm.qmp('query-blockstats') + self.assert_qmp(result, 'return[0]/node-name', 'top') + self.assert_qmp(result, 'return[0]/backing/node-name', 'base') + + self.vm.shutdown() + def test_medium_not_found(self): if iotests.qemu_default_machine != 'pc': return diff --git a/tests/qemu-iotests/041.out b/tests/qemu-iotests/041.out index e30fd3b..c28b392 100644 --- a/tests/qemu-iotests/041.out +++ b/tests/qemu-iotests/041.out @@ -1,5 +1,5 @@ -............................................................................... +..................................................................................... ---------------------------------------------------------------------- -Ran 79 tests +Ran 85 tests OK -- cgit v1.1 From 2c93c5cb43fd992038711f84ea34c9373273cda6 Mon Sep 17 00:00:00 2001 From: Kevin Wolf Date: Fri, 21 Jul 2017 16:41:21 +0200 Subject: qemu-iotests: Avoid unnecessary sleeps Test cases 030, 041 and 055 used to sleep for a second after calling block-job-pause to make sure that the block job had time to actually get into paused state. We can instead poll its status and use that one second only as a timeout. The tests also slept a second for checking that the block jobs don't make progress while being paused. Half a second is more than enough for this. These changes reduce the total time for the three tests by 25 seconds on my laptop (from 155 seconds to 130). Signed-off-by: Kevin Wolf Reviewed-by: Eric Blake --- tests/qemu-iotests/030 | 7 ++++--- tests/qemu-iotests/041 | 12 ++++-------- tests/qemu-iotests/055 | 15 +++++++++------ tests/qemu-iotests/iotests.py | 27 +++++++++++++++++++++++++++ 4 files changed, 44 insertions(+), 17 deletions(-) (limited to 'tests') diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030 index feee861..d745cb4 100755 --- a/tests/qemu-iotests/030 +++ b/tests/qemu-iotests/030 @@ -89,18 +89,19 @@ class TestSingleDrive(iotests.QMPTestCase): result = self.vm.qmp('block-job-pause', device='drive0') self.assert_qmp(result, 'return', {}) - time.sleep(1) + self.vm.resume_drive('drive0') + self.pause_job('drive0') + result = self.vm.qmp('query-block-jobs') offset = self.dictpath(result, 'return[0]/offset') - time.sleep(1) + time.sleep(0.5) result = self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) result = self.vm.qmp('block-job-resume', device='drive0') self.assert_qmp(result, 'return', {}) - self.vm.resume_drive('drive0') self.wait_until_completed() self.assert_no_active_block_jobs() diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041 index 60f09cc..4cda540 100755 --- a/tests/qemu-iotests/041 +++ b/tests/qemu-iotests/041 @@ -103,14 +103,12 @@ class TestSingleDrive(iotests.QMPTestCase): target=self.qmp_target) self.assert_qmp(result, 'return', {}) - result = self.vm.qmp('block-job-pause', device='drive0') - self.assert_qmp(result, 'return', {}) + self.pause_job('drive0') - time.sleep(1) result = self.vm.qmp('query-block-jobs') offset = self.dictpath(result, 'return[0]/offset') - time.sleep(1) + time.sleep(0.5) result = self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) @@ -896,14 +894,12 @@ class TestRepairQuorum(iotests.QMPTestCase): target=quorum_repair_img, format=iotests.imgfmt) self.assert_qmp(result, 'return', {}) - result = self.vm.qmp('block-job-pause', device='job0') - self.assert_qmp(result, 'return', {}) + self.pause_job('job0') - time.sleep(1) result = self.vm.qmp('query-block-jobs') offset = self.dictpath(result, 'return[0]/offset') - time.sleep(1) + time.sleep(0.5) result = self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055 index ba4da65..e1206ca 100755 --- a/tests/qemu-iotests/055 +++ b/tests/qemu-iotests/055 @@ -89,11 +89,12 @@ class TestSingleDrive(iotests.QMPTestCase): self.assert_qmp(result, 'return', {}) self.vm.resume_drive('drive0') - time.sleep(1) + self.pause_job('drive0') + result = self.vm.qmp('query-block-jobs') offset = self.dictpath(result, 'return[0]/offset') - time.sleep(1) + time.sleep(0.5) result = self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) @@ -302,11 +303,12 @@ class TestSingleTransaction(iotests.QMPTestCase): self.assert_qmp(result, 'return', {}) self.vm.resume_drive('drive0') - time.sleep(1) + self.pause_job('drive0') + result = self.vm.qmp('query-block-jobs') offset = self.dictpath(result, 'return[0]/offset') - time.sleep(1) + time.sleep(0.5) result = self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) @@ -529,11 +531,12 @@ class TestDriveCompression(iotests.QMPTestCase): self.assert_qmp(result, 'return', {}) self.vm.resume_drive('drive0') - time.sleep(1) + self.pause_job('drive0') + result = self.vm.qmp('query-block-jobs') offset = self.dictpath(result, 'return[0]/offset') - time.sleep(1) + time.sleep(0.5) result = self.vm.qmp('query-block-jobs') self.assert_qmp(result, 'return[0]/offset', offset) diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py index abcf3c1..22439c4 100644 --- a/tests/qemu-iotests/iotests.py +++ b/tests/qemu-iotests/iotests.py @@ -27,6 +27,7 @@ sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'scripts')) import qtest import struct import json +import signal # This will not work if arguments contain spaces but is necessary if we @@ -137,6 +138,20 @@ def log(msg, filters=[]): msg = flt(msg) print msg +class Timeout: + def __init__(self, seconds, errmsg = "Timeout"): + self.seconds = seconds + self.errmsg = errmsg + def __enter__(self): + signal.signal(signal.SIGALRM, self.timeout) + signal.setitimer(signal.ITIMER_REAL, self.seconds) + return self + def __exit__(self, type, value, traceback): + signal.setitimer(signal.ITIMER_REAL, 0) + return False + def timeout(self, signum, frame): + raise Exception(self.errmsg) + class VM(qtest.QEMUQtestMachine): '''A QEMU VM''' @@ -346,6 +361,18 @@ class QMPTestCase(unittest.TestCase): event = self.wait_until_completed(drive=drive) self.assert_qmp(event, 'data/type', 'mirror') + def pause_job(self, job_id='job0'): + result = self.vm.qmp('block-job-pause', device=job_id) + self.assert_qmp(result, 'return', {}) + + with Timeout(1, "Timeout waiting for job to pause"): + while True: + result = self.vm.qmp('query-block-jobs') + for job in result['return']: + if job['device'] == job_id and job['paused'] == True and job['busy'] == False: + return job + + def notrun(reason): '''Skip this test suite''' # Each test in qemu-iotests has a number ("seq") -- cgit v1.1