tests/qemu-iotests/056

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