tests/qemu-iotests/281

   1 #!/usr/bin/env python3
   2 # group: rw
   3 #
   4 # Test cases for blockdev + IOThread interactions
   5 #
   6 # Copyright (C) 2019 Red Hat, Inc.
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 #
  21
  22 import os
  23 import time
  24 import iotests
  25 from iotests import qemu_img, QemuStorageDaemon
  26
  27 image_len = 64 * 1024 * 1024
  28
  29 # Test for RHBZ#1782175
  30 class TestDirtyBitmapIOThread(iotests.QMPTestCase):
  31     drive0_img = os.path.join(iotests.test_dir, 'drive0.img')
  32     images = { 'drive0': drive0_img }
  33
  34     def setUp(self):
  35         for name in self.images:
  36             qemu_img('create', '-f', iotests.imgfmt,
  37                      self.images[name], str(image_len))
  38
  39         self.vm = iotests.VM()
  40         self.vm.add_object('iothread,id=iothread0')
  41
  42         for name in self.images:
  43             self.vm.add_blockdev('driver=file,filename=%s,node-name=file_%s'
  44                                  % (self.images[name], name))
  45             self.vm.add_blockdev('driver=qcow2,file=file_%s,node-name=%s'
  46                                  % (name, name))
  47
  48         self.vm.launch()
  49         self.vm.qmp('x-blockdev-set-iothread',
  50                     node_name='drive0', iothread='iothread0',
  51                     force=True)
  52
  53     def tearDown(self):
  54         self.vm.shutdown()
  55         for name in self.images:
  56             os.remove(self.images[name])
  57
  58     def test_add_dirty_bitmap(self):
  59         result = self.vm.qmp(
  60             'block-dirty-bitmap-add',
  61             node='drive0',
  62             name='bitmap1',
  63             persistent=True,
  64         )
  65
  66         self.assert_qmp(result, 'return', {})
  67
  68
  69 # Test for RHBZ#1746217 & RHBZ#1773517
  70 class TestNBDMirrorIOThread(iotests.QMPTestCase):
  71     nbd_sock = os.path.join(iotests.sock_dir, 'nbd.sock')
  72     drive0_img = os.path.join(iotests.test_dir, 'drive0.img')
  73     mirror_img = os.path.join(iotests.test_dir, 'mirror.img')
  74     images = { 'drive0': drive0_img, 'mirror': mirror_img }
  75
  76     def setUp(self):
  77         for name in self.images:
  78             qemu_img('create', '-f', iotests.imgfmt,
  79                      self.images[name], str(image_len))
  80
  81         self.vm_src = iotests.VM(path_suffix='src')
  82         self.vm_src.add_object('iothread,id=iothread0')
  83         self.vm_src.add_blockdev('driver=file,filename=%s,node-name=file0'
  84                           % (self.drive0_img))
  85         self.vm_src.add_blockdev('driver=qcow2,file=file0,node-name=drive0')
  86         self.vm_src.launch()
  87         self.vm_src.qmp('x-blockdev-set-iothread',
  88                         node_name='drive0', iothread='iothread0',
  89                         force=True)
  90
  91         self.vm_tgt = iotests.VM(path_suffix='tgt')
  92         self.vm_tgt.add_object('iothread,id=iothread0')
  93         self.vm_tgt.add_blockdev('driver=file,filename=%s,node-name=file0'
  94                           % (self.mirror_img))
  95         self.vm_tgt.add_blockdev('driver=qcow2,file=file0,node-name=drive0')
  96         self.vm_tgt.launch()
  97         self.vm_tgt.qmp('x-blockdev-set-iothread',
  98                         node_name='drive0', iothread='iothread0',
  99                         force=True)
 100
 101     def tearDown(self):
 102         self.vm_src.shutdown()
 103         self.vm_tgt.shutdown()
 104         for name in self.images:
 105             os.remove(self.images[name])
 106
 107     def test_nbd_mirror(self):
 108         result = self.vm_tgt.qmp(
 109             'nbd-server-start',
 110             addr={
 111                 'type': 'unix',
 112                 'data': { 'path': self.nbd_sock }
 113             }
 114         )
 115         self.assert_qmp(result, 'return', {})
 116
 117         result = self.vm_tgt.qmp(
 118             'nbd-server-add',
 119             device='drive0',
 120             writable=True
 121         )
 122         self.assert_qmp(result, 'return', {})
 123
 124         result = self.vm_src.qmp(
 125             'drive-mirror',
 126             device='drive0',
 127             target='nbd+unix:///drive0?socket=' + self.nbd_sock,
 128             sync='full',
 129             mode='existing',
 130             speed=64*1024*1024,
 131             job_id='j1'
 132         )
 133         self.assert_qmp(result, 'return', {})
 134
 135         self.vm_src.event_wait(name="BLOCK_JOB_READY")
 136
 137
 138 # Test for RHBZ#1779036
 139 class TestExternalSnapshotAbort(iotests.QMPTestCase):
 140     drive0_img = os.path.join(iotests.test_dir, 'drive0.img')
 141     snapshot_img = os.path.join(iotests.test_dir, 'snapshot.img')
 142     images = { 'drive0': drive0_img, 'snapshot': snapshot_img }
 143
 144     def setUp(self):
 145         for name in self.images:
 146             qemu_img('create', '-f', iotests.imgfmt,
 147                      self.images[name], str(image_len))
 148
 149         self.vm = iotests.VM()
 150         self.vm.add_object('iothread,id=iothread0')
 151         self.vm.add_blockdev('driver=file,filename=%s,node-name=file0'
 152                           % (self.drive0_img))
 153         self.vm.add_blockdev('driver=qcow2,file=file0,node-name=drive0')
 154         self.vm.launch()
 155         self.vm.qmp('x-blockdev-set-iothread',
 156                     node_name='drive0', iothread='iothread0',
 157                     force=True)
 158
 159     def tearDown(self):
 160         self.vm.shutdown()
 161         for name in self.images:
 162             os.remove(self.images[name])
 163
 164     def test_external_snapshot_abort(self):
 165         # Use a two actions transaction with a bogus values on the second
 166         # one to trigger an abort of the transaction.
 167         result = self.vm.qmp('transaction', actions=[
 168             {
 169                 'type': 'blockdev-snapshot-sync',
 170                 'data': { 'node-name': 'drive0',
 171                           'snapshot-file': self.snapshot_img,
 172                           'snapshot-node-name': 'snap1',
 173                           'mode': 'absolute-paths',
 174                           'format': 'qcow2' }
 175             },
 176             {
 177                 'type': 'blockdev-snapshot-sync',
 178                 'data': { 'node-name': 'drive0',
 179                           'snapshot-file': '/fakesnapshot',
 180                           'snapshot-node-name': 'snap2',
 181                           'mode': 'absolute-paths',
 182                           'format': 'qcow2' }
 183             },
 184         ])
 185
 186         # Crashes on failure, we expect this error.
 187         self.assert_qmp(result, 'error/class', 'GenericError')
 188
 189
 190 # Test for RHBZ#1782111
 191 class TestBlockdevBackupAbort(iotests.QMPTestCase):
 192     drive0_img = os.path.join(iotests.test_dir, 'drive0.img')
 193     drive1_img = os.path.join(iotests.test_dir, 'drive1.img')
 194     snap0_img = os.path.join(iotests.test_dir, 'snap0.img')
 195     snap1_img = os.path.join(iotests.test_dir, 'snap1.img')
 196     images = { 'drive0': drive0_img,
 197                'drive1': drive1_img,
 198                'snap0': snap0_img,
 199                'snap1': snap1_img }
 200
 201     def setUp(self):
 202         for name in self.images:
 203             qemu_img('create', '-f', iotests.imgfmt,
 204                      self.images[name], str(image_len))
 205
 206         self.vm = iotests.VM()
 207         self.vm.add_object('iothread,id=iothread0')
 208         self.vm.add_device('virtio-scsi,iothread=iothread0')
 209
 210         for name in self.images:
 211             self.vm.add_blockdev('driver=file,filename=%s,node-name=file_%s'
 212                                  % (self.images[name], name))
 213             self.vm.add_blockdev('driver=qcow2,file=file_%s,node-name=%s'
 214                                  % (name, name))
 215
 216         self.vm.add_device('scsi-hd,drive=drive0')
 217         self.vm.add_device('scsi-hd,drive=drive1')
 218         self.vm.launch()
 219
 220     def tearDown(self):
 221         self.vm.shutdown()
 222         for name in self.images:
 223             os.remove(self.images[name])
 224
 225     def test_blockdev_backup_abort(self):
 226         # Use a two actions transaction with a bogus values on the second
 227         # one to trigger an abort of the transaction.
 228         result = self.vm.qmp('transaction', actions=[
 229             {
 230                 'type': 'blockdev-backup',
 231                 'data': { 'device': 'drive0',
 232                           'target': 'snap0',
 233                           'sync': 'full',
 234                           'job-id': 'j1' }
 235             },
 236             {
 237                 'type': 'blockdev-backup',
 238                 'data': { 'device': 'drive1',
 239                           'target': 'snap1',
 240                           'sync': 'full' }
 241             },
 242         ])
 243
 244         # Hangs on failure, we expect this error.
 245         self.assert_qmp(result, 'error/class', 'GenericError')
 246
 247 # Test for RHBZ#2033626
 248 class TestYieldingAndTimers(iotests.QMPTestCase):
 249     sock = os.path.join(iotests.sock_dir, 'nbd.sock')
 250     qsd = None
 251
 252     def setUp(self):
 253         self.create_nbd_export()
 254
 255         # Simple VM with an NBD block device connected to the NBD export
 256         # provided by the QSD, and an (initially unused) iothread
 257         self.vm = iotests.VM()
 258         self.vm.add_object('iothread,id=iothr')
 259         self.vm.add_blockdev('nbd,node-name=nbd,server.type=unix,' +
 260                              f'server.path={self.sock},export=exp,' +
 261                              'reconnect-delay=1,open-timeout=1')
 262
 263         self.vm.launch()
 264
 265     def tearDown(self):
 266         self.stop_nbd_export()
 267         self.vm.shutdown()
 268
 269     def test_timers_with_blockdev_del(self):
 270         # The NBD BDS will have had an active open timer, because setUp() gave
 271         # a positive value for @open-timeout.  It should be gone once the BDS
 272         # has been opened.
 273         # (But there used to be a bug where it remained active, which will
 274         # become important below.)
 275
 276         # Stop and restart the NBD server, and do some I/O on the client to
 277         # trigger a reconnect and start the reconnect delay timer
 278         self.stop_nbd_export()
 279         self.create_nbd_export()
 280
 281         result = self.vm.qmp('human-monitor-command',
 282                              command_line='qemu-io nbd "write 0 512"')
 283         self.assert_qmp(result, 'return', '')
 284
 285         # Reconnect is done, so the reconnect delay timer should be gone.
 286         # (This is similar to how the open timer should be gone after open,
 287         # and similarly there used to be a bug where it was not gone.)
 288
 289         # Delete the BDS to see whether both timers are gone.  If they are not,
 290         # they will remain active, fire later, and then access freed data.
 291         # (Or, with "block/nbd: Assert there are no timers when closed"
 292         # applied, the assertions added in that patch will fail.)
 293         result = self.vm.qmp('blockdev-del', node_name='nbd')
 294         self.assert_qmp(result, 'return', {})
 295
 296         # Give the timers some time to fire (both have a timeout of 1 s).
 297         # (Sleeping in an iotest may ring some alarm bells, but note that if
 298         # the timing is off here, the test will just always pass.  If we kill
 299         # the VM too early, then we just kill the timers before they can fire,
 300         # thus not see the error, and so the test will pass.)
 301         time.sleep(2)
 302
 303     def test_yield_in_iothread(self):
 304         # Move the NBD node to the I/O thread; the NBD block driver should
 305         # attach the connection's QIOChannel to that thread's AioContext, too
 306         result = self.vm.qmp('x-blockdev-set-iothread',
 307                              node_name='nbd', iothread='iothr')
 308         self.assert_qmp(result, 'return', {})
 309
 310         # Do some I/O that will be throttled by the QSD, so that the network
 311         # connection hopefully will yield here.  When it is resumed, it must
 312         # then be resumed in the I/O thread's AioContext.
 313         result = self.vm.qmp('human-monitor-command',
 314                              command_line='qemu-io nbd "read 0 128K"')
 315         self.assert_qmp(result, 'return', '')
 316
 317     def create_nbd_export(self):
 318         assert self.qsd is None
 319
 320         # Export a throttled null-co BDS: Reads are throttled (max 64 kB/s),
 321         # writes are not.
 322         self.qsd = QemuStorageDaemon(
 323             '--object',
 324             'throttle-group,id=thrgr,x-bps-read=65536,x-bps-read-max=65536',
 325
 326             '--blockdev',
 327             'null-co,node-name=null,read-zeroes=true',
 328
 329             '--blockdev',
 330             'throttle,node-name=thr,file=null,throttle-group=thrgr',
 331
 332             '--nbd-server',
 333             f'addr.type=unix,addr.path={self.sock}',
 334
 335             '--export',
 336             'nbd,id=exp,node-name=thr,name=exp,writable=true'
 337         )
 338
 339     def stop_nbd_export(self):
 340         self.qsd.stop()
 341         self.qsd = None
 342
 343 if __name__ == '__main__':
 344     iotests.main(supported_fmts=['qcow2'],
 345                  supported_protocols=['file'],
 346                  unsupported_imgopts=['compat'])