1 | The following changes since commit b98a66201dbc7cf3b962f4bb260f66100cc75578: | 1 | The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e: |
---|---|---|---|
2 | 2 | ||
3 | Merge remote-tracking branch 'remotes/palmer/tags/riscv-for-master-4.0-rc0-2' into staging (2019-03-19 12:55:02 +0000) | 3 | Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20200430' into staging (2020-04-30 14:00:36 +0100) |
4 | 4 | ||
5 | are available in the Git repository at: | 5 | are available in the Git repository at: |
6 | 6 | ||
7 | git://repo.or.cz/qemu/kevin.git tags/for-upstream | 7 | git://repo.or.cz/qemu/kevin.git tags/for-upstream |
8 | 8 | ||
9 | for you to fetch changes up to 59fba0aaee7438002d9803a86c888f21a1070cc8: | 9 | for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809: |
10 | 10 | ||
11 | qemu-iotests: Treat custom TEST_DIR in 051 (2019-03-19 15:51:31 +0100) | 11 | qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200) |
12 | 12 | ||
13 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
14 | Block layer patches: | 14 | Block layer patches: |
15 | 15 | ||
16 | - mirror: Fix early return from drain (could cause deadlocks) | 16 | - Fix resize (extending) of short overlays |
17 | - vmdk: Fixed probing for version 3 images | 17 | - nvme: introduce PMR support from NVMe 1.4 spec |
18 | - vl: Fix to create migration object before block backends again (fixes | 18 | - qemu-storage-daemon: Fix non-string --object properties |
19 | segfault for block drivers that set migration blockers) | ||
20 | - Several minor fixes, documentation and test case improvements | ||
21 | 19 | ||
22 | ---------------------------------------------------------------- | 20 | ---------------------------------------------------------------- |
23 | Alberto Garcia (1): | 21 | Alberto Garcia (1): |
24 | block: Make bdrv_{copy_on_read,crypto_luks,replication} static | 22 | qcow2: Add incompatibility note between backing files and raw external data files |
25 | 23 | ||
26 | Kevin Wolf (3): | 24 | Andrzej Jakowski (1): |
27 | qcow2: Fix data file error condition in qcow2_co_create() | 25 | nvme: introduce PMR support from NVMe 1.4 spec |
28 | block: Silence Coverity in bdrv_drop_intermediate() | ||
29 | qemu-iotests: Fix 232 for non-qcow2 | ||
30 | 26 | ||
31 | Lukáš Doktor (1): | 27 | Kevin Wolf (12): |
32 | qemu-iotests: Treat custom TEST_DIR in 051 | 28 | block: Add flags to BlockDriver.bdrv_co_truncate() |
29 | block: Add flags to bdrv(_co)_truncate() | ||
30 | block-backend: Add flags to blk_truncate() | ||
31 | qcow2: Support BDRV_REQ_ZERO_WRITE for truncate | ||
32 | raw-format: Support BDRV_REQ_ZERO_WRITE for truncate | ||
33 | file-posix: Support BDRV_REQ_ZERO_WRITE for truncate | ||
34 | block: truncate: Don't make backing file data visible | ||
35 | iotests: Filter testfiles out in filter_img_info() | ||
36 | iotests: Test committing to short backing file | ||
37 | qcow2: Forward ZERO_WRITE flag for full preallocation | ||
38 | qom: Factor out user_creatable_add_dict() | ||
39 | qemu-storage-daemon: Fix non-string --object properties | ||
33 | 40 | ||
34 | Markus Armbruster (1): | 41 | Paolo Bonzini (1): |
35 | vl: Fix to create migration object before block backends again | 42 | qemu-iotests: allow qcow2 external discarded clusters to contain stale data |
36 | 43 | ||
37 | Max Reitz (1): | 44 | docs/interop/qcow2.txt | 3 + |
38 | blockdev: Check @replaces in blockdev_mirror_common | 45 | hw/block/nvme.h | 2 + |
46 | include/block/block.h | 5 +- | ||
47 | include/block/block_int.h | 10 +- | ||
48 | include/block/nvme.h | 172 ++++++++++++++++++++++++++ | ||
49 | include/qom/object_interfaces.h | 16 +++ | ||
50 | include/sysemu/block-backend.h | 2 +- | ||
51 | block.c | 3 +- | ||
52 | block/block-backend.c | 4 +- | ||
53 | block/commit.c | 4 +- | ||
54 | block/crypto.c | 7 +- | ||
55 | block/file-posix.c | 6 +- | ||
56 | block/file-win32.c | 2 +- | ||
57 | block/gluster.c | 1 + | ||
58 | block/io.c | 43 ++++++- | ||
59 | block/iscsi.c | 2 +- | ||
60 | block/mirror.c | 2 +- | ||
61 | block/nfs.c | 3 +- | ||
62 | block/parallels.c | 6 +- | ||
63 | block/qcow.c | 4 +- | ||
64 | block/qcow2-cluster.c | 2 +- | ||
65 | block/qcow2-refcount.c | 2 +- | ||
66 | block/qcow2.c | 73 +++++++++-- | ||
67 | block/qed.c | 3 +- | ||
68 | block/raw-format.c | 6 +- | ||
69 | block/rbd.c | 1 + | ||
70 | block/sheepdog.c | 4 +- | ||
71 | block/ssh.c | 2 +- | ||
72 | block/vdi.c | 2 +- | ||
73 | block/vhdx-log.c | 2 +- | ||
74 | block/vhdx.c | 6 +- | ||
75 | block/vmdk.c | 8 +- | ||
76 | block/vpc.c | 2 +- | ||
77 | blockdev.c | 2 +- | ||
78 | hw/block/nvme.c | 109 ++++++++++++++++ | ||
79 | qemu-img.c | 2 +- | ||
80 | qemu-io-cmds.c | 2 +- | ||
81 | qemu-storage-daemon.c | 4 +- | ||
82 | qom/object_interfaces.c | 31 +++++ | ||
83 | qom/qom-qmp-cmds.c | 24 +--- | ||
84 | tests/test-block-iothread.c | 9 +- | ||
85 | tests/qemu-iotests/iotests.py | 5 +- | ||
86 | hw/block/Makefile.objs | 2 +- | ||
87 | hw/block/trace-events | 4 + | ||
88 | tests/qemu-iotests/244 | 10 +- | ||
89 | tests/qemu-iotests/244.out | 9 +- | ||
90 | tests/qemu-iotests/274 | 155 +++++++++++++++++++++++ | ||
91 | tests/qemu-iotests/274.out | 268 ++++++++++++++++++++++++++++++++++++++++ | ||
92 | tests/qemu-iotests/group | 1 + | ||
93 | 49 files changed, 951 insertions(+), 96 deletions(-) | ||
94 | create mode 100755 tests/qemu-iotests/274 | ||
95 | create mode 100644 tests/qemu-iotests/274.out | ||
39 | 96 | ||
40 | Sam Eiderman (1): | ||
41 | vmdk: Support version=3 in VMDK descriptor files | ||
42 | 97 | ||
43 | Sergio Lopez (2): | ||
44 | mirror: Confirm we're quiesced only if the job is paused or cancelled | ||
45 | iotests: 153: Wait for an answer to QMP commands | ||
46 | |||
47 | Vladimir Sementsov-Ogievskiy (2): | ||
48 | qapi: fix block-latency-histogram-set description and examples | ||
49 | blockjob: fix user pause in block_job_error_action | ||
50 | |||
51 | qapi/block-core.json | 10 +++--- | ||
52 | block.c | 7 ++-- | ||
53 | block/copy-on-read.c | 2 +- | ||
54 | block/crypto.c | 2 +- | ||
55 | block/mirror.c | 16 ++++++++++ | ||
56 | block/qcow2.c | 2 +- | ||
57 | block/replication.c | 2 +- | ||
58 | block/vmdk.c | 6 ++-- | ||
59 | blockdev.c | 55 +++++++++++++++++++------------- | ||
60 | blockjob.c | 8 +++-- | ||
61 | vl.c | 15 +++++---- | ||
62 | tests/qemu-iotests/051 | 2 +- | ||
63 | tests/qemu-iotests/153 | 12 +++---- | ||
64 | tests/qemu-iotests/153.out | 6 ++++ | ||
65 | tests/qemu-iotests/232 | 30 ------------------ | ||
66 | tests/qemu-iotests/232.out | 20 ------------ | ||
67 | tests/qemu-iotests/247 | 79 ++++++++++++++++++++++++++++++++++++++++++++++ | ||
68 | tests/qemu-iotests/247.out | 22 +++++++++++++ | ||
69 | tests/qemu-iotests/group | 1 + | ||
70 | 19 files changed, 193 insertions(+), 104 deletions(-) | ||
71 | create mode 100755 tests/qemu-iotests/247 | ||
72 | create mode 100644 tests/qemu-iotests/247.out | ||
73 | diff view generated by jsdifflib |
1 | From: Alberto Garcia <berto@igalia.com> | 1 | From: Alberto Garcia <berto@igalia.com> |
---|---|---|---|
2 | 2 | ||
3 | Backing files and raw external data files are mutually exclusive. | ||
4 | The documentation of the raw external data bit (in autoclear_features) | ||
5 | already indicates that, but we should also mention it on the other | ||
6 | side. | ||
7 | |||
8 | Suggested-by: Eric Blake <eblake@redhat.com> | ||
3 | Signed-off-by: Alberto Garcia <berto@igalia.com> | 9 | Signed-off-by: Alberto Garcia <berto@igalia.com> |
10 | Message-Id: <20200410121816.8334-1-berto@igalia.com> | ||
11 | Reviewed-by: Eric Blake <eblake@redhat.com> | ||
4 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 12 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
5 | --- | 13 | --- |
6 | block/copy-on-read.c | 2 +- | 14 | docs/interop/qcow2.txt | 3 +++ |
7 | block/crypto.c | 2 +- | 15 | 1 file changed, 3 insertions(+) |
8 | block/replication.c | 2 +- | ||
9 | 3 files changed, 3 insertions(+), 3 deletions(-) | ||
10 | 16 | ||
11 | diff --git a/block/copy-on-read.c b/block/copy-on-read.c | 17 | diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt |
12 | index XXXXXXX..XXXXXXX 100644 | 18 | index XXXXXXX..XXXXXXX 100644 |
13 | --- a/block/copy-on-read.c | 19 | --- a/docs/interop/qcow2.txt |
14 | +++ b/block/copy-on-read.c | 20 | +++ b/docs/interop/qcow2.txt |
15 | @@ -XXX,XX +XXX,XX @@ static bool cor_recurse_is_first_non_filter(BlockDriverState *bs, | 21 | @@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header: |
16 | } | 22 | is stored (NB: The string is not null terminated). 0 if the |
17 | 23 | image doesn't have a backing file. | |
18 | 24 | ||
19 | -BlockDriver bdrv_copy_on_read = { | 25 | + Note: backing files are incompatible with raw external data |
20 | +static BlockDriver bdrv_copy_on_read = { | 26 | + files (auto-clear feature bit 1). |
21 | .format_name = "copy-on-read", | 27 | + |
22 | 28 | 16 - 19: backing_file_size | |
23 | .bdrv_open = cor_open, | 29 | Length of the backing file name in bytes. Must not be |
24 | diff --git a/block/crypto.c b/block/crypto.c | 30 | longer than 1023 bytes. Undefined if the image doesn't have |
25 | index XXXXXXX..XXXXXXX 100644 | ||
26 | --- a/block/crypto.c | ||
27 | +++ b/block/crypto.c | ||
28 | @@ -XXX,XX +XXX,XX @@ static const char *const block_crypto_strong_runtime_opts[] = { | ||
29 | NULL | ||
30 | }; | ||
31 | |||
32 | -BlockDriver bdrv_crypto_luks = { | ||
33 | +static BlockDriver bdrv_crypto_luks = { | ||
34 | .format_name = "luks", | ||
35 | .instance_size = sizeof(BlockCrypto), | ||
36 | .bdrv_probe = block_crypto_probe_luks, | ||
37 | diff --git a/block/replication.c b/block/replication.c | ||
38 | index XXXXXXX..XXXXXXX 100644 | ||
39 | --- a/block/replication.c | ||
40 | +++ b/block/replication.c | ||
41 | @@ -XXX,XX +XXX,XX @@ static const char *const replication_strong_runtime_opts[] = { | ||
42 | NULL | ||
43 | }; | ||
44 | |||
45 | -BlockDriver bdrv_replication = { | ||
46 | +static BlockDriver bdrv_replication = { | ||
47 | .format_name = "replication", | ||
48 | .instance_size = sizeof(BDRVReplicationState), | ||
49 | |||
50 | -- | 31 | -- |
51 | 2.20.1 | 32 | 2.25.3 |
52 | 33 | ||
53 | 34 | diff view generated by jsdifflib |
New patch | |||
---|---|---|---|
1 | From: Paolo Bonzini <pbonzini@redhat.com> | ||
1 | 2 | ||
3 | Test 244 checks the expected behavior of qcow2 external data files | ||
4 | with respect to zero and discarded clusters. Filesystems however | ||
5 | are free to ignore discard requests, and this seems to be the | ||
6 | case for overlayfs. Relax the tests to skip checks on the | ||
7 | external data file for discarded areas, which implies not using | ||
8 | qemu-img compare in the data_file_raw=on case. | ||
9 | |||
10 | This fixes docker tests on RHEL8. | ||
11 | |||
12 | Cc: Kevin Wolf <kwolf@redhat.com> | ||
13 | Cc: qemu-block@nongnu.org | ||
14 | Signed-off-by: Paolo Bonzini <pbonzini@redhat.com> | ||
15 | Message-Id: <20200409191006.24429-1-pbonzini@redhat.com> | ||
16 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
17 | --- | ||
18 | tests/qemu-iotests/244 | 10 ++++++++-- | ||
19 | tests/qemu-iotests/244.out | 9 ++++++--- | ||
20 | 2 files changed, 14 insertions(+), 5 deletions(-) | ||
21 | |||
22 | diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244 | ||
23 | index XXXXXXX..XXXXXXX 100755 | ||
24 | --- a/tests/qemu-iotests/244 | ||
25 | +++ b/tests/qemu-iotests/244 | ||
26 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \ | ||
27 | echo | ||
28 | $QEMU_IO -c 'read -P 0 0 1M' \ | ||
29 | -c 'read -P 0x11 1M 1M' \ | ||
30 | - -c 'read -P 0 2M 2M' \ | ||
31 | -c 'read -P 0x11 4M 1M' \ | ||
32 | -c 'read -P 0 5M 1M' \ | ||
33 | -f raw "$TEST_IMG.data" | | ||
34 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \ | ||
35 | -f $IMGFMT "$TEST_IMG" | | ||
36 | _filter_qemu_io | ||
37 | |||
38 | +# Discarded clusters are only marked as such in the qcow2 metadata, but | ||
39 | +# they can contain stale data in the external data file. Instead, zero | ||
40 | +# clusters must be zeroed in the external data file too. | ||
41 | echo | ||
42 | -$QEMU_IMG compare "$TEST_IMG" "$TEST_IMG.data" | ||
43 | +$QEMU_IO -c 'read -P 0 0 1M' \ | ||
44 | + -c 'read -P 0x11 1M 1M' \ | ||
45 | + -c 'read -P 0 3M 3M' \ | ||
46 | + -f raw "$TEST_IMG".data | | ||
47 | + _filter_qemu_io | ||
48 | |||
49 | echo -n "qcow2 file size after I/O: " | ||
50 | du -b $TEST_IMG | cut -f1 | ||
51 | diff --git a/tests/qemu-iotests/244.out b/tests/qemu-iotests/244.out | ||
52 | index XXXXXXX..XXXXXXX 100644 | ||
53 | --- a/tests/qemu-iotests/244.out | ||
54 | +++ b/tests/qemu-iotests/244.out | ||
55 | @@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0 | ||
56 | 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
57 | read 1048576/1048576 bytes at offset 1048576 | ||
58 | 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
59 | -read 2097152/2097152 bytes at offset 2097152 | ||
60 | -2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
61 | read 1048576/1048576 bytes at offset 4194304 | ||
62 | 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
63 | read 1048576/1048576 bytes at offset 5242880 | ||
64 | @@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 1048576 | ||
65 | read 4194304/4194304 bytes at offset 2097152 | ||
66 | 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
67 | |||
68 | -Images are identical. | ||
69 | +read 1048576/1048576 bytes at offset 0 | ||
70 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
71 | +read 1048576/1048576 bytes at offset 1048576 | ||
72 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
73 | +read 3145728/3145728 bytes at offset 3145728 | ||
74 | +3 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
75 | qcow2 file size after I/O: 327680 | ||
76 | |||
77 | === bdrv_co_block_status test for file and offset=0 === | ||
78 | -- | ||
79 | 2.25.3 | ||
80 | |||
81 | diff view generated by jsdifflib |
New patch | |||
---|---|---|---|
1 | 1 | This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate() | |
2 | driver callbacks, and a supported_truncate_flags field in | ||
3 | BlockDriverState that allows drivers to advertise support for request | ||
4 | flags in the context of truncate. | ||
5 | |||
6 | For now, we always pass 0 and no drivers declare support for any flag. | ||
7 | |||
8 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
9 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
10 | Reviewed-by: Alberto Garcia <berto@igalia.com> | ||
11 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
12 | Message-Id: <20200424125448.63318-2-kwolf@redhat.com> | ||
13 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
14 | --- | ||
15 | include/block/block_int.h | 10 +++++++++- | ||
16 | block/crypto.c | 3 ++- | ||
17 | block/file-posix.c | 2 +- | ||
18 | block/file-win32.c | 2 +- | ||
19 | block/gluster.c | 1 + | ||
20 | block/io.c | 8 +++++++- | ||
21 | block/iscsi.c | 2 +- | ||
22 | block/nfs.c | 3 ++- | ||
23 | block/qcow2.c | 2 +- | ||
24 | block/qed.c | 1 + | ||
25 | block/raw-format.c | 2 +- | ||
26 | block/rbd.c | 1 + | ||
27 | block/sheepdog.c | 4 ++-- | ||
28 | block/ssh.c | 2 +- | ||
29 | tests/test-block-iothread.c | 3 ++- | ||
30 | 15 files changed, 33 insertions(+), 13 deletions(-) | ||
31 | |||
32 | diff --git a/include/block/block_int.h b/include/block/block_int.h | ||
33 | index XXXXXXX..XXXXXXX 100644 | ||
34 | --- a/include/block/block_int.h | ||
35 | +++ b/include/block/block_int.h | ||
36 | @@ -XXX,XX +XXX,XX @@ struct BlockDriver { | ||
37 | */ | ||
38 | int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset, | ||
39 | bool exact, PreallocMode prealloc, | ||
40 | - Error **errp); | ||
41 | + BdrvRequestFlags flags, Error **errp); | ||
42 | |||
43 | int64_t (*bdrv_getlength)(BlockDriverState *bs); | ||
44 | bool has_variable_length; | ||
45 | @@ -XXX,XX +XXX,XX @@ struct BlockDriverState { | ||
46 | /* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA, | ||
47 | * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) */ | ||
48 | unsigned int supported_zero_flags; | ||
49 | + /* | ||
50 | + * Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE). | ||
51 | + * | ||
52 | + * If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure | ||
53 | + * that any added space reads as all zeros. If this can't be guaranteed, | ||
54 | + * the operation must fail. | ||
55 | + */ | ||
56 | + unsigned int supported_truncate_flags; | ||
57 | |||
58 | /* the following member gives a name to every node on the bs graph. */ | ||
59 | char node_name[32]; | ||
60 | diff --git a/block/crypto.c b/block/crypto.c | ||
61 | index XXXXXXX..XXXXXXX 100644 | ||
62 | --- a/block/crypto.c | ||
63 | +++ b/block/crypto.c | ||
64 | @@ -XXX,XX +XXX,XX @@ static int block_crypto_co_create_generic(BlockDriverState *bs, | ||
65 | |||
66 | static int coroutine_fn | ||
67 | block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact, | ||
68 | - PreallocMode prealloc, Error **errp) | ||
69 | + PreallocMode prealloc, BdrvRequestFlags flags, | ||
70 | + Error **errp) | ||
71 | { | ||
72 | BlockCrypto *crypto = bs->opaque; | ||
73 | uint64_t payload_offset = | ||
74 | diff --git a/block/file-posix.c b/block/file-posix.c | ||
75 | index XXXXXXX..XXXXXXX 100644 | ||
76 | --- a/block/file-posix.c | ||
77 | +++ b/block/file-posix.c | ||
78 | @@ -XXX,XX +XXX,XX @@ raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset, | ||
79 | |||
80 | static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, | ||
81 | bool exact, PreallocMode prealloc, | ||
82 | - Error **errp) | ||
83 | + BdrvRequestFlags flags, Error **errp) | ||
84 | { | ||
85 | BDRVRawState *s = bs->opaque; | ||
86 | struct stat st; | ||
87 | diff --git a/block/file-win32.c b/block/file-win32.c | ||
88 | index XXXXXXX..XXXXXXX 100644 | ||
89 | --- a/block/file-win32.c | ||
90 | +++ b/block/file-win32.c | ||
91 | @@ -XXX,XX +XXX,XX @@ static void raw_close(BlockDriverState *bs) | ||
92 | |||
93 | static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, | ||
94 | bool exact, PreallocMode prealloc, | ||
95 | - Error **errp) | ||
96 | + BdrvRequestFlags flags, Error **errp) | ||
97 | { | ||
98 | BDRVRawState *s = bs->opaque; | ||
99 | LONG low, high; | ||
100 | diff --git a/block/gluster.c b/block/gluster.c | ||
101 | index XXXXXXX..XXXXXXX 100644 | ||
102 | --- a/block/gluster.c | ||
103 | +++ b/block/gluster.c | ||
104 | @@ -XXX,XX +XXX,XX @@ static coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs, | ||
105 | int64_t offset, | ||
106 | bool exact, | ||
107 | PreallocMode prealloc, | ||
108 | + BdrvRequestFlags flags, | ||
109 | Error **errp) | ||
110 | { | ||
111 | BDRVGlusterState *s = bs->opaque; | ||
112 | diff --git a/block/io.c b/block/io.c | ||
113 | index XXXXXXX..XXXXXXX 100644 | ||
114 | --- a/block/io.c | ||
115 | +++ b/block/io.c | ||
116 | @@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, | ||
117 | BlockDriverState *bs = child->bs; | ||
118 | BlockDriver *drv = bs->drv; | ||
119 | BdrvTrackedRequest req; | ||
120 | + BdrvRequestFlags flags = 0; | ||
121 | int64_t old_size, new_bytes; | ||
122 | int ret; | ||
123 | |||
124 | @@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, | ||
125 | } | ||
126 | |||
127 | if (drv->bdrv_co_truncate) { | ||
128 | - ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, errp); | ||
129 | + if (flags & ~bs->supported_truncate_flags) { | ||
130 | + error_setg(errp, "Block driver does not support requested flags"); | ||
131 | + ret = -ENOTSUP; | ||
132 | + goto out; | ||
133 | + } | ||
134 | + ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp); | ||
135 | } else if (bs->file && drv->is_filter) { | ||
136 | ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp); | ||
137 | } else { | ||
138 | diff --git a/block/iscsi.c b/block/iscsi.c | ||
139 | index XXXXXXX..XXXXXXX 100644 | ||
140 | --- a/block/iscsi.c | ||
141 | +++ b/block/iscsi.c | ||
142 | @@ -XXX,XX +XXX,XX @@ static void iscsi_reopen_commit(BDRVReopenState *reopen_state) | ||
143 | |||
144 | static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset, | ||
145 | bool exact, PreallocMode prealloc, | ||
146 | - Error **errp) | ||
147 | + BdrvRequestFlags flags, Error **errp) | ||
148 | { | ||
149 | IscsiLun *iscsilun = bs->opaque; | ||
150 | int64_t cur_length; | ||
151 | diff --git a/block/nfs.c b/block/nfs.c | ||
152 | index XXXXXXX..XXXXXXX 100644 | ||
153 | --- a/block/nfs.c | ||
154 | +++ b/block/nfs.c | ||
155 | @@ -XXX,XX +XXX,XX @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs) | ||
156 | |||
157 | static int coroutine_fn | ||
158 | nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact, | ||
159 | - PreallocMode prealloc, Error **errp) | ||
160 | + PreallocMode prealloc, BdrvRequestFlags flags, | ||
161 | + Error **errp) | ||
162 | { | ||
163 | NFSClient *client = bs->opaque; | ||
164 | int ret; | ||
165 | diff --git a/block/qcow2.c b/block/qcow2.c | ||
166 | index XXXXXXX..XXXXXXX 100644 | ||
167 | --- a/block/qcow2.c | ||
168 | +++ b/block/qcow2.c | ||
169 | @@ -XXX,XX +XXX,XX @@ fail: | ||
170 | |||
171 | static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, | ||
172 | bool exact, PreallocMode prealloc, | ||
173 | - Error **errp) | ||
174 | + BdrvRequestFlags flags, Error **errp) | ||
175 | { | ||
176 | BDRVQcow2State *s = bs->opaque; | ||
177 | uint64_t old_length; | ||
178 | diff --git a/block/qed.c b/block/qed.c | ||
179 | index XXXXXXX..XXXXXXX 100644 | ||
180 | --- a/block/qed.c | ||
181 | +++ b/block/qed.c | ||
182 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_truncate(BlockDriverState *bs, | ||
183 | int64_t offset, | ||
184 | bool exact, | ||
185 | PreallocMode prealloc, | ||
186 | + BdrvRequestFlags flags, | ||
187 | Error **errp) | ||
188 | { | ||
189 | BDRVQEDState *s = bs->opaque; | ||
190 | diff --git a/block/raw-format.c b/block/raw-format.c | ||
191 | index XXXXXXX..XXXXXXX 100644 | ||
192 | --- a/block/raw-format.c | ||
193 | +++ b/block/raw-format.c | ||
194 | @@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp) | ||
195 | |||
196 | static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, | ||
197 | bool exact, PreallocMode prealloc, | ||
198 | - Error **errp) | ||
199 | + BdrvRequestFlags flags, Error **errp) | ||
200 | { | ||
201 | BDRVRawState *s = bs->opaque; | ||
202 | |||
203 | diff --git a/block/rbd.c b/block/rbd.c | ||
204 | index XXXXXXX..XXXXXXX 100644 | ||
205 | --- a/block/rbd.c | ||
206 | +++ b/block/rbd.c | ||
207 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs, | ||
208 | int64_t offset, | ||
209 | bool exact, | ||
210 | PreallocMode prealloc, | ||
211 | + BdrvRequestFlags flags, | ||
212 | Error **errp) | ||
213 | { | ||
214 | int r; | ||
215 | diff --git a/block/sheepdog.c b/block/sheepdog.c | ||
216 | index XXXXXXX..XXXXXXX 100644 | ||
217 | --- a/block/sheepdog.c | ||
218 | +++ b/block/sheepdog.c | ||
219 | @@ -XXX,XX +XXX,XX @@ static int64_t sd_getlength(BlockDriverState *bs) | ||
220 | |||
221 | static int coroutine_fn sd_co_truncate(BlockDriverState *bs, int64_t offset, | ||
222 | bool exact, PreallocMode prealloc, | ||
223 | - Error **errp) | ||
224 | + BdrvRequestFlags flags, Error **errp) | ||
225 | { | ||
226 | BDRVSheepdogState *s = bs->opaque; | ||
227 | int ret, fd; | ||
228 | @@ -XXX,XX +XXX,XX @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num, | ||
229 | |||
230 | assert(!flags); | ||
231 | if (offset > s->inode.vdi_size) { | ||
232 | - ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, NULL); | ||
233 | + ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, 0, NULL); | ||
234 | if (ret < 0) { | ||
235 | return ret; | ||
236 | } | ||
237 | diff --git a/block/ssh.c b/block/ssh.c | ||
238 | index XXXXXXX..XXXXXXX 100644 | ||
239 | --- a/block/ssh.c | ||
240 | +++ b/block/ssh.c | ||
241 | @@ -XXX,XX +XXX,XX @@ static int64_t ssh_getlength(BlockDriverState *bs) | ||
242 | |||
243 | static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset, | ||
244 | bool exact, PreallocMode prealloc, | ||
245 | - Error **errp) | ||
246 | + BdrvRequestFlags flags, Error **errp) | ||
247 | { | ||
248 | BDRVSSHState *s = bs->opaque; | ||
249 | |||
250 | diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c | ||
251 | index XXXXXXX..XXXXXXX 100644 | ||
252 | --- a/tests/test-block-iothread.c | ||
253 | +++ b/tests/test-block-iothread.c | ||
254 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs, | ||
255 | |||
256 | static int coroutine_fn | ||
257 | bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact, | ||
258 | - PreallocMode prealloc, Error **errp) | ||
259 | + PreallocMode prealloc, BdrvRequestFlags flags, | ||
260 | + Error **errp) | ||
261 | { | ||
262 | return 0; | ||
263 | } | ||
264 | -- | ||
265 | 2.25.3 | ||
266 | |||
267 | diff view generated by jsdifflib |
1 | From: Sam Eiderman <shmuel.eiderman@oracle.com> | 1 | Now that block drivers can support flags for .bdrv_co_truncate, expose |
---|---|---|---|
2 | the parameter in the node level interfaces bdrv_co_truncate() and | ||
3 | bdrv_truncate(). | ||
2 | 4 | ||
3 | Commit 509d39aa22909c0ed1aabf896865f19c81fb38a1 added support for read | 5 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
4 | only VMDKs of version 3. | 6 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> |
5 | 7 | Reviewed-by: Alberto Garcia <berto@igalia.com> | |
6 | This commit fixes the probe function to correctly handle descriptors of | 8 | Reviewed-by: Max Reitz <mreitz@redhat.com> |
7 | version 3. | 9 | Message-Id: <20200424125448.63318-3-kwolf@redhat.com> |
8 | |||
9 | This commit has two effects: | ||
10 | 1. We no longer need to supply '-f vmdk' when pointing to descriptor | ||
11 | files of version 3 in qemu/qemu-img command line arguments. | ||
12 | 2. This fixes the scenario where a VMDK points to a parent version 3 | ||
13 | descriptor file which is being probed as "raw" instead of "vmdk". | ||
14 | |||
15 | Reviewed-by: Arbel Moshe <arbel.moshe@oracle.com> | ||
16 | Reviewed-by: Mark Kanda <mark.kanda@oracle.com> | ||
17 | Signed-off-by: Shmuel Eiderman <shmuel.eiderman@oracle.com> | ||
18 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 10 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
19 | --- | 11 | --- |
20 | block/vmdk.c | 6 ++++-- | 12 | include/block/block.h | 5 +++-- |
21 | 1 file changed, 4 insertions(+), 2 deletions(-) | 13 | block/block-backend.c | 2 +- |
14 | block/crypto.c | 2 +- | ||
15 | block/io.c | 12 +++++++----- | ||
16 | block/parallels.c | 6 +++--- | ||
17 | block/qcow.c | 4 ++-- | ||
18 | block/qcow2-refcount.c | 2 +- | ||
19 | block/qcow2.c | 15 +++++++++------ | ||
20 | block/raw-format.c | 2 +- | ||
21 | block/vhdx-log.c | 2 +- | ||
22 | block/vhdx.c | 2 +- | ||
23 | block/vmdk.c | 2 +- | ||
24 | tests/test-block-iothread.c | 6 +++--- | ||
25 | 13 files changed, 34 insertions(+), 28 deletions(-) | ||
22 | 26 | ||
27 | diff --git a/include/block/block.h b/include/block/block.h | ||
28 | index XXXXXXX..XXXXXXX 100644 | ||
29 | --- a/include/block/block.h | ||
30 | +++ b/include/block/block.h | ||
31 | @@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, | ||
32 | void bdrv_refresh_filename(BlockDriverState *bs); | ||
33 | |||
34 | int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, | ||
35 | - PreallocMode prealloc, Error **errp); | ||
36 | + PreallocMode prealloc, BdrvRequestFlags flags, | ||
37 | + Error **errp); | ||
38 | int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact, | ||
39 | - PreallocMode prealloc, Error **errp); | ||
40 | + PreallocMode prealloc, BdrvRequestFlags flags, Error **errp); | ||
41 | |||
42 | int64_t bdrv_nb_sectors(BlockDriverState *bs); | ||
43 | int64_t bdrv_getlength(BlockDriverState *bs); | ||
44 | diff --git a/block/block-backend.c b/block/block-backend.c | ||
45 | index XXXXXXX..XXXXXXX 100644 | ||
46 | --- a/block/block-backend.c | ||
47 | +++ b/block/block-backend.c | ||
48 | @@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact, | ||
49 | return -ENOMEDIUM; | ||
50 | } | ||
51 | |||
52 | - return bdrv_truncate(blk->root, offset, exact, prealloc, errp); | ||
53 | + return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp); | ||
54 | } | ||
55 | |||
56 | int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf, | ||
57 | diff --git a/block/crypto.c b/block/crypto.c | ||
58 | index XXXXXXX..XXXXXXX 100644 | ||
59 | --- a/block/crypto.c | ||
60 | +++ b/block/crypto.c | ||
61 | @@ -XXX,XX +XXX,XX @@ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact, | ||
62 | |||
63 | offset += payload_offset; | ||
64 | |||
65 | - return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp); | ||
66 | + return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp); | ||
67 | } | ||
68 | |||
69 | static void block_crypto_close(BlockDriverState *bs) | ||
70 | diff --git a/block/io.c b/block/io.c | ||
71 | index XXXXXXX..XXXXXXX 100644 | ||
72 | --- a/block/io.c | ||
73 | +++ b/block/io.c | ||
74 | @@ -XXX,XX +XXX,XX @@ static void bdrv_parent_cb_resize(BlockDriverState *bs) | ||
75 | * 'offset' bytes in length. | ||
76 | */ | ||
77 | int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, | ||
78 | - PreallocMode prealloc, Error **errp) | ||
79 | + PreallocMode prealloc, BdrvRequestFlags flags, | ||
80 | + Error **errp) | ||
81 | { | ||
82 | BlockDriverState *bs = child->bs; | ||
83 | BlockDriver *drv = bs->drv; | ||
84 | BdrvTrackedRequest req; | ||
85 | - BdrvRequestFlags flags = 0; | ||
86 | int64_t old_size, new_bytes; | ||
87 | int ret; | ||
88 | |||
89 | @@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, | ||
90 | } | ||
91 | ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp); | ||
92 | } else if (bs->file && drv->is_filter) { | ||
93 | - ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp); | ||
94 | + ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp); | ||
95 | } else { | ||
96 | error_setg(errp, "Image format driver does not support resize"); | ||
97 | ret = -ENOTSUP; | ||
98 | @@ -XXX,XX +XXX,XX @@ typedef struct TruncateCo { | ||
99 | int64_t offset; | ||
100 | bool exact; | ||
101 | PreallocMode prealloc; | ||
102 | + BdrvRequestFlags flags; | ||
103 | Error **errp; | ||
104 | int ret; | ||
105 | } TruncateCo; | ||
106 | @@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_truncate_co_entry(void *opaque) | ||
107 | { | ||
108 | TruncateCo *tco = opaque; | ||
109 | tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->exact, | ||
110 | - tco->prealloc, tco->errp); | ||
111 | + tco->prealloc, tco->flags, tco->errp); | ||
112 | aio_wait_kick(); | ||
113 | } | ||
114 | |||
115 | int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact, | ||
116 | - PreallocMode prealloc, Error **errp) | ||
117 | + PreallocMode prealloc, BdrvRequestFlags flags, Error **errp) | ||
118 | { | ||
119 | Coroutine *co; | ||
120 | TruncateCo tco = { | ||
121 | @@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact, | ||
122 | .offset = offset, | ||
123 | .exact = exact, | ||
124 | .prealloc = prealloc, | ||
125 | + .flags = flags, | ||
126 | .errp = errp, | ||
127 | .ret = NOT_DONE, | ||
128 | }; | ||
129 | diff --git a/block/parallels.c b/block/parallels.c | ||
130 | index XXXXXXX..XXXXXXX 100644 | ||
131 | --- a/block/parallels.c | ||
132 | +++ b/block/parallels.c | ||
133 | @@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, | ||
134 | } else { | ||
135 | ret = bdrv_truncate(bs->file, | ||
136 | (s->data_end + space) << BDRV_SECTOR_BITS, | ||
137 | - false, PREALLOC_MODE_OFF, NULL); | ||
138 | + false, PREALLOC_MODE_OFF, 0, NULL); | ||
139 | } | ||
140 | if (ret < 0) { | ||
141 | return ret; | ||
142 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs, | ||
143 | * That means we have to pass exact=true. | ||
144 | */ | ||
145 | ret = bdrv_truncate(bs->file, res->image_end_offset, true, | ||
146 | - PREALLOC_MODE_OFF, &local_err); | ||
147 | + PREALLOC_MODE_OFF, 0, &local_err); | ||
148 | if (ret < 0) { | ||
149 | error_report_err(local_err); | ||
150 | res->check_errors++; | ||
151 | @@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs) | ||
152 | |||
153 | /* errors are ignored, so we might as well pass exact=true */ | ||
154 | bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS, true, | ||
155 | - PREALLOC_MODE_OFF, NULL); | ||
156 | + PREALLOC_MODE_OFF, 0, NULL); | ||
157 | } | ||
158 | |||
159 | g_free(s->bat_dirty_bmap); | ||
160 | diff --git a/block/qcow.c b/block/qcow.c | ||
161 | index XXXXXXX..XXXXXXX 100644 | ||
162 | --- a/block/qcow.c | ||
163 | +++ b/block/qcow.c | ||
164 | @@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs, | ||
165 | return -E2BIG; | ||
166 | } | ||
167 | ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size, | ||
168 | - false, PREALLOC_MODE_OFF, NULL); | ||
169 | + false, PREALLOC_MODE_OFF, 0, NULL); | ||
170 | if (ret < 0) { | ||
171 | return ret; | ||
172 | } | ||
173 | @@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs) | ||
174 | l1_length) < 0) | ||
175 | return -1; | ||
176 | ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false, | ||
177 | - PREALLOC_MODE_OFF, NULL); | ||
178 | + PREALLOC_MODE_OFF, 0, NULL); | ||
179 | if (ret < 0) | ||
180 | return ret; | ||
181 | |||
182 | diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c | ||
183 | index XXXXXXX..XXXXXXX 100644 | ||
184 | --- a/block/qcow2-refcount.c | ||
185 | +++ b/block/qcow2-refcount.c | ||
186 | @@ -XXX,XX +XXX,XX @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res, | ||
187 | } | ||
188 | |||
189 | ret = bdrv_truncate(bs->file, offset + s->cluster_size, false, | ||
190 | - PREALLOC_MODE_OFF, &local_err); | ||
191 | + PREALLOC_MODE_OFF, 0, &local_err); | ||
192 | if (ret < 0) { | ||
193 | error_report_err(local_err); | ||
194 | goto resize_fail; | ||
195 | diff --git a/block/qcow2.c b/block/qcow2.c | ||
196 | index XXXXXXX..XXXXXXX 100644 | ||
197 | --- a/block/qcow2.c | ||
198 | +++ b/block/qcow2.c | ||
199 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset, | ||
200 | mode = PREALLOC_MODE_OFF; | ||
201 | } | ||
202 | ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false, | ||
203 | - mode, errp); | ||
204 | + mode, 0, errp); | ||
205 | if (ret < 0) { | ||
206 | return ret; | ||
207 | } | ||
208 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, | ||
209 | * always fulfilled, so there is no need to pass it on.) | ||
210 | */ | ||
211 | bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size, | ||
212 | - false, PREALLOC_MODE_OFF, &local_err); | ||
213 | + false, PREALLOC_MODE_OFF, 0, &local_err); | ||
214 | if (local_err) { | ||
215 | warn_reportf_err(local_err, | ||
216 | "Failed to truncate the tail of the image: "); | ||
217 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, | ||
218 | * file should be resized to the exact target size, too, | ||
219 | * so we pass @exact here. | ||
220 | */ | ||
221 | - ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, errp); | ||
222 | + ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0, | ||
223 | + errp); | ||
224 | if (ret < 0) { | ||
225 | goto fail; | ||
226 | } | ||
227 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, | ||
228 | new_file_size = allocation_start + | ||
229 | nb_new_data_clusters * s->cluster_size; | ||
230 | /* Image file grows, so @exact does not matter */ | ||
231 | - ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, errp); | ||
232 | + ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0, | ||
233 | + errp); | ||
234 | if (ret < 0) { | ||
235 | error_prepend(errp, "Failed to resize underlying file: "); | ||
236 | qcow2_free_clusters(bs, allocation_start, | ||
237 | @@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs, | ||
238 | if (len < 0) { | ||
239 | return len; | ||
240 | } | ||
241 | - return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL); | ||
242 | + return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0, | ||
243 | + NULL); | ||
244 | } | ||
245 | |||
246 | if (offset_into_cluster(s, offset)) { | ||
247 | @@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs) | ||
248 | } | ||
249 | |||
250 | ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false, | ||
251 | - PREALLOC_MODE_OFF, &local_err); | ||
252 | + PREALLOC_MODE_OFF, 0, &local_err); | ||
253 | if (ret < 0) { | ||
254 | error_report_err(local_err); | ||
255 | goto fail; | ||
256 | diff --git a/block/raw-format.c b/block/raw-format.c | ||
257 | index XXXXXXX..XXXXXXX 100644 | ||
258 | --- a/block/raw-format.c | ||
259 | +++ b/block/raw-format.c | ||
260 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, | ||
261 | |||
262 | s->size = offset; | ||
263 | offset += s->offset; | ||
264 | - return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp); | ||
265 | + return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp); | ||
266 | } | ||
267 | |||
268 | static void raw_eject(BlockDriverState *bs, bool eject_flag) | ||
269 | diff --git a/block/vhdx-log.c b/block/vhdx-log.c | ||
270 | index XXXXXXX..XXXXXXX 100644 | ||
271 | --- a/block/vhdx-log.c | ||
272 | +++ b/block/vhdx-log.c | ||
273 | @@ -XXX,XX +XXX,XX @@ static int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s, | ||
274 | goto exit; | ||
275 | } | ||
276 | ret = bdrv_truncate(bs->file, new_file_size, false, | ||
277 | - PREALLOC_MODE_OFF, NULL); | ||
278 | + PREALLOC_MODE_OFF, 0, NULL); | ||
279 | if (ret < 0) { | ||
280 | goto exit; | ||
281 | } | ||
282 | diff --git a/block/vhdx.c b/block/vhdx.c | ||
283 | index XXXXXXX..XXXXXXX 100644 | ||
284 | --- a/block/vhdx.c | ||
285 | +++ b/block/vhdx.c | ||
286 | @@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s, | ||
287 | } | ||
288 | |||
289 | return bdrv_truncate(bs->file, *new_offset + s->block_size, false, | ||
290 | - PREALLOC_MODE_OFF, NULL); | ||
291 | + PREALLOC_MODE_OFF, 0, NULL); | ||
292 | } | ||
293 | |||
294 | /* | ||
23 | diff --git a/block/vmdk.c b/block/vmdk.c | 295 | diff --git a/block/vmdk.c b/block/vmdk.c |
24 | index XXXXXXX..XXXXXXX 100644 | 296 | index XXXXXXX..XXXXXXX 100644 |
25 | --- a/block/vmdk.c | 297 | --- a/block/vmdk.c |
26 | +++ b/block/vmdk.c | 298 | +++ b/block/vmdk.c |
27 | @@ -XXX,XX +XXX,XX @@ static int vmdk_probe(const uint8_t *buf, int buf_size, const char *filename) | 299 | @@ -XXX,XX +XXX,XX @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset, |
28 | } | 300 | } |
29 | if (end - p >= strlen("version=X\n")) { | 301 | length = QEMU_ALIGN_UP(length, BDRV_SECTOR_SIZE); |
30 | if (strncmp("version=1\n", p, strlen("version=1\n")) == 0 || | 302 | ret = bdrv_truncate(s->extents[i].file, length, false, |
31 | - strncmp("version=2\n", p, strlen("version=2\n")) == 0) { | 303 | - PREALLOC_MODE_OFF, NULL); |
32 | + strncmp("version=2\n", p, strlen("version=2\n")) == 0 || | 304 | + PREALLOC_MODE_OFF, 0, NULL); |
33 | + strncmp("version=3\n", p, strlen("version=3\n")) == 0) { | 305 | if (ret < 0) { |
34 | return 100; | 306 | return ret; |
35 | } | ||
36 | } | 307 | } |
37 | if (end - p >= strlen("version=X\r\n")) { | 308 | diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c |
38 | if (strncmp("version=1\r\n", p, strlen("version=1\r\n")) == 0 || | 309 | index XXXXXXX..XXXXXXX 100644 |
39 | - strncmp("version=2\r\n", p, strlen("version=2\r\n")) == 0) { | 310 | --- a/tests/test-block-iothread.c |
40 | + strncmp("version=2\r\n", p, strlen("version=2\r\n")) == 0 || | 311 | +++ b/tests/test-block-iothread.c |
41 | + strncmp("version=3\r\n", p, strlen("version=3\r\n")) == 0) { | 312 | @@ -XXX,XX +XXX,XX @@ static void test_sync_op_truncate(BdrvChild *c) |
42 | return 100; | 313 | int ret; |
43 | } | 314 | |
44 | } | 315 | /* Normal success path */ |
316 | - ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL); | ||
317 | + ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL); | ||
318 | g_assert_cmpint(ret, ==, 0); | ||
319 | |||
320 | /* Early error: Negative offset */ | ||
321 | - ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, NULL); | ||
322 | + ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL); | ||
323 | g_assert_cmpint(ret, ==, -EINVAL); | ||
324 | |||
325 | /* Error: Read-only image */ | ||
326 | c->bs->read_only = true; | ||
327 | c->bs->open_flags &= ~BDRV_O_RDWR; | ||
328 | |||
329 | - ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL); | ||
330 | + ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL); | ||
331 | g_assert_cmpint(ret, ==, -EACCES); | ||
332 | |||
333 | c->bs->read_only = false; | ||
45 | -- | 334 | -- |
46 | 2.20.1 | 335 | 2.25.3 |
47 | 336 | ||
48 | 337 | diff view generated by jsdifflib |
1 | Coverity doesn't like that the return value of bdrv_check_update_perm() | 1 | Now that node level interface bdrv_truncate() supports passing request |
---|---|---|---|
2 | stays unused only in this place (CID 1399710). | 2 | flags to the block driver, expose this on the BlockBackend level, too. |
3 | |||
4 | Even if checking local_err should be equivalent to checking ret < 0, | ||
5 | let's switch to using the return value to be more consistent (and in | ||
6 | case of a bug somewhere down the call chain, forgetting to assign errp | ||
7 | is more likely than returning 0 for an error case). | ||
8 | 3 | ||
9 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 4 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
5 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
10 | Reviewed-by: Alberto Garcia <berto@igalia.com> | 6 | Reviewed-by: Alberto Garcia <berto@igalia.com> |
11 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | 7 | Reviewed-by: Max Reitz <mreitz@redhat.com> |
12 | Reviewed-by: Markus Armbruster <armbru@redhat.com> | 8 | Message-Id: <20200424125448.63318-4-kwolf@redhat.com> |
9 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
13 | --- | 10 | --- |
14 | block.c | 7 +++---- | 11 | include/sysemu/block-backend.h | 2 +- |
15 | 1 file changed, 3 insertions(+), 4 deletions(-) | 12 | block.c | 3 ++- |
16 | 13 | block/block-backend.c | 4 ++-- | |
14 | block/commit.c | 4 ++-- | ||
15 | block/crypto.c | 2 +- | ||
16 | block/mirror.c | 2 +- | ||
17 | block/qcow2.c | 4 ++-- | ||
18 | block/qed.c | 2 +- | ||
19 | block/vdi.c | 2 +- | ||
20 | block/vhdx.c | 4 ++-- | ||
21 | block/vmdk.c | 6 +++--- | ||
22 | block/vpc.c | 2 +- | ||
23 | blockdev.c | 2 +- | ||
24 | qemu-img.c | 2 +- | ||
25 | qemu-io-cmds.c | 2 +- | ||
26 | 15 files changed, 22 insertions(+), 21 deletions(-) | ||
27 | |||
28 | diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h | ||
29 | index XXXXXXX..XXXXXXX 100644 | ||
30 | --- a/include/sysemu/block-backend.h | ||
31 | +++ b/include/sysemu/block-backend.h | ||
32 | @@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset, | ||
33 | int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf, | ||
34 | int bytes); | ||
35 | int blk_truncate(BlockBackend *blk, int64_t offset, bool exact, | ||
36 | - PreallocMode prealloc, Error **errp); | ||
37 | + PreallocMode prealloc, BdrvRequestFlags flags, Error **errp); | ||
38 | int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes); | ||
39 | int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf, | ||
40 | int64_t pos, int size); | ||
17 | diff --git a/block.c b/block.c | 41 | diff --git a/block.c b/block.c |
18 | index XXXXXXX..XXXXXXX 100644 | 42 | index XXXXXXX..XXXXXXX 100644 |
19 | --- a/block.c | 43 | --- a/block.c |
20 | +++ b/block.c | 44 | +++ b/block.c |
21 | @@ -XXX,XX +XXX,XX @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base, | 45 | @@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk, |
22 | QLIST_FOREACH_SAFE(c, &top->parents, next_parent, next) { | 46 | int64_t size; |
23 | /* Check whether we are allowed to switch c from top to base */ | 47 | int ret; |
24 | GSList *ignore_children = g_slist_prepend(NULL, c); | 48 | |
25 | - bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm, | 49 | - ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err); |
26 | - ignore_children, &local_err); | 50 | + ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0, |
27 | + ret = bdrv_check_update_perm(base, NULL, c->perm, c->shared_perm, | 51 | + &local_err); |
28 | + ignore_children, &local_err); | 52 | if (ret < 0 && ret != -ENOTSUP) { |
29 | g_slist_free(ignore_children); | 53 | error_propagate(errp, local_err); |
30 | - if (local_err) { | 54 | return ret; |
31 | - ret = -EPERM; | 55 | diff --git a/block/block-backend.c b/block/block-backend.c |
32 | + if (ret < 0) { | 56 | index XXXXXXX..XXXXXXX 100644 |
57 | --- a/block/block-backend.c | ||
58 | +++ b/block/block-backend.c | ||
59 | @@ -XXX,XX +XXX,XX @@ int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf, | ||
60 | } | ||
61 | |||
62 | int blk_truncate(BlockBackend *blk, int64_t offset, bool exact, | ||
63 | - PreallocMode prealloc, Error **errp) | ||
64 | + PreallocMode prealloc, BdrvRequestFlags flags, Error **errp) | ||
65 | { | ||
66 | if (!blk_is_available(blk)) { | ||
67 | error_setg(errp, "No medium inserted"); | ||
68 | return -ENOMEDIUM; | ||
69 | } | ||
70 | |||
71 | - return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp); | ||
72 | + return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp); | ||
73 | } | ||
74 | |||
75 | int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf, | ||
76 | diff --git a/block/commit.c b/block/commit.c | ||
77 | index XXXXXXX..XXXXXXX 100644 | ||
78 | --- a/block/commit.c | ||
79 | +++ b/block/commit.c | ||
80 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp) | ||
81 | } | ||
82 | |||
83 | if (base_len < len) { | ||
84 | - ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, NULL); | ||
85 | + ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, 0, NULL); | ||
86 | if (ret) { | ||
87 | goto out; | ||
88 | } | ||
89 | @@ -XXX,XX +XXX,XX @@ int bdrv_commit(BlockDriverState *bs) | ||
90 | * grow the backing file image if possible. If not possible, | ||
91 | * we must return an error */ | ||
92 | if (length > backing_length) { | ||
93 | - ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, | ||
94 | + ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, 0, | ||
95 | &local_err); | ||
96 | if (ret < 0) { | ||
33 | error_report_err(local_err); | 97 | error_report_err(local_err); |
34 | goto exit; | 98 | diff --git a/block/crypto.c b/block/crypto.c |
35 | } | 99 | index XXXXXXX..XXXXXXX 100644 |
100 | --- a/block/crypto.c | ||
101 | +++ b/block/crypto.c | ||
102 | @@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_init_func(QCryptoBlock *block, | ||
103 | * which will be used by the crypto header | ||
104 | */ | ||
105 | return blk_truncate(data->blk, data->size + headerlen, false, | ||
106 | - data->prealloc, errp); | ||
107 | + data->prealloc, 0, errp); | ||
108 | } | ||
109 | |||
110 | |||
111 | diff --git a/block/mirror.c b/block/mirror.c | ||
112 | index XXXXXXX..XXXXXXX 100644 | ||
113 | --- a/block/mirror.c | ||
114 | +++ b/block/mirror.c | ||
115 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp) | ||
116 | |||
117 | if (s->bdev_length > base_length) { | ||
118 | ret = blk_truncate(s->target, s->bdev_length, false, | ||
119 | - PREALLOC_MODE_OFF, NULL); | ||
120 | + PREALLOC_MODE_OFF, 0, NULL); | ||
121 | if (ret < 0) { | ||
122 | goto immediate_exit; | ||
123 | } | ||
124 | diff --git a/block/qcow2.c b/block/qcow2.c | ||
125 | index XXXXXXX..XXXXXXX 100644 | ||
126 | --- a/block/qcow2.c | ||
127 | +++ b/block/qcow2.c | ||
128 | @@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp) | ||
129 | |||
130 | /* Okay, now that we have a valid image, let's give it the right size */ | ||
131 | ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation, | ||
132 | - errp); | ||
133 | + 0, errp); | ||
134 | if (ret < 0) { | ||
135 | error_prepend(errp, "Could not resize image: "); | ||
136 | goto out; | ||
137 | @@ -XXX,XX +XXX,XX @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, | ||
138 | * Amending image options should ensure that the image has | ||
139 | * exactly the given new values, so pass exact=true here. | ||
140 | */ | ||
141 | - ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, errp); | ||
142 | + ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp); | ||
143 | blk_unref(blk); | ||
144 | if (ret < 0) { | ||
145 | return ret; | ||
146 | diff --git a/block/qed.c b/block/qed.c | ||
147 | index XXXXXXX..XXXXXXX 100644 | ||
148 | --- a/block/qed.c | ||
149 | +++ b/block/qed.c | ||
150 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts, | ||
151 | * The QED format associates file length with allocation status, | ||
152 | * so a new file (which is empty) must have a length of 0. | ||
153 | */ | ||
154 | - ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, errp); | ||
155 | + ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, 0, errp); | ||
156 | if (ret < 0) { | ||
157 | goto out; | ||
158 | } | ||
159 | diff --git a/block/vdi.c b/block/vdi.c | ||
160 | index XXXXXXX..XXXXXXX 100644 | ||
161 | --- a/block/vdi.c | ||
162 | +++ b/block/vdi.c | ||
163 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options, | ||
164 | |||
165 | if (image_type == VDI_TYPE_STATIC) { | ||
166 | ret = blk_truncate(blk, offset + blocks * block_size, false, | ||
167 | - PREALLOC_MODE_OFF, errp); | ||
168 | + PREALLOC_MODE_OFF, 0, errp); | ||
169 | if (ret < 0) { | ||
170 | error_prepend(errp, "Failed to statically allocate file"); | ||
171 | goto exit; | ||
172 | diff --git a/block/vhdx.c b/block/vhdx.c | ||
173 | index XXXXXXX..XXXXXXX 100644 | ||
174 | --- a/block/vhdx.c | ||
175 | +++ b/block/vhdx.c | ||
176 | @@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s, | ||
177 | /* All zeroes, so we can just extend the file - the end of the BAT | ||
178 | * is the furthest thing we have written yet */ | ||
179 | ret = blk_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF, | ||
180 | - errp); | ||
181 | + 0, errp); | ||
182 | if (ret < 0) { | ||
183 | goto exit; | ||
184 | } | ||
185 | } else if (type == VHDX_TYPE_FIXED) { | ||
186 | ret = blk_truncate(blk, data_file_offset + image_size, false, | ||
187 | - PREALLOC_MODE_OFF, errp); | ||
188 | + PREALLOC_MODE_OFF, 0, errp); | ||
189 | if (ret < 0) { | ||
190 | goto exit; | ||
191 | } | ||
192 | diff --git a/block/vmdk.c b/block/vmdk.c | ||
193 | index XXXXXXX..XXXXXXX 100644 | ||
194 | --- a/block/vmdk.c | ||
195 | +++ b/block/vmdk.c | ||
196 | @@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk, | ||
197 | int gd_buf_size; | ||
198 | |||
199 | if (flat) { | ||
200 | - ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, errp); | ||
201 | + ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp); | ||
202 | goto exit; | ||
203 | } | ||
204 | magic = cpu_to_be32(VMDK4_MAGIC); | ||
205 | @@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk, | ||
206 | } | ||
207 | |||
208 | ret = blk_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false, | ||
209 | - PREALLOC_MODE_OFF, errp); | ||
210 | + PREALLOC_MODE_OFF, 0, errp); | ||
211 | if (ret < 0) { | ||
212 | goto exit; | ||
213 | } | ||
214 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn vmdk_co_do_create(int64_t size, | ||
215 | /* bdrv_pwrite write padding zeros to align to sector, we don't need that | ||
216 | * for description file */ | ||
217 | if (desc_offset == 0) { | ||
218 | - ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, errp); | ||
219 | + ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, 0, errp); | ||
220 | if (ret < 0) { | ||
221 | goto exit; | ||
222 | } | ||
223 | diff --git a/block/vpc.c b/block/vpc.c | ||
224 | index XXXXXXX..XXXXXXX 100644 | ||
225 | --- a/block/vpc.c | ||
226 | +++ b/block/vpc.c | ||
227 | @@ -XXX,XX +XXX,XX @@ static int create_fixed_disk(BlockBackend *blk, uint8_t *buf, | ||
228 | /* Add footer to total size */ | ||
229 | total_size += HEADER_SIZE; | ||
230 | |||
231 | - ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, errp); | ||
232 | + ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp); | ||
233 | if (ret < 0) { | ||
234 | return ret; | ||
235 | } | ||
236 | diff --git a/blockdev.c b/blockdev.c | ||
237 | index XXXXXXX..XXXXXXX 100644 | ||
238 | --- a/blockdev.c | ||
239 | +++ b/blockdev.c | ||
240 | @@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device, | ||
241 | } | ||
242 | |||
243 | bdrv_drained_begin(bs); | ||
244 | - ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, errp); | ||
245 | + ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, 0, errp); | ||
246 | bdrv_drained_end(bs); | ||
247 | |||
248 | out: | ||
249 | diff --git a/qemu-img.c b/qemu-img.c | ||
250 | index XXXXXXX..XXXXXXX 100644 | ||
251 | --- a/qemu-img.c | ||
252 | +++ b/qemu-img.c | ||
253 | @@ -XXX,XX +XXX,XX @@ static int img_resize(int argc, char **argv) | ||
254 | * resizing, so pass @exact=true. It is of no use to report | ||
255 | * success when the image has not actually been resized. | ||
256 | */ | ||
257 | - ret = blk_truncate(blk, total_size, true, prealloc, &err); | ||
258 | + ret = blk_truncate(blk, total_size, true, prealloc, 0, &err); | ||
259 | if (!ret) { | ||
260 | qprintf(quiet, "Image resized.\n"); | ||
261 | } else { | ||
262 | diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c | ||
263 | index XXXXXXX..XXXXXXX 100644 | ||
264 | --- a/qemu-io-cmds.c | ||
265 | +++ b/qemu-io-cmds.c | ||
266 | @@ -XXX,XX +XXX,XX @@ static int truncate_f(BlockBackend *blk, int argc, char **argv) | ||
267 | * exact=true. It is better to err on the "emit more errors" side | ||
268 | * than to be overly permissive. | ||
269 | */ | ||
270 | - ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, &local_err); | ||
271 | + ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, 0, &local_err); | ||
272 | if (ret < 0) { | ||
273 | error_report_err(local_err); | ||
274 | return ret; | ||
36 | -- | 275 | -- |
37 | 2.20.1 | 276 | 2.25.3 |
38 | 277 | ||
39 | 278 | diff view generated by jsdifflib |
New patch | |||
---|---|---|---|
1 | If BDRV_REQ_ZERO_WRITE is set and we're extending the image, calling | ||
2 | qcow2_cluster_zeroize() with flags=0 does the right thing: It doesn't | ||
3 | undo any previous preallocation, but just adds the zero flag to all | ||
4 | relevant L2 entries. If an external data file is in use, a write_zeroes | ||
5 | request to the data file is made instead. | ||
1 | 6 | ||
7 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
8 | Message-Id: <20200424125448.63318-5-kwolf@redhat.com> | ||
9 | Reviewed-by: Eric Blake <eblake@redhat.com> | ||
10 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
11 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
12 | --- | ||
13 | block/qcow2-cluster.c | 2 +- | ||
14 | block/qcow2.c | 34 ++++++++++++++++++++++++++++++++++ | ||
15 | 2 files changed, 35 insertions(+), 1 deletion(-) | ||
16 | |||
17 | diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c | ||
18 | index XXXXXXX..XXXXXXX 100644 | ||
19 | --- a/block/qcow2-cluster.c | ||
20 | +++ b/block/qcow2-cluster.c | ||
21 | @@ -XXX,XX +XXX,XX @@ int qcow2_cluster_zeroize(BlockDriverState *bs, uint64_t offset, | ||
22 | /* Caller must pass aligned values, except at image end */ | ||
23 | assert(QEMU_IS_ALIGNED(offset, s->cluster_size)); | ||
24 | assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) || | ||
25 | - end_offset == bs->total_sectors << BDRV_SECTOR_BITS); | ||
26 | + end_offset >= bs->total_sectors << BDRV_SECTOR_BITS); | ||
27 | |||
28 | /* The zero flag is only supported by version 3 and newer */ | ||
29 | if (s->qcow_version < 3) { | ||
30 | diff --git a/block/qcow2.c b/block/qcow2.c | ||
31 | index XXXXXXX..XXXXXXX 100644 | ||
32 | --- a/block/qcow2.c | ||
33 | +++ b/block/qcow2.c | ||
34 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options, | ||
35 | |||
36 | bs->supported_zero_flags = header.version >= 3 ? | ||
37 | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0; | ||
38 | + bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE; | ||
39 | |||
40 | /* Repair image if dirty */ | ||
41 | if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only && | ||
42 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, | ||
43 | g_assert_not_reached(); | ||
44 | } | ||
45 | |||
46 | + if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) { | ||
47 | + uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size); | ||
48 | + | ||
49 | + /* | ||
50 | + * Use zero clusters as much as we can. qcow2_cluster_zeroize() | ||
51 | + * requires a cluster-aligned start. The end may be unaligned if it is | ||
52 | + * at the end of the image (which it is here). | ||
53 | + */ | ||
54 | + ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0); | ||
55 | + if (ret < 0) { | ||
56 | + error_setg_errno(errp, -ret, "Failed to zero out new clusters"); | ||
57 | + goto fail; | ||
58 | + } | ||
59 | + | ||
60 | + /* Write explicit zeros for the unaligned head */ | ||
61 | + if (zero_start > old_length) { | ||
62 | + uint64_t len = zero_start - old_length; | ||
63 | + uint8_t *buf = qemu_blockalign0(bs, len); | ||
64 | + QEMUIOVector qiov; | ||
65 | + qemu_iovec_init_buf(&qiov, buf, len); | ||
66 | + | ||
67 | + qemu_co_mutex_unlock(&s->lock); | ||
68 | + ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0); | ||
69 | + qemu_co_mutex_lock(&s->lock); | ||
70 | + | ||
71 | + qemu_vfree(buf); | ||
72 | + if (ret < 0) { | ||
73 | + error_setg_errno(errp, -ret, "Failed to zero out the new area"); | ||
74 | + goto fail; | ||
75 | + } | ||
76 | + } | ||
77 | + } | ||
78 | + | ||
79 | if (prealloc != PREALLOC_MODE_OFF) { | ||
80 | /* Flush metadata before actually changing the image size */ | ||
81 | ret = qcow2_write_caches(bs); | ||
82 | -- | ||
83 | 2.25.3 | ||
84 | |||
85 | diff view generated by jsdifflib |
1 | From: Lukáš Doktor <ldoktor@redhat.com> | 1 | The raw format driver can simply forward the flag and let its bs->file |
---|---|---|---|
2 | child take care of actually providing the zeros. | ||
2 | 3 | ||
3 | When custom TEST_DIR is specified the output includes it without leading | 4 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
4 | '/': | 5 | Reviewed-by: Max Reitz <mreitz@redhat.com> |
5 | 6 | Reviewed-by: Eric Blake <eblake@redhat.com> | |
6 | $ TEST_DIR=/var/tmp ./check -file -qcow2 051 | 7 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> |
7 | .... | 8 | Message-Id: <20200424125448.63318-6-kwolf@redhat.com> |
8 | -drive0 (NODE_NAME): json:{"backing": {"driver": "qcow2", "file": | ||
9 | {"driver": "file", "filename": "TEST_DIR/t.qcow2"}}, "driver": "qcow2", | ||
10 | "file": {"driver": "file", "filename": SNAPSHOT_PATH}} (qcow2, | ||
11 | read-only) | ||
12 | +drive0 (NODE_NAME): json:{"backing": {"driver": "qcow2", "file": | ||
13 | {"driver": "file", "filename": "TEST_DIR/t.qcow2"}}, "driver": "qcow2", | ||
14 | "file": {"driver": "file", "filename": "TEST_DIR/vl.ziHfeP"}} (qcow2, | ||
15 | read-only) | ||
16 | |||
17 | Let's remove it from the sed regexp. | ||
18 | |||
19 | Signed-off-by: Lukáš Doktor <ldoktor@redhat.com> | ||
20 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 9 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
21 | --- | 10 | --- |
22 | tests/qemu-iotests/051 | 2 +- | 11 | block/raw-format.c | 4 +++- |
23 | 1 file changed, 1 insertion(+), 1 deletion(-) | 12 | 1 file changed, 3 insertions(+), 1 deletion(-) |
24 | 13 | ||
25 | diff --git a/tests/qemu-iotests/051 b/tests/qemu-iotests/051 | 14 | diff --git a/block/raw-format.c b/block/raw-format.c |
26 | index XXXXXXX..XXXXXXX 100755 | 15 | index XXXXXXX..XXXXXXX 100644 |
27 | --- a/tests/qemu-iotests/051 | 16 | --- a/block/raw-format.c |
28 | +++ b/tests/qemu-iotests/051 | 17 | +++ b/block/raw-format.c |
29 | @@ -XXX,XX +XXX,XX @@ TMPDIR=/nonexistent run_qemu -drive driver=null-co,snapshot=on | 18 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, |
30 | echo "info block" | | 19 | |
31 | run_qemu -drive file="$TEST_IMG",snapshot=on,read-only=on,if=none,id=$device_id | | 20 | s->size = offset; |
32 | _filter_qemu_io | | 21 | offset += s->offset; |
33 | - sed -e 's#"/[^"]*/vl\.[A-Za-z0-9]\{6\}"#SNAPSHOT_PATH#g' | 22 | - return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp); |
34 | + sed -e 's#"[^"]*/vl\.[A-Za-z0-9]\{6\}"#SNAPSHOT_PATH#g' | 23 | + return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp); |
35 | 24 | } | |
36 | 25 | ||
37 | # success, all done | 26 | static void raw_eject(BlockDriverState *bs, bool eject_flag) |
27 | @@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags, | ||
28 | bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED | | ||
29 | ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) & | ||
30 | bs->file->bs->supported_zero_flags); | ||
31 | + bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags & | ||
32 | + BDRV_REQ_ZERO_WRITE; | ||
33 | |||
34 | if (bs->probed && !bdrv_is_read_only(bs)) { | ||
35 | bdrv_refresh_filename(bs->file->bs); | ||
38 | -- | 36 | -- |
39 | 2.20.1 | 37 | 2.25.3 |
40 | 38 | ||
41 | 39 | diff view generated by jsdifflib |
1 | From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | 1 | For regular files, we always get BDRV_REQ_ZERO_WRITE behaviour from the |
---|---|---|---|
2 | OS, so we can advertise the flag and just ignore it. | ||
2 | 3 | ||
3 | Job (especially mirror) may call block_job_error_action several | 4 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
4 | times before actual pause if it has several in-flight requests. | 5 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> |
5 | 6 | Reviewed-by: Alberto Garcia <berto@igalia.com> | |
6 | block_job_error_action will call job_pause more than once in this case, | 7 | Reviewed-by: Max Reitz <mreitz@redhat.com> |
7 | which lead to following block-job-resume qmp command can't actually | 8 | Message-Id: <20200424125448.63318-7-kwolf@redhat.com> |
8 | resume the job. | ||
9 | |||
10 | Fix it by do not increase pause level in block_job_error_action if | ||
11 | user_paused already set. | ||
12 | |||
13 | Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
14 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 9 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
15 | --- | 10 | --- |
16 | blockjob.c | 8 +++++--- | 11 | block/file-posix.c | 4 ++++ |
17 | 1 file changed, 5 insertions(+), 3 deletions(-) | 12 | 1 file changed, 4 insertions(+) |
18 | 13 | ||
19 | diff --git a/blockjob.c b/blockjob.c | 14 | diff --git a/block/file-posix.c b/block/file-posix.c |
20 | index XXXXXXX..XXXXXXX 100644 | 15 | index XXXXXXX..XXXXXXX 100644 |
21 | --- a/blockjob.c | 16 | --- a/block/file-posix.c |
22 | +++ b/blockjob.c | 17 | +++ b/block/file-posix.c |
23 | @@ -XXX,XX +XXX,XX @@ BlockErrorAction block_job_error_action(BlockJob *job, BlockdevOnError on_err, | 18 | @@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options, |
24 | action); | 19 | #endif |
25 | } | 20 | |
26 | if (action == BLOCK_ERROR_ACTION_STOP) { | 21 | bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK; |
27 | - job_pause(&job->job); | 22 | + if (S_ISREG(st.st_mode)) { |
28 | - /* make the pause user visible, which will be resumed from QMP. */ | 23 | + /* When extending regular files, we get zeros from the OS */ |
29 | - job->job.user_paused = true; | 24 | + bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE; |
30 | + if (!job->job.user_paused) { | 25 | + } |
31 | + job_pause(&job->job); | 26 | ret = 0; |
32 | + /* make the pause user visible, which will be resumed from QMP. */ | 27 | fail: |
33 | + job->job.user_paused = true; | 28 | if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) { |
34 | + } | ||
35 | block_job_iostatus_set_err(job, error); | ||
36 | } | ||
37 | return action; | ||
38 | -- | 29 | -- |
39 | 2.20.1 | 30 | 2.25.3 |
40 | 31 | ||
41 | 32 | diff view generated by jsdifflib |
1 | From: Markus Armbruster <armbru@redhat.com> | 1 | When extending the size of an image that has a backing file larger than |
---|---|---|---|
2 | its old size, make sure that the backing file data doesn't become | ||
3 | visible in the guest, but the added area is properly zeroed out. | ||
2 | 4 | ||
3 | Recent commit cda4aa9a5a0 moved block backend creation before machine | 5 | Consider the following scenario where the overlay is shorter than its |
4 | property evaluation. This broke qemu-iotests 055. Turns out we need | 6 | backing file: |
5 | to create the migration object before block backends, so block | ||
6 | backends can add migration blockers. Fix by calling | ||
7 | migration_object_init() earlier, right before configure_blockdev(). | ||
8 | 7 | ||
9 | Fixes: cda4aa9a5a08777cf13e164c0543bd4888b8adce | 8 | base.qcow2: AAAAAAAA |
10 | Reported-by: Kevin Wolf <kwolf@redhat.com> | 9 | overlay.qcow2: BBBB |
11 | Signed-off-by: Markus Armbruster <armbru@redhat.com> | 10 | |
11 | When resizing (extending) overlay.qcow2, the new blocks should not stay | ||
12 | unallocated and make the additional As from base.qcow2 visible like | ||
13 | before this patch, but zeros should be read. | ||
14 | |||
15 | A similar case happens with the various variants of a commit job when an | ||
16 | intermediate file is short (- for unallocated): | ||
17 | |||
18 | base.qcow2: A-A-AAAA | ||
19 | mid.qcow2: BB-B | ||
20 | top.qcow2: C--C--C- | ||
21 | |||
22 | After commit top.qcow2 to mid.qcow2, the following happens: | ||
23 | |||
24 | mid.qcow2: CB-C00C0 (correct result) | ||
25 | mid.qcow2: CB-C--C- (before this fix) | ||
26 | |||
27 | Without the fix, blocks that previously read as zeros on top.qcow2 | ||
28 | suddenly turn into A. | ||
29 | |||
30 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
31 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
32 | Message-Id: <20200424125448.63318-8-kwolf@redhat.com> | ||
33 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
12 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 34 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
13 | --- | 35 | --- |
14 | vl.c | 15 ++++++++------- | 36 | block/io.c | 25 +++++++++++++++++++++++++ |
15 | 1 file changed, 8 insertions(+), 7 deletions(-) | 37 | 1 file changed, 25 insertions(+) |
16 | 38 | ||
17 | diff --git a/vl.c b/vl.c | 39 | diff --git a/block/io.c b/block/io.c |
18 | index XXXXXXX..XXXXXXX 100644 | 40 | index XXXXXXX..XXXXXXX 100644 |
19 | --- a/vl.c | 41 | --- a/block/io.c |
20 | +++ b/vl.c | 42 | +++ b/block/io.c |
21 | @@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp) | 43 | @@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, |
22 | exit(0); | 44 | goto out; |
23 | } | 45 | } |
24 | 46 | ||
25 | + /* | 47 | + /* |
26 | + * Migration object can only be created after global properties | 48 | + * If the image has a backing file that is large enough that it would |
27 | + * are applied correctly. | 49 | + * provide data for the new area, we cannot leave it unallocated because |
50 | + * then the backing file content would become visible. Instead, zero-fill | ||
51 | + * the new area. | ||
52 | + * | ||
53 | + * Note that if the image has a backing file, but was opened without the | ||
54 | + * backing file, taking care of keeping things consistent with that backing | ||
55 | + * file is the user's responsibility. | ||
28 | + */ | 56 | + */ |
29 | + migration_object_init(); | 57 | + if (new_bytes && bs->backing) { |
58 | + int64_t backing_len; | ||
30 | + | 59 | + |
31 | /* | 60 | + backing_len = bdrv_getlength(backing_bs(bs)); |
32 | * Note: we need to create block backends before | 61 | + if (backing_len < 0) { |
33 | * machine_set_property(), so machine properties can refer to | 62 | + ret = backing_len; |
34 | - * them. | 63 | + error_setg_errno(errp, -ret, "Could not get backing file size"); |
35 | + * them, and after migration_object_init(), so we can create | 64 | + goto out; |
36 | + * migration blockers. | 65 | + } |
37 | */ | 66 | + |
38 | configure_blockdev(&bdo_queue, machine_class, snapshot); | 67 | + if (backing_len > old_size) { |
39 | 68 | + flags |= BDRV_REQ_ZERO_WRITE; | |
40 | @@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp) | 69 | + } |
41 | machine_class->name, machine_class->deprecation_reason); | 70 | + } |
42 | } | 71 | + |
43 | 72 | if (drv->bdrv_co_truncate) { | |
44 | - /* | 73 | if (flags & ~bs->supported_truncate_flags) { |
45 | - * Migration object can only be created after global properties | 74 | error_setg(errp, "Block driver does not support requested flags"); |
46 | - * are applied correctly. | ||
47 | - */ | ||
48 | - migration_object_init(); | ||
49 | - | ||
50 | if (qtest_chrdev) { | ||
51 | qtest_init(qtest_chrdev, qtest_log, &error_fatal); | ||
52 | } | ||
53 | -- | 75 | -- |
54 | 2.20.1 | 76 | 2.25.3 |
55 | 77 | ||
56 | 78 | diff view generated by jsdifflib |
1 | From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | 1 | We want to keep TEST_IMG for the full path of the main test image, but |
---|---|---|---|
2 | filter_testfiles() must be called for other test images before replacing | ||
3 | other things like the image format because the test directory path could | ||
4 | contain the format as a substring. | ||
2 | 5 | ||
3 | There no @device parameter, only the @id one. | 6 | Insert a filter_testfiles() call between both. |
4 | 7 | ||
5 | Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | 8 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
6 | Reviewed-by: Eric Blake <eblake@redhat.com> | 9 | Reviewed-by: Max Reitz <mreitz@redhat.com> |
10 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
11 | Message-Id: <20200424125448.63318-9-kwolf@redhat.com> | ||
7 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 12 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
8 | --- | 13 | --- |
9 | qapi/block-core.json | 10 +++++----- | 14 | tests/qemu-iotests/iotests.py | 5 +++-- |
10 | 1 file changed, 5 insertions(+), 5 deletions(-) | 15 | 1 file changed, 3 insertions(+), 2 deletions(-) |
11 | 16 | ||
12 | diff --git a/qapi/block-core.json b/qapi/block-core.json | 17 | diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py |
13 | index XXXXXXX..XXXXXXX 100644 | 18 | index XXXXXXX..XXXXXXX 100644 |
14 | --- a/qapi/block-core.json | 19 | --- a/tests/qemu-iotests/iotests.py |
15 | +++ b/qapi/block-core.json | 20 | +++ b/tests/qemu-iotests/iotests.py |
16 | @@ -XXX,XX +XXX,XX @@ | 21 | @@ -XXX,XX +XXX,XX @@ def filter_img_info(output, filename): |
17 | # | 22 | for line in output.split('\n'): |
18 | # Manage read, write and flush latency histograms for the device. | 23 | if 'disk size' in line or 'actual-size' in line: |
19 | # | 24 | continue |
20 | -# If only @device parameter is specified, remove all present latency histograms | 25 | - line = line.replace(filename, 'TEST_IMG') \ |
21 | +# If only @id parameter is specified, remove all present latency histograms | 26 | - .replace(imgfmt, 'IMGFMT') |
22 | # for the device. Otherwise, add/reset some of (or all) latency histograms. | 27 | + line = line.replace(filename, 'TEST_IMG') |
23 | # | 28 | + line = filter_testfiles(line) |
24 | # @id: The name or QOM path of the guest device. | 29 | + line = line.replace(imgfmt, 'IMGFMT') |
25 | @@ -XXX,XX +XXX,XX @@ | 30 | line = re.sub('iters: [0-9]+', 'iters: XXX', line) |
26 | # [0, 10), [10, 50), [50, 100), [100, +inf): | 31 | line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line) |
27 | # | 32 | line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line) |
28 | # -> { "execute": "block-latency-histogram-set", | ||
29 | -# "arguments": { "device": "drive0", | ||
30 | +# "arguments": { "id": "drive0", | ||
31 | # "boundaries": [10, 50, 100] } } | ||
32 | # <- { "return": {} } | ||
33 | # | ||
34 | @@ -XXX,XX +XXX,XX @@ | ||
35 | # not changed (or not created): | ||
36 | # | ||
37 | # -> { "execute": "block-latency-histogram-set", | ||
38 | -# "arguments": { "device": "drive0", | ||
39 | +# "arguments": { "id": "drive0", | ||
40 | # "boundaries-write": [10, 50, 100] } } | ||
41 | # <- { "return": {} } | ||
42 | # | ||
43 | @@ -XXX,XX +XXX,XX @@ | ||
44 | # write: [0, 1000), [1000, 5000), [5000, +inf) | ||
45 | # | ||
46 | # -> { "execute": "block-latency-histogram-set", | ||
47 | -# "arguments": { "device": "drive0", | ||
48 | +# "arguments": { "id": "drive0", | ||
49 | # "boundaries": [10, 50, 100], | ||
50 | # "boundaries-write": [1000, 5000] } } | ||
51 | # <- { "return": {} } | ||
52 | @@ -XXX,XX +XXX,XX @@ | ||
53 | # Example: remove all latency histograms: | ||
54 | # | ||
55 | # -> { "execute": "block-latency-histogram-set", | ||
56 | -# "arguments": { "device": "drive0" } } | ||
57 | +# "arguments": { "id": "drive0" } } | ||
58 | # <- { "return": {} } | ||
59 | ## | ||
60 | { 'command': 'block-latency-histogram-set', | ||
61 | -- | 33 | -- |
62 | 2.20.1 | 34 | 2.25.3 |
63 | 35 | ||
64 | 36 | diff view generated by jsdifflib |
1 | 232 is marked as generic, but commit 12efe428c9e added code that assumes | 1 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
---|---|---|---|
2 | qcow2. What the new test really needs is backing files and support for | 2 | Message-Id: <20200424125448.63318-10-kwolf@redhat.com> |
3 | updating the backing file link (.bdrv_change_backing_file). | 3 | Reviewed-by: Max Reitz <mreitz@redhat.com> |
4 | 4 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | |
5 | Split the non-generic code into a new test case 247 and make it work | ||
6 | with qed, too. | ||
7 | |||
8 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 5 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
9 | --- | 6 | --- |
10 | tests/qemu-iotests/232 | 30 --------------- | 7 | tests/qemu-iotests/274 | 155 +++++++++++++++++++++ |
11 | tests/qemu-iotests/232.out | 20 ---------- | 8 | tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++ |
12 | tests/qemu-iotests/247 | 79 ++++++++++++++++++++++++++++++++++++++ | 9 | tests/qemu-iotests/group | 1 + |
13 | tests/qemu-iotests/247.out | 22 +++++++++++ | 10 | 3 files changed, 424 insertions(+) |
14 | tests/qemu-iotests/group | 1 + | 11 | create mode 100755 tests/qemu-iotests/274 |
15 | 5 files changed, 102 insertions(+), 50 deletions(-) | 12 | create mode 100644 tests/qemu-iotests/274.out |
16 | create mode 100755 tests/qemu-iotests/247 | ||
17 | create mode 100644 tests/qemu-iotests/247.out | ||
18 | 13 | ||
19 | diff --git a/tests/qemu-iotests/232 b/tests/qemu-iotests/232 | 14 | diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274 |
20 | index XXXXXXX..XXXXXXX 100755 | ||
21 | --- a/tests/qemu-iotests/232 | ||
22 | +++ b/tests/qemu-iotests/232 | ||
23 | @@ -XXX,XX +XXX,XX @@ run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,a | ||
24 | run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0,auto-read-only=on | ||
25 | run_qemu_info_block -blockdev driver=file,filename="$TEST_IMG",node-name=node0 | ||
26 | |||
27 | -echo | ||
28 | -echo "=== Try commit to backing file with auto-read-only ===" | ||
29 | -echo | ||
30 | - | ||
31 | -TEST_IMG="$TEST_IMG.0" _make_test_img $size | ||
32 | -TEST_IMG="$TEST_IMG.1" _make_test_img $size | ||
33 | -TEST_IMG="$TEST_IMG.2" _make_test_img $size | ||
34 | -TEST_IMG="$TEST_IMG.3" _make_test_img $size | ||
35 | -TEST_IMG="$TEST_IMG.4" _make_test_img $size | ||
36 | - | ||
37 | -(cat <<EOF | ||
38 | -{"execute":"qmp_capabilities"} | ||
39 | -{"execute":"block-commit", | ||
40 | - "arguments":{"device":"format-4", "top-node": "format-2", "base-node":"format-0", "job-id":"job0"}} | ||
41 | -EOF | ||
42 | -sleep 1 | ||
43 | -echo '{"execute":"quit"}' | ||
44 | -) | $QEMU -qmp stdio -nographic -nodefaults \ | ||
45 | - -blockdev file,node-name=file-0,filename=$TEST_IMG.0,auto-read-only=on \ | ||
46 | - -blockdev qcow2,node-name=format-0,file=file-0,read-only=on \ | ||
47 | - -blockdev file,node-name=file-1,filename=$TEST_IMG.1,auto-read-only=on \ | ||
48 | - -blockdev qcow2,node-name=format-1,file=file-1,read-only=on,backing=format-0 \ | ||
49 | - -blockdev file,node-name=file-2,filename=$TEST_IMG.2,auto-read-only=on \ | ||
50 | - -blockdev qcow2,node-name=format-2,file=file-2,read-only=on,backing=format-1 \ | ||
51 | - -blockdev file,node-name=file-3,filename=$TEST_IMG.3,auto-read-only=on \ | ||
52 | - -blockdev qcow2,node-name=format-3,file=file-3,read-only=on,backing=format-2 \ | ||
53 | - -blockdev file,node-name=file-4,filename=$TEST_IMG.4,auto-read-only=on \ | ||
54 | - -blockdev qcow2,node-name=format-4,file=file-4,read-only=on,backing=format-3 | | ||
55 | - _filter_qmp | ||
56 | - | ||
57 | # success, all done | ||
58 | echo "*** done" | ||
59 | rm -f $seq.full | ||
60 | diff --git a/tests/qemu-iotests/232.out b/tests/qemu-iotests/232.out | ||
61 | index XXXXXXX..XXXXXXX 100644 | ||
62 | --- a/tests/qemu-iotests/232.out | ||
63 | +++ b/tests/qemu-iotests/232.out | ||
64 | @@ -XXX,XX +XXX,XX @@ QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,read | ||
65 | QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0,auto-read-only=off: Could not open 'TEST_DIR/t.IMGFMT': Permission denied | ||
66 | node0: TEST_DIR/t.IMGFMT (file) | ||
67 | QEMU_PROG: -blockdev driver=file,filename=TEST_DIR/t.IMGFMT,node-name=node0: Could not open 'TEST_DIR/t.IMGFMT': Permission denied | ||
68 | - | ||
69 | -=== Try commit to backing file with auto-read-only === | ||
70 | - | ||
71 | -Formatting 'TEST_DIR/t.IMGFMT.0', fmt=IMGFMT size=134217728 | ||
72 | -Formatting 'TEST_DIR/t.IMGFMT.1', fmt=IMGFMT size=134217728 | ||
73 | -Formatting 'TEST_DIR/t.IMGFMT.2', fmt=IMGFMT size=134217728 | ||
74 | -Formatting 'TEST_DIR/t.IMGFMT.3', fmt=IMGFMT size=134217728 | ||
75 | -Formatting 'TEST_DIR/t.IMGFMT.4', fmt=IMGFMT size=134217728 | ||
76 | -QMP_VERSION | ||
77 | -{"return": {}} | ||
78 | -{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}} | ||
79 | -{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}} | ||
80 | -{"return": {}} | ||
81 | -{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "waiting", "id": "job0"}} | ||
82 | -{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "pending", "id": "job0"}} | ||
83 | -{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "job0", "len": 134217728, "offset": 134217728, "speed": 0, "type": "commit"}} | ||
84 | -{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "concluded", "id": "job0"}} | ||
85 | -{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "null", "id": "job0"}} | ||
86 | -{"return": {}} | ||
87 | -{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false, "reason": "host-qmp-quit"}} | ||
88 | *** done | ||
89 | diff --git a/tests/qemu-iotests/247 b/tests/qemu-iotests/247 | ||
90 | new file mode 100755 | 15 | new file mode 100755 |
91 | index XXXXXXX..XXXXXXX | 16 | index XXXXXXX..XXXXXXX |
92 | --- /dev/null | 17 | --- /dev/null |
93 | +++ b/tests/qemu-iotests/247 | 18 | +++ b/tests/qemu-iotests/274 |
94 | @@ -XXX,XX +XXX,XX @@ | 19 | @@ -XXX,XX +XXX,XX @@ |
95 | +#!/usr/bin/env bash | 20 | +#!/usr/bin/env python3 |
96 | +# | ||
97 | +# Test for auto-read-only with commit block job | ||
98 | +# | 21 | +# |
99 | +# Copyright (C) 2019 Red Hat, Inc. | 22 | +# Copyright (C) 2019 Red Hat, Inc. |
100 | +# | 23 | +# |
101 | +# This program is free software; you can redistribute it and/or modify | 24 | +# This program is free software; you can redistribute it and/or modify |
102 | +# it under the terms of the GNU General Public License as published by | 25 | +# it under the terms of the GNU General Public License as published by |
... | ... | ||
109 | +# GNU General Public License for more details. | 32 | +# GNU General Public License for more details. |
110 | +# | 33 | +# |
111 | +# You should have received a copy of the GNU General Public License | 34 | +# You should have received a copy of the GNU General Public License |
112 | +# along with this program. If not, see <http://www.gnu.org/licenses/>. | 35 | +# along with this program. If not, see <http://www.gnu.org/licenses/>. |
113 | +# | 36 | +# |
114 | + | 37 | +# Creator/Owner: Kevin Wolf <kwolf@redhat.com> |
115 | +# creator | 38 | +# |
116 | +owner=kwolf@redhat.com | 39 | +# Some tests for short backing files and short overlays |
117 | + | 40 | + |
118 | +seq=`basename $0` | 41 | +import iotests |
119 | +echo "QA output created by $seq" | 42 | + |
120 | + | 43 | +iotests.verify_image_format(supported_fmts=['qcow2']) |
121 | +status=1 # failure is the default! | 44 | +iotests.verify_platform(['linux']) |
122 | + | 45 | + |
123 | +_cleanup() | 46 | +size_short = 1 * 1024 * 1024 |
124 | +{ | 47 | +size_long = 2 * 1024 * 1024 |
125 | + _cleanup_test_img | 48 | +size_diff = size_long - size_short |
126 | + rm -f $TEST_IMG.[01234] | 49 | + |
127 | +} | 50 | +def create_chain() -> None: |
128 | +trap "_cleanup; exit \$status" 0 1 2 3 15 | 51 | + iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, |
129 | + | 52 | + str(size_long)) |
130 | +# get standard environment, filters and checks | 53 | + iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid, |
131 | +. ./common.rc | 54 | + str(size_short)) |
132 | +. ./common.filter | 55 | + iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top, |
133 | + | 56 | + str(size_long)) |
134 | +# Requires backing files and .bdrv_change_backing_file support | 57 | + |
135 | +_supported_fmt qcow2 qed | 58 | + iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base) |
136 | +_supported_proto file | 59 | + |
137 | +_supported_os Linux | 60 | +def create_vm() -> iotests.VM: |
138 | + | 61 | + vm = iotests.VM() |
139 | +size=128M | 62 | + vm.add_blockdev('file,filename=%s,node-name=base-file' % base) |
140 | + | 63 | + vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt) |
141 | +echo | 64 | + vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid) |
142 | +echo "=== Try commit to backing file with auto-read-only ===" | 65 | + vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base' |
143 | +echo | 66 | + % iotests.imgfmt) |
144 | +TEST_IMG="$TEST_IMG.0" _make_test_img $size | 67 | + vm.add_drive(top, 'backing=mid,node-name=top') |
145 | +TEST_IMG="$TEST_IMG.1" _make_test_img $size | 68 | + return vm |
146 | +TEST_IMG="$TEST_IMG.2" _make_test_img $size | 69 | + |
147 | +TEST_IMG="$TEST_IMG.3" _make_test_img $size | 70 | +with iotests.FilePath('base') as base, \ |
148 | +TEST_IMG="$TEST_IMG.4" _make_test_img $size | 71 | + iotests.FilePath('mid') as mid, \ |
149 | + | 72 | + iotests.FilePath('top') as top: |
150 | +(cat <<EOF | 73 | + |
151 | +{"execute":"qmp_capabilities"} | 74 | + iotests.log('== Commit tests ==') |
152 | +{"execute":"block-commit", | 75 | + |
153 | + "arguments":{"device":"format-4", "top-node": "format-2", "base-node":"format-0", "job-id":"job0"}} | 76 | + create_chain() |
154 | +EOF | 77 | + |
155 | +sleep 1 | 78 | + iotests.log('=== Check visible data ===') |
156 | +echo '{"execute":"quit"}' | 79 | + |
157 | +) | $QEMU -qmp stdio -nographic -nodefaults \ | 80 | + iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top) |
158 | + -blockdev file,node-name=file-0,filename=$TEST_IMG.0,auto-read-only=on \ | 81 | + iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top) |
159 | + -blockdev $IMGFMT,node-name=format-0,file=file-0,read-only=on \ | 82 | + |
160 | + -blockdev file,node-name=file-1,filename=$TEST_IMG.1,auto-read-only=on \ | 83 | + iotests.log('=== Checking allocation status ===') |
161 | + -blockdev $IMGFMT,node-name=format-1,file=file-1,read-only=on,backing=format-0 \ | 84 | + |
162 | + -blockdev file,node-name=file-2,filename=$TEST_IMG.2,auto-read-only=on \ | 85 | + iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short, |
163 | + -blockdev $IMGFMT,node-name=format-2,file=file-2,read-only=on,backing=format-1 \ | 86 | + '-c', 'alloc %d %d' % (size_short, size_diff), |
164 | + -blockdev file,node-name=file-3,filename=$TEST_IMG.3,auto-read-only=on \ | 87 | + base) |
165 | + -blockdev $IMGFMT,node-name=format-3,file=file-3,read-only=on,backing=format-2 \ | 88 | + |
166 | + -blockdev file,node-name=file-4,filename=$TEST_IMG.4,auto-read-only=on \ | 89 | + iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short, |
167 | + -blockdev $IMGFMT,node-name=format-4,file=file-4,read-only=on,backing=format-3 | | 90 | + '-c', 'alloc %d %d' % (size_short, size_diff), |
168 | + _filter_qmp | 91 | + mid) |
169 | + | 92 | + |
170 | +# success, all done | 93 | + iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short, |
171 | +echo "*** done" | 94 | + '-c', 'alloc %d %d' % (size_short, size_diff), |
172 | +rm -f $seq.full | 95 | + top) |
173 | +status=0 | 96 | + |
174 | diff --git a/tests/qemu-iotests/247.out b/tests/qemu-iotests/247.out | 97 | + iotests.log('=== Checking map ===') |
98 | + | ||
99 | + iotests.qemu_img_log('map', '--output=json', base) | ||
100 | + iotests.qemu_img_log('map', '--output=human', base) | ||
101 | + iotests.qemu_img_log('map', '--output=json', mid) | ||
102 | + iotests.qemu_img_log('map', '--output=human', mid) | ||
103 | + iotests.qemu_img_log('map', '--output=json', top) | ||
104 | + iotests.qemu_img_log('map', '--output=human', top) | ||
105 | + | ||
106 | + iotests.log('=== Testing qemu-img commit (top -> mid) ===') | ||
107 | + | ||
108 | + iotests.qemu_img_log('commit', top) | ||
109 | + iotests.img_info_log(mid) | ||
110 | + iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid) | ||
111 | + iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid) | ||
112 | + | ||
113 | + iotests.log('=== Testing HMP commit (top -> mid) ===') | ||
114 | + | ||
115 | + create_chain() | ||
116 | + with create_vm() as vm: | ||
117 | + vm.launch() | ||
118 | + vm.qmp_log('human-monitor-command', command_line='commit drive0') | ||
119 | + | ||
120 | + iotests.img_info_log(mid) | ||
121 | + iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid) | ||
122 | + iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid) | ||
123 | + | ||
124 | + iotests.log('=== Testing QMP active commit (top -> mid) ===') | ||
125 | + | ||
126 | + create_chain() | ||
127 | + with create_vm() as vm: | ||
128 | + vm.launch() | ||
129 | + vm.qmp_log('block-commit', device='top', base_node='mid', | ||
130 | + job_id='job0', auto_dismiss=False) | ||
131 | + vm.run_job('job0', wait=5) | ||
132 | + | ||
133 | + iotests.img_info_log(mid) | ||
134 | + iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid) | ||
135 | + iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid) | ||
136 | + | ||
137 | + | ||
138 | + iotests.log('== Resize tests ==') | ||
139 | + | ||
140 | + # Use different sizes for different allocation modes: | ||
141 | + # | ||
142 | + # We want to have at least one test where 32 bit truncation in the size of | ||
143 | + # the overlapping area becomes visible. This is covered by the | ||
144 | + # prealloc='off' case (1G to 6G is an overlap of 5G). | ||
145 | + # | ||
146 | + # However, we can only do this for modes that don't preallocate data | ||
147 | + # because otherwise we might run out of space on the test host. | ||
148 | + # | ||
149 | + # We also want to test some unaligned combinations. | ||
150 | + for (prealloc, base_size, top_size_old, top_size_new, off) in [ | ||
151 | + ('off', '6G', '1G', '8G', '5G'), | ||
152 | + ('metadata', '32G', '30G', '33G', '31G'), | ||
153 | + ('falloc', '10M', '5M', '15M', '9M'), | ||
154 | + ('full', '16M', '8M', '12M', '11M'), | ||
155 | + ('off', '384k', '253k', '512k', '253k'), | ||
156 | + ('off', '400k', '256k', '512k', '336k'), | ||
157 | + ('off', '512k', '256k', '500k', '436k')]: | ||
158 | + | ||
159 | + iotests.log('=== preallocation=%s ===' % prealloc) | ||
160 | + iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, base_size) | ||
161 | + iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, top, | ||
162 | + top_size_old) | ||
163 | + iotests.qemu_io_log('-c', 'write -P 1 %s 64k' % off, base) | ||
164 | + | ||
165 | + # After this, top_size_old to base_size should be allocated/zeroed. | ||
166 | + # | ||
167 | + # In theory, leaving base_size to top_size_new unallocated would be | ||
168 | + # correct, but in practice, if we zero out anything, we zero out | ||
169 | + # everything up to top_size_new. | ||
170 | + iotests.qemu_img_log('resize', '-f', iotests.imgfmt, | ||
171 | + '--preallocation', prealloc, top, top_size_new) | ||
172 | + iotests.qemu_io_log('-c', 'read -P 0 %s 64k' % off, top) | ||
173 | + iotests.qemu_io_log('-c', 'map', top) | ||
174 | + iotests.qemu_img_log('map', '--output=json', top) | ||
175 | diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out | ||
175 | new file mode 100644 | 176 | new file mode 100644 |
176 | index XXXXXXX..XXXXXXX | 177 | index XXXXXXX..XXXXXXX |
177 | --- /dev/null | 178 | --- /dev/null |
178 | +++ b/tests/qemu-iotests/247.out | 179 | +++ b/tests/qemu-iotests/274.out |
179 | @@ -XXX,XX +XXX,XX @@ | 180 | @@ -XXX,XX +XXX,XX @@ |
180 | +QA output created by 247 | 181 | +== Commit tests == |
181 | + | 182 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16 |
182 | +=== Try commit to backing file with auto-read-only === | 183 | + |
183 | + | 184 | +Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 |
184 | +Formatting 'TEST_DIR/t.IMGFMT.0', fmt=IMGFMT size=134217728 | 185 | + |
185 | +Formatting 'TEST_DIR/t.IMGFMT.1', fmt=IMGFMT size=134217728 | 186 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16 |
186 | +Formatting 'TEST_DIR/t.IMGFMT.2', fmt=IMGFMT size=134217728 | 187 | + |
187 | +Formatting 'TEST_DIR/t.IMGFMT.3', fmt=IMGFMT size=134217728 | 188 | +wrote 2097152/2097152 bytes at offset 0 |
188 | +Formatting 'TEST_DIR/t.IMGFMT.4', fmt=IMGFMT size=134217728 | 189 | +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) |
189 | +QMP_VERSION | 190 | + |
191 | +=== Check visible data === | ||
192 | +read 1048576/1048576 bytes at offset 0 | ||
193 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
194 | + | ||
195 | +read 1048576/1048576 bytes at offset 1048576 | ||
196 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
197 | + | ||
198 | +=== Checking allocation status === | ||
199 | +1048576/1048576 bytes allocated at offset 0 bytes | ||
200 | +1048576/1048576 bytes allocated at offset 1 MiB | ||
201 | + | ||
202 | +0/1048576 bytes allocated at offset 0 bytes | ||
203 | +0/0 bytes allocated at offset 1 MiB | ||
204 | + | ||
205 | +0/1048576 bytes allocated at offset 0 bytes | ||
206 | +0/1048576 bytes allocated at offset 1 MiB | ||
207 | + | ||
208 | +=== Checking map === | ||
209 | +[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": 327680}] | ||
210 | + | ||
211 | +Offset Length Mapped to File | ||
212 | +0 0x200000 0x50000 TEST_DIR/PID-base | ||
213 | + | ||
214 | +[{ "start": 0, "length": 1048576, "depth": 1, "zero": false, "data": true, "offset": 327680}] | ||
215 | + | ||
216 | +Offset Length Mapped to File | ||
217 | +0 0x100000 0x50000 TEST_DIR/PID-base | ||
218 | + | ||
219 | +[{ "start": 0, "length": 1048576, "depth": 2, "zero": false, "data": true, "offset": 327680}, | ||
220 | +{ "start": 1048576, "length": 1048576, "depth": 0, "zero": true, "data": false}] | ||
221 | + | ||
222 | +Offset Length Mapped to File | ||
223 | +0 0x100000 0x50000 TEST_DIR/PID-base | ||
224 | + | ||
225 | +=== Testing qemu-img commit (top -> mid) === | ||
226 | +Image committed. | ||
227 | + | ||
228 | +image: TEST_IMG | ||
229 | +file format: IMGFMT | ||
230 | +virtual size: 2 MiB (2097152 bytes) | ||
231 | +cluster_size: 65536 | ||
232 | +backing file: TEST_DIR/PID-base | ||
233 | +Format specific information: | ||
234 | + compat: 1.1 | ||
235 | + lazy refcounts: false | ||
236 | + refcount bits: 16 | ||
237 | + corrupt: false | ||
238 | + | ||
239 | +read 1048576/1048576 bytes at offset 0 | ||
240 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
241 | + | ||
242 | +read 1048576/1048576 bytes at offset 1048576 | ||
243 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
244 | + | ||
245 | +=== Testing HMP commit (top -> mid) === | ||
246 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
247 | + | ||
248 | +Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
249 | + | ||
250 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
251 | + | ||
252 | +wrote 2097152/2097152 bytes at offset 0 | ||
253 | +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
254 | + | ||
255 | +{"execute": "human-monitor-command", "arguments": {"command-line": "commit drive0"}} | ||
256 | +{"return": ""} | ||
257 | +image: TEST_IMG | ||
258 | +file format: IMGFMT | ||
259 | +virtual size: 2 MiB (2097152 bytes) | ||
260 | +cluster_size: 65536 | ||
261 | +backing file: TEST_DIR/PID-base | ||
262 | +Format specific information: | ||
263 | + compat: 1.1 | ||
264 | + lazy refcounts: false | ||
265 | + refcount bits: 16 | ||
266 | + corrupt: false | ||
267 | + | ||
268 | +read 1048576/1048576 bytes at offset 0 | ||
269 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
270 | + | ||
271 | +read 1048576/1048576 bytes at offset 1048576 | ||
272 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
273 | + | ||
274 | +=== Testing QMP active commit (top -> mid) === | ||
275 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
276 | + | ||
277 | +Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
278 | + | ||
279 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
280 | + | ||
281 | +wrote 2097152/2097152 bytes at offset 0 | ||
282 | +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
283 | + | ||
284 | +{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "mid", "device": "top", "job-id": "job0"}} | ||
190 | +{"return": {}} | 285 | +{"return": {}} |
191 | +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}} | 286 | +{"execute": "job-complete", "arguments": {"id": "job0"}} |
192 | +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}} | ||
193 | +{"return": {}} | 287 | +{"return": {}} |
194 | +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "waiting", "id": "job0"}} | 288 | +{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} |
195 | +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "pending", "id": "job0"}} | 289 | +{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} |
196 | +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "job0", "len": 134217728, "offset": 134217728, "speed": 0, "type": "commit"}} | 290 | +{"execute": "job-dismiss", "arguments": {"id": "job0"}} |
197 | +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "concluded", "id": "job0"}} | ||
198 | +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "null", "id": "job0"}} | ||
199 | +{"return": {}} | 291 | +{"return": {}} |
200 | +{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN", "data": {"guest": false, "reason": "host-qmp-quit"}} | 292 | +image: TEST_IMG |
201 | +*** done | 293 | +file format: IMGFMT |
294 | +virtual size: 2 MiB (2097152 bytes) | ||
295 | +cluster_size: 65536 | ||
296 | +backing file: TEST_DIR/PID-base | ||
297 | +Format specific information: | ||
298 | + compat: 1.1 | ||
299 | + lazy refcounts: false | ||
300 | + refcount bits: 16 | ||
301 | + corrupt: false | ||
302 | + | ||
303 | +read 1048576/1048576 bytes at offset 0 | ||
304 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
305 | + | ||
306 | +read 1048576/1048576 bytes at offset 1048576 | ||
307 | +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
308 | + | ||
309 | +== Resize tests == | ||
310 | +=== preallocation=off === | ||
311 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=6442450944 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
312 | + | ||
313 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=1073741824 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
314 | + | ||
315 | +wrote 65536/65536 bytes at offset 5368709120 | ||
316 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
317 | + | ||
318 | +Image resized. | ||
319 | + | ||
320 | +read 65536/65536 bytes at offset 5368709120 | ||
321 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
322 | + | ||
323 | +1 GiB (0x40000000) bytes not allocated at offset 0 bytes (0x0) | ||
324 | +7 GiB (0x1c0000000) bytes allocated at offset 1 GiB (0x40000000) | ||
325 | + | ||
326 | +[{ "start": 0, "length": 1073741824, "depth": 1, "zero": true, "data": false}, | ||
327 | +{ "start": 1073741824, "length": 7516192768, "depth": 0, "zero": true, "data": false}] | ||
328 | + | ||
329 | +=== preallocation=metadata === | ||
330 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=34359738368 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
331 | + | ||
332 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=32212254720 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
333 | + | ||
334 | +wrote 65536/65536 bytes at offset 33285996544 | ||
335 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
336 | + | ||
337 | +Image resized. | ||
338 | + | ||
339 | +read 65536/65536 bytes at offset 33285996544 | ||
340 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
341 | + | ||
342 | +30 GiB (0x780000000) bytes not allocated at offset 0 bytes (0x0) | ||
343 | +3 GiB (0xc0000000) bytes allocated at offset 30 GiB (0x780000000) | ||
344 | + | ||
345 | +[{ "start": 0, "length": 32212254720, "depth": 1, "zero": true, "data": false}, | ||
346 | +{ "start": 32212254720, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 327680}, | ||
347 | +{ "start": 32749125632, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 537264128}, | ||
348 | +{ "start": 33285996544, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1074200576}, | ||
349 | +{ "start": 33822867456, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1611137024}, | ||
350 | +{ "start": 34359738368, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2148139008}, | ||
351 | +{ "start": 34896609280, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2685075456}] | ||
352 | + | ||
353 | +=== preallocation=falloc === | ||
354 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=10485760 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
355 | + | ||
356 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=5242880 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
357 | + | ||
358 | +wrote 65536/65536 bytes at offset 9437184 | ||
359 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
360 | + | ||
361 | +Image resized. | ||
362 | + | ||
363 | +read 65536/65536 bytes at offset 9437184 | ||
364 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
365 | + | ||
366 | +5 MiB (0x500000) bytes not allocated at offset 0 bytes (0x0) | ||
367 | +10 MiB (0xa00000) bytes allocated at offset 5 MiB (0x500000) | ||
368 | + | ||
369 | +[{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false}, | ||
370 | +{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}] | ||
371 | + | ||
372 | +=== preallocation=full === | ||
373 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
374 | + | ||
375 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=8388608 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
376 | + | ||
377 | +wrote 65536/65536 bytes at offset 11534336 | ||
378 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
379 | + | ||
380 | +Image resized. | ||
381 | + | ||
382 | +read 65536/65536 bytes at offset 11534336 | ||
383 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
384 | + | ||
385 | +8 MiB (0x800000) bytes not allocated at offset 0 bytes (0x0) | ||
386 | +4 MiB (0x400000) bytes allocated at offset 8 MiB (0x800000) | ||
387 | + | ||
388 | +[{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false}, | ||
389 | +{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}] | ||
390 | + | ||
391 | +=== preallocation=off === | ||
392 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
393 | + | ||
394 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=259072 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
395 | + | ||
396 | +wrote 65536/65536 bytes at offset 259072 | ||
397 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
398 | + | ||
399 | +Image resized. | ||
400 | + | ||
401 | +read 65536/65536 bytes at offset 259072 | ||
402 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
403 | + | ||
404 | +192 KiB (0x30000) bytes not allocated at offset 0 bytes (0x0) | ||
405 | +320 KiB (0x50000) bytes allocated at offset 192 KiB (0x30000) | ||
406 | + | ||
407 | +[{ "start": 0, "length": 196608, "depth": 1, "zero": true, "data": false}, | ||
408 | +{ "start": 196608, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": 327680}, | ||
409 | +{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}] | ||
410 | + | ||
411 | +=== preallocation=off === | ||
412 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=409600 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
413 | + | ||
414 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
415 | + | ||
416 | +wrote 65536/65536 bytes at offset 344064 | ||
417 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
418 | + | ||
419 | +Image resized. | ||
420 | + | ||
421 | +read 65536/65536 bytes at offset 344064 | ||
422 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
423 | + | ||
424 | +256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0) | ||
425 | +256 KiB (0x40000) bytes allocated at offset 256 KiB (0x40000) | ||
426 | + | ||
427 | +[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false}, | ||
428 | +{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}] | ||
429 | + | ||
430 | +=== preallocation=off === | ||
431 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=524288 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
432 | + | ||
433 | +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
434 | + | ||
435 | +wrote 65536/65536 bytes at offset 446464 | ||
436 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
437 | + | ||
438 | +Image resized. | ||
439 | + | ||
440 | +read 65536/65536 bytes at offset 446464 | ||
441 | +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
442 | + | ||
443 | +256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0) | ||
444 | +244 KiB (0x3d000) bytes allocated at offset 256 KiB (0x40000) | ||
445 | + | ||
446 | +[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false}, | ||
447 | +{ "start": 262144, "length": 249856, "depth": 0, "zero": true, "data": false}] | ||
448 | + | ||
202 | diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group | 449 | diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group |
203 | index XXXXXXX..XXXXXXX 100644 | 450 | index XXXXXXX..XXXXXXX 100644 |
204 | --- a/tests/qemu-iotests/group | 451 | --- a/tests/qemu-iotests/group |
205 | +++ b/tests/qemu-iotests/group | 452 | +++ b/tests/qemu-iotests/group |
206 | @@ -XXX,XX +XXX,XX @@ | 453 | @@ -XXX,XX +XXX,XX @@ |
207 | 244 rw auto quick | 454 | 270 rw backing quick |
208 | 245 rw auto | 455 | 272 rw |
209 | 246 rw auto quick | 456 | 273 backing quick |
210 | +247 rw auto quick | 457 | +274 rw backing |
458 | 277 rw quick | ||
459 | 279 rw backing quick | ||
460 | 280 rw migration quick | ||
211 | -- | 461 | -- |
212 | 2.20.1 | 462 | 2.25.3 |
213 | 463 | ||
214 | 464 | diff view generated by jsdifflib |
1 | We were trying to check whether bdrv_open_blockdev_ref() returned | 1 | The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the |
---|---|---|---|
2 | success, but accidentally checked the wrong variable. Spotted by | 2 | image is possibly preallocated and then the zero flag is added to all |
3 | Coverity (CID 1399703). | 3 | clusters. This means that a copy-on-write operation may be needed when |
4 | writing to these clusters, despite having used preallocation, negating | ||
5 | one of the major benefits of preallocation. | ||
6 | |||
7 | Instead, try to forward the BDRV_REQ_ZERO_WRITE to the protocol driver, | ||
8 | and if the protocol driver can ensure that the new area reads as zeros, | ||
9 | we can skip setting the zero flag in the qcow2 layer. | ||
10 | |||
11 | Unfortunately, the same approach doesn't work for metadata | ||
12 | preallocation, so we'll still set the zero flag there. | ||
4 | 13 | ||
5 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 14 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
6 | Reviewed-by: Eric Blake <eblake@redhat.com> | 15 | Reviewed-by: Max Reitz <mreitz@redhat.com> |
7 | Reviewed-by: Stefano Garzarella <sgarzare@redhat.com> | 16 | Message-Id: <20200424142701.67053-1-kwolf@redhat.com> |
17 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
18 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
8 | --- | 19 | --- |
9 | block/qcow2.c | 2 +- | 20 | block/qcow2.c | 22 +++++++++++++++++++--- |
10 | 1 file changed, 1 insertion(+), 1 deletion(-) | 21 | tests/qemu-iotests/274.out | 4 ++-- |
22 | 2 files changed, 21 insertions(+), 5 deletions(-) | ||
11 | 23 | ||
12 | diff --git a/block/qcow2.c b/block/qcow2.c | 24 | diff --git a/block/qcow2.c b/block/qcow2.c |
13 | index XXXXXXX..XXXXXXX 100644 | 25 | index XXXXXXX..XXXXXXX 100644 |
14 | --- a/block/qcow2.c | 26 | --- a/block/qcow2.c |
15 | +++ b/block/qcow2.c | 27 | +++ b/block/qcow2.c |
16 | @@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp) | 28 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, |
17 | goto out; | 29 | /* Allocate the data area */ |
18 | } | 30 | new_file_size = allocation_start + |
19 | data_bs = bdrv_open_blockdev_ref(qcow2_opts->data_file, errp); | 31 | nb_new_data_clusters * s->cluster_size; |
20 | - if (bs == NULL) { | 32 | - /* Image file grows, so @exact does not matter */ |
21 | + if (data_bs == NULL) { | 33 | - ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0, |
22 | ret = -EIO; | 34 | - errp); |
23 | goto out; | 35 | + /* |
24 | } | 36 | + * Image file grows, so @exact does not matter. |
37 | + * | ||
38 | + * If we need to zero out the new area, try first whether the protocol | ||
39 | + * driver can already take care of this. | ||
40 | + */ | ||
41 | + if (flags & BDRV_REQ_ZERO_WRITE) { | ||
42 | + ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, | ||
43 | + BDRV_REQ_ZERO_WRITE, NULL); | ||
44 | + if (ret >= 0) { | ||
45 | + flags &= ~BDRV_REQ_ZERO_WRITE; | ||
46 | + } | ||
47 | + } else { | ||
48 | + ret = -1; | ||
49 | + } | ||
50 | + if (ret < 0) { | ||
51 | + ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0, | ||
52 | + errp); | ||
53 | + } | ||
54 | if (ret < 0) { | ||
55 | error_prepend(errp, "Failed to resize underlying file: "); | ||
56 | qcow2_free_clusters(bs, allocation_start, | ||
57 | diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out | ||
58 | index XXXXXXX..XXXXXXX 100644 | ||
59 | --- a/tests/qemu-iotests/274.out | ||
60 | +++ b/tests/qemu-iotests/274.out | ||
61 | @@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 9437184 | ||
62 | 10 MiB (0xa00000) bytes allocated at offset 5 MiB (0x500000) | ||
63 | |||
64 | [{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false}, | ||
65 | -{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}] | ||
66 | +{ "start": 5242880, "length": 10485760, "depth": 0, "zero": false, "data": true, "offset": 327680}] | ||
67 | |||
68 | === preallocation=full === | ||
69 | Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
70 | @@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 11534336 | ||
71 | 4 MiB (0x400000) bytes allocated at offset 8 MiB (0x800000) | ||
72 | |||
73 | [{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false}, | ||
74 | -{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}] | ||
75 | +{ "start": 8388608, "length": 4194304, "depth": 0, "zero": false, "data": true, "offset": 327680}] | ||
76 | |||
77 | === preallocation=off === | ||
78 | Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
25 | -- | 79 | -- |
26 | 2.20.1 | 80 | 2.25.3 |
27 | 81 | ||
28 | 82 | diff view generated by jsdifflib |
1 | From: Max Reitz <mreitz@redhat.com> | 1 | From: Andrzej Jakowski <andrzej.jakowski@linux.intel.com> |
---|---|---|---|
2 | 2 | ||
3 | There is no reason why the constraints we put on @replaces should be | 3 | This patch introduces support for PMR that has been defined as part of NVMe 1.4 |
4 | limited to drive-mirror. Therefore, move the sanity checks from | 4 | spec. User can now specify a pmrdev option that should point to HostMemoryBackend. |
5 | qmp_drive_mirror() to blockdev_mirror_common() so they apply to | 5 | pmrdev memory region will subsequently be exposed as PCI BAR 2 in emulated NVMe |
6 | blockdev-mirror as well. | 6 | device. Guest OS can perform mmio read and writes to the PMR region that will stay |
7 | persistent across system reboot. | ||
7 | 8 | ||
8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 9 | Signed-off-by: Andrzej Jakowski <andrzej.jakowski@linux.intel.com> |
9 | Reviewed-by: Eric Blake <eblake@redhat.com> | 10 | Reviewed-by: Klaus Jensen <k.jensen@samsung.com> |
10 | Reviewed-by: Alberto Garcia <berto@igalia.com> | 11 | Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com> |
12 | Message-Id: <20200330164656.9348-1-andrzej.jakowski@linux.intel.com> | ||
13 | Reviewed-by: Keith Busch <kbusch@kernel.org> | ||
11 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 14 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
12 | --- | 15 | --- |
13 | blockdev.c | 55 ++++++++++++++++++++++++++++++++---------------------- | 16 | hw/block/nvme.h | 2 + |
14 | 1 file changed, 33 insertions(+), 22 deletions(-) | 17 | include/block/nvme.h | 172 +++++++++++++++++++++++++++++++++++++++++ |
18 | hw/block/nvme.c | 109 ++++++++++++++++++++++++++ | ||
19 | hw/block/Makefile.objs | 2 +- | ||
20 | hw/block/trace-events | 4 + | ||
21 | 5 files changed, 288 insertions(+), 1 deletion(-) | ||
15 | 22 | ||
16 | diff --git a/blockdev.c b/blockdev.c | 23 | diff --git a/hw/block/nvme.h b/hw/block/nvme.h |
17 | index XXXXXXX..XXXXXXX 100644 | 24 | index XXXXXXX..XXXXXXX 100644 |
18 | --- a/blockdev.c | 25 | --- a/hw/block/nvme.h |
19 | +++ b/blockdev.c | 26 | +++ b/hw/block/nvme.h |
20 | @@ -XXX,XX +XXX,XX @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs, | 27 | @@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl { |
21 | sync = MIRROR_SYNC_MODE_FULL; | 28 | uint64_t timestamp_set_qemu_clock_ms; /* QEMU clock time */ |
29 | |||
30 | char *serial; | ||
31 | + HostMemoryBackend *pmrdev; | ||
32 | + | ||
33 | NvmeNamespace *namespaces; | ||
34 | NvmeSQueue **sq; | ||
35 | NvmeCQueue **cq; | ||
36 | diff --git a/include/block/nvme.h b/include/block/nvme.h | ||
37 | index XXXXXXX..XXXXXXX 100644 | ||
38 | --- a/include/block/nvme.h | ||
39 | +++ b/include/block/nvme.h | ||
40 | @@ -XXX,XX +XXX,XX @@ typedef struct NvmeBar { | ||
41 | uint64_t acq; | ||
42 | uint32_t cmbloc; | ||
43 | uint32_t cmbsz; | ||
44 | + uint8_t padding[3520]; /* not used by QEMU */ | ||
45 | + uint32_t pmrcap; | ||
46 | + uint32_t pmrctl; | ||
47 | + uint32_t pmrsts; | ||
48 | + uint32_t pmrebs; | ||
49 | + uint32_t pmrswtp; | ||
50 | + uint32_t pmrmsc; | ||
51 | } NvmeBar; | ||
52 | |||
53 | enum NvmeCapShift { | ||
54 | @@ -XXX,XX +XXX,XX @@ enum NvmeCapShift { | ||
55 | CAP_CSS_SHIFT = 37, | ||
56 | CAP_MPSMIN_SHIFT = 48, | ||
57 | CAP_MPSMAX_SHIFT = 52, | ||
58 | + CAP_PMR_SHIFT = 56, | ||
59 | }; | ||
60 | |||
61 | enum NvmeCapMask { | ||
62 | @@ -XXX,XX +XXX,XX @@ enum NvmeCapMask { | ||
63 | CAP_CSS_MASK = 0xff, | ||
64 | CAP_MPSMIN_MASK = 0xf, | ||
65 | CAP_MPSMAX_MASK = 0xf, | ||
66 | + CAP_PMR_MASK = 0x1, | ||
67 | }; | ||
68 | |||
69 | #define NVME_CAP_MQES(cap) (((cap) >> CAP_MQES_SHIFT) & CAP_MQES_MASK) | ||
70 | @@ -XXX,XX +XXX,XX @@ enum NvmeCapMask { | ||
71 | << CAP_MPSMIN_SHIFT) | ||
72 | #define NVME_CAP_SET_MPSMAX(cap, val) (cap |= (uint64_t)(val & CAP_MPSMAX_MASK)\ | ||
73 | << CAP_MPSMAX_SHIFT) | ||
74 | +#define NVME_CAP_SET_PMRS(cap, val) (cap |= (uint64_t)(val & CAP_PMR_MASK)\ | ||
75 | + << CAP_PMR_SHIFT) | ||
76 | |||
77 | enum NvmeCcShift { | ||
78 | CC_EN_SHIFT = 0, | ||
79 | @@ -XXX,XX +XXX,XX @@ enum NvmeCmbszMask { | ||
80 | #define NVME_CMBSZ_GETSIZE(cmbsz) \ | ||
81 | (NVME_CMBSZ_SZ(cmbsz) * (1 << (12 + 4 * NVME_CMBSZ_SZU(cmbsz)))) | ||
82 | |||
83 | +enum NvmePmrcapShift { | ||
84 | + PMRCAP_RDS_SHIFT = 3, | ||
85 | + PMRCAP_WDS_SHIFT = 4, | ||
86 | + PMRCAP_BIR_SHIFT = 5, | ||
87 | + PMRCAP_PMRTU_SHIFT = 8, | ||
88 | + PMRCAP_PMRWBM_SHIFT = 10, | ||
89 | + PMRCAP_PMRTO_SHIFT = 16, | ||
90 | + PMRCAP_CMSS_SHIFT = 24, | ||
91 | +}; | ||
92 | + | ||
93 | +enum NvmePmrcapMask { | ||
94 | + PMRCAP_RDS_MASK = 0x1, | ||
95 | + PMRCAP_WDS_MASK = 0x1, | ||
96 | + PMRCAP_BIR_MASK = 0x7, | ||
97 | + PMRCAP_PMRTU_MASK = 0x3, | ||
98 | + PMRCAP_PMRWBM_MASK = 0xf, | ||
99 | + PMRCAP_PMRTO_MASK = 0xff, | ||
100 | + PMRCAP_CMSS_MASK = 0x1, | ||
101 | +}; | ||
102 | + | ||
103 | +#define NVME_PMRCAP_RDS(pmrcap) \ | ||
104 | + ((pmrcap >> PMRCAP_RDS_SHIFT) & PMRCAP_RDS_MASK) | ||
105 | +#define NVME_PMRCAP_WDS(pmrcap) \ | ||
106 | + ((pmrcap >> PMRCAP_WDS_SHIFT) & PMRCAP_WDS_MASK) | ||
107 | +#define NVME_PMRCAP_BIR(pmrcap) \ | ||
108 | + ((pmrcap >> PMRCAP_BIR_SHIFT) & PMRCAP_BIR_MASK) | ||
109 | +#define NVME_PMRCAP_PMRTU(pmrcap) \ | ||
110 | + ((pmrcap >> PMRCAP_PMRTU_SHIFT) & PMRCAP_PMRTU_MASK) | ||
111 | +#define NVME_PMRCAP_PMRWBM(pmrcap) \ | ||
112 | + ((pmrcap >> PMRCAP_PMRWBM_SHIFT) & PMRCAP_PMRWBM_MASK) | ||
113 | +#define NVME_PMRCAP_PMRTO(pmrcap) \ | ||
114 | + ((pmrcap >> PMRCAP_PMRTO_SHIFT) & PMRCAP_PMRTO_MASK) | ||
115 | +#define NVME_PMRCAP_CMSS(pmrcap) \ | ||
116 | + ((pmrcap >> PMRCAP_CMSS_SHIFT) & PMRCAP_CMSS_MASK) | ||
117 | + | ||
118 | +#define NVME_PMRCAP_SET_RDS(pmrcap, val) \ | ||
119 | + (pmrcap |= (uint64_t)(val & PMRCAP_RDS_MASK) << PMRCAP_RDS_SHIFT) | ||
120 | +#define NVME_PMRCAP_SET_WDS(pmrcap, val) \ | ||
121 | + (pmrcap |= (uint64_t)(val & PMRCAP_WDS_MASK) << PMRCAP_WDS_SHIFT) | ||
122 | +#define NVME_PMRCAP_SET_BIR(pmrcap, val) \ | ||
123 | + (pmrcap |= (uint64_t)(val & PMRCAP_BIR_MASK) << PMRCAP_BIR_SHIFT) | ||
124 | +#define NVME_PMRCAP_SET_PMRTU(pmrcap, val) \ | ||
125 | + (pmrcap |= (uint64_t)(val & PMRCAP_PMRTU_MASK) << PMRCAP_PMRTU_SHIFT) | ||
126 | +#define NVME_PMRCAP_SET_PMRWBM(pmrcap, val) \ | ||
127 | + (pmrcap |= (uint64_t)(val & PMRCAP_PMRWBM_MASK) << PMRCAP_PMRWBM_SHIFT) | ||
128 | +#define NVME_PMRCAP_SET_PMRTO(pmrcap, val) \ | ||
129 | + (pmrcap |= (uint64_t)(val & PMRCAP_PMRTO_MASK) << PMRCAP_PMRTO_SHIFT) | ||
130 | +#define NVME_PMRCAP_SET_CMSS(pmrcap, val) \ | ||
131 | + (pmrcap |= (uint64_t)(val & PMRCAP_CMSS_MASK) << PMRCAP_CMSS_SHIFT) | ||
132 | + | ||
133 | +enum NvmePmrctlShift { | ||
134 | + PMRCTL_EN_SHIFT = 0, | ||
135 | +}; | ||
136 | + | ||
137 | +enum NvmePmrctlMask { | ||
138 | + PMRCTL_EN_MASK = 0x1, | ||
139 | +}; | ||
140 | + | ||
141 | +#define NVME_PMRCTL_EN(pmrctl) ((pmrctl >> PMRCTL_EN_SHIFT) & PMRCTL_EN_MASK) | ||
142 | + | ||
143 | +#define NVME_PMRCTL_SET_EN(pmrctl, val) \ | ||
144 | + (pmrctl |= (uint64_t)(val & PMRCTL_EN_MASK) << PMRCTL_EN_SHIFT) | ||
145 | + | ||
146 | +enum NvmePmrstsShift { | ||
147 | + PMRSTS_ERR_SHIFT = 0, | ||
148 | + PMRSTS_NRDY_SHIFT = 8, | ||
149 | + PMRSTS_HSTS_SHIFT = 9, | ||
150 | + PMRSTS_CBAI_SHIFT = 12, | ||
151 | +}; | ||
152 | + | ||
153 | +enum NvmePmrstsMask { | ||
154 | + PMRSTS_ERR_MASK = 0xff, | ||
155 | + PMRSTS_NRDY_MASK = 0x1, | ||
156 | + PMRSTS_HSTS_MASK = 0x7, | ||
157 | + PMRSTS_CBAI_MASK = 0x1, | ||
158 | +}; | ||
159 | + | ||
160 | +#define NVME_PMRSTS_ERR(pmrsts) \ | ||
161 | + ((pmrsts >> PMRSTS_ERR_SHIFT) & PMRSTS_ERR_MASK) | ||
162 | +#define NVME_PMRSTS_NRDY(pmrsts) \ | ||
163 | + ((pmrsts >> PMRSTS_NRDY_SHIFT) & PMRSTS_NRDY_MASK) | ||
164 | +#define NVME_PMRSTS_HSTS(pmrsts) \ | ||
165 | + ((pmrsts >> PMRSTS_HSTS_SHIFT) & PMRSTS_HSTS_MASK) | ||
166 | +#define NVME_PMRSTS_CBAI(pmrsts) \ | ||
167 | + ((pmrsts >> PMRSTS_CBAI_SHIFT) & PMRSTS_CBAI_MASK) | ||
168 | + | ||
169 | +#define NVME_PMRSTS_SET_ERR(pmrsts, val) \ | ||
170 | + (pmrsts |= (uint64_t)(val & PMRSTS_ERR_MASK) << PMRSTS_ERR_SHIFT) | ||
171 | +#define NVME_PMRSTS_SET_NRDY(pmrsts, val) \ | ||
172 | + (pmrsts |= (uint64_t)(val & PMRSTS_NRDY_MASK) << PMRSTS_NRDY_SHIFT) | ||
173 | +#define NVME_PMRSTS_SET_HSTS(pmrsts, val) \ | ||
174 | + (pmrsts |= (uint64_t)(val & PMRSTS_HSTS_MASK) << PMRSTS_HSTS_SHIFT) | ||
175 | +#define NVME_PMRSTS_SET_CBAI(pmrsts, val) \ | ||
176 | + (pmrsts |= (uint64_t)(val & PMRSTS_CBAI_MASK) << PMRSTS_CBAI_SHIFT) | ||
177 | + | ||
178 | +enum NvmePmrebsShift { | ||
179 | + PMREBS_PMRSZU_SHIFT = 0, | ||
180 | + PMREBS_RBB_SHIFT = 4, | ||
181 | + PMREBS_PMRWBZ_SHIFT = 8, | ||
182 | +}; | ||
183 | + | ||
184 | +enum NvmePmrebsMask { | ||
185 | + PMREBS_PMRSZU_MASK = 0xf, | ||
186 | + PMREBS_RBB_MASK = 0x1, | ||
187 | + PMREBS_PMRWBZ_MASK = 0xffffff, | ||
188 | +}; | ||
189 | + | ||
190 | +#define NVME_PMREBS_PMRSZU(pmrebs) \ | ||
191 | + ((pmrebs >> PMREBS_PMRSZU_SHIFT) & PMREBS_PMRSZU_MASK) | ||
192 | +#define NVME_PMREBS_RBB(pmrebs) \ | ||
193 | + ((pmrebs >> PMREBS_RBB_SHIFT) & PMREBS_RBB_MASK) | ||
194 | +#define NVME_PMREBS_PMRWBZ(pmrebs) \ | ||
195 | + ((pmrebs >> PMREBS_PMRWBZ_SHIFT) & PMREBS_PMRWBZ_MASK) | ||
196 | + | ||
197 | +#define NVME_PMREBS_SET_PMRSZU(pmrebs, val) \ | ||
198 | + (pmrebs |= (uint64_t)(val & PMREBS_PMRSZU_MASK) << PMREBS_PMRSZU_SHIFT) | ||
199 | +#define NVME_PMREBS_SET_RBB(pmrebs, val) \ | ||
200 | + (pmrebs |= (uint64_t)(val & PMREBS_RBB_MASK) << PMREBS_RBB_SHIFT) | ||
201 | +#define NVME_PMREBS_SET_PMRWBZ(pmrebs, val) \ | ||
202 | + (pmrebs |= (uint64_t)(val & PMREBS_PMRWBZ_MASK) << PMREBS_PMRWBZ_SHIFT) | ||
203 | + | ||
204 | +enum NvmePmrswtpShift { | ||
205 | + PMRSWTP_PMRSWTU_SHIFT = 0, | ||
206 | + PMRSWTP_PMRSWTV_SHIFT = 8, | ||
207 | +}; | ||
208 | + | ||
209 | +enum NvmePmrswtpMask { | ||
210 | + PMRSWTP_PMRSWTU_MASK = 0xf, | ||
211 | + PMRSWTP_PMRSWTV_MASK = 0xffffff, | ||
212 | +}; | ||
213 | + | ||
214 | +#define NVME_PMRSWTP_PMRSWTU(pmrswtp) \ | ||
215 | + ((pmrswtp >> PMRSWTP_PMRSWTU_SHIFT) & PMRSWTP_PMRSWTU_MASK) | ||
216 | +#define NVME_PMRSWTP_PMRSWTV(pmrswtp) \ | ||
217 | + ((pmrswtp >> PMRSWTP_PMRSWTV_SHIFT) & PMRSWTP_PMRSWTV_MASK) | ||
218 | + | ||
219 | +#define NVME_PMRSWTP_SET_PMRSWTU(pmrswtp, val) \ | ||
220 | + (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTU_MASK) << PMRSWTP_PMRSWTU_SHIFT) | ||
221 | +#define NVME_PMRSWTP_SET_PMRSWTV(pmrswtp, val) \ | ||
222 | + (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTV_MASK) << PMRSWTP_PMRSWTV_SHIFT) | ||
223 | + | ||
224 | +enum NvmePmrmscShift { | ||
225 | + PMRMSC_CMSE_SHIFT = 1, | ||
226 | + PMRMSC_CBA_SHIFT = 12, | ||
227 | +}; | ||
228 | + | ||
229 | +enum NvmePmrmscMask { | ||
230 | + PMRMSC_CMSE_MASK = 0x1, | ||
231 | + PMRMSC_CBA_MASK = 0xfffffffffffff, | ||
232 | +}; | ||
233 | + | ||
234 | +#define NVME_PMRMSC_CMSE(pmrmsc) \ | ||
235 | + ((pmrmsc >> PMRMSC_CMSE_SHIFT) & PMRMSC_CMSE_MASK) | ||
236 | +#define NVME_PMRMSC_CBA(pmrmsc) \ | ||
237 | + ((pmrmsc >> PMRMSC_CBA_SHIFT) & PMRMSC_CBA_MASK) | ||
238 | + | ||
239 | +#define NVME_PMRMSC_SET_CMSE(pmrmsc, val) \ | ||
240 | + (pmrmsc |= (uint64_t)(val & PMRMSC_CMSE_MASK) << PMRMSC_CMSE_SHIFT) | ||
241 | +#define NVME_PMRMSC_SET_CBA(pmrmsc, val) \ | ||
242 | + (pmrmsc |= (uint64_t)(val & PMRMSC_CBA_MASK) << PMRMSC_CBA_SHIFT) | ||
243 | + | ||
244 | typedef struct NvmeCmd { | ||
245 | uint8_t opcode; | ||
246 | uint8_t fuse; | ||
247 | diff --git a/hw/block/nvme.c b/hw/block/nvme.c | ||
248 | index XXXXXXX..XXXXXXX 100644 | ||
249 | --- a/hw/block/nvme.c | ||
250 | +++ b/hw/block/nvme.c | ||
251 | @@ -XXX,XX +XXX,XX @@ | ||
252 | * -drive file=<file>,if=none,id=<drive_id> | ||
253 | * -device nvme,drive=<drive_id>,serial=<serial>,id=<id[optional]>, \ | ||
254 | * cmb_size_mb=<cmb_size_mb[optional]>, \ | ||
255 | + * [pmrdev=<mem_backend_file_id>,] \ | ||
256 | * num_queues=<N[optional]> | ||
257 | * | ||
258 | * Note cmb_size_mb denotes size of CMB in MB. CMB is assumed to be at | ||
259 | * offset 0 in BAR2 and supports only WDS, RDS and SQS for now. | ||
260 | + * | ||
261 | + * cmb_size_mb= and pmrdev= options are mutually exclusive due to limitation | ||
262 | + * in available BAR's. cmb_size_mb= will take precedence over pmrdev= when | ||
263 | + * both provided. | ||
264 | + * Enabling pmr emulation can be achieved by pointing to memory-backend-file. | ||
265 | + * For example: | ||
266 | + * -object memory-backend-file,id=<mem_id>,share=on,mem-path=<file_path>, \ | ||
267 | + * size=<size> .... -device nvme,...,pmrdev=<mem_id> | ||
268 | */ | ||
269 | |||
270 | #include "qemu/osdep.h" | ||
271 | @@ -XXX,XX +XXX,XX @@ | ||
272 | #include "sysemu/sysemu.h" | ||
273 | #include "qapi/error.h" | ||
274 | #include "qapi/visitor.h" | ||
275 | +#include "sysemu/hostmem.h" | ||
276 | #include "sysemu/block-backend.h" | ||
277 | +#include "exec/ram_addr.h" | ||
278 | |||
279 | #include "qemu/log.h" | ||
280 | #include "qemu/module.h" | ||
281 | @@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data, | ||
282 | NVME_GUEST_ERR(nvme_ub_mmiowr_cmbsz_readonly, | ||
283 | "invalid write to read only CMBSZ, ignored"); | ||
284 | return; | ||
285 | + case 0xE00: /* PMRCAP */ | ||
286 | + NVME_GUEST_ERR(nvme_ub_mmiowr_pmrcap_readonly, | ||
287 | + "invalid write to PMRCAP register, ignored"); | ||
288 | + return; | ||
289 | + case 0xE04: /* TODO PMRCTL */ | ||
290 | + break; | ||
291 | + case 0xE08: /* PMRSTS */ | ||
292 | + NVME_GUEST_ERR(nvme_ub_mmiowr_pmrsts_readonly, | ||
293 | + "invalid write to PMRSTS register, ignored"); | ||
294 | + return; | ||
295 | + case 0xE0C: /* PMREBS */ | ||
296 | + NVME_GUEST_ERR(nvme_ub_mmiowr_pmrebs_readonly, | ||
297 | + "invalid write to PMREBS register, ignored"); | ||
298 | + return; | ||
299 | + case 0xE10: /* PMRSWTP */ | ||
300 | + NVME_GUEST_ERR(nvme_ub_mmiowr_pmrswtp_readonly, | ||
301 | + "invalid write to PMRSWTP register, ignored"); | ||
302 | + return; | ||
303 | + case 0xE14: /* TODO PMRMSC */ | ||
304 | + break; | ||
305 | default: | ||
306 | NVME_GUEST_ERR(nvme_ub_mmiowr_invalid, | ||
307 | "invalid MMIO write," | ||
308 | @@ -XXX,XX +XXX,XX @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size) | ||
22 | } | 309 | } |
23 | 310 | ||
24 | + if (has_replaces) { | 311 | if (addr < sizeof(n->bar)) { |
25 | + BlockDriverState *to_replace_bs; | 312 | + /* |
26 | + AioContext *replace_aio_context; | 313 | + * When PMRWBM bit 1 is set then read from |
27 | + int64_t bs_size, replace_size; | 314 | + * from PMRSTS should ensure prior writes |
28 | + | 315 | + * made it to persistent media |
29 | + bs_size = bdrv_getlength(bs); | 316 | + */ |
30 | + if (bs_size < 0) { | 317 | + if (addr == 0xE08 && |
31 | + error_setg_errno(errp, -bs_size, "Failed to query device's size"); | 318 | + (NVME_PMRCAP_PMRWBM(n->bar.pmrcap) & 0x02)) { |
319 | + qemu_ram_writeback(n->pmrdev->mr.ram_block, | ||
320 | + 0, n->pmrdev->size); | ||
321 | + } | ||
322 | memcpy(&val, ptr + addr, size); | ||
323 | } else { | ||
324 | NVME_GUEST_ERR(nvme_ub_mmiord_invalid_ofs, | ||
325 | @@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp) | ||
326 | error_setg(errp, "serial property not set"); | ||
327 | return; | ||
328 | } | ||
329 | + | ||
330 | + if (!n->cmb_size_mb && n->pmrdev) { | ||
331 | + if (host_memory_backend_is_mapped(n->pmrdev)) { | ||
332 | + char *path = object_get_canonical_path_component(OBJECT(n->pmrdev)); | ||
333 | + error_setg(errp, "can't use already busy memdev: %s", path); | ||
334 | + g_free(path); | ||
32 | + return; | 335 | + return; |
33 | + } | 336 | + } |
34 | + | 337 | + |
35 | + to_replace_bs = check_to_replace_node(bs, replaces, errp); | 338 | + if (!is_power_of_2(n->pmrdev->size)) { |
36 | + if (!to_replace_bs) { | 339 | + error_setg(errp, "pmr backend size needs to be power of 2 in size"); |
37 | + return; | 340 | + return; |
38 | + } | 341 | + } |
39 | + | 342 | + |
40 | + replace_aio_context = bdrv_get_aio_context(to_replace_bs); | 343 | + host_memory_backend_set_mapped(n->pmrdev, true); |
41 | + aio_context_acquire(replace_aio_context); | ||
42 | + replace_size = bdrv_getlength(to_replace_bs); | ||
43 | + aio_context_release(replace_aio_context); | ||
44 | + | ||
45 | + if (replace_size < 0) { | ||
46 | + error_setg_errno(errp, -replace_size, | ||
47 | + "Failed to query the replacement node's size"); | ||
48 | + return; | ||
49 | + } | ||
50 | + if (bs_size != replace_size) { | ||
51 | + error_setg(errp, "cannot replace image with a mirror image of " | ||
52 | + "different size"); | ||
53 | + return; | ||
54 | + } | ||
55 | + } | 344 | + } |
56 | + | 345 | + |
57 | /* pass the node name to replace to mirror start since it's loose coupling | 346 | blkconf_blocksizes(&n->conf); |
58 | * and will allow to check whether the node still exist at mirror completion | 347 | if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk), |
59 | */ | 348 | false, errp)) { |
60 | @@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp) | 349 | @@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp) |
350 | PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 | | ||
351 | PCI_BASE_ADDRESS_MEM_PREFETCH, &n->ctrl_mem); | ||
352 | |||
353 | + } else if (n->pmrdev) { | ||
354 | + /* Controller Capabilities register */ | ||
355 | + NVME_CAP_SET_PMRS(n->bar.cap, 1); | ||
356 | + | ||
357 | + /* PMR Capabities register */ | ||
358 | + n->bar.pmrcap = 0; | ||
359 | + NVME_PMRCAP_SET_RDS(n->bar.pmrcap, 0); | ||
360 | + NVME_PMRCAP_SET_WDS(n->bar.pmrcap, 0); | ||
361 | + NVME_PMRCAP_SET_BIR(n->bar.pmrcap, 2); | ||
362 | + NVME_PMRCAP_SET_PMRTU(n->bar.pmrcap, 0); | ||
363 | + /* Turn on bit 1 support */ | ||
364 | + NVME_PMRCAP_SET_PMRWBM(n->bar.pmrcap, 0x02); | ||
365 | + NVME_PMRCAP_SET_PMRTO(n->bar.pmrcap, 0); | ||
366 | + NVME_PMRCAP_SET_CMSS(n->bar.pmrcap, 0); | ||
367 | + | ||
368 | + /* PMR Control register */ | ||
369 | + n->bar.pmrctl = 0; | ||
370 | + NVME_PMRCTL_SET_EN(n->bar.pmrctl, 0); | ||
371 | + | ||
372 | + /* PMR Status register */ | ||
373 | + n->bar.pmrsts = 0; | ||
374 | + NVME_PMRSTS_SET_ERR(n->bar.pmrsts, 0); | ||
375 | + NVME_PMRSTS_SET_NRDY(n->bar.pmrsts, 0); | ||
376 | + NVME_PMRSTS_SET_HSTS(n->bar.pmrsts, 0); | ||
377 | + NVME_PMRSTS_SET_CBAI(n->bar.pmrsts, 0); | ||
378 | + | ||
379 | + /* PMR Elasticity Buffer Size register */ | ||
380 | + n->bar.pmrebs = 0; | ||
381 | + NVME_PMREBS_SET_PMRSZU(n->bar.pmrebs, 0); | ||
382 | + NVME_PMREBS_SET_RBB(n->bar.pmrebs, 0); | ||
383 | + NVME_PMREBS_SET_PMRWBZ(n->bar.pmrebs, 0); | ||
384 | + | ||
385 | + /* PMR Sustained Write Throughput register */ | ||
386 | + n->bar.pmrswtp = 0; | ||
387 | + NVME_PMRSWTP_SET_PMRSWTU(n->bar.pmrswtp, 0); | ||
388 | + NVME_PMRSWTP_SET_PMRSWTV(n->bar.pmrswtp, 0); | ||
389 | + | ||
390 | + /* PMR Memory Space Control register */ | ||
391 | + n->bar.pmrmsc = 0; | ||
392 | + NVME_PMRMSC_SET_CMSE(n->bar.pmrmsc, 0); | ||
393 | + NVME_PMRMSC_SET_CBA(n->bar.pmrmsc, 0); | ||
394 | + | ||
395 | + pci_register_bar(pci_dev, NVME_PMRCAP_BIR(n->bar.pmrcap), | ||
396 | + PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 | | ||
397 | + PCI_BASE_ADDRESS_MEM_PREFETCH, &n->pmrdev->mr); | ||
61 | } | 398 | } |
62 | 399 | ||
63 | if (arg->has_replaces) { | 400 | for (i = 0; i < n->num_namespaces; i++) { |
64 | - BlockDriverState *to_replace_bs; | 401 | @@ -XXX,XX +XXX,XX @@ static void nvme_exit(PCIDevice *pci_dev) |
65 | - AioContext *replace_aio_context; | 402 | if (n->cmb_size_mb) { |
66 | - int64_t replace_size; | 403 | g_free(n->cmbuf); |
67 | - | ||
68 | if (!arg->has_node_name) { | ||
69 | error_setg(errp, "a node-name must be provided when replacing a" | ||
70 | " named node of the graph"); | ||
71 | goto out; | ||
72 | } | ||
73 | - | ||
74 | - to_replace_bs = check_to_replace_node(bs, arg->replaces, &local_err); | ||
75 | - | ||
76 | - if (!to_replace_bs) { | ||
77 | - error_propagate(errp, local_err); | ||
78 | - goto out; | ||
79 | - } | ||
80 | - | ||
81 | - replace_aio_context = bdrv_get_aio_context(to_replace_bs); | ||
82 | - aio_context_acquire(replace_aio_context); | ||
83 | - replace_size = bdrv_getlength(to_replace_bs); | ||
84 | - aio_context_release(replace_aio_context); | ||
85 | - | ||
86 | - if (size != replace_size) { | ||
87 | - error_setg(errp, "cannot replace image with a mirror image of " | ||
88 | - "different size"); | ||
89 | - goto out; | ||
90 | - } | ||
91 | } | 404 | } |
92 | 405 | + | |
93 | if (arg->mode == NEW_IMAGE_MODE_ABSOLUTE_PATHS) { | 406 | + if (n->pmrdev) { |
407 | + host_memory_backend_set_mapped(n->pmrdev, false); | ||
408 | + } | ||
409 | msix_uninit_exclusive_bar(pci_dev); | ||
410 | } | ||
411 | |||
412 | static Property nvme_props[] = { | ||
413 | DEFINE_BLOCK_PROPERTIES(NvmeCtrl, conf), | ||
414 | + DEFINE_PROP_LINK("pmrdev", NvmeCtrl, pmrdev, TYPE_MEMORY_BACKEND, | ||
415 | + HostMemoryBackend *), | ||
416 | DEFINE_PROP_STRING("serial", NvmeCtrl, serial), | ||
417 | DEFINE_PROP_UINT32("cmb_size_mb", NvmeCtrl, cmb_size_mb, 0), | ||
418 | DEFINE_PROP_UINT32("num_queues", NvmeCtrl, num_queues, 64), | ||
419 | diff --git a/hw/block/Makefile.objs b/hw/block/Makefile.objs | ||
420 | index XXXXXXX..XXXXXXX 100644 | ||
421 | --- a/hw/block/Makefile.objs | ||
422 | +++ b/hw/block/Makefile.objs | ||
423 | @@ -XXX,XX +XXX,XX @@ common-obj-$(CONFIG_PFLASH_CFI02) += pflash_cfi02.o | ||
424 | common-obj-$(CONFIG_XEN) += xen-block.o | ||
425 | common-obj-$(CONFIG_ECC) += ecc.o | ||
426 | common-obj-$(CONFIG_ONENAND) += onenand.o | ||
427 | -common-obj-$(CONFIG_NVME_PCI) += nvme.o | ||
428 | common-obj-$(CONFIG_SWIM) += swim.o | ||
429 | |||
430 | common-obj-$(CONFIG_SH4) += tc58128.o | ||
431 | |||
432 | obj-$(CONFIG_VIRTIO_BLK) += virtio-blk.o | ||
433 | obj-$(CONFIG_VHOST_USER_BLK) += vhost-user-blk.o | ||
434 | +obj-$(CONFIG_NVME_PCI) += nvme.o | ||
435 | |||
436 | obj-y += dataplane/ | ||
437 | diff --git a/hw/block/trace-events b/hw/block/trace-events | ||
438 | index XXXXXXX..XXXXXXX 100644 | ||
439 | --- a/hw/block/trace-events | ||
440 | +++ b/hw/block/trace-events | ||
441 | @@ -XXX,XX +XXX,XX @@ nvme_ub_mmiowr_ssreset_w1c_unsupported(void) "attempted to W1C CSTS.NSSRO but CA | ||
442 | nvme_ub_mmiowr_ssreset_unsupported(void) "attempted NVM subsystem reset but CAP.NSSRS is zero (not supported)" | ||
443 | nvme_ub_mmiowr_cmbloc_reserved(void) "invalid write to reserved CMBLOC when CMBSZ is zero, ignored" | ||
444 | nvme_ub_mmiowr_cmbsz_readonly(void) "invalid write to read only CMBSZ, ignored" | ||
445 | +nvme_ub_mmiowr_pmrcap_readonly(void) "invalid write to read only PMRCAP, ignored" | ||
446 | +nvme_ub_mmiowr_pmrsts_readonly(void) "invalid write to read only PMRSTS, ignored" | ||
447 | +nvme_ub_mmiowr_pmrebs_readonly(void) "invalid write to read only PMREBS, ignored" | ||
448 | +nvme_ub_mmiowr_pmrswtp_readonly(void) "invalid write to read only PMRSWTP, ignored" | ||
449 | nvme_ub_mmiowr_invalid(uint64_t offset, uint64_t data) "invalid MMIO write, offset=0x%"PRIx64", data=0x%"PRIx64"" | ||
450 | nvme_ub_mmiord_misaligned32(uint64_t offset) "MMIO read not 32-bit aligned, offset=0x%"PRIx64"" | ||
451 | nvme_ub_mmiord_toosmall(uint64_t offset) "MMIO read smaller than 32-bits, offset=0x%"PRIx64"" | ||
94 | -- | 452 | -- |
95 | 2.20.1 | 453 | 2.25.3 |
96 | 454 | ||
97 | 455 | diff view generated by jsdifflib |
1 | From: Sergio Lopez <slp@redhat.com> | 1 | The QMP handler qmp_object_add() and the implementation of --object in |
---|---|---|---|
2 | qemu-storage-daemon can share most of the code. Currently, | ||
3 | qemu-storage-daemon calls qmp_object_add(), but this is not correct | ||
4 | because different visitors need to be used. | ||
2 | 5 | ||
3 | While child_job_drained_begin() calls to job_pause(), the job doesn't | 6 | As a first step towards a fix, make qmp_object_add() a wrapper around a |
4 | actually transition between states until it runs again and reaches a | 7 | new function user_creatable_add_dict() that can get an additional |
5 | pause point. This means bdrv_drained_begin() may return with some jobs | 8 | parameter. The handling of "props" is only required for compatibility |
6 | using the node still having 'busy == true'. | 9 | and not required for the qemu-storage-daemon command line, so it stays |
10 | in qmp_object_add(). | ||
7 | 11 | ||
8 | As a consequence, block_job_detach_aio_context() may get into a | ||
9 | deadlock, waiting for the job to be actually paused, while the coroutine | ||
10 | servicing the job is yielding and doesn't get the opportunity to get | ||
11 | scheduled again. This situation can be reproduced by issuing a | ||
12 | 'block-commit' immediately followed by a 'device_del'. | ||
13 | |||
14 | To ensure bdrv_drained_begin() only returns when the jobs have been | ||
15 | paused, we change mirror_drained_poll() to only confirm it's quiesced | ||
16 | when job->paused == true and there aren't any in-flight requests, except | ||
17 | if we reached that point by a drained section initiated by the | ||
18 | mirror/commit job itself. | ||
19 | |||
20 | The other block jobs shouldn't need any changes, as the default | ||
21 | drained_poll() behavior is to only confirm it's quiesced if the job is | ||
22 | not busy or completed. | ||
23 | |||
24 | Signed-off-by: Sergio Lopez <slp@redhat.com> | ||
25 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 12 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
26 | --- | 13 | --- |
27 | block/mirror.c | 16 ++++++++++++++++ | 14 | include/qom/object_interfaces.h | 12 ++++++++++++ |
28 | 1 file changed, 16 insertions(+) | 15 | qom/object_interfaces.c | 27 +++++++++++++++++++++++++++ |
16 | qom/qom-qmp-cmds.c | 24 +----------------------- | ||
17 | 3 files changed, 40 insertions(+), 23 deletions(-) | ||
29 | 18 | ||
30 | diff --git a/block/mirror.c b/block/mirror.c | 19 | diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h |
31 | index XXXXXXX..XXXXXXX 100644 | 20 | index XXXXXXX..XXXXXXX 100644 |
32 | --- a/block/mirror.c | 21 | --- a/include/qom/object_interfaces.h |
33 | +++ b/block/mirror.c | 22 | +++ b/include/qom/object_interfaces.h |
34 | @@ -XXX,XX +XXX,XX @@ typedef struct MirrorBlockJob { | 23 | @@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id, |
35 | bool initial_zeroing_ongoing; | 24 | const QDict *qdict, |
36 | int in_active_write_counter; | 25 | Visitor *v, Error **errp); |
37 | bool prepared; | 26 | |
38 | + bool in_drain; | 27 | +/** |
39 | } MirrorBlockJob; | 28 | + * user_creatable_add_dict: |
40 | 29 | + * @qdict: the object definition | |
41 | typedef struct MirrorBDSOpaque { | 30 | + * @errp: if an error occurs, a pointer to an area to store the error |
42 | @@ -XXX,XX +XXX,XX @@ static int mirror_exit_common(Job *job) | 31 | + * |
43 | 32 | + * Create an instance of the user creatable object that is defined by | |
44 | /* The mirror job has no requests in flight any more, but we need to | 33 | + * @qdict. The object type is taken from the QDict key 'qom-type', its |
45 | * drain potential other users of the BDS before changing the graph. */ | 34 | + * ID from the key 'id'. The remaining entries in @qdict are used to |
46 | + assert(s->in_drain); | 35 | + * initialize the object properties. |
47 | bdrv_drained_begin(target_bs); | 36 | + */ |
48 | bdrv_replace_node(to_replace, target_bs, &local_err); | 37 | +void user_creatable_add_dict(QDict *qdict, Error **errp); |
49 | bdrv_drained_end(target_bs); | 38 | + |
50 | @@ -XXX,XX +XXX,XX @@ static int mirror_exit_common(Job *job) | 39 | /** |
51 | bs_opaque->job = NULL; | 40 | * user_creatable_add_opts: |
52 | 41 | * @opts: the object definition | |
53 | bdrv_drained_end(src); | 42 | diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c |
54 | + s->in_drain = false; | 43 | index XXXXXXX..XXXXXXX 100644 |
55 | bdrv_unref(mirror_top_bs); | 44 | --- a/qom/object_interfaces.c |
56 | bdrv_unref(src); | 45 | +++ b/qom/object_interfaces.c |
57 | 46 | @@ -XXX,XX +XXX,XX @@ | |
58 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp) | 47 | #include "qapi/qmp/qerror.h" |
59 | */ | 48 | #include "qapi/qmp/qjson.h" |
60 | trace_mirror_before_drain(s, cnt); | 49 | #include "qapi/qmp/qstring.h" |
61 | 50 | +#include "qapi/qobject-input-visitor.h" | |
62 | + s->in_drain = true; | 51 | #include "qom/object_interfaces.h" |
63 | bdrv_drained_begin(bs); | 52 | #include "qemu/help_option.h" |
64 | cnt = bdrv_get_dirty_count(s->dirty_bitmap); | 53 | #include "qemu/module.h" |
65 | if (cnt > 0 || mirror_flush(s) < 0) { | 54 | @@ -XXX,XX +XXX,XX @@ out: |
66 | bdrv_drained_end(bs); | 55 | return obj; |
67 | + s->in_drain = false; | 56 | } |
68 | continue; | 57 | |
69 | } | 58 | +void user_creatable_add_dict(QDict *qdict, Error **errp) |
70 | 59 | +{ | |
71 | @@ -XXX,XX +XXX,XX @@ immediate_exit: | 60 | + Visitor *v; |
72 | bdrv_dirty_iter_free(s->dbi); | 61 | + Object *obj; |
73 | 62 | + g_autofree char *type = NULL; | |
74 | if (need_drain) { | 63 | + g_autofree char *id = NULL; |
75 | + s->in_drain = true; | 64 | + |
76 | bdrv_drained_begin(bs); | 65 | + type = g_strdup(qdict_get_try_str(qdict, "qom-type")); |
66 | + if (!type) { | ||
67 | + error_setg(errp, QERR_MISSING_PARAMETER, "qom-type"); | ||
68 | + return; | ||
69 | + } | ||
70 | + qdict_del(qdict, "qom-type"); | ||
71 | + | ||
72 | + id = g_strdup(qdict_get_try_str(qdict, "id")); | ||
73 | + if (!id) { | ||
74 | + error_setg(errp, QERR_MISSING_PARAMETER, "id"); | ||
75 | + return; | ||
76 | + } | ||
77 | + qdict_del(qdict, "id"); | ||
78 | + | ||
79 | + v = qobject_input_visitor_new(QOBJECT(qdict)); | ||
80 | + obj = user_creatable_add_type(type, id, qdict, v, errp); | ||
81 | + visit_free(v); | ||
82 | + object_unref(obj); | ||
83 | +} | ||
84 | |||
85 | Object *user_creatable_add_opts(QemuOpts *opts, Error **errp) | ||
86 | { | ||
87 | diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c | ||
88 | index XXXXXXX..XXXXXXX 100644 | ||
89 | --- a/qom/qom-qmp-cmds.c | ||
90 | +++ b/qom/qom-qmp-cmds.c | ||
91 | @@ -XXX,XX +XXX,XX @@ | ||
92 | #include "qapi/qapi-commands-qom.h" | ||
93 | #include "qapi/qmp/qdict.h" | ||
94 | #include "qapi/qmp/qerror.h" | ||
95 | -#include "qapi/qobject-input-visitor.h" | ||
96 | #include "qemu/cutils.h" | ||
97 | #include "qom/object_interfaces.h" | ||
98 | #include "qom/qom-qobject.h" | ||
99 | @@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp) | ||
100 | { | ||
101 | QObject *props; | ||
102 | QDict *pdict; | ||
103 | - Visitor *v; | ||
104 | - Object *obj; | ||
105 | - g_autofree char *type = NULL; | ||
106 | - g_autofree char *id = NULL; | ||
107 | - | ||
108 | - type = g_strdup(qdict_get_try_str(qdict, "qom-type")); | ||
109 | - if (!type) { | ||
110 | - error_setg(errp, QERR_MISSING_PARAMETER, "qom-type"); | ||
111 | - return; | ||
112 | - } | ||
113 | - qdict_del(qdict, "qom-type"); | ||
114 | - | ||
115 | - id = g_strdup(qdict_get_try_str(qdict, "id")); | ||
116 | - if (!id) { | ||
117 | - error_setg(errp, QERR_MISSING_PARAMETER, "id"); | ||
118 | - return; | ||
119 | - } | ||
120 | - qdict_del(qdict, "id"); | ||
121 | |||
122 | props = qdict_get(qdict, "props"); | ||
123 | if (props) { | ||
124 | @@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp) | ||
125 | qobject_unref(pdict); | ||
77 | } | 126 | } |
78 | 127 | ||
79 | @@ -XXX,XX +XXX,XX @@ static void coroutine_fn mirror_pause(Job *job) | 128 | - v = qobject_input_visitor_new(QOBJECT(qdict)); |
80 | static bool mirror_drained_poll(BlockJob *job) | 129 | - obj = user_creatable_add_type(type, id, qdict, v, errp); |
81 | { | 130 | - visit_free(v); |
82 | MirrorBlockJob *s = container_of(job, MirrorBlockJob, common); | 131 | - object_unref(obj); |
83 | + | 132 | + user_creatable_add_dict(qdict, errp); |
84 | + /* If the job isn't paused nor cancelled, we can't be sure that it won't | ||
85 | + * issue more requests. We make an exception if we've reached this point | ||
86 | + * from one of our own drain sections, to avoid a deadlock waiting for | ||
87 | + * ourselves. | ||
88 | + */ | ||
89 | + if (!s->common.job.paused && !s->common.job.cancelled && !s->in_drain) { | ||
90 | + return true; | ||
91 | + } | ||
92 | + | ||
93 | return !!s->in_flight; | ||
94 | } | 133 | } |
95 | 134 | ||
135 | void qmp_object_del(const char *id, Error **errp) | ||
96 | -- | 136 | -- |
97 | 2.20.1 | 137 | 2.25.3 |
98 | 138 | ||
99 | 139 | diff view generated by jsdifflib |
1 | From: Sergio Lopez <slp@redhat.com> | 1 | After processing the option string with the keyval parser, we get a |
---|---|---|---|
2 | QDict that contains only strings. This QDict must be fed to a keyval | ||
3 | visitor which converts the strings into the right data types. | ||
2 | 4 | ||
3 | There are various actions in this test that must be executed | 5 | qmp_object_add(), however, uses the normal QObject input visitor, which |
4 | sequentially, as the result of it depends on the state triggered by the | 6 | expects a QDict where all properties already have the QType that matches |
5 | previous one. | 7 | the data type required by the QOM object type. |
6 | 8 | ||
7 | If the last argument of _send_qemu_cmd() is an empty string, it just | 9 | Change the --object implementation in qemu-storage-daemon so that it |
8 | sends the QMP commands without waiting for an answer. While unlikely, it | 10 | doesn't call qmp_object_add(), but calls user_creatable_add_dict() |
9 | may happen that the next action in the test gets invoked before QEMU | 11 | directly instead and pass it a new keyval boolean that decides which |
10 | processes the QMP request. | 12 | visitor must be used. |
11 | 13 | ||
12 | This issue seems to be easier to reproduce on servers with limited | 14 | Reported-by: Coiby Xu <coiby.xu@gmail.com> |
13 | resources or highly loaded. | ||
14 | |||
15 | With this change, we wait for an answer on all _send_qemu_cmd() calls. | ||
16 | |||
17 | Signed-off-by: Sergio Lopez <slp@redhat.com> | ||
18 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | 15 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> |
19 | --- | 16 | --- |
20 | tests/qemu-iotests/153 | 12 ++++++------ | 17 | include/qom/object_interfaces.h | 6 +++++- |
21 | tests/qemu-iotests/153.out | 6 ++++++ | 18 | qemu-storage-daemon.c | 4 +--- |
22 | 2 files changed, 12 insertions(+), 6 deletions(-) | 19 | qom/object_interfaces.c | 8 ++++++-- |
20 | qom/qom-qmp-cmds.c | 2 +- | ||
21 | 4 files changed, 13 insertions(+), 7 deletions(-) | ||
23 | 22 | ||
24 | diff --git a/tests/qemu-iotests/153 b/tests/qemu-iotests/153 | 23 | diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h |
25 | index XXXXXXX..XXXXXXX 100755 | ||
26 | --- a/tests/qemu-iotests/153 | ||
27 | +++ b/tests/qemu-iotests/153 | ||
28 | @@ -XXX,XX +XXX,XX @@ for opts1 in "" "read-only=on" "read-only=on,force-share=on"; do | ||
29 | _img_info -U | grep 'file format' | ||
30 | fi | ||
31 | done | ||
32 | - _send_qemu_cmd $h "{ 'execute': 'quit', }" "" | ||
33 | + _send_qemu_cmd $h "{ 'execute': 'quit' }" '' | ||
34 | echo | ||
35 | echo "Round done" | ||
36 | _cleanup_qemu | ||
37 | @@ -XXX,XX +XXX,XX @@ echo "Adding drive" | ||
38 | _send_qemu_cmd $QEMU_HANDLE \ | ||
39 | "{ 'execute': 'human-monitor-command', | ||
40 | 'arguments': { 'command-line': 'drive_add 0 if=none,id=d0,file=${TEST_IMG}' } }" \ | ||
41 | - "" | ||
42 | + 'return' | ||
43 | |||
44 | _run_cmd $QEMU_IO "${TEST_IMG}" -c 'write 0 512' | ||
45 | |||
46 | @@ -XXX,XX +XXX,XX @@ echo "== Closing an image should unlock it ==" | ||
47 | _send_qemu_cmd $QEMU_HANDLE \ | ||
48 | "{ 'execute': 'human-monitor-command', | ||
49 | 'arguments': { 'command-line': 'drive_del d0' } }" \ | ||
50 | - "" | ||
51 | + 'return' | ||
52 | |||
53 | _run_cmd $QEMU_IO "${TEST_IMG}" -c 'write 0 512' | ||
54 | |||
55 | @@ -XXX,XX +XXX,XX @@ for d in d0 d1; do | ||
56 | _send_qemu_cmd $QEMU_HANDLE \ | ||
57 | "{ 'execute': 'human-monitor-command', | ||
58 | 'arguments': { 'command-line': 'drive_add 0 if=none,id=$d,file=${TEST_IMG},readonly=on' } }" \ | ||
59 | - "" | ||
60 | + 'return' | ||
61 | done | ||
62 | |||
63 | _run_cmd $QEMU_IMG info "${TEST_IMG}" | ||
64 | @@ -XXX,XX +XXX,XX @@ _run_cmd $QEMU_IMG info "${TEST_IMG}" | ||
65 | _send_qemu_cmd $QEMU_HANDLE \ | ||
66 | "{ 'execute': 'human-monitor-command', | ||
67 | 'arguments': { 'command-line': 'drive_del d0' } }" \ | ||
68 | - "" | ||
69 | + 'return' | ||
70 | |||
71 | _run_cmd $QEMU_IO "${TEST_IMG}" -c 'write 0 512' | ||
72 | |||
73 | @@ -XXX,XX +XXX,XX @@ echo "Closing the other" | ||
74 | _send_qemu_cmd $QEMU_HANDLE \ | ||
75 | "{ 'execute': 'human-monitor-command', | ||
76 | 'arguments': { 'command-line': 'drive_del d1' } }" \ | ||
77 | - "" | ||
78 | + 'return' | ||
79 | |||
80 | _run_cmd $QEMU_IO "${TEST_IMG}" -c 'write 0 512' | ||
81 | |||
82 | diff --git a/tests/qemu-iotests/153.out b/tests/qemu-iotests/153.out | ||
83 | index XXXXXXX..XXXXXXX 100644 | 24 | index XXXXXXX..XXXXXXX 100644 |
84 | --- a/tests/qemu-iotests/153.out | 25 | --- a/include/qom/object_interfaces.h |
85 | +++ b/tests/qemu-iotests/153.out | 26 | +++ b/include/qom/object_interfaces.h |
86 | @@ -XXX,XX +XXX,XX @@ Is another process using the image [TEST_DIR/t.qcow2]? | 27 | @@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id, |
87 | _qemu_img_wrapper commit -b TEST_DIR/t.qcow2.b TEST_DIR/t.qcow2.c | 28 | /** |
88 | {"return": {}} | 29 | * user_creatable_add_dict: |
89 | Adding drive | 30 | * @qdict: the object definition |
90 | +{"return": "OKrn"} | 31 | + * @keyval: if true, use a keyval visitor for processing @qdict (i.e. |
91 | 32 | + * assume that all @qdict values are strings); otherwise, use | |
92 | _qemu_io_wrapper TEST_DIR/t.qcow2 -c write 0 512 | 33 | + * the normal QObject visitor (i.e. assume all @qdict values |
93 | can't open device TEST_DIR/t.qcow2: Failed to get "write" lock | 34 | + * have the QType expected by the QOM object type) |
94 | @@ -XXX,XX +XXX,XX @@ Creating overlay with qemu-img when the guest is running should be allowed | 35 | * @errp: if an error occurs, a pointer to an area to store the error |
95 | 36 | * | |
96 | _qemu_img_wrapper create -f qcow2 -b TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.overlay | 37 | * Create an instance of the user creatable object that is defined by |
97 | == Closing an image should unlock it == | 38 | @@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id, |
98 | +{"return": ""} | 39 | * ID from the key 'id'. The remaining entries in @qdict are used to |
99 | 40 | * initialize the object properties. | |
100 | _qemu_io_wrapper TEST_DIR/t.qcow2 -c write 0 512 | 41 | */ |
101 | Adding two and closing one | 42 | -void user_creatable_add_dict(QDict *qdict, Error **errp); |
102 | +{"return": "OKrn"} | 43 | +void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp); |
103 | +{"return": "OKrn"} | 44 | |
104 | 45 | /** | |
105 | _qemu_img_wrapper info TEST_DIR/t.qcow2 | 46 | * user_creatable_add_opts: |
106 | +{"return": ""} | 47 | diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c |
107 | 48 | index XXXXXXX..XXXXXXX 100644 | |
108 | _qemu_io_wrapper TEST_DIR/t.qcow2 -c write 0 512 | 49 | --- a/qemu-storage-daemon.c |
109 | can't open device TEST_DIR/t.qcow2: Failed to get "write" lock | 50 | +++ b/qemu-storage-daemon.c |
110 | Is another process using the image [TEST_DIR/t.qcow2]? | 51 | @@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[]) |
111 | Closing the other | 52 | QemuOpts *opts; |
112 | +{"return": ""} | 53 | const char *type; |
113 | 54 | QDict *args; | |
114 | _qemu_io_wrapper TEST_DIR/t.qcow2 -c write 0 512 | 55 | - QObject *ret_data = NULL; |
115 | 56 | ||
57 | /* FIXME The keyval parser rejects 'help' arguments, so we must | ||
58 | * unconditionall try QemuOpts first. */ | ||
59 | @@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[]) | ||
60 | qemu_opts_del(opts); | ||
61 | |||
62 | args = keyval_parse(optarg, "qom-type", &error_fatal); | ||
63 | - qmp_object_add(args, &ret_data, &error_fatal); | ||
64 | + user_creatable_add_dict(args, true, &error_fatal); | ||
65 | qobject_unref(args); | ||
66 | - qobject_unref(ret_data); | ||
67 | break; | ||
68 | } | ||
69 | default: | ||
70 | diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c | ||
71 | index XXXXXXX..XXXXXXX 100644 | ||
72 | --- a/qom/object_interfaces.c | ||
73 | +++ b/qom/object_interfaces.c | ||
74 | @@ -XXX,XX +XXX,XX @@ out: | ||
75 | return obj; | ||
76 | } | ||
77 | |||
78 | -void user_creatable_add_dict(QDict *qdict, Error **errp) | ||
79 | +void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp) | ||
80 | { | ||
81 | Visitor *v; | ||
82 | Object *obj; | ||
83 | @@ -XXX,XX +XXX,XX @@ void user_creatable_add_dict(QDict *qdict, Error **errp) | ||
84 | } | ||
85 | qdict_del(qdict, "id"); | ||
86 | |||
87 | - v = qobject_input_visitor_new(QOBJECT(qdict)); | ||
88 | + if (keyval) { | ||
89 | + v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); | ||
90 | + } else { | ||
91 | + v = qobject_input_visitor_new(QOBJECT(qdict)); | ||
92 | + } | ||
93 | obj = user_creatable_add_type(type, id, qdict, v, errp); | ||
94 | visit_free(v); | ||
95 | object_unref(obj); | ||
96 | diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c | ||
97 | index XXXXXXX..XXXXXXX 100644 | ||
98 | --- a/qom/qom-qmp-cmds.c | ||
99 | +++ b/qom/qom-qmp-cmds.c | ||
100 | @@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp) | ||
101 | qobject_unref(pdict); | ||
102 | } | ||
103 | |||
104 | - user_creatable_add_dict(qdict, errp); | ||
105 | + user_creatable_add_dict(qdict, false, errp); | ||
106 | } | ||
107 | |||
108 | void qmp_object_del(const char *id, Error **errp) | ||
116 | -- | 109 | -- |
117 | 2.20.1 | 110 | 2.25.3 |
118 | 111 | ||
119 | 112 | diff view generated by jsdifflib |