3 # Tests for incremental drive-backup
5 # Copyright (C) 2015 John Snow for Red Hat, Inc.
9 # This program is free software; you can redistribute it and/or modify
10 # it under the terms of the GNU General Public License as published by
11 # the Free Software Foundation; either version 2 of the License, or
12 # (at your option) any later version.
14 # This program is distributed in the hope that it will be useful,
15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 # GNU General Public License for more details.
19 # You should have received a copy of the GNU General Public License
20 # along with this program. If not, see <http://www.gnu.org/licenses/>.
27 def io_write_patterns(img
, patterns
):
28 for pattern
in patterns
:
29 iotests
.qemu_io('-c', 'write -P%s %s %s' % pattern
, img
)
40 def __init__(self
, name
, drive
):
46 def base_target(self
):
47 return (self
.drive
['backup'], None)
49 def new_target(self
, num
=None):
53 base
= os
.path
.join(iotests
.test_dir
,
54 "%s.%s." % (self
.drive
['id'], self
.name
))
55 suff
= "%i.%s" % (num
, self
.drive
['fmt'])
56 target
= base
+ "inc" + suff
57 reference
= base
+ "ref" + suff
58 self
.backups
.append((target
, reference
))
59 return (target
, reference
)
61 def last_target(self
):
63 return self
.backups
[-1]
64 return self
.base_target()
67 for image
in self
.backups
.pop():
72 for backup
in self
.backups
:
77 class TestIncrementalBackup(iotests
.QMPTestCase
):
82 self
.vm
= iotests
.VM()
83 self
.err_img
= os
.path
.join(iotests
.test_dir
, 'err.%s' % iotests
.imgfmt
)
85 # Create a base image with a distinctive patterning
86 drive0
= self
.add_node('drive0')
87 self
.img_create(drive0
['file'], drive0
['fmt'])
88 self
.vm
.add_drive(drive0
['file'])
89 io_write_patterns(drive0
['file'], (('0x41', 0, 512),
90 ('0xd5', '1M', '32k'),
91 ('0xdc', '32M', '124k')))
95 def add_node(self
, node_id
, fmt
=iotests
.imgfmt
, path
=None, backup
=None):
97 path
= os
.path
.join(iotests
.test_dir
, '%s.%s' % (node_id
, fmt
))
99 backup
= os
.path
.join(iotests
.test_dir
,
100 '%s.full.backup.%s' % (node_id
, fmt
))
107 return self
.drives
[-1]
110 def img_create(self
, img
, fmt
=iotests
.imgfmt
, size
='64M',
111 parent
=None, parentFormat
=None):
113 if parentFormat
is None:
115 iotests
.qemu_img('create', '-f', fmt
, img
, size
,
116 '-b', parent
, '-F', parentFormat
)
118 iotests
.qemu_img('create', '-f', fmt
, img
, size
)
119 self
.files
.append(img
)
122 def do_qmp_backup(self
, error
='Input/output error', **kwargs
):
123 res
= self
.vm
.qmp('drive-backup', **kwargs
)
124 self
.assert_qmp(res
, 'return', {})
126 event
= self
.vm
.event_wait(name
="BLOCK_JOB_COMPLETED",
127 match
={'data': {'device': kwargs
['device']}})
128 self
.assertNotEqual(event
, None)
131 failure
= self
.dictpath(event
, 'data/error')
132 except AssertionError:
134 self
.assert_qmp(event
, 'data/offset', event
['data']['len'])
138 self
.assert_qmp(event
, 'data/error', error
)
142 def create_anchor_backup(self
, drive
=None):
144 drive
= self
.drives
[-1]
145 res
= self
.do_qmp_backup(device
=drive
['id'], sync
='full',
146 format
=drive
['fmt'], target
=drive
['backup'])
148 self
.files
.append(drive
['backup'])
149 return drive
['backup']
152 def make_reference_backup(self
, bitmap
=None):
154 bitmap
= self
.bitmaps
[-1]
155 _
, reference
= bitmap
.last_target()
156 res
= self
.do_qmp_backup(device
=bitmap
.drive
['id'], sync
='full',
157 format
=bitmap
.drive
['fmt'], target
=reference
)
161 def add_bitmap(self
, name
, drive
, **kwargs
):
162 bitmap
= Bitmap(name
, drive
)
163 self
.bitmaps
.append(bitmap
)
164 result
= self
.vm
.qmp('block-dirty-bitmap-add', node
=drive
['id'],
165 name
=bitmap
.name
, **kwargs
)
166 self
.assert_qmp(result
, 'return', {})
170 def prepare_backup(self
, bitmap
=None, parent
=None):
172 bitmap
= self
.bitmaps
[-1]
174 parent
, _
= bitmap
.last_target()
176 target
, _
= bitmap
.new_target()
177 self
.img_create(target
, bitmap
.drive
['fmt'], parent
=parent
)
181 def create_incremental(self
, bitmap
=None, parent
=None,
182 parentFormat
=None, validate
=True):
184 bitmap
= self
.bitmaps
[-1]
186 parent
, _
= bitmap
.last_target()
188 target
= self
.prepare_backup(bitmap
, parent
)
189 res
= self
.do_qmp_backup(device
=bitmap
.drive
['id'],
190 sync
='dirty-bitmap', bitmap
=bitmap
.name
,
191 format
=bitmap
.drive
['fmt'], target
=target
,
195 self
.assertFalse(validate
)
197 self
.make_reference_backup(bitmap
)
201 def check_backups(self
):
202 for bitmap
in self
.bitmaps
:
203 for incremental
, reference
in bitmap
.backups
:
204 self
.assertTrue(iotests
.compare_images(incremental
, reference
))
205 last
= bitmap
.last_target()[0]
206 self
.assertTrue(iotests
.compare_images(last
, bitmap
.drive
['file']))
209 def hmp_io_writes(self
, drive
, patterns
):
210 for pattern
in patterns
:
211 self
.vm
.hmp_qemu_io(drive
, 'write -P%s %s %s' % pattern
)
212 self
.vm
.hmp_qemu_io(drive
, 'flush')
215 def do_incremental_simple(self
, **kwargs
):
216 self
.create_anchor_backup()
217 self
.add_bitmap('bitmap0', self
.drives
[0], **kwargs
)
219 # Sanity: Create a "hollow" incremental backup
220 self
.create_incremental()
221 # Three writes: One complete overwrite, one new segment,
222 # and one partial overlap.
223 self
.hmp_io_writes(self
.drives
[0]['id'], (('0xab', 0, 512),
224 ('0xfe', '16M', '256k'),
225 ('0x64', '32736k', '64k')))
226 self
.create_incremental()
227 # Three more writes, one of each kind, like above
228 self
.hmp_io_writes(self
.drives
[0]['id'], (('0x9a', 0, 512),
229 ('0x55', '8M', '352k'),
230 ('0x78', '15872k', '1M')))
231 self
.create_incremental()
236 def test_incremental_simple(self
):
238 Test: Create and verify three incremental backups.
240 Create a bitmap and a full backup before VM execution begins,
241 then create a series of three incremental backups "during execution,"
242 i.e.; after IO requests begin modifying the drive.
244 return self
.do_incremental_simple()
247 def test_small_granularity(self
):
249 Test: Create and verify backups made with a small granularity bitmap.
251 Perform the same test as test_incremental_simple, but with a granularity
252 of only 32KiB instead of the present default of 64KiB.
254 return self
.do_incremental_simple(granularity
=32768)
257 def test_large_granularity(self
):
259 Test: Create and verify backups made with a large granularity bitmap.
261 Perform the same test as test_incremental_simple, but with a granularity
262 of 128KiB instead of the present default of 64KiB.
264 return self
.do_incremental_simple(granularity
=131072)
267 def test_incremental_failure(self
):
268 '''Test: Verify backups made after a failure are correct.
270 Simulate a failure during an incremental backup block job,
271 emulate additional writes, then create another incremental backup
272 afterwards and verify that the backup created is correct.
275 # Create a blkdebug interface to this img as 'drive1',
276 # but don't actually create a new image.
277 drive1
= self
.add_node('drive1', self
.drives
[0]['fmt'],
278 path
=self
.drives
[0]['file'],
279 backup
=self
.drives
[0]['backup'])
280 result
= self
.vm
.qmp('blockdev-add', options
={
282 'driver': drive1
['fmt'],
284 'driver': 'blkdebug',
287 'filename': drive1
['file']
290 'event': 'flush_to_disk',
298 'immediately': False,
303 self
.assert_qmp(result
, 'return', {})
305 self
.create_anchor_backup(self
.drives
[0])
306 self
.add_bitmap('bitmap0', drive1
)
307 # Note: at this point, during a normal execution,
308 # Assume that the VM resumes and begins issuing IO requests here.
310 self
.hmp_io_writes(drive1
['id'], (('0xab', 0, 512),
311 ('0xfe', '16M', '256k'),
312 ('0x64', '32736k', '64k')))
314 result
= self
.create_incremental(validate
=False)
315 self
.assertFalse(result
)
316 self
.hmp_io_writes(drive1
['id'], (('0x9a', 0, 512),
317 ('0x55', '8M', '352k'),
318 ('0x78', '15872k', '1M')))
319 self
.create_incremental()
324 def test_sync_dirty_bitmap_missing(self
):
325 self
.assert_no_active_block_jobs()
326 self
.files
.append(self
.err_img
)
327 result
= self
.vm
.qmp('drive-backup', device
=self
.drives
[0]['id'],
328 sync
='dirty-bitmap', format
=self
.drives
[0]['fmt'],
330 self
.assert_qmp(result
, 'error/class', 'GenericError')
333 def test_sync_dirty_bitmap_not_found(self
):
334 self
.assert_no_active_block_jobs()
335 self
.files
.append(self
.err_img
)
336 result
= self
.vm
.qmp('drive-backup', device
=self
.drives
[0]['id'],
337 sync
='dirty-bitmap', bitmap
='unknown',
338 format
=self
.drives
[0]['fmt'], target
=self
.err_img
)
339 self
.assert_qmp(result
, 'error/class', 'GenericError')
342 def test_sync_dirty_bitmap_bad_granularity(self
):
344 Test: Test what happens if we provide an improper granularity.
346 The granularity must always be a power of 2.
348 self
.assert_no_active_block_jobs()
349 self
.assertRaises(AssertionError, self
.add_bitmap
,
350 'bitmap0', self
.drives
[0],
356 for bitmap
in self
.bitmaps
:
358 for filename
in self
.files
:
362 if __name__
== '__main__':
363 iotests
.main(supported_fmts
=['qcow2'])