3 # Tests for image mirroring.
5 # Copyright (C) 2012 Red Hat, Inc.
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/>.
26 from iotests import qemu_img, qemu_img_pipe, qemu_io
28 backing_img = os.path.join(iotests.test_dir, 'backing.img')
29 target_backing_img = os.path.join(iotests.test_dir, 'target-backing.img')
30 test_img = os.path.join(iotests.test_dir, 'test.img')
31 target_img = os.path.join(iotests.test_dir, 'target.img')
33 quorum_img1 = os.path.join(iotests.test_dir, 'quorum1.img')
34 quorum_img2 = os.path.join(iotests.test_dir, 'quorum2.img')
35 quorum_img3 = os.path.join(iotests.test_dir, 'quorum3.img')
36 quorum_repair_img = os.path.join(iotests.test_dir, 'quorum_repair.img')
37 quorum_snapshot_file = os.path.join(iotests.test_dir, 'quorum_snapshot.img')
39 nbd_sock_path = os.path.join(iotests.sock_dir, 'nbd.sock')
41 class TestSingleDrive(iotests.QMPTestCase):
42 image_len = 1 * 1024 * 1024 # MB
43 qmp_cmd = 'drive-mirror'
44 qmp_target = target_img
47 iotests.create_image(backing_img, self.image_len)
48 qemu_img('create', '-f', iotests.imgfmt,
49 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img)
50 self.vm = iotests.VM().add_drive(test_img, "node-name=top,backing.node-name=base")
51 if iotests.qemu_default_machine == 'pc':
52 self.vm.add_drive(None, 'media=cdrom', 'ide')
58 os.remove(backing_img)
64 def test_complete(self):
65 self.assert_no_active_block_jobs()
67 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
68 target=self.qmp_target)
69 self.assert_qmp(result, 'return', {})
71 self.complete_and_wait()
72 result = self.vm.qmp('query-block')
73 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
75 self.assertTrue(iotests.compare_images(test_img, target_img),
76 'target image does not match source after mirroring')
78 def test_cancel(self):
79 self.assert_no_active_block_jobs()
81 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
82 target=self.qmp_target)
83 self.assert_qmp(result, 'return', {})
85 self.cancel_and_wait(force=True)
86 result = self.vm.qmp('query-block')
87 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
89 def test_cancel_after_ready(self):
90 self.assert_no_active_block_jobs()
92 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
93 target=self.qmp_target)
94 self.assert_qmp(result, 'return', {})
96 self.wait_ready_and_cancel()
97 result = self.vm.qmp('query-block')
98 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
100 self.assertTrue(iotests.compare_images(test_img, target_img),
101 'target image does not match source after mirroring')
103 def test_pause(self):
104 self.assert_no_active_block_jobs()
106 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
107 target=self.qmp_target)
108 self.assert_qmp(result, 'return', {})
110 self.pause_job('drive0')
112 result = self.vm.qmp('query-block-jobs')
113 offset = self.dictpath(result, 'return[0]/offset')
116 result = self.vm.qmp('query-block-jobs')
117 self.assert_qmp(result, 'return[0]/offset', offset)
119 result = self.vm.qmp('block-job-resume', device='drive0')
120 self.assert_qmp(result, 'return', {})
122 self.complete_and_wait()
124 self.assertTrue(iotests.compare_images(test_img, target_img),
125 'target image does not match source after mirroring')
127 def test_small_buffer(self):
128 self.assert_no_active_block_jobs()
130 # A small buffer is rounded up automatically
131 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
132 buf_size=4096, target=self.qmp_target)
133 self.assert_qmp(result, 'return', {})
135 self.complete_and_wait()
136 result = self.vm.qmp('query-block')
137 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
139 self.assertTrue(iotests.compare_images(test_img, target_img),
140 'target image does not match source after mirroring')
142 def test_small_buffer2(self):
143 self.assert_no_active_block_jobs()
145 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,size=%d'
146 % (self.image_len, self.image_len), target_img)
147 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
148 buf_size=65536, mode='existing', target=self.qmp_target)
149 self.assert_qmp(result, 'return', {})
151 self.complete_and_wait()
152 result = self.vm.qmp('query-block')
153 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
155 self.assertTrue(iotests.compare_images(test_img, target_img),
156 'target image does not match source after mirroring')
158 def test_large_cluster(self):
159 self.assert_no_active_block_jobs()
161 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s'
162 % (self.image_len, backing_img),
163 '-F', 'raw', target_img)
164 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
165 mode='existing', target=self.qmp_target)
166 self.assert_qmp(result, 'return', {})
168 self.complete_and_wait()
169 result = self.vm.qmp('query-block')
170 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
172 self.assertTrue(iotests.compare_images(test_img, target_img),
173 'target image does not match source after mirroring')
175 # Tests that the insertion of the mirror_top filter node doesn't make a
176 # difference to query-block
177 def test_implicit_node(self):
178 self.assert_no_active_block_jobs()
180 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
181 target=self.qmp_target)
182 self.assert_qmp(result, 'return', {})
184 result = self.vm.qmp('query-block')
185 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
186 self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt)
187 self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img)
188 self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1)
189 self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img)
190 self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img)
192 result = self.vm.qmp('query-blockstats')
193 self.assert_qmp(result, 'return[0]/node-name', 'top')
194 self.assert_qmp(result, 'return[0]/backing/node-name', 'base')
196 self.cancel_and_wait(force=True)
197 result = self.vm.qmp('query-block')
198 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
199 self.assert_qmp(result, 'return[0]/inserted/drv', iotests.imgfmt)
200 self.assert_qmp(result, 'return[0]/inserted/backing_file', backing_img)
201 self.assert_qmp(result, 'return[0]/inserted/backing_file_depth', 1)
202 self.assert_qmp(result, 'return[0]/inserted/image/filename', test_img)
203 self.assert_qmp(result, 'return[0]/inserted/image/backing-image/filename', backing_img)
205 result = self.vm.qmp('query-blockstats')
206 self.assert_qmp(result, 'return[0]/node-name', 'top')
207 self.assert_qmp(result, 'return[0]/backing/node-name', 'base')
209 def test_medium_not_found(self):
210 if iotests.qemu_default_machine != 'pc':
213 result = self.vm.qmp(self.qmp_cmd, device='ide1-cd0', sync='full',
214 target=self.qmp_target)
215 self.assert_qmp(result, 'error/class', 'GenericError')
217 def test_image_not_found(self):
218 result = self.vm.qmp(self.qmp_cmd, device='drive0', sync='full',
219 mode='existing', target=self.qmp_target)
220 self.assert_qmp(result, 'error/class', 'GenericError')
222 def test_device_not_found(self):
223 result = self.vm.qmp(self.qmp_cmd, device='nonexistent', sync='full',
224 target=self.qmp_target)
225 self.assert_qmp(result, 'error/class', 'GenericError')
227 class TestSingleBlockdev(TestSingleDrive):
228 qmp_cmd = 'blockdev-mirror'
232 TestSingleDrive.setUp(self)
233 qemu_img('create', '-f', iotests.imgfmt,
234 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', target_img)
235 args = {'driver': iotests.imgfmt,
236 'node-name': self.qmp_target,
237 'file': { 'filename': target_img, 'driver': 'file' } }
238 result = self.vm.qmp("blockdev-add", **args)
239 self.assert_qmp(result, 'return', {})
241 def test_mirror_to_self(self):
242 result = self.vm.qmp(self.qmp_cmd, job_id='job0',
243 device=self.qmp_target, sync='full',
244 target=self.qmp_target)
245 self.assert_qmp(result, 'error/class', 'GenericError')
247 def do_test_resize(self, device, node):
250 result = self.vm.qmp('block_resize', device=device, size=65536)
251 self.assert_qmp(result, 'error/class', 'GenericError')
253 result = self.vm.qmp('block_resize', node_name=node, size=65536)
254 self.assert_qmp(result, 'error/class', 'GenericError')
256 result = self.vm.qmp(self.qmp_cmd, job_id='job0', device='drive0',
257 sync='full', target=self.qmp_target,
258 auto_finalize=False, auto_dismiss=False)
259 self.assert_qmp(result, 'return', {})
261 result = self.vm.run_job('job0', auto_finalize=False,
262 pre_finalize=pre_finalize)
263 self.assertEqual(result, None)
265 def test_source_resize(self):
266 self.do_test_resize('drive0', 'top')
268 def test_target_resize(self):
269 self.do_test_resize(None, self.qmp_target)
271 def do_test_target_size(self, size):
272 result = self.vm.qmp('block_resize', node_name=self.qmp_target,
274 self.assert_qmp(result, 'return', {})
276 result = self.vm.qmp(self.qmp_cmd, job_id='job0',
277 device='drive0', sync='full', auto_dismiss=False,
278 target=self.qmp_target)
279 self.assert_qmp(result, 'return', {})
281 result = self.vm.run_job('job0')
282 self.assertEqual(result, 'Source and target image have different sizes')
284 # qed does not support shrinking
285 @iotests.skip_for_formats(('qed'))
286 def test_small_target(self):
287 self.do_test_target_size(self.image_len // 2)
289 def test_large_target(self):
290 self.do_test_target_size(self.image_len * 2)
292 test_large_cluster = None
293 test_image_not_found = None
294 test_small_buffer2 = None
296 class TestSingleDriveZeroLength(TestSingleDrive):
298 test_small_buffer2 = None
299 test_large_cluster = None
301 class TestSingleBlockdevZeroLength(TestSingleBlockdev):
303 test_small_target = None
304 test_large_target = None
306 class TestSingleDriveUnalignedLength(TestSingleDrive):
307 image_len = 1025 * 1024
308 test_small_buffer2 = None
309 test_large_cluster = None
311 class TestSingleBlockdevUnalignedLength(TestSingleBlockdev):
312 image_len = 1025 * 1024
314 class TestMirrorNoBacking(iotests.QMPTestCase):
315 image_len = 2 * 1024 * 1024 # MB
318 iotests.create_image(backing_img, TestMirrorNoBacking.image_len)
319 qemu_img('create', '-f', iotests.imgfmt,
320 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img)
321 self.vm = iotests.VM().add_drive(test_img)
327 os.remove(backing_img)
329 os.remove(target_backing_img)
332 os.remove(target_img)
334 def test_complete(self):
335 self.assert_no_active_block_jobs()
337 qemu_img('create', '-f', iotests.imgfmt,
338 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', target_img)
339 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
340 mode='existing', target=target_img)
341 self.assert_qmp(result, 'return', {})
343 self.complete_and_wait()
344 result = self.vm.qmp('query-block')
345 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
347 self.assertTrue(iotests.compare_images(test_img, target_img),
348 'target image does not match source after mirroring')
350 def test_cancel(self):
351 self.assert_no_active_block_jobs()
353 qemu_img('create', '-f', iotests.imgfmt,
354 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', target_img)
355 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
356 mode='existing', target=target_img)
357 self.assert_qmp(result, 'return', {})
359 self.wait_ready_and_cancel()
360 result = self.vm.qmp('query-block')
361 self.assert_qmp(result, 'return[0]/inserted/file', test_img)
363 self.assertTrue(iotests.compare_images(test_img, target_img),
364 'target image does not match source after mirroring')
366 def test_large_cluster(self):
367 self.assert_no_active_block_jobs()
369 # qemu-img create fails if the image is not there
370 qemu_img('create', '-f', iotests.imgfmt, '-o', 'size=%d'
371 %(TestMirrorNoBacking.image_len), target_backing_img)
372 qemu_img('create', '-f', iotests.imgfmt, '-o', 'cluster_size=%d,backing_file=%s'
373 % (TestMirrorNoBacking.image_len, target_backing_img),
374 '-F', iotests.imgfmt, target_img)
376 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
377 mode='existing', target=target_img)
378 self.assert_qmp(result, 'return', {})
380 self.complete_and_wait()
381 result = self.vm.qmp('query-block')
382 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
384 self.assertTrue(iotests.compare_images(test_img, target_img),
385 'target image does not match source after mirroring')
387 class TestMirrorResized(iotests.QMPTestCase):
388 backing_len = 1 * 1024 * 1024 # MB
389 image_len = 2 * 1024 * 1024 # MB
392 iotests.create_image(backing_img, TestMirrorResized.backing_len)
393 qemu_img('create', '-f', iotests.imgfmt,
394 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img)
395 qemu_img('resize', test_img, '2M')
396 self.vm = iotests.VM().add_drive(test_img)
402 os.remove(backing_img)
404 os.remove(target_img)
408 def test_complete_top(self):
409 self.assert_no_active_block_jobs()
411 result = self.vm.qmp('drive-mirror', device='drive0', sync='top',
413 self.assert_qmp(result, 'return', {})
415 self.complete_and_wait()
416 result = self.vm.qmp('query-block')
417 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
419 self.assertTrue(iotests.compare_images(test_img, target_img),
420 'target image does not match source after mirroring')
422 def test_complete_full(self):
423 self.assert_no_active_block_jobs()
425 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
427 self.assert_qmp(result, 'return', {})
429 self.complete_and_wait()
430 result = self.vm.qmp('query-block')
431 self.assert_qmp(result, 'return[0]/inserted/file', target_img)
433 self.assertTrue(iotests.compare_images(test_img, target_img),
434 'target image does not match source after mirroring')
436 class TestReadErrors(iotests.QMPTestCase):
437 image_len = 2 * 1024 * 1024 # MB
439 # this should be a multiple of twice the default granularity
440 # so that we hit this offset first in state 1
441 MIRROR_GRANULARITY = 1024 * 1024
443 def create_blkdebug_file(self, name, event, errno):
444 file = open(name, 'w')
463 ''' % (event, errno, self.MIRROR_GRANULARITY // 512, event, event))
467 self.blkdebug_file = backing_img + ".blkdebug"
468 iotests.create_image(backing_img, TestReadErrors.image_len)
469 self.create_blkdebug_file(self.blkdebug_file, "read_aio", 5)
470 qemu_img('create', '-f', iotests.imgfmt,
471 '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
472 % (self.blkdebug_file, backing_img),
474 # Write something for tests that use sync='top'
475 qemu_io('-c', 'write %d 512' % (self.MIRROR_GRANULARITY + 65536),
477 self.vm = iotests.VM().add_drive(test_img)
483 os.remove(target_img)
484 os.remove(backing_img)
485 os.remove(self.blkdebug_file)
487 def test_report_read(self):
488 self.assert_no_active_block_jobs()
490 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
492 self.assert_qmp(result, 'return', {})
497 for event in self.vm.get_qmp_events(wait=True):
498 if event['event'] == 'BLOCK_JOB_ERROR':
499 self.assert_qmp(event, 'data/device', 'drive0')
500 self.assert_qmp(event, 'data/operation', 'read')
502 elif event['event'] == 'BLOCK_JOB_READY':
503 self.assertTrue(False, 'job completed unexpectedly')
504 elif event['event'] == 'BLOCK_JOB_COMPLETED':
505 self.assertTrue(error, 'job completed unexpectedly')
506 self.assert_qmp(event, 'data/type', 'mirror')
507 self.assert_qmp(event, 'data/device', 'drive0')
508 self.assert_qmp(event, 'data/error', 'Input/output error')
510 elif event['event'] == 'JOB_STATUS_CHANGE':
511 self.assert_qmp(event, 'data/id', 'drive0')
513 self.assert_no_active_block_jobs()
515 def test_ignore_read(self):
516 self.assert_no_active_block_jobs()
518 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
519 target=target_img, on_source_error='ignore')
520 self.assert_qmp(result, 'return', {})
522 event = self.vm.get_qmp_event(wait=True)
523 while event['event'] == 'JOB_STATUS_CHANGE':
524 self.assert_qmp(event, 'data/id', 'drive0')
525 event = self.vm.get_qmp_event(wait=True)
527 self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
528 self.assert_qmp(event, 'data/device', 'drive0')
529 self.assert_qmp(event, 'data/operation', 'read')
530 result = self.vm.qmp('query-block-jobs')
531 self.assert_qmp(result, 'return[0]/paused', False)
532 self.complete_and_wait()
534 def test_large_cluster(self):
535 self.assert_no_active_block_jobs()
537 # Test COW into the target image. The first half of the
538 # cluster at MIRROR_GRANULARITY has to be copied from
539 # backing_img, even though sync='top'.
540 qemu_img('create', '-f', iotests.imgfmt,
541 '-ocluster_size=131072,backing_file=%s' %(backing_img),
542 '-F', 'raw', target_img)
543 result = self.vm.qmp('drive-mirror', device='drive0', sync='top',
544 on_source_error='ignore',
545 mode='existing', target=target_img)
546 self.assert_qmp(result, 'return', {})
548 event = self.vm.get_qmp_event(wait=True)
549 while event['event'] == 'JOB_STATUS_CHANGE':
550 self.assert_qmp(event, 'data/id', 'drive0')
551 event = self.vm.get_qmp_event(wait=True)
553 self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
554 self.assert_qmp(event, 'data/device', 'drive0')
555 self.assert_qmp(event, 'data/operation', 'read')
556 result = self.vm.qmp('query-block-jobs')
557 self.assert_qmp(result, 'return[0]/paused', False)
558 self.complete_and_wait()
561 # Detach blkdebug to compare images successfully
562 qemu_img('rebase', '-f', iotests.imgfmt, '-u', '-b', backing_img,
563 '-F', 'raw', test_img)
564 self.assertTrue(iotests.compare_images(test_img, target_img),
565 'target image does not match source after mirroring')
567 def test_stop_read(self):
568 self.assert_no_active_block_jobs()
570 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
571 target=target_img, on_source_error='stop')
572 self.assert_qmp(result, 'return', {})
577 for event in self.vm.get_qmp_events(wait=True):
578 if event['event'] == 'BLOCK_JOB_ERROR':
579 self.assert_qmp(event, 'data/device', 'drive0')
580 self.assert_qmp(event, 'data/operation', 'read')
582 result = self.vm.qmp('query-block-jobs')
583 self.assert_qmp(result, 'return[0]/paused', True)
584 self.assert_qmp(result, 'return[0]/io-status', 'failed')
586 result = self.vm.qmp('block-job-resume', device='drive0')
587 self.assert_qmp(result, 'return', {})
589 elif event['event'] == 'BLOCK_JOB_READY':
590 self.assertTrue(error, 'job completed unexpectedly')
591 self.assert_qmp(event, 'data/device', 'drive0')
594 result = self.vm.qmp('query-block-jobs')
595 self.assert_qmp(result, 'return[0]/paused', False)
596 self.assert_qmp(result, 'return[0]/io-status', 'ok')
598 self.complete_and_wait(wait_ready=False)
599 self.assert_no_active_block_jobs()
601 class TestWriteErrors(iotests.QMPTestCase):
602 image_len = 2 * 1024 * 1024 # MB
604 # this should be a multiple of twice the default granularity
605 # so that we hit this offset first in state 1
606 MIRROR_GRANULARITY = 1024 * 1024
608 def create_blkdebug_file(self, name, event, errno):
609 file = open(name, 'w')
628 ''' % (event, errno, self.MIRROR_GRANULARITY // 512, event, event))
632 self.blkdebug_file = target_img + ".blkdebug"
633 iotests.create_image(backing_img, TestWriteErrors.image_len)
634 self.create_blkdebug_file(self.blkdebug_file, "write_aio", 5)
635 qemu_img('create', '-f', iotests.imgfmt,
636 '-obacking_file=%s' %(backing_img), '-F', 'raw', test_img)
637 self.vm = iotests.VM().add_drive(test_img)
638 self.target_img = 'blkdebug:%s:%s' % (self.blkdebug_file, target_img)
639 qemu_img('create', '-f', iotests.imgfmt, '-osize=%d' %(TestWriteErrors.image_len), target_img)
645 os.remove(target_img)
646 os.remove(backing_img)
647 os.remove(self.blkdebug_file)
649 def test_report_write(self):
650 self.assert_no_active_block_jobs()
652 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
653 mode='existing', target=self.target_img)
654 self.assert_qmp(result, 'return', {})
659 for event in self.vm.get_qmp_events(wait=True):
660 if event['event'] == 'BLOCK_JOB_ERROR':
661 self.assert_qmp(event, 'data/device', 'drive0')
662 self.assert_qmp(event, 'data/operation', 'write')
664 elif event['event'] == 'BLOCK_JOB_READY':
665 self.assertTrue(False, 'job completed unexpectedly')
666 elif event['event'] == 'BLOCK_JOB_COMPLETED':
667 self.assertTrue(error, 'job completed unexpectedly')
668 self.assert_qmp(event, 'data/type', 'mirror')
669 self.assert_qmp(event, 'data/device', 'drive0')
670 self.assert_qmp(event, 'data/error', 'Input/output error')
673 self.assert_no_active_block_jobs()
675 def test_ignore_write(self):
676 self.assert_no_active_block_jobs()
678 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
679 mode='existing', target=self.target_img,
680 on_target_error='ignore')
681 self.assert_qmp(result, 'return', {})
683 event = self.vm.event_wait(name='BLOCK_JOB_ERROR')
684 self.assertEqual(event['event'], 'BLOCK_JOB_ERROR')
685 self.assert_qmp(event, 'data/device', 'drive0')
686 self.assert_qmp(event, 'data/operation', 'write')
687 result = self.vm.qmp('query-block-jobs')
688 self.assert_qmp(result, 'return[0]/paused', False)
689 self.complete_and_wait()
691 def test_stop_write(self):
692 self.assert_no_active_block_jobs()
694 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
695 mode='existing', target=self.target_img,
696 on_target_error='stop')
697 self.assert_qmp(result, 'return', {})
702 for event in self.vm.get_qmp_events(wait=True):
703 if event['event'] == 'BLOCK_JOB_ERROR':
704 self.assert_qmp(event, 'data/device', 'drive0')
705 self.assert_qmp(event, 'data/operation', 'write')
707 result = self.vm.qmp('query-block-jobs')
708 self.assert_qmp(result, 'return[0]/paused', True)
709 self.assert_qmp(result, 'return[0]/io-status', 'failed')
711 result = self.vm.qmp('block-job-resume', device='drive0')
712 self.assert_qmp(result, 'return', {})
714 result = self.vm.qmp('query-block-jobs')
715 self.assert_qmp(result, 'return[0]/paused', False)
716 self.assert_qmp(result, 'return[0]/io-status', 'ok')
718 elif event['event'] == 'BLOCK_JOB_READY':
719 self.assertTrue(error, 'job completed unexpectedly')
720 self.assert_qmp(event, 'data/device', 'drive0')
723 self.complete_and_wait(wait_ready=False)
724 self.assert_no_active_block_jobs()
726 class TestSetSpeed(iotests.QMPTestCase):
727 image_len = 80 * 1024 * 1024 # MB
730 qemu_img('create', backing_img, str(TestSetSpeed.image_len))
731 qemu_img('create', '-f', iotests.imgfmt,
732 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img)
733 self.vm = iotests.VM().add_drive(test_img)
739 os.remove(backing_img)
740 os.remove(target_img)
742 def test_set_speed(self):
743 self.assert_no_active_block_jobs()
745 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
747 self.assert_qmp(result, 'return', {})
750 result = self.vm.qmp('query-block-jobs')
751 self.assert_qmp(result, 'return[0]/device', 'drive0')
752 self.assert_qmp(result, 'return[0]/speed', 0)
754 result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
755 self.assert_qmp(result, 'return', {})
757 # Ensure the speed we set was accepted
758 result = self.vm.qmp('query-block-jobs')
759 self.assert_qmp(result, 'return[0]/device', 'drive0')
760 self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024)
762 self.wait_ready_and_cancel()
764 # Check setting speed in drive-mirror works
765 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
766 target=target_img, speed=4*1024*1024)
767 self.assert_qmp(result, 'return', {})
769 result = self.vm.qmp('query-block-jobs')
770 self.assert_qmp(result, 'return[0]/device', 'drive0')
771 self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024)
773 self.wait_ready_and_cancel()
775 def test_set_speed_invalid(self):
776 self.assert_no_active_block_jobs()
778 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
779 target=target_img, speed=-1)
780 self.assert_qmp(result, 'error/class', 'GenericError')
782 self.assert_no_active_block_jobs()
784 result = self.vm.qmp('drive-mirror', device='drive0', sync='full',
786 self.assert_qmp(result, 'return', {})
788 result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
789 self.assert_qmp(result, 'error/class', 'GenericError')
791 self.wait_ready_and_cancel()
793 class TestUnbackedSource(iotests.QMPTestCase):
794 image_len = 2 * 1024 * 1024 # MB
797 qemu_img('create', '-f', iotests.imgfmt, test_img,
798 str(TestUnbackedSource.image_len))
799 self.vm = iotests.VM()
801 result = self.vm.qmp('blockdev-add', node_name='drive0',
802 driver=iotests.imgfmt,
805 'filename': test_img,
807 self.assert_qmp(result, 'return', {})
812 os.remove(target_img)
814 def test_absolute_paths_full(self):
815 self.assert_no_active_block_jobs()
816 result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
817 sync='full', target=target_img,
818 mode='absolute-paths')
819 self.assert_qmp(result, 'return', {})
820 self.complete_and_wait()
821 self.assert_no_active_block_jobs()
823 def test_absolute_paths_top(self):
824 self.assert_no_active_block_jobs()
825 result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
826 sync='top', target=target_img,
827 mode='absolute-paths')
828 self.assert_qmp(result, 'return', {})
829 self.complete_and_wait()
830 self.assert_no_active_block_jobs()
832 def test_absolute_paths_none(self):
833 self.assert_no_active_block_jobs()
834 result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
835 sync='none', target=target_img,
836 mode='absolute-paths')
837 self.assert_qmp(result, 'return', {})
838 self.complete_and_wait()
839 self.assert_no_active_block_jobs()
841 def test_existing_full(self):
842 qemu_img('create', '-f', iotests.imgfmt, target_img,
844 qemu_io('-c', 'write -P 42 0 64k', target_img)
846 self.assert_no_active_block_jobs()
847 result = self.vm.qmp('drive-mirror', job_id='drive0', device='drive0',
848 sync='full', target=target_img, mode='existing')
849 self.assert_qmp(result, 'return', {})
850 self.complete_and_wait()
851 self.assert_no_active_block_jobs()
853 result = self.vm.qmp('blockdev-del', node_name='drive0')
854 self.assert_qmp(result, 'return', {})
856 self.assertTrue(iotests.compare_images(test_img, target_img),
857 'target image does not match source after mirroring')
859 def test_blockdev_full(self):
860 qemu_img('create', '-f', iotests.imgfmt, target_img,
862 qemu_io('-c', 'write -P 42 0 64k', target_img)
864 result = self.vm.qmp('blockdev-add', node_name='target',
865 driver=iotests.imgfmt,
868 'filename': target_img,
870 self.assert_qmp(result, 'return', {})
872 self.assert_no_active_block_jobs()
873 result = self.vm.qmp('blockdev-mirror', job_id='drive0', device='drive0',
874 sync='full', target='target')
875 self.assert_qmp(result, 'return', {})
876 self.complete_and_wait()
877 self.assert_no_active_block_jobs()
879 result = self.vm.qmp('blockdev-del', node_name='drive0')
880 self.assert_qmp(result, 'return', {})
882 result = self.vm.qmp('blockdev-del', node_name='target')
883 self.assert_qmp(result, 'return', {})
885 self.assertTrue(iotests.compare_images(test_img, target_img),
886 'target image does not match source after mirroring')
888 class TestGranularity(iotests.QMPTestCase):
889 image_len = 10 * 1024 * 1024 # MB
892 qemu_img('create', '-f', iotests.imgfmt, test_img,
893 str(TestGranularity.image_len))
894 qemu_io('-c', 'write 0 %d' % (self.image_len),
896 self.vm = iotests.VM().add_drive(test_img)
901 self.assertTrue(iotests.compare_images(test_img, target_img),
902 'target image does not match source after mirroring')
904 os.remove(target_img)
906 def test_granularity(self):
907 self.assert_no_active_block_jobs()
908 result = self.vm.qmp('drive-mirror', device='drive0',
909 sync='full', target=target_img,
910 mode='absolute-paths', granularity=8192)
911 self.assert_qmp(result, 'return', {})
913 event = self.vm.get_qmp_event(wait=60.0)
914 while event['event'] == 'JOB_STATUS_CHANGE':
915 self.assert_qmp(event, 'data/id', 'drive0')
916 event = self.vm.get_qmp_event(wait=60.0)
918 # Failures will manifest as COMPLETED/ERROR.
919 self.assert_qmp(event, 'event', 'BLOCK_JOB_READY')
920 self.complete_and_wait(drive='drive0', wait_ready=False)
921 self.assert_no_active_block_jobs()
923 class TestRepairQuorum(iotests.QMPTestCase):
924 """ This class test quorum file repair using drive-mirror.
925 It's mostly a fork of TestSingleDrive """
926 image_len = 1 * 1024 * 1024 # MB
927 IMAGES = [ quorum_img1, quorum_img2, quorum_img3 ]
929 @iotests.skip_if_unsupported(['quorum'])
931 self.vm = iotests.VM()
933 if iotests.qemu_default_machine == 'pc':
934 self.vm.add_drive(None, 'media=cdrom', 'ide')
936 # Add each individual quorum images
937 for i in self.IMAGES:
938 qemu_img('create', '-f', iotests.imgfmt, i,
940 # Assign a node name to each quorum image in order to manipulate
942 opts = "node-name=img%i" % self.IMAGES.index(i)
943 opts += ',driver=%s' % iotests.imgfmt
944 opts += ',file.driver=file'
945 opts += ',file.filename=%s' % i
946 self.vm = self.vm.add_blockdev(opts)
950 #assemble the quorum block device from the individual files
951 args = { "driver": "quorum", "node-name": "quorum0",
952 "vote-threshold": 2, "children": [ "img0", "img1", "img2" ] }
953 result = self.vm.qmp("blockdev-add", **args)
954 self.assert_qmp(result, 'return', {})
959 for i in self.IMAGES + [ quorum_repair_img, quorum_snapshot_file,
961 # Do a try/except because the test may have deleted some images
967 def test_complete(self):
968 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
969 sync='full', node_name="repair0", replaces="img1",
970 target=quorum_repair_img, format=iotests.imgfmt)
971 self.assert_qmp(result, 'return', {})
973 self.complete_and_wait(drive="job0")
974 self.assert_has_block_node("repair0", quorum_repair_img)
975 self.vm.assert_block_path('quorum0', '/children.1', 'repair0')
977 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
978 'target image does not match source after mirroring')
980 def test_cancel(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.cancel_and_wait(drive="job0", force=True)
987 # here we check that the last registered quorum file has not been
988 # swapped out and unref
989 self.assert_has_block_node(None, quorum_img3)
991 def test_cancel_after_ready(self):
992 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
993 sync='full', node_name="repair0", replaces="img1",
994 target=quorum_repair_img, format=iotests.imgfmt)
995 self.assert_qmp(result, 'return', {})
997 self.wait_ready_and_cancel(drive="job0")
998 # here we check that the last registered quorum file has not been
999 # swapped out and unref
1000 self.assert_has_block_node(None, quorum_img3)
1002 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
1003 'target image does not match source after mirroring')
1005 def test_pause(self):
1006 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1007 sync='full', node_name="repair0", replaces="img1",
1008 target=quorum_repair_img, format=iotests.imgfmt)
1009 self.assert_qmp(result, 'return', {})
1011 self.pause_job('job0')
1013 result = self.vm.qmp('query-block-jobs')
1014 offset = self.dictpath(result, 'return[0]/offset')
1017 result = self.vm.qmp('query-block-jobs')
1018 self.assert_qmp(result, 'return[0]/offset', offset)
1020 result = self.vm.qmp('block-job-resume', device='job0')
1021 self.assert_qmp(result, 'return', {})
1023 self.complete_and_wait(drive="job0")
1025 self.assertTrue(iotests.compare_images(quorum_img2, quorum_repair_img),
1026 'target image does not match source after mirroring')
1028 def test_medium_not_found(self):
1029 if iotests.qemu_default_machine != 'pc':
1032 result = self.vm.qmp('drive-mirror', job_id='job0', device='drive0', # CD-ROM
1034 node_name='repair0',
1036 target=quorum_repair_img, format=iotests.imgfmt)
1037 self.assert_qmp(result, 'error/class', 'GenericError')
1039 def test_image_not_found(self):
1040 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1041 sync='full', node_name='repair0', replaces='img1',
1042 mode='existing', target=quorum_repair_img,
1043 format=iotests.imgfmt)
1044 self.assert_qmp(result, 'error/class', 'GenericError')
1046 def test_device_not_found(self):
1047 result = self.vm.qmp('drive-mirror', job_id='job0',
1048 device='nonexistent', sync='full',
1049 node_name='repair0',
1051 target=quorum_repair_img, format=iotests.imgfmt)
1052 self.assert_qmp(result, 'error/class', 'GenericError')
1054 def test_wrong_sync_mode(self):
1055 result = self.vm.qmp('drive-mirror', device='quorum0', job_id='job0',
1056 node_name='repair0',
1058 target=quorum_repair_img, format=iotests.imgfmt)
1059 self.assert_qmp(result, 'error/class', 'GenericError')
1061 def test_no_node_name(self):
1062 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1063 sync='full', replaces='img1',
1064 target=quorum_repair_img, format=iotests.imgfmt)
1065 self.assert_qmp(result, 'error/class', 'GenericError')
1067 def test_nonexistent_replaces(self):
1068 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1069 sync='full', node_name='repair0', replaces='img77',
1070 target=quorum_repair_img, format=iotests.imgfmt)
1071 self.assert_qmp(result, 'error/class', 'GenericError')
1073 def test_after_a_quorum_snapshot(self):
1074 result = self.vm.qmp('blockdev-snapshot-sync', node_name='img1',
1075 snapshot_file=quorum_snapshot_file,
1076 snapshot_node_name="snap1");
1078 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1079 sync='full', node_name='repair0', replaces="img1",
1080 target=quorum_repair_img, format=iotests.imgfmt)
1081 self.assert_qmp(result, 'error/class', 'GenericError')
1083 result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
1084 sync='full', node_name='repair0', replaces="snap1",
1085 target=quorum_repair_img, format=iotests.imgfmt)
1086 self.assert_qmp(result, 'return', {})
1088 self.complete_and_wait('job0')
1089 self.assert_has_block_node("repair0", quorum_repair_img)
1090 self.vm.assert_block_path('quorum0', '/children.1', 'repair0')
1092 def test_with_other_parent(self):
1094 Check that we cannot replace a Quorum child when it has other
1097 result = self.vm.qmp('nbd-server-start',
1100 'data': {'path': nbd_sock_path}
1102 self.assert_qmp(result, 'return', {})
1104 result = self.vm.qmp('nbd-server-add', device='img1')
1105 self.assert_qmp(result, 'return', {})
1107 result = self.vm.qmp('drive-mirror', job_id='mirror', device='quorum0',
1108 sync='full', node_name='repair0', replaces='img1',
1109 target=quorum_repair_img, format=iotests.imgfmt)
1110 self.assert_qmp(result, 'error/desc',
1111 "Cannot replace 'img1' by a node mirrored from "
1112 "'quorum0', because it cannot be guaranteed that doing "
1113 "so would not lead to an abrupt change of visible data")
1115 def test_with_other_parents_after_mirror_start(self):
1117 The same as test_with_other_parent(), but add the NBD server
1118 only when the mirror job is already running.
1120 result = self.vm.qmp('nbd-server-start',
1123 'data': {'path': nbd_sock_path}
1125 self.assert_qmp(result, 'return', {})
1127 result = self.vm.qmp('drive-mirror', job_id='mirror', device='quorum0',
1128 sync='full', node_name='repair0', replaces='img1',
1129 target=quorum_repair_img, format=iotests.imgfmt)
1130 self.assert_qmp(result, 'return', {})
1132 result = self.vm.qmp('nbd-server-add', device='img1')
1133 self.assert_qmp(result, 'return', {})
1135 # The full error message goes to stderr, we will check it later
1136 self.complete_and_wait('mirror',
1137 completion_error='Operation not permitted')
1139 # Should not have been replaced
1140 self.vm.assert_block_path('quorum0', '/children.1', 'img1')
1142 # Check the full error message now
1144 log = self.vm.get_log()
1145 log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
1146 log = re.sub(r'^Formatting.*\n', '', log)
1147 log = re.sub(r'\n\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
1148 log = re.sub(r'^%s: ' % os.path.basename(iotests.qemu_prog), '', log)
1150 self.assertEqual(log,
1151 "Can no longer replace 'img1' by 'repair0', because " +
1152 "it can no longer be guaranteed that doing so would " +
1153 "not lead to an abrupt change of visible data")
1156 # Test mirroring with a source that does not have any parents (not even a
1158 class TestOrphanedSource(iotests.QMPTestCase):
1160 blk0 = { 'node-name': 'src',
1161 'driver': 'null-co' }
1163 blk1 = { 'node-name': 'dest',
1164 'driver': 'null-co' }
1166 blk2 = { 'node-name': 'dest-ro',
1167 'driver': 'null-co',
1170 self.vm = iotests.VM()
1171 self.vm.add_blockdev(self.vm.qmp_to_opts(blk0))
1172 self.vm.add_blockdev(self.vm.qmp_to_opts(blk1))
1173 self.vm.add_blockdev(self.vm.qmp_to_opts(blk2))
1179 def test_no_job_id(self):
1180 self.assert_no_active_block_jobs()
1182 result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
1184 self.assert_qmp(result, 'error/class', 'GenericError')
1186 def test_success(self):
1187 self.assert_no_active_block_jobs()
1189 result = self.vm.qmp('blockdev-mirror', job_id='job', device='src',
1190 sync='full', target='dest')
1191 self.assert_qmp(result, 'return', {})
1193 self.complete_and_wait('job')
1195 def test_failing_permissions(self):
1196 self.assert_no_active_block_jobs()
1198 result = self.vm.qmp('blockdev-mirror', device='src', sync='full',
1200 self.assert_qmp(result, 'error/class', 'GenericError')
1202 def test_failing_permission_in_complete(self):
1203 self.assert_no_active_block_jobs()
1205 # Unshare consistent-read on the target
1206 # (The mirror job does not care)
1207 result = self.vm.qmp('blockdev-add',
1209 node_name='dest-perm',
1211 unshare_child_perms=['consistent-read'])
1212 self.assert_qmp(result, 'return', {})
1214 result = self.vm.qmp('blockdev-mirror', job_id='job', device='src',
1215 sync='full', target='dest',
1216 filter_node_name='mirror-filter')
1217 self.assert_qmp(result, 'return', {})
1219 # Require consistent-read on the source
1220 # (We can only add this node once the job has started, or it
1221 # will complain that it does not want to run on non-root nodes)
1222 result = self.vm.qmp('blockdev-add',
1224 node_name='src-perm',
1226 take_child_perms=['consistent-read'])
1227 self.assert_qmp(result, 'return', {})
1229 # While completing, mirror will attempt to replace src by
1230 # dest, which must fail because src-perm requires
1231 # consistent-read but dest-perm does not share it; thus
1232 # aborting the job when it is supposed to complete
1233 self.complete_and_wait('job',
1234 completion_error='Operation not permitted')
1236 # Assert that all of our nodes are still there (except for the
1237 # mirror filter, which should be gone despite the failure)
1238 nodes = self.vm.qmp('query-named-block-nodes')['return']
1239 nodes = [node['node-name'] for node in nodes]
1241 for expect in ('src', 'src-perm', 'dest', 'dest-perm'):
1242 self.assertTrue(expect in nodes, '%s disappeared' % expect)
1243 self.assertFalse('mirror-filter' in nodes,
1244 'Mirror filter node did not disappear')
1246 # Test cases for @replaces that do not necessarily involve Quorum
1247 class TestReplaces(iotests.QMPTestCase):
1248 # Each of these test cases needs their own block graph, so do not
1249 # create any nodes here
1251 self.vm = iotests.VM()
1256 for img in (test_img, target_img):
1262 @iotests.skip_if_unsupported(['copy-on-read'])
1263 def test_replace_filter(self):
1265 Check that we can replace filter nodes.
1267 result = self.vm.qmp('blockdev-add', **{
1268 'driver': 'copy-on-read',
1269 'node-name': 'filter0',
1271 'driver': 'copy-on-read',
1272 'node-name': 'filter1',
1278 self.assert_qmp(result, 'return', {})
1280 result = self.vm.qmp('blockdev-add',
1281 node_name='target', driver='null-co')
1282 self.assert_qmp(result, 'return', {})
1284 result = self.vm.qmp('blockdev-mirror', job_id='mirror', device='filter0',
1285 target='target', sync='full', replaces='filter1')
1286 self.assert_qmp(result, 'return', {})
1288 self.complete_and_wait('mirror')
1290 self.vm.assert_block_path('filter0', '/file', 'target')
1292 # Tests for mirror with filters (and how the mirror filter behaves, as
1293 # an example for an implicit filter)
1294 class TestFilters(iotests.QMPTestCase):
1296 qemu_img('create', '-f', iotests.imgfmt, backing_img, '1M')
1297 qemu_img('create', '-f', iotests.imgfmt, '-b', backing_img, test_img)
1298 qemu_img('create', '-f', iotests.imgfmt, '-b', backing_img, target_img)
1300 qemu_io('-c', 'write -P 1 0 512k', backing_img)
1301 qemu_io('-c', 'write -P 2 512k 512k', test_img)
1303 self.vm = iotests.VM().add_device('virtio-scsi,id=vio-scsi')
1306 result = self.vm.qmp('blockdev-add', **{
1307 'node-name': 'target',
1308 'driver': iotests.imgfmt,
1311 'filename': target_img
1315 self.assert_qmp(result, 'return', {})
1317 self.filterless_chain = {
1318 'node-name': 'source',
1319 'driver': iotests.imgfmt,
1322 'filename': test_img
1325 'node-name': 'backing',
1326 'driver': iotests.imgfmt,
1329 'filename': backing_img
1338 os.remove(target_img)
1339 os.remove(backing_img)
1342 result = self.vm.qmp('blockdev-add', **{
1343 'node-name': 'filter',
1344 'driver': 'copy-on-read',
1345 'file': self.filterless_chain
1347 self.assert_qmp(result, 'return', {})
1349 result = self.vm.qmp('blockdev-mirror',
1354 self.assert_qmp(result, 'return', {})
1356 self.complete_and_wait('mirror')
1358 self.vm.qmp('blockdev-del', node_name='target')
1360 target_map = qemu_img_pipe('map', '--output=json', target_img)
1361 target_map = json.loads(target_map)
1363 assert target_map[0]['start'] == 0
1364 assert target_map[0]['length'] == 512 * 1024
1365 assert target_map[0]['depth'] == 1
1367 assert target_map[1]['start'] == 512 * 1024
1368 assert target_map[1]['length'] == 512 * 1024
1369 assert target_map[1]['depth'] == 0
1371 def test_implicit_mirror_filter(self):
1372 result = self.vm.qmp('blockdev-add', **self.filterless_chain)
1373 self.assert_qmp(result, 'return', {})
1375 # We need this so we can query from above the mirror node
1376 result = self.vm.qmp('device_add',
1381 self.assert_qmp(result, 'return', {})
1383 result = self.vm.qmp('blockdev-mirror',
1388 self.assert_qmp(result, 'return', {})
1390 # The mirror filter is now an implicit node, so it should be
1391 # invisible when querying the backing chain
1392 blockdevs = self.vm.qmp('query-block')['return']
1393 device_info = next(dev for dev in blockdevs if dev['qdev'] == 'virtio')
1395 assert device_info['inserted']['node-name'] == 'source'
1397 image_info = device_info['inserted']['image']
1398 assert image_info['filename'] == test_img
1399 assert image_info['backing-image']['filename'] == backing_img
1401 self.complete_and_wait('mirror')
1403 def test_explicit_mirror_filter(self):
1404 # Same test as above, but this time we give the mirror filter
1405 # a node-name so it will not be invisible
1406 result = self.vm.qmp('blockdev-add', **self.filterless_chain)
1407 self.assert_qmp(result, 'return', {})
1409 # We need this so we can query from above the mirror node
1410 result = self.vm.qmp('device_add',
1415 self.assert_qmp(result, 'return', {})
1417 result = self.vm.qmp('blockdev-mirror',
1422 filter_node_name='mirror-filter')
1423 self.assert_qmp(result, 'return', {})
1425 # With a node-name given to it, the mirror filter should now
1427 blockdevs = self.vm.qmp('query-block')['return']
1428 device_info = next(dev for dev in blockdevs if dev['qdev'] == 'virtio')
1430 assert device_info['inserted']['node-name'] == 'mirror-filter'
1432 self.complete_and_wait('mirror')
1435 if __name__ == '__main__':
1436 iotests.main(supported_fmts=['qcow2', 'qed'],
1437 supported_protocols=['file'],
1438 supported_platforms=['linux', 'freebsd', 'netbsd', 'openbsd'])