3 # Tests for image streaming.
5 # Copyright (C) 2012 IBM Corp.
7 # This program is free software; you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation; either version 2 of the License, or
10 # (at your option) any later version.
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU General Public License for more details.
17 # You should have received a copy of the GNU General Public License
18 # along with this program. If not, see <http://www.gnu.org/licenses/>.
24 from iotests
import qemu_img
, qemu_io
26 backing_img
= os
.path
.join(iotests
.test_dir
, 'backing.img')
27 mid_img
= os
.path
.join(iotests
.test_dir
, 'mid.img')
28 test_img
= os
.path
.join(iotests
.test_dir
, 'test.img')
30 class TestSingleDrive(iotests
.QMPTestCase
):
31 image_len
= 1 * 1024 * 1024 # MB
34 iotests
.create_image(backing_img
, TestSingleDrive
.image_len
)
35 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, mid_img
)
36 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % mid_img
, test_img
)
37 qemu_io('-c', 'write -P 0x1 0 512', backing_img
)
38 self
.vm
= iotests
.VM().add_drive(test_img
)
45 os
.remove(backing_img
)
47 def test_stream(self
):
48 self
.assert_no_active_block_jobs()
50 result
= self
.vm
.qmp('block-stream', device
='drive0')
51 self
.assert_qmp(result
, 'return', {})
55 for event
in self
.vm
.get_qmp_events(wait
=True):
56 if event
['event'] == 'BLOCK_JOB_COMPLETED':
57 self
.assert_qmp(event
, 'data/type', 'stream')
58 self
.assert_qmp(event
, 'data/device', 'drive0')
59 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
60 self
.assert_qmp(event
, 'data/len', self
.image_len
)
63 self
.assert_no_active_block_jobs()
66 self
.assertEqual(qemu_io('-c', 'map', backing_img
),
67 qemu_io('-c', 'map', test_img
),
68 'image file map does not match backing file after streaming')
70 def test_stream_pause(self
):
71 self
.assert_no_active_block_jobs()
73 self
.vm
.pause_drive('drive0')
74 result
= self
.vm
.qmp('block-stream', device
='drive0')
75 self
.assert_qmp(result
, 'return', {})
77 result
= self
.vm
.qmp('block-job-pause', device
='drive0')
78 self
.assert_qmp(result
, 'return', {})
81 result
= self
.vm
.qmp('query-block-jobs')
82 offset
= self
.dictpath(result
, 'return[0]/offset')
85 result
= self
.vm
.qmp('query-block-jobs')
86 self
.assert_qmp(result
, 'return[0]/offset', offset
)
88 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
89 self
.assert_qmp(result
, 'return', {})
91 self
.vm
.resume_drive('drive0')
94 for event
in self
.vm
.get_qmp_events(wait
=True):
95 if event
['event'] == 'BLOCK_JOB_COMPLETED':
96 self
.assert_qmp(event
, 'data/type', 'stream')
97 self
.assert_qmp(event
, 'data/device', 'drive0')
98 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
99 self
.assert_qmp(event
, 'data/len', self
.image_len
)
102 self
.assert_no_active_block_jobs()
105 self
.assertEqual(qemu_io('-c', 'map', backing_img
),
106 qemu_io('-c', 'map', test_img
),
107 'image file map does not match backing file after streaming')
109 def test_stream_partial(self
):
110 self
.assert_no_active_block_jobs()
112 result
= self
.vm
.qmp('block-stream', device
='drive0', base
=mid_img
)
113 self
.assert_qmp(result
, 'return', {})
117 for event
in self
.vm
.get_qmp_events(wait
=True):
118 if event
['event'] == 'BLOCK_JOB_COMPLETED':
119 self
.assert_qmp(event
, 'data/type', 'stream')
120 self
.assert_qmp(event
, 'data/device', 'drive0')
121 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
122 self
.assert_qmp(event
, 'data/len', self
.image_len
)
125 self
.assert_no_active_block_jobs()
128 self
.assertEqual(qemu_io('-c', 'map', mid_img
),
129 qemu_io('-c', 'map', test_img
),
130 'image file map does not match backing file after streaming')
132 def test_device_not_found(self
):
133 result
= self
.vm
.qmp('block-stream', device
='nonexistent')
134 self
.assert_qmp(result
, 'error/class', 'DeviceNotFound')
137 class TestSmallerBackingFile(iotests
.QMPTestCase
):
138 backing_len
= 1 * 1024 * 1024 # MB
139 image_len
= 2 * backing_len
142 iotests
.create_image(backing_img
, self
.backing_len
)
143 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, test_img
, str(self
.image_len
))
144 self
.vm
= iotests
.VM().add_drive(test_img
)
147 # If this hangs, then you are missing a fix to complete streaming when the
148 # end of the backing file is reached.
149 def test_stream(self
):
150 self
.assert_no_active_block_jobs()
152 result
= self
.vm
.qmp('block-stream', device
='drive0')
153 self
.assert_qmp(result
, 'return', {})
157 for event
in self
.vm
.get_qmp_events(wait
=True):
158 if event
['event'] == 'BLOCK_JOB_COMPLETED':
159 self
.assert_qmp(event
, 'data/type', 'stream')
160 self
.assert_qmp(event
, 'data/device', 'drive0')
161 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
162 self
.assert_qmp(event
, 'data/len', self
.image_len
)
165 self
.assert_no_active_block_jobs()
168 class TestErrors(iotests
.QMPTestCase
):
169 image_len
= 2 * 1024 * 1024 # MB
171 # this should match STREAM_BUFFER_SIZE/512 in block/stream.c
172 STREAM_BUFFER_SIZE
= 512 * 1024
174 def create_blkdebug_file(self
, name
, event
, errno
):
175 file = open(name
, 'w')
194 ''' % (event
, errno
, self
.STREAM_BUFFER_SIZE
/ 512, event
, event
))
197 class TestEIO(TestErrors
):
199 self
.blkdebug_file
= backing_img
+ ".blkdebug"
200 iotests
.create_image(backing_img
, TestErrors
.image_len
)
201 self
.create_blkdebug_file(self
.blkdebug_file
, "read_aio", 5)
202 qemu_img('create', '-f', iotests
.imgfmt
,
203 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
204 % (self
.blkdebug_file
, backing_img
),
206 self
.vm
= iotests
.VM().add_drive(test_img
)
212 os
.remove(backing_img
)
213 os
.remove(self
.blkdebug_file
)
215 def test_report(self
):
216 self
.assert_no_active_block_jobs()
218 result
= self
.vm
.qmp('block-stream', device
='drive0')
219 self
.assert_qmp(result
, 'return', {})
224 for event
in self
.vm
.get_qmp_events(wait
=True):
225 if event
['event'] == 'BLOCK_JOB_ERROR':
226 self
.assert_qmp(event
, 'data/device', 'drive0')
227 self
.assert_qmp(event
, 'data/operation', 'read')
229 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
230 self
.assertTrue(error
, 'job completed unexpectedly')
231 self
.assert_qmp(event
, 'data/type', 'stream')
232 self
.assert_qmp(event
, 'data/device', 'drive0')
233 self
.assert_qmp(event
, 'data/error', 'Input/output error')
234 self
.assert_qmp(event
, 'data/offset', self
.STREAM_BUFFER_SIZE
)
235 self
.assert_qmp(event
, 'data/len', self
.image_len
)
238 self
.assert_no_active_block_jobs()
241 def test_ignore(self
):
242 self
.assert_no_active_block_jobs()
244 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='ignore')
245 self
.assert_qmp(result
, 'return', {})
250 for event
in self
.vm
.get_qmp_events(wait
=True):
251 if event
['event'] == 'BLOCK_JOB_ERROR':
252 self
.assert_qmp(event
, 'data/device', 'drive0')
253 self
.assert_qmp(event
, 'data/operation', 'read')
254 result
= self
.vm
.qmp('query-block-jobs')
255 self
.assert_qmp(result
, 'return[0]/paused', False)
257 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
258 self
.assertTrue(error
, 'job completed unexpectedly')
259 self
.assert_qmp(event
, 'data/type', 'stream')
260 self
.assert_qmp(event
, 'data/device', 'drive0')
261 self
.assert_qmp(event
, 'data/error', 'Input/output error')
262 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
263 self
.assert_qmp(event
, 'data/len', self
.image_len
)
266 self
.assert_no_active_block_jobs()
270 self
.assert_no_active_block_jobs()
272 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='stop')
273 self
.assert_qmp(result
, 'return', {})
278 for event
in self
.vm
.get_qmp_events(wait
=True):
279 if event
['event'] == 'BLOCK_JOB_ERROR':
280 self
.assert_qmp(event
, 'data/device', 'drive0')
281 self
.assert_qmp(event
, 'data/operation', 'read')
283 result
= self
.vm
.qmp('query-block-jobs')
284 self
.assert_qmp(result
, 'return[0]/paused', True)
285 self
.assert_qmp(result
, 'return[0]/offset', self
.STREAM_BUFFER_SIZE
)
286 self
.assert_qmp(result
, 'return[0]/io-status', 'failed')
288 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
289 self
.assert_qmp(result
, 'return', {})
291 result
= self
.vm
.qmp('query-block-jobs')
292 self
.assert_qmp(result
, 'return[0]/paused', False)
293 self
.assert_qmp(result
, 'return[0]/io-status', 'ok')
295 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
296 self
.assertTrue(error
, 'job completed unexpectedly')
297 self
.assert_qmp(event
, 'data/type', 'stream')
298 self
.assert_qmp(event
, 'data/device', 'drive0')
299 self
.assert_qmp_absent(event
, 'data/error')
300 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
301 self
.assert_qmp(event
, 'data/len', self
.image_len
)
304 self
.assert_no_active_block_jobs()
307 def test_enospc(self
):
308 self
.assert_no_active_block_jobs()
310 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='enospc')
311 self
.assert_qmp(result
, 'return', {})
316 for event
in self
.vm
.get_qmp_events(wait
=True):
317 if event
['event'] == 'BLOCK_JOB_ERROR':
318 self
.assert_qmp(event
, 'data/device', 'drive0')
319 self
.assert_qmp(event
, 'data/operation', 'read')
321 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
322 self
.assertTrue(error
, 'job completed unexpectedly')
323 self
.assert_qmp(event
, 'data/type', 'stream')
324 self
.assert_qmp(event
, 'data/device', 'drive0')
325 self
.assert_qmp(event
, 'data/error', 'Input/output error')
326 self
.assert_qmp(event
, 'data/offset', self
.STREAM_BUFFER_SIZE
)
327 self
.assert_qmp(event
, 'data/len', self
.image_len
)
330 self
.assert_no_active_block_jobs()
333 class TestENOSPC(TestErrors
):
335 self
.blkdebug_file
= backing_img
+ ".blkdebug"
336 iotests
.create_image(backing_img
, TestErrors
.image_len
)
337 self
.create_blkdebug_file(self
.blkdebug_file
, "read_aio", 28)
338 qemu_img('create', '-f', iotests
.imgfmt
,
339 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
340 % (self
.blkdebug_file
, backing_img
),
342 self
.vm
= iotests
.VM().add_drive(test_img
)
348 os
.remove(backing_img
)
349 os
.remove(self
.blkdebug_file
)
351 def test_enospc(self
):
352 self
.assert_no_active_block_jobs()
354 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='enospc')
355 self
.assert_qmp(result
, 'return', {})
360 for event
in self
.vm
.get_qmp_events(wait
=True):
361 if event
['event'] == 'BLOCK_JOB_ERROR':
362 self
.assert_qmp(event
, 'data/device', 'drive0')
363 self
.assert_qmp(event
, 'data/operation', 'read')
365 result
= self
.vm
.qmp('query-block-jobs')
366 self
.assert_qmp(result
, 'return[0]/paused', True)
367 self
.assert_qmp(result
, 'return[0]/offset', self
.STREAM_BUFFER_SIZE
)
368 self
.assert_qmp(result
, 'return[0]/io-status', 'nospace')
370 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
371 self
.assert_qmp(result
, 'return', {})
373 result
= self
.vm
.qmp('query-block-jobs')
374 self
.assert_qmp(result
, 'return[0]/paused', False)
375 self
.assert_qmp(result
, 'return[0]/io-status', 'ok')
377 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
378 self
.assertTrue(error
, 'job completed unexpectedly')
379 self
.assert_qmp(event
, 'data/type', 'stream')
380 self
.assert_qmp(event
, 'data/device', 'drive0')
381 self
.assert_qmp_absent(event
, 'data/error')
382 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
383 self
.assert_qmp(event
, 'data/len', self
.image_len
)
386 self
.assert_no_active_block_jobs()
389 class TestStreamStop(iotests
.QMPTestCase
):
390 image_len
= 8 * 1024 * 1024 * 1024 # GB
393 qemu_img('create', backing_img
, str(TestStreamStop
.image_len
))
394 qemu_io('-c', 'write -P 0x1 0 32M', backing_img
)
395 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, test_img
)
396 qemu_io('-c', 'write -P 0x1 32M 32M', test_img
)
397 self
.vm
= iotests
.VM().add_drive("blkdebug::" + test_img
)
403 os
.remove(backing_img
)
405 def test_stream_stop(self
):
406 self
.assert_no_active_block_jobs()
408 self
.vm
.pause_drive('drive0')
409 result
= self
.vm
.qmp('block-stream', device
='drive0')
410 self
.assert_qmp(result
, 'return', {})
413 events
= self
.vm
.get_qmp_events(wait
=False)
414 self
.assertEqual(events
, [], 'unexpected QMP event: %s' % events
)
416 self
.cancel_and_wait(resume
=True)
418 class TestSetSpeed(iotests
.QMPTestCase
):
419 image_len
= 80 * 1024 * 1024 # MB
422 qemu_img('create', backing_img
, str(TestSetSpeed
.image_len
))
423 qemu_io('-c', 'write -P 0x1 0 32M', backing_img
)
424 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, test_img
)
425 qemu_io('-c', 'write -P 0x1 32M 32M', test_img
)
426 self
.vm
= iotests
.VM().add_drive('blkdebug::' + test_img
)
432 os
.remove(backing_img
)
434 # This is a short performance test which is not run by default.
435 # Invoke "IMGFMT=qed ./030 TestSetSpeed.perf_test_throughput"
436 def perf_test_throughput(self
):
437 self
.assert_no_active_block_jobs()
439 result
= self
.vm
.qmp('block-stream', device
='drive0')
440 self
.assert_qmp(result
, 'return', {})
442 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=8 * 1024 * 1024)
443 self
.assert_qmp(result
, 'return', {})
447 for event
in self
.vm
.get_qmp_events(wait
=True):
448 if event
['event'] == 'BLOCK_JOB_COMPLETED':
449 self
.assert_qmp(event
, 'data/type', 'stream')
450 self
.assert_qmp(event
, 'data/device', 'drive0')
451 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
452 self
.assert_qmp(event
, 'data/len', self
.image_len
)
455 self
.assert_no_active_block_jobs()
457 def test_set_speed(self
):
458 self
.assert_no_active_block_jobs()
460 self
.vm
.pause_drive('drive0')
461 result
= self
.vm
.qmp('block-stream', device
='drive0')
462 self
.assert_qmp(result
, 'return', {})
465 result
= self
.vm
.qmp('query-block-jobs')
466 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
467 self
.assert_qmp(result
, 'return[0]/speed', 0)
469 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=8 * 1024 * 1024)
470 self
.assert_qmp(result
, 'return', {})
472 # Ensure the speed we set was accepted
473 result
= self
.vm
.qmp('query-block-jobs')
474 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
475 self
.assert_qmp(result
, 'return[0]/speed', 8 * 1024 * 1024)
477 self
.cancel_and_wait(resume
=True)
478 self
.vm
.pause_drive('drive0')
480 # Check setting speed in block-stream works
481 result
= self
.vm
.qmp('block-stream', device
='drive0', speed
=4 * 1024 * 1024)
482 self
.assert_qmp(result
, 'return', {})
484 result
= self
.vm
.qmp('query-block-jobs')
485 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
486 self
.assert_qmp(result
, 'return[0]/speed', 4 * 1024 * 1024)
488 self
.cancel_and_wait(resume
=True)
490 def test_set_speed_invalid(self
):
491 self
.assert_no_active_block_jobs()
493 result
= self
.vm
.qmp('block-stream', device
='drive0', speed
=-1)
494 self
.assert_qmp(result
, 'error/class', 'GenericError')
496 self
.assert_no_active_block_jobs()
498 result
= self
.vm
.qmp('block-stream', device
='drive0')
499 self
.assert_qmp(result
, 'return', {})
501 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=-1)
502 self
.assert_qmp(result
, 'error/class', 'GenericError')
504 self
.cancel_and_wait()
506 if __name__
== '__main__':
507 iotests
.main(supported_fmts
=['qcow2', 'qed'])