tests/qemu-iotests/030

   1 #!/usr/bin/env python
   2 #
   3 # Tests for image streaming.
   4 #
   5 # Copyright (C) 2012 IBM Corp.
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 2 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20
  21 import time
  22 import os
  23 import iotests
  24 from iotests import qemu_img, qemu_io
  25
  26 backing_img = os.path.join(iotests.test_dir, 'backing.img')
  27 mid_img = os.path.join(iotests.test_dir, 'mid.img')
  28 test_img = os.path.join(iotests.test_dir, 'test.img')
  29
  30 class TestSingleDrive(iotests.QMPTestCase):
  31     image_len = 1 * 1024 * 1024 # MB
  32
  33     def setUp(self):
  34         iotests.create_image(backing_img, TestSingleDrive.image_len)
  35         qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, mid_img)
  36         qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % mid_img, test_img)
  37         qemu_io('-f', 'raw', '-c', 'write -P 0x1 0 512', backing_img)
  38         self.vm = iotests.VM().add_drive("blkdebug::" + test_img)
  39         self.vm.launch()
  40
  41     def tearDown(self):
  42         self.vm.shutdown()
  43         os.remove(test_img)
  44         os.remove(mid_img)
  45         os.remove(backing_img)
  46
  47     def test_stream(self):
  48         self.assert_no_active_block_jobs()
  49
  50         result = self.vm.qmp('block-stream', device='drive0')
  51         self.assert_qmp(result, 'return', {})
  52
  53         self.wait_until_completed()
  54
  55         self.assert_no_active_block_jobs()
  56         self.vm.shutdown()
  57
  58         self.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img),
  59                          qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img),
  60                          'image file map does not match backing file after streaming')
  61
  62     def test_stream_pause(self):
  63         self.assert_no_active_block_jobs()
  64
  65         self.vm.pause_drive('drive0')
  66         result = self.vm.qmp('block-stream', device='drive0')
  67         self.assert_qmp(result, 'return', {})
  68
  69         result = self.vm.qmp('block-job-pause', device='drive0')
  70         self.assert_qmp(result, 'return', {})
  71
  72         time.sleep(1)
  73         result = self.vm.qmp('query-block-jobs')
  74         offset = self.dictpath(result, 'return[0]/offset')
  75
  76         time.sleep(1)
  77         result = self.vm.qmp('query-block-jobs')
  78         self.assert_qmp(result, 'return[0]/offset', offset)
  79
  80         result = self.vm.qmp('block-job-resume', device='drive0')
  81         self.assert_qmp(result, 'return', {})
  82
  83         self.vm.resume_drive('drive0')
  84         self.wait_until_completed()
  85
  86         self.assert_no_active_block_jobs()
  87         self.vm.shutdown()
  88
  89         self.assertEqual(qemu_io('-f', 'raw', '-c', 'map', backing_img),
  90                          qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img),
  91                          'image file map does not match backing file after streaming')
  92
  93     def test_stream_partial(self):
  94         self.assert_no_active_block_jobs()
  95
  96         result = self.vm.qmp('block-stream', device='drive0', base=mid_img)
  97         self.assert_qmp(result, 'return', {})
  98
  99         self.wait_until_completed()
 100
 101         self.assert_no_active_block_jobs()
 102         self.vm.shutdown()
 103
 104         self.assertEqual(qemu_io('-f', iotests.imgfmt, '-c', 'map', mid_img),
 105                          qemu_io('-f', iotests.imgfmt, '-c', 'map', test_img),
 106                          'image file map does not match backing file after streaming')
 107
 108     def test_device_not_found(self):
 109         result = self.vm.qmp('block-stream', device='nonexistent')
 110         self.assert_qmp(result, 'error/class', 'DeviceNotFound')
 111
 112
 113 class TestSmallerBackingFile(iotests.QMPTestCase):
 114     backing_len = 1 * 1024 * 1024 # MB
 115     image_len = 2 * backing_len
 116
 117     def setUp(self):
 118         iotests.create_image(backing_img, self.backing_len)
 119         qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img, str(self.image_len))
 120         self.vm = iotests.VM().add_drive(test_img)
 121         self.vm.launch()
 122
 123     # If this hangs, then you are missing a fix to complete streaming when the
 124     # end of the backing file is reached.
 125     def test_stream(self):
 126         self.assert_no_active_block_jobs()
 127
 128         result = self.vm.qmp('block-stream', device='drive0')
 129         self.assert_qmp(result, 'return', {})
 130
 131         self.wait_until_completed()
 132
 133         self.assert_no_active_block_jobs()
 134         self.vm.shutdown()
 135
 136 class TestErrors(iotests.QMPTestCase):
 137     image_len = 2 * 1024 * 1024 # MB
 138
 139     # this should match STREAM_BUFFER_SIZE/512 in block/stream.c
 140     STREAM_BUFFER_SIZE = 512 * 1024
 141
 142     def create_blkdebug_file(self, name, event, errno):
 143         file = open(name, 'w')
 144         file.write('''
 145 [inject-error]
 146 state = "1"
 147 event = "%s"
 148 errno = "%d"
 149 immediately = "off"
 150 once = "on"
 151 sector = "%d"
 152
 153 [set-state]
 154 state = "1"
 155 event = "%s"
 156 new_state = "2"
 157
 158 [set-state]
 159 state = "2"
 160 event = "%s"
 161 new_state = "1"
 162 ''' % (event, errno, self.STREAM_BUFFER_SIZE / 512, event, event))
 163         file.close()
 164
 165 class TestEIO(TestErrors):
 166     def setUp(self):
 167         self.blkdebug_file = backing_img + ".blkdebug"
 168         iotests.create_image(backing_img, TestErrors.image_len)
 169         self.create_blkdebug_file(self.blkdebug_file, "read_aio", 5)
 170         qemu_img('create', '-f', iotests.imgfmt,
 171                  '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
 172                        % (self.blkdebug_file, backing_img),
 173                  test_img)
 174         self.vm = iotests.VM().add_drive(test_img)
 175         self.vm.launch()
 176
 177     def tearDown(self):
 178         self.vm.shutdown()
 179         os.remove(test_img)
 180         os.remove(backing_img)
 181         os.remove(self.blkdebug_file)
 182
 183     def test_report(self):
 184         self.assert_no_active_block_jobs()
 185
 186         result = self.vm.qmp('block-stream', device='drive0')
 187         self.assert_qmp(result, 'return', {})
 188
 189         completed = False
 190         error = False
 191         while not completed:
 192             for event in self.vm.get_qmp_events(wait=True):
 193                 if event['event'] == 'BLOCK_JOB_ERROR':
 194                     self.assert_qmp(event, 'data/device', 'drive0')
 195                     self.assert_qmp(event, 'data/operation', 'read')
 196                     error = True
 197                 elif event['event'] == 'BLOCK_JOB_COMPLETED':
 198                     self.assertTrue(error, 'job completed unexpectedly')
 199                     self.assert_qmp(event, 'data/type', 'stream')
 200                     self.assert_qmp(event, 'data/device', 'drive0')
 201                     self.assert_qmp(event, 'data/error', 'Input/output error')
 202                     self.assert_qmp(event, 'data/offset', self.STREAM_BUFFER_SIZE)
 203                     self.assert_qmp(event, 'data/len', self.image_len)
 204                     completed = True
 205
 206         self.assert_no_active_block_jobs()
 207         self.vm.shutdown()
 208
 209     def test_ignore(self):
 210         self.assert_no_active_block_jobs()
 211
 212         result = self.vm.qmp('block-stream', device='drive0', on_error='ignore')
 213         self.assert_qmp(result, 'return', {})
 214
 215         error = False
 216         completed = False
 217         while not completed:
 218             for event in self.vm.get_qmp_events(wait=True):
 219                 if event['event'] == 'BLOCK_JOB_ERROR':
 220                     self.assert_qmp(event, 'data/device', 'drive0')
 221                     self.assert_qmp(event, 'data/operation', 'read')
 222                     result = self.vm.qmp('query-block-jobs')
 223                     self.assert_qmp(result, 'return[0]/paused', False)
 224                     error = True
 225                 elif event['event'] == 'BLOCK_JOB_COMPLETED':
 226                     self.assertTrue(error, 'job completed unexpectedly')
 227                     self.assert_qmp(event, 'data/type', 'stream')
 228                     self.assert_qmp(event, 'data/device', 'drive0')
 229                     self.assert_qmp(event, 'data/error', 'Input/output error')
 230                     self.assert_qmp(event, 'data/offset', self.image_len)
 231                     self.assert_qmp(event, 'data/len', self.image_len)
 232                     completed = True
 233
 234         self.assert_no_active_block_jobs()
 235         self.vm.shutdown()
 236
 237     def test_stop(self):
 238         self.assert_no_active_block_jobs()
 239
 240         result = self.vm.qmp('block-stream', device='drive0', on_error='stop')
 241         self.assert_qmp(result, 'return', {})
 242
 243         error = False
 244         completed = False
 245         while not completed:
 246             for event in self.vm.get_qmp_events(wait=True):
 247                 if event['event'] == 'BLOCK_JOB_ERROR':
 248                     error = True
 249                     self.assert_qmp(event, 'data/device', 'drive0')
 250                     self.assert_qmp(event, 'data/operation', 'read')
 251
 252                     result = self.vm.qmp('query-block-jobs')
 253                     self.assert_qmp(result, 'return[0]/paused', True)
 254                     self.assert_qmp(result, 'return[0]/offset', self.STREAM_BUFFER_SIZE)
 255                     self.assert_qmp(result, 'return[0]/io-status', 'failed')
 256
 257                     result = self.vm.qmp('block-job-resume', device='drive0')
 258                     self.assert_qmp(result, 'return', {})
 259
 260                     result = self.vm.qmp('query-block-jobs')
 261                     if result == {'return': []}:
 262                         # Race; likely already finished. Check.
 263                         continue
 264                     self.assert_qmp(result, 'return[0]/paused', False)
 265                     self.assert_qmp(result, 'return[0]/io-status', 'ok')
 266                 elif event['event'] == 'BLOCK_JOB_COMPLETED':
 267                     self.assertTrue(error, 'job completed unexpectedly')
 268                     self.assert_qmp(event, 'data/type', 'stream')
 269                     self.assert_qmp(event, 'data/device', 'drive0')
 270                     self.assert_qmp_absent(event, 'data/error')
 271                     self.assert_qmp(event, 'data/offset', self.image_len)
 272                     self.assert_qmp(event, 'data/len', self.image_len)
 273                     completed = True
 274
 275         self.assert_no_active_block_jobs()
 276         self.vm.shutdown()
 277
 278     def test_enospc(self):
 279         self.assert_no_active_block_jobs()
 280
 281         result = self.vm.qmp('block-stream', device='drive0', on_error='enospc')
 282         self.assert_qmp(result, 'return', {})
 283
 284         completed = False
 285         error = False
 286         while not completed:
 287             for event in self.vm.get_qmp_events(wait=True):
 288                 if event['event'] == 'BLOCK_JOB_ERROR':
 289                     self.assert_qmp(event, 'data/device', 'drive0')
 290                     self.assert_qmp(event, 'data/operation', 'read')
 291                     error = True
 292                 elif event['event'] == 'BLOCK_JOB_COMPLETED':
 293                     self.assertTrue(error, 'job completed unexpectedly')
 294                     self.assert_qmp(event, 'data/type', 'stream')
 295                     self.assert_qmp(event, 'data/device', 'drive0')
 296                     self.assert_qmp(event, 'data/error', 'Input/output error')
 297                     self.assert_qmp(event, 'data/offset', self.STREAM_BUFFER_SIZE)
 298                     self.assert_qmp(event, 'data/len', self.image_len)
 299                     completed = True
 300
 301         self.assert_no_active_block_jobs()
 302         self.vm.shutdown()
 303
 304 class TestENOSPC(TestErrors):
 305     def setUp(self):
 306         self.blkdebug_file = backing_img + ".blkdebug"
 307         iotests.create_image(backing_img, TestErrors.image_len)
 308         self.create_blkdebug_file(self.blkdebug_file, "read_aio", 28)
 309         qemu_img('create', '-f', iotests.imgfmt,
 310                  '-o', 'backing_file=blkdebug:%s:%s,backing_fmt=raw'
 311                        % (self.blkdebug_file, backing_img),
 312                  test_img)
 313         self.vm = iotests.VM().add_drive(test_img)
 314         self.vm.launch()
 315
 316     def tearDown(self):
 317         self.vm.shutdown()
 318         os.remove(test_img)
 319         os.remove(backing_img)
 320         os.remove(self.blkdebug_file)
 321
 322     def test_enospc(self):
 323         self.assert_no_active_block_jobs()
 324
 325         result = self.vm.qmp('block-stream', device='drive0', on_error='enospc')
 326         self.assert_qmp(result, 'return', {})
 327
 328         error = False
 329         completed = False
 330         while not completed:
 331             for event in self.vm.get_qmp_events(wait=True):
 332                 if event['event'] == 'BLOCK_JOB_ERROR':
 333                     self.assert_qmp(event, 'data/device', 'drive0')
 334                     self.assert_qmp(event, 'data/operation', 'read')
 335
 336                     result = self.vm.qmp('query-block-jobs')
 337                     self.assert_qmp(result, 'return[0]/paused', True)
 338                     self.assert_qmp(result, 'return[0]/offset', self.STREAM_BUFFER_SIZE)
 339                     self.assert_qmp(result, 'return[0]/io-status', 'nospace')
 340
 341                     result = self.vm.qmp('block-job-resume', device='drive0')
 342                     self.assert_qmp(result, 'return', {})
 343
 344                     result = self.vm.qmp('query-block-jobs')
 345                     self.assert_qmp(result, 'return[0]/paused', False)
 346                     self.assert_qmp(result, 'return[0]/io-status', 'ok')
 347                     error = True
 348                 elif event['event'] == 'BLOCK_JOB_COMPLETED':
 349                     self.assertTrue(error, 'job completed unexpectedly')
 350                     self.assert_qmp(event, 'data/type', 'stream')
 351                     self.assert_qmp(event, 'data/device', 'drive0')
 352                     self.assert_qmp_absent(event, 'data/error')
 353                     self.assert_qmp(event, 'data/offset', self.image_len)
 354                     self.assert_qmp(event, 'data/len', self.image_len)
 355                     completed = True
 356
 357         self.assert_no_active_block_jobs()
 358         self.vm.shutdown()
 359
 360 class TestStreamStop(iotests.QMPTestCase):
 361     image_len = 8 * 1024 * 1024 * 1024 # GB
 362
 363     def setUp(self):
 364         qemu_img('create', backing_img, str(TestStreamStop.image_len))
 365         qemu_io('-f', 'raw', '-c', 'write -P 0x1 0 32M', backing_img)
 366         qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
 367         qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0x1 32M 32M', test_img)
 368         self.vm = iotests.VM().add_drive("blkdebug::" + test_img)
 369         self.vm.launch()
 370
 371     def tearDown(self):
 372         self.vm.shutdown()
 373         os.remove(test_img)
 374         os.remove(backing_img)
 375
 376     def test_stream_stop(self):
 377         self.assert_no_active_block_jobs()
 378
 379         self.vm.pause_drive('drive0')
 380         result = self.vm.qmp('block-stream', device='drive0')
 381         self.assert_qmp(result, 'return', {})
 382
 383         time.sleep(0.1)
 384         events = self.vm.get_qmp_events(wait=False)
 385         self.assertEqual(events, [], 'unexpected QMP event: %s' % events)
 386
 387         self.cancel_and_wait(resume=True)
 388
 389 class TestSetSpeed(iotests.QMPTestCase):
 390     image_len = 80 * 1024 * 1024 # MB
 391
 392     def setUp(self):
 393         qemu_img('create', backing_img, str(TestSetSpeed.image_len))
 394         qemu_io('-f', 'raw', '-c', 'write -P 0x1 0 32M', backing_img)
 395         qemu_img('create', '-f', iotests.imgfmt, '-o', 'backing_file=%s' % backing_img, test_img)
 396         qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0x1 32M 32M', test_img)
 397         self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
 398         self.vm.launch()
 399
 400     def tearDown(self):
 401         self.vm.shutdown()
 402         os.remove(test_img)
 403         os.remove(backing_img)
 404
 405     # This is a short performance test which is not run by default.
 406     # Invoke "IMGFMT=qed ./030 TestSetSpeed.perf_test_throughput"
 407     def perf_test_throughput(self):
 408         self.assert_no_active_block_jobs()
 409
 410         result = self.vm.qmp('block-stream', device='drive0')
 411         self.assert_qmp(result, 'return', {})
 412
 413         result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
 414         self.assert_qmp(result, 'return', {})
 415
 416         self.wait_until_completed()
 417
 418         self.assert_no_active_block_jobs()
 419
 420     def test_set_speed(self):
 421         self.assert_no_active_block_jobs()
 422
 423         self.vm.pause_drive('drive0')
 424         result = self.vm.qmp('block-stream', device='drive0')
 425         self.assert_qmp(result, 'return', {})
 426
 427         # Default speed is 0
 428         result = self.vm.qmp('query-block-jobs')
 429         self.assert_qmp(result, 'return[0]/device', 'drive0')
 430         self.assert_qmp(result, 'return[0]/speed', 0)
 431
 432         result = self.vm.qmp('block-job-set-speed', device='drive0', speed=8 * 1024 * 1024)
 433         self.assert_qmp(result, 'return', {})
 434
 435         # Ensure the speed we set was accepted
 436         result = self.vm.qmp('query-block-jobs')
 437         self.assert_qmp(result, 'return[0]/device', 'drive0')
 438         self.assert_qmp(result, 'return[0]/speed', 8 * 1024 * 1024)
 439
 440         self.cancel_and_wait(resume=True)
 441         self.vm.pause_drive('drive0')
 442
 443         # Check setting speed in block-stream works
 444         result = self.vm.qmp('block-stream', device='drive0', speed=4 * 1024 * 1024)
 445         self.assert_qmp(result, 'return', {})
 446
 447         result = self.vm.qmp('query-block-jobs')
 448         self.assert_qmp(result, 'return[0]/device', 'drive0')
 449         self.assert_qmp(result, 'return[0]/speed', 4 * 1024 * 1024)
 450
 451         self.cancel_and_wait(resume=True)
 452
 453     def test_set_speed_invalid(self):
 454         self.assert_no_active_block_jobs()
 455
 456         result = self.vm.qmp('block-stream', device='drive0', speed=-1)
 457         self.assert_qmp(result, 'error/class', 'GenericError')
 458
 459         self.assert_no_active_block_jobs()
 460
 461         result = self.vm.qmp('block-stream', device='drive0')
 462         self.assert_qmp(result, 'return', {})
 463
 464         result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
 465         self.assert_qmp(result, 'error/class', 'GenericError')
 466
 467         self.cancel_and_wait()
 468
 469 if __name__ == '__main__':
 470     iotests.main(supported_fmts=['qcow2', 'qed'])