tests/qemu-iotests/206

   1 #!/usr/bin/env python3
   2 # group: rw
   3 #
   4 # Test qcow2 and file image creation
   5 #
   6 # Copyright (C) 2018 Red Hat, Inc.
   7 #
   8 # Creator/Owner: Kevin Wolf <kwolf@redhat.com>
   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 iotests
  25 from iotests import imgfmt
  26
  27 iotests.script_initialize(supported_fmts=['qcow2'],
  28                           supported_protocols=['file'])
  29 iotests.verify_working_luks()
  30
  31 with iotests.FilePath('t.qcow2') as disk_path, \
  32      iotests.FilePath('t.qcow2.base') as backing_path, \
  33      iotests.VM() as vm:
  34
  35     vm.add_object('secret,id=keysec0,data=foo')
  36
  37     #
  38     # Successful image creation (defaults)
  39     #
  40     iotests.log("=== Successful image creation (defaults) ===")
  41     iotests.log("")
  42
  43     size = 128 * 1024 * 1024
  44
  45     vm.launch()
  46     vm.blockdev_create({ 'driver': 'file',
  47                          'filename': disk_path,
  48                          'size': 0 })
  49
  50     vm.qmp_log('blockdev-add',
  51                filters=[iotests.filter_qmp_testfiles],
  52                driver='file', filename=disk_path,
  53                node_name='imgfile')
  54
  55     vm.blockdev_create({ 'driver': imgfmt,
  56                          'file': 'imgfile',
  57                          'size': size })
  58     vm.shutdown()
  59
  60     iotests.img_info_log(disk_path)
  61
  62     #
  63     # Successful image creation (inline blockdev-add, explicit defaults)
  64     #
  65     iotests.log("=== Successful image creation (inline blockdev-add, explicit defaults) ===")
  66     iotests.log("")
  67
  68     # Choose a different size to show that we got a new image
  69     size = 64 * 1024 * 1024
  70
  71     vm.launch()
  72     vm.blockdev_create({ 'driver': 'file',
  73                          'filename': disk_path,
  74                          'size': 0,
  75                          'preallocation': 'off',
  76                          'nocow': False })
  77
  78     vm.blockdev_create({ 'driver': imgfmt,
  79                          'file': {
  80                              'driver': 'file',
  81                              'filename': disk_path,
  82                          },
  83                          'size': size,
  84                          'version': 'v3',
  85                          'cluster-size': 65536,
  86                          'preallocation': 'off',
  87                          'lazy-refcounts': False,
  88                          'refcount-bits': 16 })
  89     vm.shutdown()
  90
  91     iotests.img_info_log(disk_path)
  92
  93     #
  94     # Successful image creation (v3 non-default options)
  95     #
  96     iotests.log("=== Successful image creation (v3 non-default options) ===")
  97     iotests.log("")
  98
  99     # Choose a different size to show that we got a new image
 100     size = 32 * 1024 * 1024
 101
 102     vm.launch()
 103     vm.blockdev_create({ 'driver': 'file',
 104                          'filename': disk_path,
 105                          'size': 0,
 106                          'preallocation': 'falloc',
 107                          'nocow': True })
 108
 109     vm.blockdev_create({ 'driver': imgfmt,
 110                          'file': {
 111                              'driver': 'file',
 112                              'filename': disk_path,
 113                          },
 114                          'size': size,
 115                          'version': 'v3',
 116                          'cluster-size': 2097152,
 117                          'preallocation': 'metadata',
 118                          'lazy-refcounts': True,
 119                          'refcount-bits': 1 })
 120     vm.shutdown()
 121
 122     iotests.img_info_log(disk_path)
 123
 124     #
 125     # Successful image creation (v2 non-default options)
 126     #
 127     iotests.log("=== Successful image creation (v2 non-default options) ===")
 128     iotests.log("")
 129
 130     vm.launch()
 131     vm.blockdev_create({ 'driver': 'file',
 132                          'filename': disk_path,
 133                          'size': 0 })
 134
 135     vm.blockdev_create({ 'driver': imgfmt,
 136                          'file': {
 137                              'driver': 'file',
 138                              'filename': disk_path,
 139                          },
 140                          'size': size,
 141                          'backing-file': backing_path,
 142                          'backing-fmt': 'qcow2',
 143                          'version': 'v2',
 144                          'cluster-size': 512 })
 145     vm.shutdown()
 146
 147     iotests.img_info_log(disk_path)
 148
 149     #
 150     # Successful image creation (encrypted)
 151     #
 152     iotests.log("=== Successful image creation (encrypted) ===")
 153     iotests.log("")
 154
 155     vm.launch()
 156     vm.blockdev_create({ 'driver': imgfmt,
 157                          'file': {
 158                              'driver': 'file',
 159                              'filename': disk_path,
 160                          },
 161                          'size': size,
 162                          'encrypt': {
 163                              'format': 'luks',
 164                              'key-secret': 'keysec0',
 165                              'cipher-alg': 'twofish-128',
 166                              'cipher-mode': 'ctr',
 167                              'ivgen-alg': 'plain64',
 168                              'ivgen-hash-alg': 'md5',
 169                              'hash-alg': 'sha1',
 170                              'iter-time': 10,
 171                          }})
 172     vm.shutdown()
 173
 174     iotests.img_info_log(disk_path)
 175
 176     #
 177     # Invalid BlockdevRef
 178     #
 179     iotests.log("=== Invalid BlockdevRef ===")
 180     iotests.log("")
 181
 182     vm.launch()
 183     vm.blockdev_create({ 'driver': imgfmt,
 184                          'file': "this doesn't exist",
 185                          'size': size })
 186     vm.shutdown()
 187
 188     #
 189     # Invalid sizes
 190     #
 191     iotests.log("=== Invalid sizes ===")
 192
 193     # TODO Negative image sizes aren't handled correctly, but this is a problem
 194     # with QAPI's implementation of the 'size' type and affects other commands
 195     # as well. Once this is fixed, we may want to add a test case here.
 196     #
 197     # 1. Misaligned image size
 198     # 2. 2^64 - 512
 199     # 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
 200     # 4. 2^63 - 512 (generally valid, but qcow2 can't handle images this size)
 201
 202     vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
 203
 204     vm.launch()
 205     for size in [ 1234, 18446744073709551104, 9223372036854775808,
 206                   9223372036854775296, 9223372035781033984 ]:
 207         vm.blockdev_create({ 'driver': imgfmt,
 208                              'file': 'node0',
 209                              'size': size })
 210     vm.shutdown()
 211
 212     #
 213     # Invalid version
 214     #
 215     iotests.log("=== Invalid version ===")
 216
 217     vm.launch()
 218     vm.blockdev_create({ 'driver': imgfmt,
 219                          'file': 'node0',
 220                          'size': 67108864,
 221                          'version': 'v1' })
 222     vm.blockdev_create({ 'driver': imgfmt,
 223                          'file': 'node0',
 224                          'size': 67108864,
 225                          'version': 'v2',
 226                          'lazy-refcounts': True })
 227     vm.blockdev_create({ 'driver': imgfmt,
 228                          'file': 'node0',
 229                          'size': 67108864,
 230                          'version': 'v2',
 231                          'refcount-bits': 8 })
 232     vm.shutdown()
 233
 234     #
 235     # Invalid backing file options
 236     #
 237     iotests.log("=== Invalid backing file options ===")
 238
 239     vm.launch()
 240     vm.blockdev_create({ 'driver': imgfmt,
 241                          'file': 'node0',
 242                          'size': 67108864,
 243                          'backing-file': '/dev/null',
 244                          'preallocation': 'full' })
 245     vm.blockdev_create({ 'driver': imgfmt,
 246                          'file': 'node0',
 247                          'size': 67108864,
 248                          'backing-fmt': imgfmt })
 249     vm.shutdown()
 250
 251     #
 252     # Invalid cluster size
 253     #
 254     iotests.log("=== Invalid cluster size ===")
 255
 256     vm.launch()
 257     for csize in [ 1234, 128, 4194304, 0 ]:
 258         vm.blockdev_create({ 'driver': imgfmt,
 259                              'file': 'node0',
 260                              'size': 67108864,
 261                              'cluster-size': csize })
 262     vm.blockdev_create({ 'driver': imgfmt,
 263                          'file': 'node0',
 264                          'size': 281474976710656,
 265                          'cluster-size': 512 })
 266     vm.shutdown()
 267
 268     #
 269     # Invalid refcount width
 270     #
 271     iotests.log("=== Invalid refcount width ===")
 272
 273     vm.launch()
 274     for refcount_bits in [ 128, 0, 7 ]:
 275         vm.blockdev_create({ 'driver': imgfmt,
 276                              'file': 'node0',
 277                              'size': 67108864,
 278                              'refcount-bits': refcount_bits })
 279     vm.shutdown()