]>
git.proxmox.com Git - mirror_qemu.git/blob - tests/qemu-iotests/056
3 # Tests for drive-backup
5 # Copyright (C) 2013 Red Hat, Inc.
9 # This program is free software; you can redistribute it and/or modify
10 # it under the terms of the GNU General Public License as published by
11 # the Free Software Foundation; either version 2 of the License, or
12 # (at your option) any later version.
14 # This program is distributed in the hope that it will be useful,
15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 # GNU General Public License for more details.
19 # You should have received a copy of the GNU General Public License
20 # along with this program. If not, see <http://www.gnu.org/licenses/>.
26 from iotests
import qemu_img
, qemu_io
, create_image
28 backing_img
= os
.path
.join(iotests
.test_dir
, 'backing.img')
29 test_img
= os
.path
.join(iotests
.test_dir
, 'test.img')
30 target_img
= os
.path
.join(iotests
.test_dir
, 'target.img')
32 def img_create(img
, fmt
=iotests
.imgfmt
, size
='64M', **kwargs
):
33 fullname
= os
.path
.join(iotests
.test_dir
, '%s.%s' % (img
, fmt
))
35 for k
,v
in kwargs
.items():
36 optargs
= optargs
+ ['-o', '%s=%s' % (k
,v
)]
37 args
= ['create', '-f', fmt
] + optargs
+ [fullname
, size
]
38 iotests
.qemu_img(*args
)
47 def io_write_patterns(img
, patterns
):
48 for pattern
in patterns
:
49 iotests
.qemu_io('-c', 'write -P%s %s %s' % pattern
, img
)
52 class TestSyncModesNoneAndTop(iotests
.QMPTestCase
):
53 image_len
= 64 * 1024 * 1024 # MB
56 create_image(backing_img
, TestSyncModesNoneAndTop
.image_len
)
57 qemu_img('create', '-f', iotests
.imgfmt
,
58 '-o', 'backing_file=%s' % backing_img
, '-F', 'raw', test_img
)
59 qemu_io('-c', 'write -P0x41 0 512', test_img
)
60 qemu_io('-c', 'write -P0xd5 1M 32k', test_img
)
61 qemu_io('-c', 'write -P0xdc 32M 124k', test_img
)
62 qemu_io('-c', 'write -P0xdc 67043328 64k', test_img
)
63 self
.vm
= iotests
.VM().add_drive(test_img
)
69 os
.remove(backing_img
)
75 def test_complete_top(self
):
76 self
.assert_no_active_block_jobs()
77 result
= self
.vm
.qmp('drive-backup', device
='drive0', sync
='top',
78 format
=iotests
.imgfmt
, target
=target_img
)
79 self
.assert_qmp(result
, 'return', {})
81 self
.wait_until_completed(check_offset
=False)
83 self
.assert_no_active_block_jobs()
85 self
.assertTrue(iotests
.compare_images(test_img
, target_img
),
86 'target image does not match source after backup')
88 def test_cancel_sync_none(self
):
89 self
.assert_no_active_block_jobs()
91 result
= self
.vm
.qmp('drive-backup', device
='drive0',
92 sync
='none', target
=target_img
)
93 self
.assert_qmp(result
, 'return', {})
95 self
.vm
.hmp_qemu_io('drive0', 'write -P0x5e 0 512')
96 self
.vm
.hmp_qemu_io('drive0', 'aio_flush')
97 # Verify that the original contents exist in the target image.
99 event
= self
.cancel_and_wait()
100 self
.assert_qmp(event
, 'data/type', 'backup')
104 self
.assertEqual(-1, qemu_io('-c', 'read -P0x41 0 512', target_img
).find("verification failed"))
106 class TestBeforeWriteNotifier(iotests
.QMPTestCase
):
108 self
.vm
= iotests
.VM().add_drive_raw("file=blkdebug::null-co://,id=drive0,align=65536,driver=blkdebug")
113 os
.remove(target_img
)
115 def test_before_write_notifier(self
):
116 self
.vm
.pause_drive("drive0")
117 result
= self
.vm
.qmp('drive-backup', device
='drive0',
118 sync
='full', target
=target_img
,
119 format
="file", speed
=1)
120 self
.assert_qmp(result
, 'return', {})
121 result
= self
.vm
.qmp('block-job-pause', device
="drive0")
122 self
.assert_qmp(result
, 'return', {})
123 # Speed is low enough that this must be an uncopied range, which will
124 # trigger the before write notifier
125 self
.vm
.hmp_qemu_io('drive0', 'aio_write -P 1 512512 512')
126 self
.vm
.resume_drive("drive0")
127 result
= self
.vm
.qmp('block-job-resume', device
="drive0")
128 self
.assert_qmp(result
, 'return', {})
129 event
= self
.cancel_and_wait()
130 self
.assert_qmp(event
, 'data/type', 'backup')
132 class BackupTest(iotests
.QMPTestCase
):
134 self
.vm
= iotests
.VM()
135 self
.test_img
= img_create('test')
136 self
.dest_img
= img_create('dest')
137 self
.dest_img2
= img_create('dest2')
138 self
.ref_img
= img_create('ref')
139 self
.vm
.add_drive(self
.test_img
)
144 try_remove(self
.test_img
)
145 try_remove(self
.dest_img
)
146 try_remove(self
.dest_img2
)
147 try_remove(self
.ref_img
)
149 def hmp_io_writes(self
, drive
, patterns
):
150 for pattern
in patterns
:
151 self
.vm
.hmp_qemu_io(drive
, 'write -P%s %s %s' % pattern
)
152 self
.vm
.hmp_qemu_io(drive
, 'flush')
154 def qmp_backup_and_wait(self
, cmd
='drive-backup', serror
=None,
155 aerror
=None, **kwargs
):
156 if not self
.qmp_backup(cmd
, serror
, **kwargs
):
158 return self
.qmp_backup_wait(kwargs
['device'], aerror
)
160 def qmp_backup(self
, cmd
='drive-backup',
161 error
=None, **kwargs
):
162 self
.assertTrue('device' in kwargs
)
163 res
= self
.vm
.qmp(cmd
, **kwargs
)
165 self
.assert_qmp(res
, 'error/desc', error
)
167 self
.assert_qmp(res
, 'return', {})
170 def qmp_backup_wait(self
, device
, error
=None):
171 event
= self
.vm
.event_wait(name
="BLOCK_JOB_COMPLETED",
172 match
={'data': {'device': device
}})
173 self
.assertNotEqual(event
, None)
175 failure
= self
.dictpath(event
, 'data/error')
176 except AssertionError:
178 self
.assert_qmp(event
, 'data/offset', event
['data']['len'])
182 self
.assert_qmp(event
, 'data/error', qerror
)
185 def test_overlapping_writes(self
):
186 # Write something to back up
187 self
.hmp_io_writes('drive0', [('42', '0M', '2M')])
189 # Create a reference backup
190 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
191 sync
='full', target
=self
.ref_img
,
193 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
194 self
.assert_qmp(res
, 'return', {})
196 # Now to the test backup: We simulate the following guest
198 # (1) [1M + 64k, 1M + 128k): Afterwards, everything in that
199 # area should be in the target image, and we must not copy
200 # it again (because the source image has changed now)
201 # (64k is the job's cluster size)
202 # (2) [1M, 2M): The backup job must not get overeager. It
203 # must copy [1M, 1M + 64k) and [1M + 128k, 2M) separately,
204 # but not the area in between.
206 self
.qmp_backup(device
='drive0', format
=iotests
.imgfmt
, sync
='full',
207 target
=self
.dest_img
, speed
=1, auto_dismiss
=False)
209 self
.hmp_io_writes('drive0', [('23', '%ik' % (1024 + 64), '64k'),
212 # Let the job complete
213 res
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=0)
214 self
.assert_qmp(res
, 'return', {})
215 self
.qmp_backup_wait('drive0')
216 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
217 self
.assert_qmp(res
, 'return', {})
219 self
.assertTrue(iotests
.compare_images(self
.ref_img
, self
.dest_img
),
220 'target image does not match reference image')
222 def test_dismiss_false(self
):
223 res
= self
.vm
.qmp('query-block-jobs')
224 self
.assert_qmp(res
, 'return', [])
225 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
226 sync
='full', target
=self
.dest_img
,
228 res
= self
.vm
.qmp('query-block-jobs')
229 self
.assert_qmp(res
, 'return', [])
231 def test_dismiss_true(self
):
232 res
= self
.vm
.qmp('query-block-jobs')
233 self
.assert_qmp(res
, 'return', [])
234 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
235 sync
='full', target
=self
.dest_img
,
237 res
= self
.vm
.qmp('query-block-jobs')
238 self
.assert_qmp(res
, 'return[0]/status', 'concluded')
239 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
240 self
.assert_qmp(res
, 'return', {})
241 res
= self
.vm
.qmp('query-block-jobs')
242 self
.assert_qmp(res
, 'return', [])
244 def test_dismiss_bad_id(self
):
245 res
= self
.vm
.qmp('query-block-jobs')
246 self
.assert_qmp(res
, 'return', [])
247 res
= self
.vm
.qmp('block-job-dismiss', id='foobar')
248 self
.assert_qmp(res
, 'error/class', 'DeviceNotActive')
250 def test_dismiss_collision(self
):
251 res
= self
.vm
.qmp('query-block-jobs')
252 self
.assert_qmp(res
, 'return', [])
253 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
254 sync
='full', target
=self
.dest_img
,
256 res
= self
.vm
.qmp('query-block-jobs')
257 self
.assert_qmp(res
, 'return[0]/status', 'concluded')
258 # Leave zombie job un-dismissed, observe a failure:
259 res
= self
.qmp_backup_and_wait(serror
="Job ID 'drive0' already in use",
260 device
='drive0', format
=iotests
.imgfmt
,
261 sync
='full', target
=self
.dest_img2
,
263 self
.assertEqual(res
, False)
264 # OK, dismiss the zombie.
265 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
266 self
.assert_qmp(res
, 'return', {})
267 res
= self
.vm
.qmp('query-block-jobs')
268 self
.assert_qmp(res
, 'return', [])
269 # Ensure it's really gone.
270 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
271 sync
='full', target
=self
.dest_img2
,
274 def dismissal_failure(self
, dismissal_opt
):
275 res
= self
.vm
.qmp('query-block-jobs')
276 self
.assert_qmp(res
, 'return', [])
277 # Give blkdebug something to chew on
278 self
.hmp_io_writes('drive0',
280 ('0x55', '8M', '352k'),
281 ('0x78', '15872k', '1M')))
282 # Add destination node via blkdebug
283 res
= self
.vm
.qmp('blockdev-add',
285 driver
=iotests
.imgfmt
,
287 'driver': 'blkdebug',
290 'filename': self
.dest_img
293 'event': 'write_aio',
295 'immediately': False,
299 self
.assert_qmp(res
, 'return', {})
301 res
= self
.qmp_backup(cmd
='blockdev-backup',
302 device
='drive0', target
='target0',
303 on_target_error
='stop',
305 auto_dismiss
=dismissal_opt
)
307 event
= self
.vm
.event_wait(name
="BLOCK_JOB_ERROR",
308 match
={'data': {'device': 'drive0'}})
309 self
.assertNotEqual(event
, None)
310 # OK, job should be wedged
311 res
= self
.vm
.qmp('query-block-jobs')
312 self
.assert_qmp(res
, 'return[0]/status', 'paused')
313 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
314 self
.assert_qmp(res
, 'error/desc',
315 "Job 'drive0' in state 'paused' cannot accept"
316 " command verb 'dismiss'")
317 res
= self
.vm
.qmp('query-block-jobs')
318 self
.assert_qmp(res
, 'return[0]/status', 'paused')
319 # OK, unstick job and move forward.
320 res
= self
.vm
.qmp('block-job-resume', device
='drive0')
321 self
.assert_qmp(res
, 'return', {})
322 # And now we need to wait for it to conclude;
323 res
= self
.qmp_backup_wait(device
='drive0')
325 if not dismissal_opt
:
326 # Job should now be languishing:
327 res
= self
.vm
.qmp('query-block-jobs')
328 self
.assert_qmp(res
, 'return[0]/status', 'concluded')
329 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
330 self
.assert_qmp(res
, 'return', {})
331 res
= self
.vm
.qmp('query-block-jobs')
332 self
.assert_qmp(res
, 'return', [])
334 def test_dismiss_premature(self
):
335 self
.dismissal_failure(False)
337 def test_dismiss_erroneous(self
):
338 self
.dismissal_failure(True)
340 if __name__
== '__main__':
341 iotests
.main(supported_fmts
=['qcow2', 'qed'],
342 supported_protocols
=['file'])