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('-f', 'raw', '-c', 'write -P 0x1 0 512', backing_img
)
38 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P 0x1 524288 512', mid_img
)
39 self
.vm
= iotests
.VM().add_drive("blkdebug::" + test_img
, "backing.node-name=mid")
46 os
.remove(backing_img
)
48 def test_stream(self
):
49 self
.assert_no_active_block_jobs()
51 result
= self
.vm
.qmp('block-stream', device
='drive0')
52 self
.assert_qmp(result
, 'return', {})
54 self
.wait_until_completed()
56 self
.assert_no_active_block_jobs()
59 self
.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img
),
60 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', test_img
),
61 'image file map does not match backing file after streaming')
63 def test_stream_intermediate(self
):
64 self
.assert_no_active_block_jobs()
66 self
.assertNotEqual(qemu_io('-f', 'raw', '-rU', '-c', 'map', backing_img
),
67 qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', mid_img
),
68 'image file map matches backing file before streaming')
70 result
= self
.vm
.qmp('block-stream', device
='mid', job_id
='stream-mid')
71 self
.assert_qmp(result
, 'return', {})
73 self
.wait_until_completed(drive
='stream-mid')
75 self
.assert_no_active_block_jobs()
78 self
.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img
),
79 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', mid_img
),
80 'image file map does not match backing file after streaming')
82 def test_stream_pause(self
):
83 self
.assert_no_active_block_jobs()
85 self
.vm
.pause_drive('drive0')
86 result
= self
.vm
.qmp('block-stream', device
='drive0')
87 self
.assert_qmp(result
, 'return', {})
89 result
= self
.vm
.qmp('block-job-pause', device
='drive0')
90 self
.assert_qmp(result
, 'return', {})
93 result
= self
.vm
.qmp('query-block-jobs')
94 offset
= self
.dictpath(result
, 'return[0]/offset')
97 result
= self
.vm
.qmp('query-block-jobs')
98 self
.assert_qmp(result
, 'return[0]/offset', offset
)
100 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
101 self
.assert_qmp(result
, 'return', {})
103 self
.vm
.resume_drive('drive0')
104 self
.wait_until_completed()
106 self
.assert_no_active_block_jobs()
109 self
.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img
),
110 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', test_img
),
111 'image file map does not match backing file after streaming')
113 def test_stream_no_op(self
):
114 self
.assert_no_active_block_jobs()
116 # The image map is empty before the operation
117 empty_map
= qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', test_img
)
119 # This is a no-op: no data should ever be copied from the base image
120 result
= self
.vm
.qmp('block-stream', device
='drive0', base
=mid_img
)
121 self
.assert_qmp(result
, 'return', {})
123 self
.wait_until_completed()
125 self
.assert_no_active_block_jobs()
128 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', test_img
),
129 empty_map
, 'image file map changed after a no-op')
131 def test_stream_partial(self
):
132 self
.assert_no_active_block_jobs()
134 result
= self
.vm
.qmp('block-stream', device
='drive0', base
=backing_img
)
135 self
.assert_qmp(result
, 'return', {})
137 self
.wait_until_completed()
139 self
.assert_no_active_block_jobs()
142 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', mid_img
),
143 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', test_img
),
144 'image file map does not match backing file after streaming')
146 def test_device_not_found(self
):
147 result
= self
.vm
.qmp('block-stream', device
='nonexistent')
148 self
.assert_qmp(result
, 'error/class', 'GenericError')
150 def test_job_id_missing(self
):
151 result
= self
.vm
.qmp('block-stream', device
='mid')
152 self
.assert_qmp(result
, 'error/class', 'GenericError')
155 class TestParallelOps(iotests
.QMPTestCase
):
156 num_ops
= 4 # Number of parallel block-stream operations
157 num_imgs
= num_ops
* 2 + 1
158 image_len
= num_ops
* 1024 * 1024
165 # Initialize file names and command-line options
166 for i
in range(self
.num_imgs
):
167 img_depth
= self
.num_imgs
- i
- 1
168 opts
.append("backing." * img_depth
+ "node-name=node%d" % i
)
169 self
.imgs
.append(os
.path
.join(iotests
.test_dir
, 'img-%d.img' % i
))
172 iotests
.create_image(self
.imgs
[0], self
.image_len
)
173 for i
in range(1, self
.num_imgs
):
174 qemu_img('create', '-f', iotests
.imgfmt
,
175 '-o', 'backing_file=%s' % self
.imgs
[i
-1], self
.imgs
[i
])
177 # Put data into the images we are copying data from
178 for i
in range(self
.num_imgs
/ 2):
179 img_index
= i
* 2 + 1
180 # Alternate between 512k and 1M.
181 # This way jobs will not finish in the same order they were created
182 num_kb
= 512 + 512 * (i
% 2)
183 qemu_io('-f', iotests
.imgfmt
,
184 '-c', 'write -P %d %d %d' % (i
, i
*1024*1024, num_kb
* 1024),
185 self
.imgs
[img_index
])
187 # Attach the drive to the VM
188 self
.vm
= iotests
.VM()
189 self
.vm
.add_drive(self
.imgs
[-1], ','.join(opts
))
194 for img
in self
.imgs
:
197 # Test that it's possible to run several block-stream operations
198 # in parallel in the same snapshot chain
199 def test_stream_parallel(self
):
200 self
.assert_no_active_block_jobs()
202 # Check that the maps don't match before the streaming operations
203 for i
in range(2, self
.num_imgs
, 2):
204 self
.assertNotEqual(qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.imgs
[i
]),
205 qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.imgs
[i
-1]),
206 'image file map matches backing file before streaming')
208 # Create all streaming jobs
210 for i
in range(2, self
.num_imgs
, 2):
211 node_name
= 'node%d' % i
212 job_id
= 'stream-%s' % node_name
213 pending_jobs
.append(job_id
)
214 result
= self
.vm
.qmp('block-stream', device
=node_name
, job_id
=job_id
, base
=self
.imgs
[i
-2], speed
=512*1024)
215 self
.assert_qmp(result
, 'return', {})
217 # Wait for all jobs to be finished.
218 while len(pending_jobs
) > 0:
219 for event
in self
.vm
.get_qmp_events(wait
=True):
220 if event
['event'] == 'BLOCK_JOB_COMPLETED':
221 job_id
= self
.dictpath(event
, 'data/device')
222 self
.assertTrue(job_id
in pending_jobs
)
223 self
.assert_qmp_absent(event
, 'data/error')
224 pending_jobs
.remove(job_id
)
226 self
.assert_no_active_block_jobs()
229 # Check that all maps match now
230 for i
in range(2, self
.num_imgs
, 2):
231 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.imgs
[i
]),
232 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.imgs
[i
-1]),
233 'image file map does not match backing file after streaming')
235 # Test that it's not possible to perform two block-stream
236 # operations if there are nodes involved in both.
237 def test_overlapping_1(self
):
238 self
.assert_no_active_block_jobs()
240 # Set a speed limit to make sure that this job blocks the rest
241 result
= self
.vm
.qmp('block-stream', device
='node4', job_id
='stream-node4', base
=self
.imgs
[1], speed
=1024*1024)
242 self
.assert_qmp(result
, 'return', {})
244 result
= self
.vm
.qmp('block-stream', device
='node5', job_id
='stream-node5', base
=self
.imgs
[2])
245 self
.assert_qmp(result
, 'error/class', 'GenericError')
247 result
= self
.vm
.qmp('block-stream', device
='node3', job_id
='stream-node3', base
=self
.imgs
[2])
248 self
.assert_qmp(result
, 'error/class', 'GenericError')
250 result
= self
.vm
.qmp('block-stream', device
='node4', job_id
='stream-node4-v2')
251 self
.assert_qmp(result
, 'error/class', 'GenericError')
253 # block-commit should also fail if it touches nodes used by the stream job
254 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[4], job_id
='commit-node4')
255 self
.assert_qmp(result
, 'error/class', 'GenericError')
257 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[1], top
=self
.imgs
[3], job_id
='commit-node1')
258 self
.assert_qmp(result
, 'error/class', 'GenericError')
260 # This fails because it needs to modify the backing string in node2, which is blocked
261 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[0], top
=self
.imgs
[1], job_id
='commit-node0')
262 self
.assert_qmp(result
, 'error/class', 'GenericError')
264 self
.wait_until_completed(drive
='stream-node4')
265 self
.assert_no_active_block_jobs()
267 # Similar to test_overlapping_1, but with block-commit
268 # blocking the other jobs
269 def test_overlapping_2(self
):
270 self
.assertLessEqual(9, self
.num_imgs
)
271 self
.assert_no_active_block_jobs()
273 # Set a speed limit to make sure that this job blocks the rest
274 result
= self
.vm
.qmp('block-commit', device
='drive0', top
=self
.imgs
[5], base
=self
.imgs
[3], job_id
='commit-node3', speed
=1024*1024)
275 self
.assert_qmp(result
, 'return', {})
277 result
= self
.vm
.qmp('block-stream', device
='node3', job_id
='stream-node3')
278 self
.assert_qmp(result
, 'error/class', 'GenericError')
280 result
= self
.vm
.qmp('block-stream', device
='node6', base
=self
.imgs
[2], job_id
='stream-node6')
281 self
.assert_qmp(result
, 'error/class', 'GenericError')
283 result
= self
.vm
.qmp('block-stream', device
='node4', base
=self
.imgs
[2], job_id
='stream-node4')
284 self
.assert_qmp(result
, 'error/class', 'GenericError')
286 result
= self
.vm
.qmp('block-stream', device
='node6', base
=self
.imgs
[4], job_id
='stream-node6-v2')
287 self
.assert_qmp(result
, 'error/class', 'GenericError')
289 # This fails because block-commit needs to block node6, the overlay of the 'top' image
290 result
= self
.vm
.qmp('block-stream', device
='node7', base
=self
.imgs
[5], job_id
='stream-node6-v3')
291 self
.assert_qmp(result
, 'error/class', 'GenericError')
293 # This fails because block-commit currently blocks the active layer even if it's not used
294 result
= self
.vm
.qmp('block-stream', device
='drive0', base
=self
.imgs
[5], job_id
='stream-drive0')
295 self
.assert_qmp(result
, 'error/class', 'GenericError')
297 self
.wait_until_completed(drive
='commit-node3')
299 # Similar to test_overlapping_2, but here block-commit doesn't use the 'top' parameter.
300 # Internally this uses a mirror block job, hence the separate test case.
301 def test_overlapping_3(self
):
302 self
.assertLessEqual(8, self
.num_imgs
)
303 self
.assert_no_active_block_jobs()
305 # Set a speed limit to make sure that this job blocks the rest
306 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[3], job_id
='commit-drive0', speed
=1024*1024)
307 self
.assert_qmp(result
, 'return', {})
309 result
= self
.vm
.qmp('block-stream', device
='node5', base
=self
.imgs
[3], job_id
='stream-node6')
310 self
.assert_qmp(result
, 'error/class', 'GenericError')
312 event
= self
.vm
.get_qmp_event(wait
=True)
313 self
.assertEqual(event
['event'], 'BLOCK_JOB_READY')
314 self
.assert_qmp(event
, 'data/device', 'commit-drive0')
315 self
.assert_qmp(event
, 'data/type', 'commit')
316 self
.assert_qmp_absent(event
, 'data/error')
318 result
= self
.vm
.qmp('block-job-complete', device
='commit-drive0')
319 self
.assert_qmp(result
, 'return', {})
321 self
.wait_until_completed(drive
='commit-drive0')
323 # Test a block-stream and a block-commit job in parallel
324 def test_stream_commit(self
):
325 self
.assertLessEqual(8, self
.num_imgs
)
326 self
.assert_no_active_block_jobs()
328 # Stream from node0 into node2
329 result
= self
.vm
.qmp('block-stream', device
='node2', job_id
='node2')
330 self
.assert_qmp(result
, 'return', {})
332 # Commit from the active layer into node3
333 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[3])
334 self
.assert_qmp(result
, 'return', {})
336 # Wait for all jobs to be finished.
337 pending_jobs
= ['node2', 'drive0']
338 while len(pending_jobs
) > 0:
339 for event
in self
.vm
.get_qmp_events(wait
=True):
340 if event
['event'] == 'BLOCK_JOB_COMPLETED':
341 node_name
= self
.dictpath(event
, 'data/device')
342 self
.assertTrue(node_name
in pending_jobs
)
343 self
.assert_qmp_absent(event
, 'data/error')
344 pending_jobs
.remove(node_name
)
345 if event
['event'] == 'BLOCK_JOB_READY':
346 self
.assert_qmp(event
, 'data/device', 'drive0')
347 self
.assert_qmp(event
, 'data/type', 'commit')
348 self
.assert_qmp_absent(event
, 'data/error')
349 self
.assertTrue('drive0' in pending_jobs
)
350 self
.vm
.qmp('block-job-complete', device
='drive0')
352 self
.assert_no_active_block_jobs()
354 # Test the base_node parameter
355 def test_stream_base_node_name(self
):
356 self
.assert_no_active_block_jobs()
358 self
.assertNotEqual(qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.imgs
[4]),
359 qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.imgs
[3]),
360 'image file map matches backing file before streaming')
362 # Error: the base node does not exist
363 result
= self
.vm
.qmp('block-stream', device
='node4', base_node
='none', job_id
='stream')
364 self
.assert_qmp(result
, 'error/class', 'GenericError')
366 # Error: the base node is not a backing file of the top node
367 result
= self
.vm
.qmp('block-stream', device
='node4', base_node
='node6', job_id
='stream')
368 self
.assert_qmp(result
, 'error/class', 'GenericError')
370 # Error: the base node is the same as the top node
371 result
= self
.vm
.qmp('block-stream', device
='node4', base_node
='node4', job_id
='stream')
372 self
.assert_qmp(result
, 'error/class', 'GenericError')
374 # Error: cannot specify 'base' and 'base-node' at the same time
375 result
= self
.vm
.qmp('block-stream', device
='node4', base
=self
.imgs
[2], base_node
='node2', job_id
='stream')
376 self
.assert_qmp(result
, 'error/class', 'GenericError')
378 # Success: the base node is a backing file of the top node
379 result
= self
.vm
.qmp('block-stream', device
='node4', base_node
='node2', job_id
='stream')
380 self
.assert_qmp(result
, 'return', {})
382 self
.wait_until_completed(drive
='stream')
384 self
.assert_no_active_block_jobs()
387 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.imgs
[4]),
388 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.imgs
[3]),
389 'image file map matches backing file after streaming')
391 class TestQuorum(iotests
.QMPTestCase
):
397 opts
= ['driver=quorum', 'vote-threshold=2']
399 # Initialize file names and command-line options
400 for i
in range(self
.num_children
):
401 child_img
= os
.path
.join(iotests
.test_dir
, 'img-%d.img' % i
)
402 backing_img
= os
.path
.join(iotests
.test_dir
, 'backing-%d.img' % i
)
403 self
.children
.append(child_img
)
404 self
.backing
.append(backing_img
)
405 qemu_img('create', '-f', iotests
.imgfmt
, backing_img
, '1M')
406 qemu_io('-f', iotests
.imgfmt
,
407 '-c', 'write -P 0x55 0 1024', backing_img
)
408 qemu_img('create', '-f', iotests
.imgfmt
,
409 '-o', 'backing_file=%s' % backing_img
, child_img
)
410 opts
.append("children.%d.file.filename=%s" % (i
, child_img
))
411 opts
.append("children.%d.node-name=node%d" % (i
, i
))
413 # Attach the drive to the VM
414 self
.vm
= iotests
.VM()
415 self
.vm
.add_drive(path
= None, opts
= ','.join(opts
))
420 for img
in self
.children
:
422 for img
in self
.backing
:
425 def test_stream_quorum(self
):
426 if not iotests
.supports_quorum():
429 self
.assertNotEqual(qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.children
[0]),
430 qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.backing
[0]),
431 'image file map matches backing file before streaming')
433 self
.assert_no_active_block_jobs()
435 result
= self
.vm
.qmp('block-stream', device
='node0', job_id
='stream-node0')
436 self
.assert_qmp(result
, 'return', {})
438 self
.wait_until_completed(drive
='stream-node0')
440 self
.assert_no_active_block_jobs()
443 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.children
[0]),
444 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.backing
[0]),
445 'image file map does not match backing file after streaming')
447 class TestSmallerBackingFile(iotests
.QMPTestCase
):
448 backing_len
= 1 * 1024 * 1024 # MB
449 image_len
= 2 * backing_len
452 iotests
.create_image(backing_img
, self
.backing_len
)
453 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, test_img
, str(self
.image_len
))
454 self
.vm
= iotests
.VM().add_drive(test_img
)
457 # If this hangs, then you are missing a fix to complete streaming when the
458 # end of the backing file is reached.
459 def test_stream(self
):
460 self
.assert_no_active_block_jobs()
462 result
= self
.vm
.qmp('block-stream', device
='drive0')
463 self
.assert_qmp(result
, 'return', {})
465 self
.wait_until_completed()
467 self
.assert_no_active_block_jobs()
470 class TestErrors(iotests
.QMPTestCase
):
471 image_len
= 2 * 1024 * 1024 # MB
473 # this should match STREAM_BUFFER_SIZE/512 in block/stream.c
474 STREAM_BUFFER_SIZE
= 512 * 1024
476 def create_blkdebug_file(self
, name
, event
, errno
):
477 file = open(name
, 'w')
496 ''' % (event
, errno
, self
.STREAM_BUFFER_SIZE
/ 512, event
, event
))
499 class TestEIO(TestErrors
):
501 self
.blkdebug_file
= backing_img
+ ".blkdebug"
502 iotests
.create_image(backing_img
, TestErrors
.image_len
)
503 self
.create_blkdebug_file(self
.blkdebug_file
, "read_aio", 5)
504 qemu_img('create', '-f', iotests
.imgfmt
,
505 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
506 % (self
.blkdebug_file
, backing_img
),
508 self
.vm
= iotests
.VM().add_drive(test_img
)
514 os
.remove(backing_img
)
515 os
.remove(self
.blkdebug_file
)
517 def test_report(self
):
518 self
.assert_no_active_block_jobs()
520 result
= self
.vm
.qmp('block-stream', device
='drive0')
521 self
.assert_qmp(result
, 'return', {})
526 for event
in self
.vm
.get_qmp_events(wait
=True):
527 if event
['event'] == 'BLOCK_JOB_ERROR':
528 self
.assert_qmp(event
, 'data/device', 'drive0')
529 self
.assert_qmp(event
, 'data/operation', 'read')
531 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
532 self
.assertTrue(error
, 'job completed unexpectedly')
533 self
.assert_qmp(event
, 'data/type', 'stream')
534 self
.assert_qmp(event
, 'data/device', 'drive0')
535 self
.assert_qmp(event
, 'data/error', 'Input/output error')
536 self
.assert_qmp(event
, 'data/offset', self
.STREAM_BUFFER_SIZE
)
537 self
.assert_qmp(event
, 'data/len', self
.image_len
)
540 self
.assert_no_active_block_jobs()
543 def test_ignore(self
):
544 self
.assert_no_active_block_jobs()
546 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='ignore')
547 self
.assert_qmp(result
, 'return', {})
552 for event
in self
.vm
.get_qmp_events(wait
=True):
553 if event
['event'] == 'BLOCK_JOB_ERROR':
555 self
.assert_qmp(event
, 'data/device', 'drive0')
556 self
.assert_qmp(event
, 'data/operation', 'read')
557 result
= self
.vm
.qmp('query-block-jobs')
558 if result
== {'return': []}:
559 # Job finished too quickly
561 self
.assert_qmp(result
, 'return[0]/paused', False)
562 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
563 self
.assertTrue(error
, 'job completed unexpectedly')
564 self
.assert_qmp(event
, 'data/type', 'stream')
565 self
.assert_qmp(event
, 'data/device', 'drive0')
566 self
.assert_qmp(event
, 'data/error', 'Input/output error')
567 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
568 self
.assert_qmp(event
, 'data/len', self
.image_len
)
571 self
.assert_no_active_block_jobs()
575 self
.assert_no_active_block_jobs()
577 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='stop')
578 self
.assert_qmp(result
, 'return', {})
583 for event
in self
.vm
.get_qmp_events(wait
=True):
584 if event
['event'] == 'BLOCK_JOB_ERROR':
586 self
.assert_qmp(event
, 'data/device', 'drive0')
587 self
.assert_qmp(event
, 'data/operation', 'read')
589 result
= self
.vm
.qmp('query-block-jobs')
590 self
.assert_qmp(result
, 'return[0]/paused', True)
591 self
.assert_qmp(result
, 'return[0]/offset', self
.STREAM_BUFFER_SIZE
)
592 self
.assert_qmp(result
, 'return[0]/io-status', 'failed')
594 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
595 self
.assert_qmp(result
, 'return', {})
597 result
= self
.vm
.qmp('query-block-jobs')
598 if result
== {'return': []}:
599 # Race; likely already finished. Check.
601 self
.assert_qmp(result
, 'return[0]/paused', False)
602 self
.assert_qmp(result
, 'return[0]/io-status', 'ok')
603 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
604 self
.assertTrue(error
, 'job completed unexpectedly')
605 self
.assert_qmp(event
, 'data/type', 'stream')
606 self
.assert_qmp(event
, 'data/device', 'drive0')
607 self
.assert_qmp_absent(event
, 'data/error')
608 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
609 self
.assert_qmp(event
, 'data/len', self
.image_len
)
612 self
.assert_no_active_block_jobs()
615 def test_enospc(self
):
616 self
.assert_no_active_block_jobs()
618 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='enospc')
619 self
.assert_qmp(result
, 'return', {})
624 for event
in self
.vm
.get_qmp_events(wait
=True):
625 if event
['event'] == 'BLOCK_JOB_ERROR':
626 self
.assert_qmp(event
, 'data/device', 'drive0')
627 self
.assert_qmp(event
, 'data/operation', 'read')
629 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
630 self
.assertTrue(error
, 'job completed unexpectedly')
631 self
.assert_qmp(event
, 'data/type', 'stream')
632 self
.assert_qmp(event
, 'data/device', 'drive0')
633 self
.assert_qmp(event
, 'data/error', 'Input/output error')
634 self
.assert_qmp(event
, 'data/offset', self
.STREAM_BUFFER_SIZE
)
635 self
.assert_qmp(event
, 'data/len', self
.image_len
)
638 self
.assert_no_active_block_jobs()
641 class TestENOSPC(TestErrors
):
643 self
.blkdebug_file
= backing_img
+ ".blkdebug"
644 iotests
.create_image(backing_img
, TestErrors
.image_len
)
645 self
.create_blkdebug_file(self
.blkdebug_file
, "read_aio", 28)
646 qemu_img('create', '-f', iotests
.imgfmt
,
647 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
648 % (self
.blkdebug_file
, backing_img
),
650 self
.vm
= iotests
.VM().add_drive(test_img
)
656 os
.remove(backing_img
)
657 os
.remove(self
.blkdebug_file
)
659 def test_enospc(self
):
660 self
.assert_no_active_block_jobs()
662 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='enospc')
663 self
.assert_qmp(result
, 'return', {})
668 for event
in self
.vm
.get_qmp_events(wait
=True):
669 if event
['event'] == 'BLOCK_JOB_ERROR':
670 self
.assert_qmp(event
, 'data/device', 'drive0')
671 self
.assert_qmp(event
, 'data/operation', 'read')
673 result
= self
.vm
.qmp('query-block-jobs')
674 self
.assert_qmp(result
, 'return[0]/paused', True)
675 self
.assert_qmp(result
, 'return[0]/offset', self
.STREAM_BUFFER_SIZE
)
676 self
.assert_qmp(result
, 'return[0]/io-status', 'nospace')
678 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
679 self
.assert_qmp(result
, 'return', {})
681 result
= self
.vm
.qmp('query-block-jobs')
682 self
.assert_qmp(result
, 'return[0]/paused', False)
683 self
.assert_qmp(result
, 'return[0]/io-status', 'ok')
685 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
686 self
.assertTrue(error
, 'job completed unexpectedly')
687 self
.assert_qmp(event
, 'data/type', 'stream')
688 self
.assert_qmp(event
, 'data/device', 'drive0')
689 self
.assert_qmp_absent(event
, 'data/error')
690 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
691 self
.assert_qmp(event
, 'data/len', self
.image_len
)
694 self
.assert_no_active_block_jobs()
697 class TestStreamStop(iotests
.QMPTestCase
):
698 image_len
= 8 * 1024 * 1024 * 1024 # GB
701 qemu_img('create', backing_img
, str(TestStreamStop
.image_len
))
702 qemu_io('-f', 'raw', '-c', 'write -P 0x1 0 32M', backing_img
)
703 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, test_img
)
704 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P 0x1 32M 32M', test_img
)
705 self
.vm
= iotests
.VM().add_drive("blkdebug::" + test_img
)
711 os
.remove(backing_img
)
713 def test_stream_stop(self
):
714 self
.assert_no_active_block_jobs()
716 self
.vm
.pause_drive('drive0')
717 result
= self
.vm
.qmp('block-stream', device
='drive0')
718 self
.assert_qmp(result
, 'return', {})
721 events
= self
.vm
.get_qmp_events(wait
=False)
722 self
.assertEqual(events
, [], 'unexpected QMP event: %s' % events
)
724 self
.cancel_and_wait(resume
=True)
726 class TestSetSpeed(iotests
.QMPTestCase
):
727 image_len
= 80 * 1024 * 1024 # MB
730 qemu_img('create', backing_img
, str(TestSetSpeed
.image_len
))
731 qemu_io('-f', 'raw', '-c', 'write -P 0x1 0 32M', backing_img
)
732 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, test_img
)
733 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P 0x1 32M 32M', test_img
)
734 self
.vm
= iotests
.VM().add_drive('blkdebug::' + test_img
)
740 os
.remove(backing_img
)
742 # This is a short performance test which is not run by default.
743 # Invoke "IMGFMT=qed ./030 TestSetSpeed.perf_test_throughput"
744 def perf_test_throughput(self
):
745 self
.assert_no_active_block_jobs()
747 result
= self
.vm
.qmp('block-stream', device
='drive0')
748 self
.assert_qmp(result
, 'return', {})
750 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=8 * 1024 * 1024)
751 self
.assert_qmp(result
, 'return', {})
753 self
.wait_until_completed()
755 self
.assert_no_active_block_jobs()
757 def test_set_speed(self
):
758 self
.assert_no_active_block_jobs()
760 self
.vm
.pause_drive('drive0')
761 result
= self
.vm
.qmp('block-stream', device
='drive0')
762 self
.assert_qmp(result
, 'return', {})
765 result
= self
.vm
.qmp('query-block-jobs')
766 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
767 self
.assert_qmp(result
, 'return[0]/speed', 0)
769 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=8 * 1024 * 1024)
770 self
.assert_qmp(result
, 'return', {})
772 # Ensure the speed we set was accepted
773 result
= self
.vm
.qmp('query-block-jobs')
774 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
775 self
.assert_qmp(result
, 'return[0]/speed', 8 * 1024 * 1024)
777 self
.cancel_and_wait(resume
=True)
778 self
.vm
.pause_drive('drive0')
780 # Check setting speed in block-stream works
781 result
= self
.vm
.qmp('block-stream', device
='drive0', speed
=4 * 1024 * 1024)
782 self
.assert_qmp(result
, 'return', {})
784 result
= self
.vm
.qmp('query-block-jobs')
785 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
786 self
.assert_qmp(result
, 'return[0]/speed', 4 * 1024 * 1024)
788 self
.cancel_and_wait(resume
=True)
790 def test_set_speed_invalid(self
):
791 self
.assert_no_active_block_jobs()
793 result
= self
.vm
.qmp('block-stream', device
='drive0', speed
=-1)
794 self
.assert_qmp(result
, 'error/class', 'GenericError')
796 self
.assert_no_active_block_jobs()
798 result
= self
.vm
.qmp('block-stream', device
='drive0')
799 self
.assert_qmp(result
, 'return', {})
801 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=-1)
802 self
.assert_qmp(result
, 'error/class', 'GenericError')
804 self
.cancel_and_wait()
806 if __name__
== '__main__':
807 iotests
.main(supported_fmts
=['qcow2', 'qed'])