4 # Test cases for the QMP 'blockdev-reopen' command
6 # Copyright (C) 2018-2019 Igalia, S.L.
7 # Author: Alberto Garcia <berto@igalia.com>
9 # This program is free software; you can redistribute it and/or modify
10 # it under the terms of the GNU General Public License as published by
11 # the Free Software Foundation; either version 2 of the License, or
12 # (at your option) any later version.
14 # This program is distributed in the hope that it will be useful,
15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 # GNU General Public License for more details.
19 # You should have received a copy of the GNU General Public License
20 # along with this program. If not, see <http://www.gnu.org/licenses/>.
28 from iotests import qemu_img, qemu_io
31 os.path.join(iotests.test_dir, 'hd0.img'),
32 os.path.join(iotests.test_dir, 'hd1.img'),
33 os.path.join(iotests.test_dir, 'hd2.img')
37 return {'driver': iotests.imgfmt,
38 'node-name': 'hd%d' % idx,
39 'file': {'driver': 'file',
40 'node-name': 'hd%d-file' % idx,
41 'filename': hd_path[idx] } }
43 class TestBlockdevReopen(iotests.QMPTestCase):
47 qemu_img('create', '-f', iotests.imgfmt, hd_path[0], '3M')
48 qemu_img('create', '-f', iotests.imgfmt, '-b', hd_path[0],
49 '-F', iotests.imgfmt, hd_path[1])
50 qemu_img('create', '-f', iotests.imgfmt, hd_path[2], '3M')
51 qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xa0 0 1M', hd_path[0])
52 qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xa1 1M 1M', hd_path[1])
53 qemu_io('-f', iotests.imgfmt, '-c', 'write -P 0xa2 2M 1M', hd_path[2])
54 self.vm = iotests.VM()
59 self.check_qemu_io_errors()
64 # The output of qemu-io is not returned by vm.hmp_qemu_io() but
65 # it's stored in the log and can only be read when the VM has been
66 # shut down. This function runs qemu-io and keeps track of the
67 # number of times it's been called.
68 def run_qemu_io(self, img, cmd):
69 result = self.vm.hmp_qemu_io(img, cmd)
70 self.assert_qmp(result, 'return', '')
71 self.total_io_cmds += 1
73 # Once the VM is shut down we can parse the log and see if qemu-io
75 def check_qemu_io_errors(self):
76 self.assertFalse(self.vm.is_running())
78 log = self.vm.get_log()
79 for line in log.split("\n"):
80 if line.startswith("Pattern verification failed"):
81 raise Exception("%s (command #%d)" % (line, found))
82 if re.match("(read|wrote) .*/.* bytes at offset", line):
84 self.assertEqual(found, self.total_io_cmds,
85 "Expected output of %d qemu-io commands, found %d" %
86 (found, self.total_io_cmds))
88 # Run blockdev-reopen on a list of block devices
89 def reopenMultiple(self, opts, errmsg = None):
90 result = self.vm.qmp('blockdev-reopen', conv_keys=False, options=opts)
92 self.assert_qmp(result, 'error/class', 'GenericError')
93 self.assert_qmp(result, 'error/desc', errmsg)
95 self.assert_qmp(result, 'return', {})
97 # Run blockdev-reopen on a single block device (specified by
98 # 'opts') but applying 'newopts' on top of it. The original 'opts'
100 def reopen(self, opts, newopts = {}, errmsg = None):
101 opts = copy.deepcopy(opts)
103 # Apply the changes from 'newopts' on top of 'opts'
106 # If key has the form "foo.bar" then we need to do
107 # opts["foo"]["bar"] = value, not opts["foo.bar"] = value
109 while key.find('.') != -1:
110 [prefix, key] = key.split('.', 1)
111 subdict = opts[prefix]
114 self.reopenMultiple([ opts ], errmsg)
117 # Run query-named-block-nodes and return the specified entry
118 def get_node(self, node_name):
119 result = self.vm.qmp('query-named-block-nodes')
120 for node in result['return']:
121 if node['node-name'] == node_name:
125 # Run 'query-named-block-nodes' and compare its output with the
126 # value passed by the user in 'graph'
127 def check_node_graph(self, graph):
128 result = self.vm.qmp('query-named-block-nodes')
129 self.assertEqual(json.dumps(graph, sort_keys=True),
130 json.dumps(result, sort_keys=True))
132 # This test opens one single disk image (without backing files)
133 # and tries to reopen it with illegal / incorrect parameters.
134 def test_incorrect_parameters_single_file(self):
135 # Open 'hd0' only (no backing files)
137 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
138 self.assert_qmp(result, 'return', {})
139 original_graph = self.vm.qmp('query-named-block-nodes')
141 # We can reopen the image passing the same options
144 # We can also reopen passing a child reference in 'file'
145 self.reopen(opts, {'file': 'hd0-file'})
147 # We cannot change any of these
148 self.reopen(opts, {'node-name': 'not-found'}, "Failed to find node with node-name='not-found'")
149 self.reopen(opts, {'node-name': ''}, "Failed to find node with node-name=''")
150 self.reopen(opts, {'node-name': None}, "Invalid parameter type for 'options[0].node-name', expected: string")
151 self.reopen(opts, {'driver': 'raw'}, "Cannot change the option 'driver'")
152 self.reopen(opts, {'driver': ''}, "Parameter 'driver' does not accept value ''")
153 self.reopen(opts, {'driver': None}, "Invalid parameter type for 'options[0].driver', expected: string")
154 self.reopen(opts, {'file': 'not-found'}, "Cannot find device='' nor node-name='not-found'")
155 self.reopen(opts, {'file': ''}, "Cannot find device='' nor node-name=''")
156 self.reopen(opts, {'file': None}, "Invalid parameter type for 'file', expected: BlockdevRef")
157 self.reopen(opts, {'file.node-name': 'newname'}, "Cannot change the option 'node-name'")
158 self.reopen(opts, {'file.driver': 'host_device'}, "Cannot change the option 'driver'")
159 self.reopen(opts, {'file.filename': hd_path[1]}, "Cannot change the option 'filename'")
160 self.reopen(opts, {'file.aio': 'native'}, "Cannot change the option 'aio'")
161 self.reopen(opts, {'file.locking': 'off'}, "Cannot change the option 'locking'")
162 self.reopen(opts, {'file.filename': None}, "Invalid parameter type for 'options[0].file.filename', expected: string")
164 # node-name is optional in BlockdevOptions, but blockdev-reopen needs it
165 del opts['node-name']
166 self.reopen(opts, {}, "node-name not specified")
168 # Check that nothing has changed
169 self.check_node_graph(original_graph)
172 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
173 self.assert_qmp(result, 'return', {})
175 # This test opens an image with a backing file and tries to reopen
176 # it with illegal / incorrect parameters.
177 def test_incorrect_parameters_backing_file(self):
178 # Open hd1 omitting the backing options (hd0 will be opened
179 # with the default options)
181 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
182 self.assert_qmp(result, 'return', {})
183 original_graph = self.vm.qmp('query-named-block-nodes')
185 # We can't reopen the image passing the same options, 'backing' is mandatory
186 self.reopen(opts, {}, "backing is missing for 'hd1'")
188 # Everything works if we pass 'backing' using the existing node name
189 for node in original_graph['return']:
190 if node['drv'] == iotests.imgfmt and node['file'] == hd_path[0]:
191 backing_node_name = node['node-name']
192 self.reopen(opts, {'backing': backing_node_name})
194 # We can't use a non-existing or empty (non-NULL) node as the backing image
195 self.reopen(opts, {'backing': 'not-found'}, "Cannot find device=\'\' nor node-name=\'not-found\'")
196 self.reopen(opts, {'backing': ''}, "Cannot find device=\'\' nor node-name=\'\'")
198 # We can reopen the image just fine if we specify the backing options
199 opts['backing'] = {'driver': iotests.imgfmt,
200 'file': {'driver': 'file',
201 'filename': hd_path[0]}}
204 # We cannot change any of these options
205 self.reopen(opts, {'backing.node-name': 'newname'}, "Cannot change the option 'node-name'")
206 self.reopen(opts, {'backing.driver': 'raw'}, "Cannot change the option 'driver'")
207 self.reopen(opts, {'backing.file.node-name': 'newname'}, "Cannot change the option 'node-name'")
208 self.reopen(opts, {'backing.file.driver': 'host_device'}, "Cannot change the option 'driver'")
210 # Check that nothing has changed since the beginning
211 self.check_node_graph(original_graph)
214 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd1')
215 self.assert_qmp(result, 'return', {})
217 # Reopen an image several times changing some of its options
218 def test_reopen(self):
219 # Check whether the filesystem supports O_DIRECT
220 if 'O_DIRECT' in qemu_io('-f', 'raw', '-t', 'none', '-c', 'quit', hd_path[0]):
221 supports_direct = False
223 supports_direct = True
225 # Open the hd1 image passing all backing options
227 opts['backing'] = hd_opts(0)
228 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
229 self.assert_qmp(result, 'return', {})
230 original_graph = self.vm.qmp('query-named-block-nodes')
232 # We can reopen the image passing the same options
235 # Reopen in read-only mode
236 self.assert_qmp(self.get_node('hd1'), 'ro', False)
238 self.reopen(opts, {'read-only': True})
239 self.assert_qmp(self.get_node('hd1'), 'ro', True)
241 self.assert_qmp(self.get_node('hd1'), 'ro', False)
243 # Change the cache options
244 self.assert_qmp(self.get_node('hd1'), 'cache/writeback', True)
245 self.assert_qmp(self.get_node('hd1'), 'cache/direct', False)
246 self.assert_qmp(self.get_node('hd1'), 'cache/no-flush', False)
247 self.reopen(opts, {'cache': { 'direct': supports_direct, 'no-flush': True }})
248 self.assert_qmp(self.get_node('hd1'), 'cache/writeback', True)
249 self.assert_qmp(self.get_node('hd1'), 'cache/direct', supports_direct)
250 self.assert_qmp(self.get_node('hd1'), 'cache/no-flush', True)
252 # Reopen again with the original options
254 self.assert_qmp(self.get_node('hd1'), 'cache/writeback', True)
255 self.assert_qmp(self.get_node('hd1'), 'cache/direct', False)
256 self.assert_qmp(self.get_node('hd1'), 'cache/no-flush', False)
258 # Change 'detect-zeroes' and 'discard'
259 self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'off')
260 self.reopen(opts, {'detect-zeroes': 'on'})
261 self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'on')
262 self.reopen(opts, {'detect-zeroes': 'unmap'},
263 "setting detect-zeroes to unmap is not allowed " +
264 "without setting discard operation to unmap")
265 self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'on')
266 self.reopen(opts, {'detect-zeroes': 'unmap', 'discard': 'unmap'})
267 self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'unmap')
269 self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'off')
271 # Changing 'force-share' is currently not supported
272 self.reopen(opts, {'force-share': True}, "Cannot change the option 'force-share'")
274 # Change some qcow2-specific options
275 # No way to test for success other than checking the return message
276 if iotests.imgfmt == 'qcow2':
277 self.reopen(opts, {'l2-cache-entry-size': 128 * 1024},
278 "L2 cache entry size must be a power of two "+
279 "between 512 and the cluster size (65536)")
280 self.reopen(opts, {'l2-cache-size': 1024 * 1024,
281 'cache-size': 512 * 1024},
282 "l2-cache-size may not exceed cache-size")
283 self.reopen(opts, {'l2-cache-size': 4 * 1024 * 1024,
284 'refcount-cache-size': 4 * 1024 * 1024,
285 'l2-cache-entry-size': 32 * 1024})
286 self.reopen(opts, {'pass-discard-request': True})
288 # Check that nothing has changed since the beginning
289 # (from the parameters that we can check)
290 self.check_node_graph(original_graph)
292 # Check that the node names (other than the top-level one) are optional
293 del opts['file']['node-name']
294 del opts['backing']['node-name']
295 del opts['backing']['file']['node-name']
297 self.check_node_graph(original_graph)
299 # Reopen setting backing = null, this removes the backing image from the chain
300 self.reopen(opts, {'backing': None})
301 self.assert_qmp_absent(self.get_node('hd1'), 'image/backing-image')
303 # Open the 'hd0' image
304 result = self.vm.qmp('blockdev-add', conv_keys = False, **hd_opts(0))
305 self.assert_qmp(result, 'return', {})
307 # Reopen the hd1 image setting 'hd0' as its backing image
308 self.reopen(opts, {'backing': 'hd0'})
309 self.assert_qmp(self.get_node('hd1'), 'image/backing-image/filename', hd_path[0])
311 # Check that nothing has changed since the beginning
312 self.reopen(hd_opts(0), {'read-only': True})
313 self.check_node_graph(original_graph)
315 # The backing file (hd0) is now a reference, we cannot change backing.* anymore
316 self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
318 # We can't remove 'hd0' while it's a backing image of 'hd1'
319 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
320 self.assert_qmp(result, 'error/class', 'GenericError')
321 self.assert_qmp(result, 'error/desc', "Node 'hd0' is busy: node is used as backing hd of 'hd1'")
323 # But we can remove both nodes if done in the proper order
324 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd1')
325 self.assert_qmp(result, 'return', {})
326 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
327 self.assert_qmp(result, 'return', {})
329 # Reopen a raw image and see the effect of changing the 'offset' option
330 def test_reopen_raw(self):
331 opts = {'driver': 'raw', 'node-name': 'hd0',
332 'file': { 'driver': 'file',
333 'filename': hd_path[0],
334 'node-name': 'hd0-file' } }
336 # First we create a 2MB raw file, and fill each half with a
338 qemu_img('create', '-f', 'raw', hd_path[0], '2M')
339 qemu_io('-f', 'raw', '-c', 'write -P 0xa0 0 1M', hd_path[0])
340 qemu_io('-f', 'raw', '-c', 'write -P 0xa1 1M 1M', hd_path[0])
342 # Open the raw file with QEMU
343 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
344 self.assert_qmp(result, 'return', {})
346 # Read 1MB from offset 0
347 self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
349 # Reopen the image with a 1MB offset.
350 # Now the results are different
351 self.reopen(opts, {'offset': 1024*1024})
352 self.run_qemu_io("hd0", "read -P 0xa1 0 1M")
354 # Reopen again with the original options.
355 # We get the original results again
357 self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
359 # Remove the block device
360 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
361 self.assert_qmp(result, 'return', {})
363 # Omitting an option should reset it to the default value, but if
364 # an option cannot be changed it shouldn't be possible to reset it
365 # to its default value either
366 def test_reset_default_values(self):
367 opts = {'driver': 'qcow2', 'node-name': 'hd0',
368 'file': { 'driver': 'file',
369 'filename': hd_path[0],
370 'x-check-cache-dropped': True, # This one can be changed
371 'locking': 'off', # This one can NOT be changed
372 'node-name': 'hd0-file' } }
374 # Open the file with QEMU
375 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
376 self.assert_qmp(result, 'return', {})
378 # file.x-check-cache-dropped can be changed...
379 self.reopen(opts, { 'file.x-check-cache-dropped': False })
380 # ...and dropped completely (resetting to the default value)
381 del opts['file']['x-check-cache-dropped']
384 # file.locking cannot be changed nor reset to the default value
385 self.reopen(opts, { 'file.locking': 'on' }, "Cannot change the option 'locking'")
386 del opts['file']['locking']
387 self.reopen(opts, {}, "Option 'locking' cannot be reset to its default value")
388 # But we can reopen it if we maintain its previous value
389 self.reopen(opts, { 'file.locking': 'off' })
391 # Remove the block device
392 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
393 self.assert_qmp(result, 'return', {})
395 # This test modifies the node graph a few times by changing the
396 # 'backing' option on reopen and verifies that the guest data that
397 # is read afterwards is consistent with the graph changes.
398 def test_io_with_graph_changes(self):
401 # Open hd0, hd1 and hd2 without any backing image
403 opts.append(hd_opts(i))
404 opts[i]['backing'] = None
405 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts[i])
406 self.assert_qmp(result, 'return', {})
409 self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
410 self.run_qemu_io("hd0", "read -P 0 1M 1M")
411 self.run_qemu_io("hd0", "read -P 0 2M 1M")
414 self.reopen(opts[0], {'backing': 'hd1'})
416 self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
417 self.run_qemu_io("hd0", "read -P 0xa1 1M 1M")
418 self.run_qemu_io("hd0", "read -P 0 2M 1M")
420 # hd1 <- hd0 , hd1 <- hd2
421 self.reopen(opts[2], {'backing': 'hd1'})
423 self.run_qemu_io("hd2", "read -P 0 0 1M")
424 self.run_qemu_io("hd2", "read -P 0xa1 1M 1M")
425 self.run_qemu_io("hd2", "read -P 0xa2 2M 1M")
428 self.reopen(opts[0], {'backing': 'hd2'})
430 self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
431 self.run_qemu_io("hd0", "read -P 0xa1 1M 1M")
432 self.run_qemu_io("hd0", "read -P 0xa2 2M 1M")
435 self.reopen(opts[2], {'backing': None})
437 self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
438 self.run_qemu_io("hd0", "read -P 0 1M 1M")
439 self.run_qemu_io("hd0", "read -P 0xa2 2M 1M")
442 self.reopen(opts[1], {'backing': 'hd2'})
443 self.reopen(opts[0], {'backing': 'hd1'})
445 self.run_qemu_io("hd0", "read -P 0xa0 0 1M")
446 self.run_qemu_io("hd0", "read -P 0xa1 1M 1M")
447 self.run_qemu_io("hd0", "read -P 0xa2 2M 1M")
449 # Illegal operation: hd2 is a child of hd1
450 self.reopen(opts[2], {'backing': 'hd1'},
451 "Making 'hd1' a backing child of 'hd2' would create a cycle")
453 # hd2 <- hd0, hd2 <- hd1
454 self.reopen(opts[0], {'backing': 'hd2'})
456 self.run_qemu_io("hd1", "read -P 0 0 1M")
457 self.run_qemu_io("hd1", "read -P 0xa1 1M 1M")
458 self.run_qemu_io("hd1", "read -P 0xa2 2M 1M")
460 # More illegal operations
461 self.reopen(opts[2], {'backing': 'hd1'},
462 "Making 'hd1' a backing child of 'hd2' would create a cycle")
463 self.reopen(opts[2], {'file': 'hd0-file'},
464 "Permission conflict on node 'hd0-file': permissions 'write, resize' are both required by node 'hd0' (uses node 'hd0-file' as 'file' child) and unshared by node 'hd2' (uses node 'hd0-file' as 'file' child).")
466 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd2')
467 self.assert_qmp(result, 'error/class', 'GenericError')
468 self.assert_qmp(result, 'error/desc', "Node 'hd2' is busy: node is used as backing hd of 'hd0'")
470 # hd1 doesn't have a backing file now
471 self.reopen(opts[1], {'backing': None})
473 self.run_qemu_io("hd1", "read -P 0 0 1M")
474 self.run_qemu_io("hd1", "read -P 0xa1 1M 1M")
475 self.run_qemu_io("hd1", "read -P 0 2M 1M")
477 # We can't remove the 'backing' option if the image has a
478 # default backing file
479 del opts[1]['backing']
480 self.reopen(opts[1], {}, "backing is missing for 'hd1'")
482 self.run_qemu_io("hd1", "read -P 0 0 1M")
483 self.run_qemu_io("hd1", "read -P 0xa1 1M 1M")
484 self.run_qemu_io("hd1", "read -P 0 2M 1M")
486 # This test verifies that we can't change the children of a block
487 # device during a reopen operation in a way that would create
488 # cycles in the node graph
489 @iotests.skip_if_unsupported(['blkverify'])
490 def test_graph_cycles(self):
493 # Open all three images without backing file
495 opts.append(hd_opts(i))
496 opts[i]['backing'] = None
497 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts[i])
498 self.assert_qmp(result, 'return', {})
500 # hd1 <- hd0, hd1 <- hd2
501 self.reopen(opts[0], {'backing': 'hd1'})
502 self.reopen(opts[2], {'backing': 'hd1'})
504 # Illegal: hd2 is backed by hd1
505 self.reopen(opts[1], {'backing': 'hd2'},
506 "Making 'hd2' a backing child of 'hd1' would create a cycle")
509 self.reopen(opts[2], {'backing': 'hd0'})
511 # Illegal: hd2 is backed by hd0, which is backed by hd1
512 self.reopen(opts[1], {'backing': 'hd2'},
513 "Making 'hd2' a backing child of 'hd1' would create a cycle")
515 # Illegal: hd1 cannot point to itself
516 self.reopen(opts[1], {'backing': 'hd1'},
517 "Making 'hd1' a backing child of 'hd1' would create a cycle")
519 # Remove all backing files
523 ##########################################
524 # Add a blkverify node using hd0 and hd1 #
525 ##########################################
526 bvopts = {'driver': 'blkverify',
530 result = self.vm.qmp('blockdev-add', conv_keys = False, **bvopts)
531 self.assert_qmp(result, 'return', {})
533 # blkverify doesn't currently allow reopening. TODO: implement this
534 self.reopen(bvopts, {}, "Block format 'blkverify' used by node 'bv'" +
535 " does not support reopening files")
537 # Illegal: hd0 is a child of the blkverify node
538 self.reopen(opts[0], {'backing': 'bv'},
539 "Making 'bv' a backing child of 'hd0' would create a cycle")
541 # Delete the blkverify node
542 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'bv')
543 self.assert_qmp(result, 'return', {})
545 # Replace the protocol layer ('file' parameter) of a disk image
546 def test_replace_file(self):
547 # Create two small raw images and add them to a running VM
548 qemu_img('create', '-f', 'raw', hd_path[0], '10k')
549 qemu_img('create', '-f', 'raw', hd_path[1], '10k')
551 hd0_opts = {'driver': 'file', 'node-name': 'hd0-file', 'filename': hd_path[0] }
552 hd1_opts = {'driver': 'file', 'node-name': 'hd1-file', 'filename': hd_path[1] }
554 result = self.vm.qmp('blockdev-add', conv_keys = False, **hd0_opts)
555 self.assert_qmp(result, 'return', {})
556 result = self.vm.qmp('blockdev-add', conv_keys = False, **hd1_opts)
557 self.assert_qmp(result, 'return', {})
559 # Add a raw format layer that uses hd0-file as its protocol layer
560 opts = {'driver': 'raw', 'node-name': 'hd', 'file': 'hd0-file'}
562 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
563 self.assert_qmp(result, 'return', {})
565 # Fill the image with data
566 self.run_qemu_io("hd", "read -P 0 0 10k")
567 self.run_qemu_io("hd", "write -P 0xa0 0 10k")
569 # Replace hd0-file with hd1-file and fill it with (different) data
570 self.reopen(opts, {'file': 'hd1-file'})
571 self.run_qemu_io("hd", "read -P 0 0 10k")
572 self.run_qemu_io("hd", "write -P 0xa1 0 10k")
574 # Use hd0-file again and check that it contains the expected data
575 self.reopen(opts, {'file': 'hd0-file'})
576 self.run_qemu_io("hd", "read -P 0xa0 0 10k")
578 # And finally do the same with hd1-file
579 self.reopen(opts, {'file': 'hd1-file'})
580 self.run_qemu_io("hd", "read -P 0xa1 0 10k")
582 # Insert (and remove) a throttle filter
583 def test_insert_throttle_filter(self):
584 # Add an image to the VM
585 hd0_opts = hd_opts(0)
586 result = self.vm.qmp('blockdev-add', conv_keys = False, **hd0_opts)
587 self.assert_qmp(result, 'return', {})
589 # Create a throttle-group object
590 opts = { 'qom-type': 'throttle-group', 'id': 'group0',
591 'limits': { 'iops-total': 1000 } }
592 result = self.vm.qmp('object-add', conv_keys = False, **opts)
593 self.assert_qmp(result, 'return', {})
595 # Add a throttle filter with the group that we just created.
596 # The filter is not used by anyone yet
597 opts = { 'driver': 'throttle', 'node-name': 'throttle0',
598 'throttle-group': 'group0', 'file': 'hd0-file' }
599 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
600 self.assert_qmp(result, 'return', {})
602 # Insert the throttle filter between hd0 and hd0-file
603 self.reopen(hd0_opts, {'file': 'throttle0'})
605 # Remove the throttle filter from hd0
606 self.reopen(hd0_opts, {'file': 'hd0-file'})
608 # Insert (and remove) a compress filter
609 def test_insert_compress_filter(self):
610 # Add an image to the VM: hd (raw) -> hd0 (qcow2) -> hd0-file (file)
611 opts = {'driver': 'raw', 'node-name': 'hd', 'file': hd_opts(0)}
612 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
613 self.assert_qmp(result, 'return', {})
615 # Add a 'compress' filter
616 filter_opts = {'driver': 'compress',
617 'node-name': 'compress0',
619 result = self.vm.qmp('blockdev-add', conv_keys = False, **filter_opts)
620 self.assert_qmp(result, 'return', {})
622 # Unmap the beginning of the image (we cannot write compressed
623 # data to an allocated cluster)
624 self.run_qemu_io("hd", "write -z -u 0 128k")
626 # Write data to the first cluster
627 self.run_qemu_io("hd", "write -P 0xa0 0 64k")
629 # Insert the filter then write to the second cluster
630 # hd -> compress0 -> hd0 -> hd0-file
631 self.reopen(opts, {'file': 'compress0'})
632 self.run_qemu_io("hd", "write -P 0xa1 64k 64k")
634 # Remove the filter then write to the third cluster
635 # hd -> hd0 -> hd0-file
636 self.reopen(opts, {'file': 'hd0'})
637 self.run_qemu_io("hd", "write -P 0xa2 128k 64k")
639 # Verify the data that we just wrote
640 self.run_qemu_io("hd", "read -P 0xa0 0 64k")
641 self.run_qemu_io("hd", "read -P 0xa1 64k 64k")
642 self.run_qemu_io("hd", "read -P 0xa2 128k 64k")
646 # Check the first byte of the first three L2 entries and verify that
647 # the second one is compressed (0x40) while the others are not (0x80)
648 iotests.qemu_io_log('-f', 'raw', '-c', 'read -P 0x80 0x40000 1',
649 '-c', 'read -P 0x40 0x40008 1',
650 '-c', 'read -P 0x80 0x40010 1', hd_path[0])
652 # Swap the disk images of two active block devices
653 def test_swap_files(self):
654 # Add hd0 and hd2 (none of them with backing files)
656 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts0)
657 self.assert_qmp(result, 'return', {})
660 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts2)
661 self.assert_qmp(result, 'return', {})
663 # Write different data to both block devices
664 self.run_qemu_io("hd0", "write -P 0xa0 0 1k")
665 self.run_qemu_io("hd2", "write -P 0xa2 0 1k")
667 # Check that the data reads correctly
668 self.run_qemu_io("hd0", "read -P 0xa0 0 1k")
669 self.run_qemu_io("hd2", "read -P 0xa2 0 1k")
671 # It's not possible to make a block device use an image that
672 # is already being used by the other device.
673 self.reopen(opts0, {'file': 'hd2-file'},
674 "Permission conflict on node 'hd2-file': permissions "
675 "'write, resize' are both required by node 'hd2' (uses "
676 "node 'hd2-file' as 'file' child) and unshared by node "
677 "'hd0' (uses node 'hd2-file' as 'file' child).")
678 self.reopen(opts2, {'file': 'hd0-file'},
679 "Permission conflict on node 'hd0-file': permissions "
680 "'write, resize' are both required by node 'hd0' (uses "
681 "node 'hd0-file' as 'file' child) and unshared by node "
682 "'hd2' (uses node 'hd0-file' as 'file' child).")
684 # But we can swap the images if we reopen both devices at the
686 opts0['file'] = 'hd2-file'
687 opts2['file'] = 'hd0-file'
688 self.reopenMultiple([opts0, opts2])
689 self.run_qemu_io("hd0", "read -P 0xa2 0 1k")
690 self.run_qemu_io("hd2", "read -P 0xa0 0 1k")
692 # And we can of course come back to the original state
693 opts0['file'] = 'hd0-file'
694 opts2['file'] = 'hd2-file'
695 self.reopenMultiple([opts0, opts2])
696 self.run_qemu_io("hd0", "read -P 0xa0 0 1k")
697 self.run_qemu_io("hd2", "read -P 0xa2 0 1k")
699 # Misc reopen tests with different block drivers
700 @iotests.skip_if_unsupported(['quorum', 'throttle'])
701 def test_misc_drivers(self):
707 # Open all three images without backing file
708 opts['backing'] = None
709 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
710 self.assert_qmp(result, 'return', {})
712 opts = {'driver': 'quorum',
713 'node-name': 'quorum0',
714 'children': ['hd0', 'hd1', 'hd2'],
716 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
717 self.assert_qmp(result, 'return', {})
719 # Quorum doesn't currently allow reopening. TODO: implement this
720 self.reopen(opts, {}, "Block format 'quorum' used by node 'quorum0'" +
721 " does not support reopening files")
723 # You can't make quorum0 a backing file of hd0:
724 # hd0 is already a child of quorum0.
725 self.reopen(hd_opts(0), {'backing': 'quorum0'},
726 "Making 'quorum0' a backing child of 'hd0' would create a cycle")
729 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'quorum0')
730 self.assert_qmp(result, 'return', {})
732 # Delete hd0, hd1 and hd2
734 result = self.vm.qmp('blockdev-del', conv_keys = True,
735 node_name = 'hd%d' % i)
736 self.assert_qmp(result, 'return', {})
738 ######################
739 ###### blkdebug ######
740 ######################
741 opts = {'driver': 'blkdebug',
743 'config': '/dev/null',
745 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
746 self.assert_qmp(result, 'return', {})
748 # blkdebug allows reopening if we keep the same options
751 # but it currently does not allow changes
752 self.reopen(opts, {'image': 'hd1'}, "Cannot change the option 'image'")
753 self.reopen(opts, {'align': 33554432}, "Cannot change the option 'align'")
754 self.reopen(opts, {'config': '/non/existent'}, "Cannot change the option 'config'")
756 self.reopen(opts, {}, "Option 'config' cannot be reset to its default value")
758 # Delete the blkdebug node
759 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'bd')
760 self.assert_qmp(result, 'return', {})
765 opts = {'driver': 'null-co', 'node-name': 'root', 'size': 1024}
767 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
768 self.assert_qmp(result, 'return', {})
770 # 1 << 30 is the default value, but we cannot change it explicitly
771 self.reopen(opts, {'size': (1 << 30)}, "Cannot change the option 'size'")
773 # We cannot change 'size' back to its default value either
775 self.reopen(opts, {}, "Option 'size' cannot be reset to its default value")
777 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'root')
778 self.assert_qmp(result, 'return', {})
784 opts['file']['locking'] = 'on'
785 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
786 self.assert_qmp(result, 'return', {})
788 # 'locking' cannot be changed
789 del opts['file']['locking']
790 self.reopen(opts, {'file.locking': 'on'})
791 self.reopen(opts, {'file.locking': 'off'}, "Cannot change the option 'locking'")
792 self.reopen(opts, {}, "Option 'locking' cannot be reset to its default value")
794 # Trying to reopen the 'file' node directly does not make a difference
796 self.reopen(opts, {'locking': 'on'})
797 self.reopen(opts, {'locking': 'off'}, "Cannot change the option 'locking'")
798 self.reopen(opts, {}, "Option 'locking' cannot be reset to its default value")
800 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
801 self.assert_qmp(result, 'return', {})
803 ######################
804 ###### throttle ######
805 ######################
806 opts = { 'qom-type': 'throttle-group', 'id': 'group0',
807 'limits': { 'iops-total': 1000 } }
808 result = self.vm.qmp('object-add', conv_keys = False, **opts)
809 self.assert_qmp(result, 'return', {})
811 opts = { 'qom-type': 'throttle-group', 'id': 'group1',
812 'limits': { 'iops-total': 2000 } }
813 result = self.vm.qmp('object-add', conv_keys = False, **opts)
814 self.assert_qmp(result, 'return', {})
816 # Add a throttle filter with group = group0
817 opts = { 'driver': 'throttle', 'node-name': 'throttle0',
818 'throttle-group': 'group0', 'file': hd_opts(0) }
819 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
820 self.assert_qmp(result, 'return', {})
822 # We can reopen it if we keep the same options
825 # We can also reopen if 'file' is a reference to the child
826 self.reopen(opts, {'file': 'hd0'})
829 self.reopen(opts, {'throttle-group': 'notfound'}, "Throttle group 'notfound' does not exist")
831 # But it's possible to change the group to group1
832 self.reopen(opts, {'throttle-group': 'group1'})
834 # Now group1 is in use, it cannot be deleted
835 result = self.vm.qmp('object-del', id = 'group1')
836 self.assert_qmp(result, 'error/class', 'GenericError')
837 self.assert_qmp(result, 'error/desc', "object 'group1' is in use, can not be deleted")
839 # Default options, this switches the group back to group0
842 # So now we cannot delete group0
843 result = self.vm.qmp('object-del', id = 'group0')
844 self.assert_qmp(result, 'error/class', 'GenericError')
845 self.assert_qmp(result, 'error/desc', "object 'group0' is in use, can not be deleted")
847 # But group1 is free this time, and it can be deleted
848 result = self.vm.qmp('object-del', id = 'group1')
849 self.assert_qmp(result, 'return', {})
851 # Let's delete the filter node
852 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'throttle0')
853 self.assert_qmp(result, 'return', {})
855 # And we can finally get rid of group0
856 result = self.vm.qmp('object-del', id = 'group0')
857 self.assert_qmp(result, 'return', {})
859 # If an image has a backing file then the 'backing' option must be
860 # passed on reopen. We don't allow leaving the option out in this
861 # case because it's unclear what the correct semantics would be.
862 def test_missing_backing_options_1(self):
865 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
866 self.assert_qmp(result, 'return', {})
870 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
871 self.assert_qmp(result, 'return', {})
873 # hd0 has no backing file: we can omit the 'backing' option
877 self.reopen(opts, {'backing': 'hd2'})
879 # hd0 has a backing file: we must set the 'backing' option
880 self.reopen(opts, {}, "backing is missing for 'hd0'")
882 # hd2 can't be removed because it's the backing file of hd0
883 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd2')
884 self.assert_qmp(result, 'error/class', 'GenericError')
885 self.assert_qmp(result, 'error/desc', "Node 'hd2' is busy: node is used as backing hd of 'hd0'")
887 # Detach hd2 from hd0.
888 self.reopen(opts, {'backing': None})
890 # Without a backing file, we can omit 'backing' again
893 # Remove both hd0 and hd2
894 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
895 self.assert_qmp(result, 'return', {})
897 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd2')
898 self.assert_qmp(result, 'return', {})
900 # If an image has default backing file (as part of its metadata)
901 # then the 'backing' option must be passed on reopen. We don't
902 # allow leaving the option out in this case because it's unclear
903 # what the correct semantics would be.
904 def test_missing_backing_options_2(self):
906 # (hd0 is hd1's default backing file)
908 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
909 self.assert_qmp(result, 'return', {})
911 # hd1 has a backing file: we can't omit the 'backing' option
912 self.reopen(opts, {}, "backing is missing for 'hd1'")
914 # Let's detach the backing file
915 self.reopen(opts, {'backing': None})
917 # No backing file attached to hd1 now, but we still can't omit the 'backing' option
918 self.reopen(opts, {}, "backing is missing for 'hd1'")
920 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd1')
921 self.assert_qmp(result, 'return', {})
923 # Test that making 'backing' a reference to an existing child
924 # keeps its current options
925 def test_backing_reference(self):
928 opts['backing'] = hd_opts(1)
929 opts['backing']['backing'] = hd_opts(2)
930 # Enable 'detect-zeroes' on all three nodes
931 opts['detect-zeroes'] = 'on'
932 opts['backing']['detect-zeroes'] = 'on'
933 opts['backing']['backing']['detect-zeroes'] = 'on'
934 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
935 self.assert_qmp(result, 'return', {})
937 # Reopen the chain passing the minimum amount of required options.
938 # By making 'backing' a reference to hd1 (instead of a sub-dict)
939 # we tell QEMU to keep its current set of options.
940 opts = {'driver': iotests.imgfmt,
946 # This has reset 'detect-zeroes' on hd0, but not on hd1 and hd2.
947 self.assert_qmp(self.get_node('hd0'), 'detect_zeroes', 'off')
948 self.assert_qmp(self.get_node('hd1'), 'detect_zeroes', 'on')
949 self.assert_qmp(self.get_node('hd2'), 'detect_zeroes', 'on')
951 # Test what happens if the graph changes due to other operations
952 # such as block-stream
953 def test_block_stream_1(self):
956 opts['backing'] = hd_opts(1)
957 opts['backing']['backing'] = None
958 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
959 self.assert_qmp(result, 'return', {})
961 # Stream hd1 into hd0 and wait until it's done
962 result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0', device = 'hd0')
963 self.assert_qmp(result, 'return', {})
964 self.wait_until_completed(drive = 'stream0')
966 # Now we have only hd0
967 self.assertEqual(self.get_node('hd1'), None)
969 # We have backing.* options but there's no backing file anymore
970 self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
972 # If we remove the 'backing' option then we can reopen hd0 just fine
976 # We can also reopen hd0 if we set 'backing' to null
977 self.reopen(opts, {'backing': None})
979 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
980 self.assert_qmp(result, 'return', {})
982 # Another block_stream test
983 def test_block_stream_2(self):
986 opts['backing'] = hd_opts(1)
987 opts['backing']['backing'] = hd_opts(2)
988 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
989 self.assert_qmp(result, 'return', {})
991 # Stream hd1 into hd0 and wait until it's done
992 result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0',
993 device = 'hd0', base_node = 'hd2')
994 self.assert_qmp(result, 'return', {})
995 self.wait_until_completed(drive = 'stream0')
997 # The chain is hd2 <- hd0 now. hd1 is missing
998 self.assertEqual(self.get_node('hd1'), None)
1000 # The backing options in the dict were meant for hd1, but we cannot
1001 # use them with hd2 because hd1 had a backing file while hd2 does not.
1002 self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
1004 # If we remove hd1's options from the dict then things work fine
1005 opts['backing'] = opts['backing']['backing']
1008 # We can also reopen hd0 if we use a reference to the backing file
1009 self.reopen(opts, {'backing': 'hd2'})
1011 # But we cannot leave the option out
1013 self.reopen(opts, {}, "backing is missing for 'hd0'")
1015 # Now we can delete hd0 (and hd2)
1016 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
1017 self.assert_qmp(result, 'return', {})
1018 self.assertEqual(self.get_node('hd2'), None)
1020 # Reopen the chain during a block-stream job (from hd1 to hd0)
1021 def test_block_stream_3(self):
1024 opts['backing'] = hd_opts(1)
1025 opts['backing']['backing'] = hd_opts(2)
1026 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
1027 self.assert_qmp(result, 'return', {})
1030 result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0',
1031 device = 'hd0', base_node = 'hd2',
1032 auto_finalize = False)
1033 self.assert_qmp(result, 'return', {})
1035 # We can remove hd2 while the stream job is ongoing
1036 opts['backing']['backing'] = None
1037 self.reopen(opts, {})
1039 # We can't remove hd1 while the stream job is ongoing
1040 opts['backing'] = None
1041 self.reopen(opts, {}, "Cannot change frozen 'backing' link from 'hd0' to 'hd1'")
1043 self.vm.run_job('stream0', auto_finalize = False, auto_dismiss = True)
1045 # Reopen the chain during a block-stream job (from hd2 to hd1)
1046 def test_block_stream_4(self):
1049 opts['backing'] = hd_opts(1)
1050 opts['backing']['backing'] = hd_opts(2)
1051 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
1052 self.assert_qmp(result, 'return', {})
1055 result = self.vm.qmp('block-stream', conv_keys = True, job_id = 'stream0',
1056 device = 'hd1', filter_node_name='cor',
1057 auto_finalize = False)
1058 self.assert_qmp(result, 'return', {})
1060 # We can't reopen with the original options because there is a filter
1061 # inserted by stream job above hd1.
1062 self.reopen(opts, {},
1063 "Cannot change the option 'backing.backing.file.node-name'")
1065 # We can't reopen hd1 to read-only, as block-stream requires it to be
1067 self.reopen(opts['backing'], {'read-only': True},
1068 "Read-only block node 'hd1' cannot support read-write users")
1070 # We can't remove hd2 while the stream job is ongoing
1071 opts['backing']['backing'] = None
1072 self.reopen(opts['backing'], {'read-only': False},
1073 "Cannot change frozen 'backing' link from 'hd1' to 'hd2'")
1075 # We can detach hd1 from hd0 because it doesn't affect the stream job
1076 opts['backing'] = None
1079 self.vm.run_job('stream0', auto_finalize = False, auto_dismiss = True)
1081 # Reopen the chain during a block-commit job (from hd0 to hd2)
1082 def test_block_commit_1(self):
1085 opts['backing'] = hd_opts(1)
1086 opts['backing']['backing'] = hd_opts(2)
1087 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
1088 self.assert_qmp(result, 'return', {})
1090 result = self.vm.qmp('block-commit', conv_keys = True, job_id = 'commit0',
1092 self.assert_qmp(result, 'return', {})
1094 # We can't remove hd2 while the commit job is ongoing
1095 opts['backing']['backing'] = None
1096 self.reopen(opts, {}, "Cannot change frozen 'backing' link from 'hd1' to 'hd2'")
1098 # We can't remove hd1 while the commit job is ongoing
1099 opts['backing'] = None
1100 self.reopen(opts, {}, "Cannot change frozen 'backing' link from 'hd0' to 'hd1'")
1102 event = self.vm.event_wait(name='BLOCK_JOB_READY')
1103 self.assert_qmp(event, 'data/device', 'commit0')
1104 self.assert_qmp(event, 'data/type', 'commit')
1105 self.assert_qmp_absent(event, 'data/error')
1107 result = self.vm.qmp('block-job-complete', device='commit0')
1108 self.assert_qmp(result, 'return', {})
1110 self.wait_until_completed(drive = 'commit0')
1112 # Reopen the chain during a block-commit job (from hd1 to hd2)
1113 def test_block_commit_2(self):
1116 opts['backing'] = hd_opts(1)
1117 opts['backing']['backing'] = hd_opts(2)
1118 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
1119 self.assert_qmp(result, 'return', {})
1121 result = self.vm.qmp('block-commit', conv_keys = True, job_id = 'commit0',
1122 device = 'hd0', top_node = 'hd1',
1123 auto_finalize = False)
1124 self.assert_qmp(result, 'return', {})
1126 # We can't remove hd2 while the commit job is ongoing
1127 opts['backing']['backing'] = None
1128 self.reopen(opts, {}, "Cannot change the option 'backing.driver'")
1130 # We can't remove hd1 while the commit job is ongoing
1131 opts['backing'] = None
1132 self.reopen(opts, {}, "Cannot replace implicit backing child of hd0")
1135 self.vm.run_job('commit0', auto_finalize = False, auto_dismiss = True)
1137 self.assert_qmp(self.get_node('hd0'), 'ro', False)
1138 self.assertEqual(self.get_node('hd1'), None)
1139 self.assert_qmp(self.get_node('hd2'), 'ro', True)
1141 def run_test_iothreads(self, iothread_a, iothread_b, errmsg = None,
1142 opts_a = None, opts_b = None):
1143 opts = opts_a or hd_opts(0)
1144 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts)
1145 self.assert_qmp(result, 'return', {})
1147 opts2 = opts_b or hd_opts(2)
1148 result = self.vm.qmp('blockdev-add', conv_keys = False, **opts2)
1149 self.assert_qmp(result, 'return', {})
1151 result = self.vm.qmp('object-add', qom_type='iothread', id='iothread0')
1152 self.assert_qmp(result, 'return', {})
1154 result = self.vm.qmp('object-add', qom_type='iothread', id='iothread1')
1155 self.assert_qmp(result, 'return', {})
1157 result = self.vm.qmp('device_add', driver='virtio-scsi', id='scsi0',
1158 iothread=iothread_a)
1159 self.assert_qmp(result, 'return', {})
1161 result = self.vm.qmp('device_add', driver='virtio-scsi', id='scsi1',
1162 iothread=iothread_b)
1163 self.assert_qmp(result, 'return', {})
1166 result = self.vm.qmp('device_add', driver='scsi-hd', drive='hd0',
1167 share_rw=True, bus="scsi0.0")
1168 self.assert_qmp(result, 'return', {})
1171 result = self.vm.qmp('device_add', driver='scsi-hd', drive='hd2',
1172 share_rw=True, bus="scsi1.0")
1173 self.assert_qmp(result, 'return', {})
1175 # Attaching the backing file may or may not work
1176 self.reopen(opts, {'backing': 'hd2'}, errmsg)
1178 # But removing the backing file should always work
1179 self.reopen(opts, {'backing': None})
1183 # We don't allow setting a backing file that uses a different AioContext if
1184 # neither of them can switch to the other AioContext
1185 def test_iothreads_error(self):
1186 self.run_test_iothreads('iothread0', 'iothread1',
1187 "Cannot change iothread of active block backend")
1189 def test_iothreads_compatible_users(self):
1190 self.run_test_iothreads('iothread0', 'iothread0')
1192 def test_iothreads_switch_backing(self):
1193 self.run_test_iothreads('iothread0', '')
1195 def test_iothreads_switch_overlay(self):
1196 self.run_test_iothreads('', 'iothread0')
1198 def test_iothreads_with_throttling(self):
1199 # Create a throttle-group object
1200 opts = { 'qom-type': 'throttle-group', 'id': 'group0',
1201 'limits': { 'iops-total': 1000 } }
1202 result = self.vm.qmp('object-add', conv_keys = False, **opts)
1203 self.assert_qmp(result, 'return', {})
1205 # Options with a throttle filter between format and protocol
1208 'driver': iotests.imgfmt,
1209 'node-name': f'hd{idx}',
1211 'node-name': f'hd{idx}-throttle',
1212 'driver': 'throttle',
1213 'throttle-group': 'group0',
1216 'node-name': f'hd{idx}-file',
1217 'filename': hd_path[idx],
1224 self.run_test_iothreads('iothread0', 'iothread0', None,
1227 if __name__ == '__main__':
1228 iotests.activate_logging()
1229 iotests.main(supported_fmts=["qcow2"],
1230 supported_protocols=["file"])