| 1 | #!/usr/bin/env python3 |
| 2 | # group: rw backing |
| 3 | # |
| 4 | # Tests for drive-backup |
| 5 | # |
| 6 | # Copyright (C) 2013 Red Hat, Inc. |
| 7 | # |
| 8 | # Based on 041. |
| 9 | # |
| 10 | # This program is free software; you can redistribute it and/or modify |
| 11 | # it under the terms of the GNU General Public License as published by |
| 12 | # the Free Software Foundation; either version 2 of the License, or |
| 13 | # (at your option) any later version. |
| 14 | # |
| 15 | # This program is distributed in the hope that it will be useful, |
| 16 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 | # GNU General Public License for more details. |
| 19 | # |
| 20 | # You should have received a copy of the GNU General Public License |
| 21 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 22 | # |
| 23 | |
| 24 | import time |
| 25 | import os |
| 26 | import iotests |
| 27 | from iotests import qemu_img, qemu_io, create_image |
| 28 | |
| 29 | backing_img = os.path.join(iotests.test_dir, 'backing.img') |
| 30 | test_img = os.path.join(iotests.test_dir, 'test.img') |
| 31 | target_img = os.path.join(iotests.test_dir, 'target.img') |
| 32 | |
| 33 | def img_create(img, fmt=iotests.imgfmt, size='64M', **kwargs): |
| 34 | fullname = os.path.join(iotests.test_dir, '%s.%s' % (img, fmt)) |
| 35 | optargs = [] |
| 36 | for k,v in kwargs.items(): |
| 37 | optargs = optargs + ['-o', '%s=%s' % (k,v)] |
| 38 | args = ['create', '-f', fmt] + optargs + [fullname, size] |
| 39 | iotests.qemu_img(*args) |
| 40 | return fullname |
| 41 | |
| 42 | def try_remove(img): |
| 43 | try: |
| 44 | os.remove(img) |
| 45 | except OSError: |
| 46 | pass |
| 47 | |
| 48 | def io_write_patterns(img, patterns): |
| 49 | for pattern in patterns: |
| 50 | iotests.qemu_io('-c', 'write -P%s %s %s' % pattern, img) |
| 51 | |
| 52 | |
| 53 | class TestSyncModesNoneAndTop(iotests.QMPTestCase): |
| 54 | image_len = 64 * 1024 * 1024 # MB |
| 55 | |
| 56 | def setUp(self): |
| 57 | create_image(backing_img, TestSyncModesNoneAndTop.image_len) |
| 58 | qemu_img('create', '-f', iotests.imgfmt, |
| 59 | '-o', 'backing_file=%s' % backing_img, '-F', 'raw', test_img) |
| 60 | qemu_io('-c', 'write -P0x41 0 512', test_img) |
| 61 | qemu_io('-c', 'write -P0xd5 1M 32k', test_img) |
| 62 | qemu_io('-c', 'write -P0xdc 32M 124k', test_img) |
| 63 | qemu_io('-c', 'write -P0xdc 67043328 64k', test_img) |
| 64 | self.vm = iotests.VM().add_drive(test_img) |
| 65 | self.vm.launch() |
| 66 | |
| 67 | def tearDown(self): |
| 68 | self.vm.shutdown() |
| 69 | os.remove(test_img) |
| 70 | os.remove(backing_img) |
| 71 | try: |
| 72 | os.remove(target_img) |
| 73 | except OSError: |
| 74 | pass |
| 75 | |
| 76 | def test_complete_top(self): |
| 77 | self.assert_no_active_block_jobs() |
| 78 | self.vm.cmd('drive-backup', device='drive0', sync='top', |
| 79 | format=iotests.imgfmt, target=target_img) |
| 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 | self.vm.cmd('drive-backup', device='drive0', |
| 92 | sync='none', target=target_img) |
| 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 | qemu_io('-c', 'read -P0x41 0 512', target_img) |
| 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 | self.vm.cmd('drive-backup', device='drive0', |
| 117 | sync='full', target=target_img, |
| 118 | format="file", speed=1) |
| 119 | self.vm.cmd('block-job-pause', device="drive0") |
| 120 | # Speed is low enough that this must be an uncopied range, which will |
| 121 | # trigger the before write notifier |
| 122 | self.vm.hmp_qemu_io('drive0', 'aio_write -P 1 512512 512') |
| 123 | self.vm.resume_drive("drive0") |
| 124 | self.vm.cmd('block-job-resume', device="drive0") |
| 125 | event = self.cancel_and_wait() |
| 126 | self.assert_qmp(event, 'data/type', 'backup') |
| 127 | |
| 128 | class BackupTest(iotests.QMPTestCase): |
| 129 | def setUp(self): |
| 130 | self.vm = iotests.VM() |
| 131 | self.test_img = img_create('test') |
| 132 | self.dest_img = img_create('dest') |
| 133 | self.dest_img2 = img_create('dest2') |
| 134 | self.ref_img = img_create('ref') |
| 135 | self.vm.add_drive(self.test_img) |
| 136 | self.vm.launch() |
| 137 | |
| 138 | def tearDown(self): |
| 139 | self.vm.shutdown() |
| 140 | try_remove(self.test_img) |
| 141 | try_remove(self.dest_img) |
| 142 | try_remove(self.dest_img2) |
| 143 | try_remove(self.ref_img) |
| 144 | |
| 145 | def hmp_io_writes(self, drive, patterns): |
| 146 | for pattern in patterns: |
| 147 | self.vm.hmp_qemu_io(drive, 'write -P%s %s %s' % pattern) |
| 148 | self.vm.hmp_qemu_io(drive, 'flush') |
| 149 | |
| 150 | def qmp_backup_and_wait(self, cmd='drive-backup', serror=None, |
| 151 | aerror=None, **kwargs): |
| 152 | if not self.qmp_backup(cmd, serror, **kwargs): |
| 153 | return False |
| 154 | return self.qmp_backup_wait(kwargs['device'], aerror) |
| 155 | |
| 156 | def qmp_backup(self, cmd='drive-backup', |
| 157 | error=None, **kwargs): |
| 158 | self.assertTrue('device' in kwargs) |
| 159 | res = self.vm.qmp(cmd, **kwargs) |
| 160 | if error: |
| 161 | self.assert_qmp(res, 'error/desc', error) |
| 162 | return False |
| 163 | self.assert_qmp(res, 'return', {}) |
| 164 | return True |
| 165 | |
| 166 | def qmp_backup_wait(self, device, error=None): |
| 167 | event = self.vm.event_wait(name="BLOCK_JOB_COMPLETED", |
| 168 | match={'data': {'device': device}}) |
| 169 | self.assertNotEqual(event, None) |
| 170 | try: |
| 171 | failure = self.dictpath(event, 'data/error') |
| 172 | except AssertionError: |
| 173 | # Backup succeeded. |
| 174 | self.assert_qmp(event, 'data/offset', event['data']['len']) |
| 175 | return True |
| 176 | else: |
| 177 | # Failure. |
| 178 | self.assert_qmp(event, 'data/error', qerror) |
| 179 | return False |
| 180 | |
| 181 | def test_overlapping_writes(self): |
| 182 | # Write something to back up |
| 183 | self.hmp_io_writes('drive0', [('42', '0M', '2M')]) |
| 184 | |
| 185 | # Create a reference backup |
| 186 | self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt, |
| 187 | sync='full', target=self.ref_img, |
| 188 | auto_dismiss=False) |
| 189 | self.vm.cmd('block-job-dismiss', id='drive0') |
| 190 | |
| 191 | # Now to the test backup: We simulate the following guest |
| 192 | # writes: |
| 193 | # (1) [1M + 64k, 1M + 128k): Afterwards, everything in that |
| 194 | # area should be in the target image, and we must not copy |
| 195 | # it again (because the source image has changed now) |
| 196 | # (64k is the job's cluster size) |
| 197 | # (2) [1M, 2M): The backup job must not get overeager. It |
| 198 | # must copy [1M, 1M + 64k) and [1M + 128k, 2M) separately, |
| 199 | # but not the area in between. |
| 200 | |
| 201 | self.qmp_backup(device='drive0', format=iotests.imgfmt, sync='full', |
| 202 | target=self.dest_img, speed=1, auto_dismiss=False) |
| 203 | |
| 204 | self.hmp_io_writes('drive0', [('23', '%ik' % (1024 + 64), '64k'), |
| 205 | ('66', '1M', '1M')]) |
| 206 | |
| 207 | # Let the job complete |
| 208 | self.vm.cmd('block-job-set-speed', device='drive0', speed=0) |
| 209 | self.qmp_backup_wait('drive0') |
| 210 | self.vm.cmd('block-job-dismiss', id='drive0') |
| 211 | |
| 212 | self.assertTrue(iotests.compare_images(self.ref_img, self.dest_img), |
| 213 | 'target image does not match reference image') |
| 214 | |
| 215 | def test_dismiss_false(self): |
| 216 | res = self.vm.qmp('query-block-jobs') |
| 217 | self.assert_qmp(res, 'return', []) |
| 218 | self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt, |
| 219 | sync='full', target=self.dest_img, |
| 220 | auto_dismiss=True) |
| 221 | res = self.vm.qmp('query-block-jobs') |
| 222 | self.assert_qmp(res, 'return', []) |
| 223 | |
| 224 | def test_dismiss_true(self): |
| 225 | res = self.vm.qmp('query-block-jobs') |
| 226 | self.assert_qmp(res, 'return', []) |
| 227 | self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt, |
| 228 | sync='full', target=self.dest_img, |
| 229 | auto_dismiss=False) |
| 230 | res = self.vm.qmp('query-block-jobs') |
| 231 | self.assert_qmp(res, 'return[0]/status', 'concluded') |
| 232 | self.vm.cmd('block-job-dismiss', id='drive0') |
| 233 | res = self.vm.qmp('query-block-jobs') |
| 234 | self.assert_qmp(res, 'return', []) |
| 235 | |
| 236 | def test_dismiss_bad_id(self): |
| 237 | res = self.vm.qmp('query-block-jobs') |
| 238 | self.assert_qmp(res, 'return', []) |
| 239 | res = self.vm.qmp('block-job-dismiss', id='foobar') |
| 240 | self.assert_qmp(res, 'error/class', 'DeviceNotActive') |
| 241 | |
| 242 | def test_dismiss_collision(self): |
| 243 | res = self.vm.qmp('query-block-jobs') |
| 244 | self.assert_qmp(res, 'return', []) |
| 245 | self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt, |
| 246 | sync='full', target=self.dest_img, |
| 247 | auto_dismiss=False) |
| 248 | res = self.vm.qmp('query-block-jobs') |
| 249 | self.assert_qmp(res, 'return[0]/status', 'concluded') |
| 250 | # Leave zombie job un-dismissed, observe a failure: |
| 251 | res = self.qmp_backup_and_wait(serror="Job ID 'drive0' already in use", |
| 252 | device='drive0', format=iotests.imgfmt, |
| 253 | sync='full', target=self.dest_img2, |
| 254 | auto_dismiss=False) |
| 255 | self.assertEqual(res, False) |
| 256 | # OK, dismiss the zombie. |
| 257 | self.vm.cmd('block-job-dismiss', id='drive0') |
| 258 | res = self.vm.qmp('query-block-jobs') |
| 259 | self.assert_qmp(res, 'return', []) |
| 260 | # Ensure it's really gone. |
| 261 | self.qmp_backup_and_wait(device='drive0', format=iotests.imgfmt, |
| 262 | sync='full', target=self.dest_img2, |
| 263 | auto_dismiss=False) |
| 264 | |
| 265 | def dismissal_failure(self, dismissal_opt): |
| 266 | res = self.vm.qmp('query-block-jobs') |
| 267 | self.assert_qmp(res, 'return', []) |
| 268 | # Give blkdebug something to chew on |
| 269 | self.hmp_io_writes('drive0', |
| 270 | (('0x9a', 0, 512), |
| 271 | ('0x55', '8M', '352k'), |
| 272 | ('0x78', '15872k', '1M'))) |
| 273 | # Add destination node via blkdebug |
| 274 | self.vm.cmd('blockdev-add', |
| 275 | node_name='target0', |
| 276 | driver=iotests.imgfmt, |
| 277 | file={ |
| 278 | 'driver': 'blkdebug', |
| 279 | 'image': { |
| 280 | 'driver': 'file', |
| 281 | 'filename': self.dest_img |
| 282 | }, |
| 283 | 'inject-error': [{ |
| 284 | 'event': 'write_aio', |
| 285 | 'errno': 5, |
| 286 | 'immediately': False, |
| 287 | 'once': True |
| 288 | }], |
| 289 | }) |
| 290 | |
| 291 | res = self.qmp_backup(cmd='blockdev-backup', |
| 292 | device='drive0', target='target0', |
| 293 | on_target_error='stop', |
| 294 | sync='full', |
| 295 | auto_dismiss=dismissal_opt) |
| 296 | self.assertTrue(res) |
| 297 | event = self.vm.event_wait(name="BLOCK_JOB_ERROR", |
| 298 | match={'data': {'device': 'drive0'}}) |
| 299 | self.assertNotEqual(event, None) |
| 300 | # OK, job should pause, but it can't do it immediately, as it can't |
| 301 | # cancel other parallel requests (which didn't fail) |
| 302 | with iotests.Timeout(60, "Timeout waiting for backup actually paused"): |
| 303 | while True: |
| 304 | res = self.vm.qmp('query-block-jobs') |
| 305 | if res['return'][0]['status'] == 'paused': |
| 306 | break |
| 307 | self.assert_qmp(res, 'return[0]/status', 'paused') |
| 308 | res = self.vm.qmp('block-job-dismiss', id='drive0') |
| 309 | self.assert_qmp(res, 'error/desc', |
| 310 | "Job 'drive0' in state 'paused' cannot accept" |
| 311 | " command verb 'dismiss'") |
| 312 | res = self.vm.qmp('query-block-jobs') |
| 313 | self.assert_qmp(res, 'return[0]/status', 'paused') |
| 314 | # OK, unstick job and move forward. |
| 315 | self.vm.cmd('block-job-resume', device='drive0') |
| 316 | # And now we need to wait for it to conclude; |
| 317 | res = self.qmp_backup_wait(device='drive0') |
| 318 | self.assertTrue(res) |
| 319 | if not dismissal_opt: |
| 320 | # Job should now be languishing: |
| 321 | res = self.vm.qmp('query-block-jobs') |
| 322 | self.assert_qmp(res, 'return[0]/status', 'concluded') |
| 323 | self.vm.cmd('block-job-dismiss', id='drive0') |
| 324 | res = self.vm.qmp('query-block-jobs') |
| 325 | self.assert_qmp(res, 'return', []) |
| 326 | |
| 327 | def test_dismiss_premature(self): |
| 328 | self.dismissal_failure(False) |
| 329 | |
| 330 | def test_dismiss_erroneous(self): |
| 331 | self.dismissal_failure(True) |
| 332 | |
| 333 | if __name__ == '__main__': |
| 334 | iotests.main(supported_fmts=['qcow2', 'qed'], |
| 335 | supported_protocols=['file'], |
| 336 | require_hmp=True) |