xref: /qemu/tests/qemu-iotests/257 (revision abff1abf) 
1#!/usr/bin/env python3
2#
3# Test bitmap-sync backups (incremental, differential, and partials)
4#
5# Copyright (c) 2019 John Snow for Red Hat, Inc.
6#
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.
11#
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.
16#
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/>.
19#
20# owner=jsnow@redhat.com
21
22import math
23import os
24
25import iotests
26from iotests import log, qemu_img
27
28SIZE = 64 * 1024 * 1024
29GRANULARITY = 64 * 1024
30
31
32class Pattern:
33    def __init__(self, byte, offset, size=GRANULARITY):
34        self.byte = byte
35        self.offset = offset
36        self.size = size
37
38    def bits(self, granularity):
39        lower = self.offset // granularity
40        upper = (self.offset + self.size - 1) // granularity
41        return set(range(lower, upper + 1))
42
43
44class PatternGroup:
45    """Grouping of Pattern objects. Initialize with an iterable of Patterns."""
46    def __init__(self, patterns):
47        self.patterns = patterns
48
49    def bits(self, granularity):
50        """Calculate the unique bits dirtied by this pattern grouping"""
51        res = set()
52        for pattern in self.patterns:
53            res |= pattern.bits(granularity)
54        return res
55
56
57GROUPS = [
58    PatternGroup([
59        # Batch 0: 4 clusters
60        Pattern('0x49', 0x0000000),
61        Pattern('0x6c', 0x0100000),   # 1M
62        Pattern('0x6f', 0x2000000),   # 32M
63        Pattern('0x76', 0x3ff0000)]), # 64M - 64K
64    PatternGroup([
65        # Batch 1: 6 clusters (3 new)
66        Pattern('0x65', 0x0000000),   # Full overwrite
67        Pattern('0x77', 0x00f8000),   # Partial-left (1M-32K)
68        Pattern('0x72', 0x2008000),   # Partial-right (32M+32K)
69        Pattern('0x69', 0x3fe0000)]), # Adjacent-left (64M - 128K)
70    PatternGroup([
71        # Batch 2: 7 clusters (3 new)
72        Pattern('0x74', 0x0010000),   # Adjacent-right
73        Pattern('0x69', 0x00e8000),   # Partial-left  (1M-96K)
74        Pattern('0x6e', 0x2018000),   # Partial-right (32M+96K)
75        Pattern('0x67', 0x3fe0000,
76                2*GRANULARITY)]),     # Overwrite [(64M-128K)-64M)
77    PatternGroup([
78        # Batch 3: 8 clusters (5 new)
79        # Carefully chosen such that nothing re-dirties the one cluster
80        # that copies out successfully before failure in Group #1.
81        Pattern('0xaa', 0x0010000,
82                3*GRANULARITY),       # Overwrite and 2x Adjacent-right
83        Pattern('0xbb', 0x00d8000),   # Partial-left (1M-160K)
84        Pattern('0xcc', 0x2028000),   # Partial-right (32M+160K)
85        Pattern('0xdd', 0x3fc0000)]), # New; leaving a gap to the right
86]
87
88
89class EmulatedBitmap:
90    def __init__(self, granularity=GRANULARITY):
91        self._bits = set()
92        self.granularity = granularity
93
94    def dirty_bits(self, bits):
95        self._bits |= set(bits)
96
97    def dirty_group(self, n):
98        self.dirty_bits(GROUPS[n].bits(self.granularity))
99
100    def clear(self):
101        self._bits = set()
102
103    def clear_bits(self, bits):
104        self._bits -= set(bits)
105
106    def clear_bit(self, bit):
107        self.clear_bits({bit})
108
109    def clear_group(self, n):
110        self.clear_bits(GROUPS[n].bits(self.granularity))
111
112    @property
113    def first_bit(self):
114        return sorted(self.bits)[0]
115
116    @property
117    def bits(self):
118        return self._bits
119
120    @property
121    def count(self):
122        return len(self.bits)
123
124    def compare(self, qmp_bitmap):
125        """
126        Print a nice human-readable message checking that a bitmap as reported
127        by the QMP interface has as many bits set as we expect it to.
128        """
129
130        name = qmp_bitmap.get('name', '(anonymous)')
131        log("= Checking Bitmap {:s} =".format(name))
132
133        want = self.count
134        have = qmp_bitmap['count'] // qmp_bitmap['granularity']
135
136        log("expecting {:d} dirty sectors; have {:d}. {:s}".format(
137            want, have, "OK!" if want == have else "ERROR!"))
138        log('')
139
140
141class Drive:
142    """Represents, vaguely, a drive attached to a VM.
143    Includes format, graph, and device information."""
144
145    def __init__(self, path, vm=None):
146        self.path = path
147        self.vm = vm
148        self.fmt = None
149        self.size = None
150        self.node = None
151
152    def img_create(self, fmt, size):
153        self.fmt = fmt
154        self.size = size
155        iotests.qemu_img_create('-f', self.fmt, self.path, str(self.size))
156
157    def create_target(self, name, fmt, size):
158        basename = os.path.basename(self.path)
159        file_node_name = "file_{}".format(basename)
160        vm = self.vm
161
162        log(vm.command('blockdev-create', job_id='bdc-file-job',
163                       options={
164                           'driver': 'file',
165                           'filename': self.path,
166                           'size': 0,
167                       }))
168        vm.run_job('bdc-file-job')
169        log(vm.command('blockdev-add', driver='file',
170                       node_name=file_node_name, filename=self.path))
171
172        log(vm.command('blockdev-create', job_id='bdc-fmt-job',
173                       options={
174                           'driver': fmt,
175                           'file': file_node_name,
176                           'size': size,
177                       }))
178        vm.run_job('bdc-fmt-job')
179        log(vm.command('blockdev-add', driver=fmt,
180                       node_name=name,
181                       file=file_node_name))
182        self.fmt = fmt
183        self.size = size
184        self.node = name
185
186def blockdev_backup(vm, device, target, sync, **kwargs):
187    # Strip any arguments explicitly nulled by the caller:
188    kwargs = {key: val for key, val in kwargs.items() if val is not None}
189    result = vm.qmp_log('blockdev-backup',
190                        device=device,
191                        target=target,
192                        sync=sync,
193                        filter_node_name='backup-top',
194                        **kwargs)
195    return result
196
197def blockdev_backup_mktarget(drive, target_id, filepath, sync, **kwargs):
198    target_drive = Drive(filepath, vm=drive.vm)
199    target_drive.create_target(target_id, drive.fmt, drive.size)
200    blockdev_backup(drive.vm, drive.node, target_id, sync, **kwargs)
201
202def reference_backup(drive, n, filepath):
203    log("--- Reference Backup #{:d} ---\n".format(n))
204    target_id = "ref_target_{:d}".format(n)
205    job_id = "ref_backup_{:d}".format(n)
206    blockdev_backup_mktarget(drive, target_id, filepath, "full",
207                             job_id=job_id)
208    drive.vm.run_job(job_id, auto_dismiss=True)
209    log('')
210
211def backup(drive, n, filepath, sync, **kwargs):
212    log("--- Test Backup #{:d} ---\n".format(n))
213    target_id = "backup_target_{:d}".format(n)
214    job_id = "backup_{:d}".format(n)
215    kwargs.setdefault('auto-finalize', False)
216    blockdev_backup_mktarget(drive, target_id, filepath, sync,
217                             job_id=job_id, **kwargs)
218    return job_id
219
220def perform_writes(drive, n, filter_node_name=None):
221    log("--- Write #{:d} ---\n".format(n))
222    for pattern in GROUPS[n].patterns:
223        cmd = "write -P{:s} 0x{:07x} 0x{:x}".format(
224            pattern.byte,
225            pattern.offset,
226            pattern.size)
227        log(cmd)
228        log(drive.vm.hmp_qemu_io(filter_node_name or drive.node, cmd))
229    bitmaps = drive.vm.query_bitmaps()
230    log({'bitmaps': bitmaps}, indent=2)
231    log('')
232    return bitmaps
233
234
235def compare_images(image, reference, baseimg=None, expected_match=True):
236    """
237    Print a nice human-readable message comparing these images.
238    """
239    expected_ret = 0 if expected_match else 1
240    if baseimg:
241        assert qemu_img("rebase", "-u", "-b", baseimg, '-F', iotests.imgfmt,
242                        image) == 0
243    ret = qemu_img("compare", image, reference)
244    log('qemu_img compare "{:s}" "{:s}" ==> {:s}, {:s}'.format(
245        image, reference,
246        "Identical" if ret == 0 else "Mismatch",
247        "OK!" if ret == expected_ret else "ERROR!"),
248        filters=[iotests.filter_testfiles])
249
250def test_bitmap_sync(bsync_mode, msync_mode='bitmap', failure=None):
251    """
252    Test bitmap backup routines.
253
254    :param bsync_mode: Is the Bitmap Sync mode, and can be any of:
255        - on-success: This is the "incremental" style mode. Bitmaps are
256                      synchronized to what was copied out only on success.
257                      (Partial images must be discarded.)
258        - never:      This is the "differential" style mode.
259                      Bitmaps are never synchronized.
260        - always:     This is a "best effort" style mode.
261                      Bitmaps are always synchronized, regardless of failure.
262                      (Partial images must be kept.)
263
264    :param msync_mode: The mirror sync mode to use for the first backup.
265                       Can be any one of:
266        - bitmap: Backups based on bitmap manifest.
267        - full:   Full backups.
268        - top:    Full backups of the top layer only.
269
270    :param failure: Is the (optional) failure mode, and can be any of:
271        - None:         No failure. Test the normative path. Default.
272        - simulated:    Cancel the job right before it completes.
273                        This also tests writes "during" the job.
274        - intermediate: This tests a job that fails mid-process and produces
275                        an incomplete backup. Testing limitations prevent
276                        testing competing writes.
277    """
278    with iotests.FilePaths(['img', 'bsync1', 'bsync2',
279                            'fbackup0', 'fbackup1', 'fbackup2']) as \
280                            (img_path, bsync1, bsync2,
281                             fbackup0, fbackup1, fbackup2), \
282         iotests.VM() as vm:
283
284        mode = "Mode {:s}; Bitmap Sync {:s}".format(msync_mode, bsync_mode)
285        preposition = "with" if failure else "without"
286        cond = "{:s} {:s}".format(preposition,
287                                  "{:s} failure".format(failure) if failure
288                                  else "failure")
289        log("\n=== {:s} {:s} ===\n".format(mode, cond))
290
291        log('--- Preparing image & VM ---\n')
292        drive0 = Drive(img_path, vm=vm)
293        drive0.img_create(iotests.imgfmt, SIZE)
294        vm.add_device("{},id=scsi0".format(iotests.get_virtio_scsi_device()))
295        vm.launch()
296
297        file_config = {
298            'driver': 'file',
299            'filename': drive0.path
300        }
301
302        if failure == 'intermediate':
303            file_config = {
304                'driver': 'blkdebug',
305                'image': file_config,
306                'set-state': [{
307                    'event': 'flush_to_disk',
308                    'state': 1,
309                    'new_state': 2
310                }, {
311                    'event': 'read_aio',
312                    'state': 2,
313                    'new_state': 3
314                }],
315                'inject-error': [{
316                    'event': 'read_aio',
317                    'errno': 5,
318                    'state': 3,
319                    'immediately': False,
320                    'once': True
321                }]
322            }
323
324        drive0.node = 'drive0'
325        vm.qmp_log('blockdev-add',
326                   filters=[iotests.filter_qmp_testfiles],
327                   node_name=drive0.node,
328                   driver=drive0.fmt,
329                   file=file_config)
330        log('')
331
332        # 0 - Writes and Reference Backup
333        perform_writes(drive0, 0)
334        reference_backup(drive0, 0, fbackup0)
335        log('--- Add Bitmap ---\n')
336        vm.qmp_log("block-dirty-bitmap-add", node=drive0.node,
337                   name="bitmap0", granularity=GRANULARITY)
338        log('')
339        ebitmap = EmulatedBitmap()
340
341        # 1 - Writes and Reference Backup
342        bitmaps = perform_writes(drive0, 1)
343        ebitmap.dirty_group(1)
344        bitmap = vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps)
345        ebitmap.compare(bitmap)
346        reference_backup(drive0, 1, fbackup1)
347
348        # 1 - Test Backup (w/ Optional induced failure)
349        if failure == 'intermediate':
350            # Activate blkdebug induced failure for second-to-next read
351            log(vm.hmp_qemu_io(drive0.node, 'flush'))
352            log('')
353        job = backup(drive0, 1, bsync1, msync_mode,
354                     bitmap="bitmap0", bitmap_mode=bsync_mode)
355
356        def _callback():
357            """Issue writes while the job is open to test bitmap divergence."""
358            # Note: when `failure` is 'intermediate', this isn't called.
359            log('')
360            bitmaps = perform_writes(drive0, 2, filter_node_name='backup-top')
361            # Named bitmap (static, should be unchanged)
362            ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0',
363                                          bitmaps=bitmaps))
364            # Anonymous bitmap (dynamic, shows new writes)
365            anonymous = EmulatedBitmap()
366            anonymous.dirty_group(2)
367            anonymous.compare(vm.get_bitmap(drive0.node, '', recording=True,
368                                            bitmaps=bitmaps))
369
370            # Simulate the order in which this will happen:
371            # group 1 gets cleared first, then group two gets written.
372            if ((bsync_mode == 'on-success' and not failure) or
373                (bsync_mode == 'always')):
374                ebitmap.clear()
375            ebitmap.dirty_group(2)
376
377        vm.run_job(job, auto_dismiss=True, auto_finalize=False,
378                   pre_finalize=_callback,
379                   cancel=(failure == 'simulated'))
380        bitmaps = vm.query_bitmaps()
381        log({'bitmaps': bitmaps}, indent=2)
382        log('')
383
384        if bsync_mode == 'always' and failure == 'intermediate':
385            # TOP treats anything allocated as dirty, expect to see:
386            if msync_mode == 'top':
387                ebitmap.dirty_group(0)
388
389            # We manage to copy one sector (one bit) before the error.
390            ebitmap.clear_bit(ebitmap.first_bit)
391
392            # Full returns all bits set except what was copied/skipped
393            if msync_mode == 'full':
394                fail_bit = ebitmap.first_bit
395                ebitmap.clear()
396                ebitmap.dirty_bits(range(fail_bit, SIZE // GRANULARITY))
397
398        ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
399
400        # 2 - Writes and Reference Backup
401        bitmaps = perform_writes(drive0, 3)
402        ebitmap.dirty_group(3)
403        ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
404        reference_backup(drive0, 2, fbackup2)
405
406        # 2 - Bitmap Backup (In failure modes, this is a recovery.)
407        job = backup(drive0, 2, bsync2, "bitmap",
408                     bitmap="bitmap0", bitmap_mode=bsync_mode)
409        vm.run_job(job, auto_dismiss=True, auto_finalize=False)
410        bitmaps = vm.query_bitmaps()
411        log({'bitmaps': bitmaps}, indent=2)
412        log('')
413        if bsync_mode != 'never':
414            ebitmap.clear()
415        ebitmap.compare(vm.get_bitmap(drive0.node, 'bitmap0', bitmaps=bitmaps))
416
417        log('--- Cleanup ---\n')
418        vm.qmp_log("block-dirty-bitmap-remove",
419                   node=drive0.node, name="bitmap0")
420        bitmaps = vm.query_bitmaps()
421        log({'bitmaps': bitmaps}, indent=2)
422        vm.shutdown()
423        log('')
424
425        log('--- Verification ---\n')
426        # 'simulated' failures will actually all pass here because we canceled
427        # while "pending". This is actually undefined behavior,
428        # don't rely on this to be true!
429        compare_images(bsync1, fbackup1, baseimg=fbackup0,
430                       expected_match=failure != 'intermediate')
431        if not failure or bsync_mode == 'always':
432            # Always keep the last backup on success or when using 'always'
433            base = bsync1
434        else:
435            base = fbackup0
436        compare_images(bsync2, fbackup2, baseimg=base)
437        compare_images(img_path, fbackup2)
438        log('')
439
440def test_backup_api():
441    """
442    Test malformed and prohibited invocations of the backup API.
443    """
444    with iotests.FilePaths(['img', 'bsync1']) as \
445         (img_path, backup_path), \
446         iotests.VM() as vm:
447
448        log("\n=== API failure tests ===\n")
449        log('--- Preparing image & VM ---\n')
450        drive0 = Drive(img_path, vm=vm)
451        drive0.img_create(iotests.imgfmt, SIZE)
452        vm.add_device("{},id=scsi0".format(iotests.get_virtio_scsi_device()))
453        vm.launch()
454
455        file_config = {
456            'driver': 'file',
457            'filename': drive0.path
458        }
459
460        drive0.node = 'drive0'
461        vm.qmp_log('blockdev-add',
462                   filters=[iotests.filter_qmp_testfiles],
463                   node_name=drive0.node,
464                   driver=drive0.fmt,
465                   file=file_config)
466        log('')
467
468        target0 = Drive(backup_path, vm=vm)
469        target0.create_target("backup_target", drive0.fmt, drive0.size)
470        log('')
471
472        vm.qmp_log("block-dirty-bitmap-add", node=drive0.node,
473                   name="bitmap0", granularity=GRANULARITY)
474        log('')
475
476        log('-- Testing invalid QMP commands --\n')
477
478        error_cases = {
479            'incremental': {
480                None:        ['on-success', 'always', 'never', None],
481                'bitmap404': ['on-success', 'always', 'never', None],
482                'bitmap0':   ['always', 'never']
483            },
484            'bitmap': {
485                None:        ['on-success', 'always', 'never', None],
486                'bitmap404': ['on-success', 'always', 'never', None],
487                'bitmap0':   [None],
488            },
489            'full': {
490                None:        ['on-success', 'always', 'never'],
491                'bitmap404': ['on-success', 'always', 'never', None],
492                'bitmap0':   ['never', None],
493            },
494            'top': {
495                None:        ['on-success', 'always', 'never'],
496                'bitmap404': ['on-success', 'always', 'never', None],
497                'bitmap0':   ['never', None],
498            },
499            'none': {
500                None:        ['on-success', 'always', 'never'],
501                'bitmap404': ['on-success', 'always', 'never', None],
502                'bitmap0':   ['on-success', 'always', 'never', None],
503            }
504        }
505
506        # Dicts, as always, are not stably-ordered prior to 3.7, so use tuples:
507        for sync_mode in ('incremental', 'bitmap', 'full', 'top', 'none'):
508            log("-- Sync mode {:s} tests --\n".format(sync_mode))
509            for bitmap in (None, 'bitmap404', 'bitmap0'):
510                for policy in error_cases[sync_mode][bitmap]:
511                    blockdev_backup(drive0.vm, drive0.node, "backup_target",
512                                    sync_mode, job_id='api_job',
513                                    bitmap=bitmap, bitmap_mode=policy)
514                    log('')
515
516
517def main():
518    for bsync_mode in ("never", "on-success", "always"):
519        for failure in ("simulated", "intermediate", None):
520            test_bitmap_sync(bsync_mode, "bitmap", failure)
521
522    for sync_mode in ('full', 'top'):
523        for bsync_mode in ('on-success', 'always'):
524            for failure in ('simulated', 'intermediate', None):
525                test_bitmap_sync(bsync_mode, sync_mode, failure)
526
527    test_backup_api()
528
529if __name__ == '__main__':
530    iotests.script_main(main, supported_fmts=['qcow2'],
531                        supported_protocols=['file'])
532