ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Block layer patches 

- Fix I/O errors because of incorrectly detected max_iov
 - Fix not white-listed copy-before-write
 - qemu-storage-daemon: Only display FUSE help when FUSE is built-in
 - iotests: update environment and linting configuration
 -----BEGIN PGP SIGNATURE-----
 
 iQJFBAABCAAvFiEE3D3rFZqa+V09dFb+fwmycsiPL9YFAmFdgUIRHGt3b2xmQHJl
 ZGhhdC5jb20ACgkQfwmycsiPL9bdhg//Wo3aVnlVb4MCEexqDGoB2HEIwY2Fumfl
 3iJccK2rmQQ4JtCbJyJ1HOyQTUiyepD3+A86pNw8BMrMS95mOMcbQ6bC79qLJCV7
 IfbwwRsYbqoV3X1xFToI7bEAnt+1Nn8dkJKbKRzgRTbF1Cujfk6kwrW6aX2o7l6W
 jWPyoEnK9ZBGL717I6SR5b7AMHTDtLTEU70xgvXQHXrx/SlhpZ/tMfp5L7dCulf3
 L0LwMPVC0Ne07MT8855zWNfPdVCGZAJL2+cy912DrEWQXNk1JQhqgwCs9th8ncUZ
 F3ItGnd7YNV0Odc6Pk2SA+9q2uMYRvMpNsgHMj1Ccgf1abXtr53c/uvVmVqMYlU6
 RJPpg6M3KjhpmyLLixBaAm/k2va+zueQ/UWU0le8RUy780ISw5UD/wF15mZiIlTP
 813N9muSWHeFSZ2yBuKQR/zpDScklOgmGDJGPc7sYsU4bBP5y3JoO8Ai+nngl4e4
 L/s1tteVLBX077RjT8bTIJlV9NCU8bj8XiI0f/Ip50dh6tnjWNPlPl1xolFI5dM2
 qhAeACDXU8l1kGLjxIqCAFn/K2bhPqxcNH95qo0InhSTAbkGRQhyKx36J40htWwX
 eAkS8NadSEO3IqJAmTAR335S+DC8zwHVKidpKWM2OM+Ze+mAo0t5E9WScTIul8+e
 Wx2b7o4TC3I=
 =Azhw
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/kwolf/tags/for-upstream' into staging

Block layer patches

- Fix I/O errors because of incorrectly detected max_iov
- Fix not white-listed copy-before-write
- qemu-storage-daemon: Only display FUSE help when FUSE is built-in
- iotests: update environment and linting configuration

# gpg: Signature made Wed 06 Oct 2021 03:58:10 AM PDT
# gpg:                using RSA key DC3DEB159A9AF95D3D7456FE7F09B272C88F2FD6
# gpg:                issuer "kwolf@redhat.com"
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>" [full]

* remotes/kwolf/tags/for-upstream:
  iotests: Update for pylint 2.11.1
  iotests/migrate-bitmaps-test: delint
  iotests/mirror-top-perms: Adjust imports
  iotests/linters: check mypy files all at once
  iotests: add 'qemu' package location to PYTHONPATH in testenv
  block: introduce max_hw_iov for use in scsi-generic
  iotests/image-fleecing: declare requirement of copy-before-write
  block: bdrv_insert_node(): don't use bdrv_open()
  block: bdrv_insert_node(): doc and style
  block: bdrv_insert_node(): fix and improve error handling
  block: implement bdrv_new_open_driver_opts()
  qemu-storage-daemon: Only display FUSE help when FUSE is built-in
  include/block.h: remove outdated comment

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson 2021-10-06 07:06:48 -07:00
parent e3acc2c196 3765315d4c
commit 5564f06816
19 changed files with 163 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
block.c
View File

