tests/qemu-iotests/155

   1 #!/usr/bin/env python3
   2 #
   3 # Test whether the backing BDSs are correct after completion of a
   4 # mirror block job; in "existing" modes (drive-mirror with
   5 # mode=existing and blockdev-mirror) the backing chain should not be
   6 # overridden.
   7 #
   8 # Copyright (C) 2016 Red Hat, Inc.
   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 os
  25 import iotests
  26 from iotests import qemu_img
  27
  28 back0_img = os.path.join(iotests.test_dir, 'back0.' + iotests.imgfmt)
  29 back1_img = os.path.join(iotests.test_dir, 'back1.' + iotests.imgfmt)
  30 back2_img = os.path.join(iotests.test_dir, 'back2.' + iotests.imgfmt)
  31 source_img = os.path.join(iotests.test_dir, 'source.' + iotests.imgfmt)
  32 target_img = os.path.join(iotests.test_dir, 'target.' + iotests.imgfmt)
  33
  34
  35 # Class variables for controlling its behavior:
  36 #
  37 # existing: If True, explicitly create the target image and blockdev-add it
  38 # target_backing: If existing is True: Use this filename as the backing file
  39 #                 of the target image
  40 #                 (None: no backing file)
  41 # target_blockdev_backing: If existing is True: Pass this dict as "backing"
  42 #                          for the blockdev-add command
  43 #                          (None: do not pass "backing")
  44 # target_real_backing: If existing is True: The real filename of the backing
  45 #                      image during runtime, only makes sense if
  46 #                      target_blockdev_backing is not None
  47 #                      (None: same as target_backing)
  48 # target_open_with_backing: If True, the target image is added with its backing
  49 #                           chain opened right away. If False, blockdev-add
  50 #                           opens it without a backing file and job completion
  51 #                           is supposed to open the backing chain.
  52 # use_iothread: If True, an iothread is configured for the virtio-blk device
  53 #               that uses the image being mirrored
  54
  55 class BaseClass(iotests.QMPTestCase):
  56     target_blockdev_backing = None
  57     target_real_backing = None
  58     target_open_with_backing = True
  59     use_iothread = False
  60
  61     def setUp(self):
  62         qemu_img('create', '-f', iotests.imgfmt, back0_img, '1440K')
  63         qemu_img('create', '-f', iotests.imgfmt, '-b', back0_img, back1_img)
  64         qemu_img('create', '-f', iotests.imgfmt, '-b', back1_img, back2_img)
  65         qemu_img('create', '-f', iotests.imgfmt, '-b', back2_img, source_img)
  66
  67         self.vm = iotests.VM()
  68         # Add the BDS via blockdev-add so it stays around after the mirror block
  69         # job has been completed
  70         blockdev = {'node-name': 'source',
  71                     'driver': iotests.imgfmt,
  72                     'file': {'driver': 'file',
  73                              'filename': source_img}}
  74         self.vm.add_blockdev(self.vm.qmp_to_opts(blockdev))
  75
  76         if self.use_iothread:
  77             self.vm.add_object('iothread,id=iothread0')
  78             iothread = ",iothread=iothread0"
  79         else:
  80             iothread = ""
  81
  82         self.vm.add_device('virtio-scsi%s' % iothread)
  83         self.vm.add_device('scsi-hd,id=qdev0,drive=source')
  84
  85         self.vm.launch()
  86
  87         self.assertIntactSourceBackingChain()
  88
  89         if self.existing:
  90             if self.target_backing:
  91                 qemu_img('create', '-f', iotests.imgfmt,
  92                          '-b', self.target_backing, target_img, '1440K')
  93             else:
  94                 qemu_img('create', '-f', iotests.imgfmt, target_img, '1440K')
  95
  96             if self.cmd == 'blockdev-mirror':
  97                 options = { 'node-name': 'target',
  98                             'driver': iotests.imgfmt,
  99                             'file': { 'driver': 'file',
 100                                       'node-name': 'target-file',
 101                                       'filename': target_img } }
 102
 103                 if not self.target_open_with_backing:
 104                         options['backing'] = None
 105                 elif self.target_blockdev_backing:
 106                         options['backing'] = self.target_blockdev_backing
 107
 108                 result = self.vm.qmp('blockdev-add', **options)
 109                 self.assert_qmp(result, 'return', {})
 110
 111     def tearDown(self):
 112         self.vm.shutdown()
 113         os.remove(source_img)
 114         os.remove(back2_img)
 115         os.remove(back1_img)
 116         os.remove(back0_img)
 117         try:
 118             os.remove(target_img)
 119         except OSError:
 120             pass
 121
 122     def findBlockNode(self, node_name, qdev=None):
 123         if qdev:
 124             result = self.vm.qmp('query-block')
 125             for device in result['return']:
 126                 if device['qdev'] == qdev:
 127                     if node_name:
 128                         self.assert_qmp(device, 'inserted/node-name', node_name)
 129                     return device['inserted']
 130         else:
 131             result = self.vm.qmp('query-named-block-nodes')
 132             for node in result['return']:
 133                 if node['node-name'] == node_name:
 134                     return node
 135
 136         self.fail('Cannot find node %s/%s' % (qdev, node_name))
 137
 138     def assertIntactSourceBackingChain(self):
 139         node = self.findBlockNode('source')
 140
 141         self.assert_qmp(node, 'image' + '/backing-image' * 0 + '/filename',
 142                         source_img)
 143         self.assert_qmp(node, 'image' + '/backing-image' * 1 + '/filename',
 144                         back2_img)
 145         self.assert_qmp(node, 'image' + '/backing-image' * 2 + '/filename',
 146                         back1_img)
 147         self.assert_qmp(node, 'image' + '/backing-image' * 3 + '/filename',
 148                         back0_img)
 149         self.assert_qmp_absent(node, 'image' + '/backing-image' * 4)
 150
 151     def assertCorrectBackingImage(self, node, default_image):
 152         if self.existing:
 153             if self.target_real_backing:
 154                 image = self.target_real_backing
 155             else:
 156                 image = self.target_backing
 157         else:
 158             image = default_image
 159
 160         if image:
 161             self.assert_qmp(node, 'image/backing-image/filename', image)
 162         else:
 163             self.assert_qmp_absent(node, 'image/backing-image')
 164
 165
 166 # Class variables for controlling its behavior:
 167 #
 168 # cmd: Mirroring command to execute, either drive-mirror or blockdev-mirror
 169
 170 class MirrorBaseClass(BaseClass):
 171     def openBacking(self):
 172         pass
 173
 174     def runMirror(self, sync):
 175         if self.cmd == 'blockdev-mirror':
 176             result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
 177                                  sync=sync, target='target',
 178                                  auto_finalize=False)
 179         else:
 180             if self.existing:
 181                 mode = 'existing'
 182             else:
 183                 mode = 'absolute-paths'
 184             result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
 185                                  sync=sync, target=target_img,
 186                                  format=iotests.imgfmt, mode=mode,
 187                                  node_name='target', auto_finalize=False)
 188
 189         self.assert_qmp(result, 'return', {})
 190
 191         self.vm.run_job('mirror-job', auto_finalize=False,
 192                         pre_finalize=self.openBacking, auto_dismiss=True)
 193
 194     def testFull(self):
 195         self.runMirror('full')
 196
 197         node = self.findBlockNode('target', 'qdev0')
 198         self.assertCorrectBackingImage(node, None)
 199         self.assertIntactSourceBackingChain()
 200
 201     def testTop(self):
 202         self.runMirror('top')
 203
 204         node = self.findBlockNode('target', 'qdev0')
 205         self.assertCorrectBackingImage(node, back2_img)
 206         self.assertIntactSourceBackingChain()
 207
 208     def testNone(self):
 209         self.runMirror('none')
 210
 211         node = self.findBlockNode('target', 'qdev0')
 212         self.assertCorrectBackingImage(node, source_img)
 213         self.assertIntactSourceBackingChain()
 214
 215
 216 class TestDriveMirrorAbsolutePaths(MirrorBaseClass):
 217     cmd = 'drive-mirror'
 218     existing = False
 219
 220 class TestDriveMirrorExistingNoBacking(MirrorBaseClass):
 221     cmd = 'drive-mirror'
 222     existing = True
 223     target_backing = None
 224
 225 class TestDriveMirrorExistingBacking(MirrorBaseClass):
 226     cmd = 'drive-mirror'
 227     existing = True
 228     target_backing = 'null-co://'
 229
 230 class TestBlockdevMirrorNoBacking(MirrorBaseClass):
 231     cmd = 'blockdev-mirror'
 232     existing = True
 233     target_backing = None
 234
 235 class TestBlockdevMirrorBacking(MirrorBaseClass):
 236     cmd = 'blockdev-mirror'
 237     existing = True
 238     target_backing = 'null-co://'
 239
 240 class TestBlockdevMirrorForcedBacking(MirrorBaseClass):
 241     cmd = 'blockdev-mirror'
 242     existing = True
 243     target_backing = None
 244     target_blockdev_backing = { 'driver': 'null-co' }
 245     target_real_backing = 'null-co://'
 246
 247 # Attach the backing chain only during completion, with blockdev-reopen
 248 class TestBlockdevMirrorReopen(MirrorBaseClass):
 249     cmd = 'blockdev-mirror'
 250     existing = True
 251     target_backing = 'null-co://'
 252     target_open_with_backing = False
 253
 254     def openBacking(self):
 255         if not self.target_open_with_backing:
 256             result = self.vm.qmp('blockdev-add', node_name="backing",
 257                                  driver="null-co")
 258             self.assert_qmp(result, 'return', {})
 259             result = self.vm.qmp('x-blockdev-reopen', node_name="target",
 260                                  driver=iotests.imgfmt, file="target-file",
 261                                  backing="backing")
 262             self.assert_qmp(result, 'return', {})
 263
 264 class TestBlockdevMirrorReopenIothread(TestBlockdevMirrorReopen):
 265     use_iothread = True
 266
 267 # Attach the backing chain only during completion, with blockdev-snapshot
 268 class TestBlockdevMirrorSnapshot(MirrorBaseClass):
 269     cmd = 'blockdev-mirror'
 270     existing = True
 271     target_backing = 'null-co://'
 272     target_open_with_backing = False
 273
 274     def openBacking(self):
 275         if not self.target_open_with_backing:
 276             result = self.vm.qmp('blockdev-add', node_name="backing",
 277                                  driver="null-co")
 278             self.assert_qmp(result, 'return', {})
 279             result = self.vm.qmp('blockdev-snapshot', node="backing",
 280                                  overlay="target")
 281             self.assert_qmp(result, 'return', {})
 282
 283 class TestBlockdevMirrorSnapshotIothread(TestBlockdevMirrorSnapshot):
 284     use_iothread = True
 285
 286 class TestCommit(BaseClass):
 287     existing = False
 288
 289     def testCommit(self):
 290         result = self.vm.qmp('block-commit', job_id='commit-job',
 291                              device='source', base=back1_img)
 292         self.assert_qmp(result, 'return', {})
 293
 294         self.vm.event_wait('BLOCK_JOB_READY')
 295
 296         result = self.vm.qmp('block-job-complete', device='commit-job')
 297         self.assert_qmp(result, 'return', {})
 298
 299         self.vm.event_wait('BLOCK_JOB_COMPLETED')
 300
 301         node = self.findBlockNode(None, 'qdev0')
 302         self.assert_qmp(node, 'image' + '/backing-image' * 0 + '/filename',
 303                         back1_img)
 304         self.assert_qmp(node, 'image' + '/backing-image' * 1 + '/filename',
 305                         back0_img)
 306         self.assert_qmp_absent(node, 'image' + '/backing-image' * 2 +
 307                                '/filename')
 308
 309         self.assertIntactSourceBackingChain()
 310
 311
 312 BaseClass = None
 313 MirrorBaseClass = None
 314
 315 if __name__ == '__main__':
 316     iotests.main(supported_fmts=['qcow2'],
 317                  supported_protocols=['file'])