xref: /openbmc/qemu/tests/qemu-iotests/041 (revision c351afd6f3fe068ff370d872fae4ab096bba0e92)
1903cb1bfSPhilippe Mathieu-Daudé#!/usr/bin/env python3
244c7ca5eSPaolo Bonzini#
344c7ca5eSPaolo Bonzini# Tests for image mirroring.
444c7ca5eSPaolo Bonzini#
544c7ca5eSPaolo Bonzini# Copyright (C) 2012 Red Hat, Inc.
644c7ca5eSPaolo Bonzini#
744c7ca5eSPaolo Bonzini# This program is free software; you can redistribute it and/or modify
844c7ca5eSPaolo Bonzini# it under the terms of the GNU General Public License as published by
944c7ca5eSPaolo Bonzini# the Free Software Foundation; either version 2 of the License, or
1044c7ca5eSPaolo Bonzini# (at your option) any later version.
1144c7ca5eSPaolo Bonzini#
1244c7ca5eSPaolo Bonzini# This program is distributed in the hope that it will be useful,
1344c7ca5eSPaolo Bonzini# but WITHOUT ANY WARRANTY; without even the implied warranty of
1444c7ca5eSPaolo Bonzini# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1544c7ca5eSPaolo Bonzini# GNU General Public License for more details.
1644c7ca5eSPaolo Bonzini#
1744c7ca5eSPaolo Bonzini# You should have received a copy of the GNU General Public License
1844c7ca5eSPaolo Bonzini# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1944c7ca5eSPaolo Bonzini#
2044c7ca5eSPaolo Bonzini
2144c7ca5eSPaolo Bonziniimport time
2244c7ca5eSPaolo Bonziniimport os
2344c7ca5eSPaolo Bonziniimport iotests
2444c7ca5eSPaolo Bonzinifrom iotests import qemu_img, qemu_io
2544c7ca5eSPaolo Bonzini
2644c7ca5eSPaolo Bonzinibacking_img = os.path.join(iotests.test_dir, 'backing.img')
2744c7ca5eSPaolo Bonzinitarget_backing_img = os.path.join(iotests.test_dir, 'target-backing.img')
2844c7ca5eSPaolo Bonzinitest_img = os.path.join(iotests.test_dir, 'test.img')
2944c7ca5eSPaolo Bonzinitarget_img = os.path.join(iotests.test_dir, 'target.img')
3044c7ca5eSPaolo Bonzini
31d88964aeSBenoît Canetquorum_img1 = os.path.join(iotests.test_dir, 'quorum1.img')
32d88964aeSBenoît Canetquorum_img2 = os.path.join(iotests.test_dir, 'quorum2.img')
33d88964aeSBenoît Canetquorum_img3 = os.path.join(iotests.test_dir, 'quorum3.img')
34d88964aeSBenoît Canetquorum_repair_img = os.path.join(iotests.test_dir, 'quorum_repair.img')
35d88964aeSBenoît Canetquorum_snapshot_file = os.path.join(iotests.test_dir, 'quorum_snapshot.img')
36d88964aeSBenoît Canet
37866323f3SFam Zhengclass TestSingleDrive(iotests.QMPTestCase):
3844c7ca5eSPaolo Bonzini    image_len = 1 * 1024 * 1024 # MB
3994ca2c73SFam Zheng    qmp_cmd = 'drive-mirror'
4094ca2c73SFam Zheng    qmp_target = target_img
4144c7ca5eSPaolo Bonzini
4244c7ca5eSPaolo Bonzini    def setUp(self):
433b9f27d2SFam Zheng        iotests.create_image(backing_img, self.image_len)
4444c7ca5eSPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
45d3c8c674SKevin Wolf        self.vm = iotests.VM().add_drive(test_img, "node-name=top,backing.node-name=base")
460ed82f7aSMax Reitz        if iotests.qemu_default_machine == 'pc':
470ed82f7aSMax Reitz            self.vm.add_drive(None, 'media=cdrom', 'ide')
4844c7ca5eSPaolo Bonzini        self.vm.launch()
4944c7ca5eSPaolo Bonzini
5044c7ca5eSPaolo Bonzini    def tearDown(self):
5144c7ca5eSPaolo Bonzini        self.vm.shutdown()
5244c7ca5eSPaolo Bonzini        os.remove(test_img)
5344c7ca5eSPaolo Bonzini        os.remove(backing_img)
5444c7ca5eSPaolo Bonzini        try:
5544c7ca5eSPaolo Bonzini            os.remove(target_img)
5644c7ca5eSPaolo Bonzini        except OSError:
5744c7ca5eSPaolo Bonzini            pass
5844c7ca5eSPaolo Bonzini
5944c7ca5eSPaolo Bonzini    def test_complete(self):
60ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
6144c7ca5eSPaolo Bonzini
6294ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
6394ca2c73SFam Zheng                             target=self.qmp_target)
6444c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
6544c7ca5eSPaolo Bonzini
6644c7ca5eSPaolo Bonzini        self.complete_and_wait()
6744c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block')
6844c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/inserted/file', target_img)
6944c7ca5eSPaolo Bonzini        self.vm.shutdown()
703a3918c3SStefan Hajnoczi        self.assertTrue(iotests.compare_images(test_img, target_img),
7144c7ca5eSPaolo Bonzini                        'target image does not match source after mirroring')
7244c7ca5eSPaolo Bonzini
7344c7ca5eSPaolo Bonzini    def test_cancel(self):
74ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
7544c7ca5eSPaolo Bonzini
7694ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
7794ca2c73SFam Zheng                             target=self.qmp_target)
7844c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
7944c7ca5eSPaolo Bonzini
802575fe16SStefan Hajnoczi        self.cancel_and_wait(force=True)
8144c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block')
8244c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/inserted/file', test_img)
8344c7ca5eSPaolo Bonzini
8444c7ca5eSPaolo Bonzini    def test_cancel_after_ready(self):
85ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
8644c7ca5eSPaolo Bonzini
8794ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
8894ca2c73SFam Zheng                             target=self.qmp_target)
8944c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
9044c7ca5eSPaolo Bonzini
912575fe16SStefan Hajnoczi        self.wait_ready_and_cancel()
9244c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block')
9344c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/inserted/file', test_img)
9444c7ca5eSPaolo Bonzini        self.vm.shutdown()
953a3918c3SStefan Hajnoczi        self.assertTrue(iotests.compare_images(test_img, target_img),
9644c7ca5eSPaolo Bonzini                        'target image does not match source after mirroring')
9744c7ca5eSPaolo Bonzini
9844c7ca5eSPaolo Bonzini    def test_pause(self):
99ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
10044c7ca5eSPaolo Bonzini
10194ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
10294ca2c73SFam Zheng                             target=self.qmp_target)
10344c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
10444c7ca5eSPaolo Bonzini
1052c93c5cbSKevin Wolf        self.pause_job('drive0')
10644c7ca5eSPaolo Bonzini
10744c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block-jobs')
10844c7ca5eSPaolo Bonzini        offset = self.dictpath(result, 'return[0]/offset')
10944c7ca5eSPaolo Bonzini
1102c93c5cbSKevin Wolf        time.sleep(0.5)
11144c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block-jobs')
11244c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/offset', offset)
11344c7ca5eSPaolo Bonzini
11444c7ca5eSPaolo Bonzini        result = self.vm.qmp('block-job-resume', device='drive0')
11544c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
11644c7ca5eSPaolo Bonzini
11744c7ca5eSPaolo Bonzini        self.complete_and_wait()
11844c7ca5eSPaolo Bonzini        self.vm.shutdown()
1193a3918c3SStefan Hajnoczi        self.assertTrue(iotests.compare_images(test_img, target_img),
12044c7ca5eSPaolo Bonzini                        'target image does not match source after mirroring')
12144c7ca5eSPaolo Bonzini
12208e4ed6cSPaolo Bonzini    def test_small_buffer(self):
123ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
12408e4ed6cSPaolo Bonzini
12508e4ed6cSPaolo Bonzini        # A small buffer is rounded up automatically
12694ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
12794ca2c73SFam Zheng                             buf_size=4096, target=self.qmp_target)
12808e4ed6cSPaolo Bonzini        self.assert_qmp(result, 'return', {})
12908e4ed6cSPaolo Bonzini
13008e4ed6cSPaolo Bonzini        self.complete_and_wait()
13108e4ed6cSPaolo Bonzini        result = self.vm.qmp('query-block')
13208e4ed6cSPaolo Bonzini        self.assert_qmp(result, 'return[0]/inserted/file', target_img)
13308e4ed6cSPaolo Bonzini        self.vm.shutdown()
1343a3918c3SStefan Hajnoczi        self.assertTrue(iotests.compare_images(test_img, target_img),
13508e4ed6cSPaolo Bonzini                        'target image does not match source after mirroring')
13608e4ed6cSPaolo Bonzini
13708e4ed6cSPaolo Bonzini    def test_small_buffer2(self):
138ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
13908e4ed6cSPaolo Bonzini
14008e4ed6cSPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,size=%d'
1413b9f27d2SFam Zheng                        % (self.image_len, self.image_len), target_img)
14294ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
14394ca2c73SFam Zheng                             buf_size=65536, mode='existing', target=self.qmp_target)
14408e4ed6cSPaolo Bonzini        self.assert_qmp(result, 'return', {})
14508e4ed6cSPaolo Bonzini
14608e4ed6cSPaolo Bonzini        self.complete_and_wait()
14708e4ed6cSPaolo Bonzini        result = self.vm.qmp('query-block')
14808e4ed6cSPaolo Bonzini        self.assert_qmp(result, 'return[0]/inserted/file', target_img)
14908e4ed6cSPaolo Bonzini        self.vm.shutdown()
1503a3918c3SStefan Hajnoczi        self.assertTrue(iotests.compare_images(test_img, target_img),
15108e4ed6cSPaolo Bonzini                        'target image does not match source after mirroring')
15208e4ed6cSPaolo Bonzini
15344c7ca5eSPaolo Bonzini    def test_large_cluster(self):
154ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
15544c7ca5eSPaolo Bonzini
15644c7ca5eSPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s'
1573b9f27d2SFam Zheng                        % (self.image_len, backing_img), target_img)
15894ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
15994ca2c73SFam Zheng                             mode='existing', target=self.qmp_target)
16044c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
16144c7ca5eSPaolo Bonzini
16244c7ca5eSPaolo Bonzini        self.complete_and_wait()
16344c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block')
16444c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/inserted/file', target_img)
16544c7ca5eSPaolo Bonzini        self.vm.shutdown()
1663a3918c3SStefan Hajnoczi        self.assertTrue(iotests.compare_images(test_img, target_img),
16744c7ca5eSPaolo Bonzini                        'target image does not match source after mirroring')
16844c7ca5eSPaolo Bonzini
169d3c8c674SKevin Wolf    # Tests that the insertion of the mirror_top filter node doesn't make a
170d3c8c674SKevin Wolf    # difference to query-block
171d3c8c674SKevin Wolf    def test_implicit_node(self):
172d3c8c674SKevin Wolf        self.assert_no_active_block_jobs()
173d3c8c674SKevin Wolf
174d3c8c674SKevin Wolf        result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
175d3c8c674SKevin Wolf                             target=self.qmp_target)
176d3c8c674SKevin Wolf        self.assert_qmp(result, 'return', {})
177d3c8c674SKevin Wolf
178d3c8c674SKevin Wolf        result = self.vm.qmp('query-block')
179d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/file', test_img)
180d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt)
181d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img)
182d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1)
183d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img)
184d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img)
185d3c8c674SKevin Wolf
186d3c8c674SKevin Wolf        result = self.vm.qmp('query-blockstats')
187d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/node-name', 'top')
188d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/backing/node-name', 'base')
189d3c8c674SKevin Wolf
190d3c8c674SKevin Wolf        self.cancel_and_wait(force=True)
191d3c8c674SKevin Wolf        result = self.vm.qmp('query-block')
192d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/file', test_img)
193d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt)
194d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img)
195d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1)
196d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img)
197d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img)
198d3c8c674SKevin Wolf
199d3c8c674SKevin Wolf        result = self.vm.qmp('query-blockstats')
200d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/node-name', 'top')
201d3c8c674SKevin Wolf        self.assert_qmp(result, 'return[0]/backing/node-name', 'base')
202d3c8c674SKevin Wolf
20344c7ca5eSPaolo Bonzini    def test_medium_not_found(self):
204d8683155SBo Tu        if iotests.qemu_default_machine != 'pc':
205d8683155SBo Tu            return
206d8683155SBo Tu
20794ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='ide1-cd0', sync='full',
20894ca2c73SFam Zheng                             target=self.qmp_target)
2090524e93aSKevin Wolf        self.assert_qmp(result, 'error/class', 'GenericError')
21044c7ca5eSPaolo Bonzini
21144c7ca5eSPaolo Bonzini    def test_image_not_found(self):
21294ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
21394ca2c73SFam Zheng                             mode='existing', target=self.qmp_target)
21444c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'error/class', 'GenericError')
21544c7ca5eSPaolo Bonzini
21644c7ca5eSPaolo Bonzini    def test_device_not_found(self):
21794ca2c73SFam Zheng        result = self.vm.qmp(self.qmp_cmd, device='nonexistent', sync='full',
21894ca2c73SFam Zheng                             target=self.qmp_target)
2190524e93aSKevin Wolf        self.assert_qmp(result, 'error/class', 'GenericError')
22094ca2c73SFam Zheng
22194ca2c73SFam Zhengclass TestSingleBlockdev(TestSingleDrive):
22294ca2c73SFam Zheng    qmp_cmd = 'blockdev-mirror'
22394ca2c73SFam Zheng    qmp_target = 'node1'
22494ca2c73SFam Zheng
22594ca2c73SFam Zheng    def setUp(self):
22694ca2c73SFam Zheng        TestSingleDrive.setUp(self)
22794ca2c73SFam Zheng        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img)
2280153d2f5SKevin Wolf        args = {'driver': iotests.imgfmt,
22994ca2c73SFam Zheng                'node-name': self.qmp_target,
2300153d2f5SKevin Wolf                'file': { 'filename': target_img, 'driver': 'file' } }
23194ca2c73SFam Zheng        result = self.vm.qmp("blockdev-add", **args)
23294ca2c73SFam Zheng        self.assert_qmp(result, 'return', {})
23394ca2c73SFam Zheng
23486fae10cSKevin Wolf    def test_mirror_to_self(self):
23586fae10cSKevin Wolf        result = self.vm.qmp(self.qmp_cmd, job_id='job0',
23686fae10cSKevin Wolf                             device=self.qmp_target, sync='full',
23786fae10cSKevin Wolf                             target=self.qmp_target)
23886fae10cSKevin Wolf        self.assert_qmp(result, 'error/class', 'GenericError')
23986fae10cSKevin Wolf
24094ca2c73SFam Zheng    test_large_cluster = None
24194ca2c73SFam Zheng    test_image_not_found = None
24294ca2c73SFam Zheng    test_small_buffer2 = None
24394ca2c73SFam Zheng
2443b9f27d2SFam Zhengclass TestSingleDriveZeroLength(TestSingleDrive):
2453b9f27d2SFam Zheng    image_len = 0
2463b9f27d2SFam Zheng    test_small_buffer2 = None
2473b9f27d2SFam Zheng    test_large_cluster = None
2483b9f27d2SFam Zheng
24994ca2c73SFam Zhengclass TestSingleBlockdevZeroLength(TestSingleBlockdev):
25094ca2c73SFam Zheng    image_len = 0
25194ca2c73SFam Zheng
2525a0f6fd5SKevin Wolfclass TestSingleDriveUnalignedLength(TestSingleDrive):
2535a0f6fd5SKevin Wolf    image_len = 1025 * 1024
2545a0f6fd5SKevin Wolf    test_small_buffer2 = None
2555a0f6fd5SKevin Wolf    test_large_cluster = None
2565a0f6fd5SKevin Wolf
25794ca2c73SFam Zhengclass TestSingleBlockdevUnalignedLength(TestSingleBlockdev):
25894ca2c73SFam Zheng    image_len = 1025 * 1024
25994ca2c73SFam Zheng
260866323f3SFam Zhengclass TestMirrorNoBacking(iotests.QMPTestCase):
26144c7ca5eSPaolo Bonzini    image_len = 2 * 1024 * 1024 # MB
26244c7ca5eSPaolo Bonzini
26344c7ca5eSPaolo Bonzini    def setUp(self):
2642499a096SStefan Hajnoczi        iotests.create_image(backing_img, TestMirrorNoBacking.image_len)
26544c7ca5eSPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
26644c7ca5eSPaolo Bonzini        self.vm = iotests.VM().add_drive(test_img)
26744c7ca5eSPaolo Bonzini        self.vm.launch()
26844c7ca5eSPaolo Bonzini
26944c7ca5eSPaolo Bonzini    def tearDown(self):
27044c7ca5eSPaolo Bonzini        self.vm.shutdown()
27144c7ca5eSPaolo Bonzini        os.remove(test_img)
27244c7ca5eSPaolo Bonzini        os.remove(backing_img)
273866323f3SFam Zheng        try:
27444c7ca5eSPaolo Bonzini            os.remove(target_backing_img)
275866323f3SFam Zheng        except:
276866323f3SFam Zheng            pass
27744c7ca5eSPaolo Bonzini        os.remove(target_img)
27844c7ca5eSPaolo Bonzini
27944c7ca5eSPaolo Bonzini    def test_complete(self):
280ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
28144c7ca5eSPaolo Bonzini
28244c7ca5eSPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img)
28344c7ca5eSPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
28444c7ca5eSPaolo Bonzini                             mode='existing', target=target_img)
28544c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
28644c7ca5eSPaolo Bonzini
28744c7ca5eSPaolo Bonzini        self.complete_and_wait()
28844c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block')
28944c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/inserted/file', target_img)
29044c7ca5eSPaolo Bonzini        self.vm.shutdown()
291866323f3SFam Zheng        self.assertTrue(iotests.compare_images(test_img, target_img),
29244c7ca5eSPaolo Bonzini                        'target image does not match source after mirroring')
29344c7ca5eSPaolo Bonzini
29444c7ca5eSPaolo Bonzini    def test_cancel(self):
295ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
29644c7ca5eSPaolo Bonzini
29744c7ca5eSPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, target_img)
29844c7ca5eSPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
29944c7ca5eSPaolo Bonzini                             mode='existing', target=target_img)
30044c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
30144c7ca5eSPaolo Bonzini
3022575fe16SStefan Hajnoczi        self.wait_ready_and_cancel()
30344c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block')
30444c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/inserted/file', test_img)
30544c7ca5eSPaolo Bonzini        self.vm.shutdown()
306866323f3SFam Zheng        self.assertTrue(iotests.compare_images(test_img, target_img),
30744c7ca5eSPaolo Bonzini                        'target image does not match source after mirroring')
30844c7ca5eSPaolo Bonzini
309b812f671SPaolo Bonzini    def test_large_cluster(self):
310ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
311b812f671SPaolo Bonzini
312b812f671SPaolo Bonzini        # qemu-img create fails if the image is not there
313b812f671SPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-o', 'size=%d'
314b812f671SPaolo Bonzini                        %(TestMirrorNoBacking.image_len), target_backing_img)
315b812f671SPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s'
316b812f671SPaolo Bonzini                        % (TestMirrorNoBacking.image_len, target_backing_img), target_img)
317b812f671SPaolo Bonzini
318b812f671SPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
319b812f671SPaolo Bonzini                             mode='existing', target=target_img)
320b812f671SPaolo Bonzini        self.assert_qmp(result, 'return', {})
321b812f671SPaolo Bonzini
322b812f671SPaolo Bonzini        self.complete_and_wait()
323b812f671SPaolo Bonzini        result = self.vm.qmp('query-block')
324b812f671SPaolo Bonzini        self.assert_qmp(result, 'return[0]/inserted/file', target_img)
325b812f671SPaolo Bonzini        self.vm.shutdown()
326866323f3SFam Zheng        self.assertTrue(iotests.compare_images(test_img, target_img),
327b812f671SPaolo Bonzini                        'target image does not match source after mirroring')
328b812f671SPaolo Bonzini
329866323f3SFam Zhengclass TestMirrorResized(iotests.QMPTestCase):
330a04eca10SVishvananda Ishaya    backing_len = 1 * 1024 * 1024 # MB
331a04eca10SVishvananda Ishaya    image_len = 2 * 1024 * 1024 # MB
332a04eca10SVishvananda Ishaya
333a04eca10SVishvananda Ishaya    def setUp(self):
3342499a096SStefan Hajnoczi        iotests.create_image(backing_img, TestMirrorResized.backing_len)
335a04eca10SVishvananda Ishaya        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
336a04eca10SVishvananda Ishaya        qemu_img('resize', test_img, '2M')
337a04eca10SVishvananda Ishaya        self.vm = iotests.VM().add_drive(test_img)
338a04eca10SVishvananda Ishaya        self.vm.launch()
339a04eca10SVishvananda Ishaya
340a04eca10SVishvananda Ishaya    def tearDown(self):
341a04eca10SVishvananda Ishaya        self.vm.shutdown()
342a04eca10SVishvananda Ishaya        os.remove(test_img)
343a04eca10SVishvananda Ishaya        os.remove(backing_img)
344a04eca10SVishvananda Ishaya        try:
345a04eca10SVishvananda Ishaya            os.remove(target_img)
346a04eca10SVishvananda Ishaya        except OSError:
347a04eca10SVishvananda Ishaya            pass
348a04eca10SVishvananda Ishaya
349a04eca10SVishvananda Ishaya    def test_complete_top(self):
350ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
351a04eca10SVishvananda Ishaya
352a04eca10SVishvananda Ishaya        result = self.vm.qmp('drive-mirror', device='drive0', sync='top',
353a04eca10SVishvananda Ishaya                             target=target_img)
354a04eca10SVishvananda Ishaya        self.assert_qmp(result, 'return', {})
355a04eca10SVishvananda Ishaya
356a04eca10SVishvananda Ishaya        self.complete_and_wait()
357a04eca10SVishvananda Ishaya        result = self.vm.qmp('query-block')
358a04eca10SVishvananda Ishaya        self.assert_qmp(result, 'return[0]/inserted/file', target_img)
359a04eca10SVishvananda Ishaya        self.vm.shutdown()
3603a3918c3SStefan Hajnoczi        self.assertTrue(iotests.compare_images(test_img, target_img),
361a04eca10SVishvananda Ishaya                        'target image does not match source after mirroring')
362a04eca10SVishvananda Ishaya
363a04eca10SVishvananda Ishaya    def test_complete_full(self):
364ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
365a04eca10SVishvananda Ishaya
366a04eca10SVishvananda Ishaya        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
367a04eca10SVishvananda Ishaya                             target=target_img)
368a04eca10SVishvananda Ishaya        self.assert_qmp(result, 'return', {})
369a04eca10SVishvananda Ishaya
370a04eca10SVishvananda Ishaya        self.complete_and_wait()
371a04eca10SVishvananda Ishaya        result = self.vm.qmp('query-block')
372a04eca10SVishvananda Ishaya        self.assert_qmp(result, 'return[0]/inserted/file', target_img)
373a04eca10SVishvananda Ishaya        self.vm.shutdown()
3743a3918c3SStefan Hajnoczi        self.assertTrue(iotests.compare_images(test_img, target_img),
375a04eca10SVishvananda Ishaya                        'target image does not match source after mirroring')
376a04eca10SVishvananda Ishaya
377866323f3SFam Zhengclass TestReadErrors(iotests.QMPTestCase):
3789dfa9f59SPaolo Bonzini    image_len = 2 * 1024 * 1024 # MB
3799dfa9f59SPaolo Bonzini
3809dfa9f59SPaolo Bonzini    # this should be a multiple of twice the default granularity
3819dfa9f59SPaolo Bonzini    # so that we hit this offset first in state 1
3829dfa9f59SPaolo Bonzini    MIRROR_GRANULARITY = 1024 * 1024
3839dfa9f59SPaolo Bonzini
3849dfa9f59SPaolo Bonzini    def create_blkdebug_file(self, name, event, errno):
3859dfa9f59SPaolo Bonzini        file = open(name, 'w')
3869dfa9f59SPaolo Bonzini        file.write('''
3879dfa9f59SPaolo Bonzini[inject-error]
3889dfa9f59SPaolo Bonzinistate = "1"
3899dfa9f59SPaolo Bonzinievent = "%s"
3909dfa9f59SPaolo Bonzinierrno = "%d"
3919dfa9f59SPaolo Bonziniimmediately = "off"
3929dfa9f59SPaolo Bonzinionce = "on"
3939dfa9f59SPaolo Bonzinisector = "%d"
3949dfa9f59SPaolo Bonzini
3959dfa9f59SPaolo Bonzini[set-state]
3969dfa9f59SPaolo Bonzinistate = "1"
3979dfa9f59SPaolo Bonzinievent = "%s"
3989dfa9f59SPaolo Bonzininew_state = "2"
3999dfa9f59SPaolo Bonzini
4009dfa9f59SPaolo Bonzini[set-state]
4019dfa9f59SPaolo Bonzinistate = "2"
4029dfa9f59SPaolo Bonzinievent = "%s"
4039dfa9f59SPaolo Bonzininew_state = "1"
4049a3a9a63SMax Reitz''' % (event, errno, self.MIRROR_GRANULARITY // 512, event, event))
4059dfa9f59SPaolo Bonzini        file.close()
4069dfa9f59SPaolo Bonzini
4079dfa9f59SPaolo Bonzini    def setUp(self):
4089dfa9f59SPaolo Bonzini        self.blkdebug_file = backing_img + ".blkdebug"
4092499a096SStefan Hajnoczi        iotests.create_image(backing_img, TestReadErrors.image_len)
4109dfa9f59SPaolo Bonzini        self.create_blkdebug_file(self.blkdebug_file, "read_aio", 5)
4119dfa9f59SPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt,
4129dfa9f59SPaolo Bonzini                 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
4139dfa9f59SPaolo Bonzini                       % (self.blkdebug_file, backing_img),
4149dfa9f59SPaolo Bonzini                 test_img)
415b812f671SPaolo Bonzini        # Write something for tests that use sync='top'
416b812f671SPaolo Bonzini        qemu_io('-c', 'write %d 512' % (self.MIRROR_GRANULARITY + 65536),
417b812f671SPaolo Bonzini                        test_img)
4189dfa9f59SPaolo Bonzini        self.vm = iotests.VM().add_drive(test_img)
4199dfa9f59SPaolo Bonzini        self.vm.launch()
4209dfa9f59SPaolo Bonzini
4219dfa9f59SPaolo Bonzini    def tearDown(self):
4229dfa9f59SPaolo Bonzini        self.vm.shutdown()
4239dfa9f59SPaolo Bonzini        os.remove(test_img)
424db11d1eeSKevin Wolf        os.remove(target_img)
4259dfa9f59SPaolo Bonzini        os.remove(backing_img)
4269dfa9f59SPaolo Bonzini        os.remove(self.blkdebug_file)
4279dfa9f59SPaolo Bonzini
4289dfa9f59SPaolo Bonzini    def test_report_read(self):
429ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
4309dfa9f59SPaolo Bonzini
4319dfa9f59SPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
4329dfa9f59SPaolo Bonzini                             target=target_img)
4339dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return', {})
4349dfa9f59SPaolo Bonzini
4359dfa9f59SPaolo Bonzini        completed = False
4369dfa9f59SPaolo Bonzini        error = False
4379dfa9f59SPaolo Bonzini        while not completed:
4389dfa9f59SPaolo Bonzini            for event in self.vm.get_qmp_events(wait=True):
4399dfa9f59SPaolo Bonzini                if event['event'] == 'BLOCK_JOB_ERROR':
4409dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/device', 'drive0')
4419dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/operation', 'read')
4429dfa9f59SPaolo Bonzini                    error = True
4439dfa9f59SPaolo Bonzini                elif event['event'] == 'BLOCK_JOB_READY':
4449dfa9f59SPaolo Bonzini                    self.assertTrue(False, 'job completed unexpectedly')
4459dfa9f59SPaolo Bonzini                elif event['event'] == 'BLOCK_JOB_COMPLETED':
4469dfa9f59SPaolo Bonzini                    self.assertTrue(error, 'job completed unexpectedly')
4479dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/type', 'mirror')
4489dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/device', 'drive0')
4499dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/error', 'Input/output error')
4509dfa9f59SPaolo Bonzini                    completed = True
4511dac83f1SKevin Wolf                elif event['event'] == 'JOB_STATUS_CHANGE':
4521dac83f1SKevin Wolf                    self.assert_qmp(event, 'data/id', 'drive0')
4539dfa9f59SPaolo Bonzini
454ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
4559dfa9f59SPaolo Bonzini
4569dfa9f59SPaolo Bonzini    def test_ignore_read(self):
457ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
4589dfa9f59SPaolo Bonzini
4599dfa9f59SPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
4609dfa9f59SPaolo Bonzini                             target=target_img, on_source_error='ignore')
4619dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return', {})
4629dfa9f59SPaolo Bonzini
4639dfa9f59SPaolo Bonzini        event = self.vm.get_qmp_event(wait=True)
4641dac83f1SKevin Wolf        while event['event'] == 'JOB_STATUS_CHANGE':
4651dac83f1SKevin Wolf            self.assert_qmp(event, 'data/id', 'drive0')
4661dac83f1SKevin Wolf            event = self.vm.get_qmp_event(wait=True)
4671dac83f1SKevin Wolf
468fa1cfb40SKevin Wolf        self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
4699dfa9f59SPaolo Bonzini        self.assert_qmp(event, 'data/device', 'drive0')
4709dfa9f59SPaolo Bonzini        self.assert_qmp(event, 'data/operation', 'read')
4719dfa9f59SPaolo Bonzini        result = self.vm.qmp('query-block-jobs')
4729dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return[0]/paused', False)
4739dfa9f59SPaolo Bonzini        self.complete_and_wait()
4749dfa9f59SPaolo Bonzini
475b812f671SPaolo Bonzini    def test_large_cluster(self):
476ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
477b812f671SPaolo Bonzini
478b812f671SPaolo Bonzini        # Test COW into the target image.  The first half of the
479b812f671SPaolo Bonzini        # cluster at MIRROR_GRANULARITY has to be copied from
480b812f671SPaolo Bonzini        # backing_img, even though sync='top'.
481b812f671SPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-ocluster_size=131072,backing_file=%s' %(backing_img), target_img)
482b812f671SPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='top',
483b812f671SPaolo Bonzini                             on_source_error='ignore',
484b812f671SPaolo Bonzini                             mode='existing', target=target_img)
485b812f671SPaolo Bonzini        self.assert_qmp(result, 'return', {})
486b812f671SPaolo Bonzini
487b812f671SPaolo Bonzini        event = self.vm.get_qmp_event(wait=True)
4881dac83f1SKevin Wolf        while event['event'] == 'JOB_STATUS_CHANGE':
4891dac83f1SKevin Wolf            self.assert_qmp(event, 'data/id', 'drive0')
4901dac83f1SKevin Wolf            event = self.vm.get_qmp_event(wait=True)
4911dac83f1SKevin Wolf
492fa1cfb40SKevin Wolf        self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
493b812f671SPaolo Bonzini        self.assert_qmp(event, 'data/device', 'drive0')
494b812f671SPaolo Bonzini        self.assert_qmp(event, 'data/operation', 'read')
495b812f671SPaolo Bonzini        result = self.vm.qmp('query-block-jobs')
496b812f671SPaolo Bonzini        self.assert_qmp(result, 'return[0]/paused', False)
497b812f671SPaolo Bonzini        self.complete_and_wait()
498b812f671SPaolo Bonzini        self.vm.shutdown()
499b812f671SPaolo Bonzini
500b812f671SPaolo Bonzini        # Detach blkdebug to compare images successfully
501b812f671SPaolo Bonzini        qemu_img('rebase', '-f', iotests.imgfmt, '-u', '-b', backing_img, test_img)
5023a3918c3SStefan Hajnoczi        self.assertTrue(iotests.compare_images(test_img, target_img),
503b812f671SPaolo Bonzini                        'target image does not match source after mirroring')
504b812f671SPaolo Bonzini
5059dfa9f59SPaolo Bonzini    def test_stop_read(self):
506ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
5079dfa9f59SPaolo Bonzini
5089dfa9f59SPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
5099dfa9f59SPaolo Bonzini                             target=target_img, on_source_error='stop')
5109dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return', {})
5119dfa9f59SPaolo Bonzini
5129dfa9f59SPaolo Bonzini        error = False
5139dfa9f59SPaolo Bonzini        ready = False
5149dfa9f59SPaolo Bonzini        while not ready:
5159dfa9f59SPaolo Bonzini            for event in self.vm.get_qmp_events(wait=True):
5169dfa9f59SPaolo Bonzini                if event['event'] == 'BLOCK_JOB_ERROR':
5179dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/device', 'drive0')
5189dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/operation', 'read')
5199dfa9f59SPaolo Bonzini
5209dfa9f59SPaolo Bonzini                    result = self.vm.qmp('query-block-jobs')
5219dfa9f59SPaolo Bonzini                    self.assert_qmp(result, 'return[0]/paused', True)
5229dfa9f59SPaolo Bonzini                    self.assert_qmp(result, 'return[0]/io-status', 'failed')
5239dfa9f59SPaolo Bonzini
5249dfa9f59SPaolo Bonzini                    result = self.vm.qmp('block-job-resume', device='drive0')
5259dfa9f59SPaolo Bonzini                    self.assert_qmp(result, 'return', {})
5269dfa9f59SPaolo Bonzini                    error = True
5279dfa9f59SPaolo Bonzini                elif event['event'] == 'BLOCK_JOB_READY':
5289dfa9f59SPaolo Bonzini                    self.assertTrue(error, 'job completed unexpectedly')
5299dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/device', 'drive0')
5309dfa9f59SPaolo Bonzini                    ready = True
5319dfa9f59SPaolo Bonzini
5329dfa9f59SPaolo Bonzini        result = self.vm.qmp('query-block-jobs')
5339dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return[0]/paused', False)
5349dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return[0]/io-status', 'ok')
5359dfa9f59SPaolo Bonzini
5369dfa9f59SPaolo Bonzini        self.complete_and_wait(wait_ready=False)
537ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
5389dfa9f59SPaolo Bonzini
539866323f3SFam Zhengclass TestWriteErrors(iotests.QMPTestCase):
5409dfa9f59SPaolo Bonzini    image_len = 2 * 1024 * 1024 # MB
5419dfa9f59SPaolo Bonzini
5429dfa9f59SPaolo Bonzini    # this should be a multiple of twice the default granularity
5439dfa9f59SPaolo Bonzini    # so that we hit this offset first in state 1
5449dfa9f59SPaolo Bonzini    MIRROR_GRANULARITY = 1024 * 1024
5459dfa9f59SPaolo Bonzini
5469dfa9f59SPaolo Bonzini    def create_blkdebug_file(self, name, event, errno):
5479dfa9f59SPaolo Bonzini        file = open(name, 'w')
5489dfa9f59SPaolo Bonzini        file.write('''
5499dfa9f59SPaolo Bonzini[inject-error]
5509dfa9f59SPaolo Bonzinistate = "1"
5519dfa9f59SPaolo Bonzinievent = "%s"
5529dfa9f59SPaolo Bonzinierrno = "%d"
5539dfa9f59SPaolo Bonziniimmediately = "off"
5549dfa9f59SPaolo Bonzinionce = "on"
5559dfa9f59SPaolo Bonzinisector = "%d"
5569dfa9f59SPaolo Bonzini
5579dfa9f59SPaolo Bonzini[set-state]
5589dfa9f59SPaolo Bonzinistate = "1"
5599dfa9f59SPaolo Bonzinievent = "%s"
5609dfa9f59SPaolo Bonzininew_state = "2"
5619dfa9f59SPaolo Bonzini
5629dfa9f59SPaolo Bonzini[set-state]
5639dfa9f59SPaolo Bonzinistate = "2"
5649dfa9f59SPaolo Bonzinievent = "%s"
5659dfa9f59SPaolo Bonzininew_state = "1"
5669a3a9a63SMax Reitz''' % (event, errno, self.MIRROR_GRANULARITY // 512, event, event))
5679dfa9f59SPaolo Bonzini        file.close()
5689dfa9f59SPaolo Bonzini
5699dfa9f59SPaolo Bonzini    def setUp(self):
5709dfa9f59SPaolo Bonzini        self.blkdebug_file = target_img + ".blkdebug"
5712499a096SStefan Hajnoczi        iotests.create_image(backing_img, TestWriteErrors.image_len)
5729dfa9f59SPaolo Bonzini        self.create_blkdebug_file(self.blkdebug_file, "write_aio", 5)
5739dfa9f59SPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-obacking_file=%s' %(backing_img), test_img)
5749dfa9f59SPaolo Bonzini        self.vm = iotests.VM().add_drive(test_img)
5759dfa9f59SPaolo Bonzini        self.target_img = 'blkdebug:%s:%s' % (self.blkdebug_file, target_img)
5769dfa9f59SPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-osize=%d' %(TestWriteErrors.image_len), target_img)
5779dfa9f59SPaolo Bonzini        self.vm.launch()
5789dfa9f59SPaolo Bonzini
5799dfa9f59SPaolo Bonzini    def tearDown(self):
5809dfa9f59SPaolo Bonzini        self.vm.shutdown()
5819dfa9f59SPaolo Bonzini        os.remove(test_img)
582db11d1eeSKevin Wolf        os.remove(target_img)
5839dfa9f59SPaolo Bonzini        os.remove(backing_img)
5849dfa9f59SPaolo Bonzini        os.remove(self.blkdebug_file)
5859dfa9f59SPaolo Bonzini
5869dfa9f59SPaolo Bonzini    def test_report_write(self):
587ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
5889dfa9f59SPaolo Bonzini
5899dfa9f59SPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
5909dfa9f59SPaolo Bonzini                             mode='existing', target=self.target_img)
5919dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return', {})
5929dfa9f59SPaolo Bonzini
5939dfa9f59SPaolo Bonzini        completed = False
5949dfa9f59SPaolo Bonzini        error = False
5959dfa9f59SPaolo Bonzini        while not completed:
5969dfa9f59SPaolo Bonzini            for event in self.vm.get_qmp_events(wait=True):
5979dfa9f59SPaolo Bonzini                if event['event'] == 'BLOCK_JOB_ERROR':
5989dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/device', 'drive0')
5999dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/operation', 'write')
6009dfa9f59SPaolo Bonzini                    error = True
6019dfa9f59SPaolo Bonzini                elif event['event'] == 'BLOCK_JOB_READY':
6029dfa9f59SPaolo Bonzini                    self.assertTrue(False, 'job completed unexpectedly')
6039dfa9f59SPaolo Bonzini                elif event['event'] == 'BLOCK_JOB_COMPLETED':
6049dfa9f59SPaolo Bonzini                    self.assertTrue(error, 'job completed unexpectedly')
6059dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/type', 'mirror')
6069dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/device', 'drive0')
6079dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/error', 'Input/output error')
6089dfa9f59SPaolo Bonzini                    completed = True
6099dfa9f59SPaolo Bonzini
610ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
6119dfa9f59SPaolo Bonzini
6129dfa9f59SPaolo Bonzini    def test_ignore_write(self):
613ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
6149dfa9f59SPaolo Bonzini
6159dfa9f59SPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
6169dfa9f59SPaolo Bonzini                             mode='existing', target=self.target_img,
6179dfa9f59SPaolo Bonzini                             on_target_error='ignore')
6189dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return', {})
6199dfa9f59SPaolo Bonzini
6201dac83f1SKevin Wolf        event = self.vm.event_wait(name='BLOCK_JOB_ERROR')
621fa1cfb40SKevin Wolf        self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
6229dfa9f59SPaolo Bonzini        self.assert_qmp(event, 'data/device', 'drive0')
6239dfa9f59SPaolo Bonzini        self.assert_qmp(event, 'data/operation', 'write')
6249dfa9f59SPaolo Bonzini        result = self.vm.qmp('query-block-jobs')
6259dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return[0]/paused', False)
6269dfa9f59SPaolo Bonzini        self.complete_and_wait()
6279dfa9f59SPaolo Bonzini
6289dfa9f59SPaolo Bonzini    def test_stop_write(self):
629ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
6309dfa9f59SPaolo Bonzini
6319dfa9f59SPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
6329dfa9f59SPaolo Bonzini                             mode='existing', target=self.target_img,
6339dfa9f59SPaolo Bonzini                             on_target_error='stop')
6349dfa9f59SPaolo Bonzini        self.assert_qmp(result, 'return', {})
6359dfa9f59SPaolo Bonzini
6369dfa9f59SPaolo Bonzini        error = False
6379dfa9f59SPaolo Bonzini        ready = False
6389dfa9f59SPaolo Bonzini        while not ready:
6399dfa9f59SPaolo Bonzini            for event in self.vm.get_qmp_events(wait=True):
6409dfa9f59SPaolo Bonzini                if event['event'] == 'BLOCK_JOB_ERROR':
6419dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/device', 'drive0')
6429dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/operation', 'write')
6439dfa9f59SPaolo Bonzini
6449dfa9f59SPaolo Bonzini                    result = self.vm.qmp('query-block-jobs')
6459dfa9f59SPaolo Bonzini                    self.assert_qmp(result, 'return[0]/paused', True)
6469dfa9f59SPaolo Bonzini                    self.assert_qmp(result, 'return[0]/io-status', 'failed')
6479dfa9f59SPaolo Bonzini
6489dfa9f59SPaolo Bonzini                    result = self.vm.qmp('block-job-resume', device='drive0')
6499dfa9f59SPaolo Bonzini                    self.assert_qmp(result, 'return', {})
6509dfa9f59SPaolo Bonzini
6519dfa9f59SPaolo Bonzini                    result = self.vm.qmp('query-block-jobs')
6529dfa9f59SPaolo Bonzini                    self.assert_qmp(result, 'return[0]/paused', False)
6539dfa9f59SPaolo Bonzini                    self.assert_qmp(result, 'return[0]/io-status', 'ok')
6549dfa9f59SPaolo Bonzini                    error = True
6559dfa9f59SPaolo Bonzini                elif event['event'] == 'BLOCK_JOB_READY':
6569dfa9f59SPaolo Bonzini                    self.assertTrue(error, 'job completed unexpectedly')
6579dfa9f59SPaolo Bonzini                    self.assert_qmp(event, 'data/device', 'drive0')
6589dfa9f59SPaolo Bonzini                    ready = True
6599dfa9f59SPaolo Bonzini
6609dfa9f59SPaolo Bonzini        self.complete_and_wait(wait_ready=False)
661ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
6629dfa9f59SPaolo Bonzini
663866323f3SFam Zhengclass TestSetSpeed(iotests.QMPTestCase):
66444c7ca5eSPaolo Bonzini    image_len = 80 * 1024 * 1024 # MB
66544c7ca5eSPaolo Bonzini
66644c7ca5eSPaolo Bonzini    def setUp(self):
66744c7ca5eSPaolo Bonzini        qemu_img('create', backing_img, str(TestSetSpeed.image_len))
66844c7ca5eSPaolo Bonzini        qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
66944c7ca5eSPaolo Bonzini        self.vm = iotests.VM().add_drive(test_img)
67044c7ca5eSPaolo Bonzini        self.vm.launch()
67144c7ca5eSPaolo Bonzini
67244c7ca5eSPaolo Bonzini    def tearDown(self):
67344c7ca5eSPaolo Bonzini        self.vm.shutdown()
67444c7ca5eSPaolo Bonzini        os.remove(test_img)
67544c7ca5eSPaolo Bonzini        os.remove(backing_img)
67644c7ca5eSPaolo Bonzini        os.remove(target_img)
67744c7ca5eSPaolo Bonzini
67844c7ca5eSPaolo Bonzini    def test_set_speed(self):
679ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
68044c7ca5eSPaolo Bonzini
68144c7ca5eSPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
68244c7ca5eSPaolo Bonzini                             target=target_img)
68344c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
68444c7ca5eSPaolo Bonzini
68544c7ca5eSPaolo Bonzini        # Default speed is 0
68644c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block-jobs')
68744c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/device', 'drive0')
68844c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/speed', 0)
68944c7ca5eSPaolo Bonzini
69044c7ca5eSPaolo Bonzini        result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
69144c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
69244c7ca5eSPaolo Bonzini
69344c7ca5eSPaolo Bonzini        # Ensure the speed we set was accepted
69444c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block-jobs')
69544c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/device', 'drive0')
69644c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024)
69744c7ca5eSPaolo Bonzini
6982575fe16SStefan Hajnoczi        self.wait_ready_and_cancel()
69944c7ca5eSPaolo Bonzini
70044c7ca5eSPaolo Bonzini        # Check setting speed in drive-mirror works
70144c7ca5eSPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
70244c7ca5eSPaolo Bonzini                             target=target_img, speed=4*1024*1024)
70344c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
70444c7ca5eSPaolo Bonzini
70544c7ca5eSPaolo Bonzini        result = self.vm.qmp('query-block-jobs')
70644c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/device', 'drive0')
70744c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024)
70844c7ca5eSPaolo Bonzini
7092575fe16SStefan Hajnoczi        self.wait_ready_and_cancel()
71044c7ca5eSPaolo Bonzini
71144c7ca5eSPaolo Bonzini    def test_set_speed_invalid(self):
712ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
71344c7ca5eSPaolo Bonzini
71444c7ca5eSPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
71544c7ca5eSPaolo Bonzini                             target=target_img, speed=-1)
71644c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'error/class', 'GenericError')
71744c7ca5eSPaolo Bonzini
718ecc1c88eSStefan Hajnoczi        self.assert_no_active_block_jobs()
71944c7ca5eSPaolo Bonzini
72044c7ca5eSPaolo Bonzini        result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
72144c7ca5eSPaolo Bonzini                             target=target_img)
72244c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'return', {})
72344c7ca5eSPaolo Bonzini
72444c7ca5eSPaolo Bonzini        result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
72544c7ca5eSPaolo Bonzini        self.assert_qmp(result, 'error/class', 'GenericError')
72644c7ca5eSPaolo Bonzini
7272575fe16SStefan Hajnoczi        self.wait_ready_and_cancel()
72844c7ca5eSPaolo Bonzini
729866323f3SFam Zhengclass TestUnbackedSource(iotests.QMPTestCase):
730c15badeeSMax Reitz    image_len = 2 * 1024 * 1024 # MB
731c15badeeSMax Reitz
732c15badeeSMax Reitz    def setUp(self):
733c15badeeSMax Reitz        qemu_img('create', '-f', iotests.imgfmt, test_img,
734c15badeeSMax Reitz                 str(TestUnbackedSource.image_len))
7359463ee1fSMax Reitz        self.vm = iotests.VM()
736c15badeeSMax Reitz        self.vm.launch()
7379463ee1fSMax Reitz        result = self.vm.qmp('blockdev-add', node_name='drive0',
7389463ee1fSMax Reitz                             driver=iotests.imgfmt,
7399463ee1fSMax Reitz                             file={
7409463ee1fSMax Reitz                                 'driver': 'file',
7419463ee1fSMax Reitz                                 'filename': test_img,
7429463ee1fSMax Reitz                             })
7439463ee1fSMax Reitz        self.assert_qmp(result, 'return', {})
744c15badeeSMax Reitz
745c15badeeSMax Reitz    def tearDown(self):
746c15badeeSMax Reitz        self.vm.shutdown()
747c15badeeSMax Reitz        os.remove(test_img)
748c15badeeSMax Reitz        os.remove(target_img)
749c15badeeSMax Reitz
750171d6431SMax Reitz    def test_absolute_paths_full(self):
751171d6431SMax Reitz        self.assert_no_active_block_jobs()
7529463ee1fSMax Reitz        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
753171d6431SMax Reitz                             sync='full', target=target_img,
754171d6431SMax Reitz                             mode='absolute-paths')
755171d6431SMax Reitz        self.assert_qmp(result, 'return', {})
756171d6431SMax Reitz        self.complete_and_wait()
757c15badeeSMax Reitz        self.assert_no_active_block_jobs()
758c15badeeSMax Reitz
759171d6431SMax Reitz    def test_absolute_paths_top(self):
760171d6431SMax Reitz        self.assert_no_active_block_jobs()
7619463ee1fSMax Reitz        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
762171d6431SMax Reitz                             sync='top', target=target_img,
763171d6431SMax Reitz                             mode='absolute-paths')
764171d6431SMax Reitz        self.assert_qmp(result, 'return', {})
765171d6431SMax Reitz        self.complete_and_wait()
766171d6431SMax Reitz        self.assert_no_active_block_jobs()
767171d6431SMax Reitz
768171d6431SMax Reitz    def test_absolute_paths_none(self):
769171d6431SMax Reitz        self.assert_no_active_block_jobs()
7709463ee1fSMax Reitz        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
771171d6431SMax Reitz                             sync='none', target=target_img,
772c15badeeSMax Reitz                             mode='absolute-paths')
773c15badeeSMax Reitz        self.assert_qmp(result, 'return', {})
774c15badeeSMax Reitz        self.complete_and_wait()
775c15badeeSMax Reitz        self.assert_no_active_block_jobs()
776c15badeeSMax Reitz
7779463ee1fSMax Reitz    def test_existing_full(self):
7789463ee1fSMax Reitz        qemu_img('create', '-f', iotests.imgfmt, target_img,
7799463ee1fSMax Reitz                 str(self.image_len))
7809463ee1fSMax Reitz        qemu_io('-c', 'write -P 42 0 64k', target_img)
7819463ee1fSMax Reitz
7829463ee1fSMax Reitz        self.assert_no_active_block_jobs()
7839463ee1fSMax Reitz        result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
7849463ee1fSMax Reitz                             sync='full', target=target_img, mode='existing')
7859463ee1fSMax Reitz        self.assert_qmp(result, 'return', {})
7869463ee1fSMax Reitz        self.complete_and_wait()
7879463ee1fSMax Reitz        self.assert_no_active_block_jobs()
7889463ee1fSMax Reitz
7899463ee1fSMax Reitz        result = self.vm.qmp('blockdev-del', node_name='drive0')
7909463ee1fSMax Reitz        self.assert_qmp(result, 'return', {})
7919463ee1fSMax Reitz
7929463ee1fSMax Reitz        self.assertTrue(iotests.compare_images(test_img, target_img),
7939463ee1fSMax Reitz                        'target image does not match source after mirroring')
7949463ee1fSMax Reitz
7959463ee1fSMax Reitz    def test_blockdev_full(self):
7969463ee1fSMax Reitz        qemu_img('create', '-f', iotests.imgfmt, target_img,
7979463ee1fSMax Reitz                 str(self.image_len))
7989463ee1fSMax Reitz        qemu_io('-c', 'write -P 42 0 64k', target_img)
7999463ee1fSMax Reitz
8009463ee1fSMax Reitz        result = self.vm.qmp('blockdev-add', node_name='target',
8019463ee1fSMax Reitz                             driver=iotests.imgfmt,
8029463ee1fSMax Reitz                             file={
8039463ee1fSMax Reitz                                 'driver': 'file',
8049463ee1fSMax Reitz                                 'filename': target_img,
8059463ee1fSMax Reitz                             })
8069463ee1fSMax Reitz        self.assert_qmp(result, 'return', {})
8079463ee1fSMax Reitz
8089463ee1fSMax Reitz        self.assert_no_active_block_jobs()
8099463ee1fSMax Reitz        result = self.vm.qmp('blockdev-mirror', job_id='drive0', device='drive0',
8109463ee1fSMax Reitz                             sync='full', target='target')
8119463ee1fSMax Reitz        self.assert_qmp(result, 'return', {})
8129463ee1fSMax Reitz        self.complete_and_wait()
8139463ee1fSMax Reitz        self.assert_no_active_block_jobs()
8149463ee1fSMax Reitz
8159463ee1fSMax Reitz        result = self.vm.qmp('blockdev-del', node_name='drive0')
8169463ee1fSMax Reitz        self.assert_qmp(result, 'return', {})
8179463ee1fSMax Reitz
8189463ee1fSMax Reitz        result = self.vm.qmp('blockdev-del', node_name='target')
8199463ee1fSMax Reitz        self.assert_qmp(result, 'return', {})
8209463ee1fSMax Reitz
8219463ee1fSMax Reitz        self.assertTrue(iotests.compare_images(test_img, target_img),
8229463ee1fSMax Reitz                        'target image does not match source after mirroring')
8239463ee1fSMax Reitz
824ccee3d8fSJohn Snowclass TestGranularity(iotests.QMPTestCase):
825ccee3d8fSJohn Snow    image_len = 10 * 1024 * 1024 # MB
826ccee3d8fSJohn Snow
827ccee3d8fSJohn Snow    def setUp(self):
828ccee3d8fSJohn Snow        qemu_img('create', '-f', iotests.imgfmt, test_img,
829ccee3d8fSJohn Snow                 str(TestGranularity.image_len))
830ccee3d8fSJohn Snow        qemu_io('-c', 'write 0 %d' % (self.image_len),
831ccee3d8fSJohn Snow                test_img)
832ccee3d8fSJohn Snow        self.vm = iotests.VM().add_drive(test_img)
833ccee3d8fSJohn Snow        self.vm.launch()
834ccee3d8fSJohn Snow
835ccee3d8fSJohn Snow    def tearDown(self):
836ccee3d8fSJohn Snow        self.vm.shutdown()
837ccee3d8fSJohn Snow        self.assertTrue(iotests.compare_images(test_img, target_img),
838ccee3d8fSJohn Snow                        'target image does not match source after mirroring')
839ccee3d8fSJohn Snow        os.remove(test_img)
840ccee3d8fSJohn Snow        os.remove(target_img)
841ccee3d8fSJohn Snow
842ccee3d8fSJohn Snow    def test_granularity(self):
843ccee3d8fSJohn Snow        self.assert_no_active_block_jobs()
844ccee3d8fSJohn Snow        result = self.vm.qmp('drive-mirror', device='drive0',
845ccee3d8fSJohn Snow                             sync='full', target=target_img,
846ccee3d8fSJohn Snow                             mode='absolute-paths', granularity=8192)
847ccee3d8fSJohn Snow        self.assert_qmp(result, 'return', {})
8481dac83f1SKevin Wolf
849ccee3d8fSJohn Snow        event = self.vm.get_qmp_event(wait=60.0)
8501dac83f1SKevin Wolf        while event['event'] == 'JOB_STATUS_CHANGE':
8511dac83f1SKevin Wolf            self.assert_qmp(event, 'data/id', 'drive0')
8521dac83f1SKevin Wolf            event = self.vm.get_qmp_event(wait=60.0)
8531dac83f1SKevin Wolf
854ccee3d8fSJohn Snow        # Failures will manifest as COMPLETED/ERROR.
855ccee3d8fSJohn Snow        self.assert_qmp(event, 'event', 'BLOCK_JOB_READY')
856ccee3d8fSJohn Snow        self.complete_and_wait(drive='drive0', wait_ready=False)
857ccee3d8fSJohn Snow        self.assert_no_active_block_jobs()
858ccee3d8fSJohn Snow
859866323f3SFam Zhengclass TestRepairQuorum(iotests.QMPTestCase):
860d88964aeSBenoît Canet    """ This class test quorum file repair using drive-mirror.
861d88964aeSBenoît Canet        It's mostly a fork of TestSingleDrive """
862d88964aeSBenoît Canet    image_len = 1 * 1024 * 1024 # MB
863d88964aeSBenoît Canet    IMAGES = [ quorum_img1, quorum_img2, quorum_img3 ]
864d88964aeSBenoît Canet
8659442bebeSThomas Huth    @iotests.skip_if_unsupported(['quorum'])
866d88964aeSBenoît Canet    def setUp(self):
867d88964aeSBenoît Canet        self.vm = iotests.VM()
868d88964aeSBenoît Canet
8690ed82f7aSMax Reitz        if iotests.qemu_default_machine == 'pc':
8700ed82f7aSMax Reitz            self.vm.add_drive(None, 'media=cdrom', 'ide')
8710ed82f7aSMax Reitz
872d88964aeSBenoît Canet        # Add each individual quorum images
873d88964aeSBenoît Canet        for i in self.IMAGES:
874d88964aeSBenoît Canet            qemu_img('create', '-f', iotests.imgfmt, i,
875d88964aeSBenoît Canet                     str(TestSingleDrive.image_len))
876d88964aeSBenoît Canet            # Assign a node name to each quorum image in order to manipulate
877d88964aeSBenoît Canet            # them
878d88964aeSBenoît Canet            opts = "node-name=img%i" % self.IMAGES.index(i)
879f718ca14SMax Reitz            opts += ',driver=%s' % iotests.imgfmt
880f718ca14SMax Reitz            opts += ',file.driver=file'
881f718ca14SMax Reitz            opts += ',file.filename=%s' % i
882f718ca14SMax Reitz            self.vm = self.vm.add_blockdev(opts)
883d88964aeSBenoît Canet
884d88964aeSBenoît Canet        self.vm.launch()
885d88964aeSBenoît Canet
886d88964aeSBenoît Canet        #assemble the quorum block device from the individual files
8870153d2f5SKevin Wolf        args = { "driver": "quorum", "node-name": "quorum0",
8880153d2f5SKevin Wolf                 "vote-threshold": 2, "children": [ "img0", "img1", "img2" ] }
889d88964aeSBenoît Canet        result = self.vm.qmp("blockdev-add", **args)
890d88964aeSBenoît Canet        self.assert_qmp(result, 'return', {})
891d88964aeSBenoît Canet
892d88964aeSBenoît Canet
893d88964aeSBenoît Canet    def tearDown(self):
894d88964aeSBenoît Canet        self.vm.shutdown()
895db11d1eeSKevin Wolf        for i in self.IMAGES + [ quorum_repair_img, quorum_snapshot_file ]:
896d88964aeSBenoît Canet            # Do a try/except because the test may have deleted some images
897d88964aeSBenoît Canet            try:
898d88964aeSBenoît Canet                os.remove(i)
899d88964aeSBenoît Canet            except OSError:
900d88964aeSBenoît Canet                pass
901d88964aeSBenoît Canet
902d88964aeSBenoît Canet    def test_complete(self):
903d88964aeSBenoît Canet        self.assert_no_active_block_jobs()
904d88964aeSBenoît Canet
905476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
906476fb028SKevin Wolf                             sync='full', node_name="repair0", replaces="img1",
907d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
908d88964aeSBenoît Canet        self.assert_qmp(result, 'return', {})
909d88964aeSBenoît Canet
910476fb028SKevin Wolf        self.complete_and_wait(drive="job0")
911e71fc0baSFam Zheng        self.assert_has_block_node("repair0", quorum_repair_img)
912*c351afd6SMax Reitz        self.vm.assert_block_path('quorum0', '/children.1', 'repair0')
913d88964aeSBenoît Canet        self.vm.shutdown()
914d88964aeSBenoît Canet        self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
915d88964aeSBenoît Canet                        'target image does not match source after mirroring')
916d88964aeSBenoît Canet
917d88964aeSBenoît Canet    def test_cancel(self):
918d88964aeSBenoît Canet        self.assert_no_active_block_jobs()
919d88964aeSBenoît Canet
920476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
921476fb028SKevin Wolf                             sync='full', node_name="repair0", replaces="img1",
922d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
923d88964aeSBenoît Canet        self.assert_qmp(result, 'return', {})
924d88964aeSBenoît Canet
925476fb028SKevin Wolf        self.cancel_and_wait(drive="job0", force=True)
926d88964aeSBenoît Canet        # here we check that the last registered quorum file has not been
927d88964aeSBenoît Canet        # swapped out and unref
928e71fc0baSFam Zheng        self.assert_has_block_node(None, quorum_img3)
929d88964aeSBenoît Canet
930d88964aeSBenoît Canet    def test_cancel_after_ready(self):
931d88964aeSBenoît Canet        self.assert_no_active_block_jobs()
932d88964aeSBenoît Canet
933476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
934476fb028SKevin Wolf                             sync='full', node_name="repair0", replaces="img1",
935d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
936d88964aeSBenoît Canet        self.assert_qmp(result, 'return', {})
937d88964aeSBenoît Canet
938476fb028SKevin Wolf        self.wait_ready_and_cancel(drive="job0")
939d88964aeSBenoît Canet        # here we check that the last registered quorum file has not been
940d88964aeSBenoît Canet        # swapped out and unref
941e71fc0baSFam Zheng        self.assert_has_block_node(None, quorum_img3)
942d88964aeSBenoît Canet        self.vm.shutdown()
943d88964aeSBenoît Canet        self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
944d88964aeSBenoît Canet                        'target image does not match source after mirroring')
945d88964aeSBenoît Canet
946d88964aeSBenoît Canet    def test_pause(self):
947d88964aeSBenoît Canet        self.assert_no_active_block_jobs()
948d88964aeSBenoît Canet
949476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
950476fb028SKevin Wolf                             sync='full', node_name="repair0", replaces="img1",
951d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
952d88964aeSBenoît Canet        self.assert_qmp(result, 'return', {})
953d88964aeSBenoît Canet
9542c93c5cbSKevin Wolf        self.pause_job('job0')
955d88964aeSBenoît Canet
956d88964aeSBenoît Canet        result = self.vm.qmp('query-block-jobs')
957d88964aeSBenoît Canet        offset = self.dictpath(result, 'return[0]/offset')
958d88964aeSBenoît Canet
9592c93c5cbSKevin Wolf        time.sleep(0.5)
960d88964aeSBenoît Canet        result = self.vm.qmp('query-block-jobs')
961d88964aeSBenoît Canet        self.assert_qmp(result, 'return[0]/offset', offset)
962d88964aeSBenoît Canet
963476fb028SKevin Wolf        result = self.vm.qmp('block-job-resume', device='job0')
964d88964aeSBenoît Canet        self.assert_qmp(result, 'return', {})
965d88964aeSBenoît Canet
966476fb028SKevin Wolf        self.complete_and_wait(drive="job0")
967d88964aeSBenoît Canet        self.vm.shutdown()
968d88964aeSBenoît Canet        self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
969d88964aeSBenoît Canet                        'target image does not match source after mirroring')
970d88964aeSBenoît Canet
971d88964aeSBenoît Canet    def test_medium_not_found(self):
972d8683155SBo Tu        if iotests.qemu_default_machine != 'pc':
973d8683155SBo Tu            return
974d8683155SBo Tu
975476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='drive0', # CD-ROM
9760ed82f7aSMax Reitz                             sync='full',
977d88964aeSBenoît Canet                             node_name='repair0',
978d88964aeSBenoît Canet                             replaces='img1',
979d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
980d88964aeSBenoît Canet        self.assert_qmp(result, 'error/class', 'GenericError')
981d88964aeSBenoît Canet
982d88964aeSBenoît Canet    def test_image_not_found(self):
983476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
984476fb028SKevin Wolf                             sync='full', node_name='repair0', replaces='img1',
985476fb028SKevin Wolf                             mode='existing', target=quorum_repair_img,
986476fb028SKevin Wolf                             format=iotests.imgfmt)
987d88964aeSBenoît Canet        self.assert_qmp(result, 'error/class', 'GenericError')
988d88964aeSBenoît Canet
989d88964aeSBenoît Canet    def test_device_not_found(self):
990476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0',
991476fb028SKevin Wolf                             device='nonexistent', sync='full',
992d88964aeSBenoît Canet                             node_name='repair0',
993d88964aeSBenoît Canet                             replaces='img1',
994d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
9950524e93aSKevin Wolf        self.assert_qmp(result, 'error/class', 'GenericError')
996d88964aeSBenoît Canet
997d88964aeSBenoît Canet    def test_wrong_sync_mode(self):
998476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', device='quorum0', job_id='job0',
999d88964aeSBenoît Canet                             node_name='repair0',
1000d88964aeSBenoît Canet                             replaces='img1',
1001d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
1002d88964aeSBenoît Canet        self.assert_qmp(result, 'error/class', 'GenericError')
1003d88964aeSBenoît Canet
1004d88964aeSBenoît Canet    def test_no_node_name(self):
1005476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1006476fb028SKevin Wolf                             sync='full', replaces='img1',
1007d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
1008d88964aeSBenoît Canet        self.assert_qmp(result, 'error/class', 'GenericError')
1009d88964aeSBenoît Canet
101067cc32ebSVeres Lajos    def test_nonexistent_replaces(self):
1011476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1012476fb028SKevin Wolf                             sync='full', node_name='repair0', replaces='img77',
1013d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
1014d88964aeSBenoît Canet        self.assert_qmp(result, 'error/class', 'GenericError')
1015d88964aeSBenoît Canet
1016d88964aeSBenoît Canet    def test_after_a_quorum_snapshot(self):
1017d88964aeSBenoît Canet        result = self.vm.qmp('blockdev-snapshot-sync', node_name='img1',
1018d88964aeSBenoît Canet                             snapshot_file=quorum_snapshot_file,
1019d88964aeSBenoît Canet                             snapshot_node_name="snap1");
1020d88964aeSBenoît Canet
1021476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1022476fb028SKevin Wolf                             sync='full', node_name='repair0', replaces="img1",
1023d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
1024d88964aeSBenoît Canet        self.assert_qmp(result, 'error/class', 'GenericError')
1025d88964aeSBenoît Canet
1026476fb028SKevin Wolf        result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1027476fb028SKevin Wolf                             sync='full', node_name='repair0', replaces="snap1",
1028d88964aeSBenoît Canet                             target=quorum_repair_img, format=iotests.imgfmt)
1029d88964aeSBenoît Canet        self.assert_qmp(result, 'return', {})
1030d88964aeSBenoît Canet
1031476fb028SKevin Wolf        self.complete_and_wait('job0')
1032e71fc0baSFam Zheng        self.assert_has_block_node("repair0", quorum_repair_img)
1033*c351afd6SMax Reitz        self.vm.assert_block_path('quorum0', '/children.1', 'repair0')
1034d88964aeSBenoît Canet
10355694923aSMax Reitz# Test mirroring with a source that does not have any parents (not even a
10365694923aSMax Reitz# BlockBackend)
10375694923aSMax Reitzclass TestOrphanedSource(iotests.QMPTestCase):
10385694923aSMax Reitz    def setUp(self):
10395694923aSMax Reitz        blk0 = { 'node-name': 'src',
10405694923aSMax Reitz                 'driver': 'null-co' }
10415694923aSMax Reitz
10425694923aSMax Reitz        blk1 = { 'node-name': 'dest',
10435694923aSMax Reitz                 'driver': 'null-co' }
10445694923aSMax Reitz
10455694923aSMax Reitz        blk2 = { 'node-name': 'dest-ro',
10465694923aSMax Reitz                 'driver': 'null-co',
10475694923aSMax Reitz                 'read-only': 'on' }
10485694923aSMax Reitz
10495694923aSMax Reitz        self.vm = iotests.VM()
105062a94288SKevin Wolf        self.vm.add_blockdev(self.vm.qmp_to_opts(blk0))
105162a94288SKevin Wolf        self.vm.add_blockdev(self.vm.qmp_to_opts(blk1))
105262a94288SKevin Wolf        self.vm.add_blockdev(self.vm.qmp_to_opts(blk2))
10535694923aSMax Reitz        self.vm.launch()
10545694923aSMax Reitz
10555694923aSMax Reitz    def tearDown(self):
10565694923aSMax Reitz        self.vm.shutdown()
10575694923aSMax Reitz
10585694923aSMax Reitz    def test_no_job_id(self):
10595694923aSMax Reitz        self.assert_no_active_block_jobs()
10605694923aSMax Reitz
10615694923aSMax Reitz        result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
10625694923aSMax Reitz                             target='dest')
10635694923aSMax Reitz        self.assert_qmp(result, 'error/class', 'GenericError')
10645694923aSMax Reitz
10655694923aSMax Reitz    def test_success(self):
10665694923aSMax Reitz        self.assert_no_active_block_jobs()
10675694923aSMax Reitz
10685694923aSMax Reitz        result = self.vm.qmp('blockdev-mirror', job_id='job', device='src',
10695694923aSMax Reitz                             sync='full', target='dest')
10705694923aSMax Reitz        self.assert_qmp(result, 'return', {})
10715694923aSMax Reitz
10725694923aSMax Reitz        self.complete_and_wait('job')
10735694923aSMax Reitz
10745694923aSMax Reitz    def test_failing_permissions(self):
10755694923aSMax Reitz        self.assert_no_active_block_jobs()
10765694923aSMax Reitz
10775694923aSMax Reitz        result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
10785694923aSMax Reitz                             target='dest-ro')
10795694923aSMax Reitz        self.assert_qmp(result, 'error/class', 'GenericError')
10805694923aSMax Reitz
10819592fe45SMax Reitz    def test_failing_permission_in_complete(self):
10829592fe45SMax Reitz        self.assert_no_active_block_jobs()
10839592fe45SMax Reitz
10849592fe45SMax Reitz        # Unshare consistent-read on the target
10859592fe45SMax Reitz        # (The mirror job does not care)
10869592fe45SMax Reitz        result = self.vm.qmp('blockdev-add',
10879592fe45SMax Reitz                             driver='blkdebug',
10889592fe45SMax Reitz                             node_name='dest-perm',
10899592fe45SMax Reitz                             image='dest',
10909592fe45SMax Reitz                             unshare_child_perms=['consistent-read'])
10919592fe45SMax Reitz        self.assert_qmp(result, 'return', {})
10929592fe45SMax Reitz
10939592fe45SMax Reitz        result = self.vm.qmp('blockdev-mirror', job_id='job', device='src',
10949592fe45SMax Reitz                             sync='full', target='dest',
10959592fe45SMax Reitz                             filter_node_name='mirror-filter')
10969592fe45SMax Reitz        self.assert_qmp(result, 'return', {})
10979592fe45SMax Reitz
10989592fe45SMax Reitz        # Require consistent-read on the source
10999592fe45SMax Reitz        # (We can only add this node once the job has started, or it
11009592fe45SMax Reitz        # will complain that it does not want to run on non-root nodes)
11019592fe45SMax Reitz        result = self.vm.qmp('blockdev-add',
11029592fe45SMax Reitz                             driver='blkdebug',
11039592fe45SMax Reitz                             node_name='src-perm',
11049592fe45SMax Reitz                             image='src',
11059592fe45SMax Reitz                             take_child_perms=['consistent-read'])
11069592fe45SMax Reitz        self.assert_qmp(result, 'return', {})
11079592fe45SMax Reitz
11089592fe45SMax Reitz        # While completing, mirror will attempt to replace src by
11099592fe45SMax Reitz        # dest, which must fail because src-perm requires
11109592fe45SMax Reitz        # consistent-read but dest-perm does not share it; thus
11119592fe45SMax Reitz        # aborting the job when it is supposed to complete
11129592fe45SMax Reitz        self.complete_and_wait('job',
11139592fe45SMax Reitz                               completion_error='Operation not permitted')
11149592fe45SMax Reitz
11159592fe45SMax Reitz        # Assert that all of our nodes are still there (except for the
11169592fe45SMax Reitz        # mirror filter, which should be gone despite the failure)
11179592fe45SMax Reitz        nodes = self.vm.qmp('query-named-block-nodes')['return']
11189592fe45SMax Reitz        nodes = [node['node-name'] for node in nodes]
11199592fe45SMax Reitz
11209592fe45SMax Reitz        for expect in ('src', 'src-perm', 'dest', 'dest-perm'):
11219592fe45SMax Reitz            self.assertTrue(expect in nodes, '%s disappeared' % expect)
11229592fe45SMax Reitz        self.assertFalse('mirror-filter' in nodes,
11239592fe45SMax Reitz                         'Mirror filter node did not disappear')
11249592fe45SMax Reitz
112544c7ca5eSPaolo Bonziniif __name__ == '__main__':
1126103cbc77SMax Reitz    iotests.main(supported_fmts=['qcow2', 'qed'],
1127877d18f2SThomas Huth                 supported_protocols=['file'],
1128877d18f2SThomas Huth                 supported_platforms=['linux', 'freebsd', 'netbsd', 'openbsd'])
1129