qemu/tests/qemu-iotests/206

280 lines
8.8 KiB
Plaintext
Raw Normal View History

#!/usr/bin/env python3
# group: rw
#
# Test qcow2 and file image creation
#
# Copyright (C) 2018 Red Hat, Inc.
#
# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
import iotests
from iotests import imgfmt
iotests.script_initialize(supported_fmts=['qcow2'],
supported_protocols=['file'])
iotests.verify_working_luks()
with iotests.FilePath('t.qcow2') as disk_path, \
iotests.FilePath('t.qcow2.base') as backing_path, \
iotests.VM() as vm:
vm.add_object('secret,id=keysec0,data=foo')
#
# Successful image creation (defaults)
#
iotests.log("=== Successful image creation (defaults) ===")
iotests.log("")
size = 128 * 1024 * 1024
vm.launch()
vm.blockdev_create({ 'driver': 'file',
'filename': disk_path,
'size': 0 })
vm.qmp_log('blockdev-add',
filters=[iotests.filter_qmp_testfiles],
driver='file', filename=disk_path,
node_name='imgfile')
vm.blockdev_create({ 'driver': imgfmt,
'file': 'imgfile',
'size': size })
vm.shutdown()
iotests.img_info_log(disk_path)
#
# Successful image creation (inline blockdev-add, explicit defaults)
#
iotests.log("=== Successful image creation (inline blockdev-add, explicit defaults) ===")
iotests.log("")
# Choose a different size to show that we got a new image
size = 64 * 1024 * 1024
vm.launch()
vm.blockdev_create({ 'driver': 'file',
'filename': disk_path,
'size': 0,
'preallocation': 'off',
'nocow': False })
vm.blockdev_create({ 'driver': imgfmt,
'file': {
'driver': 'file',
'filename': disk_path,
},
'size': size,
'version': 'v3',
'cluster-size': 65536,
'preallocation': 'off',
'lazy-refcounts': False,
'refcount-bits': 16 })
vm.shutdown()
iotests.img_info_log(disk_path)
#
# Successful image creation (v3 non-default options)
#
iotests.log("=== Successful image creation (v3 non-default options) ===")
iotests.log("")
# Choose a different size to show that we got a new image
size = 32 * 1024 * 1024
vm.launch()
vm.blockdev_create({ 'driver': 'file',
'filename': disk_path,
'size': 0,
'preallocation': 'falloc',
'nocow': True })
vm.blockdev_create({ 'driver': imgfmt,
'file': {
'driver': 'file',
'filename': disk_path,
},
'size': size,
'version': 'v3',
'cluster-size': 2097152,
'preallocation': 'metadata',
'lazy-refcounts': True,
'refcount-bits': 1 })
vm.shutdown()
iotests.img_info_log(disk_path)
#
# Successful image creation (v2 non-default options)
#
iotests.log("=== Successful image creation (v2 non-default options) ===")
iotests.log("")
vm.launch()
vm.blockdev_create({ 'driver': 'file',
'filename': disk_path,
'size': 0 })
vm.blockdev_create({ 'driver': imgfmt,
'file': {
'driver': 'file',
'filename': disk_path,
},
'size': size,
'backing-file': backing_path,
'backing-fmt': 'qcow2',
'version': 'v2',
'cluster-size': 512 })
vm.shutdown()
iotests.img_info_log(disk_path)
#
# Successful image creation (encrypted)
#
iotests.log("=== Successful image creation (encrypted) ===")
iotests.log("")
vm.launch()
vm.blockdev_create({ 'driver': imgfmt,
'file': {
'driver': 'file',
'filename': disk_path,
},
'size': size,
'encrypt': {
'format': 'luks',
'key-secret': 'keysec0',
'cipher-alg': 'aes-128',
'cipher-mode': 'cbc',
'ivgen-alg': 'plain64',
'ivgen-hash-alg': 'md5',
'hash-alg': 'sha1',
'iter-time': 10,
}})
vm.shutdown()
iotests.img_info_log(disk_path)
#
# Invalid BlockdevRef
#
iotests.log("=== Invalid BlockdevRef ===")
iotests.log("")
vm.launch()
vm.blockdev_create({ 'driver': imgfmt,
'file': "this doesn't exist",
'size': size })
vm.shutdown()
#
# Invalid sizes
#
iotests.log("=== Invalid sizes ===")
# TODO Negative image sizes aren't handled correctly, but this is a problem
# with QAPI's implementation of the 'size' type and affects other commands
# as well. Once this is fixed, we may want to add a test case here.
#
# 1. Misaligned image size
# 2. 2^64 - 512
# 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)
# 4. 2^63 - 512 (generally valid, but qcow2 can't handle images this size)
vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
vm.launch()
for size in [ 1234, 18446744073709551104, 9223372036854775808,
block: introduce BDRV_MAX_LENGTH We are going to modify block layer to work with 64bit requests. And first step is moving to int64_t type for both offset and bytes arguments in all block request related functions. It's mostly safe (when widening signed or unsigned int to int64_t), but switching from uint64_t is questionable. So, let's first establish the set of requests we want to work with. First signed int64_t should be enough, as off_t is signed anyway. Then, obviously offset + bytes should not overflow. And most interesting: (offset + bytes) being aligned up should not overflow as well. Aligned to what alignment? First thing that comes in mind is bs->bl.request_alignment, as we align up request to this alignment. But there is another thing: look at bdrv_mark_request_serialising(). It aligns request up to some given alignment. And this parameter may be bdrv_get_cluster_size(), which is often a lot greater than bs->bl.request_alignment. Note also, that bdrv_mark_request_serialising() uses signed int64_t for calculations. So, actually, we already depend on some restrictions. Happily, bdrv_get_cluster_size() returns int and bs->bl.request_alignment has 32bit unsigned type, but defined to be a power of 2 less than INT_MAX. So, we may establish, that INT_MAX is absolute maximum for any kind of alignment that may occur with the request. Note, that bdrv_get_cluster_size() is not documented to return power of 2, still bdrv_mark_request_serialising() behaves like it is. Also, backup uses bdi.cluster_size and is not prepared to it not being power of 2. So, let's establish that Qemu supports only power-of-2 clusters and alignments. So, alignment can't be greater than 2^30. Finally to be safe with calculations, to not calculate different maximums for different nodes (depending on cluster size and request_alignment), let's simply set QEMU_ALIGN_DOWN(INT64_MAX, 2^30) as absolute maximum bytes length for Qemu. Actually, it's not much less than INT64_MAX. OK, then, let's apply it to block/io. Let's consider all block/io entry points of offset/bytes: 4 bytes/offset interface functions: bdrv_co_preadv_part(), bdrv_co_pwritev_part(), bdrv_co_copy_range_internal() and bdrv_co_pdiscard() and we check them all with bdrv_check_request(). We also have one entry point with only offset: bdrv_co_truncate(). Check the offset. And one public structure: BdrvTrackedRequest. Happily, it has only three external users: file-posix.c: adopted by this patch write-threshold.c: only read fields test-write-threshold.c: sets obviously small constant values Better is to make the structure private and add corresponding interfaces.. Still it's not obvious what kind of interface is needed for file-posix.c. Let's keep it public but add corresponding assertions. After this patch we'll convert functions in block/io.c to int64_t bytes and offset parameters. We can assume that offset/bytes pair always satisfy new restrictions, and make corresponding assertions where needed. If we reach some offset/bytes point in block/io.c missing bdrv_check_request() it is considered a bug. As well, if block/io.c modifies a offset/bytes request, expanding it more then aligning up to request_alignment, it's a bug too. For all io requests except for discard we keep for now old restriction of 32bit request length. iotest 206 output error message changed, as now test disk size is larger than new limit. Add one more test case with new maximum disk size to cover too-big-L1 case. Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> Message-Id: <20201203222713.13507-5-vsementsov@virtuozzo.com> Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2020-12-04 01:27:13 +03:00
9223372036854775296, 9223372035781033984 ]:
vm.blockdev_create({ 'driver': imgfmt,
'file': 'node0',
'size': size })
vm.shutdown()
#
# Invalid version
#
iotests.log("=== Invalid version ===")
vm.launch()
vm.blockdev_create({ 'driver': imgfmt,
'file': 'node0',
'size': 67108864,
'version': 'v1' })
vm.blockdev_create({ 'driver': imgfmt,
'file': 'node0',
'size': 67108864,
'version': 'v2',
'lazy-refcounts': True })
vm.blockdev_create({ 'driver': imgfmt,
'file': 'node0',
'size': 67108864,
'version': 'v2',
'refcount-bits': 8 })
vm.shutdown()
#
# Invalid backing file options
#
iotests.log("=== Invalid backing file options ===")
vm.launch()
vm.blockdev_create({ 'driver': imgfmt,
'file': 'node0',
'size': 67108864,
'backing-file': '/dev/null',
'preallocation': 'full' })
vm.blockdev_create({ 'driver': imgfmt,
'file': 'node0',
'size': 67108864,
'backing-fmt': imgfmt })
vm.shutdown()
#
# Invalid cluster size
#
iotests.log("=== Invalid cluster size ===")
vm.launch()
for csize in [ 1234, 128, 4194304, 0 ]:
vm.blockdev_create({ 'driver': imgfmt,
'file': 'node0',
'size': 67108864,
'cluster-size': csize })
vm.blockdev_create({ 'driver': imgfmt,
'file': 'node0',
'size': 281474976710656,
'cluster-size': 512 })
vm.shutdown()
#
# Invalid refcount width
#
iotests.log("=== Invalid refcount width ===")
vm.launch()
for refcount_bits in [ 128, 0, 7 ]:
vm.blockdev_create({ 'driver': imgfmt,
'file': 'node0',
'size': 67108864,
'refcount-bits': refcount_bits })
vm.shutdown()