3 # Tests for drive-backup and blockdev-backup
5 # Copyright (C) 2013, 2014 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
28 test_img
= os
.path
.join(iotests
.test_dir
, 'test.img')
29 target_img
= os
.path
.join(iotests
.test_dir
, 'target.img')
30 blockdev_target_img
= os
.path
.join(iotests
.test_dir
, 'blockdev-target.img')
32 class TestSingleDrive(iotests
.QMPTestCase
):
33 image_len
= 64 * 1024 * 1024 # MB
36 # Write data to the image so we can compare later
37 qemu_img('create', '-f', iotests
.imgfmt
, test_img
, str(TestSingleDrive
.image_len
))
38 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P0x5d 0 64k', test_img
)
39 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P0xd5 1M 32k', test_img
)
40 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P0xdc 32M 124k', test_img
)
41 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P0xdc 67043328 64k', test_img
)
42 qemu_img('create', '-f', iotests
.imgfmt
, blockdev_target_img
, str(TestSingleDrive
.image_len
))
44 self
.vm
= iotests
.VM().add_drive(test_img
).add_drive(blockdev_target_img
)
50 os
.remove(blockdev_target_img
)
56 def do_test_cancel(self
, cmd
, target
):
57 self
.assert_no_active_block_jobs()
59 result
= self
.vm
.qmp(cmd
, device
='drive0', target
=target
, sync
='full')
60 self
.assert_qmp(result
, 'return', {})
62 event
= self
.cancel_and_wait()
63 self
.assert_qmp(event
, 'data/type', 'backup')
65 def test_cancel_drive_backup(self
):
66 self
.do_test_cancel('drive-backup', target_img
)
68 def test_cancel_blockdev_backup(self
):
69 self
.do_test_cancel('blockdev-backup', 'drive1')
71 def do_test_pause(self
, cmd
, target
, image
):
72 self
.assert_no_active_block_jobs()
74 self
.vm
.pause_drive('drive0')
75 result
= self
.vm
.qmp(cmd
, device
='drive0',
76 target
=target
, sync
='full')
77 self
.assert_qmp(result
, 'return', {})
79 result
= self
.vm
.qmp('block-job-pause', device
='drive0')
80 self
.assert_qmp(result
, 'return', {})
82 self
.vm
.resume_drive('drive0')
84 result
= self
.vm
.qmp('query-block-jobs')
85 offset
= self
.dictpath(result
, 'return[0]/offset')
88 result
= self
.vm
.qmp('query-block-jobs')
89 self
.assert_qmp(result
, 'return[0]/offset', offset
)
91 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
92 self
.assert_qmp(result
, 'return', {})
94 self
.wait_until_completed()
97 self
.assertTrue(iotests
.compare_images(test_img
, image
),
98 'target image does not match source after backup')
100 def test_pause_drive_backup(self
):
101 self
.do_test_pause('drive-backup', target_img
, target_img
)
103 def test_pause_blockdev_backup(self
):
104 self
.do_test_pause('blockdev-backup', 'drive1', blockdev_target_img
)
106 def test_medium_not_found(self
):
107 result
= self
.vm
.qmp('drive-backup', device
='ide1-cd0',
108 target
=target_img
, sync
='full')
109 self
.assert_qmp(result
, 'error/class', 'GenericError')
111 def test_medium_not_found_blockdev_backup(self
):
112 result
= self
.vm
.qmp('blockdev-backup', device
='ide1-cd0',
113 target
='drive1', sync
='full')
114 self
.assert_qmp(result
, 'error/class', 'GenericError')
116 def test_image_not_found(self
):
117 result
= self
.vm
.qmp('drive-backup', device
='drive0',
118 target
=target_img
, sync
='full', mode
='existing')
119 self
.assert_qmp(result
, 'error/class', 'GenericError')
121 def test_invalid_format(self
):
122 result
= self
.vm
.qmp('drive-backup', device
='drive0',
123 target
=target_img
, sync
='full',
124 format
='spaghetti-noodles')
125 self
.assert_qmp(result
, 'error/class', 'GenericError')
127 def do_test_device_not_found(self
, cmd
, **args
):
128 result
= self
.vm
.qmp(cmd
, **args
)
129 self
.assert_qmp(result
, 'error/class', 'DeviceNotFound')
131 def test_device_not_found(self
):
132 self
.do_test_device_not_found('drive-backup', device
='nonexistent',
133 target
=target_img
, sync
='full')
135 self
.do_test_device_not_found('blockdev-backup', device
='nonexistent',
136 target
='drive0', sync
='full')
138 self
.do_test_device_not_found('blockdev-backup', device
='drive0',
139 target
='nonexistent', sync
='full')
141 self
.do_test_device_not_found('blockdev-backup', device
='nonexistent',
142 target
='nonexistent', sync
='full')
144 def test_target_is_source(self
):
145 result
= self
.vm
.qmp('blockdev-backup', device
='drive0',
146 target
='drive0', sync
='full')
147 self
.assert_qmp(result
, 'error/class', 'GenericError')
149 class TestSetSpeed(iotests
.QMPTestCase
):
150 image_len
= 80 * 1024 * 1024 # MB
153 qemu_img('create', '-f', iotests
.imgfmt
, test_img
, str(TestSetSpeed
.image_len
))
154 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P1 0 512', test_img
)
155 qemu_img('create', '-f', iotests
.imgfmt
, blockdev_target_img
, str(TestSingleDrive
.image_len
))
157 self
.vm
= iotests
.VM().add_drive(test_img
).add_drive(blockdev_target_img
)
163 os
.remove(blockdev_target_img
)
165 os
.remove(target_img
)
169 def do_test_set_speed(self
, cmd
, target
):
170 self
.assert_no_active_block_jobs()
172 self
.vm
.pause_drive('drive0')
173 result
= self
.vm
.qmp(cmd
, device
='drive0', target
=target
, sync
='full')
174 self
.assert_qmp(result
, 'return', {})
177 result
= self
.vm
.qmp('query-block-jobs')
178 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
179 self
.assert_qmp(result
, 'return[0]/speed', 0)
181 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=8 * 1024 * 1024)
182 self
.assert_qmp(result
, 'return', {})
184 # Ensure the speed we set was accepted
185 result
= self
.vm
.qmp('query-block-jobs')
186 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
187 self
.assert_qmp(result
, 'return[0]/speed', 8 * 1024 * 1024)
189 event
= self
.cancel_and_wait(resume
=True)
190 self
.assert_qmp(event
, 'data/type', 'backup')
192 # Check setting speed option works
193 self
.vm
.pause_drive('drive0')
194 result
= self
.vm
.qmp(cmd
, device
='drive0',
195 target
=target
, sync
='full', speed
=4*1024*1024)
196 self
.assert_qmp(result
, 'return', {})
198 result
= self
.vm
.qmp('query-block-jobs')
199 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
200 self
.assert_qmp(result
, 'return[0]/speed', 4 * 1024 * 1024)
202 event
= self
.cancel_and_wait(resume
=True)
203 self
.assert_qmp(event
, 'data/type', 'backup')
205 def test_set_speed_drive_backup(self
):
206 self
.do_test_set_speed('drive-backup', target_img
)
208 def test_set_speed_blockdev_backup(self
):
209 self
.do_test_set_speed('blockdev-backup', 'drive1')
211 def do_test_set_speed_invalid(self
, cmd
, target
):
212 self
.assert_no_active_block_jobs()
214 result
= self
.vm
.qmp(cmd
, device
='drive0',
215 target
=target
, sync
='full', speed
=-1)
216 self
.assert_qmp(result
, 'error/class', 'GenericError')
218 self
.assert_no_active_block_jobs()
220 self
.vm
.pause_drive('drive0')
221 result
= self
.vm
.qmp(cmd
, device
='drive0',
222 target
=target
, sync
='full')
223 self
.assert_qmp(result
, 'return', {})
225 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=-1)
226 self
.assert_qmp(result
, 'error/class', 'GenericError')
228 event
= self
.cancel_and_wait(resume
=True)
229 self
.assert_qmp(event
, 'data/type', 'backup')
231 def test_set_speed_invalid_drive_backup(self
):
232 self
.do_test_set_speed_invalid('drive-backup', target_img
)
234 def test_set_speed_invalid_blockdev_backup(self
):
235 self
.do_test_set_speed_invalid('blockdev-backup', 'drive1')
237 class TestSingleTransaction(iotests
.QMPTestCase
):
238 image_len
= 64 * 1024 * 1024 # MB
241 qemu_img('create', '-f', iotests
.imgfmt
, test_img
, str(TestSingleTransaction
.image_len
))
242 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P0x5d 0 64k', test_img
)
243 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P0xd5 1M 32k', test_img
)
244 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P0xdc 32M 124k', test_img
)
245 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P0xdc 67043328 64k', test_img
)
246 qemu_img('create', '-f', iotests
.imgfmt
, blockdev_target_img
, str(TestSingleDrive
.image_len
))
248 self
.vm
= iotests
.VM().add_drive(test_img
).add_drive(blockdev_target_img
)
254 os
.remove(blockdev_target_img
)
256 os
.remove(target_img
)
260 def do_test_cancel(self
, cmd
, target
):
261 self
.assert_no_active_block_jobs()
263 result
= self
.vm
.qmp('transaction', actions
=[{
265 'data': { 'device': 'drive0',
271 self
.assert_qmp(result
, 'return', {})
273 event
= self
.cancel_and_wait()
274 self
.assert_qmp(event
, 'data/type', 'backup')
276 def test_cancel_drive_backup(self
):
277 self
.do_test_cancel('drive-backup', target_img
)
279 def test_cancel_blockdev_backup(self
):
280 self
.do_test_cancel('blockdev-backup', 'drive1')
282 def do_test_pause(self
, cmd
, target
, image
):
283 self
.assert_no_active_block_jobs()
285 self
.vm
.pause_drive('drive0')
286 result
= self
.vm
.qmp('transaction', actions
=[{
288 'data': { 'device': 'drive0',
293 self
.assert_qmp(result
, 'return', {})
295 result
= self
.vm
.qmp('block-job-pause', device
='drive0')
296 self
.assert_qmp(result
, 'return', {})
298 self
.vm
.resume_drive('drive0')
300 result
= self
.vm
.qmp('query-block-jobs')
301 offset
= self
.dictpath(result
, 'return[0]/offset')
304 result
= self
.vm
.qmp('query-block-jobs')
305 self
.assert_qmp(result
, 'return[0]/offset', offset
)
307 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
308 self
.assert_qmp(result
, 'return', {})
310 self
.wait_until_completed()
313 self
.assertTrue(iotests
.compare_images(test_img
, image
),
314 'target image does not match source after backup')
316 def test_pause_drive_backup(self
):
317 self
.do_test_pause('drive-backup', target_img
, target_img
)
319 def test_pause_blockdev_backup(self
):
320 self
.do_test_pause('blockdev-backup', 'drive1', blockdev_target_img
)
322 def do_test_medium_not_found(self
, cmd
, target
):
323 result
= self
.vm
.qmp('transaction', actions
=[{
325 'data': { 'device': 'ide1-cd0',
330 self
.assert_qmp(result
, 'error/class', 'GenericError')
332 def test_medium_not_found_drive_backup(self
):
333 self
.do_test_medium_not_found('drive-backup', target_img
)
335 def test_medium_not_found_blockdev_backup(self
):
336 self
.do_test_medium_not_found('blockdev-backup', 'drive1')
338 def test_image_not_found(self
):
339 result
= self
.vm
.qmp('transaction', actions
=[{
340 'type': 'drive-backup',
341 'data': { 'device': 'drive0',
343 'target': target_img
,
347 self
.assert_qmp(result
, 'error/class', 'GenericError')
349 def test_device_not_found(self
):
350 result
= self
.vm
.qmp('transaction', actions
=[{
351 'type': 'drive-backup',
352 'data': { 'device': 'nonexistent',
354 'target': target_img
,
358 self
.assert_qmp(result
, 'error/class', 'DeviceNotFound')
360 result
= self
.vm
.qmp('transaction', actions
=[{
361 'type': 'blockdev-backup',
362 'data': { 'device': 'nonexistent',
367 self
.assert_qmp(result
, 'error/class', 'DeviceNotFound')
369 result
= self
.vm
.qmp('transaction', actions
=[{
370 'type': 'blockdev-backup',
371 'data': { 'device': 'drive0',
372 'target': 'nonexistent',
376 self
.assert_qmp(result
, 'error/class', 'DeviceNotFound')
378 result
= self
.vm
.qmp('transaction', actions
=[{
379 'type': 'blockdev-backup',
380 'data': { 'device': 'nonexistent',
381 'target': 'nonexistent',
385 self
.assert_qmp(result
, 'error/class', 'DeviceNotFound')
387 def test_target_is_source(self
):
388 result
= self
.vm
.qmp('transaction', actions
=[{
389 'type': 'blockdev-backup',
390 'data': { 'device': 'drive0',
395 self
.assert_qmp(result
, 'error/class', 'GenericError')
397 def test_abort(self
):
398 result
= self
.vm
.qmp('transaction', actions
=[{
399 'type': 'drive-backup',
400 'data': { 'device': 'nonexistent',
402 'target': target_img
,
409 self
.assert_qmp(result
, 'error/class', 'GenericError')
410 self
.assert_no_active_block_jobs()
412 result
= self
.vm
.qmp('transaction', actions
=[{
413 'type': 'blockdev-backup',
414 'data': { 'device': 'nonexistent',
422 self
.assert_qmp(result
, 'error/class', 'GenericError')
423 self
.assert_no_active_block_jobs()
425 result
= self
.vm
.qmp('transaction', actions
=[{
426 'type': 'blockdev-backup',
427 'data': { 'device': 'drive0',
428 'target': 'nonexistent',
435 self
.assert_qmp(result
, 'error/class', 'GenericError')
436 self
.assert_no_active_block_jobs()
438 if __name__
== '__main__':
439 iotests
.main(supported_fmts
=['raw', 'qcow2'])