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', {})
92 self
.vm
.resume_drive('drive0')
93 self
.pause_job('drive0')
95 result
= self
.vm
.qmp('query-block-jobs')
96 offset
= self
.dictpath(result
, 'return[0]/offset')
99 result
= self
.vm
.qmp('query-block-jobs')
100 self
.assert_qmp(result
, 'return[0]/offset', offset
)
102 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
103 self
.assert_qmp(result
, 'return', {})
105 self
.wait_until_completed()
107 self
.assert_no_active_block_jobs()
110 self
.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img
),
111 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', test_img
),
112 'image file map does not match backing file after streaming')
114 def test_stream_no_op(self
):
115 self
.assert_no_active_block_jobs()
117 # The image map is empty before the operation
118 empty_map
= qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', test_img
)
120 # This is a no-op: no data should ever be copied from the base image
121 result
= self
.vm
.qmp('block-stream', device
='drive0', base
=mid_img
)
122 self
.assert_qmp(result
, 'return', {})
124 self
.wait_until_completed()
126 self
.assert_no_active_block_jobs()
129 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', test_img
),
130 empty_map
, 'image file map changed after a no-op')
132 def test_stream_partial(self
):
133 self
.assert_no_active_block_jobs()
135 result
= self
.vm
.qmp('block-stream', device
='drive0', base
=backing_img
)
136 self
.assert_qmp(result
, 'return', {})
138 self
.wait_until_completed()
140 self
.assert_no_active_block_jobs()
143 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', mid_img
),
144 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', test_img
),
145 'image file map does not match backing file after streaming')
147 def test_device_not_found(self
):
148 result
= self
.vm
.qmp('block-stream', device
='nonexistent')
149 self
.assert_qmp(result
, 'error/class', 'GenericError')
151 def test_job_id_missing(self
):
152 result
= self
.vm
.qmp('block-stream', device
='mid')
153 self
.assert_qmp(result
, 'error/class', 'GenericError')
156 class TestParallelOps(iotests
.QMPTestCase
):
157 num_ops
= 4 # Number of parallel block-stream operations
158 num_imgs
= num_ops
* 2 + 1
159 image_len
= num_ops
* 1024 * 1024
166 # Initialize file names and command-line options
167 for i
in range(self
.num_imgs
):
168 img_depth
= self
.num_imgs
- i
- 1
169 opts
.append("backing." * img_depth
+ "node-name=node%d" % i
)
170 self
.imgs
.append(os
.path
.join(iotests
.test_dir
, 'img-%d.img' % i
))
173 iotests
.create_image(self
.imgs
[0], self
.image_len
)
174 for i
in range(1, self
.num_imgs
):
175 qemu_img('create', '-f', iotests
.imgfmt
,
176 '-o', 'backing_file=%s' % self
.imgs
[i
-1], self
.imgs
[i
])
178 # Put data into the images we are copying data from
179 for i
in range(self
.num_imgs
/ 2):
180 img_index
= i
* 2 + 1
181 # Alternate between 512k and 1M.
182 # This way jobs will not finish in the same order they were created
183 num_kb
= 512 + 512 * (i
% 2)
184 qemu_io('-f', iotests
.imgfmt
,
185 '-c', 'write -P %d %d %d' % (i
, i
*1024*1024, num_kb
* 1024),
186 self
.imgs
[img_index
])
188 # Attach the drive to the VM
189 self
.vm
= iotests
.VM()
190 self
.vm
.add_drive(self
.imgs
[-1], ','.join(opts
))
195 for img
in self
.imgs
:
198 # Test that it's possible to run several block-stream operations
199 # in parallel in the same snapshot chain
200 def test_stream_parallel(self
):
201 self
.assert_no_active_block_jobs()
203 # Check that the maps don't match before the streaming operations
204 for i
in range(2, self
.num_imgs
, 2):
205 self
.assertNotEqual(qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.imgs
[i
]),
206 qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.imgs
[i
-1]),
207 'image file map matches backing file before streaming')
209 # Create all streaming jobs
211 for i
in range(2, self
.num_imgs
, 2):
212 node_name
= 'node%d' % i
213 job_id
= 'stream-%s' % node_name
214 pending_jobs
.append(job_id
)
215 result
= self
.vm
.qmp('block-stream', device
=node_name
, job_id
=job_id
, base
=self
.imgs
[i
-2], speed
=512*1024)
216 self
.assert_qmp(result
, 'return', {})
218 # Wait for all jobs to be finished.
219 while len(pending_jobs
) > 0:
220 for event
in self
.vm
.get_qmp_events(wait
=True):
221 if event
['event'] == 'BLOCK_JOB_COMPLETED':
222 job_id
= self
.dictpath(event
, 'data/device')
223 self
.assertTrue(job_id
in pending_jobs
)
224 self
.assert_qmp_absent(event
, 'data/error')
225 pending_jobs
.remove(job_id
)
227 self
.assert_no_active_block_jobs()
230 # Check that all maps match now
231 for i
in range(2, self
.num_imgs
, 2):
232 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.imgs
[i
]),
233 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.imgs
[i
-1]),
234 'image file map does not match backing file after streaming')
236 # Test that it's not possible to perform two block-stream
237 # operations if there are nodes involved in both.
238 def test_overlapping_1(self
):
239 self
.assert_no_active_block_jobs()
241 # Set a speed limit to make sure that this job blocks the rest
242 result
= self
.vm
.qmp('block-stream', device
='node4', job_id
='stream-node4', base
=self
.imgs
[1], speed
=1024*1024)
243 self
.assert_qmp(result
, 'return', {})
245 result
= self
.vm
.qmp('block-stream', device
='node5', job_id
='stream-node5', base
=self
.imgs
[2])
246 self
.assert_qmp(result
, 'error/class', 'GenericError')
248 result
= self
.vm
.qmp('block-stream', device
='node3', job_id
='stream-node3', base
=self
.imgs
[2])
249 self
.assert_qmp(result
, 'error/class', 'GenericError')
251 result
= self
.vm
.qmp('block-stream', device
='node4', job_id
='stream-node4-v2')
252 self
.assert_qmp(result
, 'error/class', 'GenericError')
254 # block-commit should also fail if it touches nodes used by the stream job
255 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[4], job_id
='commit-node4')
256 self
.assert_qmp(result
, 'error/class', 'GenericError')
258 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[1], top
=self
.imgs
[3], job_id
='commit-node1')
259 self
.assert_qmp(result
, 'error/class', 'GenericError')
261 # This fails because it needs to modify the backing string in node2, which is blocked
262 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[0], top
=self
.imgs
[1], job_id
='commit-node0')
263 self
.assert_qmp(result
, 'error/class', 'GenericError')
265 self
.wait_until_completed(drive
='stream-node4')
266 self
.assert_no_active_block_jobs()
268 # Similar to test_overlapping_1, but with block-commit
269 # blocking the other jobs
270 def test_overlapping_2(self
):
271 self
.assertLessEqual(9, self
.num_imgs
)
272 self
.assert_no_active_block_jobs()
274 # Set a speed limit to make sure that this job blocks the rest
275 result
= self
.vm
.qmp('block-commit', device
='drive0', top
=self
.imgs
[5], base
=self
.imgs
[3], job_id
='commit-node3', speed
=1024*1024)
276 self
.assert_qmp(result
, 'return', {})
278 result
= self
.vm
.qmp('block-stream', device
='node3', job_id
='stream-node3')
279 self
.assert_qmp(result
, 'error/class', 'GenericError')
281 result
= self
.vm
.qmp('block-stream', device
='node6', base
=self
.imgs
[2], job_id
='stream-node6')
282 self
.assert_qmp(result
, 'error/class', 'GenericError')
284 result
= self
.vm
.qmp('block-stream', device
='node4', base
=self
.imgs
[2], job_id
='stream-node4')
285 self
.assert_qmp(result
, 'error/class', 'GenericError')
287 result
= self
.vm
.qmp('block-stream', device
='node6', base
=self
.imgs
[4], job_id
='stream-node6-v2')
288 self
.assert_qmp(result
, 'error/class', 'GenericError')
290 # This fails because block-commit needs to block node6, the overlay of the 'top' image
291 result
= self
.vm
.qmp('block-stream', device
='node7', base
=self
.imgs
[5], job_id
='stream-node6-v3')
292 self
.assert_qmp(result
, 'error/class', 'GenericError')
294 # This fails because block-commit currently blocks the active layer even if it's not used
295 result
= self
.vm
.qmp('block-stream', device
='drive0', base
=self
.imgs
[5], job_id
='stream-drive0')
296 self
.assert_qmp(result
, 'error/class', 'GenericError')
298 self
.wait_until_completed(drive
='commit-node3')
300 # Similar to test_overlapping_2, but here block-commit doesn't use the 'top' parameter.
301 # Internally this uses a mirror block job, hence the separate test case.
302 def test_overlapping_3(self
):
303 self
.assertLessEqual(8, self
.num_imgs
)
304 self
.assert_no_active_block_jobs()
306 # Set a speed limit to make sure that this job blocks the rest
307 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[3], job_id
='commit-drive0', speed
=1024*1024)
308 self
.assert_qmp(result
, 'return', {})
310 result
= self
.vm
.qmp('block-stream', device
='node5', base
=self
.imgs
[3], job_id
='stream-node6')
311 self
.assert_qmp(result
, 'error/class', 'GenericError')
313 event
= self
.vm
.get_qmp_event(wait
=True)
314 self
.assertEqual(event
['event'], 'BLOCK_JOB_READY')
315 self
.assert_qmp(event
, 'data/device', 'commit-drive0')
316 self
.assert_qmp(event
, 'data/type', 'commit')
317 self
.assert_qmp_absent(event
, 'data/error')
319 result
= self
.vm
.qmp('block-job-complete', device
='commit-drive0')
320 self
.assert_qmp(result
, 'return', {})
322 self
.wait_until_completed(drive
='commit-drive0')
324 # Test a block-stream and a block-commit job in parallel
325 def test_stream_commit(self
):
326 self
.assertLessEqual(8, self
.num_imgs
)
327 self
.assert_no_active_block_jobs()
329 # Stream from node0 into node2
330 result
= self
.vm
.qmp('block-stream', device
='node2', job_id
='node2')
331 self
.assert_qmp(result
, 'return', {})
333 # Commit from the active layer into node3
334 result
= self
.vm
.qmp('block-commit', device
='drive0', base
=self
.imgs
[3])
335 self
.assert_qmp(result
, 'return', {})
337 # Wait for all jobs to be finished.
338 pending_jobs
= ['node2', 'drive0']
339 while len(pending_jobs
) > 0:
340 for event
in self
.vm
.get_qmp_events(wait
=True):
341 if event
['event'] == 'BLOCK_JOB_COMPLETED':
342 node_name
= self
.dictpath(event
, 'data/device')
343 self
.assertTrue(node_name
in pending_jobs
)
344 self
.assert_qmp_absent(event
, 'data/error')
345 pending_jobs
.remove(node_name
)
346 if event
['event'] == 'BLOCK_JOB_READY':
347 self
.assert_qmp(event
, 'data/device', 'drive0')
348 self
.assert_qmp(event
, 'data/type', 'commit')
349 self
.assert_qmp_absent(event
, 'data/error')
350 self
.assertTrue('drive0' in pending_jobs
)
351 self
.vm
.qmp('block-job-complete', device
='drive0')
353 self
.assert_no_active_block_jobs()
355 # Test the base_node parameter
356 def test_stream_base_node_name(self
):
357 self
.assert_no_active_block_jobs()
359 self
.assertNotEqual(qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.imgs
[4]),
360 qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.imgs
[3]),
361 'image file map matches backing file before streaming')
363 # Error: the base node does not exist
364 result
= self
.vm
.qmp('block-stream', device
='node4', base_node
='none', job_id
='stream')
365 self
.assert_qmp(result
, 'error/class', 'GenericError')
367 # Error: the base node is not a backing file of the top node
368 result
= self
.vm
.qmp('block-stream', device
='node4', base_node
='node6', job_id
='stream')
369 self
.assert_qmp(result
, 'error/class', 'GenericError')
371 # Error: the base node is the same as the top node
372 result
= self
.vm
.qmp('block-stream', device
='node4', base_node
='node4', job_id
='stream')
373 self
.assert_qmp(result
, 'error/class', 'GenericError')
375 # Error: cannot specify 'base' and 'base-node' at the same time
376 result
= self
.vm
.qmp('block-stream', device
='node4', base
=self
.imgs
[2], base_node
='node2', job_id
='stream')
377 self
.assert_qmp(result
, 'error/class', 'GenericError')
379 # Success: the base node is a backing file of the top node
380 result
= self
.vm
.qmp('block-stream', device
='node4', base_node
='node2', job_id
='stream')
381 self
.assert_qmp(result
, 'return', {})
383 self
.wait_until_completed(drive
='stream')
385 self
.assert_no_active_block_jobs()
388 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.imgs
[4]),
389 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.imgs
[3]),
390 'image file map matches backing file after streaming')
392 class TestQuorum(iotests
.QMPTestCase
):
398 opts
= ['driver=quorum', 'vote-threshold=2']
400 # Initialize file names and command-line options
401 for i
in range(self
.num_children
):
402 child_img
= os
.path
.join(iotests
.test_dir
, 'img-%d.img' % i
)
403 backing_img
= os
.path
.join(iotests
.test_dir
, 'backing-%d.img' % i
)
404 self
.children
.append(child_img
)
405 self
.backing
.append(backing_img
)
406 qemu_img('create', '-f', iotests
.imgfmt
, backing_img
, '1M')
407 qemu_io('-f', iotests
.imgfmt
,
408 '-c', 'write -P 0x55 0 1024', backing_img
)
409 qemu_img('create', '-f', iotests
.imgfmt
,
410 '-o', 'backing_file=%s' % backing_img
, child_img
)
411 opts
.append("children.%d.file.filename=%s" % (i
, child_img
))
412 opts
.append("children.%d.node-name=node%d" % (i
, i
))
414 # Attach the drive to the VM
415 self
.vm
= iotests
.VM()
416 self
.vm
.add_drive(path
= None, opts
= ','.join(opts
))
421 for img
in self
.children
:
423 for img
in self
.backing
:
426 def test_stream_quorum(self
):
427 if not iotests
.supports_quorum():
430 self
.assertNotEqual(qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.children
[0]),
431 qemu_io('-f', iotests
.imgfmt
, '-rU', '-c', 'map', self
.backing
[0]),
432 'image file map matches backing file before streaming')
434 self
.assert_no_active_block_jobs()
436 result
= self
.vm
.qmp('block-stream', device
='node0', job_id
='stream-node0')
437 self
.assert_qmp(result
, 'return', {})
439 self
.wait_until_completed(drive
='stream-node0')
441 self
.assert_no_active_block_jobs()
444 self
.assertEqual(qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.children
[0]),
445 qemu_io('-f', iotests
.imgfmt
, '-c', 'map', self
.backing
[0]),
446 'image file map does not match backing file after streaming')
448 class TestSmallerBackingFile(iotests
.QMPTestCase
):
449 backing_len
= 1 * 1024 * 1024 # MB
450 image_len
= 2 * backing_len
453 iotests
.create_image(backing_img
, self
.backing_len
)
454 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, test_img
, str(self
.image_len
))
455 self
.vm
= iotests
.VM().add_drive(test_img
)
458 # If this hangs, then you are missing a fix to complete streaming when the
459 # end of the backing file is reached.
460 def test_stream(self
):
461 self
.assert_no_active_block_jobs()
463 result
= self
.vm
.qmp('block-stream', device
='drive0')
464 self
.assert_qmp(result
, 'return', {})
466 self
.wait_until_completed()
468 self
.assert_no_active_block_jobs()
471 class TestErrors(iotests
.QMPTestCase
):
472 image_len
= 2 * 1024 * 1024 # MB
474 # this should match STREAM_BUFFER_SIZE/512 in block/stream.c
475 STREAM_BUFFER_SIZE
= 512 * 1024
477 def create_blkdebug_file(self
, name
, event
, errno
):
478 file = open(name
, 'w')
497 ''' % (event
, errno
, self
.STREAM_BUFFER_SIZE
/ 512, event
, event
))
500 class TestEIO(TestErrors
):
502 self
.blkdebug_file
= backing_img
+ ".blkdebug"
503 iotests
.create_image(backing_img
, TestErrors
.image_len
)
504 self
.create_blkdebug_file(self
.blkdebug_file
, "read_aio", 5)
505 qemu_img('create', '-f', iotests
.imgfmt
,
506 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
507 % (self
.blkdebug_file
, backing_img
),
509 self
.vm
= iotests
.VM().add_drive(test_img
)
515 os
.remove(backing_img
)
516 os
.remove(self
.blkdebug_file
)
518 def test_report(self
):
519 self
.assert_no_active_block_jobs()
521 result
= self
.vm
.qmp('block-stream', device
='drive0')
522 self
.assert_qmp(result
, 'return', {})
527 for event
in self
.vm
.get_qmp_events(wait
=True):
528 if event
['event'] == 'BLOCK_JOB_ERROR':
529 self
.assert_qmp(event
, 'data/device', 'drive0')
530 self
.assert_qmp(event
, 'data/operation', 'read')
532 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
533 self
.assertTrue(error
, 'job completed unexpectedly')
534 self
.assert_qmp(event
, 'data/type', 'stream')
535 self
.assert_qmp(event
, 'data/device', 'drive0')
536 self
.assert_qmp(event
, 'data/error', 'Input/output error')
537 self
.assert_qmp(event
, 'data/offset', self
.STREAM_BUFFER_SIZE
)
538 self
.assert_qmp(event
, 'data/len', self
.image_len
)
541 self
.assert_no_active_block_jobs()
544 def test_ignore(self
):
545 self
.assert_no_active_block_jobs()
547 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='ignore')
548 self
.assert_qmp(result
, 'return', {})
553 for event
in self
.vm
.get_qmp_events(wait
=True):
554 if event
['event'] == 'BLOCK_JOB_ERROR':
556 self
.assert_qmp(event
, 'data/device', 'drive0')
557 self
.assert_qmp(event
, 'data/operation', 'read')
558 result
= self
.vm
.qmp('query-block-jobs')
559 if result
== {'return': []}:
560 # Job finished too quickly
562 self
.assert_qmp(result
, 'return[0]/paused', False)
563 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
564 self
.assertTrue(error
, 'job completed unexpectedly')
565 self
.assert_qmp(event
, 'data/type', 'stream')
566 self
.assert_qmp(event
, 'data/device', 'drive0')
567 self
.assert_qmp(event
, 'data/error', 'Input/output error')
568 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
569 self
.assert_qmp(event
, 'data/len', self
.image_len
)
572 self
.assert_no_active_block_jobs()
576 self
.assert_no_active_block_jobs()
578 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='stop')
579 self
.assert_qmp(result
, 'return', {})
584 for event
in self
.vm
.get_qmp_events(wait
=True):
585 if event
['event'] == 'BLOCK_JOB_ERROR':
587 self
.assert_qmp(event
, 'data/device', 'drive0')
588 self
.assert_qmp(event
, 'data/operation', 'read')
590 result
= self
.vm
.qmp('query-block-jobs')
591 self
.assert_qmp(result
, 'return[0]/paused', True)
592 self
.assert_qmp(result
, 'return[0]/offset', self
.STREAM_BUFFER_SIZE
)
593 self
.assert_qmp(result
, 'return[0]/io-status', 'failed')
595 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
596 self
.assert_qmp(result
, 'return', {})
598 result
= self
.vm
.qmp('query-block-jobs')
599 if result
== {'return': []}:
600 # Race; likely already finished. Check.
602 self
.assert_qmp(result
, 'return[0]/paused', False)
603 self
.assert_qmp(result
, 'return[0]/io-status', 'ok')
604 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
605 self
.assertTrue(error
, 'job completed unexpectedly')
606 self
.assert_qmp(event
, 'data/type', 'stream')
607 self
.assert_qmp(event
, 'data/device', 'drive0')
608 self
.assert_qmp_absent(event
, 'data/error')
609 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
610 self
.assert_qmp(event
, 'data/len', self
.image_len
)
613 self
.assert_no_active_block_jobs()
616 def test_enospc(self
):
617 self
.assert_no_active_block_jobs()
619 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='enospc')
620 self
.assert_qmp(result
, 'return', {})
625 for event
in self
.vm
.get_qmp_events(wait
=True):
626 if event
['event'] == 'BLOCK_JOB_ERROR':
627 self
.assert_qmp(event
, 'data/device', 'drive0')
628 self
.assert_qmp(event
, 'data/operation', 'read')
630 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
631 self
.assertTrue(error
, 'job completed unexpectedly')
632 self
.assert_qmp(event
, 'data/type', 'stream')
633 self
.assert_qmp(event
, 'data/device', 'drive0')
634 self
.assert_qmp(event
, 'data/error', 'Input/output error')
635 self
.assert_qmp(event
, 'data/offset', self
.STREAM_BUFFER_SIZE
)
636 self
.assert_qmp(event
, 'data/len', self
.image_len
)
639 self
.assert_no_active_block_jobs()
642 class TestENOSPC(TestErrors
):
644 self
.blkdebug_file
= backing_img
+ ".blkdebug"
645 iotests
.create_image(backing_img
, TestErrors
.image_len
)
646 self
.create_blkdebug_file(self
.blkdebug_file
, "read_aio", 28)
647 qemu_img('create', '-f', iotests
.imgfmt
,
648 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
649 % (self
.blkdebug_file
, backing_img
),
651 self
.vm
= iotests
.VM().add_drive(test_img
)
657 os
.remove(backing_img
)
658 os
.remove(self
.blkdebug_file
)
660 def test_enospc(self
):
661 self
.assert_no_active_block_jobs()
663 result
= self
.vm
.qmp('block-stream', device
='drive0', on_error
='enospc')
664 self
.assert_qmp(result
, 'return', {})
669 for event
in self
.vm
.get_qmp_events(wait
=True):
670 if event
['event'] == 'BLOCK_JOB_ERROR':
671 self
.assert_qmp(event
, 'data/device', 'drive0')
672 self
.assert_qmp(event
, 'data/operation', 'read')
674 result
= self
.vm
.qmp('query-block-jobs')
675 self
.assert_qmp(result
, 'return[0]/paused', True)
676 self
.assert_qmp(result
, 'return[0]/offset', self
.STREAM_BUFFER_SIZE
)
677 self
.assert_qmp(result
, 'return[0]/io-status', 'nospace')
679 result
= self
.vm
.qmp('block-job-resume', device
='drive0')
680 self
.assert_qmp(result
, 'return', {})
682 result
= self
.vm
.qmp('query-block-jobs')
683 self
.assert_qmp(result
, 'return[0]/paused', False)
684 self
.assert_qmp(result
, 'return[0]/io-status', 'ok')
686 elif event
['event'] == 'BLOCK_JOB_COMPLETED':
687 self
.assertTrue(error
, 'job completed unexpectedly')
688 self
.assert_qmp(event
, 'data/type', 'stream')
689 self
.assert_qmp(event
, 'data/device', 'drive0')
690 self
.assert_qmp_absent(event
, 'data/error')
691 self
.assert_qmp(event
, 'data/offset', self
.image_len
)
692 self
.assert_qmp(event
, 'data/len', self
.image_len
)
695 self
.assert_no_active_block_jobs()
698 class TestStreamStop(iotests
.QMPTestCase
):
699 image_len
= 8 * 1024 * 1024 * 1024 # GB
702 qemu_img('create', backing_img
, str(TestStreamStop
.image_len
))
703 qemu_io('-f', 'raw', '-c', 'write -P 0x1 0 32M', backing_img
)
704 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, test_img
)
705 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P 0x1 32M 32M', test_img
)
706 self
.vm
= iotests
.VM().add_drive("blkdebug::" + test_img
)
712 os
.remove(backing_img
)
714 def test_stream_stop(self
):
715 self
.assert_no_active_block_jobs()
717 self
.vm
.pause_drive('drive0')
718 result
= self
.vm
.qmp('block-stream', device
='drive0')
719 self
.assert_qmp(result
, 'return', {})
722 events
= self
.vm
.get_qmp_events(wait
=False)
723 self
.assertEqual(events
, [], 'unexpected QMP event: %s' % events
)
725 self
.cancel_and_wait(resume
=True)
727 class TestSetSpeed(iotests
.QMPTestCase
):
728 image_len
= 80 * 1024 * 1024 # MB
731 qemu_img('create', backing_img
, str(TestSetSpeed
.image_len
))
732 qemu_io('-f', 'raw', '-c', 'write -P 0x1 0 32M', backing_img
)
733 qemu_img('create', '-f', iotests
.imgfmt
, '-o', 'backing_file=%s' % backing_img
, test_img
)
734 qemu_io('-f', iotests
.imgfmt
, '-c', 'write -P 0x1 32M 32M', test_img
)
735 self
.vm
= iotests
.VM().add_drive('blkdebug::' + test_img
)
741 os
.remove(backing_img
)
743 # This is a short performance test which is not run by default.
744 # Invoke "IMGFMT=qed ./030 TestSetSpeed.perf_test_throughput"
745 def perf_test_throughput(self
):
746 self
.assert_no_active_block_jobs()
748 result
= self
.vm
.qmp('block-stream', device
='drive0')
749 self
.assert_qmp(result
, 'return', {})
751 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=8 * 1024 * 1024)
752 self
.assert_qmp(result
, 'return', {})
754 self
.wait_until_completed()
756 self
.assert_no_active_block_jobs()
758 def test_set_speed(self
):
759 self
.assert_no_active_block_jobs()
761 self
.vm
.pause_drive('drive0')
762 result
= self
.vm
.qmp('block-stream', device
='drive0')
763 self
.assert_qmp(result
, 'return', {})
766 result
= self
.vm
.qmp('query-block-jobs')
767 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
768 self
.assert_qmp(result
, 'return[0]/speed', 0)
770 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=8 * 1024 * 1024)
771 self
.assert_qmp(result
, 'return', {})
773 # Ensure the speed we set was accepted
774 result
= self
.vm
.qmp('query-block-jobs')
775 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
776 self
.assert_qmp(result
, 'return[0]/speed', 8 * 1024 * 1024)
778 self
.cancel_and_wait(resume
=True)
779 self
.vm
.pause_drive('drive0')
781 # Check setting speed in block-stream works
782 result
= self
.vm
.qmp('block-stream', device
='drive0', speed
=4 * 1024 * 1024)
783 self
.assert_qmp(result
, 'return', {})
785 result
= self
.vm
.qmp('query-block-jobs')
786 self
.assert_qmp(result
, 'return[0]/device', 'drive0')
787 self
.assert_qmp(result
, 'return[0]/speed', 4 * 1024 * 1024)
789 self
.cancel_and_wait(resume
=True)
791 def test_set_speed_invalid(self
):
792 self
.assert_no_active_block_jobs()
794 result
= self
.vm
.qmp('block-stream', device
='drive0', speed
=-1)
795 self
.assert_qmp(result
, 'error/class', 'GenericError')
797 self
.assert_no_active_block_jobs()
799 result
= self
.vm
.qmp('block-stream', device
='drive0')
800 self
.assert_qmp(result
, 'return', {})
802 result
= self
.vm
.qmp('block-job-set-speed', device
='drive0', speed
=-1)
803 self
.assert_qmp(result
, 'error/class', 'GenericError')
805 self
.cancel_and_wait()
807 if __name__
== '__main__':
808 iotests
.main(supported_fmts
=['qcow2', 'qed'])