| 1 | The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e: | 1 | The following changes since commit 2ccad61746ca7de5dd3e25146062264387e43bd4: |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20200430' into staging (2020-04-30 14:00:36 +0100) | 3 | Merge tag 'pull-tcg-20221109' of https://gitlab.com/rth7680/qemu into staging (2022-11-09 13:26:45 -0500) |
| 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 | https://repo.or.cz/qemu/kevin.git tags/for-upstream |
| 8 | 8 | ||
| 9 | for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809: | 9 | for you to fetch changes up to 46530d3560b6fd5de38b6f4e45ce7d7135b9add7: |
| 10 | 10 | ||
| 11 | qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200) | 11 | tests/stream-under-throttle: New test (2022-11-14 11:31:52 +0100) |
| 12 | 12 | ||
| 13 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
| 14 | Block layer patches: | 14 | Block layer patches |
| 15 | 15 | ||
| 16 | - Fix resize (extending) of short overlays | 16 | - Fix deadlock in graph modification with iothreads |
| 17 | - nvme: introduce PMR support from NVMe 1.4 spec | 17 | - mirror: Fix non-converging cases for active mirror |
| 18 | - qemu-storage-daemon: Fix non-string --object properties | 18 | - qapi: Fix BlockdevOptionsNvmeIoUring @path description |
| 19 | - blkio: Set BlockDriver::has_variable_length to false | ||
| 19 | 20 | ||
| 20 | ---------------------------------------------------------------- | 21 | ---------------------------------------------------------------- |
| 21 | Alberto Garcia (1): | 22 | Alberto Faria (2): |
| 22 | qcow2: Add incompatibility note between backing files and raw external data files | 23 | qapi/block-core: Fix BlockdevOptionsNvmeIoUring @path description |
| 24 | block/blkio: Set BlockDriver::has_variable_length to false | ||
| 23 | 25 | ||
| 24 | Andrzej Jakowski (1): | 26 | Hanna Reitz (9): |
| 25 | nvme: introduce PMR support from NVMe 1.4 spec | 27 | block/mirror: Do not wait for active writes |
| 28 | block/mirror: Drop mirror_wait_for_any_operation() | ||
| 29 | block/mirror: Fix NULL s->job in active writes | ||
| 30 | iotests/151: Test that active mirror progresses | ||
| 31 | iotests/151: Test active requests on mirror start | ||
| 32 | block: Make bdrv_child_get_parent_aio_context I/O | ||
| 33 | block-backend: Update ctx immediately after root | ||
| 34 | block: Start/end drain on correct AioContext | ||
| 35 | tests/stream-under-throttle: New test | ||
| 26 | 36 | ||
| 27 | Kevin Wolf (12): | 37 | qapi/block-core.json | 2 +- |
| 28 | block: Add flags to BlockDriver.bdrv_co_truncate() | 38 | include/block/block-global-state.h | 1 - |
| 29 | block: Add flags to bdrv(_co)_truncate() | 39 | include/block/block-io.h | 2 + |
| 30 | block-backend: Add flags to blk_truncate() | 40 | include/block/block_int-common.h | 4 +- |
| 31 | qcow2: Support BDRV_REQ_ZERO_WRITE for truncate | 41 | block.c | 2 +- |
| 32 | raw-format: Support BDRV_REQ_ZERO_WRITE for truncate | 42 | block/blkio.c | 1 - |
| 33 | file-posix: Support BDRV_REQ_ZERO_WRITE for truncate | 43 | block/block-backend.c | 9 +- |
| 34 | block: truncate: Don't make backing file data visible | 44 | block/io.c | 6 +- |
| 35 | iotests: Filter testfiles out in filter_img_info() | 45 | block/mirror.c | 78 ++++--- |
| 36 | iotests: Test committing to short backing file | 46 | blockjob.c | 3 +- |
| 37 | qcow2: Forward ZERO_WRITE flag for full preallocation | 47 | tests/qemu-iotests/151 | 227 ++++++++++++++++++++- |
| 38 | qom: Factor out user_creatable_add_dict() | 48 | tests/qemu-iotests/151.out | 4 +- |
| 39 | qemu-storage-daemon: Fix non-string --object properties | 49 | tests/qemu-iotests/tests/stream-under-throttle | 121 +++++++++++ |
| 40 | 50 | tests/qemu-iotests/tests/stream-under-throttle.out | 5 + | |
| 41 | Paolo Bonzini (1): | 51 | 14 files changed, 424 insertions(+), 41 deletions(-) |
| 42 | qemu-iotests: allow qcow2 external discarded clusters to contain stale data | 52 | create mode 100755 tests/qemu-iotests/tests/stream-under-throttle |
| 43 | 53 | create mode 100644 tests/qemu-iotests/tests/stream-under-throttle.out | |
| 44 | docs/interop/qcow2.txt | 3 + | ||
| 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 | ||
| 96 | |||
| 97 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Alberto Garcia <berto@igalia.com> | ||
| 2 | 1 | ||
| 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> | ||
| 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> | ||
| 12 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 13 | --- | ||
| 14 | docs/interop/qcow2.txt | 3 +++ | ||
| 15 | 1 file changed, 3 insertions(+) | ||
| 16 | |||
| 17 | diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt | ||
| 18 | index XXXXXXX..XXXXXXX 100644 | ||
| 19 | --- a/docs/interop/qcow2.txt | ||
| 20 | +++ b/docs/interop/qcow2.txt | ||
| 21 | @@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header: | ||
| 22 | is stored (NB: The string is not null terminated). 0 if the | ||
| 23 | image doesn't have a backing file. | ||
| 24 | |||
| 25 | + Note: backing files are incompatible with raw external data | ||
| 26 | + files (auto-clear feature bit 1). | ||
| 27 | + | ||
| 28 | 16 - 19: backing_file_size | ||
| 29 | Length of the backing file name in bytes. Must not be | ||
| 30 | longer than 1023 bytes. Undefined if the image doesn't have | ||
| 31 | -- | ||
| 32 | 2.25.3 | ||
| 33 | |||
| 34 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Paolo Bonzini <pbonzini@redhat.com> | ||
| 2 | 1 | ||
| 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 |
Deleted patch | |||
|---|---|---|---|
| 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 | 1 | ||
| 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 |
Deleted patch | |||
|---|---|---|---|
| 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(). | ||
| 4 | 1 | ||
| 5 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 6 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
| 7 | Reviewed-by: Alberto Garcia <berto@igalia.com> | ||
| 8 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
| 9 | Message-Id: <20200424125448.63318-3-kwolf@redhat.com> | ||
| 10 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 11 | --- | ||
| 12 | include/block/block.h | 5 +++-- | ||
| 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(-) | ||
| 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 | /* | ||
| 295 | diff --git a/block/vmdk.c b/block/vmdk.c | ||
| 296 | index XXXXXXX..XXXXXXX 100644 | ||
| 297 | --- a/block/vmdk.c | ||
| 298 | +++ b/block/vmdk.c | ||
| 299 | @@ -XXX,XX +XXX,XX @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset, | ||
| 300 | } | ||
| 301 | length = QEMU_ALIGN_UP(length, BDRV_SECTOR_SIZE); | ||
| 302 | ret = bdrv_truncate(s->extents[i].file, length, false, | ||
| 303 | - PREALLOC_MODE_OFF, NULL); | ||
| 304 | + PREALLOC_MODE_OFF, 0, NULL); | ||
| 305 | if (ret < 0) { | ||
| 306 | return ret; | ||
| 307 | } | ||
| 308 | diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c | ||
| 309 | index XXXXXXX..XXXXXXX 100644 | ||
| 310 | --- a/tests/test-block-iothread.c | ||
| 311 | +++ b/tests/test-block-iothread.c | ||
| 312 | @@ -XXX,XX +XXX,XX @@ static void test_sync_op_truncate(BdrvChild *c) | ||
| 313 | int ret; | ||
| 314 | |||
| 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; | ||
| 334 | -- | ||
| 335 | 2.25.3 | ||
| 336 | |||
| 337 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | Now that node level interface bdrv_truncate() supports passing request | ||
| 2 | flags to the block driver, expose this on the BlockBackend level, too. | ||
| 3 | 1 | ||
| 4 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 5 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
| 6 | Reviewed-by: Alberto Garcia <berto@igalia.com> | ||
| 7 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
| 8 | Message-Id: <20200424125448.63318-4-kwolf@redhat.com> | ||
| 9 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 10 | --- | ||
| 11 | include/sysemu/block-backend.h | 2 +- | ||
| 12 | block.c | 3 ++- | ||
| 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); | ||
| 41 | diff --git a/block.c b/block.c | ||
| 42 | index XXXXXXX..XXXXXXX 100644 | ||
| 43 | --- a/block.c | ||
| 44 | +++ b/block.c | ||
| 45 | @@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk, | ||
| 46 | int64_t size; | ||
| 47 | int ret; | ||
| 48 | |||
| 49 | - ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err); | ||
| 50 | + ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0, | ||
| 51 | + &local_err); | ||
| 52 | if (ret < 0 && ret != -ENOTSUP) { | ||
| 53 | error_propagate(errp, local_err); | ||
| 54 | return ret; | ||
| 55 | diff --git a/block/block-backend.c b/block/block-backend.c | ||
| 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) { | ||
| 97 | error_report_err(local_err); | ||
| 98 | diff --git a/block/crypto.c b/block/crypto.c | ||
| 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; | ||
| 275 | -- | ||
| 276 | 2.25.3 | ||
| 277 | |||
| 278 | diff view generated by jsdifflib |
Deleted 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. | ||
| 6 | 1 | ||
| 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 |
Deleted patch | |||
|---|---|---|---|
| 1 | The raw format driver can simply forward the flag and let its bs->file | ||
| 2 | child take care of actually providing the zeros. | ||
| 3 | 1 | ||
| 4 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 5 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
| 6 | Reviewed-by: Eric Blake <eblake@redhat.com> | ||
| 7 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
| 8 | Message-Id: <20200424125448.63318-6-kwolf@redhat.com> | ||
| 9 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 10 | --- | ||
| 11 | block/raw-format.c | 4 +++- | ||
| 12 | 1 file changed, 3 insertions(+), 1 deletion(-) | ||
| 13 | |||
| 14 | diff --git a/block/raw-format.c b/block/raw-format.c | ||
| 15 | index XXXXXXX..XXXXXXX 100644 | ||
| 16 | --- a/block/raw-format.c | ||
| 17 | +++ b/block/raw-format.c | ||
| 18 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset, | ||
| 19 | |||
| 20 | s->size = offset; | ||
| 21 | offset += s->offset; | ||
| 22 | - return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp); | ||
| 23 | + return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp); | ||
| 24 | } | ||
| 25 | |||
| 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); | ||
| 36 | -- | ||
| 37 | 2.25.3 | ||
| 38 | |||
| 39 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 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. | ||
| 3 | 1 | ||
| 4 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 5 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
| 6 | Reviewed-by: Alberto Garcia <berto@igalia.com> | ||
| 7 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
| 8 | Message-Id: <20200424125448.63318-7-kwolf@redhat.com> | ||
| 9 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 10 | --- | ||
| 11 | block/file-posix.c | 4 ++++ | ||
| 12 | 1 file changed, 4 insertions(+) | ||
| 13 | |||
| 14 | diff --git a/block/file-posix.c b/block/file-posix.c | ||
| 15 | index XXXXXXX..XXXXXXX 100644 | ||
| 16 | --- a/block/file-posix.c | ||
| 17 | +++ b/block/file-posix.c | ||
| 18 | @@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options, | ||
| 19 | #endif | ||
| 20 | |||
| 21 | bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK; | ||
| 22 | + if (S_ISREG(st.st_mode)) { | ||
| 23 | + /* When extending regular files, we get zeros from the OS */ | ||
| 24 | + bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE; | ||
| 25 | + } | ||
| 26 | ret = 0; | ||
| 27 | fail: | ||
| 28 | if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) { | ||
| 29 | -- | ||
| 30 | 2.25.3 | ||
| 31 | |||
| 32 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 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. | ||
| 4 | 1 | ||
| 5 | Consider the following scenario where the overlay is shorter than its | ||
| 6 | backing file: | ||
| 7 | |||
| 8 | base.qcow2: AAAAAAAA | ||
| 9 | overlay.qcow2: BBBB | ||
| 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> | ||
| 34 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 35 | --- | ||
| 36 | block/io.c | 25 +++++++++++++++++++++++++ | ||
| 37 | 1 file changed, 25 insertions(+) | ||
| 38 | |||
| 39 | diff --git a/block/io.c b/block/io.c | ||
| 40 | index XXXXXXX..XXXXXXX 100644 | ||
| 41 | --- a/block/io.c | ||
| 42 | +++ b/block/io.c | ||
| 43 | @@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, | ||
| 44 | goto out; | ||
| 45 | } | ||
| 46 | |||
| 47 | + /* | ||
| 48 | + * If the image has a backing file that is large enough that it would | ||
| 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. | ||
| 56 | + */ | ||
| 57 | + if (new_bytes && bs->backing) { | ||
| 58 | + int64_t backing_len; | ||
| 59 | + | ||
| 60 | + backing_len = bdrv_getlength(backing_bs(bs)); | ||
| 61 | + if (backing_len < 0) { | ||
| 62 | + ret = backing_len; | ||
| 63 | + error_setg_errno(errp, -ret, "Could not get backing file size"); | ||
| 64 | + goto out; | ||
| 65 | + } | ||
| 66 | + | ||
| 67 | + if (backing_len > old_size) { | ||
| 68 | + flags |= BDRV_REQ_ZERO_WRITE; | ||
| 69 | + } | ||
| 70 | + } | ||
| 71 | + | ||
| 72 | if (drv->bdrv_co_truncate) { | ||
| 73 | if (flags & ~bs->supported_truncate_flags) { | ||
| 74 | error_setg(errp, "Block driver does not support requested flags"); | ||
| 75 | -- | ||
| 76 | 2.25.3 | ||
| 77 | |||
| 78 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 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. | ||
| 5 | 1 | ||
| 6 | Insert a filter_testfiles() call between both. | ||
| 7 | |||
| 8 | Signed-off-by: Kevin Wolf <kwolf@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> | ||
| 12 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 13 | --- | ||
| 14 | tests/qemu-iotests/iotests.py | 5 +++-- | ||
| 15 | 1 file changed, 3 insertions(+), 2 deletions(-) | ||
| 16 | |||
| 17 | diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py | ||
| 18 | index XXXXXXX..XXXXXXX 100644 | ||
| 19 | --- a/tests/qemu-iotests/iotests.py | ||
| 20 | +++ b/tests/qemu-iotests/iotests.py | ||
| 21 | @@ -XXX,XX +XXX,XX @@ def filter_img_info(output, filename): | ||
| 22 | for line in output.split('\n'): | ||
| 23 | if 'disk size' in line or 'actual-size' in line: | ||
| 24 | continue | ||
| 25 | - line = line.replace(filename, 'TEST_IMG') \ | ||
| 26 | - .replace(imgfmt, 'IMGFMT') | ||
| 27 | + line = line.replace(filename, 'TEST_IMG') | ||
| 28 | + line = filter_testfiles(line) | ||
| 29 | + line = line.replace(imgfmt, 'IMGFMT') | ||
| 30 | line = re.sub('iters: [0-9]+', 'iters: XXX', line) | ||
| 31 | line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line) | ||
| 32 | line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line) | ||
| 33 | -- | ||
| 34 | 2.25.3 | ||
| 35 | |||
| 36 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 2 | Message-Id: <20200424125448.63318-10-kwolf@redhat.com> | ||
| 3 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
| 4 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
| 5 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 6 | --- | ||
| 7 | tests/qemu-iotests/274 | 155 +++++++++++++++++++++ | ||
| 8 | tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++ | ||
| 9 | tests/qemu-iotests/group | 1 + | ||
| 10 | 3 files changed, 424 insertions(+) | ||
| 11 | create mode 100755 tests/qemu-iotests/274 | ||
| 12 | create mode 100644 tests/qemu-iotests/274.out | ||
| 13 | 1 | ||
| 14 | diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274 | ||
| 15 | new file mode 100755 | ||
| 16 | index XXXXXXX..XXXXXXX | ||
| 17 | --- /dev/null | ||
| 18 | +++ b/tests/qemu-iotests/274 | ||
| 19 | @@ -XXX,XX +XXX,XX @@ | ||
| 20 | +#!/usr/bin/env python3 | ||
| 21 | +# | ||
| 22 | +# Copyright (C) 2019 Red Hat, Inc. | ||
| 23 | +# | ||
| 24 | +# This program is free software; you can redistribute it and/or modify | ||
| 25 | +# it under the terms of the GNU General Public License as published by | ||
| 26 | +# the Free Software Foundation; either version 2 of the License, or | ||
| 27 | +# (at your option) any later version. | ||
| 28 | +# | ||
| 29 | +# This program is distributed in the hope that it will be useful, | ||
| 30 | +# but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 31 | +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 32 | +# GNU General Public License for more details. | ||
| 33 | +# | ||
| 34 | +# You should have received a copy of the GNU General Public License | ||
| 35 | +# along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
| 36 | +# | ||
| 37 | +# Creator/Owner: Kevin Wolf <kwolf@redhat.com> | ||
| 38 | +# | ||
| 39 | +# Some tests for short backing files and short overlays | ||
| 40 | + | ||
| 41 | +import iotests | ||
| 42 | + | ||
| 43 | +iotests.verify_image_format(supported_fmts=['qcow2']) | ||
| 44 | +iotests.verify_platform(['linux']) | ||
| 45 | + | ||
| 46 | +size_short = 1 * 1024 * 1024 | ||
| 47 | +size_long = 2 * 1024 * 1024 | ||
| 48 | +size_diff = size_long - size_short | ||
| 49 | + | ||
| 50 | +def create_chain() -> None: | ||
| 51 | + iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, | ||
| 52 | + str(size_long)) | ||
| 53 | + iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid, | ||
| 54 | + str(size_short)) | ||
| 55 | + iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top, | ||
| 56 | + str(size_long)) | ||
| 57 | + | ||
| 58 | + iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base) | ||
| 59 | + | ||
| 60 | +def create_vm() -> iotests.VM: | ||
| 61 | + vm = iotests.VM() | ||
| 62 | + vm.add_blockdev('file,filename=%s,node-name=base-file' % base) | ||
| 63 | + vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt) | ||
| 64 | + vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid) | ||
| 65 | + vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base' | ||
| 66 | + % iotests.imgfmt) | ||
| 67 | + vm.add_drive(top, 'backing=mid,node-name=top') | ||
| 68 | + return vm | ||
| 69 | + | ||
| 70 | +with iotests.FilePath('base') as base, \ | ||
| 71 | + iotests.FilePath('mid') as mid, \ | ||
| 72 | + iotests.FilePath('top') as top: | ||
| 73 | + | ||
| 74 | + iotests.log('== Commit tests ==') | ||
| 75 | + | ||
| 76 | + create_chain() | ||
| 77 | + | ||
| 78 | + iotests.log('=== Check visible data ===') | ||
| 79 | + | ||
| 80 | + iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top) | ||
| 81 | + iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top) | ||
| 82 | + | ||
| 83 | + iotests.log('=== Checking allocation status ===') | ||
| 84 | + | ||
| 85 | + iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short, | ||
| 86 | + '-c', 'alloc %d %d' % (size_short, size_diff), | ||
| 87 | + base) | ||
| 88 | + | ||
| 89 | + iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short, | ||
| 90 | + '-c', 'alloc %d %d' % (size_short, size_diff), | ||
| 91 | + mid) | ||
| 92 | + | ||
| 93 | + iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short, | ||
| 94 | + '-c', 'alloc %d %d' % (size_short, size_diff), | ||
| 95 | + top) | ||
| 96 | + | ||
| 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 | ||
| 176 | new file mode 100644 | ||
| 177 | index XXXXXXX..XXXXXXX | ||
| 178 | --- /dev/null | ||
| 179 | +++ b/tests/qemu-iotests/274.out | ||
| 180 | @@ -XXX,XX +XXX,XX @@ | ||
| 181 | +== Commit tests == | ||
| 182 | +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16 | ||
| 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 | ||
| 185 | + | ||
| 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 | ||
| 187 | + | ||
| 188 | +wrote 2097152/2097152 bytes at offset 0 | ||
| 189 | +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 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"}} | ||
| 285 | +{"return": {}} | ||
| 286 | +{"execute": "job-complete", "arguments": {"id": "job0"}} | ||
| 287 | +{"return": {}} | ||
| 288 | +{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} | ||
| 289 | +{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} | ||
| 290 | +{"execute": "job-dismiss", "arguments": {"id": "job0"}} | ||
| 291 | +{"return": {}} | ||
| 292 | +image: TEST_IMG | ||
| 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 | + | ||
| 449 | diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group | ||
| 450 | index XXXXXXX..XXXXXXX 100644 | ||
| 451 | --- a/tests/qemu-iotests/group | ||
| 452 | +++ b/tests/qemu-iotests/group | ||
| 453 | @@ -XXX,XX +XXX,XX @@ | ||
| 454 | 270 rw backing quick | ||
| 455 | 272 rw | ||
| 456 | 273 backing quick | ||
| 457 | +274 rw backing | ||
| 458 | 277 rw quick | ||
| 459 | 279 rw backing quick | ||
| 460 | 280 rw migration quick | ||
| 461 | -- | ||
| 462 | 2.25.3 | ||
| 463 | |||
| 464 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the | ||
| 2 | image is possibly preallocated and then the zero flag is added to all | ||
| 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 | 1 | ||
| 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. | ||
| 13 | |||
| 14 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 15 | Reviewed-by: Max Reitz <mreitz@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> | ||
| 19 | --- | ||
| 20 | block/qcow2.c | 22 +++++++++++++++++++--- | ||
| 21 | tests/qemu-iotests/274.out | 4 ++-- | ||
| 22 | 2 files changed, 21 insertions(+), 5 deletions(-) | ||
| 23 | |||
| 24 | diff --git a/block/qcow2.c b/block/qcow2.c | ||
| 25 | index XXXXXXX..XXXXXXX 100644 | ||
| 26 | --- a/block/qcow2.c | ||
| 27 | +++ b/block/qcow2.c | ||
| 28 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset, | ||
| 29 | /* Allocate the data area */ | ||
| 30 | new_file_size = allocation_start + | ||
| 31 | nb_new_data_clusters * s->cluster_size; | ||
| 32 | - /* Image file grows, so @exact does not matter */ | ||
| 33 | - ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0, | ||
| 34 | - errp); | ||
| 35 | + /* | ||
| 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 | ||
| 79 | -- | ||
| 80 | 2.25.3 | ||
| 81 | |||
| 82 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Andrzej Jakowski <andrzej.jakowski@linux.intel.com> | ||
| 2 | 1 | ||
| 3 | This patch introduces support for PMR that has been defined as part of NVMe 1.4 | ||
| 4 | spec. User can now specify a pmrdev option that should point to HostMemoryBackend. | ||
| 5 | pmrdev memory region will subsequently be exposed as PCI BAR 2 in emulated NVMe | ||
| 6 | device. Guest OS can perform mmio read and writes to the PMR region that will stay | ||
| 7 | persistent across system reboot. | ||
| 8 | |||
| 9 | Signed-off-by: Andrzej Jakowski <andrzej.jakowski@linux.intel.com> | ||
| 10 | Reviewed-by: Klaus Jensen <k.jensen@samsung.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> | ||
| 14 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 15 | --- | ||
| 16 | hw/block/nvme.h | 2 + | ||
| 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(-) | ||
| 22 | |||
| 23 | diff --git a/hw/block/nvme.h b/hw/block/nvme.h | ||
| 24 | index XXXXXXX..XXXXXXX 100644 | ||
| 25 | --- a/hw/block/nvme.h | ||
| 26 | +++ b/hw/block/nvme.h | ||
| 27 | @@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl { | ||
| 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) | ||
| 309 | } | ||
| 310 | |||
| 311 | if (addr < sizeof(n->bar)) { | ||
| 312 | + /* | ||
| 313 | + * When PMRWBM bit 1 is set then read from | ||
| 314 | + * from PMRSTS should ensure prior writes | ||
| 315 | + * made it to persistent media | ||
| 316 | + */ | ||
| 317 | + if (addr == 0xE08 && | ||
| 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); | ||
| 335 | + return; | ||
| 336 | + } | ||
| 337 | + | ||
| 338 | + if (!is_power_of_2(n->pmrdev->size)) { | ||
| 339 | + error_setg(errp, "pmr backend size needs to be power of 2 in size"); | ||
| 340 | + return; | ||
| 341 | + } | ||
| 342 | + | ||
| 343 | + host_memory_backend_set_mapped(n->pmrdev, true); | ||
| 344 | + } | ||
| 345 | + | ||
| 346 | blkconf_blocksizes(&n->conf); | ||
| 347 | if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk), | ||
| 348 | false, 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); | ||
| 398 | } | ||
| 399 | |||
| 400 | for (i = 0; i < n->num_namespaces; i++) { | ||
| 401 | @@ -XXX,XX +XXX,XX @@ static void nvme_exit(PCIDevice *pci_dev) | ||
| 402 | if (n->cmb_size_mb) { | ||
| 403 | g_free(n->cmbuf); | ||
| 404 | } | ||
| 405 | + | ||
| 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"" | ||
| 452 | -- | ||
| 453 | 2.25.3 | ||
| 454 | |||
| 455 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 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. | ||
| 5 | 1 | ||
| 6 | As a first step towards a fix, make qmp_object_add() a wrapper around a | ||
| 7 | new function user_creatable_add_dict() that can get an additional | ||
| 8 | parameter. The handling of "props" is only required for compatibility | ||
| 9 | and not required for the qemu-storage-daemon command line, so it stays | ||
| 10 | in qmp_object_add(). | ||
| 11 | |||
| 12 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 13 | --- | ||
| 14 | include/qom/object_interfaces.h | 12 ++++++++++++ | ||
| 15 | qom/object_interfaces.c | 27 +++++++++++++++++++++++++++ | ||
| 16 | qom/qom-qmp-cmds.c | 24 +----------------------- | ||
| 17 | 3 files changed, 40 insertions(+), 23 deletions(-) | ||
| 18 | |||
| 19 | diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h | ||
| 20 | index XXXXXXX..XXXXXXX 100644 | ||
| 21 | --- a/include/qom/object_interfaces.h | ||
| 22 | +++ b/include/qom/object_interfaces.h | ||
| 23 | @@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id, | ||
| 24 | const QDict *qdict, | ||
| 25 | Visitor *v, Error **errp); | ||
| 26 | |||
| 27 | +/** | ||
| 28 | + * user_creatable_add_dict: | ||
| 29 | + * @qdict: the object definition | ||
| 30 | + * @errp: if an error occurs, a pointer to an area to store the error | ||
| 31 | + * | ||
| 32 | + * Create an instance of the user creatable object that is defined by | ||
| 33 | + * @qdict. The object type is taken from the QDict key 'qom-type', its | ||
| 34 | + * ID from the key 'id'. The remaining entries in @qdict are used to | ||
| 35 | + * initialize the object properties. | ||
| 36 | + */ | ||
| 37 | +void user_creatable_add_dict(QDict *qdict, Error **errp); | ||
| 38 | + | ||
| 39 | /** | ||
| 40 | * user_creatable_add_opts: | ||
| 41 | * @opts: the object definition | ||
| 42 | diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c | ||
| 43 | index XXXXXXX..XXXXXXX 100644 | ||
| 44 | --- a/qom/object_interfaces.c | ||
| 45 | +++ b/qom/object_interfaces.c | ||
| 46 | @@ -XXX,XX +XXX,XX @@ | ||
| 47 | #include "qapi/qmp/qerror.h" | ||
| 48 | #include "qapi/qmp/qjson.h" | ||
| 49 | #include "qapi/qmp/qstring.h" | ||
| 50 | +#include "qapi/qobject-input-visitor.h" | ||
| 51 | #include "qom/object_interfaces.h" | ||
| 52 | #include "qemu/help_option.h" | ||
| 53 | #include "qemu/module.h" | ||
| 54 | @@ -XXX,XX +XXX,XX @@ out: | ||
| 55 | return obj; | ||
| 56 | } | ||
| 57 | |||
| 58 | +void user_creatable_add_dict(QDict *qdict, Error **errp) | ||
| 59 | +{ | ||
| 60 | + Visitor *v; | ||
| 61 | + Object *obj; | ||
| 62 | + g_autofree char *type = NULL; | ||
| 63 | + g_autofree char *id = NULL; | ||
| 64 | + | ||
| 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); | ||
| 126 | } | ||
| 127 | |||
| 128 | - v = qobject_input_visitor_new(QOBJECT(qdict)); | ||
| 129 | - obj = user_creatable_add_type(type, id, qdict, v, errp); | ||
| 130 | - visit_free(v); | ||
| 131 | - object_unref(obj); | ||
| 132 | + user_creatable_add_dict(qdict, errp); | ||
| 133 | } | ||
| 134 | |||
| 135 | void qmp_object_del(const char *id, Error **errp) | ||
| 136 | -- | ||
| 137 | 2.25.3 | ||
| 138 | |||
| 139 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 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. | ||
| 4 | 1 | ||
| 5 | qmp_object_add(), however, uses the normal QObject input visitor, which | ||
| 6 | expects a QDict where all properties already have the QType that matches | ||
| 7 | the data type required by the QOM object type. | ||
| 8 | |||
| 9 | Change the --object implementation in qemu-storage-daemon so that it | ||
| 10 | doesn't call qmp_object_add(), but calls user_creatable_add_dict() | ||
| 11 | directly instead and pass it a new keyval boolean that decides which | ||
| 12 | visitor must be used. | ||
| 13 | |||
| 14 | Reported-by: Coiby Xu <coiby.xu@gmail.com> | ||
| 15 | Signed-off-by: Kevin Wolf <kwolf@redhat.com> | ||
| 16 | --- | ||
| 17 | include/qom/object_interfaces.h | 6 +++++- | ||
| 18 | qemu-storage-daemon.c | 4 +--- | ||
| 19 | qom/object_interfaces.c | 8 ++++++-- | ||
| 20 | qom/qom-qmp-cmds.c | 2 +- | ||
| 21 | 4 files changed, 13 insertions(+), 7 deletions(-) | ||
| 22 | |||
| 23 | diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h | ||
| 24 | index XXXXXXX..XXXXXXX 100644 | ||
| 25 | --- a/include/qom/object_interfaces.h | ||
| 26 | +++ b/include/qom/object_interfaces.h | ||
| 27 | @@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id, | ||
| 28 | /** | ||
| 29 | * user_creatable_add_dict: | ||
| 30 | * @qdict: the object definition | ||
| 31 | + * @keyval: if true, use a keyval visitor for processing @qdict (i.e. | ||
| 32 | + * assume that all @qdict values are strings); otherwise, use | ||
| 33 | + * the normal QObject visitor (i.e. assume all @qdict values | ||
| 34 | + * have the QType expected by the QOM object type) | ||
| 35 | * @errp: if an error occurs, a pointer to an area to store the error | ||
| 36 | * | ||
| 37 | * Create an instance of the user creatable object that is defined by | ||
| 38 | @@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id, | ||
| 39 | * ID from the key 'id'. The remaining entries in @qdict are used to | ||
| 40 | * initialize the object properties. | ||
| 41 | */ | ||
| 42 | -void user_creatable_add_dict(QDict *qdict, Error **errp); | ||
| 43 | +void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp); | ||
| 44 | |||
| 45 | /** | ||
| 46 | * user_creatable_add_opts: | ||
| 47 | diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c | ||
| 48 | index XXXXXXX..XXXXXXX 100644 | ||
| 49 | --- a/qemu-storage-daemon.c | ||
| 50 | +++ b/qemu-storage-daemon.c | ||
| 51 | @@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[]) | ||
| 52 | QemuOpts *opts; | ||
| 53 | const char *type; | ||
| 54 | QDict *args; | ||
| 55 | - QObject *ret_data = NULL; | ||
| 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) | ||
| 109 | -- | ||
| 110 | 2.25.3 | ||
| 111 | |||
| 112 | diff view generated by jsdifflib |