1#!/usr/bin/env python3
2#
3# Tests for drive-backup
4#
5# Copyright (C) 2013 Red Hat, Inc.
6#
7# Based on 041.
8#
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.
13#
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.
18#
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/>.
21#
22
23import time
24import os
25import iotests
26from iotests import qemu_img, qemu_io, create_image
27
28backing_img = os.path.join(iotests.test_dir, 'backing.img')
29test_img = os.path.join(iotests.test_dir, 'test.img')
30target_img = os.path.join(iotests.test_dir, 'target.img')
31
32def img_create(img, fmt=iotests.imgfmt, size='64M', **kwargs):
33    fullname = os.path.join(iotests.test_dir, '%s.%s' % (img, fmt))
34    optargs = []
35    for k,v in kwargs.items():
36        optargs = optargs + ['-o', '%s=%s' % (k,v)]
37    args = ['create', '-f', fmt] + optargs + [fullname, size]
38    iotests.qemu_img(*args)
39    return fullname
40
41def try_remove(img):
42    try:
43        os.remove(img)
44    except OSError:
45        pass
46
47def io_write_patterns(img, patterns):
48    for pattern in patterns:
49        iotests.qemu_io('-c', 'write -P%s %s %s' % pattern, img)
50
51
52class TestSyncModesNoneAndTop(iotests.QMPTestCase):
53    image_len = 64 * 1024 * 1024 # MB
54
55    def setUp(self):
56        create_image(backing_img, TestSyncModesNoneAndTop.image_len)
57        qemu_img('create', '-f', iotests.imgfmt,
58                 '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img)
59        qemu_io('-c', 'write -P0x41 0 512', test_img)
60        qemu_io('-c', 'write -P0xd5 1M 32k', test_img)
61        qemu_io('-c', 'write -P0xdc 32M 124k', test_img)
62        qemu_io('-c', 'write -P0xdc 67043328 64k', test_img)
63        self.vm = iotests.VM().add_drive(test_img)
64        self.vm.launch()
65
66    def tearDown(self):
67        self.vm.shutdown()
68        os.remove(test_img)
69        os.remove(backing_img)
70        try:
71            os.remove(target_img)
72        except OSError:
73            pass
74
75    def test_complete_top(self):
76        self.assert_no_active_block_jobs()
77        result = self.vm.qmp('drive-backup', device='drive0', sync='top',
78                             format=iotests.imgfmt, target=target_img)
79        self.assert_qmp(result, 'return', {})
80
81        self.wait_until_completed(check_offset=False)
82
83        self.assert_no_active_block_jobs()
84        self.vm.shutdown()
85        self.assertTrue(iotests.compare_images(test_img, target_img),
86                        'target image does not match source after backup')
87
88    def test_cancel_sync_none(self):
89        self.assert_no_active_block_jobs()
90
91        result = self.vm.qmp('drive-backup', device='drive0',
92                             sync='none', target=target_img)
93        self.assert_qmp(result, 'return', {})
94        time.sleep(1)
95        self.vm.hmp_qemu_io('drive0', 'write -P0x5e 0 512')
96        self.vm.hmp_qemu_io('drive0', 'aio_flush')
97        # Verify that the original contents exist in the target image.
98
99        event = self.cancel_and_wait()
100        self.assert_qmp(event, 'data/type', 'backup')
101
102        self.vm.shutdown()
103        time.sleep(1)
104        self.assertEqual(-1, qemu_io('-c', 'read -P0x41 0 512', target_img).find("verification failed"))
105
106class TestBeforeWriteNotifier(iotests.QMPTestCase):
107    def setUp(self):
108        self.vm = iotests.VM().add_drive_raw("file=blkdebug::null-co://,id=drive0,align=65536,driver=blkdebug")
109        self.vm.launch()
110
111    def tearDown(self):
112        self.vm.shutdown()
113        os.remove(target_img)
114
115    def test_before_write_notifier(self):
116        self.vm.pause_drive("drive0")
117        result = self.vm.qmp('drive-backup', device='drive0',
118                             sync='full', target=target_img,
119                             format="file", speed=1)
120        self.assert_qmp(result, 'return', {})
121        result = self.vm.qmp('block-job-pause', device="drive0")
122        self.assert_qmp(result, 'return', {})
123        # Speed is low enough that this must be an uncopied range, which will
124        # trigger the before write notifier
125        self.vm.hmp_qemu_io('drive0', 'aio_write -P 1 512512 512')
126        self.vm.resume_drive("drive0")
127        result = self.vm.qmp('block-job-resume', device="drive0")
128        self.assert_qmp(result, 'return', {})
129        event = self.cancel_and_wait()
130        self.assert_qmp(event, 'data/type', 'backup')
131
132class BackupTest(iotests.QMPTestCase):
133    def setUp(self):
134        self.vm = iotests.VM()
135        self.test_img = img_create('test')
136        self.dest_img = img_create('dest')
137        self.dest_img2 = img_create('dest2')
138        self.ref_img = img_create('ref')
139        self.vm.add_drive(self.test_img)
140        self.vm.launch()
141
142    def tearDown(self):
143        self.vm.shutdown()
144        try_remove(self.test_img)
145        try_remove(self.dest_img)
146        try_remove(self.dest_img2)
147        try_remove(self.ref_img)
148
149    def hmp_io_writes(self, drive, patterns):
150        for pattern in patterns:
151            self.vm.hmp_qemu_io(drive, 'write -P%s %s %s' % pattern)
152        self.vm.hmp_qemu_io(drive, 'flush')
153
154    def qmp_backup_and_wait(self, cmd='drive-backup', serror=None,
155                            aerror=None, **kwargs):
156        if not self.qmp_backup(cmd, serror, **kwargs):
157            return False
158        return self.qmp_backup_wait(kwargs['device'], aerror)
159
160    def qmp_backup(self, cmd='drive-backup',
161                   error=None, **kwargs):
162        self.assertTrue('device' in kwargs)
163        res = self.vm.qmp(cmd, **kwargs)
164        if error:
165            self.assert_qmp(res, 'error/desc', error)
166            return False
167        self.assert_qmp(res, 'return', {})
168        return True
169
170    def qmp_backup_wait(self, device, error=None):
171        event = self.vm.event_wait(name="BLOCK_JOB_COMPLETED",
172                                   match={'data': {'device': device}})
173        self.assertNotEqual(event, None)
174        try:
175            failure = self.dictpath(event, 'data/error')
176        except AssertionError:
177            # Backup succeeded.
178            self.assert_qmp(event, 'data/offset', event['data']['len'])
179            return True
180        else:
181            # Failure.
182            self.assert_qmp(event, 'data/error', qerror)
183            return False
184
185    def test_overlapping_writes(self):
186        # Write something to back up
187        self.hmp_io_writes('drive0', [('42', '0M', '2M')])
188
189        # Create a reference backup
190        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
191                                 sync='full', target=self.ref_img,
192                                 auto_dismiss=False)
193        res = self.vm.qmp('block-job-dismiss', id='drive0')
194        self.assert_qmp(res, 'return', {})
195
196        # Now to the test backup: We simulate the following guest
197        # writes:
198        # (1) [1M + 64k, 1M + 128k): Afterwards, everything in that
199        #     area should be in the target image, and we must not copy
200        #     it again (because the source image has changed now)
201        #     (64k is the job's cluster size)
202        # (2) [1M, 2M): The backup job must not get overeager.  It
203        #     must copy [1M, 1M + 64k) and [1M + 128k, 2M) separately,
204        #     but not the area in between.
205
206        self.qmp_backup(device='drive0', format=iotests.imgfmt, sync='full',
207                        target=self.dest_img, speed=1, auto_dismiss=False)
208
209        self.hmp_io_writes('drive0', [('23', '%ik' % (1024 + 64), '64k'),
210                                      ('66', '1M', '1M')])
211
212        # Let the job complete
213        res = self.vm.qmp('block-job-set-speed', device='drive0', speed=0)
214        self.assert_qmp(res, 'return', {})
215        self.qmp_backup_wait('drive0')
216        res = self.vm.qmp('block-job-dismiss', id='drive0')
217        self.assert_qmp(res, 'return', {})
218
219        self.assertTrue(iotests.compare_images(self.ref_img, self.dest_img),
220                        'target image does not match reference image')
221
222    def test_dismiss_false(self):
223        res = self.vm.qmp('query-block-jobs')
224        self.assert_qmp(res, 'return', [])
225        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
226                                 sync='full', target=self.dest_img,
227                                 auto_dismiss=True)
228        res = self.vm.qmp('query-block-jobs')
229        self.assert_qmp(res, 'return', [])
230
231    def test_dismiss_true(self):
232        res = self.vm.qmp('query-block-jobs')
233        self.assert_qmp(res, 'return', [])
234        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
235                                 sync='full', target=self.dest_img,
236                                 auto_dismiss=False)
237        res = self.vm.qmp('query-block-jobs')
238        self.assert_qmp(res, 'return[0]/status', 'concluded')
239        res = self.vm.qmp('block-job-dismiss', id='drive0')
240        self.assert_qmp(res, 'return', {})
241        res = self.vm.qmp('query-block-jobs')
242        self.assert_qmp(res, 'return', [])
243
244    def test_dismiss_bad_id(self):
245        res = self.vm.qmp('query-block-jobs')
246        self.assert_qmp(res, 'return', [])
247        res = self.vm.qmp('block-job-dismiss', id='foobar')
248        self.assert_qmp(res, 'error/class', 'DeviceNotActive')
249
250    def test_dismiss_collision(self):
251        res = self.vm.qmp('query-block-jobs')
252        self.assert_qmp(res, 'return', [])
253        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
254                                 sync='full', target=self.dest_img,
255                                 auto_dismiss=False)
256        res = self.vm.qmp('query-block-jobs')
257        self.assert_qmp(res, 'return[0]/status', 'concluded')
258        # Leave zombie job un-dismissed, observe a failure:
259        res = self.qmp_backup_and_wait(serror="Job ID 'drive0' already in use",
260                                       device='drive0', format=iotests.imgfmt,
261                                       sync='full', target=self.dest_img2,
262                                       auto_dismiss=False)
263        self.assertEqual(res, False)
264        # OK, dismiss the zombie.
265        res = self.vm.qmp('block-job-dismiss', id='drive0')
266        self.assert_qmp(res, 'return', {})
267        res = self.vm.qmp('query-block-jobs')
268        self.assert_qmp(res, 'return', [])
269        # Ensure it's really gone.
270        self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt,
271                                 sync='full', target=self.dest_img2,
272                                 auto_dismiss=False)
273
274    def dismissal_failure(self, dismissal_opt):
275        res = self.vm.qmp('query-block-jobs')
276        self.assert_qmp(res, 'return', [])
277        # Give blkdebug something to chew on
278        self.hmp_io_writes('drive0',
279                           (('0x9a', 0, 512),
280                           ('0x55', '8M', '352k'),
281                           ('0x78', '15872k', '1M')))
282        # Add destination node via blkdebug
283        res = self.vm.qmp('blockdev-add',
284                          node_name='target0',
285                          driver=iotests.imgfmt,
286                          file={
287                              'driver': 'blkdebug',
288                              'image': {
289                                  'driver': 'file',
290                                  'filename': self.dest_img
291                              },
292                              'inject-error': [{
293                                  'event': 'write_aio',
294                                  'errno': 5,
295                                  'immediately': False,
296                                  'once': True
297                              }],
298                          })
299        self.assert_qmp(res, 'return', {})
300
301        res = self.qmp_backup(cmd='blockdev-backup',
302                              device='drive0', target='target0',
303                              on_target_error='stop',
304                              sync='full',
305                              auto_dismiss=dismissal_opt)
306        self.assertTrue(res)
307        event = self.vm.event_wait(name="BLOCK_JOB_ERROR",
308                                   match={'data': {'device': 'drive0'}})
309        self.assertNotEqual(event, None)
310        # OK, job should be wedged
311        res = self.vm.qmp('query-block-jobs')
312        self.assert_qmp(res, 'return[0]/status', 'paused')
313        res = self.vm.qmp('block-job-dismiss', id='drive0')
314        self.assert_qmp(res, 'error/desc',
315                        "Job 'drive0' in state 'paused' cannot accept"
316                        " command verb 'dismiss'")
317        res = self.vm.qmp('query-block-jobs')
318        self.assert_qmp(res, 'return[0]/status', 'paused')
319        # OK, unstick job and move forward.
320        res = self.vm.qmp('block-job-resume', device='drive0')
321        self.assert_qmp(res, 'return', {})
322        # And now we need to wait for it to conclude;
323        res = self.qmp_backup_wait(device='drive0')
324        self.assertTrue(res)
325        if not dismissal_opt:
326            # Job should now be languishing:
327            res = self.vm.qmp('query-block-jobs')
328            self.assert_qmp(res, 'return[0]/status', 'concluded')
329            res = self.vm.qmp('block-job-dismiss', id='drive0')
330            self.assert_qmp(res, 'return', {})
331            res = self.vm.qmp('query-block-jobs')
332            self.assert_qmp(res, 'return', [])
333
334    def test_dismiss_premature(self):
335        self.dismissal_failure(False)
336
337    def test_dismiss_erroneous(self):
338        self.dismissal_failure(True)
339
340if __name__ == '__main__':
341    iotests.main(supported_fmts=['qcow2', 'qed'],
342                 supported_protocols=['file'])
343