tests/qemu-iotests/245

   1 #!/usr/bin/env python
   2 #
   3 # Test cases for the QMP 'x-blockdev-reopen' command
   4 #
   5 # Copyright (C) 2018-2019 Igalia, S.L.
   6 # Author: Alberto Garcia <berto@igalia.com>
   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 re
  24 import iotests
  25 import copy
  26 import json
  27 from iotests import qemu_img, qemu_io
  28
  29 hd_path = [
  30     os.path.join(iotests.test_dir, 'hd0.img'),
  31     os.path.join(iotests.test_dir, 'hd1.img'),
  32     os.path.join(iotests.test_dir, 'hd2.img')
  33 ]
  34
  35 def hd_opts(idx):
  36     return {'driver': iotests.imgfmt,
  37             'node-name': 'hd%d' % idx,
  38             'file': {'driver': 'file',
  39                      'node-name': 'hd%d-file' % idx,
  40                      'filename':  hd_path[idx] } }
  41
  42 class TestBlockdevReopen(iotests.QMPTestCase):
  43     total_io_cmds = 0
  44
  45     def setUp(self):
  46         qemu_img('create', '-f', iotests.imgfmt, hd_path[0], '3M')
  47         qemu_img('create', '-f', iotests.imgfmt, '-b', hd_path[0], hd_path[1])
  48         qemu_img('create', '-f', iotests.imgfmt, hd_path[2], '3M')
  49         qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xa0  0 1M', hd_path[0])
  50         qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xa1 1M 1M', hd_path[1])
  51         qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xa2 2M 1M', hd_path[2])
  52         self.vm = iotests.VM()
  53         self.vm.launch()
  54
  55     def tearDown(self):
  56         self.vm.shutdown()
  57         self.check_qemu_io_errors()
  58         os.remove(hd_path[0])
  59         os.remove(hd_path[1])
  60         os.remove(hd_path[2])
  61
  62     # The output of qemu-io is not returned by vm.hmp_qemu_io() but
  63     # it's stored in the log and can only be read when the VM has been
  64     # shut down. This function runs qemu-io and keeps track of the
  65     # number of times it's been called.
  66     def run_qemu_io(self, img, cmd):
  67         result = self.vm.hmp_qemu_io(img, cmd)
  68         self.assert_qmp(result, 'return', '')
  69         self.total_io_cmds += 1
  70
  71     # Once the VM is shut down we can parse the log and see if qemu-io
  72     # ran without errors.
  73     def check_qemu_io_errors(self):
  74         self.assertFalse(self.vm.is_running())
  75         found = 0
  76         log = self.vm.get_log()
  77         for line in log.split("\n"):
  78             if line.startswith("Pattern verification failed"):
  79                 raise Exception("%s (command #%d)" % (line, found))
  80             if re.match("read .*/.* bytes at offset", line):
  81                 found += 1
  82         self.assertEqual(found, self.total_io_cmds,
  83                          "Expected output of %d qemu-io commands, found %d" %
  84                          (found, self.total_io_cmds))
  85
  86     # Run x-blockdev-reopen with 'opts' but applying 'newopts'
  87     # on top of it. The original 'opts' dict is unmodified
  88     def reopen(self, opts, newopts = {}, errmsg = None):
  89         opts = copy.deepcopy(opts)
  90
  91         # Apply the changes from 'newopts' on top of 'opts'
  92         for key in newopts:
  93             value = newopts[key]
  94             # If key has the form "foo.bar" then we need to do
  95             # opts["foo"]["bar"] = value, not opts["foo.bar"] = value
  96             subdict = opts
  97             while key.find('.') != -1:
  98                 [prefix, key] = key.split('.', 1)
  99                 subdict = opts[prefix]
 100             subdict[key] = value
 101
 102         result = self.vm.qmp('x-blockdev-reopen', conv_keys = False, **opts)
 103         if errmsg:
 104             self.assert_qmp(result, 'error/class', 'GenericError')
 105             self.assert_qmp(result, 'error/desc', errmsg)
 106         else:
 107             self.assert_qmp(result, 'return', {})
 108
 109
 110     # Run query-named-block-nodes and return the specified entry
 111     def get_node(self, node_name):
 112         result = self.vm.qmp('query-named-block-nodes')
 113         for node in result['return']:
 114             if node['node-name'] == node_name:
 115                 return node
 116         return None
 117
 118     # Run 'query-named-block-nodes' and compare its output with the
 119     # value passed by the user in 'graph'
 120     def check_node_graph(self, graph):
 121         result = self.vm.qmp('query-named-block-nodes')
 122         self.assertEqual(json.dumps(graph,  sort_keys=True),
 123                          json.dumps(result, sort_keys=True))
 124
 125     # This test opens one single disk image (without backing files)
 126     # and tries to reopen it with illegal / incorrect parameters.
 127     def test_incorrect_parameters_single_file(self):
 128         # Open 'hd0' only (no backing files)
 129         opts = hd_opts(0)
 130         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 131         self.assert_qmp(result, 'return', {})
 132         original_graph = self.vm.qmp('query-named-block-nodes')
 133
 134         # We can reopen the image passing the same options
 135         self.reopen(opts)
 136
 137         # We can also reopen passing a child reference in 'file'
 138         self.reopen(opts, {'file': 'hd0-file'})
 139
 140         # We cannot change any of these
 141         self.reopen(opts, {'node-name': 'not-found'}, "Cannot find node named 'not-found'")
 142         self.reopen(opts, {'node-name': ''}, "Cannot find node named ''")
 143         self.reopen(opts, {'node-name': None}, "Invalid parameter type for 'node-name', expected: string")
 144         self.reopen(opts, {'driver': 'raw'}, "Cannot change the option 'driver'")
 145         self.reopen(opts, {'driver': ''}, "Invalid parameter ''")
 146         self.reopen(opts, {'driver': None}, "Invalid parameter type for 'driver', expected: string")
 147         self.reopen(opts, {'file': 'not-found'}, "Cannot change the option 'file'")
 148         self.reopen(opts, {'file': ''}, "Cannot change the option 'file'")
 149         self.reopen(opts, {'file': None}, "Invalid parameter type for 'file', expected: BlockdevRef")
 150         self.reopen(opts, {'file.node-name': 'newname'}, "Cannot change the option 'node-name'")
 151         self.reopen(opts, {'file.driver': 'host_device'}, "Cannot change the option 'driver'")
 152         self.reopen(opts, {'file.filename': hd_path[1]}, "Cannot change the option 'filename'")
 153         self.reopen(opts, {'file.aio': 'native'}, "Cannot change the option 'aio'")
 154         self.reopen(opts, {'file.locking': 'off'}, "Cannot change the option 'locking'")
 155         self.reopen(opts, {'file.filename': None}, "Invalid parameter type for 'file.filename', expected: string")
 156
 157         # node-name is optional in BlockdevOptions, but x-blockdev-reopen needs it
 158         del opts['node-name']
 159         self.reopen(opts, {}, "Node name not specified")
 160
 161         # Check that nothing has changed
 162         self.check_node_graph(original_graph)
 163
 164         # Remove the node
 165         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
 166         self.assert_qmp(result, 'return', {})
 167
 168     # This test opens an image with a backing file and tries to reopen
 169     # it with illegal / incorrect parameters.
 170     def test_incorrect_parameters_backing_file(self):
 171         # Open hd1 omitting the backing options (hd0 will be opened
 172         # with the default options)
 173         opts = hd_opts(1)
 174         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 175         self.assert_qmp(result, 'return', {})
 176         original_graph = self.vm.qmp('query-named-block-nodes')
 177
 178         # We can't reopen the image passing the same options, 'backing' is mandatory
 179         self.reopen(opts, {}, "backing is missing for 'hd1'")
 180
 181         # Everything works if we pass 'backing' using the existing node name
 182         for node in original_graph['return']:
 183             if node['drv'] == iotests.imgfmt and node['file'] == hd_path[0]:
 184                 backing_node_name = node['node-name']
 185         self.reopen(opts, {'backing': backing_node_name})
 186
 187         # We can't use a non-existing or empty (non-NULL) node as the backing image
 188         self.reopen(opts, {'backing': 'not-found'}, "Cannot find device= nor node_name=not-found")
 189         self.reopen(opts, {'backing': ''}, "Cannot find device= nor node_name=")
 190
 191         # We can reopen the image just fine if we specify the backing options
 192         opts['backing'] = {'driver': iotests.imgfmt,
 193                            'file': {'driver': 'file',
 194                                     'filename': hd_path[0]}}
 195         self.reopen(opts)
 196
 197         # We cannot change any of these options
 198         self.reopen(opts, {'backing.node-name': 'newname'}, "Cannot change the option 'node-name'")
 199         self.reopen(opts, {'backing.driver': 'raw'}, "Cannot change the option 'driver'")
 200         self.reopen(opts, {'backing.file.node-name': 'newname'}, "Cannot change the option 'node-name'")
 201         self.reopen(opts, {'backing.file.driver': 'host_device'}, "Cannot change the option 'driver'")
 202
 203         # Check that nothing has changed since the beginning
 204         self.check_node_graph(original_graph)
 205
 206         # Remove the node
 207         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd1')
 208         self.assert_qmp(result, 'return', {})
 209
 210     # Reopen an image several times changing some of its options
 211     def test_reopen(self):
 212         # Check whether the filesystem supports O_DIRECT
 213         if 'O_DIRECT' in qemu_io('-f', 'raw', '-t', 'none', '-c', 'quit', hd_path[0]):
 214             supports_direct = False
 215         else:
 216             supports_direct = True
 217
 218         # Open the hd1 image passing all backing options
 219         opts = hd_opts(1)
 220         opts['backing'] = hd_opts(0)
 221         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 222         self.assert_qmp(result, 'return', {})
 223         original_graph = self.vm.qmp('query-named-block-nodes')
 224
 225         # We can reopen the image passing the same options
 226         self.reopen(opts)
 227
 228         # Reopen in read-only mode
 229         self.assert_qmp(self.get_node('hd1'), 'ro', False)
 230
 231         self.reopen(opts, {'read-only': True})
 232         self.assert_qmp(self.get_node('hd1'), 'ro', True)
 233         self.reopen(opts)
 234         self.assert_qmp(self.get_node('hd1'), 'ro', False)
 235
 236         # Change the cache options
 237         self.assert_qmp(self.get_node('hd1'), 'cache/writeback', True)
 238         self.assert_qmp(self.get_node('hd1'), 'cache/direct', False)
 239         self.assert_qmp(self.get_node('hd1'), 'cache/no-flush', False)
 240         self.reopen(opts, {'cache': { 'direct': supports_direct, 'no-flush': True }})
 241         self.assert_qmp(self.get_node('hd1'), 'cache/writeback', True)
 242         self.assert_qmp(self.get_node('hd1'), 'cache/direct', supports_direct)
 243         self.assert_qmp(self.get_node('hd1'), 'cache/no-flush', True)
 244
 245         # Reopen again with the original options
 246         self.reopen(opts)
 247         self.assert_qmp(self.get_node('hd1'), 'cache/writeback', True)
 248         self.assert_qmp(self.get_node('hd1'), 'cache/direct', False)
 249         self.assert_qmp(self.get_node('hd1'), 'cache/no-flush', False)
 250
 251         # Change 'detect-zeroes' and 'discard'
 252         self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'off')
 253         self.reopen(opts, {'detect-zeroes': 'on'})
 254         self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'on')
 255         self.reopen(opts, {'detect-zeroes': 'unmap'},
 256                     "setting detect-zeroes to unmap is not allowed " +
 257                     "without setting discard operation to unmap")
 258         self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'on')
 259         self.reopen(opts, {'detect-zeroes': 'unmap', 'discard': 'unmap'})
 260         self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'unmap')
 261         self.reopen(opts)
 262         self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'off')
 263
 264         # Changing 'force-share' is currently not supported
 265         self.reopen(opts, {'force-share': True}, "Cannot change the option 'force-share'")
 266
 267         # Change some qcow2-specific options
 268         # No way to test for success other than checking the return message
 269         if iotests.imgfmt == 'qcow2':
 270             self.reopen(opts, {'l2-cache-entry-size': 128 * 1024},
 271                         "L2 cache entry size must be a power of two "+
 272                         "between 512 and the cluster size (65536)")
 273             self.reopen(opts, {'l2-cache-size': 1024 * 1024,
 274                                'cache-size':     512 * 1024},
 275                         "l2-cache-size may not exceed cache-size")
 276             self.reopen(opts, {'l2-cache-size':        4 * 1024 * 1024,
 277                                'refcount-cache-size':  4 * 1024 * 1024,
 278                                'l2-cache-entry-size': 32 * 1024})
 279             self.reopen(opts, {'pass-discard-request': True})
 280
 281         # Check that nothing has changed since the beginning
 282         # (from the parameters that we can check)
 283         self.check_node_graph(original_graph)
 284
 285         # Check that the node names (other than the top-level one) are optional
 286         del opts['file']['node-name']
 287         del opts['backing']['node-name']
 288         del opts['backing']['file']['node-name']
 289         self.reopen(opts)
 290         self.check_node_graph(original_graph)
 291
 292         # Reopen setting backing = null, this removes the backing image from the chain
 293         self.reopen(opts, {'backing': None})
 294         self.assert_qmp_absent(self.get_node('hd1'), 'image/backing-image')
 295
 296         # Open the 'hd0' image
 297         result = self.vm.qmp('blockdev-add', conv_keys = False, **hd_opts(0))
 298         self.assert_qmp(result, 'return', {})
 299
 300         # Reopen the hd1 image setting 'hd0' as its backing image
 301         self.reopen(opts, {'backing': 'hd0'})
 302         self.assert_qmp(self.get_node('hd1'), 'image/backing-image/filename', hd_path[0])
 303
 304         # Check that nothing has changed since the beginning
 305         self.reopen(hd_opts(0), {'read-only': True})
 306         self.check_node_graph(original_graph)
 307
 308         # The backing file (hd0) is now a reference, we cannot change backing.* anymore
 309         self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
 310
 311         # We can't remove 'hd0' while it's a backing image of 'hd1'
 312         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
 313         self.assert_qmp(result, 'error/class', 'GenericError')
 314         self.assert_qmp(result, 'error/desc', "Node 'hd0' is busy: node is used as backing hd of 'hd1'")
 315
 316         # But we can remove both nodes if done in the proper order
 317         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd1')
 318         self.assert_qmp(result, 'return', {})
 319         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
 320         self.assert_qmp(result, 'return', {})
 321
 322     # Reopen a raw image and see the effect of changing the 'offset' option
 323     def test_reopen_raw(self):
 324         opts = {'driver': 'raw', 'node-name': 'hd0',
 325                 'file': { 'driver': 'file',
 326                           'filename': hd_path[0],
 327                           'node-name': 'hd0-file' } }
 328
 329         # First we create a 2MB raw file, and fill each half with a
 330         # different value
 331         qemu_img('create', '-f', 'raw', hd_path[0], '2M')
 332         qemu_io('-f', 'raw', '-c', 'write -P 0xa0  0 1M', hd_path[0])
 333         qemu_io('-f', 'raw', '-c', 'write -P 0xa1 1M 1M', hd_path[0])
 334
 335         # Open the raw file with QEMU
 336         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 337         self.assert_qmp(result, 'return', {})
 338
 339         # Read 1MB from offset 0
 340         self.run_qemu_io("hd0", "read -P 0xa0  0 1M")
 341
 342         # Reopen the image with a 1MB offset.
 343         # Now the results are different
 344         self.reopen(opts, {'offset': 1024*1024})
 345         self.run_qemu_io("hd0", "read -P 0xa1  0 1M")
 346
 347         # Reopen again with the original options.
 348         # We get the original results again
 349         self.reopen(opts)
 350         self.run_qemu_io("hd0", "read -P 0xa0  0 1M")
 351
 352         # Remove the block device
 353         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
 354         self.assert_qmp(result, 'return', {})
 355
 356     # Omitting an option should reset it to the default value, but if
 357     # an option cannot be changed it shouldn't be possible to reset it
 358     # to its default value either
 359     def test_reset_default_values(self):
 360         opts = {'driver': 'qcow2', 'node-name': 'hd0',
 361                 'file': { 'driver': 'file',
 362                           'filename': hd_path[0],
 363                           'x-check-cache-dropped': True, # This one can be changed
 364                           'locking': 'off',              # This one can NOT be changed
 365                           'node-name': 'hd0-file' } }
 366
 367         # Open the file with QEMU
 368         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 369         self.assert_qmp(result, 'return', {})
 370
 371         # file.x-check-cache-dropped can be changed...
 372         self.reopen(opts, { 'file.x-check-cache-dropped': False })
 373         # ...and dropped completely (resetting to the default value)
 374         del opts['file']['x-check-cache-dropped']
 375         self.reopen(opts)
 376
 377         # file.locking cannot be changed nor reset to the default value
 378         self.reopen(opts, { 'file.locking': 'on' }, "Cannot change the option 'locking'")
 379         del opts['file']['locking']
 380         self.reopen(opts, {}, "Option 'locking' cannot be reset to its default value")
 381         # But we can reopen it if we maintain its previous value
 382         self.reopen(opts, { 'file.locking': 'off' })
 383
 384         # Remove the block device
 385         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
 386         self.assert_qmp(result, 'return', {})
 387
 388     # This test modifies the node graph a few times by changing the
 389     # 'backing' option on reopen and verifies that the guest data that
 390     # is read afterwards is consistent with the graph changes.
 391     def test_io_with_graph_changes(self):
 392         opts = []
 393
 394         # Open hd0, hd1 and hd2 without any backing image
 395         for i in range(3):
 396             opts.append(hd_opts(i))
 397             opts[i]['backing'] = None
 398             result = self.vm.qmp('blockdev-add', conv_keys = False, **opts[i])
 399             self.assert_qmp(result, 'return', {})
 400
 401         # hd0
 402         self.run_qemu_io("hd0", "read -P 0xa0  0 1M")
 403         self.run_qemu_io("hd0", "read -P 0    1M 1M")
 404         self.run_qemu_io("hd0", "read -P 0    2M 1M")
 405
 406         # hd1 <- hd0
 407         self.reopen(opts[0], {'backing': 'hd1'})
 408
 409         self.run_qemu_io("hd0", "read -P 0xa0  0 1M")
 410         self.run_qemu_io("hd0", "read -P 0xa1 1M 1M")
 411         self.run_qemu_io("hd0", "read -P 0    2M 1M")
 412
 413         # hd1 <- hd0 , hd1 <- hd2
 414         self.reopen(opts[2], {'backing': 'hd1'})
 415
 416         self.run_qemu_io("hd2", "read -P 0     0 1M")
 417         self.run_qemu_io("hd2", "read -P 0xa1 1M 1M")
 418         self.run_qemu_io("hd2", "read -P 0xa2 2M 1M")
 419
 420         # hd1 <- hd2 <- hd0
 421         self.reopen(opts[0], {'backing': 'hd2'})
 422
 423         self.run_qemu_io("hd0", "read -P 0xa0  0 1M")
 424         self.run_qemu_io("hd0", "read -P 0xa1 1M 1M")
 425         self.run_qemu_io("hd0", "read -P 0xa2 2M 1M")
 426
 427         # hd2 <- hd0
 428         self.reopen(opts[2], {'backing': None})
 429
 430         self.run_qemu_io("hd0", "read -P 0xa0  0 1M")
 431         self.run_qemu_io("hd0", "read -P 0    1M 1M")
 432         self.run_qemu_io("hd0", "read -P 0xa2 2M 1M")
 433
 434         # hd2 <- hd1 <- hd0
 435         self.reopen(opts[1], {'backing': 'hd2'})
 436         self.reopen(opts[0], {'backing': 'hd1'})
 437
 438         self.run_qemu_io("hd0", "read -P 0xa0  0 1M")
 439         self.run_qemu_io("hd0", "read -P 0xa1 1M 1M")
 440         self.run_qemu_io("hd0", "read -P 0xa2 2M 1M")
 441
 442         # Illegal operation: hd2 is a child of hd1
 443         self.reopen(opts[2], {'backing': 'hd1'},
 444                     "Making 'hd1' a backing file of 'hd2' would create a cycle")
 445
 446         # hd2 <- hd0, hd2 <- hd1
 447         self.reopen(opts[0], {'backing': 'hd2'})
 448
 449         self.run_qemu_io("hd1", "read -P 0     0 1M")
 450         self.run_qemu_io("hd1", "read -P 0xa1 1M 1M")
 451         self.run_qemu_io("hd1", "read -P 0xa2 2M 1M")
 452
 453         # More illegal operations
 454         self.reopen(opts[2], {'backing': 'hd1'},
 455                     "Making 'hd1' a backing file of 'hd2' would create a cycle")
 456         self.reopen(opts[2], {'file': 'hd0-file'}, "Cannot change the option 'file'")
 457
 458         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd2')
 459         self.assert_qmp(result, 'error/class', 'GenericError')
 460         self.assert_qmp(result, 'error/desc', "Node 'hd2' is busy: node is used as backing hd of 'hd0'")
 461
 462         # hd1 doesn't have a backing file now
 463         self.reopen(opts[1], {'backing': None})
 464
 465         self.run_qemu_io("hd1", "read -P 0     0 1M")
 466         self.run_qemu_io("hd1", "read -P 0xa1 1M 1M")
 467         self.run_qemu_io("hd1", "read -P 0    2M 1M")
 468
 469         # We can't remove the 'backing' option if the image has a
 470         # default backing file
 471         del opts[1]['backing']
 472         self.reopen(opts[1], {}, "backing is missing for 'hd1'")
 473
 474         self.run_qemu_io("hd1", "read -P 0     0 1M")
 475         self.run_qemu_io("hd1", "read -P 0xa1 1M 1M")
 476         self.run_qemu_io("hd1", "read -P 0    2M 1M")
 477
 478     # This test verifies that we can't change the children of a block
 479     # device during a reopen operation in a way that would create
 480     # cycles in the node graph
 481     @iotests.skip_if_unsupported(['blkverify'])
 482     def test_graph_cycles(self):
 483         opts = []
 484
 485         # Open all three images without backing file
 486         for i in range(3):
 487             opts.append(hd_opts(i))
 488             opts[i]['backing'] = None
 489             result = self.vm.qmp('blockdev-add', conv_keys = False, **opts[i])
 490             self.assert_qmp(result, 'return', {})
 491
 492         # hd1 <- hd0, hd1 <- hd2
 493         self.reopen(opts[0], {'backing': 'hd1'})
 494         self.reopen(opts[2], {'backing': 'hd1'})
 495
 496         # Illegal: hd2 is backed by hd1
 497         self.reopen(opts[1], {'backing': 'hd2'},
 498                     "Making 'hd2' a backing file of 'hd1' would create a cycle")
 499
 500         # hd1 <- hd0 <- hd2
 501         self.reopen(opts[2], {'backing': 'hd0'})
 502
 503         # Illegal: hd2 is backed by hd0, which is backed by hd1
 504         self.reopen(opts[1], {'backing': 'hd2'},
 505                     "Making 'hd2' a backing file of 'hd1' would create a cycle")
 506
 507         # Illegal: hd1 cannot point to itself
 508         self.reopen(opts[1], {'backing': 'hd1'},
 509                     "Making 'hd1' a backing file of 'hd1' would create a cycle")
 510
 511         # Remove all backing files
 512         self.reopen(opts[0])
 513         self.reopen(opts[2])
 514
 515         ##########################################
 516         # Add a blkverify node using hd0 and hd1 #
 517         ##########################################
 518         bvopts = {'driver': 'blkverify',
 519                   'node-name': 'bv',
 520                   'test': 'hd0',
 521                   'raw': 'hd1'}
 522         result = self.vm.qmp('blockdev-add', conv_keys = False, **bvopts)
 523         self.assert_qmp(result, 'return', {})
 524
 525         # blkverify doesn't currently allow reopening. TODO: implement this
 526         self.reopen(bvopts, {}, "Block format 'blkverify' used by node 'bv'" +
 527                     " does not support reopening files")
 528
 529         # Illegal: hd0 is a child of the blkverify node
 530         self.reopen(opts[0], {'backing': 'bv'},
 531                     "Making 'bv' a backing file of 'hd0' would create a cycle")
 532
 533         # Delete the blkverify node
 534         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'bv')
 535         self.assert_qmp(result, 'return', {})
 536
 537     # Misc reopen tests with different block drivers
 538     @iotests.skip_if_unsupported(['quorum', 'throttle'])
 539     def test_misc_drivers(self):
 540         ####################
 541         ###### quorum ######
 542         ####################
 543         for i in range(3):
 544             opts = hd_opts(i)
 545             # Open all three images without backing file
 546             opts['backing'] = None
 547             result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 548             self.assert_qmp(result, 'return', {})
 549
 550         opts = {'driver': 'quorum',
 551                 'node-name': 'quorum0',
 552                 'children': ['hd0', 'hd1', 'hd2'],
 553                 'vote-threshold': 2}
 554         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 555         self.assert_qmp(result, 'return', {})
 556
 557         # Quorum doesn't currently allow reopening. TODO: implement this
 558         self.reopen(opts, {}, "Block format 'quorum' used by node 'quorum0'" +
 559                     " does not support reopening files")
 560
 561         # You can't make quorum0 a backing file of hd0:
 562         # hd0 is already a child of quorum0.
 563         self.reopen(hd_opts(0), {'backing': 'quorum0'},
 564                     "Making 'quorum0' a backing file of 'hd0' would create a cycle")
 565
 566         # Delete quorum0
 567         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'quorum0')
 568         self.assert_qmp(result, 'return', {})
 569
 570         # Delete hd0, hd1 and hd2
 571         for i in range(3):
 572             result = self.vm.qmp('blockdev-del', conv_keys = True,
 573                                  node_name = 'hd%d' % i)
 574             self.assert_qmp(result, 'return', {})
 575
 576         ######################
 577         ###### blkdebug ######
 578         ######################
 579         opts = {'driver': 'blkdebug',
 580                 'node-name': 'bd',
 581                 'config': '/dev/null',
 582                 'image': hd_opts(0)}
 583         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 584         self.assert_qmp(result, 'return', {})
 585
 586         # blkdebug allows reopening if we keep the same options
 587         self.reopen(opts)
 588
 589         # but it currently does not allow changes
 590         self.reopen(opts, {'image': 'hd1'}, "Cannot change the option 'image'")
 591         self.reopen(opts, {'align': 33554432}, "Cannot change the option 'align'")
 592         self.reopen(opts, {'config': '/non/existent'}, "Cannot change the option 'config'")
 593         del opts['config']
 594         self.reopen(opts, {}, "Option 'config' cannot be reset to its default value")
 595
 596         # Delete the blkdebug node
 597         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'bd')
 598         self.assert_qmp(result, 'return', {})
 599
 600         ##################
 601         ###### null ######
 602         ##################
 603         opts = {'driver': 'null-co', 'node-name': 'root', 'size': 1024}
 604
 605         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 606         self.assert_qmp(result, 'return', {})
 607
 608         # 1 << 30 is the default value, but we cannot change it explicitly
 609         self.reopen(opts, {'size': (1 << 30)}, "Cannot change the option 'size'")
 610
 611         # We cannot change 'size' back to its default value either
 612         del opts['size']
 613         self.reopen(opts, {}, "Option 'size' cannot be reset to its default value")
 614
 615         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'root')
 616         self.assert_qmp(result, 'return', {})
 617
 618         ##################
 619         ###### file ######
 620         ##################
 621         opts = hd_opts(0)
 622         opts['file']['locking'] = 'on'
 623         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 624         self.assert_qmp(result, 'return', {})
 625
 626         # 'locking' cannot be changed
 627         del opts['file']['locking']
 628         self.reopen(opts, {'file.locking': 'on'})
 629         self.reopen(opts, {'file.locking': 'off'}, "Cannot change the option 'locking'")
 630         self.reopen(opts, {}, "Option 'locking' cannot be reset to its default value")
 631
 632         # Trying to reopen the 'file' node directly does not make a difference
 633         opts = opts['file']
 634         self.reopen(opts, {'locking': 'on'})
 635         self.reopen(opts, {'locking': 'off'}, "Cannot change the option 'locking'")
 636         self.reopen(opts, {}, "Option 'locking' cannot be reset to its default value")
 637
 638         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
 639         self.assert_qmp(result, 'return', {})
 640
 641         ######################
 642         ###### throttle ######
 643         ######################
 644         opts = { 'qom-type': 'throttle-group', 'id': 'group0',
 645                  'props': { 'limits': { 'iops-total': 1000 } } }
 646         result = self.vm.qmp('object-add', conv_keys = False, **opts)
 647         self.assert_qmp(result, 'return', {})
 648
 649         opts = { 'qom-type': 'throttle-group', 'id': 'group1',
 650                  'props': { 'limits': { 'iops-total': 2000 } } }
 651         result = self.vm.qmp('object-add', conv_keys = False, **opts)
 652         self.assert_qmp(result, 'return', {})
 653
 654         # Add a throttle filter with group = group0
 655         opts = { 'driver': 'throttle', 'node-name': 'throttle0',
 656                  'throttle-group': 'group0', 'file': hd_opts(0) }
 657         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 658         self.assert_qmp(result, 'return', {})
 659
 660         # We can reopen it if we keep the same options
 661         self.reopen(opts)
 662
 663         # We can also reopen if 'file' is a reference to the child
 664         self.reopen(opts, {'file': 'hd0'})
 665
 666         # This is illegal
 667         self.reopen(opts, {'throttle-group': 'notfound'}, "Throttle group 'notfound' does not exist")
 668
 669         # But it's possible to change the group to group1
 670         self.reopen(opts, {'throttle-group': 'group1'})
 671
 672         # Now group1 is in use, it cannot be deleted
 673         result = self.vm.qmp('object-del', id = 'group1')
 674         self.assert_qmp(result, 'error/class', 'GenericError')
 675         self.assert_qmp(result, 'error/desc', "object 'group1' is in use, can not be deleted")
 676
 677         # Default options, this switches the group back to group0
 678         self.reopen(opts)
 679
 680         # So now we cannot delete group0
 681         result = self.vm.qmp('object-del', id = 'group0')
 682         self.assert_qmp(result, 'error/class', 'GenericError')
 683         self.assert_qmp(result, 'error/desc', "object 'group0' is in use, can not be deleted")
 684
 685         # But group1 is free this time, and it can be deleted
 686         result = self.vm.qmp('object-del', id = 'group1')
 687         self.assert_qmp(result, 'return', {})
 688
 689         # Let's delete the filter node
 690         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'throttle0')
 691         self.assert_qmp(result, 'return', {})
 692
 693         # And we can finally get rid of group0
 694         result = self.vm.qmp('object-del', id = 'group0')
 695         self.assert_qmp(result, 'return', {})
 696
 697     # If an image has a backing file then the 'backing' option must be
 698     # passed on reopen. We don't allow leaving the option out in this
 699     # case because it's unclear what the correct semantics would be.
 700     def test_missing_backing_options_1(self):
 701         # hd2
 702         opts = hd_opts(2)
 703         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 704         self.assert_qmp(result, 'return', {})
 705
 706         # hd0
 707         opts = hd_opts(0)
 708         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 709         self.assert_qmp(result, 'return', {})
 710
 711         # hd0 has no backing file: we can omit the 'backing' option
 712         self.reopen(opts)
 713
 714         # hd2 <- hd0
 715         self.reopen(opts, {'backing': 'hd2'})
 716
 717         # hd0 has a backing file: we must set the 'backing' option
 718         self.reopen(opts, {}, "backing is missing for 'hd0'")
 719
 720         # hd2 can't be removed because it's the backing file of hd0
 721         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd2')
 722         self.assert_qmp(result, 'error/class', 'GenericError')
 723         self.assert_qmp(result, 'error/desc', "Node 'hd2' is busy: node is used as backing hd of 'hd0'")
 724
 725         # Detach hd2 from hd0.
 726         self.reopen(opts, {'backing': None})
 727         self.reopen(opts, {}, "backing is missing for 'hd0'")
 728
 729         # Remove both hd0 and hd2
 730         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
 731         self.assert_qmp(result, 'return', {})
 732
 733         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd2')
 734         self.assert_qmp(result, 'return', {})
 735
 736     # If an image has default backing file (as part of its metadata)
 737     # then the 'backing' option must be passed on reopen. We don't
 738     # allow leaving the option out in this case because it's unclear
 739     # what the correct semantics would be.
 740     def test_missing_backing_options_2(self):
 741         # hd0 <- hd1
 742         # (hd0 is hd1's default backing file)
 743         opts = hd_opts(1)
 744         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 745         self.assert_qmp(result, 'return', {})
 746
 747         # hd1 has a backing file: we can't omit the 'backing' option
 748         self.reopen(opts, {}, "backing is missing for 'hd1'")
 749
 750         # Let's detach the backing file
 751         self.reopen(opts, {'backing': None})
 752
 753         # No backing file attached to hd1 now, but we still can't omit the 'backing' option
 754         self.reopen(opts, {}, "backing is missing for 'hd1'")
 755
 756         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd1')
 757         self.assert_qmp(result, 'return', {})
 758
 759     # Test that making 'backing' a reference to an existing child
 760     # keeps its current options
 761     def test_backing_reference(self):
 762         # hd2 <- hd1 <- hd0
 763         opts = hd_opts(0)
 764         opts['backing'] = hd_opts(1)
 765         opts['backing']['backing'] = hd_opts(2)
 766         # Enable 'detect-zeroes' on all three nodes
 767         opts['detect-zeroes'] = 'on'
 768         opts['backing']['detect-zeroes'] = 'on'
 769         opts['backing']['backing']['detect-zeroes'] = 'on'
 770         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 771         self.assert_qmp(result, 'return', {})
 772
 773         # Reopen the chain passing the minimum amount of required options.
 774         # By making 'backing' a reference to hd1 (instead of a sub-dict)
 775         # we tell QEMU to keep its current set of options.
 776         opts = {'driver': iotests.imgfmt,
 777                 'node-name': 'hd0',
 778                 'file': 'hd0-file',
 779                 'backing': 'hd1' }
 780         self.reopen(opts)
 781
 782         # This has reset 'detect-zeroes' on hd0, but not on hd1 and hd2.
 783         self.assert_qmp(self.get_node('hd0'), 'detect_zeroes', 'off')
 784         self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'on')
 785         self.assert_qmp(self.get_node('hd2'), 'detect_zeroes', 'on')
 786
 787     # Test what happens if the graph changes due to other operations
 788     # such as block-stream
 789     def test_block_stream_1(self):
 790         # hd1 <- hd0
 791         opts = hd_opts(0)
 792         opts['backing'] = hd_opts(1)
 793         opts['backing']['backing'] = None
 794         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 795         self.assert_qmp(result, 'return', {})
 796
 797         # Stream hd1 into hd0 and wait until it's done
 798         result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0', device = 'hd0')
 799         self.assert_qmp(result, 'return', {})
 800         self.wait_until_completed(drive = 'stream0')
 801
 802         # Now we have only hd0
 803         self.assertEqual(self.get_node('hd1'), None)
 804
 805         # We have backing.* options but there's no backing file anymore
 806         self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
 807
 808         # If we remove the 'backing' option then we can reopen hd0 just fine
 809         del opts['backing']
 810         self.reopen(opts)
 811
 812         # We can also reopen hd0 if we set 'backing' to null
 813         self.reopen(opts, {'backing': None})
 814
 815         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
 816         self.assert_qmp(result, 'return', {})
 817
 818     # Another block_stream test
 819     def test_block_stream_2(self):
 820         # hd2 <- hd1 <- hd0
 821         opts = hd_opts(0)
 822         opts['backing'] = hd_opts(1)
 823         opts['backing']['backing'] = hd_opts(2)
 824         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 825         self.assert_qmp(result, 'return', {})
 826
 827         # Stream hd1 into hd0 and wait until it's done
 828         result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0',
 829                              device = 'hd0', base_node = 'hd2')
 830         self.assert_qmp(result, 'return', {})
 831         self.wait_until_completed(drive = 'stream0')
 832
 833         # The chain is hd2 <- hd0 now. hd1 is missing
 834         self.assertEqual(self.get_node('hd1'), None)
 835
 836         # The backing options in the dict were meant for hd1, but we cannot
 837         # use them with hd2 because hd1 had a backing file while hd2 does not.
 838         self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
 839
 840         # If we remove hd1's options from the dict then things work fine
 841         opts['backing'] = opts['backing']['backing']
 842         self.reopen(opts)
 843
 844         # We can also reopen hd0 if we use a reference to the backing file
 845         self.reopen(opts, {'backing': 'hd2'})
 846
 847         # But we cannot leave the option out
 848         del opts['backing']
 849         self.reopen(opts, {}, "backing is missing for 'hd0'")
 850
 851         # Now we can delete hd0 (and hd2)
 852         result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
 853         self.assert_qmp(result, 'return', {})
 854         self.assertEqual(self.get_node('hd2'), None)
 855
 856     # Reopen the chain during a block-stream job (from hd1 to hd0)
 857     def test_block_stream_3(self):
 858         # hd2 <- hd1 <- hd0
 859         opts = hd_opts(0)
 860         opts['backing'] = hd_opts(1)
 861         opts['backing']['backing'] = hd_opts(2)
 862         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 863         self.assert_qmp(result, 'return', {})
 864
 865         # hd2 <- hd0
 866         result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0',
 867                              device = 'hd0', base_node = 'hd2',
 868                              auto_finalize = False)
 869         self.assert_qmp(result, 'return', {})
 870
 871         # We can remove hd2 while the stream job is ongoing
 872         opts['backing']['backing'] = None
 873         self.reopen(opts, {})
 874
 875         # We can't remove hd1 while the stream job is ongoing
 876         opts['backing'] = None
 877         self.reopen(opts, {}, "Cannot change 'backing' link from 'hd0' to 'hd1'")
 878
 879         self.vm.run_job('stream0', auto_finalize = False, auto_dismiss = True)
 880
 881     # Reopen the chain during a block-stream job (from hd2 to hd1)
 882     def test_block_stream_4(self):
 883         # hd2 <- hd1 <- hd0
 884         opts = hd_opts(0)
 885         opts['backing'] = hd_opts(1)
 886         opts['backing']['backing'] = hd_opts(2)
 887         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 888         self.assert_qmp(result, 'return', {})
 889
 890         # hd1 <- hd0
 891         result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0',
 892                              device = 'hd1', auto_finalize = False)
 893         self.assert_qmp(result, 'return', {})
 894
 895         # We can't reopen with the original options because that would
 896         # make hd1 read-only and block-stream requires it to be read-write
 897         # (Which error message appears depends on whether the stream job is
 898         # already done with copying at this point.)
 899         self.reopen(opts, {},
 900             ["Can't set node 'hd1' to r/o with copy-on-read enabled",
 901              "Cannot make block node read-only, there is a writer on it"])
 902
 903         # We can't remove hd2 while the stream job is ongoing
 904         opts['backing']['backing'] = None
 905         self.reopen(opts, {'backing.read-only': False}, "Cannot change 'backing' link from 'hd1' to 'hd2'")
 906
 907         # We can detach hd1 from hd0 because it doesn't affect the stream job
 908         opts['backing'] = None
 909         self.reopen(opts)
 910
 911         self.vm.run_job('stream0', auto_finalize = False, auto_dismiss = True)
 912
 913     # Reopen the chain during a block-commit job (from hd0 to hd2)
 914     def test_block_commit_1(self):
 915         # hd2 <- hd1 <- hd0
 916         opts = hd_opts(0)
 917         opts['backing'] = hd_opts(1)
 918         opts['backing']['backing'] = hd_opts(2)
 919         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 920         self.assert_qmp(result, 'return', {})
 921
 922         result = self.vm.qmp('block-commit', conv_keys = True, job_id = 'commit0',
 923                              device = 'hd0')
 924         self.assert_qmp(result, 'return', {})
 925
 926         # We can't remove hd2 while the commit job is ongoing
 927         opts['backing']['backing'] = None
 928         self.reopen(opts, {}, "Cannot change 'backing' link from 'hd1' to 'hd2'")
 929
 930         # We can't remove hd1 while the commit job is ongoing
 931         opts['backing'] = None
 932         self.reopen(opts, {}, "Cannot change 'backing' link from 'hd0' to 'hd1'")
 933
 934         event = self.vm.event_wait(name='BLOCK_JOB_READY')
 935         self.assert_qmp(event, 'data/device', 'commit0')
 936         self.assert_qmp(event, 'data/type', 'commit')
 937         self.assert_qmp_absent(event, 'data/error')
 938
 939         result = self.vm.qmp('block-job-complete', device='commit0')
 940         self.assert_qmp(result, 'return', {})
 941
 942         self.wait_until_completed(drive = 'commit0')
 943
 944     # Reopen the chain during a block-commit job (from hd1 to hd2)
 945     def test_block_commit_2(self):
 946         # hd2 <- hd1 <- hd0
 947         opts = hd_opts(0)
 948         opts['backing'] = hd_opts(1)
 949         opts['backing']['backing'] = hd_opts(2)
 950         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 951         self.assert_qmp(result, 'return', {})
 952
 953         result = self.vm.qmp('block-commit', conv_keys = True, job_id = 'commit0',
 954                              device = 'hd0', top_node = 'hd1',
 955                              auto_finalize = False)
 956         self.assert_qmp(result, 'return', {})
 957
 958         # We can't remove hd2 while the commit job is ongoing
 959         opts['backing']['backing'] = None
 960         self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
 961
 962         # We can't remove hd1 while the commit job is ongoing
 963         opts['backing'] = None
 964         self.reopen(opts, {}, "Cannot change backing link if 'hd0' has an implicit backing file")
 965
 966         # hd2 <- hd0
 967         self.vm.run_job('commit0', auto_finalize = False, auto_dismiss = True)
 968
 969         self.assert_qmp(self.get_node('hd0'), 'ro', False)
 970         self.assertEqual(self.get_node('hd1'), None)
 971         self.assert_qmp(self.get_node('hd2'), 'ro', True)
 972
 973     # We don't allow setting a backing file that uses a different AioContext
 974     def test_iothreads(self):
 975         opts = hd_opts(0)
 976         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
 977         self.assert_qmp(result, 'return', {})
 978
 979         opts2 = hd_opts(2)
 980         result = self.vm.qmp('blockdev-add', conv_keys = False, **opts2)
 981         self.assert_qmp(result, 'return', {})
 982
 983         result = self.vm.qmp('object-add', qom_type='iothread', id='iothread0')
 984         self.assert_qmp(result, 'return', {})
 985
 986         result = self.vm.qmp('object-add', qom_type='iothread', id='iothread1')
 987         self.assert_qmp(result, 'return', {})
 988
 989         result = self.vm.qmp('x-blockdev-set-iothread', node_name='hd0', iothread='iothread0')
 990         self.assert_qmp(result, 'return', {})
 991
 992         self.reopen(opts, {'backing': 'hd2'}, "Cannot use a new backing file with a different AioContext")
 993
 994         result = self.vm.qmp('x-blockdev-set-iothread', node_name='hd2', iothread='iothread1')
 995         self.assert_qmp(result, 'return', {})
 996
 997         self.reopen(opts, {'backing': 'hd2'}, "Cannot use a new backing file with a different AioContext")
 998
 999         result = self.vm.qmp('x-blockdev-set-iothread', node_name='hd2', iothread='iothread0')
1000         self.assert_qmp(result, 'return', {})
1001
1002         self.reopen(opts, {'backing': 'hd2'})
1003
1004 if __name__ == '__main__':
1005     iotests.main(supported_fmts=["qcow2"],
1006                  supported_protocols=["file"])