cirrus: fix off-by-one in cirrus_bitblt_rop_bkwd_transp_*_16
[qemu.git] / tests / qemu-iotests / 155
1 #!/usr/bin/env python
2 #
3 # Test whether the backing BDSs are correct after completion of a
4 # mirror block job; in "existing" modes (drive-mirror with
5 # mode=existing and blockdev-mirror) the backing chain should not be
6 # overridden.
7 #
8 # Copyright (C) 2016 Red Hat, Inc.
9 #
10 # This program is free software; you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation; either version 2 of the License, or
13 # (at your option) any later version.
14 #
15 # This program is distributed in the hope that it will be useful,
16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 # GNU General Public License for more details.
19 #
20 # You should have received a copy of the GNU General Public License
21 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 #
23
24 import os
25 import iotests
26 from iotests import qemu_img
27
28 back0_img = os.path.join(iotests.test_dir, 'back0.' + iotests.imgfmt)
29 back1_img = os.path.join(iotests.test_dir, 'back1.' + iotests.imgfmt)
30 back2_img = os.path.join(iotests.test_dir, 'back2.' + iotests.imgfmt)
31 source_img = os.path.join(iotests.test_dir, 'source.' + iotests.imgfmt)
32 target_img = os.path.join(iotests.test_dir, 'target.' + iotests.imgfmt)
33
34
35 # Class variables for controlling its behavior:
36 #
37 # existing: If True, explicitly create the target image and blockdev-add it
38 # target_backing: If existing is True: Use this filename as the backing file
39 #                 of the target image
40 #                 (None: no backing file)
41 # target_blockdev_backing: If existing is True: Pass this dict as "backing"
42 #                          for the blockdev-add command
43 #                          (None: do not pass "backing")
44 # target_real_backing: If existing is True: The real filename of the backing
45 #                      image during runtime, only makes sense if
46 #                      target_blockdev_backing is not None
47 #                      (None: same as target_backing)
48
49 class BaseClass(iotests.QMPTestCase):
50     target_blockdev_backing = None
51     target_real_backing = None
52
53     def setUp(self):
54         qemu_img('create', '-f', iotests.imgfmt, back0_img, '1M')
55         qemu_img('create', '-f', iotests.imgfmt, '-b', back0_img, back1_img)
56         qemu_img('create', '-f', iotests.imgfmt, '-b', back1_img, back2_img)
57         qemu_img('create', '-f', iotests.imgfmt, '-b', back2_img, source_img)
58
59         self.vm = iotests.VM()
60         self.vm.add_drive(None, '', 'none')
61         self.vm.launch()
62
63         # Add the BDS via blockdev-add so it stays around after the mirror block
64         # job has been completed
65         result = self.vm.qmp('blockdev-add',
66                              node_name='source',
67                              driver=iotests.imgfmt,
68                              file={'driver': 'file',
69                                    'filename': source_img})
70         self.assert_qmp(result, 'return', {})
71
72         result = self.vm.qmp('x-blockdev-insert-medium',
73                              device='drive0', node_name='source')
74         self.assert_qmp(result, 'return', {})
75
76         self.assertIntactSourceBackingChain()
77
78         if self.existing:
79             if self.target_backing:
80                 qemu_img('create', '-f', iotests.imgfmt,
81                          '-b', self.target_backing, target_img, '1M')
82             else:
83                 qemu_img('create', '-f', iotests.imgfmt, target_img, '1M')
84
85             if self.cmd == 'blockdev-mirror':
86                 options = { 'node-name': 'target',
87                             'driver': iotests.imgfmt,
88                             'file': { 'driver': 'file',
89                                       'filename': target_img } }
90                 if self.target_blockdev_backing:
91                     options['backing'] = self.target_blockdev_backing
92
93                 result = self.vm.qmp('blockdev-add', **options)
94                 self.assert_qmp(result, 'return', {})
95
96     def tearDown(self):
97         self.vm.shutdown()
98         os.remove(source_img)
99         os.remove(back2_img)
100         os.remove(back1_img)
101         os.remove(back0_img)
102         try:
103             os.remove(target_img)
104         except OSError:
105             pass
106
107     def findBlockNode(self, node_name, id=None):
108         if id:
109             result = self.vm.qmp('query-block')
110             for device in result['return']:
111                 if device['device'] == id:
112                     if node_name:
113                         self.assert_qmp(device, 'inserted/node-name', node_name)
114                     return device['inserted']
115         else:
116             result = self.vm.qmp('query-named-block-nodes')
117             for node in result['return']:
118                 if node['node-name'] == node_name:
119                     return node
120
121         self.fail('Cannot find node %s/%s' % (id, node_name))
122
123     def assertIntactSourceBackingChain(self):
124         node = self.findBlockNode('source')
125
126         self.assert_qmp(node, 'image' + '/backing-image' * 0 + '/filename',
127                         source_img)
128         self.assert_qmp(node, 'image' + '/backing-image' * 1 + '/filename',
129                         back2_img)
130         self.assert_qmp(node, 'image' + '/backing-image' * 2 + '/filename',
131                         back1_img)
132         self.assert_qmp(node, 'image' + '/backing-image' * 3 + '/filename',
133                         back0_img)
134         self.assert_qmp_absent(node, 'image' + '/backing-image' * 4)
135
136     def assertCorrectBackingImage(self, node, default_image):
137         if self.existing:
138             if self.target_real_backing:
139                 image = self.target_real_backing
140             else:
141                 image = self.target_backing
142         else:
143             image = default_image
144
145         if image:
146             self.assert_qmp(node, 'image/backing-image/filename', image)
147         else:
148             self.assert_qmp_absent(node, 'image/backing-image')
149
150
151 # Class variables for controlling its behavior:
152 #
153 # cmd: Mirroring command to execute, either drive-mirror or blockdev-mirror
154
155 class MirrorBaseClass(BaseClass):
156     def runMirror(self, sync):
157         if self.cmd == 'blockdev-mirror':
158             result = self.vm.qmp(self.cmd, device='drive0', sync=sync,
159                                  target='target')
160         else:
161             if self.existing:
162                 mode = 'existing'
163             else:
164                 mode = 'absolute-paths'
165             result = self.vm.qmp(self.cmd, device='drive0', sync=sync,
166                                  target=target_img, format=iotests.imgfmt,
167                                  mode=mode, node_name='target')
168
169         self.assert_qmp(result, 'return', {})
170
171         self.vm.event_wait('BLOCK_JOB_READY')
172
173         result = self.vm.qmp('block-job-complete', device='drive0')
174         self.assert_qmp(result, 'return', {})
175
176         self.vm.event_wait('BLOCK_JOB_COMPLETED')
177
178     def testFull(self):
179         self.runMirror('full')
180
181         node = self.findBlockNode('target', 'drive0')
182         self.assertCorrectBackingImage(node, None)
183         self.assertIntactSourceBackingChain()
184
185     def testTop(self):
186         self.runMirror('top')
187
188         node = self.findBlockNode('target', 'drive0')
189         self.assertCorrectBackingImage(node, back2_img)
190         self.assertIntactSourceBackingChain()
191
192     def testNone(self):
193         self.runMirror('none')
194
195         node = self.findBlockNode('target', 'drive0')
196         self.assertCorrectBackingImage(node, source_img)
197         self.assertIntactSourceBackingChain()
198
199
200 class TestDriveMirrorAbsolutePaths(MirrorBaseClass):
201     cmd = 'drive-mirror'
202     existing = False
203
204 class TestDriveMirrorExistingNoBacking(MirrorBaseClass):
205     cmd = 'drive-mirror'
206     existing = True
207     target_backing = None
208
209 class TestDriveMirrorExistingBacking(MirrorBaseClass):
210     cmd = 'drive-mirror'
211     existing = True
212     target_backing = 'null-co://'
213
214 class TestBlockdevMirrorNoBacking(MirrorBaseClass):
215     cmd = 'blockdev-mirror'
216     existing = True
217     target_backing = None
218
219 class TestBlockdevMirrorBacking(MirrorBaseClass):
220     cmd = 'blockdev-mirror'
221     existing = True
222     target_backing = 'null-co://'
223
224 class TestBlockdevMirrorForcedBacking(MirrorBaseClass):
225     cmd = 'blockdev-mirror'
226     existing = True
227     target_backing = None
228     target_blockdev_backing = { 'driver': 'null-co' }
229     target_real_backing = 'null-co://'
230
231
232 class TestCommit(BaseClass):
233     existing = False
234
235     def testCommit(self):
236         result = self.vm.qmp('block-commit', device='drive0', base=back1_img)
237         self.assert_qmp(result, 'return', {})
238
239         self.vm.event_wait('BLOCK_JOB_READY')
240
241         result = self.vm.qmp('block-job-complete', device='drive0')
242         self.assert_qmp(result, 'return', {})
243
244         self.vm.event_wait('BLOCK_JOB_COMPLETED')
245
246         node = self.findBlockNode(None, 'drive0')
247         self.assert_qmp(node, 'image' + '/backing-image' * 0 + '/filename',
248                         back1_img)
249         self.assert_qmp(node, 'image' + '/backing-image' * 1 + '/filename',
250                         back0_img)
251         self.assert_qmp_absent(node, 'image' + '/backing-image' * 2 +
252                                '/filename')
253
254         self.assertIntactSourceBackingChain()
255
256
257 BaseClass = None
258 MirrorBaseClass = None
259
260 if __name__ == '__main__':
261     iotests.main(supported_fmts=['qcow2'])