2 # group: rw auto backing
4 # Tests for image mirroring.
6 # Copyright (C) 2012 Red Hat, Inc.
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
13 # This program is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
18 # You should have received a copy of the GNU General Public License
19 # along with this program. If not, see <http://www.gnu.org/licenses/>.
27 from iotests import qemu_img, qemu_img_map, qemu_io
29 backing_img = os.path.join(iotests.test_dir, 'backing.img')
30 target_backing_img = os.path.join(iotests.test_dir, 'target-backing.img')
31 test_img = os.path.join(iotests.test_dir, 'test.img')
32 target_img = os.path.join(iotests.test_dir, 'target.img')
34 quorum_img1 = os.path.join(iotests.test_dir, 'quorum1.img')
35 quorum_img2 = os.path.join(iotests.test_dir, 'quorum2.img')
36 quorum_img3 = os.path.join(iotests.test_dir, 'quorum3.img')
37 quorum_repair_img = os.path.join(iotests.test_dir, 'quorum_repair.img')
38 quorum_snapshot_file = os.path.join(iotests.test_dir, 'quorum_snapshot.img')
40 nbd_sock_path = os.path.join(iotests.sock_dir, 'nbd.sock')
42 class TestSingleDrive(iotests.QMPTestCase):
43 image_len = 1 * 1024 * 1024 # MB
44 qmp_cmd = 'drive-mirror'
45 qmp_target = target_img
48 iotests.create_image(backing_img, self.image_len)
49 qemu_img('create', '-f', iotests.imgfmt,
50 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img)
51 self.vm = iotests.VM().add_drive(test_img, "node-name=top,backing.node-name=base")
52 if iotests.qemu_default_machine == 'pc':
53 self.vm.add_drive(None, 'media=cdrom', 'ide')
59 os.remove(backing_img)
65 def test_complete(self):
66 self.assert_no_active_block_jobs()
68 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
69 target=self.qmp_target)
70 self.assert_qmp(result, 'return', {})
72 self.complete_and_wait()
73 result = self.vm.qmp('query-block')
74 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
76 self.assertTrue(iotests.compare_images(test_img, target_img),
77 'target image does not match source after mirroring')
79 def test_cancel(self):
80 self.assert_no_active_block_jobs()
82 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
83 target=self.qmp_target)
84 self.assert_qmp(result, 'return', {})
86 self.cancel_and_wait(force=True)
87 result = self.vm.qmp('query-block')
88 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
90 def test_cancel_after_ready(self):
91 self.assert_no_active_block_jobs()
93 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
94 target=self.qmp_target)
95 self.assert_qmp(result, 'return', {})
97 self.wait_ready_and_cancel()
98 result = self.vm.qmp('query-block')
99 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
101 self.assertTrue(iotests.compare_images(test_img, target_img),
102 'target image does not match source after mirroring')
104 def test_pause(self):
105 self.assert_no_active_block_jobs()
107 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
108 target=self.qmp_target)
109 self.assert_qmp(result, 'return', {})
111 self.pause_job('drive0')
113 result = self.vm.qmp('query-block-jobs')
114 offset = self.dictpath(result, 'return[0]/offset')
117 result = self.vm.qmp('query-block-jobs')
118 self.assert_qmp(result, 'return[0]/offset', offset)
120 result = self.vm.qmp('block-job-resume', device='drive0')
121 self.assert_qmp(result, 'return', {})
123 self.complete_and_wait()
125 self.assertTrue(iotests.compare_images(test_img, target_img),
126 'target image does not match source after mirroring')
128 def test_small_buffer(self):
129 self.assert_no_active_block_jobs()
131 # A small buffer is rounded up automatically
132 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
133 buf_size=4096, target=self.qmp_target)
134 self.assert_qmp(result, 'return', {})
136 self.complete_and_wait()
137 result = self.vm.qmp('query-block')
138 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
140 self.assertTrue(iotests.compare_images(test_img, target_img),
141 'target image does not match source after mirroring')
143 def test_small_buffer2(self):
144 self.assert_no_active_block_jobs()
146 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,size=%d'
147 % (self.image_len, self.image_len), target_img)
148 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
149 buf_size=65536, mode='existing', target=self.qmp_target)
150 self.assert_qmp(result, 'return', {})
152 self.complete_and_wait()
153 result = self.vm.qmp('query-block')
154 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
156 self.assertTrue(iotests.compare_images(test_img, target_img),
157 'target image does not match source after mirroring')
159 def test_large_cluster(self):
160 self.assert_no_active_block_jobs()
162 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s'
163 % (self.image_len, backing_img),
164 '-F', 'raw', target_img)
165 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
166 mode='existing', target=self.qmp_target)
167 self.assert_qmp(result, 'return', {})
169 self.complete_and_wait()
170 result = self.vm.qmp('query-block')
171 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
173 self.assertTrue(iotests.compare_images(test_img, target_img),
174 'target image does not match source after mirroring')
176 # Tests that the insertion of the mirror_top filter node doesn't make a
177 # difference to query-block
178 def test_implicit_node(self):
179 self.assert_no_active_block_jobs()
181 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
182 target=self.qmp_target)
183 self.assert_qmp(result, 'return', {})
185 result = self.vm.qmp('query-block')
186 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
187 self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt)
188 self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img)
189 self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1)
190 self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img)
191 self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img)
193 result = self.vm.qmp('query-blockstats')
194 self.assert_qmp(result, 'return[0]/node-name', 'top')
195 self.assert_qmp(result, 'return[0]/backing/node-name', 'base')
197 self.cancel_and_wait(force=True)
198 result = self.vm.qmp('query-block')
199 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
200 self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt)
201 self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img)
202 self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1)
203 self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img)
204 self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img)
206 result = self.vm.qmp('query-blockstats')
207 self.assert_qmp(result, 'return[0]/node-name', 'top')
208 self.assert_qmp(result, 'return[0]/backing/node-name', 'base')
210 def test_medium_not_found(self):
211 if iotests.qemu_default_machine != 'pc':
214 result = self.vm.qmp(self.qmp_cmd, device='ide1-cd0', sync='full',
215 target=self.qmp_target)
216 self.assert_qmp(result, 'error/class', 'GenericError')
218 def test_image_not_found(self):
219 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
220 mode='existing', target=self.qmp_target)
221 self.assert_qmp(result, 'error/class', 'GenericError')
223 def test_device_not_found(self):
224 result = self.vm.qmp(self.qmp_cmd, device='nonexistent', sync='full',
225 target=self.qmp_target)
226 self.assert_qmp(result, 'error/class', 'GenericError')
228 class TestSingleBlockdev(TestSingleDrive):
229 qmp_cmd = 'blockdev-mirror'
233 TestSingleDrive.setUp(self)
234 qemu_img('create', '-f', iotests.imgfmt,
235 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', target_img)
236 args = {'driver': iotests.imgfmt,
237 'node-name': self.qmp_target,
238 'file': { 'filename': target_img, 'driver': 'file' } }
239 result = self.vm.qmp("blockdev-add", **args)
240 self.assert_qmp(result, 'return', {})
242 def test_mirror_to_self(self):
243 result = self.vm.qmp(self.qmp_cmd, job_id='job0',
244 device=self.qmp_target, sync='full',
245 target=self.qmp_target)
246 self.assert_qmp(result, 'error/class', 'GenericError')
248 def do_test_resize(self, device, node):
251 result = self.vm.qmp('block_resize', device=device, size=65536)
252 self.assert_qmp(result, 'error/class', 'GenericError')
254 result = self.vm.qmp('block_resize', node_name=node, size=65536)
255 self.assert_qmp(result, 'error/class', 'GenericError')
257 result = self.vm.qmp(self.qmp_cmd, job_id='job0', device='drive0',
258 sync='full', target=self.qmp_target,
259 auto_finalize=False, auto_dismiss=False)
260 self.assert_qmp(result, 'return', {})
262 result = self.vm.run_job('job0', auto_finalize=False,
263 pre_finalize=pre_finalize)
264 self.assertEqual(result, None)
266 def test_source_resize(self):
267 self.do_test_resize('drive0', 'top')
269 def test_target_resize(self):
270 self.do_test_resize(None, self.qmp_target)
272 def do_test_target_size(self, size):
273 result = self.vm.qmp('block_resize', node_name=self.qmp_target,
275 self.assert_qmp(result, 'return', {})
277 result = self.vm.qmp(self.qmp_cmd, job_id='job0',
278 device='drive0', sync='full', auto_dismiss=False,
279 target=self.qmp_target)
280 self.assert_qmp(result, 'return', {})
282 result = self.vm.run_job('job0')
283 self.assertEqual(result, 'Source and target image have different sizes')
285 # qed does not support shrinking
286 @iotests.skip_for_formats(('qed'))
287 def test_small_target(self):
288 self.do_test_target_size(self.image_len // 2)
290 def test_large_target(self):
291 self.do_test_target_size(self.image_len * 2)
293 test_large_cluster = None
294 test_image_not_found = None
295 test_small_buffer2 = None
297 class TestSingleDriveZeroLength(TestSingleDrive):
299 test_small_buffer2 = None
300 test_large_cluster = None
302 class TestSingleBlockdevZeroLength(TestSingleBlockdev):
304 test_small_target = None
305 test_large_target = None
307 class TestSingleDriveUnalignedLength(TestSingleDrive):
308 image_len = 1025 * 1024
309 test_small_buffer2 = None
310 test_large_cluster = None
312 class TestSingleBlockdevUnalignedLength(TestSingleBlockdev):
313 image_len = 1025 * 1024
315 class TestMirrorNoBacking(iotests.QMPTestCase):
316 image_len = 2 * 1024 * 1024 # MB
319 iotests.create_image(backing_img, TestMirrorNoBacking.image_len)
320 qemu_img('create', '-f', iotests.imgfmt,
321 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img)
322 self.vm = iotests.VM().add_drive(test_img)
328 os.remove(backing_img)
330 os.remove(target_backing_img)
333 os.remove(target_img)
335 def test_complete(self):
336 self.assert_no_active_block_jobs()
338 qemu_img('create', '-f', iotests.imgfmt,
339 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', target_img)
340 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
341 mode='existing', target=target_img)
342 self.assert_qmp(result, 'return', {})
344 self.complete_and_wait()
345 result = self.vm.qmp('query-block')
346 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
348 self.assertTrue(iotests.compare_images(test_img, target_img),
349 'target image does not match source after mirroring')
351 def test_cancel(self):
352 self.assert_no_active_block_jobs()
354 qemu_img('create', '-f', iotests.imgfmt,
355 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', target_img)
356 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
357 mode='existing', target=target_img)
358 self.assert_qmp(result, 'return', {})
360 self.wait_ready_and_cancel()
361 result = self.vm.qmp('query-block')
362 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
364 self.assertTrue(iotests.compare_images(test_img, target_img),
365 'target image does not match source after mirroring')
367 def test_large_cluster(self):
368 self.assert_no_active_block_jobs()
370 # qemu-img create fails if the image is not there
371 qemu_img('create', '-f', iotests.imgfmt, '-o', 'size=%d'
372 %(TestMirrorNoBacking.image_len), target_backing_img)
373 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s'
374 % (TestMirrorNoBacking.image_len, target_backing_img),
375 '-F', iotests.imgfmt, target_img)
377 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
378 mode='existing', target=target_img)
379 self.assert_qmp(result, 'return', {})
381 self.complete_and_wait()
382 result = self.vm.qmp('query-block')
383 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
385 self.assertTrue(iotests.compare_images(test_img, target_img),
386 'target image does not match source after mirroring')
388 class TestMirrorResized(iotests.QMPTestCase):
389 backing_len = 1 * 1024 * 1024 # MB
390 image_len = 2 * 1024 * 1024 # MB
393 iotests.create_image(backing_img, TestMirrorResized.backing_len)
394 qemu_img('create', '-f', iotests.imgfmt,
395 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img)
396 qemu_img('resize', test_img, '2M')
397 self.vm = iotests.VM().add_drive(test_img)
403 os.remove(backing_img)
405 os.remove(target_img)
409 def test_complete_top(self):
410 self.assert_no_active_block_jobs()
412 result = self.vm.qmp('drive-mirror', device='drive0', sync='top',
414 self.assert_qmp(result, 'return', {})
416 self.complete_and_wait()
417 result = self.vm.qmp('query-block')
418 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
420 self.assertTrue(iotests.compare_images(test_img, target_img),
421 'target image does not match source after mirroring')
423 def test_complete_full(self):
424 self.assert_no_active_block_jobs()
426 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
428 self.assert_qmp(result, 'return', {})
430 self.complete_and_wait()
431 result = self.vm.qmp('query-block')
432 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
434 self.assertTrue(iotests.compare_images(test_img, target_img),
435 'target image does not match source after mirroring')
437 class TestReadErrors(iotests.QMPTestCase):
438 image_len = 2 * 1024 * 1024 # MB
440 # this should be a multiple of twice the default granularity
441 # so that we hit this offset first in state 1
442 MIRROR_GRANULARITY = 1024 * 1024
444 def create_blkdebug_file(self, name, event, errno):
445 file = open(name, 'w')
464 ''' % (event, errno, self.MIRROR_GRANULARITY // 512, event, event))
468 self.blkdebug_file = backing_img + ".blkdebug"
469 iotests.create_image(backing_img, TestReadErrors.image_len)
470 self.create_blkdebug_file(self.blkdebug_file, "read_aio", 5)
471 qemu_img('create', '-f', iotests.imgfmt,
472 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
473 % (self.blkdebug_file, backing_img),
475 # Write something for tests that use sync='top'
476 qemu_io('-c', 'write %d 512' % (self.MIRROR_GRANULARITY + 65536),
478 self.vm = iotests.VM().add_drive(test_img)
484 os.remove(target_img)
485 os.remove(backing_img)
486 os.remove(self.blkdebug_file)
488 def test_report_read(self):
489 self.assert_no_active_block_jobs()
491 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
493 self.assert_qmp(result, 'return', {})
498 for event in self.vm.get_qmp_events(wait=True):
499 if event['event'] == 'BLOCK_JOB_ERROR':
500 self.assert_qmp(event, 'data/device', 'drive0')
501 self.assert_qmp(event, 'data/operation', 'read')
503 elif event['event'] == 'BLOCK_JOB_READY':
504 self.assertTrue(False, 'job completed unexpectedly')
505 elif event['event'] == 'BLOCK_JOB_COMPLETED':
506 self.assertTrue(error, 'job completed unexpectedly')
507 self.assert_qmp(event, 'data/type', 'mirror')
508 self.assert_qmp(event, 'data/device', 'drive0')
509 self.assert_qmp(event, 'data/error', 'Input/output error')
511 elif event['event'] == 'JOB_STATUS_CHANGE':
512 self.assert_qmp(event, 'data/id', 'drive0')
514 self.assert_no_active_block_jobs()
516 def test_ignore_read(self):
517 self.assert_no_active_block_jobs()
519 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
520 target=target_img, on_source_error='ignore')
521 self.assert_qmp(result, 'return', {})
523 event = self.vm.get_qmp_event(wait=True)
524 while event['event'] == 'JOB_STATUS_CHANGE':
525 self.assert_qmp(event, 'data/id', 'drive0')
526 event = self.vm.get_qmp_event(wait=True)
528 self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
529 self.assert_qmp(event, 'data/device', 'drive0')
530 self.assert_qmp(event, 'data/operation', 'read')
531 result = self.vm.qmp('query-block-jobs')
532 self.assertIn(result['return'][0]['status'], ['running', 'ready'])
533 self.complete_and_wait()
535 def test_large_cluster(self):
536 self.assert_no_active_block_jobs()
538 # Test COW into the target image. The first half of the
539 # cluster at MIRROR_GRANULARITY has to be copied from
540 # backing_img, even though sync='top'.
541 qemu_img('create', '-f', iotests.imgfmt,
542 '-ocluster_size=131072,backing_file=%s' %(backing_img),
543 '-F', 'raw', target_img)
544 result = self.vm.qmp('drive-mirror', device='drive0', sync='top',
545 on_source_error='ignore',
546 mode='existing', target=target_img)
547 self.assert_qmp(result, 'return', {})
549 event = self.vm.get_qmp_event(wait=True)
550 while event['event'] == 'JOB_STATUS_CHANGE':
551 self.assert_qmp(event, 'data/id', 'drive0')
552 event = self.vm.get_qmp_event(wait=True)
554 self.assertEqual(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 self.assertIn(result['return'][0]['status'], ['running', 'ready'])
559 self.complete_and_wait()
562 # Detach blkdebug to compare images successfully
563 qemu_img('rebase', '-f', iotests.imgfmt, '-u', '-b', backing_img,
564 '-F', 'raw', test_img)
565 self.assertTrue(iotests.compare_images(test_img, target_img),
566 'target image does not match source after mirroring')
568 def test_stop_read(self):
569 self.assert_no_active_block_jobs()
571 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
572 target=target_img, on_source_error='stop')
573 self.assert_qmp(result, 'return', {})
578 for event in self.vm.get_qmp_events(wait=True):
579 if event['event'] == 'BLOCK_JOB_ERROR':
580 self.assert_qmp(event, 'data/device', 'drive0')
581 self.assert_qmp(event, 'data/operation', 'read')
583 if self.vm.qmp('query-block-jobs')['return'][0]['status'] != 'paused':
584 self.vm.events_wait([(
586 {'data': {'id': 'drive0', 'status': 'paused'}}
589 result = self.vm.qmp('query-block-jobs')
590 self.assert_qmp(result, 'return[0]/status', 'paused')
591 self.assert_qmp(result, 'return[0]/io-status', 'failed')
593 result = self.vm.qmp('block-job-resume', device='drive0')
594 self.assert_qmp(result, 'return', {})
596 elif event['event'] == 'BLOCK_JOB_READY':
597 self.assertTrue(error, 'job completed unexpectedly')
598 self.assert_qmp(event, 'data/device', 'drive0')
601 result = self.vm.qmp('query-block-jobs')
602 self.assert_qmp(result, 'return[0]/status', 'ready')
603 self.assert_qmp(result, 'return[0]/io-status', 'ok')
605 self.complete_and_wait(wait_ready=False)
606 self.assert_no_active_block_jobs()
608 class TestWriteErrors(iotests.QMPTestCase):
609 image_len = 2 * 1024 * 1024 # MB
611 # this should be a multiple of twice the default granularity
612 # so that we hit this offset first in state 1
613 MIRROR_GRANULARITY = 1024 * 1024
615 def create_blkdebug_file(self, name, event, errno):
616 file = open(name, 'w')
635 ''' % (event, errno, self.MIRROR_GRANULARITY // 512, event, event))
639 self.blkdebug_file = target_img + ".blkdebug"
640 iotests.create_image(backing_img, TestWriteErrors.image_len)
641 self.create_blkdebug_file(self.blkdebug_file, "write_aio", 5)
642 qemu_img('create', '-f', iotests.imgfmt,
643 '-obacking_file=%s' %(backing_img), '-F', 'raw', test_img)
644 self.vm = iotests.VM().add_drive(test_img)
645 self.target_img = 'blkdebug:%s:%s' % (self.blkdebug_file, target_img)
646 qemu_img('create', '-f', iotests.imgfmt, '-osize=%d' %(TestWriteErrors.image_len), target_img)
652 os.remove(target_img)
653 os.remove(backing_img)
654 os.remove(self.blkdebug_file)
656 def test_report_write(self):
657 self.assert_no_active_block_jobs()
659 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
660 mode='existing', target=self.target_img)
661 self.assert_qmp(result, 'return', {})
666 for event in self.vm.get_qmp_events(wait=True):
667 if event['event'] == 'BLOCK_JOB_ERROR':
668 self.assert_qmp(event, 'data/device', 'drive0')
669 self.assert_qmp(event, 'data/operation', 'write')
671 elif event['event'] == 'BLOCK_JOB_READY':
672 self.assertTrue(False, 'job completed unexpectedly')
673 elif event['event'] == 'BLOCK_JOB_COMPLETED':
674 self.assertTrue(error, 'job completed unexpectedly')
675 self.assert_qmp(event, 'data/type', 'mirror')
676 self.assert_qmp(event, 'data/device', 'drive0')
677 self.assert_qmp(event, 'data/error', 'Input/output error')
680 self.assert_no_active_block_jobs()
682 def test_ignore_write(self):
683 self.assert_no_active_block_jobs()
685 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
686 mode='existing', target=self.target_img,
687 on_target_error='ignore')
688 self.assert_qmp(result, 'return', {})
690 event = self.vm.event_wait(name='BLOCK_JOB_ERROR')
691 self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
692 self.assert_qmp(event, 'data/device', 'drive0')
693 self.assert_qmp(event, 'data/operation', 'write')
694 result = self.vm.qmp('query-block-jobs')
695 self.assertIn(result['return'][0]['status'], ['running', 'ready'])
696 self.complete_and_wait()
698 def test_stop_write(self):
699 self.assert_no_active_block_jobs()
701 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
702 mode='existing', target=self.target_img,
703 on_target_error='stop')
704 self.assert_qmp(result, 'return', {})
709 for event in self.vm.get_qmp_events(wait=True):
710 if event['event'] == 'BLOCK_JOB_ERROR':
711 self.assert_qmp(event, 'data/device', 'drive0')
712 self.assert_qmp(event, 'data/operation', 'write')
714 if self.vm.qmp('query-block-jobs')['return'][0]['status'] != 'paused':
715 self.vm.events_wait([(
717 {'data': {'id': 'drive0', 'status': 'paused'}}
720 result = self.vm.qmp('query-block-jobs')
721 self.assert_qmp(result, 'return[0]/status', 'paused')
722 self.assert_qmp(result, 'return[0]/io-status', 'failed')
724 result = self.vm.qmp('block-job-resume', device='drive0')
725 self.assert_qmp(result, 'return', {})
727 result = self.vm.qmp('query-block-jobs')
728 self.assertIn(result['return'][0]['status'], ['running', 'ready'])
729 self.assert_qmp(result, 'return[0]/io-status', 'ok')
731 elif event['event'] == 'BLOCK_JOB_READY':
732 self.assertTrue(error, 'job completed unexpectedly')
733 self.assert_qmp(event, 'data/device', 'drive0')
736 self.complete_and_wait(wait_ready=False)
737 self.assert_no_active_block_jobs()
739 class TestSetSpeed(iotests.QMPTestCase):
740 image_len = 80 * 1024 * 1024 # MB
743 qemu_img('create', backing_img, str(TestSetSpeed.image_len))
744 qemu_img('create', '-f', iotests.imgfmt,
745 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img)
746 self.vm = iotests.VM().add_drive(test_img)
752 os.remove(backing_img)
753 os.remove(target_img)
755 def test_set_speed(self):
756 self.assert_no_active_block_jobs()
758 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
760 self.assert_qmp(result, 'return', {})
763 result = self.vm.qmp('query-block-jobs')
764 self.assert_qmp(result, 'return[0]/device', 'drive0')
765 self.assert_qmp(result, 'return[0]/speed', 0)
767 result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
768 self.assert_qmp(result, 'return', {})
770 # Ensure the speed we set was accepted
771 result = self.vm.qmp('query-block-jobs')
772 self.assert_qmp(result, 'return[0]/device', 'drive0')
773 self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024)
775 self.wait_ready_and_cancel()
777 # Check setting speed in drive-mirror works
778 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
779 target=target_img, speed=4*1024*1024)
780 self.assert_qmp(result, 'return', {})
782 result = self.vm.qmp('query-block-jobs')
783 self.assert_qmp(result, 'return[0]/device', 'drive0')
784 self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024)
786 self.wait_ready_and_cancel()
788 def test_set_speed_invalid(self):
789 self.assert_no_active_block_jobs()
791 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
792 target=target_img, speed=-1)
793 self.assert_qmp(result, 'error/class', 'GenericError')
795 self.assert_no_active_block_jobs()
797 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
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.wait_ready_and_cancel()
806 class TestUnbackedSource(iotests.QMPTestCase):
807 image_len = 2 * 1024 * 1024 # MB
810 qemu_img('create', '-f', iotests.imgfmt, test_img,
811 str(TestUnbackedSource.image_len))
812 self.vm = iotests.VM()
814 result = self.vm.qmp('blockdev-add', node_name='drive0',
815 driver=iotests.imgfmt,
818 'filename': test_img,
820 self.assert_qmp(result, 'return', {})
825 os.remove(target_img)
827 def test_absolute_paths_full(self):
828 self.assert_no_active_block_jobs()
829 result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
830 sync='full', target=target_img,
831 mode='absolute-paths')
832 self.assert_qmp(result, 'return', {})
833 self.complete_and_wait()
834 self.assert_no_active_block_jobs()
836 def test_absolute_paths_top(self):
837 self.assert_no_active_block_jobs()
838 result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
839 sync='top', target=target_img,
840 mode='absolute-paths')
841 self.assert_qmp(result, 'return', {})
842 self.complete_and_wait()
843 self.assert_no_active_block_jobs()
845 def test_absolute_paths_none(self):
846 self.assert_no_active_block_jobs()
847 result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
848 sync='none', target=target_img,
849 mode='absolute-paths')
850 self.assert_qmp(result, 'return', {})
851 self.complete_and_wait()
852 self.assert_no_active_block_jobs()
854 def test_existing_full(self):
855 qemu_img('create', '-f', iotests.imgfmt, target_img,
857 qemu_io('-c', 'write -P 42 0 64k', target_img)
859 self.assert_no_active_block_jobs()
860 result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
861 sync='full', target=target_img, mode='existing')
862 self.assert_qmp(result, 'return', {})
863 self.complete_and_wait()
864 self.assert_no_active_block_jobs()
866 result = self.vm.qmp('blockdev-del', node_name='drive0')
867 self.assert_qmp(result, 'return', {})
869 self.assertTrue(iotests.compare_images(test_img, target_img),
870 'target image does not match source after mirroring')
872 def test_blockdev_full(self):
873 qemu_img('create', '-f', iotests.imgfmt, target_img,
875 qemu_io('-c', 'write -P 42 0 64k', target_img)
877 result = self.vm.qmp('blockdev-add', node_name='target',
878 driver=iotests.imgfmt,
881 'filename': target_img,
883 self.assert_qmp(result, 'return', {})
885 self.assert_no_active_block_jobs()
886 result = self.vm.qmp('blockdev-mirror', job_id='drive0', device='drive0',
887 sync='full', target='target')
888 self.assert_qmp(result, 'return', {})
889 self.complete_and_wait()
890 self.assert_no_active_block_jobs()
892 result = self.vm.qmp('blockdev-del', node_name='drive0')
893 self.assert_qmp(result, 'return', {})
895 result = self.vm.qmp('blockdev-del', node_name='target')
896 self.assert_qmp(result, 'return', {})
898 self.assertTrue(iotests.compare_images(test_img, target_img),
899 'target image does not match source after mirroring')
901 class TestGranularity(iotests.QMPTestCase):
902 image_len = 10 * 1024 * 1024 # MB
905 qemu_img('create', '-f', iotests.imgfmt, test_img,
906 str(TestGranularity.image_len))
907 qemu_io('-c', 'write 0 %d' % (self.image_len),
909 self.vm = iotests.VM().add_drive(test_img)
914 self.assertTrue(iotests.compare_images(test_img, target_img),
915 'target image does not match source after mirroring')
917 os.remove(target_img)
919 def test_granularity(self):
920 self.assert_no_active_block_jobs()
921 result = self.vm.qmp('drive-mirror', device='drive0',
922 sync='full', target=target_img,
923 mode='absolute-paths', granularity=8192)
924 self.assert_qmp(result, 'return', {})
926 event = self.vm.get_qmp_event(wait=60.0)
927 while event['event'] == 'JOB_STATUS_CHANGE':
928 self.assert_qmp(event, 'data/id', 'drive0')
929 event = self.vm.get_qmp_event(wait=60.0)
931 # Failures will manifest as COMPLETED/ERROR.
932 self.assert_qmp(event, 'event', 'BLOCK_JOB_READY')
933 self.complete_and_wait(drive='drive0', wait_ready=False)
934 self.assert_no_active_block_jobs()
936 class TestRepairQuorum(iotests.QMPTestCase):
937 """ This class test quorum file repair using drive-mirror.
938 It's mostly a fork of TestSingleDrive """
939 image_len = 1 * 1024 * 1024 # MB
940 IMAGES = [ quorum_img1, quorum_img2, quorum_img3 ]
942 @iotests.skip_if_unsupported(['quorum'])
944 self.vm = iotests.VM()
946 if iotests.qemu_default_machine == 'pc':
947 self.vm.add_drive(None, 'media=cdrom', 'ide')
949 # Add each individual quorum images
950 for i in self.IMAGES:
951 qemu_img('create', '-f', iotests.imgfmt, i,
953 # Assign a node name to each quorum image in order to manipulate
955 opts = "node-name=img%i" % self.IMAGES.index(i)
956 opts += ',driver=%s' % iotests.imgfmt
957 opts += ',file.driver=file'
958 opts += ',file.filename=%s' % i
959 self.vm = self.vm.add_blockdev(opts)
963 #assemble the quorum block device from the individual files
964 args = { "driver": "quorum", "node-name": "quorum0",
965 "vote-threshold": 2, "children": [ "img0", "img1", "img2" ] }
966 result = self.vm.qmp("blockdev-add", **args)
967 self.assert_qmp(result, 'return', {})
972 for i in self.IMAGES + [ quorum_repair_img, quorum_snapshot_file,
974 # Do a try/except because the test may have deleted some images
980 def test_complete(self):
981 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
982 sync='full', node_name="repair0", replaces="img1",
983 target=quorum_repair_img, format=iotests.imgfmt)
984 self.assert_qmp(result, 'return', {})
986 self.complete_and_wait(drive="job0")
987 self.assert_has_block_node("repair0", quorum_repair_img)
988 self.vm.assert_block_path('quorum0', '/children.1', 'repair0')
990 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
991 'target image does not match source after mirroring')
993 def test_cancel(self):
994 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
995 sync='full', node_name="repair0", replaces="img1",
996 target=quorum_repair_img, format=iotests.imgfmt)
997 self.assert_qmp(result, 'return', {})
999 self.cancel_and_wait(drive="job0", force=True)
1000 # here we check that the last registered quorum file has not been
1001 # swapped out and unref
1002 self.assert_has_block_node(None, quorum_img3)
1004 def test_cancel_after_ready(self):
1005 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1006 sync='full', node_name="repair0", replaces="img1",
1007 target=quorum_repair_img, format=iotests.imgfmt)
1008 self.assert_qmp(result, 'return', {})
1010 self.wait_ready_and_cancel(drive="job0")
1011 # here we check that the last registered quorum file has not been
1012 # swapped out and unref
1013 self.assert_has_block_node(None, quorum_img3)
1015 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
1016 'target image does not match source after mirroring')
1018 def test_pause(self):
1019 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1020 sync='full', node_name="repair0", replaces="img1",
1021 target=quorum_repair_img, format=iotests.imgfmt)
1022 self.assert_qmp(result, 'return', {})
1024 self.pause_job('job0')
1026 result = self.vm.qmp('query-block-jobs')
1027 offset = self.dictpath(result, 'return[0]/offset')
1030 result = self.vm.qmp('query-block-jobs')
1031 self.assert_qmp(result, 'return[0]/offset', offset)
1033 result = self.vm.qmp('block-job-resume', device='job0')
1034 self.assert_qmp(result, 'return', {})
1036 self.complete_and_wait(drive="job0")
1038 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
1039 'target image does not match source after mirroring')
1041 def test_medium_not_found(self):
1042 if iotests.qemu_default_machine != 'pc':
1045 result = self.vm.qmp('drive-mirror', job_id='job0', device='drive0', # CD-ROM
1047 node_name='repair0',
1049 target=quorum_repair_img, format=iotests.imgfmt)
1050 self.assert_qmp(result, 'error/class', 'GenericError')
1052 def test_image_not_found(self):
1053 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1054 sync='full', node_name='repair0', replaces='img1',
1055 mode='existing', target=quorum_repair_img,
1056 format=iotests.imgfmt)
1057 self.assert_qmp(result, 'error/class', 'GenericError')
1059 def test_device_not_found(self):
1060 result = self.vm.qmp('drive-mirror', job_id='job0',
1061 device='nonexistent', sync='full',
1062 node_name='repair0',
1064 target=quorum_repair_img, format=iotests.imgfmt)
1065 self.assert_qmp(result, 'error/class', 'GenericError')
1067 def test_wrong_sync_mode(self):
1068 result = self.vm.qmp('drive-mirror', device='quorum0', job_id='job0',
1069 node_name='repair0',
1071 target=quorum_repair_img, format=iotests.imgfmt)
1072 self.assert_qmp(result, 'error/class', 'GenericError')
1074 def test_no_node_name(self):
1075 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1076 sync='full', replaces='img1',
1077 target=quorum_repair_img, format=iotests.imgfmt)
1078 self.assert_qmp(result, 'error/class', 'GenericError')
1080 def test_nonexistent_replaces(self):
1081 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1082 sync='full', node_name='repair0', replaces='img77',
1083 target=quorum_repair_img, format=iotests.imgfmt)
1084 self.assert_qmp(result, 'error/class', 'GenericError')
1086 def test_after_a_quorum_snapshot(self):
1087 result = self.vm.qmp('blockdev-snapshot-sync', node_name='img1',
1088 snapshot_file=quorum_snapshot_file,
1089 snapshot_node_name="snap1");
1091 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1092 sync='full', node_name='repair0', replaces="img1",
1093 target=quorum_repair_img, format=iotests.imgfmt)
1094 self.assert_qmp(result, 'error/class', 'GenericError')
1096 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1097 sync='full', node_name='repair0', replaces="snap1",
1098 target=quorum_repair_img, format=iotests.imgfmt)
1099 self.assert_qmp(result, 'return', {})
1101 self.complete_and_wait('job0')
1102 self.assert_has_block_node("repair0", quorum_repair_img)
1103 self.vm.assert_block_path('quorum0', '/children.1', 'repair0')
1105 def test_with_other_parent(self):
1107 Check that we cannot replace a Quorum child when it has other
1110 result = self.vm.qmp('nbd-server-start',
1113 'data': {'path': nbd_sock_path}
1115 self.assert_qmp(result, 'return', {})
1117 result = self.vm.qmp('nbd-server-add', device='img1')
1118 self.assert_qmp(result, 'return', {})
1120 result = self.vm.qmp('drive-mirror', job_id='mirror', device='quorum0',
1121 sync='full', node_name='repair0', replaces='img1',
1122 target=quorum_repair_img, format=iotests.imgfmt)
1123 self.assert_qmp(result, 'error/desc',
1124 "Cannot replace 'img1' by a node mirrored from "
1125 "'quorum0', because it cannot be guaranteed that doing "
1126 "so would not lead to an abrupt change of visible data")
1128 def test_with_other_parents_after_mirror_start(self):
1130 The same as test_with_other_parent(), but add the NBD server
1131 only when the mirror job is already running.
1133 result = self.vm.qmp('nbd-server-start',
1136 'data': {'path': nbd_sock_path}
1138 self.assert_qmp(result, 'return', {})
1140 result = self.vm.qmp('drive-mirror', job_id='mirror', device='quorum0',
1141 sync='full', node_name='repair0', replaces='img1',
1142 target=quorum_repair_img, format=iotests.imgfmt)
1143 self.assert_qmp(result, 'return', {})
1145 result = self.vm.qmp('nbd-server-add', device='img1')
1146 self.assert_qmp(result, 'return', {})
1148 # The full error message goes to stderr, we will check it later
1149 self.complete_and_wait('mirror',
1150 completion_error='Operation not permitted')
1152 # Should not have been replaced
1153 self.vm.assert_block_path('quorum0', '/children.1', 'img1')
1155 # Check the full error message now
1157 log = self.vm.get_log()
1158 log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
1159 log = re.sub(r'^Formatting.*\n', '', log)
1160 log = re.sub(r'\n\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
1161 log = re.sub(r'^%s: ' % os.path.basename(iotests.qemu_prog), '', log)
1163 self.assertEqual(log,
1164 "Can no longer replace 'img1' by 'repair0', because " +
1165 "it can no longer be guaranteed that doing so would " +
1166 "not lead to an abrupt change of visible data")
1169 # Test mirroring with a source that does not have any parents (not even a
1171 class TestOrphanedSource(iotests.QMPTestCase):
1173 blk0 = { 'node-name': 'src',
1174 'driver': 'null-co' }
1176 blk1 = { 'node-name': 'dest',
1177 'driver': 'null-co' }
1179 blk2 = { 'node-name': 'dest-ro',
1180 'driver': 'null-co',
1183 self.vm = iotests.VM()
1184 self.vm.add_blockdev(self.vm.qmp_to_opts(blk0))
1185 self.vm.add_blockdev(self.vm.qmp_to_opts(blk1))
1186 self.vm.add_blockdev(self.vm.qmp_to_opts(blk2))
1192 def test_no_job_id(self):
1193 self.assert_no_active_block_jobs()
1195 result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
1197 self.assert_qmp(result, 'error/class', 'GenericError')
1199 def test_success(self):
1200 self.assert_no_active_block_jobs()
1202 result = self.vm.qmp('blockdev-mirror', job_id='job', device='src',
1203 sync='full', target='dest')
1204 self.assert_qmp(result, 'return', {})
1206 self.complete_and_wait('job')
1208 def test_failing_permissions(self):
1209 self.assert_no_active_block_jobs()
1211 result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
1213 self.assert_qmp(result, 'error/class', 'GenericError')
1215 def test_failing_permission_in_complete(self):
1216 self.assert_no_active_block_jobs()
1218 # Unshare consistent-read on the target
1219 # (The mirror job does not care)
1220 result = self.vm.qmp('blockdev-add',
1222 node_name='dest-perm',
1224 unshare_child_perms=['consistent-read'])
1225 self.assert_qmp(result, 'return', {})
1227 result = self.vm.qmp('blockdev-mirror', job_id='job', device='src',
1228 sync='full', target='dest',
1229 filter_node_name='mirror-filter')
1230 self.assert_qmp(result, 'return', {})
1232 # Require consistent-read on the source
1233 # (We can only add this node once the job has started, or it
1234 # will complain that it does not want to run on non-root nodes)
1235 result = self.vm.qmp('blockdev-add',
1237 node_name='src-perm',
1239 take_child_perms=['consistent-read'])
1240 self.assert_qmp(result, 'return', {})
1242 # While completing, mirror will attempt to replace src by
1243 # dest, which must fail because src-perm requires
1244 # consistent-read but dest-perm does not share it; thus
1245 # aborting the job when it is supposed to complete
1246 self.complete_and_wait('job',
1247 completion_error='Operation not permitted')
1249 # Assert that all of our nodes are still there (except for the
1250 # mirror filter, which should be gone despite the failure)
1251 nodes = self.vm.qmp('query-named-block-nodes')['return']
1252 nodes = [node['node-name'] for node in nodes]
1254 for expect in ('src', 'src-perm', 'dest', 'dest-perm'):
1255 self.assertTrue(expect in nodes, '%s disappeared' % expect)
1256 self.assertFalse('mirror-filter' in nodes,
1257 'Mirror filter node did not disappear')
1259 # Test cases for @replaces that do not necessarily involve Quorum
1260 class TestReplaces(iotests.QMPTestCase):
1261 # Each of these test cases needs their own block graph, so do not
1262 # create any nodes here
1264 self.vm = iotests.VM()
1269 for img in (test_img, target_img):
1275 @iotests.skip_if_unsupported(['copy-on-read'])
1276 def test_replace_filter(self):
1278 Check that we can replace filter nodes.
1280 result = self.vm.qmp('blockdev-add', **{
1281 'driver': 'copy-on-read',
1282 'node-name': 'filter0',
1284 'driver': 'copy-on-read',
1285 'node-name': 'filter1',
1291 self.assert_qmp(result, 'return', {})
1293 result = self.vm.qmp('blockdev-add',
1294 node_name='target', driver='null-co')
1295 self.assert_qmp(result, 'return', {})
1297 result = self.vm.qmp('blockdev-mirror', job_id='mirror', device='filter0',
1298 target='target', sync='full', replaces='filter1')
1299 self.assert_qmp(result, 'return', {})
1301 self.complete_and_wait('mirror')
1303 self.vm.assert_block_path('filter0', '/file', 'target')
1305 # Tests for mirror with filters (and how the mirror filter behaves, as
1306 # an example for an implicit filter)
1307 class TestFilters(iotests.QMPTestCase):
1309 qemu_img('create', '-f', iotests.imgfmt, backing_img, '1M')
1310 qemu_img('create', '-f', iotests.imgfmt, '-b', backing_img,
1311 '-F', iotests.imgfmt, test_img)
1312 qemu_img('create', '-f', iotests.imgfmt, '-b', backing_img,
1313 '-F', iotests.imgfmt, target_img)
1315 qemu_io('-c', 'write -P 1 0 512k', backing_img)
1316 qemu_io('-c', 'write -P 2 512k 512k', test_img)
1318 self.vm = iotests.VM().add_device('virtio-scsi,id=vio-scsi')
1321 result = self.vm.qmp('blockdev-add', **{
1322 'node-name': 'target',
1323 'driver': iotests.imgfmt,
1326 'filename': target_img
1330 self.assert_qmp(result, 'return', {})
1332 self.filterless_chain = {
1333 'node-name': 'source',
1334 'driver': iotests.imgfmt,
1337 'filename': test_img
1340 'node-name': 'backing',
1341 'driver': iotests.imgfmt,
1344 'filename': backing_img
1353 os.remove(target_img)
1354 os.remove(backing_img)
1357 result = self.vm.qmp('blockdev-add', **{
1358 'node-name': 'filter',
1359 'driver': 'copy-on-read',
1360 'file': self.filterless_chain
1362 self.assert_qmp(result, 'return', {})
1364 result = self.vm.qmp('blockdev-mirror',
1369 self.assert_qmp(result, 'return', {})
1371 self.complete_and_wait('mirror')
1373 self.vm.qmp('blockdev-del', node_name='target')
1375 target_map = qemu_img_map(target_img)
1377 assert target_map[0]['start'] == 0
1378 assert target_map[0]['length'] == 512 * 1024
1379 assert target_map[0]['depth'] == 1
1381 assert target_map[1]['start'] == 512 * 1024
1382 assert target_map[1]['length'] == 512 * 1024
1383 assert target_map[1]['depth'] == 0
1385 def test_implicit_mirror_filter(self):
1386 result = self.vm.qmp('blockdev-add', **self.filterless_chain)
1387 self.assert_qmp(result, 'return', {})
1389 # We need this so we can query from above the mirror node
1390 result = self.vm.qmp('device_add',
1395 self.assert_qmp(result, 'return', {})
1397 result = self.vm.qmp('blockdev-mirror',
1402 self.assert_qmp(result, 'return', {})
1404 # The mirror filter is now an implicit node, so it should be
1405 # invisible when querying the backing chain
1406 blockdevs = self.vm.qmp('query-block')['return']
1407 device_info = next(dev for dev in blockdevs if dev['qdev'] == 'virtio')
1409 assert device_info['inserted']['node-name'] == 'source'
1411 image_info = device_info['inserted']['image']
1412 assert image_info['filename'] == test_img
1413 assert image_info['backing-image']['filename'] == backing_img
1415 self.complete_and_wait('mirror')
1417 def test_explicit_mirror_filter(self):
1418 # Same test as above, but this time we give the mirror filter
1419 # a node-name so it will not be invisible
1420 result = self.vm.qmp('blockdev-add', **self.filterless_chain)
1421 self.assert_qmp(result, 'return', {})
1423 # We need this so we can query from above the mirror node
1424 result = self.vm.qmp('device_add',
1429 self.assert_qmp(result, 'return', {})
1431 result = self.vm.qmp('blockdev-mirror',
1436 filter_node_name='mirror-filter')
1437 self.assert_qmp(result, 'return', {})
1439 # With a node-name given to it, the mirror filter should now
1441 blockdevs = self.vm.qmp('query-block')['return']
1442 device_info = next(dev for dev in blockdevs if dev['qdev'] == 'virtio')
1444 assert device_info['inserted']['node-name'] == 'mirror-filter'
1446 self.complete_and_wait('mirror')
1449 if __name__ == '__main__':
1450 iotests.main(supported_fmts=['qcow2', 'qed'],
1451 supported_protocols=['file'],
1452 supported_platforms=['linux', 'freebsd', 'netbsd', 'openbsd'])