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
, '-o', 'backing_file=%s' % backing_img
, test_img
)
58 qemu_io('-c', 'write -P0x41 0 512', test_img
)
59 qemu_io('-c', 'write -P0xd5 1M 32k', test_img
)
60 qemu_io('-c', 'write -P0xdc 32M 124k', test_img
)
61 qemu_io('-c', 'write -P0xdc 67043328 64k', test_img
)
62 self
.vm
= iotests
.VM().add_drive(test_img
)
68 os
.remove(backing_img
)
74 def test_complete_top(self
):
75 self
.assert_no_active_block_jobs()
76 result
= self
.vm
.qmp('drive-backup', device
='drive0', sync
='top',
77 format
=iotests
.imgfmt
, target
=target_img
)
78 self
.assert_qmp(result
, 'return', {})
80 self
.wait_until_completed(check_offset
=False)
82 self
.assert_no_active_block_jobs()
84 self
.assertTrue(iotests
.compare_images(test_img
, target_img
),
85 'target image does not match source after backup')
87 def test_cancel_sync_none(self
):
88 self
.assert_no_active_block_jobs()
90 result
= self
.vm
.qmp('drive-backup', device
='drive0',
91 sync
='none', target
=target_img
)
92 self
.assert_qmp(result
, 'return', {})
94 self
.vm
.hmp_qemu_io('drive0', 'write -P0x5e 0 512')
95 self
.vm
.hmp_qemu_io('drive0', 'aio_flush')
96 # Verify that the original contents exist in the target image.
98 event
= self
.cancel_and_wait()
99 self
.assert_qmp(event
, 'data/type', 'backup')
103 self
.assertEqual(-1, qemu_io('-c', 'read -P0x41 0 512', target_img
).find("verification failed"))
105 class TestBeforeWriteNotifier(iotests
.QMPTestCase
):
107 self
.vm
= iotests
.VM().add_drive_raw("file=blkdebug::null-co://,id=drive0,align=65536,driver=blkdebug")
112 os
.remove(target_img
)
114 def test_before_write_notifier(self
):
115 self
.vm
.pause_drive("drive0")
116 result
= self
.vm
.qmp('drive-backup', device
='drive0',
117 sync
='full', target
=target_img
,
118 format
="file", speed
=1)
119 self
.assert_qmp(result
, 'return', {})
120 result
= self
.vm
.qmp('block-job-pause', device
="drive0")
121 self
.assert_qmp(result
, 'return', {})
122 # Speed is low enough that this must be an uncopied range, which will
123 # trigger the before write notifier
124 self
.vm
.hmp_qemu_io('drive0', 'aio_write -P 1 512512 512')
125 self
.vm
.resume_drive("drive0")
126 result
= self
.vm
.qmp('block-job-resume', device
="drive0")
127 self
.assert_qmp(result
, 'return', {})
128 event
= self
.cancel_and_wait()
129 self
.assert_qmp(event
, 'data/type', 'backup')
131 class BackupTest(iotests
.QMPTestCase
):
133 self
.vm
= iotests
.VM()
134 self
.test_img
= img_create('test')
135 self
.dest_img
= img_create('dest')
136 self
.dest_img2
= img_create('dest2')
137 self
.ref_img
= img_create('ref')
138 self
.vm
.add_drive(self
.test_img
)
143 try_remove(self
.test_img
)
144 try_remove(self
.dest_img
)
145 try_remove(self
.dest_img2
)
146 try_remove(self
.ref_img
)
148 def hmp_io_writes(self
, drive
, patterns
):
149 for pattern
in patterns
:
150 self
.vm
.hmp_qemu_io(drive
, 'write -P%s %s %s' % pattern
)
151 self
.vm
.hmp_qemu_io(drive
, 'flush')
153 def qmp_backup_and_wait(self
, cmd
='drive-backup', serror
=None,
154 aerror
=None, **kwargs
):
155 if not self
.qmp_backup(cmd
, serror
, **kwargs
):
157 return self
.qmp_backup_wait(kwargs
['device'], aerror
)
159 def qmp_backup(self
, cmd
='drive-backup',
160 error
=None, **kwargs
):
161 self
.assertTrue('device' in kwargs
)
162 res
= self
.vm
.qmp(cmd
, **kwargs
)
164 self
.assert_qmp(res
, 'error/desc', error
)
166 self
.assert_qmp(res
, 'return', {})
169 def qmp_backup_wait(self
, device
, error
=None):
170 event
= self
.vm
.event_wait(name
="BLOCK_JOB_COMPLETED",
171 match
={'data': {'device': device
}})
172 self
.assertNotEqual(event
, None)
174 failure
= self
.dictpath(event
, 'data/error')
175 except AssertionError:
177 self
.assert_qmp(event
, 'data/offset', event
['data']['len'])
181 self
.assert_qmp(event
, 'data/error', qerror
)
184 def test_overlapping_writes(self
):
185 # Write something to back up
186 self
.hmp_io_writes('drive0', [('42', '0M', '2M')])
188 # Create a reference backup
189 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
190 sync
='full', target
=self
.ref_img
,
192 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
193 self
.assert_qmp(res
, 'return', {})
195 # Now to the test backup: We simulate the following guest
197 # (1) [1M + 64k, 1M + 128k): Afterwards, everything in that
198 # area should be in the target image, and we must not copy
199 # it again (because the source image has changed now)
200 # (64k is the job's cluster size)
201 # (2) [1M, 2M): The backup job must not get overeager. It
202 # must copy [1M, 1M + 64k) and [1M + 128k, 2M) separately,
203 # but not the area in between.
205 self
.qmp_backup(device
='drive0', format
=iotests
.imgfmt
, sync
='full',
206 target
=self
.dest_img
, speed
=1, auto_dismiss
=False)
208 self
.hmp_io_writes('drive0', [('23', '%ik' % (1024 + 64), '64k'),
211 # Let the job complete
212 res
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=0)
213 self
.assert_qmp(res
, 'return', {})
214 self
.qmp_backup_wait('drive0')
215 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
216 self
.assert_qmp(res
, 'return', {})
218 self
.assertTrue(iotests
.compare_images(self
.ref_img
, self
.dest_img
),
219 'target image does not match reference image')
221 def test_dismiss_false(self
):
222 res
= self
.vm
.qmp('query-block-jobs')
223 self
.assert_qmp(res
, 'return', [])
224 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
225 sync
='full', target
=self
.dest_img
,
227 res
= self
.vm
.qmp('query-block-jobs')
228 self
.assert_qmp(res
, 'return', [])
230 def test_dismiss_true(self
):
231 res
= self
.vm
.qmp('query-block-jobs')
232 self
.assert_qmp(res
, 'return', [])
233 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
234 sync
='full', target
=self
.dest_img
,
236 res
= self
.vm
.qmp('query-block-jobs')
237 self
.assert_qmp(res
, 'return[0]/status', 'concluded')
238 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
239 self
.assert_qmp(res
, 'return', {})
240 res
= self
.vm
.qmp('query-block-jobs')
241 self
.assert_qmp(res
, 'return', [])
243 def test_dismiss_bad_id(self
):
244 res
= self
.vm
.qmp('query-block-jobs')
245 self
.assert_qmp(res
, 'return', [])
246 res
= self
.vm
.qmp('block-job-dismiss', id='foobar')
247 self
.assert_qmp(res
, 'error/class', 'DeviceNotActive')
249 def test_dismiss_collision(self
):
250 res
= self
.vm
.qmp('query-block-jobs')
251 self
.assert_qmp(res
, 'return', [])
252 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
253 sync
='full', target
=self
.dest_img
,
255 res
= self
.vm
.qmp('query-block-jobs')
256 self
.assert_qmp(res
, 'return[0]/status', 'concluded')
257 # Leave zombie job un-dismissed, observe a failure:
258 res
= self
.qmp_backup_and_wait(serror
="Job ID 'drive0' already in use",
259 device
='drive0', format
=iotests
.imgfmt
,
260 sync
='full', target
=self
.dest_img2
,
262 self
.assertEqual(res
, False)
263 # OK, dismiss the zombie.
264 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
265 self
.assert_qmp(res
, 'return', {})
266 res
= self
.vm
.qmp('query-block-jobs')
267 self
.assert_qmp(res
, 'return', [])
268 # Ensure it's really gone.
269 self
.qmp_backup_and_wait(device
='drive0', format
=iotests
.imgfmt
,
270 sync
='full', target
=self
.dest_img2
,
273 def dismissal_failure(self
, dismissal_opt
):
274 res
= self
.vm
.qmp('query-block-jobs')
275 self
.assert_qmp(res
, 'return', [])
276 # Give blkdebug something to chew on
277 self
.hmp_io_writes('drive0',
279 ('0x55', '8M', '352k'),
280 ('0x78', '15872k', '1M')))
281 # Add destination node via blkdebug
282 res
= self
.vm
.qmp('blockdev-add',
284 driver
=iotests
.imgfmt
,
286 'driver': 'blkdebug',
289 'filename': self
.dest_img
292 'event': 'write_aio',
294 'immediately': False,
298 self
.assert_qmp(res
, 'return', {})
300 res
= self
.qmp_backup(cmd
='blockdev-backup',
301 device
='drive0', target
='target0',
302 on_target_error
='stop',
304 auto_dismiss
=dismissal_opt
)
306 event
= self
.vm
.event_wait(name
="BLOCK_JOB_ERROR",
307 match
={'data': {'device': 'drive0'}})
308 self
.assertNotEqual(event
, None)
309 # OK, job should be wedged
310 res
= self
.vm
.qmp('query-block-jobs')
311 self
.assert_qmp(res
, 'return[0]/status', 'paused')
312 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
313 self
.assert_qmp(res
, 'error/desc',
314 "Job 'drive0' in state 'paused' cannot accept"
315 " command verb 'dismiss'")
316 res
= self
.vm
.qmp('query-block-jobs')
317 self
.assert_qmp(res
, 'return[0]/status', 'paused')
318 # OK, unstick job and move forward.
319 res
= self
.vm
.qmp('block-job-resume', device
='drive0')
320 self
.assert_qmp(res
, 'return', {})
321 # And now we need to wait for it to conclude;
322 res
= self
.qmp_backup_wait(device
='drive0')
324 if not dismissal_opt
:
325 # Job should now be languishing:
326 res
= self
.vm
.qmp('query-block-jobs')
327 self
.assert_qmp(res
, 'return[0]/status', 'concluded')
328 res
= self
.vm
.qmp('block-job-dismiss', id='drive0')
329 self
.assert_qmp(res
, 'return', {})
330 res
= self
.vm
.qmp('query-block-jobs')
331 self
.assert_qmp(res
, 'return', [])
333 def test_dismiss_premature(self
):
334 self
.dismissal_failure(False)
336 def test_dismiss_erroneous(self
):
337 self
.dismissal_failure(True)
339 if __name__
== '__main__':
340 iotests
.main(supported_fmts
=['qcow2', 'qed'],
341 supported_protocols
=['file'])