@ -1604,16 +1604,26 @@ open_failed:
return ret;
}
BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
int flags, Error **errp)
/*
* Create and open a block node.
*
* @options is a QDict of options to pass to the block drivers, or NULL for an
* empty set of options. The reference to the QDict belongs to the block layer
* after the call (even on failure), so if the caller intends to reuse the
* dictionary, it needs to use qobject_ref() before calling bdrv_open.
*/
BlockDriverState *bdrv_new_open_driver_opts(BlockDriver *drv,
const char *node_name,
QDict *options, int flags,
Error **errp)
{
BlockDriverState *bs;
int ret;
bs = bdrv_new();
bs->open_flags = flags;
bs->explicit_options = qdict_new();
bs->options = qdict_new();
bs->options = options ?: qdict_new();
bs->explicit_options = qdict_clone_shallow(bs->options);
bs->opaque = NULL;
update_options_from_flags(bs->options, flags);
@ -1631,6 +1641,13 @@ BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
return bs;
}
/* Create and open a block node. */
BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
int flags, Error **errp)
{
return bdrv_new_open_driver_opts(drv, node_name, NULL, flags, errp);
}
QemuOptsList bdrv_runtime_opts = {
.name = "bdrv_common",
.head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
@ -5102,29 +5119,61 @@ static void bdrv_delete(BlockDriverState *bs)
g_free(bs);
}
BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *node_options,
/*
* Replace @bs by newly created block node.
*
* @options is a QDict of options to pass to the block drivers, or NULL for an
* empty set of options. The reference to the QDict belongs to the block layer
* after the call (even on failure), so if the caller intends to reuse the
* dictionary, it needs to use qobject_ref() before calling bdrv_open.
*/
BlockDriverState *bdrv_insert_node(BlockDriverState *bs, QDict *options,
int flags, Error **errp)
{
BlockDriverState *new_node_bs;
Error *local_err = NULL;
ERRP_GUARD();
int ret;
BlockDriverState *new_node_bs = NULL;
const char *drvname, *node_name;
BlockDriver *drv;
new_node_bs = bdrv_open(NULL, NULL, node_options, flags, errp);
if (new_node_bs == NULL) {
drvname = qdict_get_try_str(options, "driver");
if (!drvname) {
error_setg(errp, "driver is not specified");
goto fail;
}
drv = bdrv_find_format(drvname);
if (!drv) {
error_setg(errp, "Unknown driver: '%s'", drvname);
goto fail;
}
node_name = qdict_get_try_str(options, "node-name");
new_node_bs = bdrv_new_open_driver_opts(drv, node_name, options, flags,
errp);
options = NULL; /* bdrv_new_open_driver() eats options */
if (!new_node_bs) {
error_prepend(errp, "Could not create node: ");
return NULL;
goto fail;
}
bdrv_drained_begin(bs);
bdrv_replace_node(bs, new_node_bs, &local_err);
ret = bdrv_replace_node(bs, new_node_bs, errp);
bdrv_drained_end(bs);
if (local_err) {
bdrv_unref(new_node_bs);
error_propagate(errp, local_err);
return NULL;
if (ret < 0) {
error_prepend(errp, "Could not replace node: ");
goto fail;
}
return new_node_bs;
fail:
qobject_unref(options);
bdrv_unref(new_node_bs);
return NULL;
}
/*

6
block/block-backend.c
View File

@ -1986,6 +1986,12 @@ uint32_t blk_get_max_transfer(BlockBackend *blk)
return ROUND_DOWN(max, blk_get_request_alignment(blk));
}
int blk_get_max_hw_iov(BlockBackend *blk)
{
return MIN_NON_ZERO(blk->root->bs->bl.max_hw_iov,
blk->root->bs->bl.max_iov);
}
int blk_get_max_iov(BlockBackend *blk)
{
return blk->root->bs->bl.max_iov;

2
block/file-posix.c
View File

@ -1273,7 +1273,7 @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
ret = hdev_get_max_segments(s->fd, &st);
if (ret > 0) {
bs->bl.max_iov = ret;
bs->bl.max_hw_iov = ret;
}
}
}

1
block/io.c
View File

@ -136,6 +136,7 @@ static void bdrv_merge_limits(BlockLimits *dst, const BlockLimits *src)
dst->min_mem_alignment = MAX(dst->min_mem_alignment,
src->min_mem_alignment);
dst->max_iov = MIN_NON_ZERO(dst->max_iov, src->max_iov);
dst->max_hw_iov = MIN_NON_ZERO(dst->max_hw_iov, src->max_hw_iov);
}
typedef struct BdrvRefreshLimitsState {

2
hw/scsi/scsi-generic.c
View File

@ -180,7 +180,7 @@ static int scsi_handle_inquiry_reply(SCSIGenericReq *r, SCSIDevice *s, int len)
page = r->req.cmd.buf[2];
if (page == 0xb0) {
uint64_t max_transfer = blk_get_max_hw_transfer(s->conf.blk);
uint32_t max_iov = blk_get_max_iov(s->conf.blk);
uint32_t max_iov = blk_get_max_hw_iov(s->conf.blk);
assert(max_transfer);
max_transfer = MIN_NON_ZERO(max_transfer, max_iov * qemu_real_host_page_size)

8
include/block/block.h
View File

@ -383,6 +383,10 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
const char *bdref_key, Error **errp);
BlockDriverState *bdrv_open(const char *filename, const char *reference,
QDict *options, int flags, Error **errp);
BlockDriverState *bdrv_new_open_driver_opts(BlockDriver *drv,
const char *node_name,
QDict *options, int flags,
Error **errp);
BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
int flags, Error **errp);
BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
@ -751,9 +755,7 @@ bool bdrv_drain_poll(BlockDriverState *bs, bool recursive,
* bdrv_drained_begin:
*
* Begin a quiesced section for exclusive access to the BDS, by disabling
* external request sources including NBD server and device model. Note that
* this doesn't block timers or coroutines from submitting more requests, which
* means block_job_pause is still necessary.
* external request sources including NBD server, block jobs, and device model.
*
* This function can be recursive.
*/

7
include/block/block_int.h
View File

@ -718,6 +718,13 @@ typedef struct BlockLimits {
*/
uint64_t max_hw_transfer;
/* Maximal number of scatter/gather elements allowed by the hardware.
* Applies whenever transfers to the device bypass the kernel I/O
* scheduler, for example with SG_IO. If larger than max_iov
* or if zero, blk_get_max_hw_iov will fall back to max_iov.
*/
int max_hw_iov;
/* memory alignment, in bytes so that no bounce buffer is needed */
size_t min_mem_alignment;

1
include/sysemu/block-backend.h
View File

@ -211,6 +211,7 @@ uint32_t blk_get_request_alignment(BlockBackend *blk);
uint32_t blk_get_max_transfer(BlockBackend *blk);
uint64_t blk_get_max_hw_transfer(BlockBackend *blk);
int blk_get_max_iov(BlockBackend *blk);
int blk_get_max_hw_iov(BlockBackend *blk);
void blk_set_guest_block_size(BlockBackend *blk, int align);
void *blk_try_blockalign(BlockBackend *blk, size_t size);
void *blk_blockalign(BlockBackend *blk, size_t size);

2
storage-daemon/qemu-storage-daemon.c
View File

@ -98,10 +98,12 @@ static void help(void)
" export the specified block node over NBD\n"
" (requires --nbd-server)\n"
"\n"
#ifdef CONFIG_FUSE
" --export [type=]fuse,id=<id>,node-name=<node-name>,mountpoint=<file>\n"
" [,growable=on|off][,writable=on|off]\n"
" export the specified block node over FUSE\n"
"\n"
#endif /* CONFIG_FUSE */
" --monitor [chardev=]name[,mode=control][,pretty[=on|off]]\n"
" configure a QMP monitor\n"
"\n"

2
tests/qemu-iotests/235
View File

@ -24,8 +24,6 @@ import os
import iotests
from iotests import qemu_img_create, qemu_io, file_path, log
sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python'))
from qemu.machine import QEMUMachine
iotests.script_initialize(supported_fmts=['qcow2'])

50
tests/qemu-iotests/297
View File

@ -68,44 +68,34 @@ def run_linters():
# Todo notes are fine, but fixme's or xxx's should probably just be
# fixed (in tests, at least)
env = os.environ.copy()
qemu_module_path = os.path.join(os.path.dirname(__file__),
'..', '..', 'python')
try:
env['PYTHONPATH'] += os.pathsep + qemu_module_path
except KeyError:
env['PYTHONPATH'] = qemu_module_path
subprocess.run(('pylint-3', '--score=n', '--notes=FIXME,XXX', *files),
env=env, check=False)
print('=== mypy ===')
sys.stdout.flush()
# We have to call mypy separately for each file. Otherwise, it
# will interpret all given files as belonging together (i.e., they
# may not both define the same classes, etc.; most notably, they
# must not both define the __main__ module).
env['MYPYPATH'] = env['PYTHONPATH']
for filename in files:
p = subprocess.run(('mypy',
'--warn-unused-configs',
'--disallow-subclassing-any',
'--disallow-any-generics',
'--disallow-incomplete-defs',
'--disallow-untyped-decorators',
'--no-implicit-optional',
'--warn-redundant-casts',
'--warn-unused-ignores',
'--no-implicit-reexport',
'--namespace-packages',
filename),
env=env,
check=False,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True)
p = subprocess.run(('mypy',
'--warn-unused-configs',
'--disallow-subclassing-any',
'--disallow-any-generics',
'--disallow-incomplete-defs',
'--disallow-untyped-decorators',
'--no-implicit-optional',
'--warn-redundant-casts',
'--warn-unused-ignores',
'--no-implicit-reexport',
'--namespace-packages',
'--scripts-are-modules',
*files),
env=env,
check=False,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True)
if p.returncode != 0:
print(p.stdout)
if p.returncode != 0:
print(p.stdout)
for linter in ('pylint-3', 'mypy'):

5
tests/qemu-iotests/300
View File

@ -24,11 +24,10 @@ import random
import re
from typing import Dict, List, Optional
from qemu.machine import machine
import iotests
# Import qemu after iotests.py has amended sys.path
# pylint: disable=wrong-import-order
from qemu.machine import machine
BlockBitmapMapping = List[Dict[str, object]]

2
tests/qemu-iotests/iotests.py
View File

@ -36,8 +36,6 @@ import unittest
from contextlib import contextmanager
# pylint: disable=import-error, wrong-import-position
sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'python'))
from qemu.machine import qtest
from qemu.qmp import QMPMessage

6
tests/qemu-iotests/pylintrc
View File

@ -19,13 +19,17 @@ disable=invalid-name,
too-many-public-methods,
# pylint warns about Optional[] etc. as unsubscriptable in 3.9
unsubscriptable-object,
# pylint's static analysis causes false positivies for file_path();
# If we really care to make it statically knowable, we'll use mypy.
unbalanced-tuple-unpacking,
# Sometimes we need to disable a newly introduced pylint warning.
# Doing so should not produce a warning in older versions of pylint.
bad-option-value,
# These are temporary, and should be removed:
missing-docstring,
too-many-return-statements,
too-many-statements
too-many-statements,
consider-using-f-string,
[FORMAT]

15
tests/qemu-iotests/testenv.py
View File

@ -108,12 +108,15 @@ class TestEnv(ContextManager['TestEnv']):
SAMPLE_IMG_DIR
OUTPUT_DIR
"""
self.pythonpath = os.getenv('PYTHONPATH')
if self.pythonpath:
self.pythonpath = self.source_iotests + os.pathsep + \
self.pythonpath
else:
self.pythonpath = self.source_iotests
# Path where qemu goodies live in this source tree.
qemu_srctree_path = Path(__file__, '../../../python').resolve()
self.pythonpath = os.pathsep.join(filter(None, (
self.source_iotests,
str(qemu_srctree_path),
os.getenv('PYTHONPATH'),
)))
self.test_dir = os.getenv('TEST_DIR',
os.path.join(os.getcwd(), 'scratch'))

7
tests/qemu-iotests/testrunner.py
View File

@ -266,12 +266,13 @@ class TestRunner(ContextManager['TestRunner']):
diff=file_diff(str(f_reference), str(f_bad)))
if f_notrun.exists():
return TestResult(status='not run',
description=f_notrun.read_text().strip())
return TestResult(
status='not run',
description=f_notrun.read_text(encoding='utf-8').strip())
casenotrun = ''
if f_casenotrun.exists():
casenotrun = f_casenotrun.read_text()
casenotrun = f_casenotrun.read_text(encoding='utf-8')
diff = file_diff(str(f_reference), str(f_bad))
if diff:

1
tests/qemu-iotests/tests/image-fleecing
View File

@ -28,6 +28,7 @@ from iotests import log, qemu_img, qemu_io, qemu_io_silent
iotests.script_initialize(
supported_fmts=['qcow2', 'qcow', 'qed', 'vmdk', 'vhdx', 'raw'],
supported_platforms=['linux'],
required_fmts=['copy-before-write'],
)
patterns = [('0x5d', '0', '64k'),

50
tests/qemu-iotests/tests/migrate-bitmaps-test
View File

@ -19,10 +19,11 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
import os
import itertools
import operator
import os
import re
import iotests
from iotests import qemu_img, qemu_img_create, Timeout
@ -224,25 +225,6 @@ def inject_test_case(klass, suffix, method, *args, **kwargs):
setattr(klass, 'test_' + method + suffix, lambda self: mc(self))
for cmb in list(itertools.product((True, False), repeat=5)):
name = ('_' if cmb[0] else '_not_') + 'persistent_'
name += ('_' if cmb[1] else '_not_') + 'migbitmap_'
name += '_online' if cmb[2] else '_offline'
name += '_shared' if cmb[3] else '_nonshared'
if cmb[4]:
name += '__pre_shutdown'
inject_test_case(TestDirtyBitmapMigration, name, 'do_test_migration',
*list(cmb))
for cmb in list(itertools.product((True, False), repeat=2)):
name = ('_' if cmb[0] else '_not_') + 'persistent_'
name += ('_' if cmb[1] else '_not_') + 'migbitmap'
inject_test_case(TestDirtyBitmapMigration, name,
'do_test_migration_resume_source', *list(cmb))
class TestDirtyBitmapBackingMigration(iotests.QMPTestCase):
def setUp(self):
qemu_img_create('-f', iotests.imgfmt, base_a, size)
@ -304,6 +286,30 @@ class TestDirtyBitmapBackingMigration(iotests.QMPTestCase):
self.assert_qmp(result, 'return', {})
def main() -> None:
for cmb in list(itertools.product((True, False), repeat=5)):
name = ('_' if cmb[0] else '_not_') + 'persistent_'
name += ('_' if cmb[1] else '_not_') + 'migbitmap_'
name += '_online' if cmb[2] else '_offline'
name += '_shared' if cmb[3] else '_nonshared'
if cmb[4]:
name += '__pre_shutdown'
inject_test_case(TestDirtyBitmapMigration, name, 'do_test_migration',
*list(cmb))
for cmb in list(itertools.product((True, False), repeat=2)):
name = ('_' if cmb[0] else '_not_') + 'persistent_'
name += ('_' if cmb[1] else '_not_') + 'migbitmap'
inject_test_case(TestDirtyBitmapMigration, name,
'do_test_migration_resume_source', *list(cmb))
iotests.main(
supported_fmts=['qcow2'],
supported_protocols=['file']
)
if __name__ == '__main__':
iotests.main(supported_fmts=['qcow2'],
supported_protocols=['file'])
main()

12
tests/qemu-iotests/tests/mirror-top-perms
View File

@ -20,13 +20,13 @@
#
import os
from qemu import qmp
from qemu.machine import machine
import iotests
from iotests import qemu_img
# Import qemu after iotests.py has amended sys.path
# pylint: disable=wrong-import-order
import qemu
image_size = 1 * 1024 * 1024
source = os.path.join(iotests.test_dir, 'source.img')
@ -47,7 +47,7 @@ class TestMirrorTopPerms(iotests.QMPTestCase):
def tearDown(self):
try:
self.vm.shutdown()
except qemu.machine.machine.AbnormalShutdown:
except machine.AbnormalShutdown:
pass
if self.vm_b is not None:
@ -102,7 +102,7 @@ class TestMirrorTopPerms(iotests.QMPTestCase):
self.vm_b.launch()
print('ERROR: VM B launched successfully, this should not have '
'happened')
except qemu.qmp.QMPConnectError:
except qmp.QMPConnectError:
assert 'Is another process using the image' in self.vm_b.get_log()
result = self.vm.qmp('block-job-cancel',