| 1 | The following changes since commit 23919ddfd56135cad3cb468a8f54d5a595f024f4: | 1 | The following changes since commit 9af638cc1f665712522608c5d6b8c03d8fa67666: |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Merge remote-tracking branch 'remotes/aperard/tags/pull-xen-20190827' into staging (2019-08-27 15:52:36 +0100) | 3 | Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200504' into staging (2020-05-04 13:37:17 +0100) |
| 4 | 4 | ||
| 5 | are available in the Git repository at: | 5 | are available in the Git repository at: |
| 6 | 6 | ||
| 7 | https://github.com/XanClic/qemu.git tags/pull-block-2019-08-27 | 7 | https://github.com/stefanha/qemu.git tags/block-pull-request |
| 8 | 8 | ||
| 9 | for you to fetch changes up to bb043c056cffcc2f3ce88bfdaf2e76e455c09e2c: | 9 | for you to fetch changes up to 08b689aa6b521964b8275dd7a2564aefa5d68129: |
| 10 | 10 | ||
| 11 | iotests: Unify cache mode quoting (2019-08-27 19:48:44 +0200) | 11 | lockable: Replace locks with lock guard macros (2020-05-04 16:07:43 +0100) |
| 12 | 12 | ||
| 13 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
| 14 | Block patches: | 14 | Pull request |
| 15 | - qemu-io now accepts a file to read a write pattern from | 15 | |
| 16 | - Ensure that raw files have their first block allocated so we can probe | 16 | v2: |
| 17 | the O_DIRECT alignment if necessary | 17 | * Fixed stray slirp submodule change [Peter] |
| 18 | - Various fixes | 18 | |
| 19 | Fixes for the lock guard macros, code conversions to the lock guard macros, and | ||
| 20 | support for selecting fuzzer targets with argv[0]. | ||
| 19 | 21 | ||
| 20 | ---------------------------------------------------------------- | 22 | ---------------------------------------------------------------- |
| 21 | Denis Plotnikov (1): | ||
| 22 | qemu-io: add pattern file for write command | ||
| 23 | 23 | ||
| 24 | Max Reitz (7): | 24 | Alexander Bulekov (1): |
| 25 | iotests: Fix _filter_img_create() | 25 | fuzz: select fuzz target using executable name |
| 26 | vmdk: Use bdrv_dirname() for relative extent paths | ||
| 27 | iotests: Keep testing broken relative extent paths | ||
| 28 | vmdk: Reject invalid compressed writes | ||
| 29 | iotests: Disable broken streamOptimized tests | ||
| 30 | iotests: Disable 110 for vmdk.twoGbMaxExtentSparse | ||
| 31 | iotests: Disable 126 for flat vmdk subformats | ||
| 32 | 26 | ||
| 33 | Nir Soffer (3): | 27 | Daniel Brodsky (2): |
| 34 | block: posix: Always allocate the first block | 28 | lockable: fix __COUNTER__ macro to be referenced properly |
| 35 | iotests: Test allocate_first_block() with O_DIRECT | 29 | lockable: replaced locks with lock guard macros where appropriate |
| 36 | iotests: Unify cache mode quoting | ||
| 37 | 30 | ||
| 38 | Stefan Hajnoczi (1): | 31 | Simran Singhal (1): |
| 39 | file-posix: fix request_alignment typo | 32 | lockable: Replace locks with lock guard macros |
| 40 | 33 | ||
| 41 | Thomas Huth (2): | 34 | include/qemu/lockable.h | 7 +++--- |
| 42 | iotests: Check for enabled drivers before testing them | 35 | include/qemu/rcu.h | 2 +- |
| 43 | tests/check-block: Skip iotests when sanitizers are enabled | 36 | block/iscsi.c | 7 ++---- |
| 44 | 37 | block/nfs.c | 51 +++++++++++++++++++---------------------- | |
| 45 | Vladimir Sementsov-Ogievskiy (1): | 38 | cpus-common.c | 14 ++++------- |
| 46 | block: fix permission update in bdrv_replace_node | 39 | hw/display/qxl.c | 43 ++++++++++++++++------------------ |
| 47 | 40 | hw/hyperv/hyperv.c | 15 ++++++------ | |
| 48 | block.c | 5 +- | 41 | hw/rdma/rdma_backend.c | 50 ++++++++++++++++++++-------------------- |
| 49 | block/file-posix.c | 53 +++++++++- | 42 | hw/rdma/rdma_rm.c | 3 +-- |
| 50 | block/vmdk.c | 64 ++++++++---- | 43 | hw/vfio/platform.c | 5 ++-- |
| 51 | qemu-io-cmds.c | 99 +++++++++++++++++-- | 44 | migration/migration.c | 3 +-- |
| 52 | tests/check-block.sh | 5 + | 45 | migration/multifd.c | 8 +++---- |
| 53 | tests/qemu-iotests/002 | 1 + | 46 | migration/ram.c | 3 +-- |
| 54 | tests/qemu-iotests/003 | 1 + | 47 | monitor/misc.c | 4 +--- |
| 55 | tests/qemu-iotests/005 | 3 +- | 48 | tests/qtest/fuzz/fuzz.c | 19 ++++++++------- |
| 56 | tests/qemu-iotests/009 | 1 + | 49 | ui/spice-display.c | 14 +++++------ |
| 57 | tests/qemu-iotests/010 | 1 + | 50 | util/log.c | 4 ++-- |
| 58 | tests/qemu-iotests/011 | 1 + | 51 | util/qemu-timer.c | 17 +++++++------- |
| 59 | tests/qemu-iotests/017 | 3 +- | 52 | util/rcu.c | 8 +++---- |
| 60 | tests/qemu-iotests/018 | 3 +- | 53 | util/thread-pool.c | 3 +-- |
| 61 | tests/qemu-iotests/019 | 3 +- | 54 | util/vfio-helpers.c | 5 ++-- |
| 62 | tests/qemu-iotests/020 | 3 +- | 55 | 21 files changed, 132 insertions(+), 153 deletions(-) |
| 63 | tests/qemu-iotests/026 | 4 +- | ||
| 64 | tests/qemu-iotests/027 | 1 + | ||
| 65 | tests/qemu-iotests/032 | 1 + | ||
| 66 | tests/qemu-iotests/033 | 1 + | ||
| 67 | tests/qemu-iotests/034 | 3 +- | ||
| 68 | tests/qemu-iotests/037 | 3 +- | ||
| 69 | tests/qemu-iotests/039 | 4 +- | ||
| 70 | tests/qemu-iotests/052 | 2 +- | ||
| 71 | tests/qemu-iotests/059 | 34 ++++++- | ||
| 72 | tests/qemu-iotests/059.out | 26 +++-- | ||
| 73 | tests/qemu-iotests/063 | 3 +- | ||
| 74 | tests/qemu-iotests/071 | 1 + | ||
| 75 | tests/qemu-iotests/072 | 1 + | ||
| 76 | tests/qemu-iotests/081 | 4 +- | ||
| 77 | tests/qemu-iotests/091 | 4 +- | ||
| 78 | tests/qemu-iotests/099 | 1 + | ||
| 79 | tests/qemu-iotests/105 | 3 +- | ||
| 80 | tests/qemu-iotests/110 | 3 +- | ||
| 81 | tests/qemu-iotests/120 | 1 + | ||
| 82 | tests/qemu-iotests/126 | 2 + | ||
| 83 | tests/qemu-iotests/{150.out => 150.out.qcow2} | 0 | ||
| 84 | tests/qemu-iotests/150.out.raw | 12 +++ | ||
| 85 | tests/qemu-iotests/162 | 4 +- | ||
| 86 | tests/qemu-iotests/175 | 47 +++++++-- | ||
| 87 | tests/qemu-iotests/175.out | 16 ++- | ||
| 88 | tests/qemu-iotests/178.out.qcow2 | 4 +- | ||
| 89 | tests/qemu-iotests/184 | 1 + | ||
| 90 | tests/qemu-iotests/186 | 1 + | ||
| 91 | tests/qemu-iotests/197 | 1 + | ||
| 92 | tests/qemu-iotests/215 | 1 + | ||
| 93 | tests/qemu-iotests/221.out | 12 ++- | ||
| 94 | tests/qemu-iotests/251 | 1 + | ||
| 95 | tests/qemu-iotests/253.out | 12 ++- | ||
| 96 | tests/qemu-iotests/common.filter | 4 +- | ||
| 97 | tests/qemu-iotests/common.rc | 14 +++ | ||
| 98 | 50 files changed, 391 insertions(+), 87 deletions(-) | ||
| 99 | rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%) | ||
| 100 | create mode 100644 tests/qemu-iotests/150.out.raw | ||
| 101 | 56 | ||
| 102 | -- | 57 | -- |
| 103 | 2.21.0 | 58 | 2.25.3 |
| 104 | 59 | ||
| 105 | diff view generated by jsdifflib |
| 1 | From: Denis Plotnikov <dplotnikov@virtuozzo.com> | 1 | From: Alexander Bulekov <alxndr@bu.edu> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | The patch allows to provide a pattern file for write | 3 | The fuzzers are built into a binary (e.g. qemu-fuzz-i386). To select the |
| 4 | command. There was no similar ability before. | 4 | device to fuzz/fuzz target, we usually use the --fuzz-target= argument. |
| 5 | This commit allows the fuzz-target to be specified using the name of the | ||
| 6 | executable. If the executable name ends with -target-FUZZ_TARGET, then | ||
| 7 | we select the fuzz target based on this name, rather than the | ||
| 8 | --fuzz-target argument. This is useful for systems such as oss-fuzz | ||
| 9 | where we don't have control of the arguments passed to the fuzzer. | ||
| 5 | 10 | ||
| 6 | Signed-off-by: Denis Plotnikov <dplotnikov@virtuozzo.com> | 11 | [Fixed incorrect indentation. |
| 7 | Message-id: 20190820164616.4072-1-dplotnikov@virtuozzo.com | 12 | --Stefan] |
| 8 | Reviewed-by: Eric Blake <eblake@redhat.com> | 13 | |
| 9 | [mreitz: Keep optstring in alphabetical order] | 14 | Signed-off-by: Alexander Bulekov <alxndr@bu.edu> |
| 10 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 15 | Reviewed-by: Darren Kenny <darren.kenny@oracle.com> |
| 16 | Message-id: 20200421182230.6313-1-alxndr@bu.edu | ||
| 17 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
| 11 | --- | 18 | --- |
| 12 | qemu-io-cmds.c | 99 +++++++++++++++++++++++++++++++++++++++++++++++--- | 19 | tests/qtest/fuzz/fuzz.c | 19 +++++++++++-------- |
| 13 | 1 file changed, 93 insertions(+), 6 deletions(-) | 20 | 1 file changed, 11 insertions(+), 8 deletions(-) |
| 14 | 21 | ||
| 15 | diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c | 22 | diff --git a/tests/qtest/fuzz/fuzz.c b/tests/qtest/fuzz/fuzz.c |
| 16 | index XXXXXXX..XXXXXXX 100644 | 23 | index XXXXXXX..XXXXXXX 100644 |
| 17 | --- a/qemu-io-cmds.c | 24 | --- a/tests/qtest/fuzz/fuzz.c |
| 18 | +++ b/qemu-io-cmds.c | 25 | +++ b/tests/qtest/fuzz/fuzz.c |
| 19 | @@ -XXX,XX +XXX,XX @@ static void qemu_io_free(void *p) | 26 | @@ -XXX,XX +XXX,XX @@ static void usage(char *path) |
| 20 | qemu_vfree(p); | 27 | printf(" * %s : %s\n", tmp->target->name, |
| 28 | tmp->target->description); | ||
| 29 | } | ||
| 30 | + printf("Alternatively, add -target-FUZZ_TARGET to the executable name\n"); | ||
| 31 | exit(0); | ||
| 21 | } | 32 | } |
| 22 | 33 | ||
| 23 | +/* | 34 | @@ -XXX,XX +XXX,XX @@ int LLVMFuzzerInitialize(int *argc, char ***argv, char ***envp) |
| 24 | + * qemu_io_alloc_from_file() | 35 | module_call_init(MODULE_INIT_QOM); |
| 25 | + * | 36 | module_call_init(MODULE_INIT_LIBQOS); |
| 26 | + * Allocates the buffer and populates it with the content of the given file | 37 | |
| 27 | + * up to @len bytes. If the file length is less than @len, then the buffer | 38 | - if (*argc <= 1) { |
| 28 | + * is populated with the file content cyclically. | 39 | + target_name = strstr(**argv, "-target-"); |
| 29 | + * | 40 | + if (target_name) { /* The binary name specifies the target */ |
| 30 | + * @blk - the block backend where the buffer content is going to be written to | 41 | + target_name += strlen("-target-"); |
| 31 | + * @len - the buffer length | 42 | + } else if (*argc > 1) { /* The target is specified as an argument */ |
| 32 | + * @file_name - the file to read the content from | 43 | + target_name = (*argv)[1]; |
| 33 | + * | 44 | + if (!strstr(target_name, "--fuzz-target=")) { |
| 34 | + * Returns: the buffer pointer on success | 45 | + usage(**argv); |
| 35 | + * NULL on error | ||
| 36 | + */ | ||
| 37 | +static void *qemu_io_alloc_from_file(BlockBackend *blk, size_t len, | ||
| 38 | + const char *file_name) | ||
| 39 | +{ | ||
| 40 | + char *buf, *buf_origin; | ||
| 41 | + FILE *f = fopen(file_name, "r"); | ||
| 42 | + int pattern_len; | ||
| 43 | + | ||
| 44 | + if (!f) { | ||
| 45 | + perror(file_name); | ||
| 46 | + return NULL; | ||
| 47 | + } | ||
| 48 | + | ||
| 49 | + if (qemuio_misalign) { | ||
| 50 | + len += MISALIGN_OFFSET; | ||
| 51 | + } | ||
| 52 | + | ||
| 53 | + buf_origin = buf = blk_blockalign(blk, len); | ||
| 54 | + | ||
| 55 | + if (qemuio_misalign) { | ||
| 56 | + buf_origin += MISALIGN_OFFSET; | ||
| 57 | + buf += MISALIGN_OFFSET; | ||
| 58 | + len -= MISALIGN_OFFSET; | ||
| 59 | + } | ||
| 60 | + | ||
| 61 | + pattern_len = fread(buf_origin, 1, len, f); | ||
| 62 | + | ||
| 63 | + if (ferror(f)) { | ||
| 64 | + perror(file_name); | ||
| 65 | + goto error; | ||
| 66 | + } | ||
| 67 | + | ||
| 68 | + if (pattern_len == 0) { | ||
| 69 | + fprintf(stderr, "%s: file is empty\n", file_name); | ||
| 70 | + goto error; | ||
| 71 | + } | ||
| 72 | + | ||
| 73 | + fclose(f); | ||
| 74 | + | ||
| 75 | + if (len > pattern_len) { | ||
| 76 | + len -= pattern_len; | ||
| 77 | + buf += pattern_len; | ||
| 78 | + | ||
| 79 | + while (len > 0) { | ||
| 80 | + size_t len_to_copy = MIN(pattern_len, len); | ||
| 81 | + | ||
| 82 | + memcpy(buf, buf_origin, len_to_copy); | ||
| 83 | + | ||
| 84 | + len -= len_to_copy; | ||
| 85 | + buf += len_to_copy; | ||
| 86 | + } | 46 | + } |
| 87 | + } | 47 | + target_name += strlen("--fuzz-target="); |
| 88 | + | 48 | + } else { |
| 89 | + return buf_origin; | 49 | usage(**argv); |
| 90 | + | ||
| 91 | +error: | ||
| 92 | + qemu_io_free(buf_origin); | ||
| 93 | + return NULL; | ||
| 94 | +} | ||
| 95 | + | ||
| 96 | static void dump_buffer(const void *buffer, int64_t offset, int64_t len) | ||
| 97 | { | ||
| 98 | uint64_t i; | ||
| 99 | @@ -XXX,XX +XXX,XX @@ static void write_help(void) | ||
| 100 | " -n, -- with -z, don't allow slow fallback\n" | ||
| 101 | " -p, -- ignored for backwards compatibility\n" | ||
| 102 | " -P, -- use different pattern to fill file\n" | ||
| 103 | +" -s, -- use a pattern file to fill the write buffer\n" | ||
| 104 | " -C, -- report statistics in a machine parsable format\n" | ||
| 105 | " -q, -- quiet mode, do not show I/O statistics\n" | ||
| 106 | " -u, -- with -z, allow unmapping\n" | ||
| 107 | @@ -XXX,XX +XXX,XX @@ static const cmdinfo_t write_cmd = { | ||
| 108 | .perm = BLK_PERM_WRITE, | ||
| 109 | .argmin = 2, | ||
| 110 | .argmax = -1, | ||
| 111 | - .args = "[-bcCfnquz] [-P pattern] off len", | ||
| 112 | + .args = "[-bcCfnquz] [-P pattern | -s source_file] off len", | ||
| 113 | .oneline = "writes a number of bytes at a specified offset", | ||
| 114 | .help = write_help, | ||
| 115 | }; | ||
| 116 | @@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv) | ||
| 117 | { | ||
| 118 | struct timespec t1, t2; | ||
| 119 | bool Cflag = false, qflag = false, bflag = false; | ||
| 120 | - bool Pflag = false, zflag = false, cflag = false; | ||
| 121 | + bool Pflag = false, zflag = false, cflag = false, sflag = false; | ||
| 122 | int flags = 0; | ||
| 123 | int c, cnt, ret; | ||
| 124 | char *buf = NULL; | ||
| 125 | @@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv) | ||
| 126 | /* Some compilers get confused and warn if this is not initialized. */ | ||
| 127 | int64_t total = 0; | ||
| 128 | int pattern = 0xcd; | ||
| 129 | + const char *file_name = NULL; | ||
| 130 | |||
| 131 | - while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) { | ||
| 132 | + while ((c = getopt(argc, argv, "bcCfnpP:qs:uz")) != -1) { | ||
| 133 | switch (c) { | ||
| 134 | case 'b': | ||
| 135 | bflag = true; | ||
| 136 | @@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv) | ||
| 137 | case 'q': | ||
| 138 | qflag = true; | ||
| 139 | break; | ||
| 140 | + case 's': | ||
| 141 | + sflag = true; | ||
| 142 | + file_name = optarg; | ||
| 143 | + break; | ||
| 144 | case 'u': | ||
| 145 | flags |= BDRV_REQ_MAY_UNMAP; | ||
| 146 | break; | ||
| 147 | @@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv) | ||
| 148 | return -EINVAL; | ||
| 149 | } | 50 | } |
| 150 | 51 | ||
| 151 | - if (zflag && Pflag) { | 52 | /* Identify the fuzz target */ |
| 152 | - printf("-z and -P cannot be specified at the same time\n"); | 53 | - target_name = (*argv)[1]; |
| 153 | + if (zflag + Pflag + sflag > 1) { | 54 | - if (!strstr(target_name, "--fuzz-target=")) { |
| 154 | + printf("Only one of -z, -P, and -s " | 55 | - usage(**argv); |
| 155 | + "can be specified at the same time\n"); | 56 | - } |
| 156 | return -EINVAL; | 57 | - |
| 157 | } | 58 | - target_name += strlen("--fuzz-target="); |
| 158 | 59 | - | |
| 159 | @@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv) | 60 | fuzz_target = fuzz_get_target(target_name); |
| 160 | } | 61 | if (!fuzz_target) { |
| 161 | 62 | usage(**argv); | |
| 162 | if (!zflag) { | ||
| 163 | - buf = qemu_io_alloc(blk, count, pattern); | ||
| 164 | + if (sflag) { | ||
| 165 | + buf = qemu_io_alloc_from_file(blk, count, file_name); | ||
| 166 | + if (!buf) { | ||
| 167 | + return -EINVAL; | ||
| 168 | + } | ||
| 169 | + } else { | ||
| 170 | + buf = qemu_io_alloc(blk, count, pattern); | ||
| 171 | + } | ||
| 172 | } | ||
| 173 | |||
| 174 | clock_gettime(CLOCK_MONOTONIC, &t1); | ||
| 175 | -- | 63 | -- |
| 176 | 2.21.0 | 64 | 2.25.3 |
| 177 | 65 | ||
| 178 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
| 2 | 1 | ||
| 3 | It's wrong to OR shared permissions. It may lead to crash on further | ||
| 4 | permission updates. | ||
| 5 | Also, no needs to consider previously calculated permissions, as at | ||
| 6 | this point we already bind all new parents and bdrv_get_cumulative_perm | ||
| 7 | result is enough. So fix the bug by just set permissions by | ||
| 8 | bdrv_get_cumulative_perm result. | ||
| 9 | |||
| 10 | Bug was introduced in long ago 234ac1a9025, in 2.9. | ||
| 11 | |||
| 12 | Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
| 13 | Message-id: 20190824100740.61635-1-vsementsov@virtuozzo.com | ||
| 14 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 15 | --- | ||
| 16 | block.c | 5 ++--- | ||
| 17 | 1 file changed, 2 insertions(+), 3 deletions(-) | ||
| 18 | |||
| 19 | diff --git a/block.c b/block.c | ||
| 20 | index XXXXXXX..XXXXXXX 100644 | ||
| 21 | --- a/block.c | ||
| 22 | +++ b/block.c | ||
| 23 | @@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to, | ||
| 24 | { | ||
| 25 | BdrvChild *c, *next; | ||
| 26 | GSList *list = NULL, *p; | ||
| 27 | - uint64_t old_perm, old_shared; | ||
| 28 | uint64_t perm = 0, shared = BLK_PERM_ALL; | ||
| 29 | int ret; | ||
| 30 | |||
| 31 | @@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to, | ||
| 32 | bdrv_unref(from); | ||
| 33 | } | ||
| 34 | |||
| 35 | - bdrv_get_cumulative_perm(to, &old_perm, &old_shared); | ||
| 36 | - bdrv_set_perm(to, old_perm | perm, old_shared | shared); | ||
| 37 | + bdrv_get_cumulative_perm(to, &perm, &shared); | ||
| 38 | + bdrv_set_perm(to, perm, shared); | ||
| 39 | |||
| 40 | out: | ||
| 41 | g_slist_free(list); | ||
| 42 | -- | ||
| 43 | 2.21.0 | ||
| 44 | |||
| 45 | diff view generated by jsdifflib |
| 1 | From: Nir Soffer <nirsof@gmail.com> | 1 | From: Daniel Brodsky <dnbrdsky@gmail.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Quoting cache mode is not needed, and most tests use unquoted values. | 3 | - __COUNTER__ doesn't work with ## concat |
| 4 | Unify all test to use the same style. | 4 | - replaced ## with glue() macro so __COUNTER__ is evaluated |
| 5 | 5 | ||
| 6 | Message-id: 20190827173432.7656-1-nsoffer@redhat.com | 6 | Fixes: 3284c3ddc4 |
| 7 | Signed-off-by: Nir Soffer <nsoffer@redhat.com> | 7 | |
| 8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 8 | Signed-off-by: Daniel Brodsky <dnbrdsky@gmail.com> |
| 9 | Message-id: 20200404042108.389635-2-dnbrdsky@gmail.com | ||
| 10 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
| 9 | --- | 11 | --- |
| 10 | tests/qemu-iotests/026 | 4 ++-- | 12 | include/qemu/lockable.h | 7 ++++--- |
| 11 | tests/qemu-iotests/039 | 4 ++-- | 13 | include/qemu/rcu.h | 2 +- |
| 12 | tests/qemu-iotests/052 | 2 +- | 14 | 2 files changed, 5 insertions(+), 4 deletions(-) |
| 13 | tests/qemu-iotests/091 | 4 ++-- | ||
| 14 | 4 files changed, 7 insertions(+), 7 deletions(-) | ||
| 15 | 15 | ||
| 16 | diff --git a/tests/qemu-iotests/026 b/tests/qemu-iotests/026 | 16 | diff --git a/include/qemu/lockable.h b/include/qemu/lockable.h |
| 17 | index XXXXXXX..XXXXXXX 100755 | 17 | index XXXXXXX..XXXXXXX 100644 |
| 18 | --- a/tests/qemu-iotests/026 | 18 | --- a/include/qemu/lockable.h |
| 19 | +++ b/tests/qemu-iotests/026 | 19 | +++ b/include/qemu/lockable.h |
| 20 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | 20 | @@ -XXX,XX +XXX,XX @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(QemuLockable, qemu_lockable_auto_unlock) |
| 21 | # Currently only qcow2 supports rebasing | 21 | * } |
| 22 | _supported_fmt qcow2 | 22 | */ |
| 23 | _supported_proto file | 23 | #define WITH_QEMU_LOCK_GUARD(x) \ |
| 24 | -_default_cache_mode "writethrough" | 24 | - WITH_QEMU_LOCK_GUARD_((x), qemu_lockable_auto##__COUNTER__) |
| 25 | -_supported_cache_modes "writethrough" "none" | 25 | + WITH_QEMU_LOCK_GUARD_((x), glue(qemu_lockable_auto, __COUNTER__)) |
| 26 | +_default_cache_mode writethrough | 26 | |
| 27 | +_supported_cache_modes writethrough none | 27 | /** |
| 28 | # The refcount table tests expect a certain minimum width for refcount entries | 28 | * QEMU_LOCK_GUARD - Lock an object until the end of the scope |
| 29 | # (so that the refcount table actually needs to grow); that minimum is 16 bits, | 29 | @@ -XXX,XX +XXX,XX @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(QemuLockable, qemu_lockable_auto_unlock) |
| 30 | # being the default refcount entry width. | 30 | * return; <-- mutex is automatically unlocked |
| 31 | diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039 | 31 | * } |
| 32 | index XXXXXXX..XXXXXXX 100755 | 32 | */ |
| 33 | --- a/tests/qemu-iotests/039 | 33 | -#define QEMU_LOCK_GUARD(x) \ |
| 34 | +++ b/tests/qemu-iotests/039 | 34 | - g_autoptr(QemuLockable) qemu_lockable_auto##__COUNTER__ = \ |
| 35 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | 35 | +#define QEMU_LOCK_GUARD(x) \ |
| 36 | _supported_fmt qcow2 | 36 | + g_autoptr(QemuLockable) \ |
| 37 | _supported_proto file | 37 | + glue(qemu_lockable_auto, __COUNTER__) G_GNUC_UNUSED = \ |
| 38 | _supported_os Linux | 38 | qemu_lockable_auto_lock(QEMU_MAKE_LOCKABLE((x))) |
| 39 | -_default_cache_mode "writethrough" | 39 | |
| 40 | -_supported_cache_modes "writethrough" | 40 | #endif |
| 41 | +_default_cache_mode writethrough | 41 | diff --git a/include/qemu/rcu.h b/include/qemu/rcu.h |
| 42 | +_supported_cache_modes writethrough | 42 | index XXXXXXX..XXXXXXX 100644 |
| 43 | 43 | --- a/include/qemu/rcu.h | |
| 44 | size=128M | 44 | +++ b/include/qemu/rcu.h |
| 45 | 45 | @@ -XXX,XX +XXX,XX @@ static inline void rcu_read_auto_unlock(RCUReadAuto *r) | |
| 46 | diff --git a/tests/qemu-iotests/052 b/tests/qemu-iotests/052 | 46 | G_DEFINE_AUTOPTR_CLEANUP_FUNC(RCUReadAuto, rcu_read_auto_unlock) |
| 47 | index XXXXXXX..XXXXXXX 100755 | 47 | |
| 48 | --- a/tests/qemu-iotests/052 | 48 | #define WITH_RCU_READ_LOCK_GUARD() \ |
| 49 | +++ b/tests/qemu-iotests/052 | 49 | - WITH_RCU_READ_LOCK_GUARD_(_rcu_read_auto##__COUNTER__) |
| 50 | @@ -XXX,XX +XXX,XX @@ _supported_fmt generic | 50 | + WITH_RCU_READ_LOCK_GUARD_(glue(_rcu_read_auto, __COUNTER__)) |
| 51 | _supported_proto file | 51 | |
| 52 | 52 | #define WITH_RCU_READ_LOCK_GUARD_(var) \ | |
| 53 | # Don't do O_DIRECT on tmpfs | 53 | for (g_autoptr(RCUReadAuto) var = rcu_read_auto_lock(); \ |
| 54 | -_supported_cache_modes "writeback" "writethrough" "unsafe" | ||
| 55 | +_supported_cache_modes writeback writethrough unsafe | ||
| 56 | |||
| 57 | size=128M | ||
| 58 | _make_test_img $size | ||
| 59 | diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091 | ||
| 60 | index XXXXXXX..XXXXXXX 100755 | ||
| 61 | --- a/tests/qemu-iotests/091 | ||
| 62 | +++ b/tests/qemu-iotests/091 | ||
| 63 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 64 | _supported_fmt qcow2 | ||
| 65 | _supported_proto file | ||
| 66 | _supported_os Linux | ||
| 67 | -_default_cache_mode "none" | ||
| 68 | -_supported_cache_modes "writethrough" "none" "writeback" | ||
| 69 | +_default_cache_mode none | ||
| 70 | +_supported_cache_modes writethrough none writeback | ||
| 71 | |||
| 72 | size=1G | ||
| 73 | |||
| 74 | -- | 54 | -- |
| 75 | 2.21.0 | 55 | 2.25.3 |
| 76 | 56 | ||
| 77 | diff view generated by jsdifflib |
| 1 | This makes iotest 033 pass with e.g. subformat=monolithicFlat. It also | 1 | From: Daniel Brodsky <dnbrdsky@gmail.com> |
|---|---|---|---|
| 2 | turns a former error in 059 into success. | ||
| 3 | 2 | ||
| 4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 3 | - ran regexp "qemu_mutex_lock\(.*\).*\n.*if" to find targets |
| 5 | Message-id: 20190815153638.4600-3-mreitz@redhat.com | 4 | - replaced result with QEMU_LOCK_GUARD if all unlocks at function end |
| 6 | Reviewed-by: John Snow <jsnow@redhat.com> | 5 | - replaced result with WITH_QEMU_LOCK_GUARD if unlock not at end |
| 7 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 6 | |
| 7 | Signed-off-by: Daniel Brodsky <dnbrdsky@gmail.com> | ||
| 8 | Reviewed-by: Juan Quintela <quintela@redhat.com> | ||
| 9 | Message-id: 20200404042108.389635-3-dnbrdsky@gmail.com | ||
| 10 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
| 8 | --- | 11 | --- |
| 9 | block/vmdk.c | 54 ++++++++++++++++++++++++-------------- | 12 | block/iscsi.c | 7 ++---- |
| 10 | tests/qemu-iotests/059 | 7 +++-- | 13 | block/nfs.c | 51 ++++++++++++++++++++----------------------- |
| 11 | tests/qemu-iotests/059.out | 4 ++- | 14 | cpus-common.c | 14 +++++------- |
| 12 | 3 files changed, 42 insertions(+), 23 deletions(-) | 15 | hw/display/qxl.c | 43 +++++++++++++++++------------------- |
| 16 | hw/vfio/platform.c | 5 ++--- | ||
| 17 | migration/migration.c | 3 +-- | ||
| 18 | migration/multifd.c | 8 +++---- | ||
| 19 | migration/ram.c | 3 +-- | ||
| 20 | monitor/misc.c | 4 +--- | ||
| 21 | ui/spice-display.c | 14 ++++++------ | ||
| 22 | util/log.c | 4 ++-- | ||
| 23 | util/qemu-timer.c | 17 +++++++-------- | ||
| 24 | util/rcu.c | 8 +++---- | ||
| 25 | util/thread-pool.c | 3 +-- | ||
| 26 | util/vfio-helpers.c | 5 ++--- | ||
| 27 | 15 files changed, 83 insertions(+), 106 deletions(-) | ||
| 13 | 28 | ||
| 14 | diff --git a/block/vmdk.c b/block/vmdk.c | 29 | diff --git a/block/iscsi.c b/block/iscsi.c |
| 15 | index XXXXXXX..XXXXXXX 100644 | 30 | index XXXXXXX..XXXXXXX 100644 |
| 16 | --- a/block/vmdk.c | 31 | --- a/block/iscsi.c |
| 17 | +++ b/block/vmdk.c | 32 | +++ b/block/iscsi.c |
| 18 | @@ -XXX,XX +XXX,XX @@ static const char *next_line(const char *s) | 33 | @@ -XXX,XX +XXX,XX @@ static void iscsi_nop_timed_event(void *opaque) |
| 19 | } | ||
| 20 | |||
| 21 | static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, | ||
| 22 | - const char *desc_file_path, QDict *options, | ||
| 23 | - Error **errp) | ||
| 24 | + QDict *options, Error **errp) | ||
| 25 | { | 34 | { |
| 26 | int ret; | 35 | IscsiLun *iscsilun = opaque; |
| 27 | int matches; | 36 | |
| 28 | @@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, | 37 | - qemu_mutex_lock(&iscsilun->mutex); |
| 29 | const char *p, *np; | 38 | + QEMU_LOCK_GUARD(&iscsilun->mutex); |
| 30 | int64_t sectors = 0; | 39 | if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) { |
| 31 | int64_t flat_offset; | 40 | error_report("iSCSI: NOP timeout. Reconnecting..."); |
| 32 | + char *desc_file_dir = NULL; | 41 | iscsilun->request_timed_out = true; |
| 33 | char *extent_path; | 42 | } else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) { |
| 34 | BdrvChild *extent_file; | 43 | error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages."); |
| 35 | BDRVVmdkState *s = bs->opaque; | 44 | - goto out; |
| 36 | @@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, | 45 | + return; |
| 37 | continue; | 46 | } |
| 38 | } | 47 | |
| 39 | 48 | timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL); | |
| 40 | - if (!path_is_absolute(fname) && !path_has_protocol(fname) && | 49 | iscsi_set_events(iscsilun); |
| 41 | - !desc_file_path[0]) | 50 | - |
| 42 | - { | 51 | -out: |
| 43 | - bdrv_refresh_filename(bs->file->bs); | 52 | - qemu_mutex_unlock(&iscsilun->mutex); |
| 44 | - error_setg(errp, "Cannot use relative extent paths with VMDK " | 53 | } |
| 45 | - "descriptor file '%s'", bs->file->bs->filename); | 54 | |
| 46 | - return -EINVAL; | 55 | static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp) |
| 47 | - } | 56 | diff --git a/block/nfs.c b/block/nfs.c |
| 48 | + if (path_is_absolute(fname)) { | 57 | index XXXXXXX..XXXXXXX 100644 |
| 49 | + extent_path = g_strdup(fname); | 58 | --- a/block/nfs.c |
| 50 | + } else { | 59 | +++ b/block/nfs.c |
| 51 | + if (!desc_file_dir) { | 60 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, uint64_t offset, |
| 52 | + desc_file_dir = bdrv_dirname(bs->file->bs, errp); | 61 | nfs_co_init_task(bs, &task); |
| 53 | + if (!desc_file_dir) { | 62 | task.iov = iov; |
| 54 | + bdrv_refresh_filename(bs->file->bs); | 63 | |
| 55 | + error_prepend(errp, "Cannot use relative paths with VMDK " | 64 | - qemu_mutex_lock(&client->mutex); |
| 56 | + "descriptor file '%s': ", | 65 | - if (nfs_pread_async(client->context, client->fh, |
| 57 | + bs->file->bs->filename); | 66 | - offset, bytes, nfs_co_generic_cb, &task) != 0) { |
| 58 | + ret = -EINVAL; | 67 | - qemu_mutex_unlock(&client->mutex); |
| 59 | + goto out; | 68 | - return -ENOMEM; |
| 69 | - } | ||
| 70 | + WITH_QEMU_LOCK_GUARD(&client->mutex) { | ||
| 71 | + if (nfs_pread_async(client->context, client->fh, | ||
| 72 | + offset, bytes, nfs_co_generic_cb, &task) != 0) { | ||
| 73 | + return -ENOMEM; | ||
| 74 | + } | ||
| 75 | |||
| 76 | - nfs_set_events(client); | ||
| 77 | - qemu_mutex_unlock(&client->mutex); | ||
| 78 | + nfs_set_events(client); | ||
| 79 | + } | ||
| 80 | while (!task.complete) { | ||
| 81 | qemu_coroutine_yield(); | ||
| 82 | } | ||
| 83 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, uint64_t offset, | ||
| 84 | buf = iov->iov[0].iov_base; | ||
| 85 | } | ||
| 86 | |||
| 87 | - qemu_mutex_lock(&client->mutex); | ||
| 88 | - if (nfs_pwrite_async(client->context, client->fh, | ||
| 89 | - offset, bytes, buf, | ||
| 90 | - nfs_co_generic_cb, &task) != 0) { | ||
| 91 | - qemu_mutex_unlock(&client->mutex); | ||
| 92 | - if (my_buffer) { | ||
| 93 | - g_free(buf); | ||
| 94 | + WITH_QEMU_LOCK_GUARD(&client->mutex) { | ||
| 95 | + if (nfs_pwrite_async(client->context, client->fh, | ||
| 96 | + offset, bytes, buf, | ||
| 97 | + nfs_co_generic_cb, &task) != 0) { | ||
| 98 | + if (my_buffer) { | ||
| 99 | + g_free(buf); | ||
| 100 | + } | ||
| 101 | + return -ENOMEM; | ||
| 102 | } | ||
| 103 | - return -ENOMEM; | ||
| 104 | - } | ||
| 105 | |||
| 106 | - nfs_set_events(client); | ||
| 107 | - qemu_mutex_unlock(&client->mutex); | ||
| 108 | + nfs_set_events(client); | ||
| 109 | + } | ||
| 110 | while (!task.complete) { | ||
| 111 | qemu_coroutine_yield(); | ||
| 112 | } | ||
| 113 | @@ -XXX,XX +XXX,XX @@ static int coroutine_fn nfs_co_flush(BlockDriverState *bs) | ||
| 114 | |||
| 115 | nfs_co_init_task(bs, &task); | ||
| 116 | |||
| 117 | - qemu_mutex_lock(&client->mutex); | ||
| 118 | - if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb, | ||
| 119 | - &task) != 0) { | ||
| 120 | - qemu_mutex_unlock(&client->mutex); | ||
| 121 | - return -ENOMEM; | ||
| 122 | - } | ||
| 123 | + WITH_QEMU_LOCK_GUARD(&client->mutex) { | ||
| 124 | + if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb, | ||
| 125 | + &task) != 0) { | ||
| 126 | + return -ENOMEM; | ||
| 127 | + } | ||
| 128 | |||
| 129 | - nfs_set_events(client); | ||
| 130 | - qemu_mutex_unlock(&client->mutex); | ||
| 131 | + nfs_set_events(client); | ||
| 132 | + } | ||
| 133 | while (!task.complete) { | ||
| 134 | qemu_coroutine_yield(); | ||
| 135 | } | ||
| 136 | diff --git a/cpus-common.c b/cpus-common.c | ||
| 137 | index XXXXXXX..XXXXXXX 100644 | ||
| 138 | --- a/cpus-common.c | ||
| 139 | +++ b/cpus-common.c | ||
| 140 | @@ -XXX,XX +XXX,XX @@ | ||
| 141 | #include "exec/cpu-common.h" | ||
| 142 | #include "hw/core/cpu.h" | ||
| 143 | #include "sysemu/cpus.h" | ||
| 144 | +#include "qemu/lockable.h" | ||
| 145 | |||
| 146 | static QemuMutex qemu_cpu_list_lock; | ||
| 147 | static QemuCond exclusive_cond; | ||
| 148 | @@ -XXX,XX +XXX,XX @@ static int cpu_get_free_index(void) | ||
| 149 | |||
| 150 | void cpu_list_add(CPUState *cpu) | ||
| 151 | { | ||
| 152 | - qemu_mutex_lock(&qemu_cpu_list_lock); | ||
| 153 | + QEMU_LOCK_GUARD(&qemu_cpu_list_lock); | ||
| 154 | if (cpu->cpu_index == UNASSIGNED_CPU_INDEX) { | ||
| 155 | cpu->cpu_index = cpu_get_free_index(); | ||
| 156 | assert(cpu->cpu_index != UNASSIGNED_CPU_INDEX); | ||
| 157 | @@ -XXX,XX +XXX,XX @@ void cpu_list_add(CPUState *cpu) | ||
| 158 | assert(!cpu_index_auto_assigned); | ||
| 159 | } | ||
| 160 | QTAILQ_INSERT_TAIL_RCU(&cpus, cpu, node); | ||
| 161 | - qemu_mutex_unlock(&qemu_cpu_list_lock); | ||
| 162 | } | ||
| 163 | |||
| 164 | void cpu_list_remove(CPUState *cpu) | ||
| 165 | { | ||
| 166 | - qemu_mutex_lock(&qemu_cpu_list_lock); | ||
| 167 | + QEMU_LOCK_GUARD(&qemu_cpu_list_lock); | ||
| 168 | if (!QTAILQ_IN_USE(cpu, node)) { | ||
| 169 | /* there is nothing to undo since cpu_exec_init() hasn't been called */ | ||
| 170 | - qemu_mutex_unlock(&qemu_cpu_list_lock); | ||
| 171 | return; | ||
| 172 | } | ||
| 173 | |||
| 174 | @@ -XXX,XX +XXX,XX @@ void cpu_list_remove(CPUState *cpu) | ||
| 175 | |||
| 176 | QTAILQ_REMOVE_RCU(&cpus, cpu, node); | ||
| 177 | cpu->cpu_index = UNASSIGNED_CPU_INDEX; | ||
| 178 | - qemu_mutex_unlock(&qemu_cpu_list_lock); | ||
| 179 | } | ||
| 180 | |||
| 181 | struct qemu_work_item { | ||
| 182 | @@ -XXX,XX +XXX,XX @@ void cpu_exec_start(CPUState *cpu) | ||
| 183 | * see cpu->running == true, and it will kick the CPU. | ||
| 184 | */ | ||
| 185 | if (unlikely(atomic_read(&pending_cpus))) { | ||
| 186 | - qemu_mutex_lock(&qemu_cpu_list_lock); | ||
| 187 | + QEMU_LOCK_GUARD(&qemu_cpu_list_lock); | ||
| 188 | if (!cpu->has_waiter) { | ||
| 189 | /* Not counted in pending_cpus, let the exclusive item | ||
| 190 | * run. Since we have the lock, just set cpu->running to true | ||
| 191 | @@ -XXX,XX +XXX,XX @@ void cpu_exec_start(CPUState *cpu) | ||
| 192 | * waiter at cpu_exec_end. | ||
| 193 | */ | ||
| 194 | } | ||
| 195 | - qemu_mutex_unlock(&qemu_cpu_list_lock); | ||
| 196 | } | ||
| 197 | } | ||
| 198 | |||
| 199 | @@ -XXX,XX +XXX,XX @@ void cpu_exec_end(CPUState *cpu) | ||
| 200 | * next cpu_exec_start. | ||
| 201 | */ | ||
| 202 | if (unlikely(atomic_read(&pending_cpus))) { | ||
| 203 | - qemu_mutex_lock(&qemu_cpu_list_lock); | ||
| 204 | + QEMU_LOCK_GUARD(&qemu_cpu_list_lock); | ||
| 205 | if (cpu->has_waiter) { | ||
| 206 | cpu->has_waiter = false; | ||
| 207 | atomic_set(&pending_cpus, pending_cpus - 1); | ||
| 208 | @@ -XXX,XX +XXX,XX @@ void cpu_exec_end(CPUState *cpu) | ||
| 209 | qemu_cond_signal(&exclusive_cond); | ||
| 210 | } | ||
| 211 | } | ||
| 212 | - qemu_mutex_unlock(&qemu_cpu_list_lock); | ||
| 213 | } | ||
| 214 | } | ||
| 215 | |||
| 216 | diff --git a/hw/display/qxl.c b/hw/display/qxl.c | ||
| 217 | index XXXXXXX..XXXXXXX 100644 | ||
| 218 | --- a/hw/display/qxl.c | ||
| 219 | +++ b/hw/display/qxl.c | ||
| 220 | @@ -XXX,XX +XXX,XX @@ static int qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext) | ||
| 221 | cmd->u.surface_create.stride); | ||
| 222 | return 1; | ||
| 223 | } | ||
| 224 | - qemu_mutex_lock(&qxl->track_lock); | ||
| 225 | - if (cmd->type == QXL_SURFACE_CMD_CREATE) { | ||
| 226 | - qxl->guest_surfaces.cmds[id] = ext->cmd.data; | ||
| 227 | - qxl->guest_surfaces.count++; | ||
| 228 | - if (qxl->guest_surfaces.max < qxl->guest_surfaces.count) | ||
| 229 | - qxl->guest_surfaces.max = qxl->guest_surfaces.count; | ||
| 230 | + WITH_QEMU_LOCK_GUARD(&qxl->track_lock) { | ||
| 231 | + if (cmd->type == QXL_SURFACE_CMD_CREATE) { | ||
| 232 | + qxl->guest_surfaces.cmds[id] = ext->cmd.data; | ||
| 233 | + qxl->guest_surfaces.count++; | ||
| 234 | + if (qxl->guest_surfaces.max < qxl->guest_surfaces.count) { | ||
| 235 | + qxl->guest_surfaces.max = qxl->guest_surfaces.count; | ||
| 60 | + } | 236 | + } |
| 61 | + } | 237 | + } |
| 62 | 238 | + if (cmd->type == QXL_SURFACE_CMD_DESTROY) { | |
| 63 | - extent_path = path_combine(desc_file_path, fname); | 239 | + qxl->guest_surfaces.cmds[id] = 0; |
| 64 | + extent_path = g_strconcat(desc_file_dir, fname, NULL); | 240 | + qxl->guest_surfaces.count--; |
| 241 | + } | ||
| 242 | } | ||
| 243 | - if (cmd->type == QXL_SURFACE_CMD_DESTROY) { | ||
| 244 | - qxl->guest_surfaces.cmds[id] = 0; | ||
| 245 | - qxl->guest_surfaces.count--; | ||
| 246 | - } | ||
| 247 | - qemu_mutex_unlock(&qxl->track_lock); | ||
| 248 | break; | ||
| 249 | } | ||
| 250 | case QXL_CMD_CURSOR: | ||
| 251 | @@ -XXX,XX +XXX,XX @@ static void interface_update_area_complete(QXLInstance *sin, | ||
| 252 | int i; | ||
| 253 | int qxl_i; | ||
| 254 | |||
| 255 | - qemu_mutex_lock(&qxl->ssd.lock); | ||
| 256 | + QEMU_LOCK_GUARD(&qxl->ssd.lock); | ||
| 257 | if (surface_id != 0 || !num_updated_rects || | ||
| 258 | !qxl->render_update_cookie_num) { | ||
| 259 | - qemu_mutex_unlock(&qxl->ssd.lock); | ||
| 260 | return; | ||
| 261 | } | ||
| 262 | trace_qxl_interface_update_area_complete(qxl->id, surface_id, dirty->left, | ||
| 263 | @@ -XXX,XX +XXX,XX @@ static void interface_update_area_complete(QXLInstance *sin, | ||
| 264 | * Don't bother copying or scheduling the bh since we will flip | ||
| 265 | * the whole area anyway on completion of the update_area async call | ||
| 266 | */ | ||
| 267 | - qemu_mutex_unlock(&qxl->ssd.lock); | ||
| 268 | return; | ||
| 269 | } | ||
| 270 | qxl_i = qxl->num_dirty_rects; | ||
| 271 | @@ -XXX,XX +XXX,XX @@ static void interface_update_area_complete(QXLInstance *sin, | ||
| 272 | trace_qxl_interface_update_area_complete_schedule_bh(qxl->id, | ||
| 273 | qxl->num_dirty_rects); | ||
| 274 | qemu_bh_schedule(qxl->update_area_bh); | ||
| 275 | - qemu_mutex_unlock(&qxl->ssd.lock); | ||
| 276 | } | ||
| 277 | |||
| 278 | /* called from spice server thread context only */ | ||
| 279 | @@ -XXX,XX +XXX,XX @@ static void ioport_write(void *opaque, hwaddr addr, | ||
| 280 | case QXL_IO_MONITORS_CONFIG_ASYNC: | ||
| 281 | async_common: | ||
| 282 | async = QXL_ASYNC; | ||
| 283 | - qemu_mutex_lock(&d->async_lock); | ||
| 284 | - if (d->current_async != QXL_UNDEFINED_IO) { | ||
| 285 | - qxl_set_guest_bug(d, "%d async started before last (%d) complete", | ||
| 286 | - io_port, d->current_async); | ||
| 287 | - qemu_mutex_unlock(&d->async_lock); | ||
| 288 | - return; | ||
| 289 | + WITH_QEMU_LOCK_GUARD(&d->async_lock) { | ||
| 290 | + if (d->current_async != QXL_UNDEFINED_IO) { | ||
| 291 | + qxl_set_guest_bug(d, "%d async started before last (%d) complete", | ||
| 292 | + io_port, d->current_async); | ||
| 293 | + return; | ||
| 294 | + } | ||
| 295 | + d->current_async = orig_io_port; | ||
| 296 | } | ||
| 297 | - d->current_async = orig_io_port; | ||
| 298 | - qemu_mutex_unlock(&d->async_lock); | ||
| 299 | break; | ||
| 300 | default: | ||
| 301 | break; | ||
| 302 | diff --git a/hw/vfio/platform.c b/hw/vfio/platform.c | ||
| 303 | index XXXXXXX..XXXXXXX 100644 | ||
| 304 | --- a/hw/vfio/platform.c | ||
| 305 | +++ b/hw/vfio/platform.c | ||
| 306 | @@ -XXX,XX +XXX,XX @@ | ||
| 307 | #include "hw/vfio/vfio-platform.h" | ||
| 308 | #include "migration/vmstate.h" | ||
| 309 | #include "qemu/error-report.h" | ||
| 310 | +#include "qemu/lockable.h" | ||
| 311 | #include "qemu/main-loop.h" | ||
| 312 | #include "qemu/module.h" | ||
| 313 | #include "qemu/range.h" | ||
| 314 | @@ -XXX,XX +XXX,XX @@ static void vfio_intp_interrupt(VFIOINTp *intp) | ||
| 315 | VFIOPlatformDevice *vdev = intp->vdev; | ||
| 316 | bool delay_handling = false; | ||
| 317 | |||
| 318 | - qemu_mutex_lock(&vdev->intp_mutex); | ||
| 319 | + QEMU_LOCK_GUARD(&vdev->intp_mutex); | ||
| 320 | if (intp->state == VFIO_IRQ_INACTIVE) { | ||
| 321 | QLIST_FOREACH(tmp, &vdev->intp_list, next) { | ||
| 322 | if (tmp->state == VFIO_IRQ_ACTIVE || | ||
| 323 | @@ -XXX,XX +XXX,XX @@ static void vfio_intp_interrupt(VFIOINTp *intp) | ||
| 324 | QSIMPLEQ_INSERT_TAIL(&vdev->pending_intp_queue, | ||
| 325 | intp, pqnext); | ||
| 326 | ret = event_notifier_test_and_clear(intp->interrupt); | ||
| 327 | - qemu_mutex_unlock(&vdev->intp_mutex); | ||
| 328 | return; | ||
| 329 | } | ||
| 330 | |||
| 331 | @@ -XXX,XX +XXX,XX @@ static void vfio_intp_interrupt(VFIOINTp *intp) | ||
| 332 | qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + | ||
| 333 | vdev->mmap_timeout); | ||
| 334 | } | ||
| 335 | - qemu_mutex_unlock(&vdev->intp_mutex); | ||
| 336 | } | ||
| 337 | |||
| 338 | /** | ||
| 339 | diff --git a/migration/migration.c b/migration/migration.c | ||
| 340 | index XXXXXXX..XXXXXXX 100644 | ||
| 341 | --- a/migration/migration.c | ||
| 342 | +++ b/migration/migration.c | ||
| 343 | @@ -XXX,XX +XXX,XX @@ static void migrate_fd_cleanup_bh(void *opaque) | ||
| 344 | |||
| 345 | void migrate_set_error(MigrationState *s, const Error *error) | ||
| 346 | { | ||
| 347 | - qemu_mutex_lock(&s->error_mutex); | ||
| 348 | + QEMU_LOCK_GUARD(&s->error_mutex); | ||
| 349 | if (!s->error) { | ||
| 350 | s->error = error_copy(error); | ||
| 351 | } | ||
| 352 | - qemu_mutex_unlock(&s->error_mutex); | ||
| 353 | } | ||
| 354 | |||
| 355 | void migrate_fd_error(MigrationState *s, const Error *error) | ||
| 356 | diff --git a/migration/multifd.c b/migration/multifd.c | ||
| 357 | index XXXXXXX..XXXXXXX 100644 | ||
| 358 | --- a/migration/multifd.c | ||
| 359 | +++ b/migration/multifd.c | ||
| 360 | @@ -XXX,XX +XXX,XX @@ void multifd_recv_sync_main(void) | ||
| 361 | for (i = 0; i < migrate_multifd_channels(); i++) { | ||
| 362 | MultiFDRecvParams *p = &multifd_recv_state->params[i]; | ||
| 363 | |||
| 364 | - qemu_mutex_lock(&p->mutex); | ||
| 365 | - if (multifd_recv_state->packet_num < p->packet_num) { | ||
| 366 | - multifd_recv_state->packet_num = p->packet_num; | ||
| 367 | + WITH_QEMU_LOCK_GUARD(&p->mutex) { | ||
| 368 | + if (multifd_recv_state->packet_num < p->packet_num) { | ||
| 369 | + multifd_recv_state->packet_num = p->packet_num; | ||
| 370 | + } | ||
| 371 | } | ||
| 372 | - qemu_mutex_unlock(&p->mutex); | ||
| 373 | trace_multifd_recv_sync_main_signal(p->id); | ||
| 374 | qemu_sem_post(&p->sem_sync); | ||
| 375 | } | ||
| 376 | diff --git a/migration/ram.c b/migration/ram.c | ||
| 377 | index XXXXXXX..XXXXXXX 100644 | ||
| 378 | --- a/migration/ram.c | ||
| 379 | +++ b/migration/ram.c | ||
| 380 | @@ -XXX,XX +XXX,XX @@ static RAMBlock *unqueue_page(RAMState *rs, ram_addr_t *offset) | ||
| 381 | return NULL; | ||
| 382 | } | ||
| 383 | |||
| 384 | - qemu_mutex_lock(&rs->src_page_req_mutex); | ||
| 385 | + QEMU_LOCK_GUARD(&rs->src_page_req_mutex); | ||
| 386 | if (!QSIMPLEQ_EMPTY(&rs->src_page_requests)) { | ||
| 387 | struct RAMSrcPageRequest *entry = | ||
| 388 | QSIMPLEQ_FIRST(&rs->src_page_requests); | ||
| 389 | @@ -XXX,XX +XXX,XX @@ static RAMBlock *unqueue_page(RAMState *rs, ram_addr_t *offset) | ||
| 390 | migration_consume_urgent_request(); | ||
| 391 | } | ||
| 392 | } | ||
| 393 | - qemu_mutex_unlock(&rs->src_page_req_mutex); | ||
| 394 | |||
| 395 | return block; | ||
| 396 | } | ||
| 397 | diff --git a/monitor/misc.c b/monitor/misc.c | ||
| 398 | index XXXXXXX..XXXXXXX 100644 | ||
| 399 | --- a/monitor/misc.c | ||
| 400 | +++ b/monitor/misc.c | ||
| 401 | @@ -XXX,XX +XXX,XX @@ AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id, | ||
| 402 | MonFdsetFd *mon_fdset_fd; | ||
| 403 | AddfdInfo *fdinfo; | ||
| 404 | |||
| 405 | - qemu_mutex_lock(&mon_fdsets_lock); | ||
| 406 | + QEMU_LOCK_GUARD(&mon_fdsets_lock); | ||
| 407 | if (has_fdset_id) { | ||
| 408 | QLIST_FOREACH(mon_fdset, &mon_fdsets, next) { | ||
| 409 | /* Break if match found or match impossible due to ordering by ID */ | ||
| 410 | @@ -XXX,XX +XXX,XX @@ AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id, | ||
| 411 | if (fdset_id < 0) { | ||
| 412 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id", | ||
| 413 | "a non-negative value"); | ||
| 414 | - qemu_mutex_unlock(&mon_fdsets_lock); | ||
| 415 | return NULL; | ||
| 416 | } | ||
| 417 | /* Use specified fdset ID */ | ||
| 418 | @@ -XXX,XX +XXX,XX @@ AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id, | ||
| 419 | fdinfo->fdset_id = mon_fdset->id; | ||
| 420 | fdinfo->fd = mon_fdset_fd->fd; | ||
| 421 | |||
| 422 | - qemu_mutex_unlock(&mon_fdsets_lock); | ||
| 423 | return fdinfo; | ||
| 424 | } | ||
| 425 | |||
| 426 | diff --git a/ui/spice-display.c b/ui/spice-display.c | ||
| 427 | index XXXXXXX..XXXXXXX 100644 | ||
| 428 | --- a/ui/spice-display.c | ||
| 429 | +++ b/ui/spice-display.c | ||
| 430 | @@ -XXX,XX +XXX,XX @@ | ||
| 431 | #include "qemu/osdep.h" | ||
| 432 | #include "ui/qemu-spice.h" | ||
| 433 | #include "qemu/timer.h" | ||
| 434 | +#include "qemu/lockable.h" | ||
| 435 | #include "qemu/main-loop.h" | ||
| 436 | #include "qemu/option.h" | ||
| 437 | #include "qemu/queue.h" | ||
| 438 | @@ -XXX,XX +XXX,XX @@ void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd) | ||
| 439 | { | ||
| 440 | graphic_hw_update(ssd->dcl.con); | ||
| 441 | |||
| 442 | - qemu_mutex_lock(&ssd->lock); | ||
| 443 | - if (QTAILQ_EMPTY(&ssd->updates) && ssd->ds) { | ||
| 444 | - qemu_spice_create_update(ssd); | ||
| 445 | - ssd->notify++; | ||
| 446 | + WITH_QEMU_LOCK_GUARD(&ssd->lock) { | ||
| 447 | + if (QTAILQ_EMPTY(&ssd->updates) && ssd->ds) { | ||
| 448 | + qemu_spice_create_update(ssd); | ||
| 449 | + ssd->notify++; | ||
| 65 | + } | 450 | + } |
| 66 | 451 | } | |
| 67 | ret = snprintf(extent_opt_prefix, 32, "extents.%d", s->num_extents); | 452 | - qemu_mutex_unlock(&ssd->lock); |
| 68 | assert(ret < 32); | 453 | |
| 69 | @@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, | 454 | trace_qemu_spice_display_refresh(ssd->qxl.id, ssd->notify); |
| 70 | g_free(extent_path); | 455 | if (ssd->notify) { |
| 71 | if (local_err) { | 456 | @@ -XXX,XX +XXX,XX @@ static int interface_get_cursor_command(QXLInstance *sin, QXLCommandExt *ext) |
| 72 | error_propagate(errp, local_err); | 457 | SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl); |
| 73 | - return -EINVAL; | 458 | int ret; |
| 74 | + ret = -EINVAL; | 459 | |
| 75 | + goto out; | 460 | - qemu_mutex_lock(&ssd->lock); |
| 76 | } | 461 | + QEMU_LOCK_GUARD(&ssd->lock); |
| 77 | 462 | if (ssd->ptr_define) { | |
| 78 | /* save to extents array */ | 463 | *ext = ssd->ptr_define->ext; |
| 79 | @@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, | 464 | ssd->ptr_define = NULL; |
| 80 | 0, 0, 0, 0, 0, &extent, errp); | 465 | @@ -XXX,XX +XXX,XX @@ static int interface_get_cursor_command(QXLInstance *sin, QXLCommandExt *ext) |
| 81 | if (ret < 0) { | 466 | } else { |
| 82 | bdrv_unref_child(bs, extent_file); | 467 | ret = false; |
| 83 | - return ret; | 468 | } |
| 84 | + goto out; | 469 | - qemu_mutex_unlock(&ssd->lock); |
| 85 | } | ||
| 86 | extent->flat_start_offset = flat_offset << 9; | ||
| 87 | } else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) { | ||
| 88 | @@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs, | ||
| 89 | g_free(buf); | ||
| 90 | if (ret) { | ||
| 91 | bdrv_unref_child(bs, extent_file); | ||
| 92 | - return ret; | ||
| 93 | + goto out; | ||
| 94 | } | ||
| 95 | extent = &s->extents[s->num_extents - 1]; | ||
| 96 | } else if (!strcmp(type, "SESPARSE")) { | ||
| 97 | ret = vmdk_open_se_sparse(bs, extent_file, bs->open_flags, errp); | ||
| 98 | if (ret) { | ||
| 99 | bdrv_unref_child(bs, extent_file); | ||
| 100 | - return ret; | ||
| 101 | + goto out; | ||
| 102 | } | ||
| 103 | extent = &s->extents[s->num_extents - 1]; | ||
| 104 | } else { | ||
| 105 | error_setg(errp, "Unsupported extent type '%s'", type); | ||
| 106 | bdrv_unref_child(bs, extent_file); | ||
| 107 | - return -ENOTSUP; | ||
| 108 | + ret = -ENOTSUP; | ||
| 109 | + goto out; | ||
| 110 | } | ||
| 111 | extent->type = g_strdup(type); | ||
| 112 | } | ||
| 113 | - return 0; | ||
| 114 | + | ||
| 115 | + ret = 0; | ||
| 116 | + goto out; | ||
| 117 | |||
| 118 | invalid: | ||
| 119 | np = next_line(p); | ||
| 120 | @@ -XXX,XX +XXX,XX @@ invalid: | ||
| 121 | np--; | ||
| 122 | } | ||
| 123 | error_setg(errp, "Invalid extent line: %.*s", (int)(np - p), p); | ||
| 124 | - return -EINVAL; | ||
| 125 | + ret = -EINVAL; | ||
| 126 | + | ||
| 127 | +out: | ||
| 128 | + g_free(desc_file_dir); | ||
| 129 | + return ret; | ||
| 130 | } | ||
| 131 | |||
| 132 | static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf, | ||
| 133 | @@ -XXX,XX +XXX,XX @@ static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf, | ||
| 134 | } | ||
| 135 | s->create_type = g_strdup(ct); | ||
| 136 | s->desc_offset = 0; | ||
| 137 | - ret = vmdk_parse_extents(buf, bs, bs->file->bs->exact_filename, options, | ||
| 138 | - errp); | ||
| 139 | + ret = vmdk_parse_extents(buf, bs, options, errp); | ||
| 140 | exit: | ||
| 141 | return ret; | 470 | return ret; |
| 142 | } | 471 | } |
| 143 | diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059 | 472 | |
| 144 | index XXXXXXX..XXXXXXX 100755 | 473 | diff --git a/util/log.c b/util/log.c |
| 145 | --- a/tests/qemu-iotests/059 | 474 | index XXXXXXX..XXXXXXX 100644 |
| 146 | +++ b/tests/qemu-iotests/059 | 475 | --- a/util/log.c |
| 147 | @@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2 | 476 | +++ b/util/log.c |
| 148 | 477 | @@ -XXX,XX +XXX,XX @@ | |
| 149 | echo | 478 | #include "qemu/cutils.h" |
| 150 | echo "=== Testing monolithicFlat with internally generated JSON file name ===" | 479 | #include "trace/control.h" |
| 151 | +# Should work, because bdrv_dirname() works fine with blkdebug | 480 | #include "qemu/thread.h" |
| 152 | IMGOPTS="subformat=monolithicFlat" _make_test_img 64M | 481 | +#include "qemu/lockable.h" |
| 153 | -$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" 2>&1 \ | 482 | |
| 154 | - | _filter_testdir | _filter_imgfmt | 483 | static char *logfilename; |
| 155 | +$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \ | 484 | static QemuMutex qemu_logfile_mutex; |
| 156 | + -c info \ | 485 | @@ -XXX,XX +XXX,XX @@ void qemu_set_log(int log_flags) |
| 157 | + 2>&1 \ | 486 | if (qemu_loglevel && (!is_daemonized() || logfilename)) { |
| 158 | + | _filter_testdir | _filter_imgfmt | _filter_img_info | 487 | need_to_open_file = true; |
| 159 | _cleanup_test_img | 488 | } |
| 160 | 489 | - qemu_mutex_lock(&qemu_logfile_mutex); | |
| 161 | echo | 490 | + QEMU_LOCK_GUARD(&qemu_logfile_mutex); |
| 162 | diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out | 491 | if (qemu_logfile && !need_to_open_file) { |
| 163 | index XXXXXXX..XXXXXXX 100644 | 492 | logfile = qemu_logfile; |
| 164 | --- a/tests/qemu-iotests/059.out | 493 | atomic_rcu_set(&qemu_logfile, NULL); |
| 165 | +++ b/tests/qemu-iotests/059.out | 494 | @@ -XXX,XX +XXX,XX @@ void qemu_set_log(int log_flags) |
| 166 | @@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240 | 495 | } |
| 167 | 496 | atomic_rcu_set(&qemu_logfile, logfile); | |
| 168 | === Testing monolithicFlat with internally generated JSON file name === | 497 | } |
| 169 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 | 498 | - qemu_mutex_unlock(&qemu_logfile_mutex); |
| 170 | -qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}' | 499 | } |
| 171 | +format name: IMGFMT | 500 | |
| 172 | +cluster size: 0 bytes | 501 | void qemu_log_needs_buffers(void) |
| 173 | +vm state offset: 0 bytes | 502 | diff --git a/util/qemu-timer.c b/util/qemu-timer.c |
| 174 | 503 | index XXXXXXX..XXXXXXX 100644 | |
| 175 | === Testing version 3 === | 504 | --- a/util/qemu-timer.c |
| 176 | image: TEST_DIR/iotest-version3.IMGFMT | 505 | +++ b/util/qemu-timer.c |
| 506 | @@ -XXX,XX +XXX,XX @@ void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time) | ||
| 507 | QEMUTimerList *timer_list = ts->timer_list; | ||
| 508 | bool rearm; | ||
| 509 | |||
| 510 | - qemu_mutex_lock(&timer_list->active_timers_lock); | ||
| 511 | - if (ts->expire_time == -1 || ts->expire_time > expire_time) { | ||
| 512 | - if (ts->expire_time != -1) { | ||
| 513 | - timer_del_locked(timer_list, ts); | ||
| 514 | + WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) { | ||
| 515 | + if (ts->expire_time == -1 || ts->expire_time > expire_time) { | ||
| 516 | + if (ts->expire_time != -1) { | ||
| 517 | + timer_del_locked(timer_list, ts); | ||
| 518 | + } | ||
| 519 | + rearm = timer_mod_ns_locked(timer_list, ts, expire_time); | ||
| 520 | + } else { | ||
| 521 | + rearm = false; | ||
| 522 | } | ||
| 523 | - rearm = timer_mod_ns_locked(timer_list, ts, expire_time); | ||
| 524 | - } else { | ||
| 525 | - rearm = false; | ||
| 526 | } | ||
| 527 | - qemu_mutex_unlock(&timer_list->active_timers_lock); | ||
| 528 | - | ||
| 529 | if (rearm) { | ||
| 530 | timerlist_rearm(timer_list); | ||
| 531 | } | ||
| 532 | diff --git a/util/rcu.c b/util/rcu.c | ||
| 533 | index XXXXXXX..XXXXXXX 100644 | ||
| 534 | --- a/util/rcu.c | ||
| 535 | +++ b/util/rcu.c | ||
| 536 | @@ -XXX,XX +XXX,XX @@ | ||
| 537 | #include "qemu/atomic.h" | ||
| 538 | #include "qemu/thread.h" | ||
| 539 | #include "qemu/main-loop.h" | ||
| 540 | +#include "qemu/lockable.h" | ||
| 541 | #if defined(CONFIG_MALLOC_TRIM) | ||
| 542 | #include <malloc.h> | ||
| 543 | #endif | ||
| 544 | @@ -XXX,XX +XXX,XX @@ static void wait_for_readers(void) | ||
| 545 | |||
| 546 | void synchronize_rcu(void) | ||
| 547 | { | ||
| 548 | - qemu_mutex_lock(&rcu_sync_lock); | ||
| 549 | + QEMU_LOCK_GUARD(&rcu_sync_lock); | ||
| 550 | |||
| 551 | /* Write RCU-protected pointers before reading p_rcu_reader->ctr. | ||
| 552 | * Pairs with smp_mb_placeholder() in rcu_read_lock(). | ||
| 553 | */ | ||
| 554 | smp_mb_global(); | ||
| 555 | |||
| 556 | - qemu_mutex_lock(&rcu_registry_lock); | ||
| 557 | + QEMU_LOCK_GUARD(&rcu_registry_lock); | ||
| 558 | if (!QLIST_EMPTY(®istry)) { | ||
| 559 | /* In either case, the atomic_mb_set below blocks stores that free | ||
| 560 | * old RCU-protected pointers. | ||
| 561 | @@ -XXX,XX +XXX,XX @@ void synchronize_rcu(void) | ||
| 562 | |||
| 563 | wait_for_readers(); | ||
| 564 | } | ||
| 565 | - | ||
| 566 | - qemu_mutex_unlock(&rcu_registry_lock); | ||
| 567 | - qemu_mutex_unlock(&rcu_sync_lock); | ||
| 568 | } | ||
| 569 | |||
| 570 | |||
| 571 | diff --git a/util/thread-pool.c b/util/thread-pool.c | ||
| 572 | index XXXXXXX..XXXXXXX 100644 | ||
| 573 | --- a/util/thread-pool.c | ||
| 574 | +++ b/util/thread-pool.c | ||
| 575 | @@ -XXX,XX +XXX,XX @@ static void thread_pool_cancel(BlockAIOCB *acb) | ||
| 576 | |||
| 577 | trace_thread_pool_cancel(elem, elem->common.opaque); | ||
| 578 | |||
| 579 | - qemu_mutex_lock(&pool->lock); | ||
| 580 | + QEMU_LOCK_GUARD(&pool->lock); | ||
| 581 | if (elem->state == THREAD_QUEUED && | ||
| 582 | /* No thread has yet started working on elem. we can try to "steal" | ||
| 583 | * the item from the worker if we can get a signal from the | ||
| 584 | @@ -XXX,XX +XXX,XX @@ static void thread_pool_cancel(BlockAIOCB *acb) | ||
| 585 | elem->ret = -ECANCELED; | ||
| 586 | } | ||
| 587 | |||
| 588 | - qemu_mutex_unlock(&pool->lock); | ||
| 589 | } | ||
| 590 | |||
| 591 | static AioContext *thread_pool_get_aio_context(BlockAIOCB *acb) | ||
| 592 | diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c | ||
| 593 | index XXXXXXX..XXXXXXX 100644 | ||
| 594 | --- a/util/vfio-helpers.c | ||
| 595 | +++ b/util/vfio-helpers.c | ||
| 596 | @@ -XXX,XX +XXX,XX @@ | ||
| 597 | #include "standard-headers/linux/pci_regs.h" | ||
| 598 | #include "qemu/event_notifier.h" | ||
| 599 | #include "qemu/vfio-helpers.h" | ||
| 600 | +#include "qemu/lockable.h" | ||
| 601 | #include "trace.h" | ||
| 602 | |||
| 603 | #define QEMU_VFIO_DEBUG 0 | ||
| 604 | @@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_reset_temporary(QEMUVFIOState *s) | ||
| 605 | .size = QEMU_VFIO_IOVA_MAX - s->high_water_mark, | ||
| 606 | }; | ||
| 607 | trace_qemu_vfio_dma_reset_temporary(s); | ||
| 608 | - qemu_mutex_lock(&s->lock); | ||
| 609 | + QEMU_LOCK_GUARD(&s->lock); | ||
| 610 | if (ioctl(s->container, VFIO_IOMMU_UNMAP_DMA, &unmap)) { | ||
| 611 | error_report("VFIO_UNMAP_DMA failed: %s", strerror(errno)); | ||
| 612 | - qemu_mutex_unlock(&s->lock); | ||
| 613 | return -errno; | ||
| 614 | } | ||
| 615 | s->high_water_mark = QEMU_VFIO_IOVA_MAX; | ||
| 616 | - qemu_mutex_unlock(&s->lock); | ||
| 617 | return 0; | ||
| 618 | } | ||
| 619 | |||
| 177 | -- | 620 | -- |
| 178 | 2.21.0 | 621 | 2.25.3 |
| 179 | 622 | ||
| 180 | diff view generated by jsdifflib |
| 1 | From: Nir Soffer <nirsof@gmail.com> | 1 | From: Simran Singhal <singhalsimran0@gmail.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | When creating an image with preallocation "off" or "falloc", the first | 3 | Replace manual lock()/unlock() calls with lock guard macros |
| 4 | block of the image is typically not allocated. When using Gluster | 4 | (QEMU_LOCK_GUARD/WITH_QEMU_LOCK_GUARD). |
| 5 | storage backed by XFS filesystem, reading this block using direct I/O | ||
| 6 | succeeds regardless of request length, fooling alignment detection. | ||
| 7 | 5 | ||
| 8 | In this case we fallback to a safe value (4096) instead of the optimal | 6 | Signed-off-by: Simran Singhal <singhalsimran0@gmail.com> |
| 9 | value (512), which may lead to unneeded data copying when aligning | 7 | Reviewed-by: Yuval Shaia <yuval.shaia.ml@gmail.com> |
| 10 | requests. Allocating the first block avoids the fallback. | 8 | Reviewed-by: Marcel Apfelbaum<marcel.apfelbaum@gmail.com> |
| 9 | Tested-by: Yuval Shaia <yuval.shaia.ml@gmail.com> | ||
| 10 | Message-id: 20200402065035.GA15477@simran-Inspiron-5558 | ||
| 11 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
| 12 | --- | ||
| 13 | hw/hyperv/hyperv.c | 15 ++++++------- | ||
| 14 | hw/rdma/rdma_backend.c | 50 +++++++++++++++++++++--------------------- | ||
| 15 | hw/rdma/rdma_rm.c | 3 +-- | ||
| 16 | 3 files changed, 33 insertions(+), 35 deletions(-) | ||
| 11 | 17 | ||
| 12 | Since we allocate the first block even with preallocation=off, we no | 18 | diff --git a/hw/hyperv/hyperv.c b/hw/hyperv/hyperv.c |
| 13 | longer create images with zero disk size: | ||
| 14 | |||
| 15 | $ ./qemu-img create -f raw test.raw 1g | ||
| 16 | Formatting 'test.raw', fmt=raw size=1073741824 | ||
| 17 | |||
| 18 | $ ls -lhs test.raw | ||
| 19 | 4.0K -rw-r--r--. 1 nsoffer nsoffer 1.0G Aug 16 23:48 test.raw | ||
| 20 | |||
| 21 | And converting the image requires additional cluster: | ||
| 22 | |||
| 23 | $ ./qemu-img measure -f raw -O qcow2 test.raw | ||
| 24 | required size: 458752 | ||
| 25 | fully allocated size: 1074135040 | ||
| 26 | |||
| 27 | When using format like vmdk with multiple files per image, we allocate | ||
| 28 | one block per file: | ||
| 29 | |||
| 30 | $ ./qemu-img create -f vmdk -o subformat=twoGbMaxExtentFlat test.vmdk 4g | ||
| 31 | Formatting 'test.vmdk', fmt=vmdk size=4294967296 compat6=off hwversion=undefined subformat=twoGbMaxExtentFlat | ||
| 32 | |||
| 33 | $ ls -lhs test*.vmdk | ||
| 34 | 4.0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f001.vmdk | ||
| 35 | 4.0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f002.vmdk | ||
| 36 | 4.0K -rw-r--r--. 1 nsoffer nsoffer 353 Aug 27 03:23 test.vmdk | ||
| 37 | |||
| 38 | I did quick performance test for copying disks with qemu-img convert to | ||
| 39 | new raw target image to Gluster storage with sector size of 512 bytes: | ||
| 40 | |||
| 41 | for i in $(seq 10); do | ||
| 42 | rm -f dst.raw | ||
| 43 | sleep 10 | ||
| 44 | time ./qemu-img convert -f raw -O raw -t none -T none src.raw dst.raw | ||
| 45 | done | ||
| 46 | |||
| 47 | Here is a table comparing the total time spent: | ||
| 48 | |||
| 49 | Type Before(s) After(s) Diff(%) | ||
| 50 | --------------------------------------- | ||
| 51 | real 530.028 469.123 -11.4 | ||
| 52 | user 17.204 10.768 -37.4 | ||
| 53 | sys 17.881 7.011 -60.7 | ||
| 54 | |||
| 55 | We can see very clear improvement in CPU usage. | ||
| 56 | |||
| 57 | Signed-off-by: Nir Soffer <nsoffer@redhat.com> | ||
| 58 | Message-id: 20190827010528.8818-2-nsoffer@redhat.com | ||
| 59 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
| 60 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 61 | --- | ||
| 62 | block/file-posix.c | 51 +++++++++++++++++++ | ||
| 63 | tests/qemu-iotests/059.out | 2 +- | ||
| 64 | tests/qemu-iotests/{150.out => 150.out.qcow2} | 0 | ||
| 65 | tests/qemu-iotests/150.out.raw | 12 +++++ | ||
| 66 | tests/qemu-iotests/175 | 19 ++++--- | ||
| 67 | tests/qemu-iotests/175.out | 8 +-- | ||
| 68 | tests/qemu-iotests/178.out.qcow2 | 4 +- | ||
| 69 | tests/qemu-iotests/221.out | 12 +++-- | ||
| 70 | tests/qemu-iotests/253.out | 12 +++-- | ||
| 71 | 9 files changed, 99 insertions(+), 21 deletions(-) | ||
| 72 | rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%) | ||
| 73 | create mode 100644 tests/qemu-iotests/150.out.raw | ||
| 74 | |||
| 75 | diff --git a/block/file-posix.c b/block/file-posix.c | ||
| 76 | index XXXXXXX..XXXXXXX 100644 | 19 | index XXXXXXX..XXXXXXX 100644 |
| 77 | --- a/block/file-posix.c | 20 | --- a/hw/hyperv/hyperv.c |
| 78 | +++ b/block/file-posix.c | 21 | +++ b/hw/hyperv/hyperv.c |
| 79 | @@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque) | 22 | @@ -XXX,XX +XXX,XX @@ |
| 23 | #include "sysemu/kvm.h" | ||
| 24 | #include "qemu/bitops.h" | ||
| 25 | #include "qemu/error-report.h" | ||
| 26 | +#include "qemu/lockable.h" | ||
| 27 | #include "qemu/queue.h" | ||
| 28 | #include "qemu/rcu.h" | ||
| 29 | #include "qemu/rcu_queue.h" | ||
| 30 | @@ -XXX,XX +XXX,XX @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data) | ||
| 31 | int ret; | ||
| 32 | MsgHandler *mh; | ||
| 33 | |||
| 34 | - qemu_mutex_lock(&handlers_mutex); | ||
| 35 | + QEMU_LOCK_GUARD(&handlers_mutex); | ||
| 36 | QLIST_FOREACH(mh, &msg_handlers, link) { | ||
| 37 | if (mh->conn_id == conn_id) { | ||
| 38 | if (handler) { | ||
| 39 | @@ -XXX,XX +XXX,XX @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data) | ||
| 40 | g_free_rcu(mh, rcu); | ||
| 41 | ret = 0; | ||
| 42 | } | ||
| 43 | - goto unlock; | ||
| 44 | + return ret; | ||
| 45 | } | ||
| 46 | } | ||
| 47 | |||
| 48 | @@ -XXX,XX +XXX,XX @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data) | ||
| 49 | } else { | ||
| 50 | ret = -ENOENT; | ||
| 51 | } | ||
| 52 | -unlock: | ||
| 53 | - qemu_mutex_unlock(&handlers_mutex); | ||
| 54 | + | ||
| 80 | return ret; | 55 | return ret; |
| 81 | } | 56 | } |
| 82 | 57 | ||
| 83 | +/* | 58 | @@ -XXX,XX +XXX,XX @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier) |
| 84 | + * Help alignment probing by allocating the first block. | 59 | int ret; |
| 85 | + * | 60 | EventFlagHandler *handler; |
| 86 | + * When reading with direct I/O from unallocated area on Gluster backed by XFS, | 61 | |
| 87 | + * reading succeeds regardless of request length. In this case we fallback to | 62 | - qemu_mutex_lock(&handlers_mutex); |
| 88 | + * safe alignment which is not optimal. Allocating the first block avoids this | 63 | + QEMU_LOCK_GUARD(&handlers_mutex); |
| 89 | + * fallback. | 64 | QLIST_FOREACH(handler, &event_flag_handlers, link) { |
| 90 | + * | 65 | if (handler->conn_id == conn_id) { |
| 91 | + * fd may be opened with O_DIRECT, but we don't know the buffer alignment or | 66 | if (notifier) { |
| 92 | + * request alignment, so we use safe values. | 67 | @@ -XXX,XX +XXX,XX @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier) |
| 93 | + * | 68 | g_free_rcu(handler, rcu); |
| 94 | + * Returns: 0 on success, -errno on failure. Since this is an optimization, | 69 | ret = 0; |
| 95 | + * caller may ignore failures. | 70 | } |
| 96 | + */ | 71 | - goto unlock; |
| 97 | +static int allocate_first_block(int fd, size_t max_size) | 72 | + return ret; |
| 98 | +{ | 73 | } |
| 99 | + size_t write_size = (max_size < MAX_BLOCKSIZE) | 74 | } |
| 100 | + ? BDRV_SECTOR_SIZE | 75 | |
| 101 | + : MAX_BLOCKSIZE; | 76 | @@ -XXX,XX +XXX,XX @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier) |
| 102 | + size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize()); | 77 | } else { |
| 103 | + void *buf; | 78 | ret = -ENOENT; |
| 104 | + ssize_t n; | 79 | } |
| 105 | + int ret; | 80 | -unlock: |
| 81 | - qemu_mutex_unlock(&handlers_mutex); | ||
| 106 | + | 82 | + |
| 107 | + buf = qemu_memalign(max_align, write_size); | 83 | return ret; |
| 108 | + memset(buf, 0, write_size); | 84 | } |
| 109 | + | 85 | |
| 110 | + do { | 86 | diff --git a/hw/rdma/rdma_backend.c b/hw/rdma/rdma_backend.c |
| 111 | + n = pwrite(fd, buf, write_size, 0); | 87 | index XXXXXXX..XXXXXXX 100644 |
| 112 | + } while (n == -1 && errno == EINTR); | 88 | --- a/hw/rdma/rdma_backend.c |
| 113 | + | 89 | +++ b/hw/rdma/rdma_backend.c |
| 114 | + ret = (n == -1) ? -errno : 0; | 90 | @@ -XXX,XX +XXX,XX @@ static int rdma_poll_cq(RdmaDeviceResources *rdma_dev_res, struct ibv_cq *ibcq) |
| 115 | + | 91 | struct ibv_wc wc[2]; |
| 116 | + qemu_vfree(buf); | 92 | RdmaProtectedGSList *cqe_ctx_list; |
| 117 | + return ret; | 93 | |
| 118 | +} | 94 | - qemu_mutex_lock(&rdma_dev_res->lock); |
| 119 | + | 95 | - do { |
| 120 | static int handle_aiocb_truncate(void *opaque) | 96 | - ne = ibv_poll_cq(ibcq, ARRAY_SIZE(wc), wc); |
| 97 | + WITH_QEMU_LOCK_GUARD(&rdma_dev_res->lock) { | ||
| 98 | + do { | ||
| 99 | + ne = ibv_poll_cq(ibcq, ARRAY_SIZE(wc), wc); | ||
| 100 | |||
| 101 | - trace_rdma_poll_cq(ne, ibcq); | ||
| 102 | + trace_rdma_poll_cq(ne, ibcq); | ||
| 103 | |||
| 104 | - for (i = 0; i < ne; i++) { | ||
| 105 | - bctx = rdma_rm_get_cqe_ctx(rdma_dev_res, wc[i].wr_id); | ||
| 106 | - if (unlikely(!bctx)) { | ||
| 107 | - rdma_error_report("No matching ctx for req %"PRId64, | ||
| 108 | - wc[i].wr_id); | ||
| 109 | - continue; | ||
| 110 | - } | ||
| 111 | + for (i = 0; i < ne; i++) { | ||
| 112 | + bctx = rdma_rm_get_cqe_ctx(rdma_dev_res, wc[i].wr_id); | ||
| 113 | + if (unlikely(!bctx)) { | ||
| 114 | + rdma_error_report("No matching ctx for req %"PRId64, | ||
| 115 | + wc[i].wr_id); | ||
| 116 | + continue; | ||
| 117 | + } | ||
| 118 | |||
| 119 | - comp_handler(bctx->up_ctx, &wc[i]); | ||
| 120 | + comp_handler(bctx->up_ctx, &wc[i]); | ||
| 121 | |||
| 122 | - if (bctx->backend_qp) { | ||
| 123 | - cqe_ctx_list = &bctx->backend_qp->cqe_ctx_list; | ||
| 124 | - } else { | ||
| 125 | - cqe_ctx_list = &bctx->backend_srq->cqe_ctx_list; | ||
| 126 | - } | ||
| 127 | + if (bctx->backend_qp) { | ||
| 128 | + cqe_ctx_list = &bctx->backend_qp->cqe_ctx_list; | ||
| 129 | + } else { | ||
| 130 | + cqe_ctx_list = &bctx->backend_srq->cqe_ctx_list; | ||
| 131 | + } | ||
| 132 | |||
| 133 | - rdma_protected_gslist_remove_int32(cqe_ctx_list, wc[i].wr_id); | ||
| 134 | - rdma_rm_dealloc_cqe_ctx(rdma_dev_res, wc[i].wr_id); | ||
| 135 | - g_free(bctx); | ||
| 136 | - } | ||
| 137 | - total_ne += ne; | ||
| 138 | - } while (ne > 0); | ||
| 139 | - atomic_sub(&rdma_dev_res->stats.missing_cqe, total_ne); | ||
| 140 | - qemu_mutex_unlock(&rdma_dev_res->lock); | ||
| 141 | + rdma_protected_gslist_remove_int32(cqe_ctx_list, wc[i].wr_id); | ||
| 142 | + rdma_rm_dealloc_cqe_ctx(rdma_dev_res, wc[i].wr_id); | ||
| 143 | + g_free(bctx); | ||
| 144 | + } | ||
| 145 | + total_ne += ne; | ||
| 146 | + } while (ne > 0); | ||
| 147 | + atomic_sub(&rdma_dev_res->stats.missing_cqe, total_ne); | ||
| 148 | + } | ||
| 149 | |||
| 150 | if (ne < 0) { | ||
| 151 | rdma_error_report("ibv_poll_cq fail, rc=%d, errno=%d", ne, errno); | ||
| 152 | diff --git a/hw/rdma/rdma_rm.c b/hw/rdma/rdma_rm.c | ||
| 153 | index XXXXXXX..XXXXXXX 100644 | ||
| 154 | --- a/hw/rdma/rdma_rm.c | ||
| 155 | +++ b/hw/rdma/rdma_rm.c | ||
| 156 | @@ -XXX,XX +XXX,XX @@ static inline void rdma_res_tbl_dealloc(RdmaRmResTbl *tbl, uint32_t handle) | ||
| 121 | { | 157 | { |
| 122 | RawPosixAIOData *aiocb = opaque; | 158 | trace_rdma_res_tbl_dealloc(tbl->name, handle); |
| 123 | @@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque) | 159 | |
| 124 | /* posix_fallocate() doesn't set errno. */ | 160 | - qemu_mutex_lock(&tbl->lock); |
| 125 | error_setg_errno(errp, -result, | 161 | + QEMU_LOCK_GUARD(&tbl->lock); |
| 126 | "Could not preallocate new data"); | 162 | |
| 127 | + } else if (current_length == 0) { | 163 | if (handle < tbl->tbl_sz) { |
| 128 | + /* | 164 | clear_bit(handle, tbl->bitmap); |
| 129 | + * posix_fallocate() uses fallocate() if the filesystem | 165 | tbl->used--; |
| 130 | + * supports it, or fallback to manually writing zeroes. If | 166 | } |
| 131 | + * fallocate() was used, unaligned reads from the fallocated | 167 | |
| 132 | + * area in raw_probe_alignment() will succeed, hence we need to | 168 | - qemu_mutex_unlock(&tbl->lock); |
| 133 | + * allocate the first block. | ||
| 134 | + * | ||
| 135 | + * Optimize future alignment probing; ignore failures. | ||
| 136 | + */ | ||
| 137 | + allocate_first_block(fd, offset); | ||
| 138 | } | ||
| 139 | } else { | ||
| 140 | result = 0; | ||
| 141 | @@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque) | ||
| 142 | if (ftruncate(fd, offset) != 0) { | ||
| 143 | result = -errno; | ||
| 144 | error_setg_errno(errp, -result, "Could not resize file"); | ||
| 145 | + } else if (current_length == 0 && offset > current_length) { | ||
| 146 | + /* Optimize future alignment probing; ignore failures. */ | ||
| 147 | + allocate_first_block(fd, offset); | ||
| 148 | } | ||
| 149 | return result; | ||
| 150 | default: | ||
| 151 | diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out | ||
| 152 | index XXXXXXX..XXXXXXX 100644 | ||
| 153 | --- a/tests/qemu-iotests/059.out | ||
| 154 | +++ b/tests/qemu-iotests/059.out | ||
| 155 | @@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMax | ||
| 156 | image: TEST_DIR/t.vmdk | ||
| 157 | file format: vmdk | ||
| 158 | virtual size: 0.977 TiB (1073741824000 bytes) | ||
| 159 | -disk size: 16 KiB | ||
| 160 | +disk size: 1.97 MiB | ||
| 161 | Format specific information: | ||
| 162 | cid: XXXXXXXX | ||
| 163 | parent cid: XXXXXXXX | ||
| 164 | diff --git a/tests/qemu-iotests/150.out b/tests/qemu-iotests/150.out.qcow2 | ||
| 165 | similarity index 100% | ||
| 166 | rename from tests/qemu-iotests/150.out | ||
| 167 | rename to tests/qemu-iotests/150.out.qcow2 | ||
| 168 | diff --git a/tests/qemu-iotests/150.out.raw b/tests/qemu-iotests/150.out.raw | ||
| 169 | new file mode 100644 | ||
| 170 | index XXXXXXX..XXXXXXX | ||
| 171 | --- /dev/null | ||
| 172 | +++ b/tests/qemu-iotests/150.out.raw | ||
| 173 | @@ -XXX,XX +XXX,XX @@ | ||
| 174 | +QA output created by 150 | ||
| 175 | + | ||
| 176 | +=== Mapping sparse conversion === | ||
| 177 | + | ||
| 178 | +Offset Length File | ||
| 179 | +0 0x1000 TEST_DIR/t.IMGFMT | ||
| 180 | + | ||
| 181 | +=== Mapping non-sparse conversion === | ||
| 182 | + | ||
| 183 | +Offset Length File | ||
| 184 | +0 0x100000 TEST_DIR/t.IMGFMT | ||
| 185 | +*** done | ||
| 186 | diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175 | ||
| 187 | index XXXXXXX..XXXXXXX 100755 | ||
| 188 | --- a/tests/qemu-iotests/175 | ||
| 189 | +++ b/tests/qemu-iotests/175 | ||
| 190 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 191 | # the file size. This function hides the resulting difference in the | ||
| 192 | # stat -c '%b' output. | ||
| 193 | # Parameter 1: Number of blocks an empty file occupies | ||
| 194 | -# Parameter 2: Image size in bytes | ||
| 195 | +# Parameter 2: Minimal number of blocks in an image | ||
| 196 | +# Parameter 3: Image size in bytes | ||
| 197 | _filter_blocks() | ||
| 198 | { | ||
| 199 | extra_blocks=$1 | ||
| 200 | - img_size=$2 | ||
| 201 | + min_blocks=$2 | ||
| 202 | + img_size=$3 | ||
| 203 | |||
| 204 | - sed -e "s/blocks=$extra_blocks\\(\$\\|[^0-9]\\)/nothing allocated/" \ | ||
| 205 | - -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/everything allocated/" | ||
| 206 | + sed -e "s/blocks=$min_blocks\\(\$\\|[^0-9]\\)/min allocation/" \ | ||
| 207 | + -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/max allocation/" | ||
| 208 | } | 169 | } |
| 209 | 170 | ||
| 210 | # get standard environment, filters and checks | 171 | int rdma_rm_alloc_pd(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev, |
| 211 | @@ -XXX,XX +XXX,XX @@ size=$((1 * 1024 * 1024)) | ||
| 212 | touch "$TEST_DIR/empty" | ||
| 213 | extra_blocks=$(stat -c '%b' "$TEST_DIR/empty") | ||
| 214 | |||
| 215 | +# We always write the first byte; check how many blocks this filesystem | ||
| 216 | +# allocates to match empty image alloation. | ||
| 217 | +printf "\0" > "$TEST_DIR/empty" | ||
| 218 | +min_blocks=$(stat -c '%b' "$TEST_DIR/empty") | ||
| 219 | + | ||
| 220 | echo | ||
| 221 | echo "== creating image with default preallocation ==" | ||
| 222 | _make_test_img $size | _filter_imgfmt | ||
| 223 | -stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size | ||
| 224 | +stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size | ||
| 225 | |||
| 226 | for mode in off full falloc; do | ||
| 227 | echo | ||
| 228 | echo "== creating image with preallocation $mode ==" | ||
| 229 | IMGOPTS=preallocation=$mode _make_test_img $size | _filter_imgfmt | ||
| 230 | - stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size | ||
| 231 | + stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size | ||
| 232 | done | ||
| 233 | |||
| 234 | # success, all done | ||
| 235 | diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out | ||
| 236 | index XXXXXXX..XXXXXXX 100644 | ||
| 237 | --- a/tests/qemu-iotests/175.out | ||
| 238 | +++ b/tests/qemu-iotests/175.out | ||
| 239 | @@ -XXX,XX +XXX,XX @@ QA output created by 175 | ||
| 240 | |||
| 241 | == creating image with default preallocation == | ||
| 242 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 | ||
| 243 | -size=1048576, nothing allocated | ||
| 244 | +size=1048576, min allocation | ||
| 245 | |||
| 246 | == creating image with preallocation off == | ||
| 247 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=off | ||
| 248 | -size=1048576, nothing allocated | ||
| 249 | +size=1048576, min allocation | ||
| 250 | |||
| 251 | == creating image with preallocation full == | ||
| 252 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=full | ||
| 253 | -size=1048576, everything allocated | ||
| 254 | +size=1048576, max allocation | ||
| 255 | |||
| 256 | == creating image with preallocation falloc == | ||
| 257 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc | ||
| 258 | -size=1048576, everything allocated | ||
| 259 | +size=1048576, max allocation | ||
| 260 | *** done | ||
| 261 | diff --git a/tests/qemu-iotests/178.out.qcow2 b/tests/qemu-iotests/178.out.qcow2 | ||
| 262 | index XXXXXXX..XXXXXXX 100644 | ||
| 263 | --- a/tests/qemu-iotests/178.out.qcow2 | ||
| 264 | +++ b/tests/qemu-iotests/178.out.qcow2 | ||
| 265 | @@ -XXX,XX +XXX,XX @@ converted image file size in bytes: 196608 | ||
| 266 | == raw input image with data (human) == | ||
| 267 | |||
| 268 | Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824 | ||
| 269 | -required size: 393216 | ||
| 270 | +required size: 458752 | ||
| 271 | fully allocated size: 1074135040 | ||
| 272 | wrote 512/512 bytes at offset 512 | ||
| 273 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 274 | @@ -XXX,XX +XXX,XX @@ converted image file size in bytes: 196608 | ||
| 275 | |||
| 276 | Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824 | ||
| 277 | { | ||
| 278 | - "required": 393216, | ||
| 279 | + "required": 458752, | ||
| 280 | "fully-allocated": 1074135040 | ||
| 281 | } | ||
| 282 | wrote 512/512 bytes at offset 512 | ||
| 283 | diff --git a/tests/qemu-iotests/221.out b/tests/qemu-iotests/221.out | ||
| 284 | index XXXXXXX..XXXXXXX 100644 | ||
| 285 | --- a/tests/qemu-iotests/221.out | ||
| 286 | +++ b/tests/qemu-iotests/221.out | ||
| 287 | @@ -XXX,XX +XXX,XX @@ QA output created by 221 | ||
| 288 | === Check mapping of unaligned raw image === | ||
| 289 | |||
| 290 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=65537 | ||
| 291 | -[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 292 | -[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 293 | +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 294 | +{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 295 | +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 296 | +{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 297 | wrote 1/1 bytes at offset 65536 | ||
| 298 | 1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 299 | -[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, | ||
| 300 | +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 301 | +{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, | ||
| 302 | { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 303 | { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 304 | -[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, | ||
| 305 | +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 306 | +{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, | ||
| 307 | { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 308 | { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 309 | *** done | ||
| 310 | diff --git a/tests/qemu-iotests/253.out b/tests/qemu-iotests/253.out | ||
| 311 | index XXXXXXX..XXXXXXX 100644 | ||
| 312 | --- a/tests/qemu-iotests/253.out | ||
| 313 | +++ b/tests/qemu-iotests/253.out | ||
| 314 | @@ -XXX,XX +XXX,XX @@ QA output created by 253 | ||
| 315 | === Check mapping of unaligned raw image === | ||
| 316 | |||
| 317 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048575 | ||
| 318 | -[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 319 | -[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 320 | +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 321 | +{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 322 | +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 323 | +{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}] | ||
| 324 | wrote 65535/65535 bytes at offset 983040 | ||
| 325 | 63.999 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 326 | -[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, | ||
| 327 | +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 328 | +{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, | ||
| 329 | { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}] | ||
| 330 | -[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, | ||
| 331 | +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET}, | ||
| 332 | +{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET}, | ||
| 333 | { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}] | ||
| 334 | *** done | ||
| 335 | -- | 172 | -- |
| 336 | 2.21.0 | 173 | 2.25.3 |
| 337 | 174 | ||
| 338 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Nir Soffer <nirsof@gmail.com> | ||
| 2 | 1 | ||
| 3 | Using block_resize we can test allocate_first_block() with file | ||
| 4 | descriptor opened with O_DIRECT, ensuring that it works for any size | ||
| 5 | larger than 4096 bytes. | ||
| 6 | |||
| 7 | Testing smaller sizes is tricky as the result depends on the filesystem | ||
| 8 | used for testing. For example on NFS any size will work since O_DIRECT | ||
| 9 | does not require any alignment. | ||
| 10 | |||
| 11 | Signed-off-by: Nir Soffer <nsoffer@redhat.com> | ||
| 12 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
| 13 | Message-id: 20190827010528.8818-3-nsoffer@redhat.com | ||
| 14 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 15 | --- | ||
| 16 | tests/qemu-iotests/175 | 28 ++++++++++++++++++++++++++++ | ||
| 17 | tests/qemu-iotests/175.out | 8 ++++++++ | ||
| 18 | 2 files changed, 36 insertions(+) | ||
| 19 | |||
| 20 | diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175 | ||
| 21 | index XXXXXXX..XXXXXXX 100755 | ||
| 22 | --- a/tests/qemu-iotests/175 | ||
| 23 | +++ b/tests/qemu-iotests/175 | ||
| 24 | @@ -XXX,XX +XXX,XX @@ _filter_blocks() | ||
| 25 | -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/max allocation/" | ||
| 26 | } | ||
| 27 | |||
| 28 | +# Resize image using block_resize. | ||
| 29 | +# Parameter 1: image path | ||
| 30 | +# Parameter 2: new size | ||
| 31 | +_block_resize() | ||
| 32 | +{ | ||
| 33 | + local path=$1 | ||
| 34 | + local size=$2 | ||
| 35 | + | ||
| 36 | + $QEMU -qmp stdio -nographic -nodefaults \ | ||
| 37 | + -blockdev file,node-name=file,filename=$path,cache.direct=on \ | ||
| 38 | + <<EOF | ||
| 39 | +{'execute': 'qmp_capabilities'} | ||
| 40 | +{'execute': 'block_resize', 'arguments': {'node-name': 'file', 'size': $size}} | ||
| 41 | +{'execute': 'quit'} | ||
| 42 | +EOF | ||
| 43 | +} | ||
| 44 | + | ||
| 45 | # get standard environment, filters and checks | ||
| 46 | . ./common.rc | ||
| 47 | . ./common.filter | ||
| 48 | @@ -XXX,XX +XXX,XX @@ _supported_fmt raw | ||
| 49 | _supported_proto file | ||
| 50 | _supported_os Linux | ||
| 51 | |||
| 52 | +_default_cache_mode none | ||
| 53 | +_supported_cache_modes none directsync | ||
| 54 | + | ||
| 55 | size=$((1 * 1024 * 1024)) | ||
| 56 | |||
| 57 | touch "$TEST_DIR/empty" | ||
| 58 | @@ -XXX,XX +XXX,XX @@ for mode in off full falloc; do | ||
| 59 | stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size | ||
| 60 | done | ||
| 61 | |||
| 62 | +for new_size in 4096 1048576; do | ||
| 63 | + echo | ||
| 64 | + echo "== resize empty image with block_resize ==" | ||
| 65 | + _make_test_img 0 | _filter_imgfmt | ||
| 66 | + _block_resize $TEST_IMG $new_size >/dev/null | ||
| 67 | + stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $new_size | ||
| 68 | +done | ||
| 69 | + | ||
| 70 | # success, all done | ||
| 71 | echo "*** done" | ||
| 72 | rm -f $seq.full | ||
| 73 | diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out | ||
| 74 | index XXXXXXX..XXXXXXX 100644 | ||
| 75 | --- a/tests/qemu-iotests/175.out | ||
| 76 | +++ b/tests/qemu-iotests/175.out | ||
| 77 | @@ -XXX,XX +XXX,XX @@ size=1048576, max allocation | ||
| 78 | == creating image with preallocation falloc == | ||
| 79 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc | ||
| 80 | size=1048576, max allocation | ||
| 81 | + | ||
| 82 | +== resize empty image with block_resize == | ||
| 83 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0 | ||
| 84 | +size=4096, min allocation | ||
| 85 | + | ||
| 86 | +== resize empty image with block_resize == | ||
| 87 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0 | ||
| 88 | +size=1048576, min allocation | ||
| 89 | *** done | ||
| 90 | -- | ||
| 91 | 2.21.0 | ||
| 92 | |||
| 93 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | fe646693acc changed qemu-img create's output so that it no longer prints | ||
| 2 | single quotes around parameter values. The subformat and adapter_type | ||
| 3 | filters in _filter_img_create() have never been adapted to that change. | ||
| 4 | 1 | ||
| 5 | Fixes: fe646693acc13ac48b98435d14149ab04dc597bc | ||
| 6 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 7 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 8 | Message-id: 20190815153638.4600-2-mreitz@redhat.com | ||
| 9 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 10 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 11 | --- | ||
| 12 | tests/qemu-iotests/059.out | 16 ++++++++-------- | ||
| 13 | tests/qemu-iotests/common.filter | 4 ++-- | ||
| 14 | 2 files changed, 10 insertions(+), 10 deletions(-) | ||
| 15 | |||
| 16 | diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out | ||
| 17 | index XXXXXXX..XXXXXXX 100644 | ||
| 18 | --- a/tests/qemu-iotests/059.out | ||
| 19 | +++ b/tests/qemu-iotests/059.out | ||
| 20 | @@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 | ||
| 21 | qemu-io: can't open device TEST_DIR/t.vmdk: L1 size too big | ||
| 22 | |||
| 23 | === Testing monolithicFlat creation and opening === | ||
| 24 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat | ||
| 25 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 | ||
| 26 | image: TEST_DIR/t.IMGFMT | ||
| 27 | file format: IMGFMT | ||
| 28 | virtual size: 2 GiB (2147483648 bytes) | ||
| 29 | |||
| 30 | === Testing monolithicFlat with zeroed_grain === | ||
| 31 | qemu-img: TEST_DIR/t.IMGFMT: Flat image can't enable zeroed grain | ||
| 32 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat | ||
| 33 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 | ||
| 34 | |||
| 35 | === Testing big twoGbMaxExtentFlat === | ||
| 36 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMaxExtentFlat | ||
| 37 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 | ||
| 38 | image: TEST_DIR/t.vmdk | ||
| 39 | file format: vmdk | ||
| 40 | virtual size: 0.977 TiB (1073741824000 bytes) | ||
| 41 | @@ -XXX,XX +XXX,XX @@ Format specific information: | ||
| 42 | qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Invalid extent line: RW 12582912 VMFS "dummy.IMGFMT" 1 | ||
| 43 | |||
| 44 | === Testing truncated sparse === | ||
| 45 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400 subformat=monolithicSparse | ||
| 46 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400 | ||
| 47 | qemu-img: Could not open 'TEST_DIR/t.IMGFMT': File truncated, expecting at least 13172736 bytes | ||
| 48 | |||
| 49 | === Converting to streamOptimized from image with small cluster size=== | ||
| 50 | @@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240 | ||
| 51 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 52 | |||
| 53 | === Testing monolithicFlat with internally generated JSON file name === | ||
| 54 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 subformat=monolithicFlat | ||
| 55 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 | ||
| 56 | qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}' | ||
| 57 | |||
| 58 | === Testing version 3 === | ||
| 59 | @@ -XXX,XX +XXX,XX @@ read 512/512 bytes at offset 64931328 | ||
| 60 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 61 | |||
| 62 | === Testing 4TB monolithicFlat creation and IO === | ||
| 63 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104 subformat=monolithicFlat | ||
| 64 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104 | ||
| 65 | image: TEST_DIR/t.IMGFMT | ||
| 66 | file format: IMGFMT | ||
| 67 | virtual size: 4 TiB (4398046511104 bytes) | ||
| 68 | @@ -XXX,XX +XXX,XX @@ read 1024/1024 bytes at offset 966367641600 | ||
| 69 | 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 70 | |||
| 71 | === Testing qemu-img map on extents === | ||
| 72 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=monolithicSparse | ||
| 73 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 | ||
| 74 | wrote 1024/1024 bytes at offset 65024 | ||
| 75 | 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 76 | wrote 1024/1024 bytes at offset 2147483136 | ||
| 77 | @@ -XXX,XX +XXX,XX @@ Offset Length Mapped to File | ||
| 78 | 0 0x20000 0x3f0000 TEST_DIR/t.vmdk | ||
| 79 | 0x7fff0000 0x20000 0x410000 TEST_DIR/t.vmdk | ||
| 80 | 0x140000000 0x10000 0x430000 TEST_DIR/t.vmdk | ||
| 81 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=twoGbMaxExtentSparse | ||
| 82 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 | ||
| 83 | wrote 1024/1024 bytes at offset 65024 | ||
| 84 | 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 85 | wrote 1024/1024 bytes at offset 2147483136 | ||
| 86 | diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter | ||
| 87 | index XXXXXXX..XXXXXXX 100644 | ||
| 88 | --- a/tests/qemu-iotests/common.filter | ||
| 89 | +++ b/tests/qemu-iotests/common.filter | ||
| 90 | @@ -XXX,XX +XXX,XX @@ _filter_img_create() | ||
| 91 | -e "s# compat6=\\(on\\|off\\)##g" \ | ||
| 92 | -e "s# static=\\(on\\|off\\)##g" \ | ||
| 93 | -e "s# zeroed_grain=\\(on\\|off\\)##g" \ | ||
| 94 | - -e "s# subformat='[^']*'##g" \ | ||
| 95 | - -e "s# adapter_type='[^']*'##g" \ | ||
| 96 | + -e "s# subformat=[^ ]*##g" \ | ||
| 97 | + -e "s# adapter_type=[^ ]*##g" \ | ||
| 98 | -e "s# hwversion=[^ ]*##g" \ | ||
| 99 | -e "s# lazy_refcounts=\\(on\\|off\\)##g" \ | ||
| 100 | -e "s# block_size=[0-9]\\+##g" \ | ||
| 101 | -- | ||
| 102 | 2.21.0 | ||
| 103 | |||
| 104 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | We had a test for a case where relative extent paths did not work, but | ||
| 2 | unfortunately we just fixed the underlying problem, so it works now. | ||
| 3 | This patch adds a new test case that still fails. | ||
| 4 | 1 | ||
| 5 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 6 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 7 | Message-id: 20190815153638.4600-4-mreitz@redhat.com | ||
| 8 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 9 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 10 | --- | ||
| 11 | tests/qemu-iotests/059 | 27 +++++++++++++++++++++++++++ | ||
| 12 | tests/qemu-iotests/059.out | 4 ++++ | ||
| 13 | 2 files changed, 31 insertions(+) | ||
| 14 | |||
| 15 | diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059 | ||
| 16 | index XXXXXXX..XXXXXXX 100755 | ||
| 17 | --- a/tests/qemu-iotests/059 | ||
| 18 | +++ b/tests/qemu-iotests/059 | ||
| 19 | @@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2 | ||
| 20 | |||
| 21 | echo | ||
| 22 | echo "=== Testing monolithicFlat with internally generated JSON file name ===" | ||
| 23 | + | ||
| 24 | +echo '--- blkdebug ---' | ||
| 25 | # Should work, because bdrv_dirname() works fine with blkdebug | ||
| 26 | IMGOPTS="subformat=monolithicFlat" _make_test_img 64M | ||
| 27 | $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \ | ||
| 28 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TE | ||
| 29 | | _filter_testdir | _filter_imgfmt | _filter_img_info | ||
| 30 | _cleanup_test_img | ||
| 31 | |||
| 32 | +echo '--- quorum ---' | ||
| 33 | +# Should not work, because bdrv_dirname() does not work with quorum | ||
| 34 | +IMGOPTS="subformat=monolithicFlat" _make_test_img 64M | ||
| 35 | +cp "$TEST_IMG" "$TEST_IMG.orig" | ||
| 36 | + | ||
| 37 | +filename="json:{ | ||
| 38 | + \"driver\": \"$IMGFMT\", | ||
| 39 | + \"file\": { | ||
| 40 | + \"driver\": \"quorum\", | ||
| 41 | + \"children\": [ { | ||
| 42 | + \"driver\": \"file\", | ||
| 43 | + \"filename\": \"$TEST_IMG\" | ||
| 44 | + }, { | ||
| 45 | + \"driver\": \"file\", | ||
| 46 | + \"filename\": \"$TEST_IMG.orig\" | ||
| 47 | + } ], | ||
| 48 | + \"vote-threshold\": 1 | ||
| 49 | + } }" | ||
| 50 | + | ||
| 51 | +filename=$(echo "$filename" | tr '\n' ' ' | sed -e 's/\s\+/ /g') | ||
| 52 | +$QEMU_IMG info "$filename" 2>&1 \ | ||
| 53 | + | sed -e "s/'json:[^']*'/\$QUORUM_FILE/g" \ | ||
| 54 | + | _filter_testdir | _filter_imgfmt | _filter_img_info | ||
| 55 | + | ||
| 56 | + | ||
| 57 | echo | ||
| 58 | echo "=== Testing version 3 ===" | ||
| 59 | _use_sample_img iotest-version3.vmdk.bz2 | ||
| 60 | diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out | ||
| 61 | index XXXXXXX..XXXXXXX 100644 | ||
| 62 | --- a/tests/qemu-iotests/059.out | ||
| 63 | +++ b/tests/qemu-iotests/059.out | ||
| 64 | @@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240 | ||
| 65 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
| 66 | |||
| 67 | === Testing monolithicFlat with internally generated JSON file name === | ||
| 68 | +--- blkdebug --- | ||
| 69 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 | ||
| 70 | format name: IMGFMT | ||
| 71 | cluster size: 0 bytes | ||
| 72 | vm state offset: 0 bytes | ||
| 73 | +--- quorum --- | ||
| 74 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 | ||
| 75 | +qemu-img: Could not open $QUORUM_FILE: Cannot use relative paths with VMDK descriptor file $QUORUM_FILE: Cannot generate a base directory for quorum nodes | ||
| 76 | |||
| 77 | === Testing version 3 === | ||
| 78 | image: TEST_DIR/iotest-version3.IMGFMT | ||
| 79 | -- | ||
| 80 | 2.21.0 | ||
| 81 | |||
| 82 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | Compressed writes generally have to write full clusters, not just in | ||
| 2 | theory but also in practice when it comes to vmdk's streamOptimized | ||
| 3 | subformat. It currently is just silently broken for writes with | ||
| 4 | non-zero in-cluster offsets: | ||
| 5 | 1 | ||
| 6 | $ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M | ||
| 7 | $ qemu-io -c 'write 4k 4k' -c 'read 4k 4k' foo.vmdk | ||
| 8 | wrote 4096/4096 bytes at offset 4096 | ||
| 9 | 4 KiB, 1 ops; 00.01 sec (443.724 KiB/sec and 110.9309 ops/sec) | ||
| 10 | read failed: Invalid argument | ||
| 11 | |||
| 12 | (The technical reason is that vmdk_write_extent() just writes the | ||
| 13 | incomplete compressed data actually to offset 4k. When reading the | ||
| 14 | data, vmdk_read_extent() looks at offset 0 and finds the compressed data | ||
| 15 | size to be 0, because that is what it reads from there. This yields an | ||
| 16 | error.) | ||
| 17 | |||
| 18 | For incomplete writes with zero in-cluster offsets, the error path when | ||
| 19 | reading the rest of the cluster is a bit different, but the result is | ||
| 20 | the same: | ||
| 21 | |||
| 22 | $ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M | ||
| 23 | $ qemu-io -c 'write 0k 4k' -c 'read 4k 4k' foo.vmdk | ||
| 24 | wrote 4096/4096 bytes at offset 0 | ||
| 25 | 4 KiB, 1 ops; 00.01 sec (362.641 KiB/sec and 90.6603 ops/sec) | ||
| 26 | read failed: Invalid argument | ||
| 27 | |||
| 28 | (Here, vmdk_read_extent() finds the data and then sees that the | ||
| 29 | uncompressed data is short.) | ||
| 30 | |||
| 31 | It is better to reject invalid writes than to make the user believe they | ||
| 32 | might have succeeded and then fail when trying to read it back. | ||
| 33 | |||
| 34 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 35 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 36 | Message-id: 20190815153638.4600-5-mreitz@redhat.com | ||
| 37 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 38 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 39 | --- | ||
| 40 | block/vmdk.c | 10 ++++++++++ | ||
| 41 | 1 file changed, 10 insertions(+) | ||
| 42 | |||
| 43 | diff --git a/block/vmdk.c b/block/vmdk.c | ||
| 44 | index XXXXXXX..XXXXXXX 100644 | ||
| 45 | --- a/block/vmdk.c | ||
| 46 | +++ b/block/vmdk.c | ||
| 47 | @@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset, | ||
| 48 | if (extent->compressed) { | ||
| 49 | void *compressed_data; | ||
| 50 | |||
| 51 | + /* Only whole clusters */ | ||
| 52 | + if (offset_in_cluster || | ||
| 53 | + n_bytes > (extent->cluster_sectors * SECTOR_SIZE) || | ||
| 54 | + (n_bytes < (extent->cluster_sectors * SECTOR_SIZE) && | ||
| 55 | + offset + n_bytes != extent->end_sector * SECTOR_SIZE)) | ||
| 56 | + { | ||
| 57 | + ret = -EINVAL; | ||
| 58 | + goto out; | ||
| 59 | + } | ||
| 60 | + | ||
| 61 | if (!extent->has_marker) { | ||
| 62 | ret = -EINVAL; | ||
| 63 | goto out; | ||
| 64 | -- | ||
| 65 | 2.21.0 | ||
| 66 | |||
| 67 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | streamOptimized does not support writes that do not span exactly one | ||
| 2 | cluster. Furthermore, it cannot rewrite already allocated clusters. | ||
| 3 | As such, many iotests do not work with it. Disable them. | ||
| 4 | 1 | ||
| 5 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 6 | Message-id: 20190815153638.4600-6-mreitz@redhat.com | ||
| 7 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 9 | --- | ||
| 10 | tests/qemu-iotests/002 | 1 + | ||
| 11 | tests/qemu-iotests/003 | 1 + | ||
| 12 | tests/qemu-iotests/005 | 3 ++- | ||
| 13 | tests/qemu-iotests/009 | 1 + | ||
| 14 | tests/qemu-iotests/010 | 1 + | ||
| 15 | tests/qemu-iotests/011 | 1 + | ||
| 16 | tests/qemu-iotests/017 | 3 ++- | ||
| 17 | tests/qemu-iotests/018 | 3 ++- | ||
| 18 | tests/qemu-iotests/019 | 3 ++- | ||
| 19 | tests/qemu-iotests/020 | 3 ++- | ||
| 20 | tests/qemu-iotests/027 | 1 + | ||
| 21 | tests/qemu-iotests/032 | 1 + | ||
| 22 | tests/qemu-iotests/033 | 1 + | ||
| 23 | tests/qemu-iotests/034 | 3 ++- | ||
| 24 | tests/qemu-iotests/037 | 3 ++- | ||
| 25 | tests/qemu-iotests/063 | 3 ++- | ||
| 26 | tests/qemu-iotests/072 | 1 + | ||
| 27 | tests/qemu-iotests/105 | 3 ++- | ||
| 28 | tests/qemu-iotests/197 | 1 + | ||
| 29 | tests/qemu-iotests/215 | 1 + | ||
| 30 | tests/qemu-iotests/251 | 1 + | ||
| 31 | 21 files changed, 30 insertions(+), 9 deletions(-) | ||
| 32 | |||
| 33 | diff --git a/tests/qemu-iotests/002 b/tests/qemu-iotests/002 | ||
| 34 | index XXXXXXX..XXXXXXX 100755 | ||
| 35 | --- a/tests/qemu-iotests/002 | ||
| 36 | +++ b/tests/qemu-iotests/002 | ||
| 37 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 38 | |||
| 39 | _supported_fmt generic | ||
| 40 | _supported_proto generic | ||
| 41 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 42 | |||
| 43 | |||
| 44 | size=128M | ||
| 45 | diff --git a/tests/qemu-iotests/003 b/tests/qemu-iotests/003 | ||
| 46 | index XXXXXXX..XXXXXXX 100755 | ||
| 47 | --- a/tests/qemu-iotests/003 | ||
| 48 | +++ b/tests/qemu-iotests/003 | ||
| 49 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 50 | |||
| 51 | _supported_fmt generic | ||
| 52 | _supported_proto generic | ||
| 53 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 54 | |||
| 55 | size=128M | ||
| 56 | offset=67M | ||
| 57 | diff --git a/tests/qemu-iotests/005 b/tests/qemu-iotests/005 | ||
| 58 | index XXXXXXX..XXXXXXX 100755 | ||
| 59 | --- a/tests/qemu-iotests/005 | ||
| 60 | +++ b/tests/qemu-iotests/005 | ||
| 61 | @@ -XXX,XX +XXX,XX @@ _supported_fmt generic | ||
| 62 | _supported_proto generic | ||
| 63 | _supported_os Linux | ||
| 64 | _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \ | ||
| 65 | - "subformat=twoGbMaxExtentSparse" | ||
| 66 | + "subformat=twoGbMaxExtentSparse" \ | ||
| 67 | + "subformat=streamOptimized" | ||
| 68 | |||
| 69 | # vpc is limited to 127GB, so we can't test it here | ||
| 70 | if [ "$IMGFMT" = "vpc" ]; then | ||
| 71 | diff --git a/tests/qemu-iotests/009 b/tests/qemu-iotests/009 | ||
| 72 | index XXXXXXX..XXXXXXX 100755 | ||
| 73 | --- a/tests/qemu-iotests/009 | ||
| 74 | +++ b/tests/qemu-iotests/009 | ||
| 75 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 76 | |||
| 77 | _supported_fmt generic | ||
| 78 | _supported_proto generic | ||
| 79 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 80 | |||
| 81 | |||
| 82 | size=6G | ||
| 83 | diff --git a/tests/qemu-iotests/010 b/tests/qemu-iotests/010 | ||
| 84 | index XXXXXXX..XXXXXXX 100755 | ||
| 85 | --- a/tests/qemu-iotests/010 | ||
| 86 | +++ b/tests/qemu-iotests/010 | ||
| 87 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 88 | |||
| 89 | _supported_fmt generic | ||
| 90 | _supported_proto generic | ||
| 91 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 92 | |||
| 93 | |||
| 94 | size=6G | ||
| 95 | diff --git a/tests/qemu-iotests/011 b/tests/qemu-iotests/011 | ||
| 96 | index XXXXXXX..XXXXXXX 100755 | ||
| 97 | --- a/tests/qemu-iotests/011 | ||
| 98 | +++ b/tests/qemu-iotests/011 | ||
| 99 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 100 | |||
| 101 | _supported_fmt generic | ||
| 102 | _supported_proto generic | ||
| 103 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 104 | |||
| 105 | |||
| 106 | size=6G | ||
| 107 | diff --git a/tests/qemu-iotests/017 b/tests/qemu-iotests/017 | ||
| 108 | index XXXXXXX..XXXXXXX 100755 | ||
| 109 | --- a/tests/qemu-iotests/017 | ||
| 110 | +++ b/tests/qemu-iotests/017 | ||
| 111 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 112 | _supported_fmt qcow qcow2 vmdk qed | ||
| 113 | _supported_proto generic | ||
| 114 | _unsupported_proto vxhs | ||
| 115 | -_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" | ||
| 116 | +_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \ | ||
| 117 | + "subformat=streamOptimized" | ||
| 118 | |||
| 119 | TEST_OFFSETS="0 4294967296" | ||
| 120 | |||
| 121 | diff --git a/tests/qemu-iotests/018 b/tests/qemu-iotests/018 | ||
| 122 | index XXXXXXX..XXXXXXX 100755 | ||
| 123 | --- a/tests/qemu-iotests/018 | ||
| 124 | +++ b/tests/qemu-iotests/018 | ||
| 125 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 126 | _supported_fmt qcow qcow2 vmdk qed | ||
| 127 | _supported_proto file | ||
| 128 | _supported_os Linux | ||
| 129 | -_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" | ||
| 130 | +_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \ | ||
| 131 | + "streamOptimized" | ||
| 132 | |||
| 133 | TEST_OFFSETS="0 4294967296" | ||
| 134 | |||
| 135 | diff --git a/tests/qemu-iotests/019 b/tests/qemu-iotests/019 | ||
| 136 | index XXXXXXX..XXXXXXX 100755 | ||
| 137 | --- a/tests/qemu-iotests/019 | ||
| 138 | +++ b/tests/qemu-iotests/019 | ||
| 139 | @@ -XXX,XX +XXX,XX @@ _supported_proto file | ||
| 140 | _supported_os Linux | ||
| 141 | _unsupported_imgopts "subformat=monolithicFlat" \ | ||
| 142 | "subformat=twoGbMaxExtentFlat" \ | ||
| 143 | - "subformat=twoGbMaxExtentSparse" | ||
| 144 | + "subformat=twoGbMaxExtentSparse" \ | ||
| 145 | + "subformat=streamOptimized" | ||
| 146 | |||
| 147 | TEST_OFFSETS="0 4294967296" | ||
| 148 | CLUSTER_SIZE=65536 | ||
| 149 | diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020 | ||
| 150 | index XXXXXXX..XXXXXXX 100755 | ||
| 151 | --- a/tests/qemu-iotests/020 | ||
| 152 | +++ b/tests/qemu-iotests/020 | ||
| 153 | @@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed | ||
| 154 | _supported_proto file | ||
| 155 | _unsupported_imgopts "subformat=monolithicFlat" \ | ||
| 156 | "subformat=twoGbMaxExtentFlat" \ | ||
| 157 | - "subformat=twoGbMaxExtentSparse" | ||
| 158 | + "subformat=twoGbMaxExtentSparse" \ | ||
| 159 | + "subformat=streamOptimized" | ||
| 160 | |||
| 161 | TEST_OFFSETS="0 4294967296" | ||
| 162 | |||
| 163 | diff --git a/tests/qemu-iotests/027 b/tests/qemu-iotests/027 | ||
| 164 | index XXXXXXX..XXXXXXX 100755 | ||
| 165 | --- a/tests/qemu-iotests/027 | ||
| 166 | +++ b/tests/qemu-iotests/027 | ||
| 167 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 168 | |||
| 169 | _supported_fmt vmdk qcow qcow2 qed | ||
| 170 | _supported_proto generic | ||
| 171 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 172 | |||
| 173 | |||
| 174 | size=128M | ||
| 175 | diff --git a/tests/qemu-iotests/032 b/tests/qemu-iotests/032 | ||
| 176 | index XXXXXXX..XXXXXXX 100755 | ||
| 177 | --- a/tests/qemu-iotests/032 | ||
| 178 | +++ b/tests/qemu-iotests/032 | ||
| 179 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 180 | # This works for any image format (though unlikely to segfault for raw) | ||
| 181 | _supported_fmt generic | ||
| 182 | _supported_proto generic | ||
| 183 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 184 | |||
| 185 | echo | ||
| 186 | echo === Prepare image === | ||
| 187 | diff --git a/tests/qemu-iotests/033 b/tests/qemu-iotests/033 | ||
| 188 | index XXXXXXX..XXXXXXX 100755 | ||
| 189 | --- a/tests/qemu-iotests/033 | ||
| 190 | +++ b/tests/qemu-iotests/033 | ||
| 191 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 192 | |||
| 193 | _supported_fmt generic | ||
| 194 | _supported_proto generic | ||
| 195 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 196 | |||
| 197 | |||
| 198 | size=128M | ||
| 199 | diff --git a/tests/qemu-iotests/034 b/tests/qemu-iotests/034 | ||
| 200 | index XXXXXXX..XXXXXXX 100755 | ||
| 201 | --- a/tests/qemu-iotests/034 | ||
| 202 | +++ b/tests/qemu-iotests/034 | ||
| 203 | @@ -XXX,XX +XXX,XX @@ _supported_proto file | ||
| 204 | _supported_os Linux | ||
| 205 | _unsupported_imgopts "subformat=monolithicFlat" \ | ||
| 206 | "subformat=twoGbMaxExtentFlat" \ | ||
| 207 | - "subformat=twoGbMaxExtentSparse" | ||
| 208 | + "subformat=twoGbMaxExtentSparse" \ | ||
| 209 | + "subformat=streamOptimized" | ||
| 210 | |||
| 211 | CLUSTER_SIZE=4k | ||
| 212 | size=128M | ||
| 213 | diff --git a/tests/qemu-iotests/037 b/tests/qemu-iotests/037 | ||
| 214 | index XXXXXXX..XXXXXXX 100755 | ||
| 215 | --- a/tests/qemu-iotests/037 | ||
| 216 | +++ b/tests/qemu-iotests/037 | ||
| 217 | @@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed | ||
| 218 | _supported_proto file | ||
| 219 | _unsupported_imgopts "subformat=monolithicFlat" \ | ||
| 220 | "subformat=twoGbMaxExtentFlat" \ | ||
| 221 | - "subformat=twoGbMaxExtentSparse" | ||
| 222 | + "subformat=twoGbMaxExtentSparse" \ | ||
| 223 | + "subformat=streamOptimized" | ||
| 224 | |||
| 225 | CLUSTER_SIZE=4k | ||
| 226 | size=128M | ||
| 227 | diff --git a/tests/qemu-iotests/063 b/tests/qemu-iotests/063 | ||
| 228 | index XXXXXXX..XXXXXXX 100755 | ||
| 229 | --- a/tests/qemu-iotests/063 | ||
| 230 | +++ b/tests/qemu-iotests/063 | ||
| 231 | @@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed raw | ||
| 232 | _supported_proto file | ||
| 233 | _unsupported_imgopts "subformat=monolithicFlat" \ | ||
| 234 | "subformat=twoGbMaxExtentFlat" \ | ||
| 235 | - "subformat=twoGbMaxExtentSparse" | ||
| 236 | + "subformat=twoGbMaxExtentSparse" \ | ||
| 237 | + "subformat=streamOptimized" | ||
| 238 | |||
| 239 | _make_test_img 4M | ||
| 240 | |||
| 241 | diff --git a/tests/qemu-iotests/072 b/tests/qemu-iotests/072 | ||
| 242 | index XXXXXXX..XXXXXXX 100755 | ||
| 243 | --- a/tests/qemu-iotests/072 | ||
| 244 | +++ b/tests/qemu-iotests/072 | ||
| 245 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 246 | |||
| 247 | _supported_fmt vpc vmdk vhdx vdi qed qcow2 qcow | ||
| 248 | _supported_proto file | ||
| 249 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 250 | |||
| 251 | IMG_SIZE=64M | ||
| 252 | |||
| 253 | diff --git a/tests/qemu-iotests/105 b/tests/qemu-iotests/105 | ||
| 254 | index XXXXXXX..XXXXXXX 100755 | ||
| 255 | --- a/tests/qemu-iotests/105 | ||
| 256 | +++ b/tests/qemu-iotests/105 | ||
| 257 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 258 | _supported_fmt qcow2 vmdk vhdx qed | ||
| 259 | _supported_proto generic | ||
| 260 | _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \ | ||
| 261 | - "subformat=twoGbMaxExtentSparse" | ||
| 262 | + "subformat=twoGbMaxExtentSparse" \ | ||
| 263 | + "subformat=streamOptimized" | ||
| 264 | |||
| 265 | echo | ||
| 266 | echo "creating large image" | ||
| 267 | diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197 | ||
| 268 | index XXXXXXX..XXXXXXX 100755 | ||
| 269 | --- a/tests/qemu-iotests/197 | ||
| 270 | +++ b/tests/qemu-iotests/197 | ||
| 271 | @@ -XXX,XX +XXX,XX @@ _supported_fmt generic | ||
| 272 | _supported_proto generic | ||
| 273 | # LUKS support may be possible, but it complicates things. | ||
| 274 | _unsupported_fmt luks | ||
| 275 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 276 | |||
| 277 | echo | ||
| 278 | echo '=== Copy-on-read ===' | ||
| 279 | diff --git a/tests/qemu-iotests/215 b/tests/qemu-iotests/215 | ||
| 280 | index XXXXXXX..XXXXXXX 100755 | ||
| 281 | --- a/tests/qemu-iotests/215 | ||
| 282 | +++ b/tests/qemu-iotests/215 | ||
| 283 | @@ -XXX,XX +XXX,XX @@ _supported_fmt generic | ||
| 284 | _supported_proto generic | ||
| 285 | # LUKS support may be possible, but it complicates things. | ||
| 286 | _unsupported_fmt luks | ||
| 287 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 288 | |||
| 289 | echo | ||
| 290 | echo '=== Copy-on-read ===' | ||
| 291 | diff --git a/tests/qemu-iotests/251 b/tests/qemu-iotests/251 | ||
| 292 | index XXXXXXX..XXXXXXX 100755 | ||
| 293 | --- a/tests/qemu-iotests/251 | ||
| 294 | +++ b/tests/qemu-iotests/251 | ||
| 295 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 296 | _supported_fmt generic | ||
| 297 | _supported_proto file | ||
| 298 | _supported_os Linux | ||
| 299 | +_unsupported_imgopts "subformat=streamOptimized" | ||
| 300 | |||
| 301 | if [ "$IMGOPTSSYNTAX" = "true" ]; then | ||
| 302 | # We use json:{} filenames here, so we cannot work with additional options. | ||
| 303 | -- | ||
| 304 | 2.21.0 | ||
| 305 | |||
| 306 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | The error message for the test case where we have a quorum node for | ||
| 2 | which no directory name can be generated is different: For | ||
| 3 | twoGbMaxExtentSparse, it complains that it cannot open the extent file. | ||
| 4 | For other (sub)formats, it just notes that it cannot determine the | ||
| 5 | backing file path. Both are fine, but just disable twoGbMaxExtentSparse | ||
| 6 | for simplicity's sake. | ||
| 7 | 1 | ||
| 8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 9 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 10 | Message-id: 20190815153638.4600-7-mreitz@redhat.com | ||
| 11 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 12 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 13 | --- | ||
| 14 | tests/qemu-iotests/110 | 3 ++- | ||
| 15 | 1 file changed, 2 insertions(+), 1 deletion(-) | ||
| 16 | |||
| 17 | diff --git a/tests/qemu-iotests/110 b/tests/qemu-iotests/110 | ||
| 18 | index XXXXXXX..XXXXXXX 100755 | ||
| 19 | --- a/tests/qemu-iotests/110 | ||
| 20 | +++ b/tests/qemu-iotests/110 | ||
| 21 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 22 | # Any format supporting backing files | ||
| 23 | _supported_fmt qed qcow qcow2 vmdk | ||
| 24 | _supported_proto file | ||
| 25 | -_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" | ||
| 26 | +_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \ | ||
| 27 | + "subformat=twoGbMaxExtentSparse" | ||
| 28 | |||
| 29 | TEST_IMG_REL=$(basename "$TEST_IMG") | ||
| 30 | |||
| 31 | -- | ||
| 32 | 2.21.0 | ||
| 33 | |||
| 34 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | iotest 126 requires backing file support, which flat vmdks cannot offer. | ||
| 2 | Skip this test for such subformats. | ||
| 3 | 1 | ||
| 4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 5 | Message-id: 20190815153638.4600-8-mreitz@redhat.com | ||
| 6 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
| 7 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 8 | --- | ||
| 9 | tests/qemu-iotests/126 | 2 ++ | ||
| 10 | 1 file changed, 2 insertions(+) | ||
| 11 | |||
| 12 | diff --git a/tests/qemu-iotests/126 b/tests/qemu-iotests/126 | ||
| 13 | index XXXXXXX..XXXXXXX 100755 | ||
| 14 | --- a/tests/qemu-iotests/126 | ||
| 15 | +++ b/tests/qemu-iotests/126 | ||
| 16 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
| 17 | |||
| 18 | # Needs backing file support | ||
| 19 | _supported_fmt qcow qcow2 qed vmdk | ||
| 20 | +_unsupported_imgopts "subformat=monolithicFlat" \ | ||
| 21 | + "subformat=twoGbMaxExtentFlat" | ||
| 22 | # This is the default protocol (and we want to test the difference between | ||
| 23 | # colons which separate a protocol prefix from the rest and colons which are | ||
| 24 | # just part of the filename, so we cannot test protocols which require a prefix) | ||
| 25 | -- | ||
| 26 | 2.21.0 | ||
| 27 | |||
| 28 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Stefan Hajnoczi <stefanha@redhat.com> | ||
| 2 | 1 | ||
| 3 | Fixes: a6b257a08e3d72219f03e461a52152672fec0612 | ||
| 4 | ("file-posix: Handle undetectable alignment") | ||
| 5 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
| 6 | Message-id: 20190827101328.4062-1-stefanha@redhat.com | ||
| 7 | Reviewed-by: Thomas Huth <thuth@redhat.com> | ||
| 8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 9 | --- | ||
| 10 | block/file-posix.c | 2 +- | ||
| 11 | 1 file changed, 1 insertion(+), 1 deletion(-) | ||
| 12 | |||
| 13 | diff --git a/block/file-posix.c b/block/file-posix.c | ||
| 14 | index XXXXXXX..XXXXXXX 100644 | ||
| 15 | --- a/block/file-posix.c | ||
| 16 | +++ b/block/file-posix.c | ||
| 17 | @@ -XXX,XX +XXX,XX @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp) | ||
| 18 | for (i = 0; i < ARRAY_SIZE(alignments); i++) { | ||
| 19 | align = alignments[i]; | ||
| 20 | if (raw_is_io_aligned(fd, buf + align, max_align)) { | ||
| 21 | - /* Fallback to request_aligment. */ | ||
| 22 | + /* Fallback to request_alignment. */ | ||
| 23 | s->buf_align = (align != 1) ? align : bs->bl.request_alignment; | ||
| 24 | break; | ||
| 25 | } | ||
| 26 | -- | ||
| 27 | 2.21.0 | ||
| 28 | |||
| 29 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Thomas Huth <thuth@redhat.com> | ||
| 2 | 1 | ||
| 3 | It is possible to enable only a subset of the block drivers with the | ||
| 4 | "--block-drv-rw-whitelist" option of the "configure" script. All other | ||
| 5 | drivers are marked as unusable (or only included as read-only with the | ||
| 6 | "--block-drv-ro-whitelist" option). If an iotest is now using such a | ||
| 7 | disabled block driver, it is failing - which is bad, since at least the | ||
| 8 | tests in the "auto" group should be able to deal with this situation. | ||
| 9 | Thus let's introduce a "_require_drivers" function that can be used by | ||
| 10 | the shell tests to check for the availability of certain drivers first, | ||
| 11 | and marks the test as "not run" if one of the drivers is missing. | ||
| 12 | |||
| 13 | This patch mainly targets the test in the "auto" group which should | ||
| 14 | never fail in such a case, but also improves some of the other tests | ||
| 15 | along the way. Note that we also assume that the "qcow2" and "file" | ||
| 16 | drivers are always available - otherwise it does not make sense to | ||
| 17 | run "make check-block" at all (which only tests with qcow2 by default). | ||
| 18 | |||
| 19 | Signed-off-by: Thomas Huth <thuth@redhat.com> | ||
| 20 | Message-id: 20190823133552.11680-1-thuth@redhat.com | ||
| 21 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 22 | --- | ||
| 23 | tests/qemu-iotests/071 | 1 + | ||
| 24 | tests/qemu-iotests/081 | 4 +--- | ||
| 25 | tests/qemu-iotests/099 | 1 + | ||
| 26 | tests/qemu-iotests/120 | 1 + | ||
| 27 | tests/qemu-iotests/162 | 4 +--- | ||
| 28 | tests/qemu-iotests/184 | 1 + | ||
| 29 | tests/qemu-iotests/186 | 1 + | ||
| 30 | tests/qemu-iotests/common.rc | 14 ++++++++++++++ | ||
| 31 | 8 files changed, 21 insertions(+), 6 deletions(-) | ||
| 32 | |||
| 33 | diff --git a/tests/qemu-iotests/071 b/tests/qemu-iotests/071 | ||
| 34 | index XXXXXXX..XXXXXXX 100755 | ||
| 35 | --- a/tests/qemu-iotests/071 | ||
| 36 | +++ b/tests/qemu-iotests/071 | ||
| 37 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 38 | |||
| 39 | _supported_fmt qcow2 | ||
| 40 | _supported_proto file | ||
| 41 | +_require_drivers blkdebug blkverify | ||
| 42 | |||
| 43 | do_run_qemu() | ||
| 44 | { | ||
| 45 | diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081 | ||
| 46 | index XXXXXXX..XXXXXXX 100755 | ||
| 47 | --- a/tests/qemu-iotests/081 | ||
| 48 | +++ b/tests/qemu-iotests/081 | ||
| 49 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 50 | _supported_fmt raw | ||
| 51 | _supported_proto file | ||
| 52 | _supported_os Linux | ||
| 53 | +_require_drivers quorum | ||
| 54 | |||
| 55 | do_run_qemu() | ||
| 56 | { | ||
| 57 | @@ -XXX,XX +XXX,XX @@ run_qemu() | ||
| 58 | | _filter_qemu_io | _filter_generated_node_ids | ||
| 59 | } | ||
| 60 | |||
| 61 | -test_quorum=$($QEMU_IMG --help|grep quorum) | ||
| 62 | -[ "$test_quorum" = "" ] && _supported_fmt quorum | ||
| 63 | - | ||
| 64 | quorum="driver=raw,file.driver=quorum,file.vote-threshold=2" | ||
| 65 | quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw" | ||
| 66 | quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw" | ||
| 67 | diff --git a/tests/qemu-iotests/099 b/tests/qemu-iotests/099 | ||
| 68 | index XXXXXXX..XXXXXXX 100755 | ||
| 69 | --- a/tests/qemu-iotests/099 | ||
| 70 | +++ b/tests/qemu-iotests/099 | ||
| 71 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 72 | _supported_fmt qcow qcow2 qed vdi vhdx vmdk vpc | ||
| 73 | _supported_proto file | ||
| 74 | _supported_os Linux | ||
| 75 | +_require_drivers blkdebug blkverify | ||
| 76 | _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \ | ||
| 77 | "subformat=twoGbMaxExtentSparse" | ||
| 78 | |||
| 79 | diff --git a/tests/qemu-iotests/120 b/tests/qemu-iotests/120 | ||
| 80 | index XXXXXXX..XXXXXXX 100755 | ||
| 81 | --- a/tests/qemu-iotests/120 | ||
| 82 | +++ b/tests/qemu-iotests/120 | ||
| 83 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 84 | _supported_fmt generic | ||
| 85 | _supported_proto file | ||
| 86 | _unsupported_fmt luks | ||
| 87 | +_require_drivers raw | ||
| 88 | |||
| 89 | _make_test_img 64M | ||
| 90 | |||
| 91 | diff --git a/tests/qemu-iotests/162 b/tests/qemu-iotests/162 | ||
| 92 | index XXXXXXX..XXXXXXX 100755 | ||
| 93 | --- a/tests/qemu-iotests/162 | ||
| 94 | +++ b/tests/qemu-iotests/162 | ||
| 95 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 96 | . ./common.filter | ||
| 97 | |||
| 98 | _supported_fmt generic | ||
| 99 | - | ||
| 100 | -test_ssh=$($QEMU_IMG --help | grep '^Supported formats:.* ssh\( \|$\)') | ||
| 101 | -[ "$test_ssh" = "" ] && _notrun "ssh support required" | ||
| 102 | +_require_drivers ssh | ||
| 103 | |||
| 104 | echo | ||
| 105 | echo '=== NBD ===' | ||
| 106 | diff --git a/tests/qemu-iotests/184 b/tests/qemu-iotests/184 | ||
| 107 | index XXXXXXX..XXXXXXX 100755 | ||
| 108 | --- a/tests/qemu-iotests/184 | ||
| 109 | +++ b/tests/qemu-iotests/184 | ||
| 110 | @@ -XXX,XX +XXX,XX @@ trap "exit \$status" 0 1 2 3 15 | ||
| 111 | . ./common.filter | ||
| 112 | |||
| 113 | _supported_os Linux | ||
| 114 | +_require_drivers throttle | ||
| 115 | |||
| 116 | do_run_qemu() | ||
| 117 | { | ||
| 118 | diff --git a/tests/qemu-iotests/186 b/tests/qemu-iotests/186 | ||
| 119 | index XXXXXXX..XXXXXXX 100755 | ||
| 120 | --- a/tests/qemu-iotests/186 | ||
| 121 | +++ b/tests/qemu-iotests/186 | ||
| 122 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
| 123 | |||
| 124 | _supported_fmt qcow2 | ||
| 125 | _supported_proto file | ||
| 126 | +_require_drivers null-co | ||
| 127 | |||
| 128 | if [ "$QEMU_DEFAULT_MACHINE" != "pc" ]; then | ||
| 129 | _notrun "Requires a PC machine" | ||
| 130 | diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc | ||
| 131 | index XXXXXXX..XXXXXXX 100644 | ||
| 132 | --- a/tests/qemu-iotests/common.rc | ||
| 133 | +++ b/tests/qemu-iotests/common.rc | ||
| 134 | @@ -XXX,XX +XXX,XX @@ _require_command() | ||
| 135 | [ -x "$c" ] || _notrun "$1 utility required, skipped this test" | ||
| 136 | } | ||
| 137 | |||
| 138 | +# Check that a set of drivers has been whitelisted in the QEMU binary | ||
| 139 | +# | ||
| 140 | +_require_drivers() | ||
| 141 | +{ | ||
| 142 | + available=$($QEMU -drive format=help | \ | ||
| 143 | + sed -e '/Supported formats:/!d' -e 's/Supported formats://') | ||
| 144 | + for driver | ||
| 145 | + do | ||
| 146 | + if ! echo "$available" | grep -q " $driver\( \|$\)"; then | ||
| 147 | + _notrun "$driver not available" | ||
| 148 | + fi | ||
| 149 | + done | ||
| 150 | +} | ||
| 151 | + | ||
| 152 | # make sure this script returns success | ||
| 153 | true | ||
| 154 | -- | ||
| 155 | 2.21.0 | ||
| 156 | |||
| 157 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Thomas Huth <thuth@redhat.com> | ||
| 2 | 1 | ||
| 3 | The sanitizers (especially the address sanitizer from Clang) are | ||
| 4 | sometimes printing out warnings or false positives - this spoils | ||
| 5 | the output of the iotests, causing some of the tests to fail. | ||
| 6 | Thus let's skip the automatic iotests during "make check" when the | ||
| 7 | user configured QEMU with --enable-sanitizers. | ||
| 8 | |||
| 9 | Signed-off-by: Thomas Huth <thuth@redhat.com> | ||
| 10 | Message-id: 20190823084203.29734-1-thuth@redhat.com | ||
| 11 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
| 12 | --- | ||
| 13 | tests/check-block.sh | 5 +++++ | ||
| 14 | 1 file changed, 5 insertions(+) | ||
| 15 | |||
| 16 | diff --git a/tests/check-block.sh b/tests/check-block.sh | ||
| 17 | index XXXXXXX..XXXXXXX 100755 | ||
| 18 | --- a/tests/check-block.sh | ||
| 19 | +++ b/tests/check-block.sh | ||
| 20 | @@ -XXX,XX +XXX,XX @@ if grep -q "TARGET_GPROF=y" *-softmmu/config-target.mak 2>/dev/null ; then | ||
| 21 | exit 0 | ||
| 22 | fi | ||
| 23 | |||
| 24 | +if grep -q "CFLAGS.*-fsanitize" config-host.mak 2>/dev/null ; then | ||
| 25 | + echo "Sanitizers are enabled ==> Not running the qemu-iotests." | ||
| 26 | + exit 0 | ||
| 27 | +fi | ||
| 28 | + | ||
| 29 | if [ -z "$(find . -name 'qemu-system-*' -print)" ]; then | ||
| 30 | echo "No qemu-system binary available ==> Not running the qemu-iotests." | ||
| 31 | exit 0 | ||
| 32 | -- | ||
| 33 | 2.21.0 | ||
| 34 | |||
| 35 | diff view generated by jsdifflib |