1 | The following changes since commit f17783e706ab9c7b3a2b69cf48e4f0ba40664f54: | 1 | The following changes since commit ffd454c67e38cc6df792733ebc5d967eee28ac0d: |
---|---|---|---|
2 | 2 | ||
3 | Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20191220' into staging (2020-01-03 18:50:33 +0000) | 3 | Merge tag 'pull-vfio-20240107' of https://github.com/legoater/qemu into staging (2024-01-08 10:28:42 +0000) |
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-2020-01-06 | 7 | https://gitlab.com/stefanha/qemu.git tags/block-pull-request |
8 | 8 | ||
9 | for you to fetch changes up to 503ca1262bab2c11c533a4816d1ff4297d4f58a6: | 9 | for you to fetch changes up to 0b2675c473f68f13bc5ca1dd1c43ce421542e7b8: |
10 | 10 | ||
11 | backup-top: Begin drain earlier (2020-01-06 14:26:23 +0100) | 11 | Rename "QEMU global mutex" to "BQL" in comments and docs (2024-01-08 10:45:43 -0500) |
12 | 12 | ||
13 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
14 | Block patches: | 14 | Pull request |
15 | - Minor fixes and tests from the freeze period (too minor to be included | ||
16 | in 4.2) | ||
17 | - Allow many bash iotests to test qcow2's external data file feature | ||
18 | - Add compress filter driver | ||
19 | - Fix Python iotests after 6f6e1698a6 | ||
20 | - Fix for the backup job | ||
21 | 15 | ||
22 | ---------------------------------------------------------------- | 16 | ---------------------------------------------------------------- |
23 | Andrey Shinkevich (3): | ||
24 | block: introduce compress filter driver | ||
25 | qcow2: Allow writing compressed data of multiple clusters | ||
26 | tests/qemu-iotests: add case to write compressed data of multiple | ||
27 | clusters | ||
28 | |||
29 | Max Reitz (28): | ||
30 | block: Add bdrv_qapi_perm_to_blk_perm() | ||
31 | block: Use bdrv_qapi_perm_to_blk_perm() | ||
32 | blkdebug: Allow taking/unsharing permissions | ||
33 | iotests: Add @error to wait_until_completed | ||
34 | iotests: Add test for failing mirror complete | ||
35 | iotests: s/qocw2/qcow2/ | ||
36 | iotests/qcow2.py: Add dump-header-exts | ||
37 | iotests/qcow2.py: Split feature fields into bits | ||
38 | iotests: Add _filter_json_filename | ||
39 | iotests: Filter refcount_order in 036 | ||
40 | iotests: Replace IMGOPTS by _unsupported_imgopts | ||
41 | iotests: Drop compat=1.1 in 050 | ||
42 | iotests: Let _make_test_img parse its parameters | ||
43 | iotests: Add -o and --no-opts to _make_test_img | ||
44 | iotests: Inject space into -ocompat=0.10 in 051 | ||
45 | iotests: Replace IMGOPTS= by -o | ||
46 | iotests: Replace IMGOPTS='' by --no-opts | ||
47 | iotests: Drop IMGOPTS use in 267 | ||
48 | iotests: Avoid qemu-img create | ||
49 | iotests: Use _rm_test_img for deleting test images | ||
50 | iotests: Avoid cp/mv of test images | ||
51 | iotests: Make 091 work with data_file | ||
52 | iotests: Make 110 work with data_file | ||
53 | iotests: Make 137 work with data_file | ||
54 | iotests: Make 198 work with data_file | ||
55 | iotests: Disable data_file where it cannot be used | ||
56 | iotests: Allow check -o data_file | ||
57 | backup-top: Begin drain earlier | ||
58 | |||
59 | PanNengyuan (1): | ||
60 | throttle-groups: fix memory leak in throttle_group_set_limit: | ||
61 | 17 | ||
62 | Philippe Mathieu-Daudé (1): | 18 | Philippe Mathieu-Daudé (1): |
63 | tests/qemu-iotests: Update tests to recent desugarized -accel option | 19 | iothread: Remove unused Error** argument in aio_context_set_aio_params |
64 | 20 | ||
65 | Vladimir Sementsov-Ogievskiy (1): | 21 | Stefan Hajnoczi (5): |
66 | qcow2-bitmaps: fix qcow2_can_store_new_dirty_bitmap | 22 | system/cpus: rename qemu_mutex_lock_iothread() to bql_lock() |
23 | qemu/main-loop: rename QEMU_IOTHREAD_LOCK_GUARD to BQL_LOCK_GUARD | ||
24 | qemu/main-loop: rename qemu_cond_wait_iothread() to | ||
25 | qemu_cond_wait_bql() | ||
26 | Replace "iothread lock" with "BQL" in comments | ||
27 | Rename "QEMU global mutex" to "BQL" in comments and docs | ||
67 | 28 | ||
68 | block.c | 47 +++++---- | 29 | docs/devel/multi-thread-tcg.rst | 7 +- |
69 | block/Makefile.objs | 1 + | 30 | docs/devel/qapi-code-gen.rst | 2 +- |
70 | block/backup-top.c | 4 +- | 31 | docs/devel/replay.rst | 2 +- |
71 | block/blkdebug.c | 93 ++++++++++++++++- | 32 | docs/devel/reset.rst | 2 +- |
72 | block/filter-compress.c | 168 +++++++++++++++++++++++++++++++ | 33 | docs/devel/multiple-iothreads.txt | 14 ++-- |
73 | block/qcow2-bitmap.c | 41 ++++---- | 34 | hw/display/qxl.h | 2 +- |
74 | block/qcow2.c | 102 ++++++++++++++----- | 35 | include/block/aio-wait.h | 2 +- |
75 | block/throttle-groups.c | 4 +- | 36 | include/block/aio.h | 3 +- |
76 | include/block/block.h | 1 + | 37 | include/block/blockjob.h | 6 +- |
77 | qapi/block-core.json | 24 ++++- | 38 | include/exec/cpu-common.h | 2 +- |
78 | tests/qemu-iotests/007 | 5 +- | 39 | include/exec/memory.h | 4 +- |
79 | tests/qemu-iotests/014 | 2 + | 40 | include/exec/ramblock.h | 2 +- |
80 | tests/qemu-iotests/015 | 5 +- | 41 | include/io/task.h | 2 +- |
81 | tests/qemu-iotests/019 | 6 +- | 42 | include/migration/register.h | 8 +- |
82 | tests/qemu-iotests/020 | 6 +- | 43 | include/qemu/coroutine-core.h | 2 +- |
83 | tests/qemu-iotests/024 | 10 +- | 44 | include/qemu/coroutine.h | 2 +- |
84 | tests/qemu-iotests/026 | 5 +- | 45 | include/qemu/main-loop.h | 68 ++++++++------- |
85 | tests/qemu-iotests/028 | 2 +- | 46 | include/qemu/thread.h | 2 +- |
86 | tests/qemu-iotests/029 | 7 +- | 47 | target/arm/internals.h | 4 +- |
87 | tests/qemu-iotests/031 | 9 +- | 48 | accel/accel-blocker.c | 10 +-- |
88 | tests/qemu-iotests/031.out | 36 +++---- | 49 | accel/dummy-cpus.c | 8 +- |
89 | tests/qemu-iotests/036 | 15 +-- | 50 | accel/hvf/hvf-accel-ops.c | 4 +- |
90 | tests/qemu-iotests/036.out | 66 ++---------- | 51 | accel/kvm/kvm-accel-ops.c | 4 +- |
91 | tests/qemu-iotests/039 | 27 ++--- | 52 | accel/kvm/kvm-all.c | 22 ++--- |
92 | tests/qemu-iotests/039.out | 22 ++-- | 53 | accel/tcg/cpu-exec.c | 26 +++--- |
93 | tests/qemu-iotests/041 | 44 ++++++++ | 54 | accel/tcg/cputlb.c | 20 ++--- |
94 | tests/qemu-iotests/041.out | 4 +- | 55 | accel/tcg/tcg-accel-ops-icount.c | 6 +- |
95 | tests/qemu-iotests/043 | 4 +- | 56 | accel/tcg/tcg-accel-ops-mttcg.c | 12 +-- |
96 | tests/qemu-iotests/046 | 2 + | 57 | accel/tcg/tcg-accel-ops-rr.c | 18 ++-- |
97 | tests/qemu-iotests/048 | 4 +- | 58 | accel/tcg/tcg-accel-ops.c | 2 +- |
98 | tests/qemu-iotests/050 | 8 +- | 59 | accel/tcg/translate-all.c | 2 +- |
99 | tests/qemu-iotests/051 | 7 +- | 60 | cpu-common.c | 4 +- |
100 | tests/qemu-iotests/053 | 4 +- | 61 | dump/dump.c | 4 +- |
101 | tests/qemu-iotests/058 | 7 +- | 62 | hw/block/dataplane/virtio-blk.c | 8 +- |
102 | tests/qemu-iotests/059 | 20 ++-- | 63 | hw/block/virtio-blk.c | 2 +- |
103 | tests/qemu-iotests/060 | 14 +-- | 64 | hw/core/cpu-common.c | 6 +- |
104 | tests/qemu-iotests/060.out | 20 ++-- | 65 | hw/display/virtio-gpu.c | 2 +- |
105 | tests/qemu-iotests/061 | 63 ++++++------ | 66 | hw/i386/intel_iommu.c | 6 +- |
106 | tests/qemu-iotests/061.out | 72 ++++++------- | 67 | hw/i386/kvm/xen_evtchn.c | 30 +++---- |
107 | tests/qemu-iotests/062 | 5 +- | 68 | hw/i386/kvm/xen_gnttab.c | 2 +- |
108 | tests/qemu-iotests/063 | 18 ++-- | 69 | hw/i386/kvm/xen_overlay.c | 2 +- |
109 | tests/qemu-iotests/063.out | 3 +- | 70 | hw/i386/kvm/xen_xenstore.c | 2 +- |
110 | tests/qemu-iotests/066 | 7 +- | 71 | hw/intc/arm_gicv3_cpuif.c | 2 +- |
111 | tests/qemu-iotests/067 | 6 +- | 72 | hw/intc/s390_flic.c | 18 ++-- |
112 | tests/qemu-iotests/068 | 6 +- | 73 | hw/mips/mips_int.c | 2 +- |
113 | tests/qemu-iotests/069 | 2 +- | 74 | hw/misc/edu.c | 4 +- |
114 | tests/qemu-iotests/071 | 7 +- | 75 | hw/misc/imx6_src.c | 2 +- |
115 | tests/qemu-iotests/073 | 4 + | 76 | hw/misc/imx7_src.c | 2 +- |
116 | tests/qemu-iotests/074 | 4 +- | 77 | hw/net/xen_nic.c | 8 +- |
117 | tests/qemu-iotests/079 | 3 +- | 78 | hw/ppc/pegasos2.c | 2 +- |
118 | tests/qemu-iotests/080 | 7 +- | 79 | hw/ppc/ppc.c | 6 +- |
119 | tests/qemu-iotests/081 | 6 +- | 80 | hw/ppc/spapr.c | 2 +- |
120 | tests/qemu-iotests/085 | 18 ++-- | 81 | hw/ppc/spapr_events.c | 2 +- |
121 | tests/qemu-iotests/085.out | 8 +- | 82 | hw/ppc/spapr_rng.c | 4 +- |
122 | tests/qemu-iotests/088 | 2 +- | 83 | hw/ppc/spapr_softmmu.c | 4 +- |
123 | tests/qemu-iotests/090 | 2 + | 84 | hw/remote/mpqemu-link.c | 22 ++--- |
124 | tests/qemu-iotests/091 | 2 +- | 85 | hw/remote/vfio-user-obj.c | 2 +- |
125 | tests/qemu-iotests/091.out | 2 - | 86 | hw/s390x/s390-skeys.c | 2 +- |
126 | tests/qemu-iotests/092 | 2 +- | 87 | hw/scsi/virtio-scsi-dataplane.c | 6 +- |
127 | tests/qemu-iotests/094 | 4 +- | 88 | iothread.c | 3 +- |
128 | tests/qemu-iotests/095 | 5 +- | 89 | migration/block-dirty-bitmap.c | 14 ++-- |
129 | tests/qemu-iotests/098 | 6 +- | 90 | migration/block.c | 38 ++++----- |
130 | tests/qemu-iotests/099 | 10 +- | 91 | migration/colo.c | 62 +++++++------- |
131 | tests/qemu-iotests/103 | 5 +- | 92 | migration/dirtyrate.c | 12 +-- |
132 | tests/qemu-iotests/106 | 2 +- | 93 | migration/migration.c | 54 ++++++------ |
133 | tests/qemu-iotests/108 | 10 +- | 94 | migration/ram.c | 16 ++-- |
134 | tests/qemu-iotests/109 | 4 +- | 95 | net/tap.c | 2 +- |
135 | tests/qemu-iotests/110 | 11 +- | 96 | replay/replay-internal.c | 2 +- |
136 | tests/qemu-iotests/110.out | 4 +- | 97 | semihosting/console.c | 8 +- |
137 | tests/qemu-iotests/111 | 3 +- | 98 | stubs/iothread-lock.c | 6 +- |
138 | tests/qemu-iotests/112 | 37 +++---- | 99 | system/cpu-throttle.c | 6 +- |
139 | tests/qemu-iotests/114 | 2 + | 100 | system/cpus.c | 55 +++++++------ |
140 | tests/qemu-iotests/115 | 3 +- | 101 | system/dirtylimit.c | 4 +- |
141 | tests/qemu-iotests/121 | 9 +- | 102 | system/memory.c | 2 +- |
142 | tests/qemu-iotests/122 | 6 +- | 103 | system/physmem.c | 14 ++-- |
143 | tests/qemu-iotests/123 | 4 +- | 104 | system/runstate.c | 2 +- |
144 | tests/qemu-iotests/125 | 2 +- | 105 | system/watchpoint.c | 4 +- |
145 | tests/qemu-iotests/137 | 17 +++- | 106 | target/arm/arm-powerctl.c | 14 ++-- |
146 | tests/qemu-iotests/137.out | 6 +- | 107 | target/arm/helper.c | 6 +- |
147 | tests/qemu-iotests/138 | 8 +- | 108 | target/arm/hvf/hvf.c | 8 +- |
148 | tests/qemu-iotests/141 | 4 +- | 109 | target/arm/kvm.c | 8 +- |
149 | tests/qemu-iotests/142 | 2 +- | 110 | target/arm/ptw.c | 6 +- |
150 | tests/qemu-iotests/144 | 4 +- | 111 | target/arm/tcg/helper-a64.c | 8 +- |
151 | tests/qemu-iotests/153 | 12 +-- | 112 | target/arm/tcg/m_helper.c | 6 +- |
152 | tests/qemu-iotests/156 | 10 +- | 113 | target/arm/tcg/op_helper.c | 24 +++--- |
153 | tests/qemu-iotests/159 | 2 +- | 114 | target/arm/tcg/psci.c | 2 +- |
154 | tests/qemu-iotests/160 | 3 +- | 115 | target/hppa/int_helper.c | 8 +- |
155 | tests/qemu-iotests/161 | 4 +- | 116 | target/i386/hvf/hvf.c | 6 +- |
156 | tests/qemu-iotests/170 | 2 +- | 117 | target/i386/kvm/hyperv.c | 4 +- |
157 | tests/qemu-iotests/172 | 6 +- | 118 | target/i386/kvm/kvm.c | 28 +++---- |
158 | tests/qemu-iotests/173 | 3 +- | 119 | target/i386/kvm/xen-emu.c | 16 ++-- |
159 | tests/qemu-iotests/174 | 2 +- | 120 | target/i386/nvmm/nvmm-accel-ops.c | 6 +- |
160 | tests/qemu-iotests/175 | 2 +- | 121 | target/i386/nvmm/nvmm-all.c | 20 ++--- |
161 | tests/qemu-iotests/176 | 7 +- | 122 | target/i386/tcg/sysemu/fpu_helper.c | 6 +- |
162 | tests/qemu-iotests/178 | 6 +- | 123 | target/i386/tcg/sysemu/misc_helper.c | 4 +- |
163 | tests/qemu-iotests/182 | 2 +- | 124 | target/i386/whpx/whpx-accel-ops.c | 6 +- |
164 | tests/qemu-iotests/183 | 2 +- | 125 | target/i386/whpx/whpx-all.c | 24 +++--- |
165 | tests/qemu-iotests/185 | 4 +- | 126 | target/loongarch/tcg/csr_helper.c | 4 +- |
166 | tests/qemu-iotests/187 | 6 +- | 127 | target/mips/kvm.c | 4 +- |
167 | tests/qemu-iotests/190 | 4 +- | 128 | target/mips/tcg/sysemu/cp0_helper.c | 4 +- |
168 | tests/qemu-iotests/191 | 11 +- | 129 | target/openrisc/sys_helper.c | 16 ++-- |
169 | tests/qemu-iotests/195 | 2 +- | 130 | target/ppc/excp_helper.c | 14 ++-- |
170 | tests/qemu-iotests/197 | 6 +- | 131 | target/ppc/helper_regs.c | 2 +- |
171 | tests/qemu-iotests/198 | 6 +- | 132 | target/ppc/kvm.c | 4 +- |
172 | tests/qemu-iotests/198.out | 4 +- | 133 | target/ppc/misc_helper.c | 8 +- |
173 | tests/qemu-iotests/200 | 7 +- | 134 | target/ppc/timebase_helper.c | 8 +- |
174 | tests/qemu-iotests/201 | 6 +- | 135 | target/riscv/cpu_helper.c | 4 +- |
175 | tests/qemu-iotests/214 | 46 ++++++++- | 136 | target/s390x/kvm/kvm.c | 4 +- |
176 | tests/qemu-iotests/214.out | 14 +++ | 137 | target/s390x/tcg/misc_helper.c | 118 +++++++++++++-------------- |
177 | tests/qemu-iotests/215 | 6 +- | 138 | target/sparc/int32_helper.c | 2 +- |
178 | tests/qemu-iotests/217 | 3 +- | 139 | target/sparc/int64_helper.c | 6 +- |
179 | tests/qemu-iotests/220 | 5 +- | 140 | target/sparc/win_helper.c | 20 ++--- |
180 | tests/qemu-iotests/225 | 2 +- | 141 | target/xtensa/exc_helper.c | 8 +- |
181 | tests/qemu-iotests/229 | 3 +- | 142 | ui/spice-core.c | 6 +- |
182 | tests/qemu-iotests/232 | 4 +- | 143 | util/aio-posix.c | 3 +- |
183 | tests/qemu-iotests/235 | 2 +- | 144 | util/aio-win32.c | 3 +- |
184 | tests/qemu-iotests/243 | 10 +- | 145 | util/async.c | 2 +- |
185 | tests/qemu-iotests/244 | 15 +-- | 146 | util/main-loop.c | 13 ++- |
186 | tests/qemu-iotests/247 | 4 +- | 147 | util/qsp.c | 6 +- |
187 | tests/qemu-iotests/249 | 4 +- | 148 | util/rcu.c | 16 ++-- |
188 | tests/qemu-iotests/250 | 5 +- | 149 | audio/coreaudio.m | 8 +- |
189 | tests/qemu-iotests/252 | 2 +- | 150 | memory_ldst.c.inc | 18 ++-- |
190 | tests/qemu-iotests/261 | 5 +- | 151 | target/i386/hvf/README.md | 2 +- |
191 | tests/qemu-iotests/265 | 2 +- | 152 | ui/cocoa.m | 56 ++++++------- |
192 | tests/qemu-iotests/267 | 17 ++-- | 153 | 124 files changed, 646 insertions(+), 655 deletions(-) |
193 | tests/qemu-iotests/273 | 3 + | ||
194 | tests/qemu-iotests/check | 6 +- | ||
195 | tests/qemu-iotests/common.filter | 47 ++++++++- | ||
196 | tests/qemu-iotests/common.rc | 63 ++++++++++-- | ||
197 | tests/qemu-iotests/iotests.py | 18 ++-- | ||
198 | tests/qemu-iotests/qcow2.py | 23 ++++- | ||
199 | 131 files changed, 1139 insertions(+), 552 deletions(-) | ||
200 | create mode 100644 block/filter-compress.c | ||
201 | 154 | ||
202 | -- | 155 | -- |
203 | 2.24.1 | 156 | 2.43.0 |
204 | 157 | ||
205 | 158 | diff view generated by jsdifflib |
1 | We need some way to correlate QAPI BlockPermission values with | 1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> |
---|---|---|---|
2 | BLK_PERM_* flags. We could: | ||
3 | 2 | ||
4 | (1) have the same order in the QAPI definition as the the BLK_PERM_* | 3 | aio_context_set_aio_params() doesn't use its undocumented |
5 | flags are in LSb-first order. However, then there is no guarantee | 4 | Error** argument. Remove it to simplify. |
6 | that they actually match (e.g. when someone modifies the QAPI schema | ||
7 | without thinking of the BLK_PERM_* definitions). | ||
8 | We could add static assertions, but these would break what’s good | ||
9 | about this solution, namely its simplicity. | ||
10 | 5 | ||
11 | (2) define the BLK_PERM_* flags based on the BlockPermission values. | 6 | Note this removes a use of "unchecked Error**" in |
12 | But this way whenever someone were to modify the QAPI order | 7 | iothread_set_aio_context_params(). |
13 | (perfectly sensible in theory), the BLK_PERM_* values would change. | ||
14 | Because these values are used for file locking, this might break | ||
15 | file locking between different qemu versions. | ||
16 | 8 | ||
17 | Therefore, go the slightly more cumbersome way: Add a function to | 9 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
18 | translate from the QAPI constants to the BLK_PERM_* flags. | 10 | Reviewed-by: Markus Armbruster <armbru@redhat.com> |
11 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
12 | Message-ID: <20231120171806.19361-1-philmd@linaro.org> | ||
13 | --- | ||
14 | include/block/aio.h | 3 +-- | ||
15 | iothread.c | 3 +-- | ||
16 | util/aio-posix.c | 3 +-- | ||
17 | util/aio-win32.c | 3 +-- | ||
18 | util/main-loop.c | 5 +---- | ||
19 | 5 files changed, 5 insertions(+), 12 deletions(-) | ||
19 | 20 | ||
20 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 21 | diff --git a/include/block/aio.h b/include/block/aio.h |
21 | Message-id: 20191108123455.39445-2-mreitz@redhat.com | ||
22 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
23 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
24 | --- | ||
25 | block.c | 18 ++++++++++++++++++ | ||
26 | include/block/block.h | 1 + | ||
27 | 2 files changed, 19 insertions(+) | ||
28 | |||
29 | diff --git a/block.c b/block.c | ||
30 | index XXXXXXX..XXXXXXX 100644 | 22 | index XXXXXXX..XXXXXXX 100644 |
31 | --- a/block.c | 23 | --- a/include/block/aio.h |
32 | +++ b/block.c | 24 | +++ b/include/block/aio.h |
33 | @@ -XXX,XX +XXX,XX @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c, | 25 | @@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns, |
34 | *nshared = shared; | 26 | * @max_batch: maximum number of requests in a batch, 0 means that the |
27 | * engine will use its default | ||
28 | */ | ||
29 | -void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch, | ||
30 | - Error **errp); | ||
31 | +void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch); | ||
32 | |||
33 | /** | ||
34 | * aio_context_set_thread_pool_params: | ||
35 | diff --git a/iothread.c b/iothread.c | ||
36 | index XXXXXXX..XXXXXXX 100644 | ||
37 | --- a/iothread.c | ||
38 | +++ b/iothread.c | ||
39 | @@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp) | ||
40 | } | ||
41 | |||
42 | aio_context_set_aio_params(iothread->ctx, | ||
43 | - iothread->parent_obj.aio_max_batch, | ||
44 | - errp); | ||
45 | + iothread->parent_obj.aio_max_batch); | ||
46 | |||
47 | aio_context_set_thread_pool_params(iothread->ctx, base->thread_pool_min, | ||
48 | base->thread_pool_max, errp); | ||
49 | diff --git a/util/aio-posix.c b/util/aio-posix.c | ||
50 | index XXXXXXX..XXXXXXX 100644 | ||
51 | --- a/util/aio-posix.c | ||
52 | +++ b/util/aio-posix.c | ||
53 | @@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns, | ||
54 | aio_notify(ctx); | ||
35 | } | 55 | } |
36 | 56 | ||
37 | +uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm) | 57 | -void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch, |
38 | +{ | 58 | - Error **errp) |
39 | + static const uint64_t permissions[] = { | 59 | +void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch) |
40 | + [BLOCK_PERMISSION_CONSISTENT_READ] = BLK_PERM_CONSISTENT_READ, | ||
41 | + [BLOCK_PERMISSION_WRITE] = BLK_PERM_WRITE, | ||
42 | + [BLOCK_PERMISSION_WRITE_UNCHANGED] = BLK_PERM_WRITE_UNCHANGED, | ||
43 | + [BLOCK_PERMISSION_RESIZE] = BLK_PERM_RESIZE, | ||
44 | + [BLOCK_PERMISSION_GRAPH_MOD] = BLK_PERM_GRAPH_MOD, | ||
45 | + }; | ||
46 | + | ||
47 | + QEMU_BUILD_BUG_ON(ARRAY_SIZE(permissions) != BLOCK_PERMISSION__MAX); | ||
48 | + QEMU_BUILD_BUG_ON(1UL << ARRAY_SIZE(permissions) != BLK_PERM_ALL + 1); | ||
49 | + | ||
50 | + assert(qapi_perm < BLOCK_PERMISSION__MAX); | ||
51 | + | ||
52 | + return permissions[qapi_perm]; | ||
53 | +} | ||
54 | + | ||
55 | static void bdrv_replace_child_noperm(BdrvChild *child, | ||
56 | BlockDriverState *new_bs) | ||
57 | { | 60 | { |
58 | diff --git a/include/block/block.h b/include/block/block.h | 61 | /* |
62 | * No thread synchronization here, it doesn't matter if an incorrect value | ||
63 | diff --git a/util/aio-win32.c b/util/aio-win32.c | ||
59 | index XXXXXXX..XXXXXXX 100644 | 64 | index XXXXXXX..XXXXXXX 100644 |
60 | --- a/include/block/block.h | 65 | --- a/util/aio-win32.c |
61 | +++ b/include/block/block.h | 66 | +++ b/util/aio-win32.c |
62 | @@ -XXX,XX +XXX,XX @@ enum { | 67 | @@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns, |
63 | }; | 68 | } |
64 | 69 | } | |
65 | char *bdrv_perm_names(uint64_t perm); | 70 | |
66 | +uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm); | 71 | -void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch, |
67 | 72 | - Error **errp) | |
68 | /* disk I/O throttling */ | 73 | +void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch) |
69 | void bdrv_init(void); | 74 | { |
75 | } | ||
76 | diff --git a/util/main-loop.c b/util/main-loop.c | ||
77 | index XXXXXXX..XXXXXXX 100644 | ||
78 | --- a/util/main-loop.c | ||
79 | +++ b/util/main-loop.c | ||
80 | @@ -XXX,XX +XXX,XX @@ static void main_loop_update_params(EventLoopBase *base, Error **errp) | ||
81 | return; | ||
82 | } | ||
83 | |||
84 | - aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp); | ||
85 | - if (*errp) { | ||
86 | - return; | ||
87 | - } | ||
88 | + aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch); | ||
89 | |||
90 | aio_context_set_thread_pool_params(qemu_aio_context, base->thread_pool_min, | ||
91 | base->thread_pool_max, errp); | ||
70 | -- | 92 | -- |
71 | 2.24.1 | 93 | 2.43.0 |
72 | 94 | ||
73 | 95 | diff view generated by jsdifflib |
1 | We can save some LoC in xdbg_graph_add_edge() by using | 1 | The Big QEMU Lock (BQL) has many names and they are confusing. The |
---|---|---|---|
2 | bdrv_qapi_perm_to_blk_perm(). | 2 | actual QemuMutex variable is called qemu_global_mutex but it's commonly |
3 | referred to as the BQL in discussions and some code comments. The | ||
4 | locking APIs, however, are called qemu_mutex_lock_iothread() and | ||
5 | qemu_mutex_unlock_iothread(). | ||
3 | 6 | ||
4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 7 | The "iothread" name is historic and comes from when the main thread was |
5 | Message-id: 20191108123455.39445-3-mreitz@redhat.com | 8 | split into into KVM vcpu threads and the "iothread" (now called the main |
6 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | 9 | loop thread). I have contributed to the confusion myself by introducing |
7 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 10 | a separate --object iothread, a separate concept unrelated to the BQL. |
11 | |||
12 | The "iothread" name is no longer appropriate for the BQL. Rename the | ||
13 | locking APIs to: | ||
14 | - void bql_lock(void) | ||
15 | - void bql_unlock(void) | ||
16 | - bool bql_locked(void) | ||
17 | |||
18 | There are more APIs with "iothread" in their names. Subsequent patches | ||
19 | will rename them. There are also comments and documentation that will be | ||
20 | updated in later patches. | ||
21 | |||
22 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
23 | Reviewed-by: Paul Durrant <paul@xen.org> | ||
24 | Acked-by: Fabiano Rosas <farosas@suse.de> | ||
25 | Acked-by: David Woodhouse <dwmw@amazon.co.uk> | ||
26 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | ||
27 | Acked-by: Peter Xu <peterx@redhat.com> | ||
28 | Acked-by: Eric Farman <farman@linux.ibm.com> | ||
29 | Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com> | ||
30 | Acked-by: Hyman Huang <yong.huang@smartx.com> | ||
31 | Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com> | ||
32 | Message-id: 20240102153529.486531-2-stefanha@redhat.com | ||
33 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
8 | --- | 34 | --- |
9 | block.c | 29 ++++++++--------------------- | 35 | include/block/aio-wait.h | 2 +- |
10 | 1 file changed, 8 insertions(+), 21 deletions(-) | 36 | include/qemu/main-loop.h | 39 +++++---- |
37 | include/qemu/thread.h | 2 +- | ||
38 | accel/accel-blocker.c | 10 +-- | ||
39 | accel/dummy-cpus.c | 8 +- | ||
40 | accel/hvf/hvf-accel-ops.c | 4 +- | ||
41 | accel/kvm/kvm-accel-ops.c | 4 +- | ||
42 | accel/kvm/kvm-all.c | 22 ++--- | ||
43 | accel/tcg/cpu-exec.c | 26 +++--- | ||
44 | accel/tcg/cputlb.c | 16 ++-- | ||
45 | accel/tcg/tcg-accel-ops-icount.c | 4 +- | ||
46 | accel/tcg/tcg-accel-ops-mttcg.c | 12 +-- | ||
47 | accel/tcg/tcg-accel-ops-rr.c | 14 ++-- | ||
48 | accel/tcg/tcg-accel-ops.c | 2 +- | ||
49 | accel/tcg/translate-all.c | 2 +- | ||
50 | cpu-common.c | 4 +- | ||
51 | dump/dump.c | 4 +- | ||
52 | hw/core/cpu-common.c | 6 +- | ||
53 | hw/i386/intel_iommu.c | 6 +- | ||
54 | hw/i386/kvm/xen_evtchn.c | 16 ++-- | ||
55 | hw/i386/kvm/xen_overlay.c | 2 +- | ||
56 | hw/i386/kvm/xen_xenstore.c | 2 +- | ||
57 | hw/intc/arm_gicv3_cpuif.c | 2 +- | ||
58 | hw/intc/s390_flic.c | 18 ++-- | ||
59 | hw/misc/edu.c | 4 +- | ||
60 | hw/misc/imx6_src.c | 2 +- | ||
61 | hw/misc/imx7_src.c | 2 +- | ||
62 | hw/net/xen_nic.c | 8 +- | ||
63 | hw/ppc/pegasos2.c | 2 +- | ||
64 | hw/ppc/ppc.c | 4 +- | ||
65 | hw/ppc/spapr.c | 2 +- | ||
66 | hw/ppc/spapr_rng.c | 4 +- | ||
67 | hw/ppc/spapr_softmmu.c | 4 +- | ||
68 | hw/remote/mpqemu-link.c | 20 ++--- | ||
69 | hw/remote/vfio-user-obj.c | 2 +- | ||
70 | hw/s390x/s390-skeys.c | 2 +- | ||
71 | migration/block-dirty-bitmap.c | 4 +- | ||
72 | migration/block.c | 16 ++-- | ||
73 | migration/colo.c | 60 +++++++------- | ||
74 | migration/dirtyrate.c | 12 +-- | ||
75 | migration/migration.c | 52 ++++++------ | ||
76 | migration/ram.c | 12 +-- | ||
77 | replay/replay-internal.c | 2 +- | ||
78 | semihosting/console.c | 8 +- | ||
79 | stubs/iothread-lock.c | 6 +- | ||
80 | system/cpu-throttle.c | 4 +- | ||
81 | system/cpus.c | 51 ++++++------ | ||
82 | system/dirtylimit.c | 4 +- | ||
83 | system/memory.c | 2 +- | ||
84 | system/physmem.c | 8 +- | ||
85 | system/runstate.c | 2 +- | ||
86 | system/watchpoint.c | 4 +- | ||
87 | target/arm/arm-powerctl.c | 14 ++-- | ||
88 | target/arm/helper.c | 4 +- | ||
89 | target/arm/hvf/hvf.c | 8 +- | ||
90 | target/arm/kvm.c | 8 +- | ||
91 | target/arm/ptw.c | 6 +- | ||
92 | target/arm/tcg/helper-a64.c | 8 +- | ||
93 | target/arm/tcg/m_helper.c | 6 +- | ||
94 | target/arm/tcg/op_helper.c | 24 +++--- | ||
95 | target/arm/tcg/psci.c | 2 +- | ||
96 | target/hppa/int_helper.c | 8 +- | ||
97 | target/i386/hvf/hvf.c | 6 +- | ||
98 | target/i386/kvm/hyperv.c | 4 +- | ||
99 | target/i386/kvm/kvm.c | 28 +++---- | ||
100 | target/i386/kvm/xen-emu.c | 14 ++-- | ||
101 | target/i386/nvmm/nvmm-accel-ops.c | 4 +- | ||
102 | target/i386/nvmm/nvmm-all.c | 20 ++--- | ||
103 | target/i386/tcg/sysemu/fpu_helper.c | 6 +- | ||
104 | target/i386/tcg/sysemu/misc_helper.c | 4 +- | ||
105 | target/i386/whpx/whpx-accel-ops.c | 4 +- | ||
106 | target/i386/whpx/whpx-all.c | 24 +++--- | ||
107 | target/loongarch/tcg/csr_helper.c | 4 +- | ||
108 | target/mips/kvm.c | 4 +- | ||
109 | target/mips/tcg/sysemu/cp0_helper.c | 4 +- | ||
110 | target/openrisc/sys_helper.c | 16 ++-- | ||
111 | target/ppc/excp_helper.c | 12 +-- | ||
112 | target/ppc/kvm.c | 4 +- | ||
113 | target/ppc/misc_helper.c | 8 +- | ||
114 | target/ppc/timebase_helper.c | 8 +- | ||
115 | target/s390x/kvm/kvm.c | 4 +- | ||
116 | target/s390x/tcg/misc_helper.c | 118 +++++++++++++-------------- | ||
117 | target/sparc/int32_helper.c | 2 +- | ||
118 | target/sparc/int64_helper.c | 6 +- | ||
119 | target/sparc/win_helper.c | 20 ++--- | ||
120 | target/xtensa/exc_helper.c | 8 +- | ||
121 | ui/spice-core.c | 4 +- | ||
122 | util/async.c | 2 +- | ||
123 | util/main-loop.c | 8 +- | ||
124 | util/qsp.c | 6 +- | ||
125 | util/rcu.c | 14 ++-- | ||
126 | audio/coreaudio.m | 4 +- | ||
127 | memory_ldst.c.inc | 18 ++-- | ||
128 | target/i386/hvf/README.md | 2 +- | ||
129 | ui/cocoa.m | 50 ++++++------ | ||
130 | 95 files changed, 529 insertions(+), 529 deletions(-) | ||
11 | 131 | ||
12 | diff --git a/block.c b/block.c | 132 | diff --git a/include/block/aio-wait.h b/include/block/aio-wait.h |
13 | index XXXXXXX..XXXXXXX 100644 | 133 | index XXXXXXX..XXXXXXX 100644 |
14 | --- a/block.c | 134 | --- a/include/block/aio-wait.h |
15 | +++ b/block.c | 135 | +++ b/include/block/aio-wait.h |
16 | @@ -XXX,XX +XXX,XX @@ static void xdbg_graph_add_node(XDbgBlockGraphConstructor *gr, void *node, | 136 | @@ -XXX,XX +XXX,XX @@ static inline bool in_aio_context_home_thread(AioContext *ctx) |
17 | static void xdbg_graph_add_edge(XDbgBlockGraphConstructor *gr, void *parent, | 137 | } |
18 | const BdrvChild *child) | 138 | |
19 | { | 139 | if (ctx == qemu_get_aio_context()) { |
20 | - typedef struct { | 140 | - return qemu_mutex_iothread_locked(); |
21 | - unsigned int flag; | 141 | + return bql_locked(); |
22 | - BlockPermission num; | 142 | } else { |
23 | - } PermissionMap; | 143 | return false; |
24 | - | 144 | } |
25 | - static const PermissionMap permissions[] = { | 145 | diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h |
26 | - { BLK_PERM_CONSISTENT_READ, BLOCK_PERMISSION_CONSISTENT_READ }, | 146 | index XXXXXXX..XXXXXXX 100644 |
27 | - { BLK_PERM_WRITE, BLOCK_PERMISSION_WRITE }, | 147 | --- a/include/qemu/main-loop.h |
28 | - { BLK_PERM_WRITE_UNCHANGED, BLOCK_PERMISSION_WRITE_UNCHANGED }, | 148 | +++ b/include/qemu/main-loop.h |
29 | - { BLK_PERM_RESIZE, BLOCK_PERMISSION_RESIZE }, | 149 | @@ -XXX,XX +XXX,XX @@ GSource *iohandler_get_g_source(void); |
30 | - { BLK_PERM_GRAPH_MOD, BLOCK_PERMISSION_GRAPH_MOD }, | 150 | AioContext *iohandler_get_aio_context(void); |
31 | - { 0, 0 } | 151 | |
32 | - }; | 152 | /** |
33 | - const PermissionMap *p; | 153 | - * qemu_mutex_iothread_locked: Return lock status of the main loop mutex. |
34 | + BlockPermission qapi_perm; | 154 | + * bql_locked: Return lock status of the Big QEMU Lock (BQL) |
35 | XDbgBlockGraphEdge *edge; | 155 | * |
36 | 156 | - * The main loop mutex is the coarsest lock in QEMU, and as such it | |
37 | - QEMU_BUILD_BUG_ON(1UL << (ARRAY_SIZE(permissions) - 1) != BLK_PERM_ALL + 1); | 157 | + * The Big QEMU Lock (BQL) is the coarsest lock in QEMU, and as such it |
38 | - | 158 | * must always be taken outside other locks. This function helps |
39 | edge = g_new0(XDbgBlockGraphEdge, 1); | 159 | * functions take different paths depending on whether the current |
40 | 160 | - * thread is running within the main loop mutex. | |
41 | edge->parent = xdbg_graph_node_num(gr, parent); | 161 | + * thread is running within the BQL. |
42 | edge->child = xdbg_graph_node_num(gr, child->bs); | 162 | * |
43 | edge->name = g_strdup(child->name); | 163 | * This function should never be used in the block layer, because |
44 | 164 | * unit tests, block layer tools and qemu-storage-daemon do not | |
45 | - for (p = permissions; p->flag; p++) { | 165 | * have a BQL. |
46 | - if (p->flag & child->perm) { | 166 | * Please instead refer to qemu_in_main_thread(). |
47 | - QAPI_LIST_ADD(edge->perm, p->num); | 167 | */ |
48 | + for (qapi_perm = 0; qapi_perm < BLOCK_PERMISSION__MAX; qapi_perm++) { | 168 | -bool qemu_mutex_iothread_locked(void); |
49 | + uint64_t flag = bdrv_qapi_perm_to_blk_perm(qapi_perm); | 169 | +bool bql_locked(void); |
50 | + | 170 | |
51 | + if (flag & child->perm) { | 171 | /** |
52 | + QAPI_LIST_ADD(edge->perm, qapi_perm); | 172 | * qemu_in_main_thread: return whether it's possible to safely access |
53 | } | 173 | @@ -XXX,XX +XXX,XX @@ bool qemu_in_main_thread(void); |
54 | - if (p->flag & child->shared_perm) { | 174 | } while (0) |
55 | - QAPI_LIST_ADD(edge->shared_perm, p->num); | 175 | |
56 | + if (flag & child->shared_perm) { | 176 | /** |
57 | + QAPI_LIST_ADD(edge->shared_perm, qapi_perm); | 177 | - * qemu_mutex_lock_iothread: Lock the main loop mutex. |
58 | } | 178 | + * bql_lock: Lock the Big QEMU Lock (BQL). |
59 | } | 179 | * |
180 | - * This function locks the main loop mutex. The mutex is taken by | ||
181 | + * This function locks the Big QEMU Lock (BQL). The lock is taken by | ||
182 | * main() in vl.c and always taken except while waiting on | ||
183 | - * external events (such as with select). The mutex should be taken | ||
184 | + * external events (such as with select). The lock should be taken | ||
185 | * by threads other than the main loop thread when calling | ||
186 | * qemu_bh_new(), qemu_set_fd_handler() and basically all other | ||
187 | * functions documented in this file. | ||
188 | * | ||
189 | - * NOTE: tools currently are single-threaded and qemu_mutex_lock_iothread | ||
190 | + * NOTE: tools currently are single-threaded and bql_lock | ||
191 | * is a no-op there. | ||
192 | */ | ||
193 | -#define qemu_mutex_lock_iothread() \ | ||
194 | - qemu_mutex_lock_iothread_impl(__FILE__, __LINE__) | ||
195 | -void qemu_mutex_lock_iothread_impl(const char *file, int line); | ||
196 | +#define bql_lock() bql_lock_impl(__FILE__, __LINE__) | ||
197 | +void bql_lock_impl(const char *file, int line); | ||
198 | |||
199 | /** | ||
200 | - * qemu_mutex_unlock_iothread: Unlock the main loop mutex. | ||
201 | + * bql_unlock: Unlock the Big QEMU Lock (BQL). | ||
202 | * | ||
203 | - * This function unlocks the main loop mutex. The mutex is taken by | ||
204 | + * This function unlocks the Big QEMU Lock. The lock is taken by | ||
205 | * main() in vl.c and always taken except while waiting on | ||
206 | - * external events (such as with select). The mutex should be unlocked | ||
207 | + * external events (such as with select). The lock should be unlocked | ||
208 | * as soon as possible by threads other than the main loop thread, | ||
209 | * because it prevents the main loop from processing callbacks, | ||
210 | * including timers and bottom halves. | ||
211 | * | ||
212 | - * NOTE: tools currently are single-threaded and qemu_mutex_unlock_iothread | ||
213 | + * NOTE: tools currently are single-threaded and bql_unlock | ||
214 | * is a no-op there. | ||
215 | */ | ||
216 | -void qemu_mutex_unlock_iothread(void); | ||
217 | +void bql_unlock(void); | ||
218 | |||
219 | /** | ||
220 | * QEMU_IOTHREAD_LOCK_GUARD | ||
221 | * | ||
222 | - * Wrap a block of code in a conditional qemu_mutex_{lock,unlock}_iothread. | ||
223 | + * Wrap a block of code in a conditional bql_{lock,unlock}. | ||
224 | */ | ||
225 | typedef struct IOThreadLockAuto IOThreadLockAuto; | ||
226 | |||
227 | static inline IOThreadLockAuto *qemu_iothread_auto_lock(const char *file, | ||
228 | int line) | ||
229 | { | ||
230 | - if (qemu_mutex_iothread_locked()) { | ||
231 | + if (bql_locked()) { | ||
232 | return NULL; | ||
233 | } | ||
234 | - qemu_mutex_lock_iothread_impl(file, line); | ||
235 | + bql_lock_impl(file, line); | ||
236 | /* Anything non-NULL causes the cleanup function to be called */ | ||
237 | return (IOThreadLockAuto *)(uintptr_t)1; | ||
238 | } | ||
239 | |||
240 | static inline void qemu_iothread_auto_unlock(IOThreadLockAuto *l) | ||
241 | { | ||
242 | - qemu_mutex_unlock_iothread(); | ||
243 | + bql_unlock(); | ||
244 | } | ||
245 | |||
246 | G_DEFINE_AUTOPTR_CLEANUP_FUNC(IOThreadLockAuto, qemu_iothread_auto_unlock) | ||
247 | diff --git a/include/qemu/thread.h b/include/qemu/thread.h | ||
248 | index XXXXXXX..XXXXXXX 100644 | ||
249 | --- a/include/qemu/thread.h | ||
250 | +++ b/include/qemu/thread.h | ||
251 | @@ -XXX,XX +XXX,XX @@ typedef void (*QemuCondWaitFunc)(QemuCond *c, QemuMutex *m, const char *f, | ||
252 | typedef bool (*QemuCondTimedWaitFunc)(QemuCond *c, QemuMutex *m, int ms, | ||
253 | const char *f, int l); | ||
254 | |||
255 | -extern QemuMutexLockFunc qemu_bql_mutex_lock_func; | ||
256 | +extern QemuMutexLockFunc bql_mutex_lock_func; | ||
257 | extern QemuMutexLockFunc qemu_mutex_lock_func; | ||
258 | extern QemuMutexTrylockFunc qemu_mutex_trylock_func; | ||
259 | extern QemuRecMutexLockFunc qemu_rec_mutex_lock_func; | ||
260 | diff --git a/accel/accel-blocker.c b/accel/accel-blocker.c | ||
261 | index XXXXXXX..XXXXXXX 100644 | ||
262 | --- a/accel/accel-blocker.c | ||
263 | +++ b/accel/accel-blocker.c | ||
264 | @@ -XXX,XX +XXX,XX @@ void accel_blocker_init(void) | ||
265 | |||
266 | void accel_ioctl_begin(void) | ||
267 | { | ||
268 | - if (likely(qemu_mutex_iothread_locked())) { | ||
269 | + if (likely(bql_locked())) { | ||
270 | return; | ||
271 | } | ||
272 | |||
273 | @@ -XXX,XX +XXX,XX @@ void accel_ioctl_begin(void) | ||
274 | |||
275 | void accel_ioctl_end(void) | ||
276 | { | ||
277 | - if (likely(qemu_mutex_iothread_locked())) { | ||
278 | + if (likely(bql_locked())) { | ||
279 | return; | ||
280 | } | ||
281 | |||
282 | @@ -XXX,XX +XXX,XX @@ void accel_ioctl_end(void) | ||
283 | |||
284 | void accel_cpu_ioctl_begin(CPUState *cpu) | ||
285 | { | ||
286 | - if (unlikely(qemu_mutex_iothread_locked())) { | ||
287 | + if (unlikely(bql_locked())) { | ||
288 | return; | ||
289 | } | ||
290 | |||
291 | @@ -XXX,XX +XXX,XX @@ void accel_cpu_ioctl_begin(CPUState *cpu) | ||
292 | |||
293 | void accel_cpu_ioctl_end(CPUState *cpu) | ||
294 | { | ||
295 | - if (unlikely(qemu_mutex_iothread_locked())) { | ||
296 | + if (unlikely(bql_locked())) { | ||
297 | return; | ||
298 | } | ||
299 | |||
300 | @@ -XXX,XX +XXX,XX @@ void accel_ioctl_inhibit_begin(void) | ||
301 | * We allow to inhibit only when holding the BQL, so we can identify | ||
302 | * when an inhibitor wants to issue an ioctl easily. | ||
303 | */ | ||
304 | - g_assert(qemu_mutex_iothread_locked()); | ||
305 | + g_assert(bql_locked()); | ||
306 | |||
307 | /* Block further invocations of the ioctls outside the BQL. */ | ||
308 | CPU_FOREACH(cpu) { | ||
309 | diff --git a/accel/dummy-cpus.c b/accel/dummy-cpus.c | ||
310 | index XXXXXXX..XXXXXXX 100644 | ||
311 | --- a/accel/dummy-cpus.c | ||
312 | +++ b/accel/dummy-cpus.c | ||
313 | @@ -XXX,XX +XXX,XX @@ static void *dummy_cpu_thread_fn(void *arg) | ||
314 | |||
315 | rcu_register_thread(); | ||
316 | |||
317 | - qemu_mutex_lock_iothread(); | ||
318 | + bql_lock(); | ||
319 | qemu_thread_get_self(cpu->thread); | ||
320 | cpu->thread_id = qemu_get_thread_id(); | ||
321 | cpu->neg.can_do_io = true; | ||
322 | @@ -XXX,XX +XXX,XX @@ static void *dummy_cpu_thread_fn(void *arg) | ||
323 | qemu_guest_random_seed_thread_part2(cpu->random_seed); | ||
324 | |||
325 | do { | ||
326 | - qemu_mutex_unlock_iothread(); | ||
327 | + bql_unlock(); | ||
328 | #ifndef _WIN32 | ||
329 | do { | ||
330 | int sig; | ||
331 | @@ -XXX,XX +XXX,XX @@ static void *dummy_cpu_thread_fn(void *arg) | ||
332 | #else | ||
333 | qemu_sem_wait(&cpu->sem); | ||
334 | #endif | ||
335 | - qemu_mutex_lock_iothread(); | ||
336 | + bql_lock(); | ||
337 | qemu_wait_io_event(cpu); | ||
338 | } while (!cpu->unplug); | ||
339 | |||
340 | - qemu_mutex_unlock_iothread(); | ||
341 | + bql_unlock(); | ||
342 | rcu_unregister_thread(); | ||
343 | return NULL; | ||
344 | } | ||
345 | diff --git a/accel/hvf/hvf-accel-ops.c b/accel/hvf/hvf-accel-ops.c | ||
346 | index XXXXXXX..XXXXXXX 100644 | ||
347 | --- a/accel/hvf/hvf-accel-ops.c | ||
348 | +++ b/accel/hvf/hvf-accel-ops.c | ||
349 | @@ -XXX,XX +XXX,XX @@ static void *hvf_cpu_thread_fn(void *arg) | ||
350 | |||
351 | rcu_register_thread(); | ||
352 | |||
353 | - qemu_mutex_lock_iothread(); | ||
354 | + bql_lock(); | ||
355 | qemu_thread_get_self(cpu->thread); | ||
356 | |||
357 | cpu->thread_id = qemu_get_thread_id(); | ||
358 | @@ -XXX,XX +XXX,XX @@ static void *hvf_cpu_thread_fn(void *arg) | ||
359 | |||
360 | hvf_vcpu_destroy(cpu); | ||
361 | cpu_thread_signal_destroyed(cpu); | ||
362 | - qemu_mutex_unlock_iothread(); | ||
363 | + bql_unlock(); | ||
364 | rcu_unregister_thread(); | ||
365 | return NULL; | ||
366 | } | ||
367 | diff --git a/accel/kvm/kvm-accel-ops.c b/accel/kvm/kvm-accel-ops.c | ||
368 | index XXXXXXX..XXXXXXX 100644 | ||
369 | --- a/accel/kvm/kvm-accel-ops.c | ||
370 | +++ b/accel/kvm/kvm-accel-ops.c | ||
371 | @@ -XXX,XX +XXX,XX @@ static void *kvm_vcpu_thread_fn(void *arg) | ||
372 | |||
373 | rcu_register_thread(); | ||
374 | |||
375 | - qemu_mutex_lock_iothread(); | ||
376 | + bql_lock(); | ||
377 | qemu_thread_get_self(cpu->thread); | ||
378 | cpu->thread_id = qemu_get_thread_id(); | ||
379 | cpu->neg.can_do_io = true; | ||
380 | @@ -XXX,XX +XXX,XX @@ static void *kvm_vcpu_thread_fn(void *arg) | ||
381 | |||
382 | kvm_destroy_vcpu(cpu); | ||
383 | cpu_thread_signal_destroyed(cpu); | ||
384 | - qemu_mutex_unlock_iothread(); | ||
385 | + bql_unlock(); | ||
386 | rcu_unregister_thread(); | ||
387 | return NULL; | ||
388 | } | ||
389 | diff --git a/accel/kvm/kvm-all.c b/accel/kvm/kvm-all.c | ||
390 | index XXXXXXX..XXXXXXX 100644 | ||
391 | --- a/accel/kvm/kvm-all.c | ||
392 | +++ b/accel/kvm/kvm-all.c | ||
393 | @@ -XXX,XX +XXX,XX @@ static void kvm_dirty_ring_flush(void) | ||
394 | * should always be with BQL held, serialization is guaranteed. | ||
395 | * However, let's be sure of it. | ||
396 | */ | ||
397 | - assert(qemu_mutex_iothread_locked()); | ||
398 | + assert(bql_locked()); | ||
399 | /* | ||
400 | * First make sure to flush the hardware buffers by kicking all | ||
401 | * vcpus out in a synchronous way. | ||
402 | @@ -XXX,XX +XXX,XX @@ static void *kvm_dirty_ring_reaper_thread(void *data) | ||
403 | trace_kvm_dirty_ring_reaper("wakeup"); | ||
404 | r->reaper_state = KVM_DIRTY_RING_REAPER_REAPING; | ||
405 | |||
406 | - qemu_mutex_lock_iothread(); | ||
407 | + bql_lock(); | ||
408 | kvm_dirty_ring_reap(s, NULL); | ||
409 | - qemu_mutex_unlock_iothread(); | ||
410 | + bql_unlock(); | ||
411 | |||
412 | r->reaper_iteration++; | ||
413 | } | ||
414 | @@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu) | ||
415 | return EXCP_HLT; | ||
416 | } | ||
417 | |||
418 | - qemu_mutex_unlock_iothread(); | ||
419 | + bql_unlock(); | ||
420 | cpu_exec_start(cpu); | ||
421 | |||
422 | do { | ||
423 | @@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu) | ||
424 | |||
425 | #ifdef KVM_HAVE_MCE_INJECTION | ||
426 | if (unlikely(have_sigbus_pending)) { | ||
427 | - qemu_mutex_lock_iothread(); | ||
428 | + bql_lock(); | ||
429 | kvm_arch_on_sigbus_vcpu(cpu, pending_sigbus_code, | ||
430 | pending_sigbus_addr); | ||
431 | have_sigbus_pending = false; | ||
432 | - qemu_mutex_unlock_iothread(); | ||
433 | + bql_unlock(); | ||
434 | } | ||
435 | #endif | ||
436 | |||
437 | @@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu) | ||
438 | * still full. Got kicked by KVM_RESET_DIRTY_RINGS. | ||
439 | */ | ||
440 | trace_kvm_dirty_ring_full(cpu->cpu_index); | ||
441 | - qemu_mutex_lock_iothread(); | ||
442 | + bql_lock(); | ||
443 | /* | ||
444 | * We throttle vCPU by making it sleep once it exit from kernel | ||
445 | * due to dirty ring full. In the dirtylimit scenario, reaping | ||
446 | @@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu) | ||
447 | } else { | ||
448 | kvm_dirty_ring_reap(kvm_state, NULL); | ||
449 | } | ||
450 | - qemu_mutex_unlock_iothread(); | ||
451 | + bql_unlock(); | ||
452 | dirtylimit_vcpu_execute(cpu); | ||
453 | ret = 0; | ||
454 | break; | ||
455 | @@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu) | ||
456 | break; | ||
457 | case KVM_SYSTEM_EVENT_CRASH: | ||
458 | kvm_cpu_synchronize_state(cpu); | ||
459 | - qemu_mutex_lock_iothread(); | ||
460 | + bql_lock(); | ||
461 | qemu_system_guest_panicked(cpu_get_crash_info(cpu)); | ||
462 | - qemu_mutex_unlock_iothread(); | ||
463 | + bql_unlock(); | ||
464 | ret = 0; | ||
465 | break; | ||
466 | default: | ||
467 | @@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu) | ||
468 | } while (ret == 0); | ||
469 | |||
470 | cpu_exec_end(cpu); | ||
471 | - qemu_mutex_lock_iothread(); | ||
472 | + bql_lock(); | ||
473 | |||
474 | if (ret < 0) { | ||
475 | cpu_dump_state(cpu, stderr, CPU_DUMP_CODE); | ||
476 | diff --git a/accel/tcg/cpu-exec.c b/accel/tcg/cpu-exec.c | ||
477 | index XXXXXXX..XXXXXXX 100644 | ||
478 | --- a/accel/tcg/cpu-exec.c | ||
479 | +++ b/accel/tcg/cpu-exec.c | ||
480 | @@ -XXX,XX +XXX,XX @@ static void cpu_exec_longjmp_cleanup(CPUState *cpu) | ||
481 | tcg_ctx->gen_tb = NULL; | ||
482 | } | ||
483 | #endif | ||
484 | - if (qemu_mutex_iothread_locked()) { | ||
485 | - qemu_mutex_unlock_iothread(); | ||
486 | + if (bql_locked()) { | ||
487 | + bql_unlock(); | ||
488 | } | ||
489 | assert_no_pages_locked(); | ||
490 | } | ||
491 | @@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_halt(CPUState *cpu) | ||
492 | #if defined(TARGET_I386) | ||
493 | if (cpu->interrupt_request & CPU_INTERRUPT_POLL) { | ||
494 | X86CPU *x86_cpu = X86_CPU(cpu); | ||
495 | - qemu_mutex_lock_iothread(); | ||
496 | + bql_lock(); | ||
497 | apic_poll_irq(x86_cpu->apic_state); | ||
498 | cpu_reset_interrupt(cpu, CPU_INTERRUPT_POLL); | ||
499 | - qemu_mutex_unlock_iothread(); | ||
500 | + bql_unlock(); | ||
501 | } | ||
502 | #endif /* TARGET_I386 */ | ||
503 | if (!cpu_has_work(cpu)) { | ||
504 | @@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_exception(CPUState *cpu, int *ret) | ||
505 | #else | ||
506 | if (replay_exception()) { | ||
507 | CPUClass *cc = CPU_GET_CLASS(cpu); | ||
508 | - qemu_mutex_lock_iothread(); | ||
509 | + bql_lock(); | ||
510 | cc->tcg_ops->do_interrupt(cpu); | ||
511 | - qemu_mutex_unlock_iothread(); | ||
512 | + bql_unlock(); | ||
513 | cpu->exception_index = -1; | ||
514 | |||
515 | if (unlikely(cpu->singlestep_enabled)) { | ||
516 | @@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu, | ||
517 | |||
518 | if (unlikely(qatomic_read(&cpu->interrupt_request))) { | ||
519 | int interrupt_request; | ||
520 | - qemu_mutex_lock_iothread(); | ||
521 | + bql_lock(); | ||
522 | interrupt_request = cpu->interrupt_request; | ||
523 | if (unlikely(cpu->singlestep_enabled & SSTEP_NOIRQ)) { | ||
524 | /* Mask out external interrupts for this step. */ | ||
525 | @@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu, | ||
526 | if (interrupt_request & CPU_INTERRUPT_DEBUG) { | ||
527 | cpu->interrupt_request &= ~CPU_INTERRUPT_DEBUG; | ||
528 | cpu->exception_index = EXCP_DEBUG; | ||
529 | - qemu_mutex_unlock_iothread(); | ||
530 | + bql_unlock(); | ||
531 | return true; | ||
532 | } | ||
533 | #if !defined(CONFIG_USER_ONLY) | ||
534 | @@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu, | ||
535 | cpu->interrupt_request &= ~CPU_INTERRUPT_HALT; | ||
536 | cpu->halted = 1; | ||
537 | cpu->exception_index = EXCP_HLT; | ||
538 | - qemu_mutex_unlock_iothread(); | ||
539 | + bql_unlock(); | ||
540 | return true; | ||
541 | } | ||
542 | #if defined(TARGET_I386) | ||
543 | @@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu, | ||
544 | cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0, 0); | ||
545 | do_cpu_init(x86_cpu); | ||
546 | cpu->exception_index = EXCP_HALTED; | ||
547 | - qemu_mutex_unlock_iothread(); | ||
548 | + bql_unlock(); | ||
549 | return true; | ||
550 | } | ||
551 | #else | ||
552 | else if (interrupt_request & CPU_INTERRUPT_RESET) { | ||
553 | replay_interrupt(); | ||
554 | cpu_reset(cpu); | ||
555 | - qemu_mutex_unlock_iothread(); | ||
556 | + bql_unlock(); | ||
557 | return true; | ||
558 | } | ||
559 | #endif /* !TARGET_I386 */ | ||
560 | @@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu, | ||
561 | */ | ||
562 | if (unlikely(cpu->singlestep_enabled)) { | ||
563 | cpu->exception_index = EXCP_DEBUG; | ||
564 | - qemu_mutex_unlock_iothread(); | ||
565 | + bql_unlock(); | ||
566 | return true; | ||
567 | } | ||
568 | cpu->exception_index = -1; | ||
569 | @@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu, | ||
570 | } | ||
571 | |||
572 | /* If we exit via cpu_loop_exit/longjmp it is reset in cpu_exec */ | ||
573 | - qemu_mutex_unlock_iothread(); | ||
574 | + bql_unlock(); | ||
575 | } | ||
576 | |||
577 | /* Finally, check if we need to exit to the main loop. */ | ||
578 | diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c | ||
579 | index XXXXXXX..XXXXXXX 100644 | ||
580 | --- a/accel/tcg/cputlb.c | ||
581 | +++ b/accel/tcg/cputlb.c | ||
582 | @@ -XXX,XX +XXX,XX @@ static uint64_t do_ld_mmio_beN(CPUState *cpu, CPUTLBEntryFull *full, | ||
583 | section = io_prepare(&mr_offset, cpu, full->xlat_section, attrs, addr, ra); | ||
584 | mr = section->mr; | ||
585 | |||
586 | - qemu_mutex_lock_iothread(); | ||
587 | + bql_lock(); | ||
588 | ret = int_ld_mmio_beN(cpu, full, ret_be, addr, size, mmu_idx, | ||
589 | type, ra, mr, mr_offset); | ||
590 | - qemu_mutex_unlock_iothread(); | ||
591 | + bql_unlock(); | ||
592 | |||
593 | return ret; | ||
594 | } | ||
595 | @@ -XXX,XX +XXX,XX @@ static Int128 do_ld16_mmio_beN(CPUState *cpu, CPUTLBEntryFull *full, | ||
596 | section = io_prepare(&mr_offset, cpu, full->xlat_section, attrs, addr, ra); | ||
597 | mr = section->mr; | ||
598 | |||
599 | - qemu_mutex_lock_iothread(); | ||
600 | + bql_lock(); | ||
601 | a = int_ld_mmio_beN(cpu, full, ret_be, addr, size - 8, mmu_idx, | ||
602 | MMU_DATA_LOAD, ra, mr, mr_offset); | ||
603 | b = int_ld_mmio_beN(cpu, full, ret_be, addr + size - 8, 8, mmu_idx, | ||
604 | MMU_DATA_LOAD, ra, mr, mr_offset + size - 8); | ||
605 | - qemu_mutex_unlock_iothread(); | ||
606 | + bql_unlock(); | ||
607 | |||
608 | return int128_make128(b, a); | ||
609 | } | ||
610 | @@ -XXX,XX +XXX,XX @@ static uint64_t do_st_mmio_leN(CPUState *cpu, CPUTLBEntryFull *full, | ||
611 | section = io_prepare(&mr_offset, cpu, full->xlat_section, attrs, addr, ra); | ||
612 | mr = section->mr; | ||
613 | |||
614 | - qemu_mutex_lock_iothread(); | ||
615 | + bql_lock(); | ||
616 | ret = int_st_mmio_leN(cpu, full, val_le, addr, size, mmu_idx, | ||
617 | ra, mr, mr_offset); | ||
618 | - qemu_mutex_unlock_iothread(); | ||
619 | + bql_unlock(); | ||
620 | |||
621 | return ret; | ||
622 | } | ||
623 | @@ -XXX,XX +XXX,XX @@ static uint64_t do_st16_mmio_leN(CPUState *cpu, CPUTLBEntryFull *full, | ||
624 | section = io_prepare(&mr_offset, cpu, full->xlat_section, attrs, addr, ra); | ||
625 | mr = section->mr; | ||
626 | |||
627 | - qemu_mutex_lock_iothread(); | ||
628 | + bql_lock(); | ||
629 | int_st_mmio_leN(cpu, full, int128_getlo(val_le), addr, 8, | ||
630 | mmu_idx, ra, mr, mr_offset); | ||
631 | ret = int_st_mmio_leN(cpu, full, int128_gethi(val_le), addr + 8, | ||
632 | size - 8, mmu_idx, ra, mr, mr_offset + 8); | ||
633 | - qemu_mutex_unlock_iothread(); | ||
634 | + bql_unlock(); | ||
635 | |||
636 | return ret; | ||
637 | } | ||
638 | diff --git a/accel/tcg/tcg-accel-ops-icount.c b/accel/tcg/tcg-accel-ops-icount.c | ||
639 | index XXXXXXX..XXXXXXX 100644 | ||
640 | --- a/accel/tcg/tcg-accel-ops-icount.c | ||
641 | +++ b/accel/tcg/tcg-accel-ops-icount.c | ||
642 | @@ -XXX,XX +XXX,XX @@ void icount_prepare_for_run(CPUState *cpu, int64_t cpu_budget) | ||
643 | * We're called without the iothread lock, so must take it while | ||
644 | * we're calling timer handlers. | ||
645 | */ | ||
646 | - qemu_mutex_lock_iothread(); | ||
647 | + bql_lock(); | ||
648 | icount_notify_aio_contexts(); | ||
649 | - qemu_mutex_unlock_iothread(); | ||
650 | + bql_unlock(); | ||
651 | } | ||
652 | } | ||
653 | |||
654 | diff --git a/accel/tcg/tcg-accel-ops-mttcg.c b/accel/tcg/tcg-accel-ops-mttcg.c | ||
655 | index XXXXXXX..XXXXXXX 100644 | ||
656 | --- a/accel/tcg/tcg-accel-ops-mttcg.c | ||
657 | +++ b/accel/tcg/tcg-accel-ops-mttcg.c | ||
658 | @@ -XXX,XX +XXX,XX @@ static void *mttcg_cpu_thread_fn(void *arg) | ||
659 | rcu_add_force_rcu_notifier(&force_rcu.notifier); | ||
660 | tcg_register_thread(); | ||
661 | |||
662 | - qemu_mutex_lock_iothread(); | ||
663 | + bql_lock(); | ||
664 | qemu_thread_get_self(cpu->thread); | ||
665 | |||
666 | cpu->thread_id = qemu_get_thread_id(); | ||
667 | @@ -XXX,XX +XXX,XX @@ static void *mttcg_cpu_thread_fn(void *arg) | ||
668 | do { | ||
669 | if (cpu_can_run(cpu)) { | ||
670 | int r; | ||
671 | - qemu_mutex_unlock_iothread(); | ||
672 | + bql_unlock(); | ||
673 | r = tcg_cpus_exec(cpu); | ||
674 | - qemu_mutex_lock_iothread(); | ||
675 | + bql_lock(); | ||
676 | switch (r) { | ||
677 | case EXCP_DEBUG: | ||
678 | cpu_handle_guest_debug(cpu); | ||
679 | @@ -XXX,XX +XXX,XX @@ static void *mttcg_cpu_thread_fn(void *arg) | ||
680 | */ | ||
681 | break; | ||
682 | case EXCP_ATOMIC: | ||
683 | - qemu_mutex_unlock_iothread(); | ||
684 | + bql_unlock(); | ||
685 | cpu_exec_step_atomic(cpu); | ||
686 | - qemu_mutex_lock_iothread(); | ||
687 | + bql_lock(); | ||
688 | default: | ||
689 | /* Ignore everything else? */ | ||
690 | break; | ||
691 | @@ -XXX,XX +XXX,XX @@ static void *mttcg_cpu_thread_fn(void *arg) | ||
692 | } while (!cpu->unplug || cpu_can_run(cpu)); | ||
693 | |||
694 | tcg_cpus_destroy(cpu); | ||
695 | - qemu_mutex_unlock_iothread(); | ||
696 | + bql_unlock(); | ||
697 | rcu_remove_force_rcu_notifier(&force_rcu.notifier); | ||
698 | rcu_unregister_thread(); | ||
699 | return NULL; | ||
700 | diff --git a/accel/tcg/tcg-accel-ops-rr.c b/accel/tcg/tcg-accel-ops-rr.c | ||
701 | index XXXXXXX..XXXXXXX 100644 | ||
702 | --- a/accel/tcg/tcg-accel-ops-rr.c | ||
703 | +++ b/accel/tcg/tcg-accel-ops-rr.c | ||
704 | @@ -XXX,XX +XXX,XX @@ static void *rr_cpu_thread_fn(void *arg) | ||
705 | rcu_add_force_rcu_notifier(&force_rcu); | ||
706 | tcg_register_thread(); | ||
707 | |||
708 | - qemu_mutex_lock_iothread(); | ||
709 | + bql_lock(); | ||
710 | qemu_thread_get_self(cpu->thread); | ||
711 | |||
712 | cpu->thread_id = qemu_get_thread_id(); | ||
713 | @@ -XXX,XX +XXX,XX @@ static void *rr_cpu_thread_fn(void *arg) | ||
714 | /* Only used for icount_enabled() */ | ||
715 | int64_t cpu_budget = 0; | ||
716 | |||
717 | - qemu_mutex_unlock_iothread(); | ||
718 | + bql_unlock(); | ||
719 | replay_mutex_lock(); | ||
720 | - qemu_mutex_lock_iothread(); | ||
721 | + bql_lock(); | ||
722 | |||
723 | if (icount_enabled()) { | ||
724 | int cpu_count = rr_cpu_count(); | ||
725 | @@ -XXX,XX +XXX,XX @@ static void *rr_cpu_thread_fn(void *arg) | ||
726 | if (cpu_can_run(cpu)) { | ||
727 | int r; | ||
728 | |||
729 | - qemu_mutex_unlock_iothread(); | ||
730 | + bql_unlock(); | ||
731 | if (icount_enabled()) { | ||
732 | icount_prepare_for_run(cpu, cpu_budget); | ||
733 | } | ||
734 | @@ -XXX,XX +XXX,XX @@ static void *rr_cpu_thread_fn(void *arg) | ||
735 | if (icount_enabled()) { | ||
736 | icount_process_data(cpu); | ||
737 | } | ||
738 | - qemu_mutex_lock_iothread(); | ||
739 | + bql_lock(); | ||
740 | |||
741 | if (r == EXCP_DEBUG) { | ||
742 | cpu_handle_guest_debug(cpu); | ||
743 | break; | ||
744 | } else if (r == EXCP_ATOMIC) { | ||
745 | - qemu_mutex_unlock_iothread(); | ||
746 | + bql_unlock(); | ||
747 | cpu_exec_step_atomic(cpu); | ||
748 | - qemu_mutex_lock_iothread(); | ||
749 | + bql_lock(); | ||
750 | break; | ||
751 | } | ||
752 | } else if (cpu->stop) { | ||
753 | diff --git a/accel/tcg/tcg-accel-ops.c b/accel/tcg/tcg-accel-ops.c | ||
754 | index XXXXXXX..XXXXXXX 100644 | ||
755 | --- a/accel/tcg/tcg-accel-ops.c | ||
756 | +++ b/accel/tcg/tcg-accel-ops.c | ||
757 | @@ -XXX,XX +XXX,XX @@ static void tcg_cpu_reset_hold(CPUState *cpu) | ||
758 | /* mask must never be zero, except for A20 change call */ | ||
759 | void tcg_handle_interrupt(CPUState *cpu, int mask) | ||
760 | { | ||
761 | - g_assert(qemu_mutex_iothread_locked()); | ||
762 | + g_assert(bql_locked()); | ||
763 | |||
764 | cpu->interrupt_request |= mask; | ||
765 | |||
766 | diff --git a/accel/tcg/translate-all.c b/accel/tcg/translate-all.c | ||
767 | index XXXXXXX..XXXXXXX 100644 | ||
768 | --- a/accel/tcg/translate-all.c | ||
769 | +++ b/accel/tcg/translate-all.c | ||
770 | @@ -XXX,XX +XXX,XX @@ void cpu_io_recompile(CPUState *cpu, uintptr_t retaddr) | ||
771 | |||
772 | void cpu_interrupt(CPUState *cpu, int mask) | ||
773 | { | ||
774 | - g_assert(qemu_mutex_iothread_locked()); | ||
775 | + g_assert(bql_locked()); | ||
776 | cpu->interrupt_request |= mask; | ||
777 | qatomic_set(&cpu->neg.icount_decr.u16.high, -1); | ||
778 | } | ||
779 | diff --git a/cpu-common.c b/cpu-common.c | ||
780 | index XXXXXXX..XXXXXXX 100644 | ||
781 | --- a/cpu-common.c | ||
782 | +++ b/cpu-common.c | ||
783 | @@ -XXX,XX +XXX,XX @@ void process_queued_cpu_work(CPUState *cpu) | ||
784 | * BQL, so it goes to sleep; start_exclusive() is sleeping too, so | ||
785 | * neither CPU can proceed. | ||
786 | */ | ||
787 | - qemu_mutex_unlock_iothread(); | ||
788 | + bql_unlock(); | ||
789 | start_exclusive(); | ||
790 | wi->func(cpu, wi->data); | ||
791 | end_exclusive(); | ||
792 | - qemu_mutex_lock_iothread(); | ||
793 | + bql_lock(); | ||
794 | } else { | ||
795 | wi->func(cpu, wi->data); | ||
796 | } | ||
797 | diff --git a/dump/dump.c b/dump/dump.c | ||
798 | index XXXXXXX..XXXXXXX 100644 | ||
799 | --- a/dump/dump.c | ||
800 | +++ b/dump/dump.c | ||
801 | @@ -XXX,XX +XXX,XX @@ static int dump_cleanup(DumpState *s) | ||
802 | s->guest_note = NULL; | ||
803 | if (s->resume) { | ||
804 | if (s->detached) { | ||
805 | - qemu_mutex_lock_iothread(); | ||
806 | + bql_lock(); | ||
807 | } | ||
808 | vm_start(); | ||
809 | if (s->detached) { | ||
810 | - qemu_mutex_unlock_iothread(); | ||
811 | + bql_unlock(); | ||
812 | } | ||
813 | } | ||
814 | migrate_del_blocker(&dump_migration_blocker); | ||
815 | diff --git a/hw/core/cpu-common.c b/hw/core/cpu-common.c | ||
816 | index XXXXXXX..XXXXXXX 100644 | ||
817 | --- a/hw/core/cpu-common.c | ||
818 | +++ b/hw/core/cpu-common.c | ||
819 | @@ -XXX,XX +XXX,XX @@ CPUState *cpu_create(const char *typename) | ||
820 | * BQL here if we need to. cpu_interrupt assumes it is held.*/ | ||
821 | void cpu_reset_interrupt(CPUState *cpu, int mask) | ||
822 | { | ||
823 | - bool need_lock = !qemu_mutex_iothread_locked(); | ||
824 | + bool need_lock = !bql_locked(); | ||
825 | |||
826 | if (need_lock) { | ||
827 | - qemu_mutex_lock_iothread(); | ||
828 | + bql_lock(); | ||
829 | } | ||
830 | cpu->interrupt_request &= ~mask; | ||
831 | if (need_lock) { | ||
832 | - qemu_mutex_unlock_iothread(); | ||
833 | + bql_unlock(); | ||
834 | } | ||
835 | } | ||
836 | |||
837 | diff --git a/hw/i386/intel_iommu.c b/hw/i386/intel_iommu.c | ||
838 | index XXXXXXX..XXXXXXX 100644 | ||
839 | --- a/hw/i386/intel_iommu.c | ||
840 | +++ b/hw/i386/intel_iommu.c | ||
841 | @@ -XXX,XX +XXX,XX @@ static bool vtd_switch_address_space(VTDAddressSpace *as) | ||
842 | { | ||
843 | bool use_iommu, pt; | ||
844 | /* Whether we need to take the BQL on our own */ | ||
845 | - bool take_bql = !qemu_mutex_iothread_locked(); | ||
846 | + bool take_bql = !bql_locked(); | ||
847 | |||
848 | assert(as); | ||
849 | |||
850 | @@ -XXX,XX +XXX,XX @@ static bool vtd_switch_address_space(VTDAddressSpace *as) | ||
851 | * it. We'd better make sure we have had it already, or, take it. | ||
852 | */ | ||
853 | if (take_bql) { | ||
854 | - qemu_mutex_lock_iothread(); | ||
855 | + bql_lock(); | ||
856 | } | ||
857 | |||
858 | /* Turn off first then on the other */ | ||
859 | @@ -XXX,XX +XXX,XX @@ static bool vtd_switch_address_space(VTDAddressSpace *as) | ||
860 | } | ||
861 | |||
862 | if (take_bql) { | ||
863 | - qemu_mutex_unlock_iothread(); | ||
864 | + bql_unlock(); | ||
865 | } | ||
866 | |||
867 | return use_iommu; | ||
868 | diff --git a/hw/i386/kvm/xen_evtchn.c b/hw/i386/kvm/xen_evtchn.c | ||
869 | index XXXXXXX..XXXXXXX 100644 | ||
870 | --- a/hw/i386/kvm/xen_evtchn.c | ||
871 | +++ b/hw/i386/kvm/xen_evtchn.c | ||
872 | @@ -XXX,XX +XXX,XX @@ void xen_evtchn_set_callback_level(int level) | ||
873 | * effect immediately. That just leaves interdomain loopback as the case | ||
874 | * which uses the BH. | ||
875 | */ | ||
876 | - if (!qemu_mutex_iothread_locked()) { | ||
877 | + if (!bql_locked()) { | ||
878 | qemu_bh_schedule(s->gsi_bh); | ||
879 | return; | ||
880 | } | ||
881 | @@ -XXX,XX +XXX,XX @@ int xen_evtchn_set_callback_param(uint64_t param) | ||
882 | * We need the BQL because set_callback_pci_intx() may call into PCI code, | ||
883 | * and because we may need to manipulate the old and new GSI levels. | ||
884 | */ | ||
885 | - assert(qemu_mutex_iothread_locked()); | ||
886 | + assert(bql_locked()); | ||
887 | qemu_mutex_lock(&s->port_lock); | ||
888 | |||
889 | switch (type) { | ||
890 | @@ -XXX,XX +XXX,XX @@ static int close_port(XenEvtchnState *s, evtchn_port_t port, | ||
891 | XenEvtchnPort *p = &s->port_table[port]; | ||
892 | |||
893 | /* Because it *might* be a PIRQ port */ | ||
894 | - assert(qemu_mutex_iothread_locked()); | ||
895 | + assert(bql_locked()); | ||
896 | |||
897 | switch (p->type) { | ||
898 | case EVTCHNSTAT_closed: | ||
899 | @@ -XXX,XX +XXX,XX @@ int xen_evtchn_soft_reset(void) | ||
900 | return -ENOTSUP; | ||
901 | } | ||
902 | |||
903 | - assert(qemu_mutex_iothread_locked()); | ||
904 | + assert(bql_locked()); | ||
905 | |||
906 | qemu_mutex_lock(&s->port_lock); | ||
907 | |||
908 | @@ -XXX,XX +XXX,XX @@ bool xen_evtchn_set_gsi(int gsi, int level) | ||
909 | XenEvtchnState *s = xen_evtchn_singleton; | ||
910 | int pirq; | ||
911 | |||
912 | - assert(qemu_mutex_iothread_locked()); | ||
913 | + assert(bql_locked()); | ||
914 | |||
915 | if (!s || gsi < 0 || gsi >= IOAPIC_NUM_PINS) { | ||
916 | return false; | ||
917 | @@ -XXX,XX +XXX,XX @@ void xen_evtchn_snoop_msi(PCIDevice *dev, bool is_msix, unsigned int vector, | ||
918 | return; | ||
919 | } | ||
920 | |||
921 | - assert(qemu_mutex_iothread_locked()); | ||
922 | + assert(bql_locked()); | ||
923 | |||
924 | pirq = msi_pirq_target(addr, data); | ||
925 | |||
926 | @@ -XXX,XX +XXX,XX @@ int xen_evtchn_translate_pirq_msi(struct kvm_irq_routing_entry *route, | ||
927 | return 1; /* Not a PIRQ */ | ||
928 | } | ||
929 | |||
930 | - assert(qemu_mutex_iothread_locked()); | ||
931 | + assert(bql_locked()); | ||
932 | |||
933 | pirq = msi_pirq_target(address, data); | ||
934 | if (!pirq || pirq >= s->nr_pirqs) { | ||
935 | @@ -XXX,XX +XXX,XX @@ bool xen_evtchn_deliver_pirq_msi(uint64_t address, uint32_t data) | ||
936 | return false; | ||
937 | } | ||
938 | |||
939 | - assert(qemu_mutex_iothread_locked()); | ||
940 | + assert(bql_locked()); | ||
941 | |||
942 | pirq = msi_pirq_target(address, data); | ||
943 | if (!pirq || pirq >= s->nr_pirqs) { | ||
944 | diff --git a/hw/i386/kvm/xen_overlay.c b/hw/i386/kvm/xen_overlay.c | ||
945 | index XXXXXXX..XXXXXXX 100644 | ||
946 | --- a/hw/i386/kvm/xen_overlay.c | ||
947 | +++ b/hw/i386/kvm/xen_overlay.c | ||
948 | @@ -XXX,XX +XXX,XX @@ int xen_overlay_map_shinfo_page(uint64_t gpa) | ||
949 | return -ENOENT; | ||
950 | } | ||
951 | |||
952 | - assert(qemu_mutex_iothread_locked()); | ||
953 | + assert(bql_locked()); | ||
954 | |||
955 | if (s->shinfo_gpa) { | ||
956 | /* If removing shinfo page, turn the kernel magic off first */ | ||
957 | diff --git a/hw/i386/kvm/xen_xenstore.c b/hw/i386/kvm/xen_xenstore.c | ||
958 | index XXXXXXX..XXXXXXX 100644 | ||
959 | --- a/hw/i386/kvm/xen_xenstore.c | ||
960 | +++ b/hw/i386/kvm/xen_xenstore.c | ||
961 | @@ -XXX,XX +XXX,XX @@ static void fire_watch_cb(void *opaque, const char *path, const char *token) | ||
962 | { | ||
963 | XenXenstoreState *s = opaque; | ||
964 | |||
965 | - assert(qemu_mutex_iothread_locked()); | ||
966 | + assert(bql_locked()); | ||
967 | |||
968 | /* | ||
969 | * If there's a response pending, we obviously can't scribble over | ||
970 | diff --git a/hw/intc/arm_gicv3_cpuif.c b/hw/intc/arm_gicv3_cpuif.c | ||
971 | index XXXXXXX..XXXXXXX 100644 | ||
972 | --- a/hw/intc/arm_gicv3_cpuif.c | ||
973 | +++ b/hw/intc/arm_gicv3_cpuif.c | ||
974 | @@ -XXX,XX +XXX,XX @@ void gicv3_cpuif_update(GICv3CPUState *cs) | ||
975 | ARMCPU *cpu = ARM_CPU(cs->cpu); | ||
976 | CPUARMState *env = &cpu->env; | ||
977 | |||
978 | - g_assert(qemu_mutex_iothread_locked()); | ||
979 | + g_assert(bql_locked()); | ||
980 | |||
981 | trace_gicv3_cpuif_update(gicv3_redist_affid(cs), cs->hppi.irq, | ||
982 | cs->hppi.grp, cs->hppi.prio); | ||
983 | diff --git a/hw/intc/s390_flic.c b/hw/intc/s390_flic.c | ||
984 | index XXXXXXX..XXXXXXX 100644 | ||
985 | --- a/hw/intc/s390_flic.c | ||
986 | +++ b/hw/intc/s390_flic.c | ||
987 | @@ -XXX,XX +XXX,XX @@ static int qemu_s390_clear_io_flic(S390FLICState *fs, uint16_t subchannel_id, | ||
988 | QEMUS390FlicIO *cur, *next; | ||
989 | uint8_t isc; | ||
990 | |||
991 | - g_assert(qemu_mutex_iothread_locked()); | ||
992 | + g_assert(bql_locked()); | ||
993 | if (!(flic->pending & FLIC_PENDING_IO)) { | ||
994 | return 0; | ||
995 | } | ||
996 | @@ -XXX,XX +XXX,XX @@ uint32_t qemu_s390_flic_dequeue_service(QEMUS390FLICState *flic) | ||
997 | { | ||
998 | uint32_t tmp; | ||
999 | |||
1000 | - g_assert(qemu_mutex_iothread_locked()); | ||
1001 | + g_assert(bql_locked()); | ||
1002 | g_assert(flic->pending & FLIC_PENDING_SERVICE); | ||
1003 | tmp = flic->service_param; | ||
1004 | flic->service_param = 0; | ||
1005 | @@ -XXX,XX +XXX,XX @@ QEMUS390FlicIO *qemu_s390_flic_dequeue_io(QEMUS390FLICState *flic, uint64_t cr6) | ||
1006 | QEMUS390FlicIO *io; | ||
1007 | uint8_t isc; | ||
1008 | |||
1009 | - g_assert(qemu_mutex_iothread_locked()); | ||
1010 | + g_assert(bql_locked()); | ||
1011 | if (!(flic->pending & CR6_TO_PENDING_IO(cr6))) { | ||
1012 | return NULL; | ||
1013 | } | ||
1014 | @@ -XXX,XX +XXX,XX @@ QEMUS390FlicIO *qemu_s390_flic_dequeue_io(QEMUS390FLICState *flic, uint64_t cr6) | ||
1015 | |||
1016 | void qemu_s390_flic_dequeue_crw_mchk(QEMUS390FLICState *flic) | ||
1017 | { | ||
1018 | - g_assert(qemu_mutex_iothread_locked()); | ||
1019 | + g_assert(bql_locked()); | ||
1020 | g_assert(flic->pending & FLIC_PENDING_MCHK_CR); | ||
1021 | flic->pending &= ~FLIC_PENDING_MCHK_CR; | ||
1022 | } | ||
1023 | @@ -XXX,XX +XXX,XX @@ static void qemu_s390_inject_service(S390FLICState *fs, uint32_t parm) | ||
1024 | { | ||
1025 | QEMUS390FLICState *flic = s390_get_qemu_flic(fs); | ||
1026 | |||
1027 | - g_assert(qemu_mutex_iothread_locked()); | ||
1028 | + g_assert(bql_locked()); | ||
1029 | /* multiplexing is good enough for sclp - kvm does it internally as well */ | ||
1030 | flic->service_param |= parm; | ||
1031 | flic->pending |= FLIC_PENDING_SERVICE; | ||
1032 | @@ -XXX,XX +XXX,XX @@ static void qemu_s390_inject_io(S390FLICState *fs, uint16_t subchannel_id, | ||
1033 | QEMUS390FLICState *flic = s390_get_qemu_flic(fs); | ||
1034 | QEMUS390FlicIO *io; | ||
1035 | |||
1036 | - g_assert(qemu_mutex_iothread_locked()); | ||
1037 | + g_assert(bql_locked()); | ||
1038 | io = g_new0(QEMUS390FlicIO, 1); | ||
1039 | io->id = subchannel_id; | ||
1040 | io->nr = subchannel_nr; | ||
1041 | @@ -XXX,XX +XXX,XX @@ static void qemu_s390_inject_crw_mchk(S390FLICState *fs) | ||
1042 | { | ||
1043 | QEMUS390FLICState *flic = s390_get_qemu_flic(fs); | ||
1044 | |||
1045 | - g_assert(qemu_mutex_iothread_locked()); | ||
1046 | + g_assert(bql_locked()); | ||
1047 | flic->pending |= FLIC_PENDING_MCHK_CR; | ||
1048 | |||
1049 | qemu_s390_flic_notify(FLIC_PENDING_MCHK_CR); | ||
1050 | @@ -XXX,XX +XXX,XX @@ bool qemu_s390_flic_has_crw_mchk(QEMUS390FLICState *flic) | ||
1051 | |||
1052 | bool qemu_s390_flic_has_any(QEMUS390FLICState *flic) | ||
1053 | { | ||
1054 | - g_assert(qemu_mutex_iothread_locked()); | ||
1055 | + g_assert(bql_locked()); | ||
1056 | return !!flic->pending; | ||
1057 | } | ||
1058 | |||
1059 | @@ -XXX,XX +XXX,XX @@ static void qemu_s390_flic_reset(DeviceState *dev) | ||
1060 | QEMUS390FlicIO *cur, *next; | ||
1061 | int isc; | ||
1062 | |||
1063 | - g_assert(qemu_mutex_iothread_locked()); | ||
1064 | + g_assert(bql_locked()); | ||
1065 | flic->simm = 0; | ||
1066 | flic->nimm = 0; | ||
1067 | flic->pending = 0; | ||
1068 | diff --git a/hw/misc/edu.c b/hw/misc/edu.c | ||
1069 | index XXXXXXX..XXXXXXX 100644 | ||
1070 | --- a/hw/misc/edu.c | ||
1071 | +++ b/hw/misc/edu.c | ||
1072 | @@ -XXX,XX +XXX,XX @@ static void *edu_fact_thread(void *opaque) | ||
1073 | smp_mb__after_rmw(); | ||
1074 | |||
1075 | if (qatomic_read(&edu->status) & EDU_STATUS_IRQFACT) { | ||
1076 | - qemu_mutex_lock_iothread(); | ||
1077 | + bql_lock(); | ||
1078 | edu_raise_irq(edu, FACT_IRQ); | ||
1079 | - qemu_mutex_unlock_iothread(); | ||
1080 | + bql_unlock(); | ||
1081 | } | ||
1082 | } | ||
1083 | |||
1084 | diff --git a/hw/misc/imx6_src.c b/hw/misc/imx6_src.c | ||
1085 | index XXXXXXX..XXXXXXX 100644 | ||
1086 | --- a/hw/misc/imx6_src.c | ||
1087 | +++ b/hw/misc/imx6_src.c | ||
1088 | @@ -XXX,XX +XXX,XX @@ static void imx6_clear_reset_bit(CPUState *cpu, run_on_cpu_data data) | ||
1089 | struct SRCSCRResetInfo *ri = data.host_ptr; | ||
1090 | IMX6SRCState *s = ri->s; | ||
1091 | |||
1092 | - assert(qemu_mutex_iothread_locked()); | ||
1093 | + assert(bql_locked()); | ||
1094 | |||
1095 | s->regs[SRC_SCR] = deposit32(s->regs[SRC_SCR], ri->reset_bit, 1, 0); | ||
1096 | DPRINTF("reg[%s] <= 0x%" PRIx32 "\n", | ||
1097 | diff --git a/hw/misc/imx7_src.c b/hw/misc/imx7_src.c | ||
1098 | index XXXXXXX..XXXXXXX 100644 | ||
1099 | --- a/hw/misc/imx7_src.c | ||
1100 | +++ b/hw/misc/imx7_src.c | ||
1101 | @@ -XXX,XX +XXX,XX @@ static void imx7_clear_reset_bit(CPUState *cpu, run_on_cpu_data data) | ||
1102 | struct SRCSCRResetInfo *ri = data.host_ptr; | ||
1103 | IMX7SRCState *s = ri->s; | ||
1104 | |||
1105 | - assert(qemu_mutex_iothread_locked()); | ||
1106 | + assert(bql_locked()); | ||
1107 | |||
1108 | s->regs[SRC_A7RCR0] = deposit32(s->regs[SRC_A7RCR0], ri->reset_bit, 1, 0); | ||
1109 | |||
1110 | diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c | ||
1111 | index XXXXXXX..XXXXXXX 100644 | ||
1112 | --- a/hw/net/xen_nic.c | ||
1113 | +++ b/hw/net/xen_nic.c | ||
1114 | @@ -XXX,XX +XXX,XX @@ static bool net_tx_packets(struct XenNetDev *netdev) | ||
1115 | void *page; | ||
1116 | void *tmpbuf = NULL; | ||
1117 | |||
1118 | - assert(qemu_mutex_iothread_locked()); | ||
1119 | + assert(bql_locked()); | ||
1120 | |||
1121 | for (;;) { | ||
1122 | rc = netdev->tx_ring.req_cons; | ||
1123 | @@ -XXX,XX +XXX,XX @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size | ||
1124 | RING_IDX rc, rp; | ||
1125 | void *page; | ||
1126 | |||
1127 | - assert(qemu_mutex_iothread_locked()); | ||
1128 | + assert(bql_locked()); | ||
1129 | |||
1130 | if (xen_device_backend_get_state(&netdev->xendev) != XenbusStateConnected) { | ||
1131 | return -1; | ||
1132 | @@ -XXX,XX +XXX,XX @@ static bool xen_netdev_connect(XenDevice *xendev, Error **errp) | ||
1133 | XenNetDev *netdev = XEN_NET_DEVICE(xendev); | ||
1134 | unsigned int port, rx_copy; | ||
1135 | |||
1136 | - assert(qemu_mutex_iothread_locked()); | ||
1137 | + assert(bql_locked()); | ||
1138 | |||
1139 | if (xen_device_frontend_scanf(xendev, "tx-ring-ref", "%u", | ||
1140 | &netdev->tx_ring_ref) != 1) { | ||
1141 | @@ -XXX,XX +XXX,XX @@ static void xen_netdev_disconnect(XenDevice *xendev, Error **errp) | ||
1142 | |||
1143 | trace_xen_netdev_disconnect(netdev->dev); | ||
1144 | |||
1145 | - assert(qemu_mutex_iothread_locked()); | ||
1146 | + assert(bql_locked()); | ||
1147 | |||
1148 | netdev->tx_ring.sring = NULL; | ||
1149 | netdev->rx_ring.sring = NULL; | ||
1150 | diff --git a/hw/ppc/pegasos2.c b/hw/ppc/pegasos2.c | ||
1151 | index XXXXXXX..XXXXXXX 100644 | ||
1152 | --- a/hw/ppc/pegasos2.c | ||
1153 | +++ b/hw/ppc/pegasos2.c | ||
1154 | @@ -XXX,XX +XXX,XX @@ static void pegasos2_hypercall(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu) | ||
1155 | CPUPPCState *env = &cpu->env; | ||
1156 | |||
1157 | /* The TCG path should also be holding the BQL at this point */ | ||
1158 | - g_assert(qemu_mutex_iothread_locked()); | ||
1159 | + g_assert(bql_locked()); | ||
1160 | |||
1161 | if (FIELD_EX64(env->msr, MSR, PR)) { | ||
1162 | qemu_log_mask(LOG_GUEST_ERROR, "Hypercall made with MSR[PR]=1\n"); | ||
1163 | diff --git a/hw/ppc/ppc.c b/hw/ppc/ppc.c | ||
1164 | index XXXXXXX..XXXXXXX 100644 | ||
1165 | --- a/hw/ppc/ppc.c | ||
1166 | +++ b/hw/ppc/ppc.c | ||
1167 | @@ -XXX,XX +XXX,XX @@ void store_40x_dbcr0(CPUPPCState *env, uint32_t val) | ||
1168 | { | ||
1169 | PowerPCCPU *cpu = env_archcpu(env); | ||
1170 | |||
1171 | - qemu_mutex_lock_iothread(); | ||
1172 | + bql_lock(); | ||
1173 | |||
1174 | switch ((val >> 28) & 0x3) { | ||
1175 | case 0x0: | ||
1176 | @@ -XXX,XX +XXX,XX @@ void store_40x_dbcr0(CPUPPCState *env, uint32_t val) | ||
1177 | break; | ||
1178 | } | ||
1179 | |||
1180 | - qemu_mutex_unlock_iothread(); | ||
1181 | + bql_unlock(); | ||
1182 | } | ||
1183 | |||
1184 | /* PowerPC 40x internal IRQ controller */ | ||
1185 | diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c | ||
1186 | index XXXXXXX..XXXXXXX 100644 | ||
1187 | --- a/hw/ppc/spapr.c | ||
1188 | +++ b/hw/ppc/spapr.c | ||
1189 | @@ -XXX,XX +XXX,XX @@ static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp, | ||
1190 | CPUPPCState *env = &cpu->env; | ||
1191 | |||
1192 | /* The TCG path should also be holding the BQL at this point */ | ||
1193 | - g_assert(qemu_mutex_iothread_locked()); | ||
1194 | + g_assert(bql_locked()); | ||
1195 | |||
1196 | g_assert(!vhyp_cpu_in_nested(cpu)); | ||
1197 | |||
1198 | diff --git a/hw/ppc/spapr_rng.c b/hw/ppc/spapr_rng.c | ||
1199 | index XXXXXXX..XXXXXXX 100644 | ||
1200 | --- a/hw/ppc/spapr_rng.c | ||
1201 | +++ b/hw/ppc/spapr_rng.c | ||
1202 | @@ -XXX,XX +XXX,XX @@ static target_ulong h_random(PowerPCCPU *cpu, SpaprMachineState *spapr, | ||
1203 | while (hrdata.received < 8) { | ||
1204 | rng_backend_request_entropy(rngstate->backend, 8 - hrdata.received, | ||
1205 | random_recv, &hrdata); | ||
1206 | - qemu_mutex_unlock_iothread(); | ||
1207 | + bql_unlock(); | ||
1208 | qemu_sem_wait(&hrdata.sem); | ||
1209 | - qemu_mutex_lock_iothread(); | ||
1210 | + bql_lock(); | ||
1211 | } | ||
1212 | |||
1213 | qemu_sem_destroy(&hrdata.sem); | ||
1214 | diff --git a/hw/ppc/spapr_softmmu.c b/hw/ppc/spapr_softmmu.c | ||
1215 | index XXXXXXX..XXXXXXX 100644 | ||
1216 | --- a/hw/ppc/spapr_softmmu.c | ||
1217 | +++ b/hw/ppc/spapr_softmmu.c | ||
1218 | @@ -XXX,XX +XXX,XX @@ static void *hpt_prepare_thread(void *opaque) | ||
1219 | pending->ret = H_NO_MEM; | ||
1220 | } | ||
1221 | |||
1222 | - qemu_mutex_lock_iothread(); | ||
1223 | + bql_lock(); | ||
1224 | |||
1225 | if (SPAPR_MACHINE(qdev_get_machine())->pending_hpt == pending) { | ||
1226 | /* Ready to go */ | ||
1227 | @@ -XXX,XX +XXX,XX @@ static void *hpt_prepare_thread(void *opaque) | ||
1228 | free_pending_hpt(pending); | ||
1229 | } | ||
1230 | |||
1231 | - qemu_mutex_unlock_iothread(); | ||
1232 | + bql_unlock(); | ||
1233 | return NULL; | ||
1234 | } | ||
1235 | |||
1236 | diff --git a/hw/remote/mpqemu-link.c b/hw/remote/mpqemu-link.c | ||
1237 | index XXXXXXX..XXXXXXX 100644 | ||
1238 | --- a/hw/remote/mpqemu-link.c | ||
1239 | +++ b/hw/remote/mpqemu-link.c | ||
1240 | @@ -XXX,XX +XXX,XX @@ | ||
1241 | */ | ||
1242 | bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp) | ||
1243 | { | ||
1244 | - bool iolock = qemu_mutex_iothread_locked(); | ||
1245 | + bool drop_bql = bql_locked(); | ||
1246 | bool iothread = qemu_in_iothread(); | ||
1247 | struct iovec send[2] = {}; | ||
1248 | int *fds = NULL; | ||
1249 | @@ -XXX,XX +XXX,XX @@ bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp) | ||
1250 | * for IOThread case. | ||
1251 | * Also skip lock handling while in a co-routine in the main context. | ||
1252 | */ | ||
1253 | - if (iolock && !iothread && !qemu_in_coroutine()) { | ||
1254 | - qemu_mutex_unlock_iothread(); | ||
1255 | + if (drop_bql && !iothread && !qemu_in_coroutine()) { | ||
1256 | + bql_unlock(); | ||
1257 | } | ||
1258 | |||
1259 | if (!qio_channel_writev_full_all(ioc, send, G_N_ELEMENTS(send), | ||
1260 | @@ -XXX,XX +XXX,XX @@ bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp) | ||
1261 | trace_mpqemu_send_io_error(msg->cmd, msg->size, nfds); | ||
1262 | } | ||
1263 | |||
1264 | - if (iolock && !iothread && !qemu_in_coroutine()) { | ||
1265 | + if (drop_bql && !iothread && !qemu_in_coroutine()) { | ||
1266 | /* See above comment why skip locking here. */ | ||
1267 | - qemu_mutex_lock_iothread(); | ||
1268 | + bql_lock(); | ||
1269 | } | ||
1270 | |||
1271 | return ret; | ||
1272 | @@ -XXX,XX +XXX,XX @@ static ssize_t mpqemu_read(QIOChannel *ioc, void *buf, size_t len, int **fds, | ||
1273 | size_t *nfds, Error **errp) | ||
1274 | { | ||
1275 | struct iovec iov = { .iov_base = buf, .iov_len = len }; | ||
1276 | - bool iolock = qemu_mutex_iothread_locked(); | ||
1277 | + bool drop_bql = bql_locked(); | ||
1278 | bool iothread = qemu_in_iothread(); | ||
1279 | int ret = -1; | ||
1280 | |||
1281 | @@ -XXX,XX +XXX,XX @@ static ssize_t mpqemu_read(QIOChannel *ioc, void *buf, size_t len, int **fds, | ||
1282 | */ | ||
1283 | assert(qemu_in_coroutine() || !iothread); | ||
1284 | |||
1285 | - if (iolock && !iothread && !qemu_in_coroutine()) { | ||
1286 | - qemu_mutex_unlock_iothread(); | ||
1287 | + if (drop_bql && !iothread && !qemu_in_coroutine()) { | ||
1288 | + bql_unlock(); | ||
1289 | } | ||
1290 | |||
1291 | ret = qio_channel_readv_full_all_eof(ioc, &iov, 1, fds, nfds, errp); | ||
1292 | |||
1293 | - if (iolock && !iothread && !qemu_in_coroutine()) { | ||
1294 | - qemu_mutex_lock_iothread(); | ||
1295 | + if (drop_bql && !iothread && !qemu_in_coroutine()) { | ||
1296 | + bql_lock(); | ||
1297 | } | ||
1298 | |||
1299 | return (ret <= 0) ? ret : iov.iov_len; | ||
1300 | diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c | ||
1301 | index XXXXXXX..XXXXXXX 100644 | ||
1302 | --- a/hw/remote/vfio-user-obj.c | ||
1303 | +++ b/hw/remote/vfio-user-obj.c | ||
1304 | @@ -XXX,XX +XXX,XX @@ static int vfu_object_mr_rw(MemoryRegion *mr, uint8_t *buf, hwaddr offset, | ||
1305 | } | ||
1306 | |||
1307 | if (release_lock) { | ||
1308 | - qemu_mutex_unlock_iothread(); | ||
1309 | + bql_unlock(); | ||
1310 | release_lock = false; | ||
1311 | } | ||
1312 | |||
1313 | diff --git a/hw/s390x/s390-skeys.c b/hw/s390x/s390-skeys.c | ||
1314 | index XXXXXXX..XXXXXXX 100644 | ||
1315 | --- a/hw/s390x/s390-skeys.c | ||
1316 | +++ b/hw/s390x/s390-skeys.c | ||
1317 | @@ -XXX,XX +XXX,XX @@ void qmp_dump_skeys(const char *filename, Error **errp) | ||
1318 | goto out; | ||
1319 | } | ||
1320 | |||
1321 | - assert(qemu_mutex_iothread_locked()); | ||
1322 | + assert(bql_locked()); | ||
1323 | guest_phys_blocks_init(&guest_phys_blocks); | ||
1324 | guest_phys_blocks_append(&guest_phys_blocks); | ||
1325 | |||
1326 | diff --git a/migration/block-dirty-bitmap.c b/migration/block-dirty-bitmap.c | ||
1327 | index XXXXXXX..XXXXXXX 100644 | ||
1328 | --- a/migration/block-dirty-bitmap.c | ||
1329 | +++ b/migration/block-dirty-bitmap.c | ||
1330 | @@ -XXX,XX +XXX,XX @@ static void dirty_bitmap_state_pending(void *opaque, | ||
1331 | SaveBitmapState *dbms; | ||
1332 | uint64_t pending = 0; | ||
1333 | |||
1334 | - qemu_mutex_lock_iothread(); | ||
1335 | + bql_lock(); | ||
1336 | |||
1337 | QSIMPLEQ_FOREACH(dbms, &s->dbms_list, entry) { | ||
1338 | uint64_t gran = bdrv_dirty_bitmap_granularity(dbms->bitmap); | ||
1339 | @@ -XXX,XX +XXX,XX @@ static void dirty_bitmap_state_pending(void *opaque, | ||
1340 | pending += DIV_ROUND_UP(sectors * BDRV_SECTOR_SIZE, gran); | ||
1341 | } | ||
1342 | |||
1343 | - qemu_mutex_unlock_iothread(); | ||
1344 | + bql_unlock(); | ||
1345 | |||
1346 | trace_dirty_bitmap_state_pending(pending); | ||
1347 | |||
1348 | diff --git a/migration/block.c b/migration/block.c | ||
1349 | index XXXXXXX..XXXXXXX 100644 | ||
1350 | --- a/migration/block.c | ||
1351 | +++ b/migration/block.c | ||
1352 | @@ -XXX,XX +XXX,XX @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds) | ||
1353 | int64_t count; | ||
1354 | |||
1355 | if (bmds->shared_base) { | ||
1356 | - qemu_mutex_lock_iothread(); | ||
1357 | + bql_lock(); | ||
1358 | /* Skip unallocated sectors; intentionally treats failure or | ||
1359 | * partial sector as an allocated sector */ | ||
1360 | while (cur_sector < total_sectors && | ||
1361 | @@ -XXX,XX +XXX,XX @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds) | ||
1362 | } | ||
1363 | cur_sector += count >> BDRV_SECTOR_BITS; | ||
1364 | } | ||
1365 | - qemu_mutex_unlock_iothread(); | ||
1366 | + bql_unlock(); | ||
1367 | } | ||
1368 | |||
1369 | if (cur_sector >= total_sectors) { | ||
1370 | @@ -XXX,XX +XXX,XX @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds) | ||
1371 | * I/O runs in the main loop AioContext (see | ||
1372 | * qemu_get_current_aio_context()). | ||
1373 | */ | ||
1374 | - qemu_mutex_lock_iothread(); | ||
1375 | + bql_lock(); | ||
1376 | bdrv_reset_dirty_bitmap(bmds->dirty_bitmap, cur_sector * BDRV_SECTOR_SIZE, | ||
1377 | nr_sectors * BDRV_SECTOR_SIZE); | ||
1378 | blk->aiocb = blk_aio_preadv(bb, cur_sector * BDRV_SECTOR_SIZE, &blk->qiov, | ||
1379 | 0, blk_mig_read_cb, blk); | ||
1380 | - qemu_mutex_unlock_iothread(); | ||
1381 | + bql_unlock(); | ||
1382 | |||
1383 | bmds->cur_sector = cur_sector + nr_sectors; | ||
1384 | return (bmds->cur_sector >= total_sectors); | ||
1385 | @@ -XXX,XX +XXX,XX @@ static int block_save_iterate(QEMUFile *f, void *opaque) | ||
1386 | /* Always called with iothread lock taken for | ||
1387 | * simplicity, block_save_complete also calls it. | ||
1388 | */ | ||
1389 | - qemu_mutex_lock_iothread(); | ||
1390 | + bql_lock(); | ||
1391 | ret = blk_mig_save_dirty_block(f, 1); | ||
1392 | - qemu_mutex_unlock_iothread(); | ||
1393 | + bql_unlock(); | ||
1394 | } | ||
1395 | if (ret < 0) { | ||
1396 | return ret; | ||
1397 | @@ -XXX,XX +XXX,XX @@ static void block_state_pending(void *opaque, uint64_t *must_precopy, | ||
1398 | /* Estimate pending number of bytes to send */ | ||
1399 | uint64_t pending; | ||
1400 | |||
1401 | - qemu_mutex_lock_iothread(); | ||
1402 | + bql_lock(); | ||
1403 | pending = get_remaining_dirty(); | ||
1404 | - qemu_mutex_unlock_iothread(); | ||
1405 | + bql_unlock(); | ||
1406 | |||
1407 | blk_mig_lock(); | ||
1408 | pending += block_mig_state.submitted * BLK_MIG_BLOCK_SIZE + | ||
1409 | diff --git a/migration/colo.c b/migration/colo.c | ||
1410 | index XXXXXXX..XXXXXXX 100644 | ||
1411 | --- a/migration/colo.c | ||
1412 | +++ b/migration/colo.c | ||
1413 | @@ -XXX,XX +XXX,XX @@ static int colo_do_checkpoint_transaction(MigrationState *s, | ||
1414 | qio_channel_io_seek(QIO_CHANNEL(bioc), 0, 0, NULL); | ||
1415 | bioc->usage = 0; | ||
1416 | |||
1417 | - qemu_mutex_lock_iothread(); | ||
1418 | + bql_lock(); | ||
1419 | if (failover_get_state() != FAILOVER_STATUS_NONE) { | ||
1420 | - qemu_mutex_unlock_iothread(); | ||
1421 | + bql_unlock(); | ||
1422 | goto out; | ||
1423 | } | ||
1424 | vm_stop_force_state(RUN_STATE_COLO); | ||
1425 | - qemu_mutex_unlock_iothread(); | ||
1426 | + bql_unlock(); | ||
1427 | trace_colo_vm_state_change("run", "stop"); | ||
1428 | /* | ||
1429 | * Failover request bh could be called after vm_stop_force_state(), | ||
1430 | @@ -XXX,XX +XXX,XX @@ static int colo_do_checkpoint_transaction(MigrationState *s, | ||
1431 | if (failover_get_state() != FAILOVER_STATUS_NONE) { | ||
1432 | goto out; | ||
1433 | } | ||
1434 | - qemu_mutex_lock_iothread(); | ||
1435 | + bql_lock(); | ||
1436 | |||
1437 | replication_do_checkpoint_all(&local_err); | ||
1438 | if (local_err) { | ||
1439 | - qemu_mutex_unlock_iothread(); | ||
1440 | + bql_unlock(); | ||
1441 | goto out; | ||
1442 | } | ||
1443 | |||
1444 | colo_send_message(s->to_dst_file, COLO_MESSAGE_VMSTATE_SEND, &local_err); | ||
1445 | if (local_err) { | ||
1446 | - qemu_mutex_unlock_iothread(); | ||
1447 | + bql_unlock(); | ||
1448 | goto out; | ||
1449 | } | ||
1450 | /* Note: device state is saved into buffer */ | ||
1451 | ret = qemu_save_device_state(fb); | ||
1452 | |||
1453 | - qemu_mutex_unlock_iothread(); | ||
1454 | + bql_unlock(); | ||
1455 | if (ret < 0) { | ||
1456 | goto out; | ||
1457 | } | ||
1458 | @@ -XXX,XX +XXX,XX @@ static int colo_do_checkpoint_transaction(MigrationState *s, | ||
1459 | |||
1460 | ret = 0; | ||
1461 | |||
1462 | - qemu_mutex_lock_iothread(); | ||
1463 | + bql_lock(); | ||
1464 | vm_start(); | ||
1465 | - qemu_mutex_unlock_iothread(); | ||
1466 | + bql_unlock(); | ||
1467 | trace_colo_vm_state_change("stop", "run"); | ||
1468 | |||
1469 | out: | ||
1470 | @@ -XXX,XX +XXX,XX @@ static void colo_process_checkpoint(MigrationState *s) | ||
1471 | fb = qemu_file_new_output(QIO_CHANNEL(bioc)); | ||
1472 | object_unref(OBJECT(bioc)); | ||
1473 | |||
1474 | - qemu_mutex_lock_iothread(); | ||
1475 | + bql_lock(); | ||
1476 | replication_start_all(REPLICATION_MODE_PRIMARY, &local_err); | ||
1477 | if (local_err) { | ||
1478 | - qemu_mutex_unlock_iothread(); | ||
1479 | + bql_unlock(); | ||
1480 | goto out; | ||
1481 | } | ||
1482 | |||
1483 | vm_start(); | ||
1484 | - qemu_mutex_unlock_iothread(); | ||
1485 | + bql_unlock(); | ||
1486 | trace_colo_vm_state_change("stop", "run"); | ||
1487 | |||
1488 | timer_mod(s->colo_delay_timer, qemu_clock_get_ms(QEMU_CLOCK_HOST) + | ||
1489 | @@ -XXX,XX +XXX,XX @@ out: | ||
1490 | |||
1491 | void migrate_start_colo_process(MigrationState *s) | ||
1492 | { | ||
1493 | - qemu_mutex_unlock_iothread(); | ||
1494 | + bql_unlock(); | ||
1495 | qemu_event_init(&s->colo_checkpoint_event, false); | ||
1496 | s->colo_delay_timer = timer_new_ms(QEMU_CLOCK_HOST, | ||
1497 | colo_checkpoint_notify, s); | ||
1498 | |||
1499 | qemu_sem_init(&s->colo_exit_sem, 0); | ||
1500 | colo_process_checkpoint(s); | ||
1501 | - qemu_mutex_lock_iothread(); | ||
1502 | + bql_lock(); | ||
1503 | } | ||
1504 | |||
1505 | static void colo_incoming_process_checkpoint(MigrationIncomingState *mis, | ||
1506 | @@ -XXX,XX +XXX,XX @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis, | ||
1507 | Error *local_err = NULL; | ||
1508 | int ret; | ||
1509 | |||
1510 | - qemu_mutex_lock_iothread(); | ||
1511 | + bql_lock(); | ||
1512 | vm_stop_force_state(RUN_STATE_COLO); | ||
1513 | - qemu_mutex_unlock_iothread(); | ||
1514 | + bql_unlock(); | ||
1515 | trace_colo_vm_state_change("run", "stop"); | ||
1516 | |||
1517 | /* FIXME: This is unnecessary for periodic checkpoint mode */ | ||
1518 | @@ -XXX,XX +XXX,XX @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis, | ||
1519 | return; | ||
1520 | } | ||
1521 | |||
1522 | - qemu_mutex_lock_iothread(); | ||
1523 | + bql_lock(); | ||
1524 | cpu_synchronize_all_states(); | ||
1525 | ret = qemu_loadvm_state_main(mis->from_src_file, mis); | ||
1526 | - qemu_mutex_unlock_iothread(); | ||
1527 | + bql_unlock(); | ||
1528 | |||
1529 | if (ret < 0) { | ||
1530 | error_setg(errp, "Load VM's live state (ram) error"); | ||
1531 | @@ -XXX,XX +XXX,XX @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis, | ||
1532 | return; | ||
1533 | } | ||
1534 | |||
1535 | - qemu_mutex_lock_iothread(); | ||
1536 | + bql_lock(); | ||
1537 | vmstate_loading = true; | ||
1538 | colo_flush_ram_cache(); | ||
1539 | ret = qemu_load_device_state(fb); | ||
1540 | if (ret < 0) { | ||
1541 | error_setg(errp, "COLO: load device state failed"); | ||
1542 | vmstate_loading = false; | ||
1543 | - qemu_mutex_unlock_iothread(); | ||
1544 | + bql_unlock(); | ||
1545 | return; | ||
1546 | } | ||
1547 | |||
1548 | @@ -XXX,XX +XXX,XX @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis, | ||
1549 | if (local_err) { | ||
1550 | error_propagate(errp, local_err); | ||
1551 | vmstate_loading = false; | ||
1552 | - qemu_mutex_unlock_iothread(); | ||
1553 | + bql_unlock(); | ||
1554 | return; | ||
1555 | } | ||
1556 | |||
1557 | @@ -XXX,XX +XXX,XX @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis, | ||
1558 | if (local_err) { | ||
1559 | error_propagate(errp, local_err); | ||
1560 | vmstate_loading = false; | ||
1561 | - qemu_mutex_unlock_iothread(); | ||
1562 | + bql_unlock(); | ||
1563 | return; | ||
1564 | } | ||
1565 | /* Notify all filters of all NIC to do checkpoint */ | ||
1566 | @@ -XXX,XX +XXX,XX @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis, | ||
1567 | if (local_err) { | ||
1568 | error_propagate(errp, local_err); | ||
1569 | vmstate_loading = false; | ||
1570 | - qemu_mutex_unlock_iothread(); | ||
1571 | + bql_unlock(); | ||
1572 | return; | ||
1573 | } | ||
1574 | |||
1575 | vmstate_loading = false; | ||
1576 | vm_start(); | ||
1577 | - qemu_mutex_unlock_iothread(); | ||
1578 | + bql_unlock(); | ||
1579 | trace_colo_vm_state_change("stop", "run"); | ||
1580 | |||
1581 | if (failover_get_state() == FAILOVER_STATUS_RELAUNCH) { | ||
1582 | @@ -XXX,XX +XXX,XX @@ static void *colo_process_incoming_thread(void *opaque) | ||
1583 | fb = qemu_file_new_input(QIO_CHANNEL(bioc)); | ||
1584 | object_unref(OBJECT(bioc)); | ||
1585 | |||
1586 | - qemu_mutex_lock_iothread(); | ||
1587 | + bql_lock(); | ||
1588 | replication_start_all(REPLICATION_MODE_SECONDARY, &local_err); | ||
1589 | if (local_err) { | ||
1590 | - qemu_mutex_unlock_iothread(); | ||
1591 | + bql_unlock(); | ||
1592 | goto out; | ||
1593 | } | ||
1594 | vm_start(); | ||
1595 | - qemu_mutex_unlock_iothread(); | ||
1596 | + bql_unlock(); | ||
1597 | trace_colo_vm_state_change("stop", "run"); | ||
1598 | |||
1599 | colo_send_message(mis->to_src_file, COLO_MESSAGE_CHECKPOINT_READY, | ||
1600 | @@ -XXX,XX +XXX,XX @@ int coroutine_fn colo_incoming_co(void) | ||
1601 | Error *local_err = NULL; | ||
1602 | QemuThread th; | ||
1603 | |||
1604 | - assert(qemu_mutex_iothread_locked()); | ||
1605 | + assert(bql_locked()); | ||
1606 | |||
1607 | if (!migration_incoming_colo_enabled()) { | ||
1608 | return 0; | ||
1609 | @@ -XXX,XX +XXX,XX @@ int coroutine_fn colo_incoming_co(void) | ||
1610 | qemu_coroutine_yield(); | ||
1611 | mis->colo_incoming_co = NULL; | ||
1612 | |||
1613 | - qemu_mutex_unlock_iothread(); | ||
1614 | + bql_unlock(); | ||
1615 | /* Wait checkpoint incoming thread exit before free resource */ | ||
1616 | qemu_thread_join(&th); | ||
1617 | - qemu_mutex_lock_iothread(); | ||
1618 | + bql_lock(); | ||
1619 | |||
1620 | /* We hold the global iothread lock, so it is safe here */ | ||
1621 | colo_release_ram_cache(); | ||
1622 | diff --git a/migration/dirtyrate.c b/migration/dirtyrate.c | ||
1623 | index XXXXXXX..XXXXXXX 100644 | ||
1624 | --- a/migration/dirtyrate.c | ||
1625 | +++ b/migration/dirtyrate.c | ||
1626 | @@ -XXX,XX +XXX,XX @@ static int64_t do_calculate_dirtyrate(DirtyPageRecord dirty_pages, | ||
1627 | |||
1628 | void global_dirty_log_change(unsigned int flag, bool start) | ||
1629 | { | ||
1630 | - qemu_mutex_lock_iothread(); | ||
1631 | + bql_lock(); | ||
1632 | if (start) { | ||
1633 | memory_global_dirty_log_start(flag); | ||
1634 | } else { | ||
1635 | memory_global_dirty_log_stop(flag); | ||
1636 | } | ||
1637 | - qemu_mutex_unlock_iothread(); | ||
1638 | + bql_unlock(); | ||
1639 | } | ||
1640 | |||
1641 | /* | ||
1642 | @@ -XXX,XX +XXX,XX @@ void global_dirty_log_change(unsigned int flag, bool start) | ||
1643 | */ | ||
1644 | static void global_dirty_log_sync(unsigned int flag, bool one_shot) | ||
1645 | { | ||
1646 | - qemu_mutex_lock_iothread(); | ||
1647 | + bql_lock(); | ||
1648 | memory_global_dirty_log_sync(false); | ||
1649 | if (one_shot) { | ||
1650 | memory_global_dirty_log_stop(flag); | ||
1651 | } | ||
1652 | - qemu_mutex_unlock_iothread(); | ||
1653 | + bql_unlock(); | ||
1654 | } | ||
1655 | |||
1656 | static DirtyPageRecord *vcpu_dirty_stat_alloc(VcpuStat *stat) | ||
1657 | @@ -XXX,XX +XXX,XX @@ static void calculate_dirtyrate_dirty_bitmap(struct DirtyRateConfig config) | ||
1658 | int64_t start_time; | ||
1659 | DirtyPageRecord dirty_pages; | ||
1660 | |||
1661 | - qemu_mutex_lock_iothread(); | ||
1662 | + bql_lock(); | ||
1663 | memory_global_dirty_log_start(GLOBAL_DIRTY_DIRTY_RATE); | ||
1664 | |||
1665 | /* | ||
1666 | @@ -XXX,XX +XXX,XX @@ static void calculate_dirtyrate_dirty_bitmap(struct DirtyRateConfig config) | ||
1667 | * KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE cap is enabled. | ||
1668 | */ | ||
1669 | dirtyrate_manual_reset_protect(); | ||
1670 | - qemu_mutex_unlock_iothread(); | ||
1671 | + bql_unlock(); | ||
1672 | |||
1673 | record_dirtypages_bitmap(&dirty_pages, true); | ||
1674 | |||
1675 | diff --git a/migration/migration.c b/migration/migration.c | ||
1676 | index XXXXXXX..XXXXXXX 100644 | ||
1677 | --- a/migration/migration.c | ||
1678 | +++ b/migration/migration.c | ||
1679 | @@ -XXX,XX +XXX,XX @@ static void migrate_fd_cleanup(MigrationState *s) | ||
1680 | QEMUFile *tmp; | ||
1681 | |||
1682 | trace_migrate_fd_cleanup(); | ||
1683 | - qemu_mutex_unlock_iothread(); | ||
1684 | + bql_unlock(); | ||
1685 | if (s->migration_thread_running) { | ||
1686 | qemu_thread_join(&s->thread); | ||
1687 | s->migration_thread_running = false; | ||
1688 | } | ||
1689 | - qemu_mutex_lock_iothread(); | ||
1690 | + bql_lock(); | ||
1691 | |||
1692 | multifd_save_cleanup(); | ||
1693 | qemu_mutex_lock(&s->qemu_file_lock); | ||
1694 | @@ -XXX,XX +XXX,XX @@ static int postcopy_start(MigrationState *ms, Error **errp) | ||
1695 | } | ||
1696 | |||
1697 | trace_postcopy_start(); | ||
1698 | - qemu_mutex_lock_iothread(); | ||
1699 | + bql_lock(); | ||
1700 | trace_postcopy_start_set_run(); | ||
1701 | |||
1702 | migration_downtime_start(ms); | ||
1703 | @@ -XXX,XX +XXX,XX @@ static int postcopy_start(MigrationState *ms, Error **errp) | ||
1704 | |||
1705 | migration_downtime_end(ms); | ||
1706 | |||
1707 | - qemu_mutex_unlock_iothread(); | ||
1708 | + bql_unlock(); | ||
1709 | |||
1710 | if (migrate_postcopy_ram()) { | ||
1711 | /* | ||
1712 | @@ -XXX,XX +XXX,XX @@ fail: | ||
1713 | error_report_err(local_err); | ||
1714 | } | ||
1715 | } | ||
1716 | - qemu_mutex_unlock_iothread(); | ||
1717 | + bql_unlock(); | ||
1718 | return -1; | ||
1719 | } | ||
1720 | |||
1721 | @@ -XXX,XX +XXX,XX @@ static int migration_maybe_pause(MigrationState *s, | ||
1722 | * wait for the 'pause_sem' semaphore. | ||
1723 | */ | ||
1724 | if (s->state != MIGRATION_STATUS_CANCELLING) { | ||
1725 | - qemu_mutex_unlock_iothread(); | ||
1726 | + bql_unlock(); | ||
1727 | migrate_set_state(&s->state, *current_active_state, | ||
1728 | MIGRATION_STATUS_PRE_SWITCHOVER); | ||
1729 | qemu_sem_wait(&s->pause_sem); | ||
1730 | migrate_set_state(&s->state, MIGRATION_STATUS_PRE_SWITCHOVER, | ||
1731 | new_state); | ||
1732 | *current_active_state = new_state; | ||
1733 | - qemu_mutex_lock_iothread(); | ||
1734 | + bql_lock(); | ||
1735 | } | ||
1736 | |||
1737 | return s->state == new_state ? 0 : -EINVAL; | ||
1738 | @@ -XXX,XX +XXX,XX @@ static int migration_completion_precopy(MigrationState *s, | ||
1739 | { | ||
1740 | int ret; | ||
1741 | |||
1742 | - qemu_mutex_lock_iothread(); | ||
1743 | + bql_lock(); | ||
1744 | migration_downtime_start(s); | ||
1745 | |||
1746 | s->vm_old_state = runstate_get(); | ||
1747 | @@ -XXX,XX +XXX,XX @@ static int migration_completion_precopy(MigrationState *s, | ||
1748 | ret = qemu_savevm_state_complete_precopy(s->to_dst_file, false, | ||
1749 | s->block_inactive); | ||
1750 | out_unlock: | ||
1751 | - qemu_mutex_unlock_iothread(); | ||
1752 | + bql_unlock(); | ||
1753 | return ret; | ||
1754 | } | ||
1755 | |||
1756 | @@ -XXX,XX +XXX,XX @@ static void migration_completion_postcopy(MigrationState *s) | ||
1757 | { | ||
1758 | trace_migration_completion_postcopy_end(); | ||
1759 | |||
1760 | - qemu_mutex_lock_iothread(); | ||
1761 | + bql_lock(); | ||
1762 | qemu_savevm_state_complete_postcopy(s->to_dst_file); | ||
1763 | - qemu_mutex_unlock_iothread(); | ||
1764 | + bql_unlock(); | ||
1765 | |||
1766 | /* | ||
1767 | * Shutdown the postcopy fast path thread. This is only needed when dest | ||
1768 | @@ -XXX,XX +XXX,XX @@ static void migration_completion_failed(MigrationState *s, | ||
1769 | */ | ||
1770 | Error *local_err = NULL; | ||
1771 | |||
1772 | - qemu_mutex_lock_iothread(); | ||
1773 | + bql_lock(); | ||
1774 | bdrv_activate_all(&local_err); | ||
1775 | if (local_err) { | ||
1776 | error_report_err(local_err); | ||
1777 | } else { | ||
1778 | s->block_inactive = false; | ||
1779 | } | ||
1780 | - qemu_mutex_unlock_iothread(); | ||
1781 | + bql_unlock(); | ||
1782 | } | ||
1783 | |||
1784 | migrate_set_state(&s->state, current_active_state, | ||
1785 | @@ -XXX,XX +XXX,XX @@ static void migration_iteration_finish(MigrationState *s) | ||
1786 | /* If we enabled cpu throttling for auto-converge, turn it off. */ | ||
1787 | cpu_throttle_stop(); | ||
1788 | |||
1789 | - qemu_mutex_lock_iothread(); | ||
1790 | + bql_lock(); | ||
1791 | switch (s->state) { | ||
1792 | case MIGRATION_STATUS_COMPLETED: | ||
1793 | migration_calculate_complete(s); | ||
1794 | @@ -XXX,XX +XXX,XX @@ static void migration_iteration_finish(MigrationState *s) | ||
1795 | break; | ||
1796 | } | ||
1797 | migrate_fd_cleanup_schedule(s); | ||
1798 | - qemu_mutex_unlock_iothread(); | ||
1799 | + bql_unlock(); | ||
1800 | } | ||
1801 | |||
1802 | static void bg_migration_iteration_finish(MigrationState *s) | ||
1803 | @@ -XXX,XX +XXX,XX @@ static void bg_migration_iteration_finish(MigrationState *s) | ||
1804 | */ | ||
1805 | ram_write_tracking_stop(); | ||
1806 | |||
1807 | - qemu_mutex_lock_iothread(); | ||
1808 | + bql_lock(); | ||
1809 | switch (s->state) { | ||
1810 | case MIGRATION_STATUS_COMPLETED: | ||
1811 | migration_calculate_complete(s); | ||
1812 | @@ -XXX,XX +XXX,XX @@ static void bg_migration_iteration_finish(MigrationState *s) | ||
1813 | } | ||
1814 | |||
1815 | migrate_fd_cleanup_schedule(s); | ||
1816 | - qemu_mutex_unlock_iothread(); | ||
1817 | + bql_unlock(); | ||
1818 | } | ||
1819 | |||
1820 | /* | ||
1821 | @@ -XXX,XX +XXX,XX @@ static void *migration_thread(void *opaque) | ||
1822 | object_ref(OBJECT(s)); | ||
1823 | update_iteration_initial_status(s); | ||
1824 | |||
1825 | - qemu_mutex_lock_iothread(); | ||
1826 | + bql_lock(); | ||
1827 | qemu_savevm_state_header(s->to_dst_file); | ||
1828 | - qemu_mutex_unlock_iothread(); | ||
1829 | + bql_unlock(); | ||
1830 | |||
1831 | /* | ||
1832 | * If we opened the return path, we need to make sure dst has it | ||
1833 | @@ -XXX,XX +XXX,XX @@ static void *migration_thread(void *opaque) | ||
1834 | qemu_savevm_send_colo_enable(s->to_dst_file); | ||
1835 | } | ||
1836 | |||
1837 | - qemu_mutex_lock_iothread(); | ||
1838 | + bql_lock(); | ||
1839 | qemu_savevm_state_setup(s->to_dst_file); | ||
1840 | - qemu_mutex_unlock_iothread(); | ||
1841 | + bql_unlock(); | ||
1842 | |||
1843 | qemu_savevm_wait_unplug(s, MIGRATION_STATUS_SETUP, | ||
1844 | MIGRATION_STATUS_ACTIVE); | ||
1845 | @@ -XXX,XX +XXX,XX @@ static void *bg_migration_thread(void *opaque) | ||
1846 | ram_write_tracking_prepare(); | ||
1847 | #endif | ||
1848 | |||
1849 | - qemu_mutex_lock_iothread(); | ||
1850 | + bql_lock(); | ||
1851 | qemu_savevm_state_header(s->to_dst_file); | ||
1852 | qemu_savevm_state_setup(s->to_dst_file); | ||
1853 | - qemu_mutex_unlock_iothread(); | ||
1854 | + bql_unlock(); | ||
1855 | |||
1856 | qemu_savevm_wait_unplug(s, MIGRATION_STATUS_SETUP, | ||
1857 | MIGRATION_STATUS_ACTIVE); | ||
1858 | @@ -XXX,XX +XXX,XX @@ static void *bg_migration_thread(void *opaque) | ||
1859 | trace_migration_thread_setup_complete(); | ||
1860 | migration_downtime_start(s); | ||
1861 | |||
1862 | - qemu_mutex_lock_iothread(); | ||
1863 | + bql_lock(); | ||
1864 | |||
1865 | s->vm_old_state = runstate_get(); | ||
1866 | |||
1867 | @@ -XXX,XX +XXX,XX @@ static void *bg_migration_thread(void *opaque) | ||
1868 | s->vm_start_bh = qemu_bh_new(bg_migration_vm_start_bh, s); | ||
1869 | qemu_bh_schedule(s->vm_start_bh); | ||
1870 | |||
1871 | - qemu_mutex_unlock_iothread(); | ||
1872 | + bql_unlock(); | ||
1873 | |||
1874 | while (migration_is_active(s)) { | ||
1875 | MigIterateState iter_state = bg_migration_iteration_run(s); | ||
1876 | @@ -XXX,XX +XXX,XX @@ fail: | ||
1877 | if (early_fail) { | ||
1878 | migrate_set_state(&s->state, MIGRATION_STATUS_ACTIVE, | ||
1879 | MIGRATION_STATUS_FAILED); | ||
1880 | - qemu_mutex_unlock_iothread(); | ||
1881 | + bql_unlock(); | ||
1882 | } | ||
1883 | |||
1884 | bg_migration_iteration_finish(s); | ||
1885 | diff --git a/migration/ram.c b/migration/ram.c | ||
1886 | index XXXXXXX..XXXXXXX 100644 | ||
1887 | --- a/migration/ram.c | ||
1888 | +++ b/migration/ram.c | ||
1889 | @@ -XXX,XX +XXX,XX @@ static int ram_save_setup(QEMUFile *f, void *opaque) | ||
1890 | migration_ops = g_malloc0(sizeof(MigrationOps)); | ||
1891 | migration_ops->ram_save_target_page = ram_save_target_page_legacy; | ||
1892 | |||
1893 | - qemu_mutex_unlock_iothread(); | ||
1894 | + bql_unlock(); | ||
1895 | ret = multifd_send_sync_main(f); | ||
1896 | - qemu_mutex_lock_iothread(); | ||
1897 | + bql_lock(); | ||
1898 | if (ret < 0) { | ||
1899 | return ret; | ||
1900 | } | ||
1901 | @@ -XXX,XX +XXX,XX @@ static void ram_state_pending_exact(void *opaque, uint64_t *must_precopy, | ||
1902 | uint64_t remaining_size = rs->migration_dirty_pages * TARGET_PAGE_SIZE; | ||
1903 | |||
1904 | if (!migration_in_postcopy() && remaining_size < s->threshold_size) { | ||
1905 | - qemu_mutex_lock_iothread(); | ||
1906 | + bql_lock(); | ||
1907 | WITH_RCU_READ_LOCK_GUARD() { | ||
1908 | migration_bitmap_sync_precopy(rs, false); | ||
1909 | } | ||
1910 | - qemu_mutex_unlock_iothread(); | ||
1911 | + bql_unlock(); | ||
1912 | remaining_size = rs->migration_dirty_pages * TARGET_PAGE_SIZE; | ||
1913 | } | ||
1914 | |||
1915 | @@ -XXX,XX +XXX,XX @@ void colo_incoming_start_dirty_log(void) | ||
1916 | { | ||
1917 | RAMBlock *block = NULL; | ||
1918 | /* For memory_global_dirty_log_start below. */ | ||
1919 | - qemu_mutex_lock_iothread(); | ||
1920 | + bql_lock(); | ||
1921 | qemu_mutex_lock_ramlist(); | ||
1922 | |||
1923 | memory_global_dirty_log_sync(false); | ||
1924 | @@ -XXX,XX +XXX,XX @@ void colo_incoming_start_dirty_log(void) | ||
1925 | } | ||
1926 | ram_state->migration_dirty_pages = 0; | ||
1927 | qemu_mutex_unlock_ramlist(); | ||
1928 | - qemu_mutex_unlock_iothread(); | ||
1929 | + bql_unlock(); | ||
1930 | } | ||
1931 | |||
1932 | /* It is need to hold the global lock to call this helper */ | ||
1933 | diff --git a/replay/replay-internal.c b/replay/replay-internal.c | ||
1934 | index XXXXXXX..XXXXXXX 100644 | ||
1935 | --- a/replay/replay-internal.c | ||
1936 | +++ b/replay/replay-internal.c | ||
1937 | @@ -XXX,XX +XXX,XX @@ void replay_mutex_lock(void) | ||
1938 | { | ||
1939 | if (replay_mode != REPLAY_MODE_NONE) { | ||
1940 | unsigned long id; | ||
1941 | - g_assert(!qemu_mutex_iothread_locked()); | ||
1942 | + g_assert(!bql_locked()); | ||
1943 | g_assert(!replay_mutex_locked()); | ||
1944 | qemu_mutex_lock(&lock); | ||
1945 | id = mutex_tail++; | ||
1946 | diff --git a/semihosting/console.c b/semihosting/console.c | ||
1947 | index XXXXXXX..XXXXXXX 100644 | ||
1948 | --- a/semihosting/console.c | ||
1949 | +++ b/semihosting/console.c | ||
1950 | @@ -XXX,XX +XXX,XX @@ static SemihostingConsole console; | ||
1951 | static int console_can_read(void *opaque) | ||
1952 | { | ||
1953 | SemihostingConsole *c = opaque; | ||
1954 | - g_assert(qemu_mutex_iothread_locked()); | ||
1955 | + g_assert(bql_locked()); | ||
1956 | return (int)fifo8_num_free(&c->fifo); | ||
1957 | } | ||
1958 | |||
1959 | @@ -XXX,XX +XXX,XX @@ static void console_wake_up(gpointer data, gpointer user_data) | ||
1960 | static void console_read(void *opaque, const uint8_t *buf, int size) | ||
1961 | { | ||
1962 | SemihostingConsole *c = opaque; | ||
1963 | - g_assert(qemu_mutex_iothread_locked()); | ||
1964 | + g_assert(bql_locked()); | ||
1965 | while (size-- && !fifo8_is_full(&c->fifo)) { | ||
1966 | fifo8_push(&c->fifo, *buf++); | ||
1967 | } | ||
1968 | @@ -XXX,XX +XXX,XX @@ bool qemu_semihosting_console_ready(void) | ||
1969 | { | ||
1970 | SemihostingConsole *c = &console; | ||
1971 | |||
1972 | - g_assert(qemu_mutex_iothread_locked()); | ||
1973 | + g_assert(bql_locked()); | ||
1974 | return !fifo8_is_empty(&c->fifo); | ||
1975 | } | ||
1976 | |||
1977 | @@ -XXX,XX +XXX,XX @@ void qemu_semihosting_console_block_until_ready(CPUState *cs) | ||
1978 | { | ||
1979 | SemihostingConsole *c = &console; | ||
1980 | |||
1981 | - g_assert(qemu_mutex_iothread_locked()); | ||
1982 | + g_assert(bql_locked()); | ||
1983 | |||
1984 | /* Block if the fifo is completely empty. */ | ||
1985 | if (fifo8_is_empty(&c->fifo)) { | ||
1986 | diff --git a/stubs/iothread-lock.c b/stubs/iothread-lock.c | ||
1987 | index XXXXXXX..XXXXXXX 100644 | ||
1988 | --- a/stubs/iothread-lock.c | ||
1989 | +++ b/stubs/iothread-lock.c | ||
1990 | @@ -XXX,XX +XXX,XX @@ | ||
1991 | #include "qemu/osdep.h" | ||
1992 | #include "qemu/main-loop.h" | ||
1993 | |||
1994 | -bool qemu_mutex_iothread_locked(void) | ||
1995 | +bool bql_locked(void) | ||
1996 | { | ||
1997 | return false; | ||
1998 | } | ||
1999 | |||
2000 | -void qemu_mutex_lock_iothread_impl(const char *file, int line) | ||
2001 | +void bql_lock_impl(const char *file, int line) | ||
2002 | { | ||
2003 | } | ||
2004 | |||
2005 | -void qemu_mutex_unlock_iothread(void) | ||
2006 | +void bql_unlock(void) | ||
2007 | { | ||
2008 | } | ||
2009 | diff --git a/system/cpu-throttle.c b/system/cpu-throttle.c | ||
2010 | index XXXXXXX..XXXXXXX 100644 | ||
2011 | --- a/system/cpu-throttle.c | ||
2012 | +++ b/system/cpu-throttle.c | ||
2013 | @@ -XXX,XX +XXX,XX @@ static void cpu_throttle_thread(CPUState *cpu, run_on_cpu_data opaque) | ||
2014 | qemu_cond_timedwait_iothread(cpu->halt_cond, | ||
2015 | sleeptime_ns / SCALE_MS); | ||
2016 | } else { | ||
2017 | - qemu_mutex_unlock_iothread(); | ||
2018 | + bql_unlock(); | ||
2019 | g_usleep(sleeptime_ns / SCALE_US); | ||
2020 | - qemu_mutex_lock_iothread(); | ||
2021 | + bql_lock(); | ||
2022 | } | ||
2023 | sleeptime_ns = endtime_ns - qemu_clock_get_ns(QEMU_CLOCK_REALTIME); | ||
2024 | } | ||
2025 | diff --git a/system/cpus.c b/system/cpus.c | ||
2026 | index XXXXXXX..XXXXXXX 100644 | ||
2027 | --- a/system/cpus.c | ||
2028 | +++ b/system/cpus.c | ||
2029 | @@ -XXX,XX +XXX,XX @@ | ||
2030 | |||
2031 | #endif /* CONFIG_LINUX */ | ||
2032 | |||
2033 | -static QemuMutex qemu_global_mutex; | ||
2034 | +/* The Big QEMU Lock (BQL) */ | ||
2035 | +static QemuMutex bql; | ||
2036 | |||
2037 | /* | ||
2038 | * The chosen accelerator is supposed to register this. | ||
2039 | @@ -XXX,XX +XXX,XX @@ void qemu_init_cpu_loop(void) | ||
2040 | qemu_init_sigbus(); | ||
2041 | qemu_cond_init(&qemu_cpu_cond); | ||
2042 | qemu_cond_init(&qemu_pause_cond); | ||
2043 | - qemu_mutex_init(&qemu_global_mutex); | ||
2044 | + qemu_mutex_init(&bql); | ||
2045 | |||
2046 | qemu_thread_get_self(&io_thread); | ||
2047 | } | ||
2048 | |||
2049 | void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data) | ||
2050 | { | ||
2051 | - do_run_on_cpu(cpu, func, data, &qemu_global_mutex); | ||
2052 | + do_run_on_cpu(cpu, func, data, &bql); | ||
2053 | } | ||
2054 | |||
2055 | static void qemu_cpu_stop(CPUState *cpu, bool exit) | ||
2056 | @@ -XXX,XX +XXX,XX @@ void qemu_wait_io_event(CPUState *cpu) | ||
2057 | slept = true; | ||
2058 | qemu_plugin_vcpu_idle_cb(cpu); | ||
2059 | } | ||
2060 | - qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex); | ||
2061 | + qemu_cond_wait(cpu->halt_cond, &bql); | ||
2062 | } | ||
2063 | if (slept) { | ||
2064 | qemu_plugin_vcpu_resume_cb(cpu); | ||
2065 | @@ -XXX,XX +XXX,XX @@ bool qemu_in_vcpu_thread(void) | ||
2066 | return current_cpu && qemu_cpu_is_self(current_cpu); | ||
2067 | } | ||
2068 | |||
2069 | -QEMU_DEFINE_STATIC_CO_TLS(bool, iothread_locked) | ||
2070 | +QEMU_DEFINE_STATIC_CO_TLS(bool, bql_locked) | ||
2071 | |||
2072 | -bool qemu_mutex_iothread_locked(void) | ||
2073 | +bool bql_locked(void) | ||
2074 | { | ||
2075 | - return get_iothread_locked(); | ||
2076 | + return get_bql_locked(); | ||
2077 | } | ||
2078 | |||
2079 | bool qemu_in_main_thread(void) | ||
2080 | { | ||
2081 | - return qemu_mutex_iothread_locked(); | ||
2082 | + return bql_locked(); | ||
2083 | } | ||
2084 | |||
2085 | /* | ||
2086 | * The BQL is taken from so many places that it is worth profiling the | ||
2087 | * callers directly, instead of funneling them all through a single function. | ||
2088 | */ | ||
2089 | -void qemu_mutex_lock_iothread_impl(const char *file, int line) | ||
2090 | +void bql_lock_impl(const char *file, int line) | ||
2091 | { | ||
2092 | - QemuMutexLockFunc bql_lock = qatomic_read(&qemu_bql_mutex_lock_func); | ||
2093 | + QemuMutexLockFunc bql_lock_fn = qatomic_read(&bql_mutex_lock_func); | ||
2094 | |||
2095 | - g_assert(!qemu_mutex_iothread_locked()); | ||
2096 | - bql_lock(&qemu_global_mutex, file, line); | ||
2097 | - set_iothread_locked(true); | ||
2098 | + g_assert(!bql_locked()); | ||
2099 | + bql_lock_fn(&bql, file, line); | ||
2100 | + set_bql_locked(true); | ||
2101 | } | ||
2102 | |||
2103 | -void qemu_mutex_unlock_iothread(void) | ||
2104 | +void bql_unlock(void) | ||
2105 | { | ||
2106 | - g_assert(qemu_mutex_iothread_locked()); | ||
2107 | - set_iothread_locked(false); | ||
2108 | - qemu_mutex_unlock(&qemu_global_mutex); | ||
2109 | + g_assert(bql_locked()); | ||
2110 | + set_bql_locked(false); | ||
2111 | + qemu_mutex_unlock(&bql); | ||
2112 | } | ||
2113 | |||
2114 | void qemu_cond_wait_iothread(QemuCond *cond) | ||
2115 | { | ||
2116 | - qemu_cond_wait(cond, &qemu_global_mutex); | ||
2117 | + qemu_cond_wait(cond, &bql); | ||
2118 | } | ||
2119 | |||
2120 | void qemu_cond_timedwait_iothread(QemuCond *cond, int ms) | ||
2121 | { | ||
2122 | - qemu_cond_timedwait(cond, &qemu_global_mutex, ms); | ||
2123 | + qemu_cond_timedwait(cond, &bql, ms); | ||
2124 | } | ||
2125 | |||
2126 | /* signal CPU creation */ | ||
2127 | @@ -XXX,XX +XXX,XX @@ void pause_all_vcpus(void) | ||
2128 | replay_mutex_unlock(); | ||
2129 | |||
2130 | while (!all_vcpus_paused()) { | ||
2131 | - qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex); | ||
2132 | + qemu_cond_wait(&qemu_pause_cond, &bql); | ||
2133 | CPU_FOREACH(cpu) { | ||
2134 | qemu_cpu_kick(cpu); | ||
2135 | } | ||
2136 | } | ||
2137 | |||
2138 | - qemu_mutex_unlock_iothread(); | ||
2139 | + bql_unlock(); | ||
2140 | replay_mutex_lock(); | ||
2141 | - qemu_mutex_lock_iothread(); | ||
2142 | + bql_lock(); | ||
2143 | } | ||
2144 | |||
2145 | void cpu_resume(CPUState *cpu) | ||
2146 | @@ -XXX,XX +XXX,XX @@ void cpu_remove_sync(CPUState *cpu) | ||
2147 | cpu->stop = true; | ||
2148 | cpu->unplug = true; | ||
2149 | qemu_cpu_kick(cpu); | ||
2150 | - qemu_mutex_unlock_iothread(); | ||
2151 | + bql_unlock(); | ||
2152 | qemu_thread_join(cpu->thread); | ||
2153 | - qemu_mutex_lock_iothread(); | ||
2154 | + bql_lock(); | ||
2155 | } | ||
2156 | |||
2157 | void cpus_register_accel(const AccelOpsClass *ops) | ||
2158 | @@ -XXX,XX +XXX,XX @@ void qemu_init_vcpu(CPUState *cpu) | ||
2159 | cpus_accel->create_vcpu_thread(cpu); | ||
2160 | |||
2161 | while (!cpu->created) { | ||
2162 | - qemu_cond_wait(&qemu_cpu_cond, &qemu_global_mutex); | ||
2163 | + qemu_cond_wait(&qemu_cpu_cond, &bql); | ||
2164 | } | ||
2165 | } | ||
2166 | |||
2167 | diff --git a/system/dirtylimit.c b/system/dirtylimit.c | ||
2168 | index XXXXXXX..XXXXXXX 100644 | ||
2169 | --- a/system/dirtylimit.c | ||
2170 | +++ b/system/dirtylimit.c | ||
2171 | @@ -XXX,XX +XXX,XX @@ void vcpu_dirty_rate_stat_stop(void) | ||
2172 | { | ||
2173 | qatomic_set(&vcpu_dirty_rate_stat->running, 0); | ||
2174 | dirtylimit_state_unlock(); | ||
2175 | - qemu_mutex_unlock_iothread(); | ||
2176 | + bql_unlock(); | ||
2177 | qemu_thread_join(&vcpu_dirty_rate_stat->thread); | ||
2178 | - qemu_mutex_lock_iothread(); | ||
2179 | + bql_lock(); | ||
2180 | dirtylimit_state_lock(); | ||
2181 | } | ||
2182 | |||
2183 | diff --git a/system/memory.c b/system/memory.c | ||
2184 | index XXXXXXX..XXXXXXX 100644 | ||
2185 | --- a/system/memory.c | ||
2186 | +++ b/system/memory.c | ||
2187 | @@ -XXX,XX +XXX,XX @@ void memory_region_transaction_commit(void) | ||
2188 | AddressSpace *as; | ||
2189 | |||
2190 | assert(memory_region_transaction_depth); | ||
2191 | - assert(qemu_mutex_iothread_locked()); | ||
2192 | + assert(bql_locked()); | ||
2193 | |||
2194 | --memory_region_transaction_depth; | ||
2195 | if (!memory_region_transaction_depth) { | ||
2196 | diff --git a/system/physmem.c b/system/physmem.c | ||
2197 | index XXXXXXX..XXXXXXX 100644 | ||
2198 | --- a/system/physmem.c | ||
2199 | +++ b/system/physmem.c | ||
2200 | @@ -XXX,XX +XXX,XX @@ bool prepare_mmio_access(MemoryRegion *mr) | ||
2201 | { | ||
2202 | bool release_lock = false; | ||
2203 | |||
2204 | - if (!qemu_mutex_iothread_locked()) { | ||
2205 | - qemu_mutex_lock_iothread(); | ||
2206 | + if (!bql_locked()) { | ||
2207 | + bql_lock(); | ||
2208 | release_lock = true; | ||
2209 | } | ||
2210 | if (mr->flush_coalesced_mmio) { | ||
2211 | @@ -XXX,XX +XXX,XX @@ static MemTxResult flatview_write_continue(FlatView *fv, hwaddr addr, | ||
2212 | } | ||
2213 | |||
2214 | if (release_lock) { | ||
2215 | - qemu_mutex_unlock_iothread(); | ||
2216 | + bql_unlock(); | ||
2217 | release_lock = false; | ||
2218 | } | ||
2219 | |||
2220 | @@ -XXX,XX +XXX,XX @@ MemTxResult flatview_read_continue(FlatView *fv, hwaddr addr, | ||
2221 | } | ||
2222 | |||
2223 | if (release_lock) { | ||
2224 | - qemu_mutex_unlock_iothread(); | ||
2225 | + bql_unlock(); | ||
2226 | release_lock = false; | ||
2227 | } | ||
2228 | |||
2229 | diff --git a/system/runstate.c b/system/runstate.c | ||
2230 | index XXXXXXX..XXXXXXX 100644 | ||
2231 | --- a/system/runstate.c | ||
2232 | +++ b/system/runstate.c | ||
2233 | @@ -XXX,XX +XXX,XX @@ void qemu_init_subsystems(void) | ||
2234 | |||
2235 | qemu_init_cpu_list(); | ||
2236 | qemu_init_cpu_loop(); | ||
2237 | - qemu_mutex_lock_iothread(); | ||
2238 | + bql_lock(); | ||
2239 | |||
2240 | atexit(qemu_run_exit_notifiers); | ||
2241 | |||
2242 | diff --git a/system/watchpoint.c b/system/watchpoint.c | ||
2243 | index XXXXXXX..XXXXXXX 100644 | ||
2244 | --- a/system/watchpoint.c | ||
2245 | +++ b/system/watchpoint.c | ||
2246 | @@ -XXX,XX +XXX,XX @@ void cpu_check_watchpoint(CPUState *cpu, vaddr addr, vaddr len, | ||
2247 | * Now raise the debug interrupt so that it will | ||
2248 | * trigger after the current instruction. | ||
2249 | */ | ||
2250 | - qemu_mutex_lock_iothread(); | ||
2251 | + bql_lock(); | ||
2252 | cpu_interrupt(cpu, CPU_INTERRUPT_DEBUG); | ||
2253 | - qemu_mutex_unlock_iothread(); | ||
2254 | + bql_unlock(); | ||
2255 | return; | ||
2256 | } | ||
2257 | |||
2258 | diff --git a/target/arm/arm-powerctl.c b/target/arm/arm-powerctl.c | ||
2259 | index XXXXXXX..XXXXXXX 100644 | ||
2260 | --- a/target/arm/arm-powerctl.c | ||
2261 | +++ b/target/arm/arm-powerctl.c | ||
2262 | @@ -XXX,XX +XXX,XX @@ static void arm_set_cpu_on_async_work(CPUState *target_cpu_state, | ||
2263 | g_free(info); | ||
2264 | |||
2265 | /* Finally set the power status */ | ||
2266 | - assert(qemu_mutex_iothread_locked()); | ||
2267 | + assert(bql_locked()); | ||
2268 | target_cpu->power_state = PSCI_ON; | ||
2269 | } | ||
2270 | |||
2271 | @@ -XXX,XX +XXX,XX @@ int arm_set_cpu_on(uint64_t cpuid, uint64_t entry, uint64_t context_id, | ||
2272 | ARMCPU *target_cpu; | ||
2273 | struct CpuOnInfo *info; | ||
2274 | |||
2275 | - assert(qemu_mutex_iothread_locked()); | ||
2276 | + assert(bql_locked()); | ||
2277 | |||
2278 | DPRINTF("cpu %" PRId64 " (EL %d, %s) @ 0x%" PRIx64 " with R0 = 0x%" PRIx64 | ||
2279 | "\n", cpuid, target_el, target_aa64 ? "aarch64" : "aarch32", entry, | ||
2280 | @@ -XXX,XX +XXX,XX @@ static void arm_set_cpu_on_and_reset_async_work(CPUState *target_cpu_state, | ||
2281 | target_cpu_state->halted = 0; | ||
2282 | |||
2283 | /* Finally set the power status */ | ||
2284 | - assert(qemu_mutex_iothread_locked()); | ||
2285 | + assert(bql_locked()); | ||
2286 | target_cpu->power_state = PSCI_ON; | ||
2287 | } | ||
2288 | |||
2289 | @@ -XXX,XX +XXX,XX @@ int arm_set_cpu_on_and_reset(uint64_t cpuid) | ||
2290 | CPUState *target_cpu_state; | ||
2291 | ARMCPU *target_cpu; | ||
2292 | |||
2293 | - assert(qemu_mutex_iothread_locked()); | ||
2294 | + assert(bql_locked()); | ||
2295 | |||
2296 | /* Retrieve the cpu we are powering up */ | ||
2297 | target_cpu_state = arm_get_cpu_by_id(cpuid); | ||
2298 | @@ -XXX,XX +XXX,XX @@ static void arm_set_cpu_off_async_work(CPUState *target_cpu_state, | ||
2299 | { | ||
2300 | ARMCPU *target_cpu = ARM_CPU(target_cpu_state); | ||
2301 | |||
2302 | - assert(qemu_mutex_iothread_locked()); | ||
2303 | + assert(bql_locked()); | ||
2304 | target_cpu->power_state = PSCI_OFF; | ||
2305 | target_cpu_state->halted = 1; | ||
2306 | target_cpu_state->exception_index = EXCP_HLT; | ||
2307 | @@ -XXX,XX +XXX,XX @@ int arm_set_cpu_off(uint64_t cpuid) | ||
2308 | CPUState *target_cpu_state; | ||
2309 | ARMCPU *target_cpu; | ||
2310 | |||
2311 | - assert(qemu_mutex_iothread_locked()); | ||
2312 | + assert(bql_locked()); | ||
2313 | |||
2314 | DPRINTF("cpu %" PRId64 "\n", cpuid); | ||
2315 | |||
2316 | @@ -XXX,XX +XXX,XX @@ int arm_reset_cpu(uint64_t cpuid) | ||
2317 | CPUState *target_cpu_state; | ||
2318 | ARMCPU *target_cpu; | ||
2319 | |||
2320 | - assert(qemu_mutex_iothread_locked()); | ||
2321 | + assert(bql_locked()); | ||
2322 | |||
2323 | DPRINTF("cpu %" PRId64 "\n", cpuid); | ||
2324 | |||
2325 | diff --git a/target/arm/helper.c b/target/arm/helper.c | ||
2326 | index XXXXXXX..XXXXXXX 100644 | ||
2327 | --- a/target/arm/helper.c | ||
2328 | +++ b/target/arm/helper.c | ||
2329 | @@ -XXX,XX +XXX,XX @@ static void do_hcr_write(CPUARMState *env, uint64_t value, uint64_t valid_mask) | ||
2330 | * VFIQ are masked unless running at EL0 or EL1, and HCR | ||
2331 | * can only be written at EL2. | ||
2332 | */ | ||
2333 | - g_assert(qemu_mutex_iothread_locked()); | ||
2334 | + g_assert(bql_locked()); | ||
2335 | arm_cpu_update_virq(cpu); | ||
2336 | arm_cpu_update_vfiq(cpu); | ||
2337 | arm_cpu_update_vserr(cpu); | ||
2338 | @@ -XXX,XX +XXX,XX @@ void arm_cpu_do_interrupt(CPUState *cs) | ||
2339 | * BQL needs to be held for any modification of | ||
2340 | * cs->interrupt_request. | ||
2341 | */ | ||
2342 | - g_assert(qemu_mutex_iothread_locked()); | ||
2343 | + g_assert(bql_locked()); | ||
2344 | |||
2345 | arm_call_pre_el_change_hook(cpu); | ||
2346 | |||
2347 | diff --git a/target/arm/hvf/hvf.c b/target/arm/hvf/hvf.c | ||
2348 | index XXXXXXX..XXXXXXX 100644 | ||
2349 | --- a/target/arm/hvf/hvf.c | ||
2350 | +++ b/target/arm/hvf/hvf.c | ||
2351 | @@ -XXX,XX +XXX,XX @@ static void hvf_wait_for_ipi(CPUState *cpu, struct timespec *ts) | ||
2352 | * sleeping. | ||
2353 | */ | ||
2354 | qatomic_set_mb(&cpu->thread_kicked, false); | ||
2355 | - qemu_mutex_unlock_iothread(); | ||
2356 | + bql_unlock(); | ||
2357 | pselect(0, 0, 0, 0, ts, &cpu->accel->unblock_ipi_mask); | ||
2358 | - qemu_mutex_lock_iothread(); | ||
2359 | + bql_lock(); | ||
2360 | } | ||
2361 | |||
2362 | static void hvf_wfi(CPUState *cpu) | ||
2363 | @@ -XXX,XX +XXX,XX @@ int hvf_vcpu_exec(CPUState *cpu) | ||
2364 | |||
2365 | flush_cpu_state(cpu); | ||
2366 | |||
2367 | - qemu_mutex_unlock_iothread(); | ||
2368 | + bql_unlock(); | ||
2369 | assert_hvf_ok(hv_vcpu_run(cpu->accel->fd)); | ||
2370 | |||
2371 | /* handle VMEXIT */ | ||
2372 | @@ -XXX,XX +XXX,XX @@ int hvf_vcpu_exec(CPUState *cpu) | ||
2373 | uint32_t ec = syn_get_ec(syndrome); | ||
2374 | |||
2375 | ret = 0; | ||
2376 | - qemu_mutex_lock_iothread(); | ||
2377 | + bql_lock(); | ||
2378 | switch (exit_reason) { | ||
2379 | case HV_EXIT_REASON_EXCEPTION: | ||
2380 | /* This is the main one, handle below. */ | ||
2381 | diff --git a/target/arm/kvm.c b/target/arm/kvm.c | ||
2382 | index XXXXXXX..XXXXXXX 100644 | ||
2383 | --- a/target/arm/kvm.c | ||
2384 | +++ b/target/arm/kvm.c | ||
2385 | @@ -XXX,XX +XXX,XX @@ MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run) | ||
2386 | if (run->s.regs.device_irq_level != cpu->device_irq_level) { | ||
2387 | switched_level = cpu->device_irq_level ^ run->s.regs.device_irq_level; | ||
2388 | |||
2389 | - qemu_mutex_lock_iothread(); | ||
2390 | + bql_lock(); | ||
2391 | |||
2392 | if (switched_level & KVM_ARM_DEV_EL1_VTIMER) { | ||
2393 | qemu_set_irq(cpu->gt_timer_outputs[GTIMER_VIRT], | ||
2394 | @@ -XXX,XX +XXX,XX @@ MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run) | ||
2395 | |||
2396 | /* We also mark unknown levels as processed to not waste cycles */ | ||
2397 | cpu->device_irq_level = run->s.regs.device_irq_level; | ||
2398 | - qemu_mutex_unlock_iothread(); | ||
2399 | + bql_unlock(); | ||
2400 | } | ||
2401 | |||
2402 | return MEMTXATTRS_UNSPECIFIED; | ||
2403 | @@ -XXX,XX +XXX,XX @@ static bool kvm_arm_handle_debug(ARMCPU *cpu, | ||
2404 | env->exception.syndrome = debug_exit->hsr; | ||
2405 | env->exception.vaddress = debug_exit->far; | ||
2406 | env->exception.target_el = 1; | ||
2407 | - qemu_mutex_lock_iothread(); | ||
2408 | + bql_lock(); | ||
2409 | arm_cpu_do_interrupt(cs); | ||
2410 | - qemu_mutex_unlock_iothread(); | ||
2411 | + bql_unlock(); | ||
2412 | |||
2413 | return false; | ||
2414 | } | ||
2415 | diff --git a/target/arm/ptw.c b/target/arm/ptw.c | ||
2416 | index XXXXXXX..XXXXXXX 100644 | ||
2417 | --- a/target/arm/ptw.c | ||
2418 | +++ b/target/arm/ptw.c | ||
2419 | @@ -XXX,XX +XXX,XX @@ static uint64_t arm_casq_ptw(CPUARMState *env, uint64_t old_val, | ||
2420 | #if !TCG_OVERSIZED_GUEST | ||
2421 | # error "Unexpected configuration" | ||
2422 | #endif | ||
2423 | - bool locked = qemu_mutex_iothread_locked(); | ||
2424 | + bool locked = bql_locked(); | ||
2425 | if (!locked) { | ||
2426 | - qemu_mutex_lock_iothread(); | ||
2427 | + bql_lock(); | ||
2428 | } | ||
2429 | if (ptw->out_be) { | ||
2430 | cur_val = ldq_be_p(host); | ||
2431 | @@ -XXX,XX +XXX,XX @@ static uint64_t arm_casq_ptw(CPUARMState *env, uint64_t old_val, | ||
2432 | } | ||
2433 | } | ||
2434 | if (!locked) { | ||
2435 | - qemu_mutex_unlock_iothread(); | ||
2436 | + bql_unlock(); | ||
2437 | } | ||
2438 | #endif | ||
2439 | |||
2440 | diff --git a/target/arm/tcg/helper-a64.c b/target/arm/tcg/helper-a64.c | ||
2441 | index XXXXXXX..XXXXXXX 100644 | ||
2442 | --- a/target/arm/tcg/helper-a64.c | ||
2443 | +++ b/target/arm/tcg/helper-a64.c | ||
2444 | @@ -XXX,XX +XXX,XX @@ void HELPER(exception_return)(CPUARMState *env, uint64_t new_pc) | ||
2445 | goto illegal_return; | ||
2446 | } | ||
2447 | |||
2448 | - qemu_mutex_lock_iothread(); | ||
2449 | + bql_lock(); | ||
2450 | arm_call_pre_el_change_hook(env_archcpu(env)); | ||
2451 | - qemu_mutex_unlock_iothread(); | ||
2452 | + bql_unlock(); | ||
2453 | |||
2454 | if (!return_to_aa64) { | ||
2455 | env->aarch64 = false; | ||
2456 | @@ -XXX,XX +XXX,XX @@ void HELPER(exception_return)(CPUARMState *env, uint64_t new_pc) | ||
2457 | */ | ||
2458 | aarch64_sve_change_el(env, cur_el, new_el, return_to_aa64); | ||
2459 | |||
2460 | - qemu_mutex_lock_iothread(); | ||
2461 | + bql_lock(); | ||
2462 | arm_call_el_change_hook(env_archcpu(env)); | ||
2463 | - qemu_mutex_unlock_iothread(); | ||
2464 | + bql_unlock(); | ||
2465 | |||
2466 | return; | ||
2467 | |||
2468 | diff --git a/target/arm/tcg/m_helper.c b/target/arm/tcg/m_helper.c | ||
2469 | index XXXXXXX..XXXXXXX 100644 | ||
2470 | --- a/target/arm/tcg/m_helper.c | ||
2471 | +++ b/target/arm/tcg/m_helper.c | ||
2472 | @@ -XXX,XX +XXX,XX @@ void HELPER(v7m_preserve_fp_state)(CPUARMState *env) | ||
2473 | bool ts = is_secure && (env->v7m.fpccr[M_REG_S] & R_V7M_FPCCR_TS_MASK); | ||
2474 | bool take_exception; | ||
2475 | |||
2476 | - /* Take the iothread lock as we are going to touch the NVIC */ | ||
2477 | - qemu_mutex_lock_iothread(); | ||
2478 | + /* Take the BQL as we are going to touch the NVIC */ | ||
2479 | + bql_lock(); | ||
2480 | |||
2481 | /* Check the background context had access to the FPU */ | ||
2482 | if (!v7m_cpacr_pass(env, is_secure, is_priv)) { | ||
2483 | @@ -XXX,XX +XXX,XX @@ void HELPER(v7m_preserve_fp_state)(CPUARMState *env) | ||
2484 | take_exception = !stacked_ok && | ||
2485 | armv7m_nvic_can_take_pending_exception(env->nvic); | ||
2486 | |||
2487 | - qemu_mutex_unlock_iothread(); | ||
2488 | + bql_unlock(); | ||
2489 | |||
2490 | if (take_exception) { | ||
2491 | raise_exception_ra(env, EXCP_LAZYFP, 0, 1, GETPC()); | ||
2492 | diff --git a/target/arm/tcg/op_helper.c b/target/arm/tcg/op_helper.c | ||
2493 | index XXXXXXX..XXXXXXX 100644 | ||
2494 | --- a/target/arm/tcg/op_helper.c | ||
2495 | +++ b/target/arm/tcg/op_helper.c | ||
2496 | @@ -XXX,XX +XXX,XX @@ void HELPER(cpsr_write_eret)(CPUARMState *env, uint32_t val) | ||
2497 | { | ||
2498 | uint32_t mask; | ||
2499 | |||
2500 | - qemu_mutex_lock_iothread(); | ||
2501 | + bql_lock(); | ||
2502 | arm_call_pre_el_change_hook(env_archcpu(env)); | ||
2503 | - qemu_mutex_unlock_iothread(); | ||
2504 | + bql_unlock(); | ||
2505 | |||
2506 | mask = aarch32_cpsr_valid_mask(env->features, &env_archcpu(env)->isar); | ||
2507 | cpsr_write(env, val, mask, CPSRWriteExceptionReturn); | ||
2508 | @@ -XXX,XX +XXX,XX @@ void HELPER(cpsr_write_eret)(CPUARMState *env, uint32_t val) | ||
2509 | env->regs[15] &= (env->thumb ? ~1 : ~3); | ||
2510 | arm_rebuild_hflags(env); | ||
2511 | |||
2512 | - qemu_mutex_lock_iothread(); | ||
2513 | + bql_lock(); | ||
2514 | arm_call_el_change_hook(env_archcpu(env)); | ||
2515 | - qemu_mutex_unlock_iothread(); | ||
2516 | + bql_unlock(); | ||
2517 | } | ||
2518 | |||
2519 | /* Access to user mode registers from privileged modes. */ | ||
2520 | @@ -XXX,XX +XXX,XX @@ void HELPER(set_cp_reg)(CPUARMState *env, const void *rip, uint32_t value) | ||
2521 | const ARMCPRegInfo *ri = rip; | ||
2522 | |||
2523 | if (ri->type & ARM_CP_IO) { | ||
2524 | - qemu_mutex_lock_iothread(); | ||
2525 | + bql_lock(); | ||
2526 | ri->writefn(env, ri, value); | ||
2527 | - qemu_mutex_unlock_iothread(); | ||
2528 | + bql_unlock(); | ||
2529 | } else { | ||
2530 | ri->writefn(env, ri, value); | ||
2531 | } | ||
2532 | @@ -XXX,XX +XXX,XX @@ uint32_t HELPER(get_cp_reg)(CPUARMState *env, const void *rip) | ||
2533 | uint32_t res; | ||
2534 | |||
2535 | if (ri->type & ARM_CP_IO) { | ||
2536 | - qemu_mutex_lock_iothread(); | ||
2537 | + bql_lock(); | ||
2538 | res = ri->readfn(env, ri); | ||
2539 | - qemu_mutex_unlock_iothread(); | ||
2540 | + bql_unlock(); | ||
2541 | } else { | ||
2542 | res = ri->readfn(env, ri); | ||
2543 | } | ||
2544 | @@ -XXX,XX +XXX,XX @@ void HELPER(set_cp_reg64)(CPUARMState *env, const void *rip, uint64_t value) | ||
2545 | const ARMCPRegInfo *ri = rip; | ||
2546 | |||
2547 | if (ri->type & ARM_CP_IO) { | ||
2548 | - qemu_mutex_lock_iothread(); | ||
2549 | + bql_lock(); | ||
2550 | ri->writefn(env, ri, value); | ||
2551 | - qemu_mutex_unlock_iothread(); | ||
2552 | + bql_unlock(); | ||
2553 | } else { | ||
2554 | ri->writefn(env, ri, value); | ||
2555 | } | ||
2556 | @@ -XXX,XX +XXX,XX @@ uint64_t HELPER(get_cp_reg64)(CPUARMState *env, const void *rip) | ||
2557 | uint64_t res; | ||
2558 | |||
2559 | if (ri->type & ARM_CP_IO) { | ||
2560 | - qemu_mutex_lock_iothread(); | ||
2561 | + bql_lock(); | ||
2562 | res = ri->readfn(env, ri); | ||
2563 | - qemu_mutex_unlock_iothread(); | ||
2564 | + bql_unlock(); | ||
2565 | } else { | ||
2566 | res = ri->readfn(env, ri); | ||
2567 | } | ||
2568 | diff --git a/target/arm/tcg/psci.c b/target/arm/tcg/psci.c | ||
2569 | index XXXXXXX..XXXXXXX 100644 | ||
2570 | --- a/target/arm/tcg/psci.c | ||
2571 | +++ b/target/arm/tcg/psci.c | ||
2572 | @@ -XXX,XX +XXX,XX @@ void arm_handle_psci_call(ARMCPU *cpu) | ||
2573 | } | ||
2574 | target_cpu = ARM_CPU(target_cpu_state); | ||
2575 | |||
2576 | - g_assert(qemu_mutex_iothread_locked()); | ||
2577 | + g_assert(bql_locked()); | ||
2578 | ret = target_cpu->power_state; | ||
2579 | break; | ||
2580 | default: | ||
2581 | diff --git a/target/hppa/int_helper.c b/target/hppa/int_helper.c | ||
2582 | index XXXXXXX..XXXXXXX 100644 | ||
2583 | --- a/target/hppa/int_helper.c | ||
2584 | +++ b/target/hppa/int_helper.c | ||
2585 | @@ -XXX,XX +XXX,XX @@ void hppa_cpu_alarm_timer(void *opaque) | ||
2586 | void HELPER(write_eirr)(CPUHPPAState *env, target_ulong val) | ||
2587 | { | ||
2588 | env->cr[CR_EIRR] &= ~val; | ||
2589 | - qemu_mutex_lock_iothread(); | ||
2590 | + bql_lock(); | ||
2591 | eval_interrupt(env_archcpu(env)); | ||
2592 | - qemu_mutex_unlock_iothread(); | ||
2593 | + bql_unlock(); | ||
2594 | } | ||
2595 | |||
2596 | void HELPER(write_eiem)(CPUHPPAState *env, target_ulong val) | ||
2597 | { | ||
2598 | env->cr[CR_EIEM] = val; | ||
2599 | - qemu_mutex_lock_iothread(); | ||
2600 | + bql_lock(); | ||
2601 | eval_interrupt(env_archcpu(env)); | ||
2602 | - qemu_mutex_unlock_iothread(); | ||
2603 | + bql_unlock(); | ||
2604 | } | ||
2605 | |||
2606 | void hppa_cpu_do_interrupt(CPUState *cs) | ||
2607 | diff --git a/target/i386/hvf/hvf.c b/target/i386/hvf/hvf.c | ||
2608 | index XXXXXXX..XXXXXXX 100644 | ||
2609 | --- a/target/i386/hvf/hvf.c | ||
2610 | +++ b/target/i386/hvf/hvf.c | ||
2611 | @@ -XXX,XX +XXX,XX @@ int hvf_vcpu_exec(CPUState *cpu) | ||
2612 | } | ||
2613 | vmx_update_tpr(cpu); | ||
2614 | |||
2615 | - qemu_mutex_unlock_iothread(); | ||
2616 | + bql_unlock(); | ||
2617 | if (!cpu_is_bsp(X86_CPU(cpu)) && cpu->halted) { | ||
2618 | - qemu_mutex_lock_iothread(); | ||
2619 | + bql_lock(); | ||
2620 | return EXCP_HLT; | ||
2621 | } | ||
2622 | |||
2623 | @@ -XXX,XX +XXX,XX @@ int hvf_vcpu_exec(CPUState *cpu) | ||
2624 | rip = rreg(cpu->accel->fd, HV_X86_RIP); | ||
2625 | env->eflags = rreg(cpu->accel->fd, HV_X86_RFLAGS); | ||
2626 | |||
2627 | - qemu_mutex_lock_iothread(); | ||
2628 | + bql_lock(); | ||
2629 | |||
2630 | update_apic_tpr(cpu); | ||
2631 | current_cpu = cpu; | ||
2632 | diff --git a/target/i386/kvm/hyperv.c b/target/i386/kvm/hyperv.c | ||
2633 | index XXXXXXX..XXXXXXX 100644 | ||
2634 | --- a/target/i386/kvm/hyperv.c | ||
2635 | +++ b/target/i386/kvm/hyperv.c | ||
2636 | @@ -XXX,XX +XXX,XX @@ void hyperv_x86_synic_update(X86CPU *cpu) | ||
2637 | |||
2638 | static void async_synic_update(CPUState *cs, run_on_cpu_data data) | ||
2639 | { | ||
2640 | - qemu_mutex_lock_iothread(); | ||
2641 | + bql_lock(); | ||
2642 | hyperv_x86_synic_update(X86_CPU(cs)); | ||
2643 | - qemu_mutex_unlock_iothread(); | ||
2644 | + bql_unlock(); | ||
2645 | } | ||
2646 | |||
2647 | int kvm_hv_handle_exit(X86CPU *cpu, struct kvm_hyperv_exit *exit) | ||
2648 | diff --git a/target/i386/kvm/kvm.c b/target/i386/kvm/kvm.c | ||
2649 | index XXXXXXX..XXXXXXX 100644 | ||
2650 | --- a/target/i386/kvm/kvm.c | ||
2651 | +++ b/target/i386/kvm/kvm.c | ||
2652 | @@ -XXX,XX +XXX,XX @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) | ||
2653 | /* Inject NMI */ | ||
2654 | if (cpu->interrupt_request & (CPU_INTERRUPT_NMI | CPU_INTERRUPT_SMI)) { | ||
2655 | if (cpu->interrupt_request & CPU_INTERRUPT_NMI) { | ||
2656 | - qemu_mutex_lock_iothread(); | ||
2657 | + bql_lock(); | ||
2658 | cpu->interrupt_request &= ~CPU_INTERRUPT_NMI; | ||
2659 | - qemu_mutex_unlock_iothread(); | ||
2660 | + bql_unlock(); | ||
2661 | DPRINTF("injected NMI\n"); | ||
2662 | ret = kvm_vcpu_ioctl(cpu, KVM_NMI); | ||
2663 | if (ret < 0) { | ||
2664 | @@ -XXX,XX +XXX,XX @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) | ||
2665 | } | ||
2666 | } | ||
2667 | if (cpu->interrupt_request & CPU_INTERRUPT_SMI) { | ||
2668 | - qemu_mutex_lock_iothread(); | ||
2669 | + bql_lock(); | ||
2670 | cpu->interrupt_request &= ~CPU_INTERRUPT_SMI; | ||
2671 | - qemu_mutex_unlock_iothread(); | ||
2672 | + bql_unlock(); | ||
2673 | DPRINTF("injected SMI\n"); | ||
2674 | ret = kvm_vcpu_ioctl(cpu, KVM_SMI); | ||
2675 | if (ret < 0) { | ||
2676 | @@ -XXX,XX +XXX,XX @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) | ||
2677 | } | ||
2678 | |||
2679 | if (!kvm_pic_in_kernel()) { | ||
2680 | - qemu_mutex_lock_iothread(); | ||
2681 | + bql_lock(); | ||
2682 | } | ||
2683 | |||
2684 | /* Force the VCPU out of its inner loop to process any INIT requests | ||
2685 | @@ -XXX,XX +XXX,XX @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run) | ||
2686 | DPRINTF("setting tpr\n"); | ||
2687 | run->cr8 = cpu_get_apic_tpr(x86_cpu->apic_state); | ||
2688 | |||
2689 | - qemu_mutex_unlock_iothread(); | ||
2690 | + bql_unlock(); | ||
2691 | } | ||
2692 | } | ||
2693 | |||
2694 | @@ -XXX,XX +XXX,XX @@ MemTxAttrs kvm_arch_post_run(CPUState *cpu, struct kvm_run *run) | ||
2695 | /* We need to protect the apic state against concurrent accesses from | ||
2696 | * different threads in case the userspace irqchip is used. */ | ||
2697 | if (!kvm_irqchip_in_kernel()) { | ||
2698 | - qemu_mutex_lock_iothread(); | ||
2699 | + bql_lock(); | ||
2700 | } | ||
2701 | cpu_set_apic_tpr(x86_cpu->apic_state, run->cr8); | ||
2702 | cpu_set_apic_base(x86_cpu->apic_state, run->apic_base); | ||
2703 | if (!kvm_irqchip_in_kernel()) { | ||
2704 | - qemu_mutex_unlock_iothread(); | ||
2705 | + bql_unlock(); | ||
2706 | } | ||
2707 | return cpu_get_mem_attrs(env); | ||
2708 | } | ||
2709 | @@ -XXX,XX +XXX,XX @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) | ||
2710 | switch (run->exit_reason) { | ||
2711 | case KVM_EXIT_HLT: | ||
2712 | DPRINTF("handle_hlt\n"); | ||
2713 | - qemu_mutex_lock_iothread(); | ||
2714 | + bql_lock(); | ||
2715 | ret = kvm_handle_halt(cpu); | ||
2716 | - qemu_mutex_unlock_iothread(); | ||
2717 | + bql_unlock(); | ||
2718 | break; | ||
2719 | case KVM_EXIT_SET_TPR: | ||
2720 | ret = 0; | ||
2721 | break; | ||
2722 | case KVM_EXIT_TPR_ACCESS: | ||
2723 | - qemu_mutex_lock_iothread(); | ||
2724 | + bql_lock(); | ||
2725 | ret = kvm_handle_tpr_access(cpu); | ||
2726 | - qemu_mutex_unlock_iothread(); | ||
2727 | + bql_unlock(); | ||
2728 | break; | ||
2729 | case KVM_EXIT_FAIL_ENTRY: | ||
2730 | code = run->fail_entry.hardware_entry_failure_reason; | ||
2731 | @@ -XXX,XX +XXX,XX @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) | ||
2732 | break; | ||
2733 | case KVM_EXIT_DEBUG: | ||
2734 | DPRINTF("kvm_exit_debug\n"); | ||
2735 | - qemu_mutex_lock_iothread(); | ||
2736 | + bql_lock(); | ||
2737 | ret = kvm_handle_debug(cpu, &run->debug.arch); | ||
2738 | - qemu_mutex_unlock_iothread(); | ||
2739 | + bql_unlock(); | ||
2740 | break; | ||
2741 | case KVM_EXIT_HYPERV: | ||
2742 | ret = kvm_hv_handle_exit(cpu, &run->hyperv); | ||
2743 | diff --git a/target/i386/kvm/xen-emu.c b/target/i386/kvm/xen-emu.c | ||
2744 | index XXXXXXX..XXXXXXX 100644 | ||
2745 | --- a/target/i386/kvm/xen-emu.c | ||
2746 | +++ b/target/i386/kvm/xen-emu.c | ||
2747 | @@ -XXX,XX +XXX,XX @@ void kvm_xen_maybe_deassert_callback(CPUState *cs) | ||
2748 | |||
2749 | /* If the evtchn_upcall_pending flag is cleared, turn the GSI off. */ | ||
2750 | if (!vi->evtchn_upcall_pending) { | ||
2751 | - qemu_mutex_lock_iothread(); | ||
2752 | + bql_lock(); | ||
2753 | /* | ||
2754 | * Check again now we have the lock, because it may have been | ||
2755 | * asserted in the interim. And we don't want to take the lock | ||
2756 | @@ -XXX,XX +XXX,XX @@ void kvm_xen_maybe_deassert_callback(CPUState *cs) | ||
2757 | X86_CPU(cs)->env.xen_callback_asserted = false; | ||
2758 | xen_evtchn_set_callback_level(0); | ||
2759 | } | ||
2760 | - qemu_mutex_unlock_iothread(); | ||
2761 | + bql_unlock(); | ||
2762 | } | ||
2763 | } | ||
2764 | |||
2765 | @@ -XXX,XX +XXX,XX @@ static bool handle_set_param(struct kvm_xen_exit *exit, X86CPU *cpu, | ||
2766 | |||
2767 | switch (hp.index) { | ||
2768 | case HVM_PARAM_CALLBACK_IRQ: | ||
2769 | - qemu_mutex_lock_iothread(); | ||
2770 | + bql_lock(); | ||
2771 | err = xen_evtchn_set_callback_param(hp.value); | ||
2772 | - qemu_mutex_unlock_iothread(); | ||
2773 | + bql_unlock(); | ||
2774 | xen_set_long_mode(exit->u.hcall.longmode); | ||
2775 | break; | ||
2776 | default: | ||
2777 | @@ -XXX,XX +XXX,XX @@ int kvm_xen_soft_reset(void) | ||
2778 | CPUState *cpu; | ||
2779 | int err; | ||
2780 | |||
2781 | - assert(qemu_mutex_iothread_locked()); | ||
2782 | + assert(bql_locked()); | ||
2783 | |||
2784 | trace_kvm_xen_soft_reset(); | ||
2785 | |||
2786 | @@ -XXX,XX +XXX,XX @@ static int schedop_shutdown(CPUState *cs, uint64_t arg) | ||
2787 | break; | ||
2788 | |||
2789 | case SHUTDOWN_soft_reset: | ||
2790 | - qemu_mutex_lock_iothread(); | ||
2791 | + bql_lock(); | ||
2792 | ret = kvm_xen_soft_reset(); | ||
2793 | - qemu_mutex_unlock_iothread(); | ||
2794 | + bql_unlock(); | ||
2795 | break; | ||
2796 | |||
2797 | default: | ||
2798 | diff --git a/target/i386/nvmm/nvmm-accel-ops.c b/target/i386/nvmm/nvmm-accel-ops.c | ||
2799 | index XXXXXXX..XXXXXXX 100644 | ||
2800 | --- a/target/i386/nvmm/nvmm-accel-ops.c | ||
2801 | +++ b/target/i386/nvmm/nvmm-accel-ops.c | ||
2802 | @@ -XXX,XX +XXX,XX @@ static void *qemu_nvmm_cpu_thread_fn(void *arg) | ||
2803 | |||
2804 | rcu_register_thread(); | ||
2805 | |||
2806 | - qemu_mutex_lock_iothread(); | ||
2807 | + bql_lock(); | ||
2808 | qemu_thread_get_self(cpu->thread); | ||
2809 | cpu->thread_id = qemu_get_thread_id(); | ||
2810 | current_cpu = cpu; | ||
2811 | @@ -XXX,XX +XXX,XX @@ static void *qemu_nvmm_cpu_thread_fn(void *arg) | ||
2812 | |||
2813 | nvmm_destroy_vcpu(cpu); | ||
2814 | cpu_thread_signal_destroyed(cpu); | ||
2815 | - qemu_mutex_unlock_iothread(); | ||
2816 | + bql_unlock(); | ||
2817 | rcu_unregister_thread(); | ||
2818 | return NULL; | ||
2819 | } | ||
2820 | diff --git a/target/i386/nvmm/nvmm-all.c b/target/i386/nvmm/nvmm-all.c | ||
2821 | index XXXXXXX..XXXXXXX 100644 | ||
2822 | --- a/target/i386/nvmm/nvmm-all.c | ||
2823 | +++ b/target/i386/nvmm/nvmm-all.c | ||
2824 | @@ -XXX,XX +XXX,XX @@ nvmm_vcpu_pre_run(CPUState *cpu) | ||
2825 | uint8_t tpr; | ||
2826 | int ret; | ||
2827 | |||
2828 | - qemu_mutex_lock_iothread(); | ||
2829 | + bql_lock(); | ||
2830 | |||
2831 | tpr = cpu_get_apic_tpr(x86_cpu->apic_state); | ||
2832 | if (tpr != qcpu->tpr) { | ||
2833 | @@ -XXX,XX +XXX,XX @@ nvmm_vcpu_pre_run(CPUState *cpu) | ||
2834 | } | ||
2835 | } | ||
2836 | |||
2837 | - qemu_mutex_unlock_iothread(); | ||
2838 | + bql_unlock(); | ||
2839 | } | ||
2840 | |||
2841 | /* | ||
2842 | @@ -XXX,XX +XXX,XX @@ nvmm_vcpu_post_run(CPUState *cpu, struct nvmm_vcpu_exit *exit) | ||
2843 | tpr = exit->exitstate.cr8; | ||
2844 | if (qcpu->tpr != tpr) { | ||
2845 | qcpu->tpr = tpr; | ||
2846 | - qemu_mutex_lock_iothread(); | ||
2847 | + bql_lock(); | ||
2848 | cpu_set_apic_tpr(x86_cpu->apic_state, qcpu->tpr); | ||
2849 | - qemu_mutex_unlock_iothread(); | ||
2850 | + bql_unlock(); | ||
2851 | } | ||
2852 | } | ||
2853 | |||
2854 | @@ -XXX,XX +XXX,XX @@ nvmm_handle_halted(struct nvmm_machine *mach, CPUState *cpu, | ||
2855 | CPUX86State *env = cpu_env(cpu); | ||
2856 | int ret = 0; | ||
2857 | |||
2858 | - qemu_mutex_lock_iothread(); | ||
2859 | + bql_lock(); | ||
2860 | |||
2861 | if (!((cpu->interrupt_request & CPU_INTERRUPT_HARD) && | ||
2862 | (env->eflags & IF_MASK)) && | ||
2863 | @@ -XXX,XX +XXX,XX @@ nvmm_handle_halted(struct nvmm_machine *mach, CPUState *cpu, | ||
2864 | ret = 1; | ||
2865 | } | ||
2866 | |||
2867 | - qemu_mutex_unlock_iothread(); | ||
2868 | + bql_unlock(); | ||
2869 | |||
2870 | return ret; | ||
2871 | } | ||
2872 | @@ -XXX,XX +XXX,XX @@ nvmm_vcpu_loop(CPUState *cpu) | ||
2873 | return 0; | ||
2874 | } | ||
2875 | |||
2876 | - qemu_mutex_unlock_iothread(); | ||
2877 | + bql_unlock(); | ||
2878 | cpu_exec_start(cpu); | ||
2879 | |||
2880 | /* | ||
2881 | @@ -XXX,XX +XXX,XX @@ nvmm_vcpu_loop(CPUState *cpu) | ||
2882 | error_report("NVMM: Unexpected VM exit code 0x%lx [hw=0x%lx]", | ||
2883 | exit->reason, exit->u.inv.hwcode); | ||
2884 | nvmm_get_registers(cpu); | ||
2885 | - qemu_mutex_lock_iothread(); | ||
2886 | + bql_lock(); | ||
2887 | qemu_system_guest_panicked(cpu_get_crash_info(cpu)); | ||
2888 | - qemu_mutex_unlock_iothread(); | ||
2889 | + bql_unlock(); | ||
2890 | ret = -1; | ||
2891 | break; | ||
2892 | } | ||
2893 | } while (ret == 0); | ||
2894 | |||
2895 | cpu_exec_end(cpu); | ||
2896 | - qemu_mutex_lock_iothread(); | ||
2897 | + bql_lock(); | ||
2898 | |||
2899 | qatomic_set(&cpu->exit_request, false); | ||
2900 | |||
2901 | diff --git a/target/i386/tcg/sysemu/fpu_helper.c b/target/i386/tcg/sysemu/fpu_helper.c | ||
2902 | index XXXXXXX..XXXXXXX 100644 | ||
2903 | --- a/target/i386/tcg/sysemu/fpu_helper.c | ||
2904 | +++ b/target/i386/tcg/sysemu/fpu_helper.c | ||
2905 | @@ -XXX,XX +XXX,XX @@ void x86_register_ferr_irq(qemu_irq irq) | ||
2906 | void fpu_check_raise_ferr_irq(CPUX86State *env) | ||
2907 | { | ||
2908 | if (ferr_irq && !(env->hflags2 & HF2_IGNNE_MASK)) { | ||
2909 | - qemu_mutex_lock_iothread(); | ||
2910 | + bql_lock(); | ||
2911 | qemu_irq_raise(ferr_irq); | ||
2912 | - qemu_mutex_unlock_iothread(); | ||
2913 | + bql_unlock(); | ||
2914 | return; | ||
2915 | } | ||
2916 | } | ||
2917 | @@ -XXX,XX +XXX,XX @@ void cpu_set_ignne(void) | ||
2918 | { | ||
2919 | CPUX86State *env = &X86_CPU(first_cpu)->env; | ||
2920 | |||
2921 | - assert(qemu_mutex_iothread_locked()); | ||
2922 | + assert(bql_locked()); | ||
2923 | |||
2924 | env->hflags2 |= HF2_IGNNE_MASK; | ||
2925 | /* | ||
2926 | diff --git a/target/i386/tcg/sysemu/misc_helper.c b/target/i386/tcg/sysemu/misc_helper.c | ||
2927 | index XXXXXXX..XXXXXXX 100644 | ||
2928 | --- a/target/i386/tcg/sysemu/misc_helper.c | ||
2929 | +++ b/target/i386/tcg/sysemu/misc_helper.c | ||
2930 | @@ -XXX,XX +XXX,XX @@ void helper_write_crN(CPUX86State *env, int reg, target_ulong t0) | ||
2931 | break; | ||
2932 | case 8: | ||
2933 | if (!(env->hflags2 & HF2_VINTR_MASK)) { | ||
2934 | - qemu_mutex_lock_iothread(); | ||
2935 | + bql_lock(); | ||
2936 | cpu_set_apic_tpr(env_archcpu(env)->apic_state, t0); | ||
2937 | - qemu_mutex_unlock_iothread(); | ||
2938 | + bql_unlock(); | ||
2939 | } | ||
2940 | env->int_ctl = (env->int_ctl & ~V_TPR_MASK) | (t0 & V_TPR_MASK); | ||
2941 | |||
2942 | diff --git a/target/i386/whpx/whpx-accel-ops.c b/target/i386/whpx/whpx-accel-ops.c | ||
2943 | index XXXXXXX..XXXXXXX 100644 | ||
2944 | --- a/target/i386/whpx/whpx-accel-ops.c | ||
2945 | +++ b/target/i386/whpx/whpx-accel-ops.c | ||
2946 | @@ -XXX,XX +XXX,XX @@ static void *whpx_cpu_thread_fn(void *arg) | ||
2947 | |||
2948 | rcu_register_thread(); | ||
2949 | |||
2950 | - qemu_mutex_lock_iothread(); | ||
2951 | + bql_lock(); | ||
2952 | qemu_thread_get_self(cpu->thread); | ||
2953 | cpu->thread_id = qemu_get_thread_id(); | ||
2954 | current_cpu = cpu; | ||
2955 | @@ -XXX,XX +XXX,XX @@ static void *whpx_cpu_thread_fn(void *arg) | ||
2956 | |||
2957 | whpx_destroy_vcpu(cpu); | ||
2958 | cpu_thread_signal_destroyed(cpu); | ||
2959 | - qemu_mutex_unlock_iothread(); | ||
2960 | + bql_unlock(); | ||
2961 | rcu_unregister_thread(); | ||
2962 | return NULL; | ||
2963 | } | ||
2964 | diff --git a/target/i386/whpx/whpx-all.c b/target/i386/whpx/whpx-all.c | ||
2965 | index XXXXXXX..XXXXXXX 100644 | ||
2966 | --- a/target/i386/whpx/whpx-all.c | ||
2967 | +++ b/target/i386/whpx/whpx-all.c | ||
2968 | @@ -XXX,XX +XXX,XX @@ static int whpx_first_vcpu_starting(CPUState *cpu) | ||
2969 | struct whpx_state *whpx = &whpx_global; | ||
2970 | HRESULT hr; | ||
2971 | |||
2972 | - g_assert(qemu_mutex_iothread_locked()); | ||
2973 | + g_assert(bql_locked()); | ||
2974 | |||
2975 | if (!QTAILQ_EMPTY(&cpu->breakpoints) || | ||
2976 | (whpx->breakpoints.breakpoints && | ||
2977 | @@ -XXX,XX +XXX,XX @@ static int whpx_handle_halt(CPUState *cpu) | ||
2978 | CPUX86State *env = cpu_env(cpu); | ||
2979 | int ret = 0; | ||
2980 | |||
2981 | - qemu_mutex_lock_iothread(); | ||
2982 | + bql_lock(); | ||
2983 | if (!((cpu->interrupt_request & CPU_INTERRUPT_HARD) && | ||
2984 | (env->eflags & IF_MASK)) && | ||
2985 | !(cpu->interrupt_request & CPU_INTERRUPT_NMI)) { | ||
2986 | @@ -XXX,XX +XXX,XX @@ static int whpx_handle_halt(CPUState *cpu) | ||
2987 | cpu->halted = true; | ||
2988 | ret = 1; | ||
2989 | } | ||
2990 | - qemu_mutex_unlock_iothread(); | ||
2991 | + bql_unlock(); | ||
2992 | |||
2993 | return ret; | ||
2994 | } | ||
2995 | @@ -XXX,XX +XXX,XX @@ static void whpx_vcpu_pre_run(CPUState *cpu) | ||
2996 | memset(&new_int, 0, sizeof(new_int)); | ||
2997 | memset(reg_values, 0, sizeof(reg_values)); | ||
2998 | |||
2999 | - qemu_mutex_lock_iothread(); | ||
3000 | + bql_lock(); | ||
3001 | |||
3002 | /* Inject NMI */ | ||
3003 | if (!vcpu->interruption_pending && | ||
3004 | @@ -XXX,XX +XXX,XX @@ static void whpx_vcpu_pre_run(CPUState *cpu) | ||
3005 | reg_count += 1; | ||
3006 | } | ||
3007 | |||
3008 | - qemu_mutex_unlock_iothread(); | ||
3009 | + bql_unlock(); | ||
3010 | vcpu->ready_for_pic_interrupt = false; | ||
3011 | |||
3012 | if (reg_count) { | ||
3013 | @@ -XXX,XX +XXX,XX @@ static void whpx_vcpu_post_run(CPUState *cpu) | ||
3014 | uint64_t tpr = vcpu->exit_ctx.VpContext.Cr8; | ||
3015 | if (vcpu->tpr != tpr) { | ||
3016 | vcpu->tpr = tpr; | ||
3017 | - qemu_mutex_lock_iothread(); | ||
3018 | + bql_lock(); | ||
3019 | cpu_set_apic_tpr(x86_cpu->apic_state, whpx_cr8_to_apic_tpr(vcpu->tpr)); | ||
3020 | - qemu_mutex_unlock_iothread(); | ||
3021 | + bql_unlock(); | ||
3022 | } | ||
3023 | |||
3024 | vcpu->interruption_pending = | ||
3025 | @@ -XXX,XX +XXX,XX @@ static int whpx_vcpu_run(CPUState *cpu) | ||
3026 | WhpxStepMode exclusive_step_mode = WHPX_STEP_NONE; | ||
3027 | int ret; | ||
3028 | |||
3029 | - g_assert(qemu_mutex_iothread_locked()); | ||
3030 | + g_assert(bql_locked()); | ||
3031 | |||
3032 | if (whpx->running_cpus++ == 0) { | ||
3033 | /* Insert breakpoints into memory, update exception exit bitmap. */ | ||
3034 | @@ -XXX,XX +XXX,XX @@ static int whpx_vcpu_run(CPUState *cpu) | ||
3035 | } | ||
3036 | } | ||
3037 | |||
3038 | - qemu_mutex_unlock_iothread(); | ||
3039 | + bql_unlock(); | ||
3040 | |||
3041 | if (exclusive_step_mode != WHPX_STEP_NONE) { | ||
3042 | start_exclusive(); | ||
3043 | @@ -XXX,XX +XXX,XX @@ static int whpx_vcpu_run(CPUState *cpu) | ||
3044 | error_report("WHPX: Unexpected VP exit code %d", | ||
3045 | vcpu->exit_ctx.ExitReason); | ||
3046 | whpx_get_registers(cpu); | ||
3047 | - qemu_mutex_lock_iothread(); | ||
3048 | + bql_lock(); | ||
3049 | qemu_system_guest_panicked(cpu_get_crash_info(cpu)); | ||
3050 | - qemu_mutex_unlock_iothread(); | ||
3051 | + bql_unlock(); | ||
3052 | break; | ||
3053 | } | ||
3054 | |||
3055 | @@ -XXX,XX +XXX,XX @@ static int whpx_vcpu_run(CPUState *cpu) | ||
3056 | cpu_exec_end(cpu); | ||
3057 | } | ||
3058 | |||
3059 | - qemu_mutex_lock_iothread(); | ||
3060 | + bql_lock(); | ||
3061 | current_cpu = cpu; | ||
3062 | |||
3063 | if (--whpx->running_cpus == 0) { | ||
3064 | diff --git a/target/loongarch/tcg/csr_helper.c b/target/loongarch/tcg/csr_helper.c | ||
3065 | index XXXXXXX..XXXXXXX 100644 | ||
3066 | --- a/target/loongarch/tcg/csr_helper.c | ||
3067 | +++ b/target/loongarch/tcg/csr_helper.c | ||
3068 | @@ -XXX,XX +XXX,XX @@ target_ulong helper_csrwr_ticlr(CPULoongArchState *env, target_ulong val) | ||
3069 | int64_t old_v = 0; | ||
3070 | |||
3071 | if (val & 0x1) { | ||
3072 | - qemu_mutex_lock_iothread(); | ||
3073 | + bql_lock(); | ||
3074 | loongarch_cpu_set_irq(cpu, IRQ_TIMER, 0); | ||
3075 | - qemu_mutex_unlock_iothread(); | ||
3076 | + bql_unlock(); | ||
3077 | } | ||
3078 | return old_v; | ||
3079 | } | ||
3080 | diff --git a/target/mips/kvm.c b/target/mips/kvm.c | ||
3081 | index XXXXXXX..XXXXXXX 100644 | ||
3082 | --- a/target/mips/kvm.c | ||
3083 | +++ b/target/mips/kvm.c | ||
3084 | @@ -XXX,XX +XXX,XX @@ void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run) | ||
3085 | int r; | ||
3086 | struct kvm_mips_interrupt intr; | ||
3087 | |||
3088 | - qemu_mutex_lock_iothread(); | ||
3089 | + bql_lock(); | ||
3090 | |||
3091 | if ((cs->interrupt_request & CPU_INTERRUPT_HARD) && | ||
3092 | cpu_mips_io_interrupts_pending(cpu)) { | ||
3093 | @@ -XXX,XX +XXX,XX @@ void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run) | ||
3094 | } | ||
3095 | } | ||
3096 | |||
3097 | - qemu_mutex_unlock_iothread(); | ||
3098 | + bql_unlock(); | ||
3099 | } | ||
3100 | |||
3101 | MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run) | ||
3102 | diff --git a/target/mips/tcg/sysemu/cp0_helper.c b/target/mips/tcg/sysemu/cp0_helper.c | ||
3103 | index XXXXXXX..XXXXXXX 100644 | ||
3104 | --- a/target/mips/tcg/sysemu/cp0_helper.c | ||
3105 | +++ b/target/mips/tcg/sysemu/cp0_helper.c | ||
3106 | @@ -XXX,XX +XXX,XX @@ static inline void mips_vpe_wake(MIPSCPU *c) | ||
3107 | * because there might be other conditions that state that c should | ||
3108 | * be sleeping. | ||
3109 | */ | ||
3110 | - qemu_mutex_lock_iothread(); | ||
3111 | + bql_lock(); | ||
3112 | cpu_interrupt(CPU(c), CPU_INTERRUPT_WAKE); | ||
3113 | - qemu_mutex_unlock_iothread(); | ||
3114 | + bql_unlock(); | ||
3115 | } | ||
3116 | |||
3117 | static inline void mips_vpe_sleep(MIPSCPU *cpu) | ||
3118 | diff --git a/target/openrisc/sys_helper.c b/target/openrisc/sys_helper.c | ||
3119 | index XXXXXXX..XXXXXXX 100644 | ||
3120 | --- a/target/openrisc/sys_helper.c | ||
3121 | +++ b/target/openrisc/sys_helper.c | ||
3122 | @@ -XXX,XX +XXX,XX @@ void HELPER(mtspr)(CPUOpenRISCState *env, target_ulong spr, target_ulong rb) | ||
3123 | break; | ||
3124 | case TO_SPR(9, 0): /* PICMR */ | ||
3125 | env->picmr = rb; | ||
3126 | - qemu_mutex_lock_iothread(); | ||
3127 | + bql_lock(); | ||
3128 | if (env->picsr & env->picmr) { | ||
3129 | cpu_interrupt(cs, CPU_INTERRUPT_HARD); | ||
3130 | } else { | ||
3131 | cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD); | ||
3132 | } | ||
3133 | - qemu_mutex_unlock_iothread(); | ||
3134 | + bql_unlock(); | ||
3135 | break; | ||
3136 | case TO_SPR(9, 2): /* PICSR */ | ||
3137 | env->picsr &= ~rb; | ||
3138 | break; | ||
3139 | case TO_SPR(10, 0): /* TTMR */ | ||
3140 | { | ||
3141 | - qemu_mutex_lock_iothread(); | ||
3142 | + bql_lock(); | ||
3143 | if ((env->ttmr & TTMR_M) ^ (rb & TTMR_M)) { | ||
3144 | switch (rb & TTMR_M) { | ||
3145 | case TIMER_NONE: | ||
3146 | @@ -XXX,XX +XXX,XX @@ void HELPER(mtspr)(CPUOpenRISCState *env, target_ulong spr, target_ulong rb) | ||
3147 | cs->interrupt_request &= ~CPU_INTERRUPT_TIMER; | ||
3148 | } | ||
3149 | cpu_openrisc_timer_update(cpu); | ||
3150 | - qemu_mutex_unlock_iothread(); | ||
3151 | + bql_unlock(); | ||
3152 | } | ||
3153 | break; | ||
3154 | |||
3155 | case TO_SPR(10, 1): /* TTCR */ | ||
3156 | - qemu_mutex_lock_iothread(); | ||
3157 | + bql_lock(); | ||
3158 | cpu_openrisc_count_set(cpu, rb); | ||
3159 | cpu_openrisc_timer_update(cpu); | ||
3160 | - qemu_mutex_unlock_iothread(); | ||
3161 | + bql_unlock(); | ||
3162 | break; | ||
3163 | } | ||
3164 | #endif | ||
3165 | @@ -XXX,XX +XXX,XX @@ target_ulong HELPER(mfspr)(CPUOpenRISCState *env, target_ulong rd, | ||
3166 | return env->ttmr; | ||
3167 | |||
3168 | case TO_SPR(10, 1): /* TTCR */ | ||
3169 | - qemu_mutex_lock_iothread(); | ||
3170 | + bql_lock(); | ||
3171 | cpu_openrisc_count_update(cpu); | ||
3172 | - qemu_mutex_unlock_iothread(); | ||
3173 | + bql_unlock(); | ||
3174 | return cpu_openrisc_count_get(cpu); | ||
3175 | } | ||
3176 | #endif | ||
3177 | diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c | ||
3178 | index XXXXXXX..XXXXXXX 100644 | ||
3179 | --- a/target/ppc/excp_helper.c | ||
3180 | +++ b/target/ppc/excp_helper.c | ||
3181 | @@ -XXX,XX +XXX,XX @@ void helper_msgsnd(target_ulong rb) | ||
3182 | return; | ||
3183 | } | ||
3184 | |||
3185 | - qemu_mutex_lock_iothread(); | ||
3186 | + bql_lock(); | ||
3187 | CPU_FOREACH(cs) { | ||
3188 | PowerPCCPU *cpu = POWERPC_CPU(cs); | ||
3189 | CPUPPCState *cenv = &cpu->env; | ||
3190 | @@ -XXX,XX +XXX,XX @@ void helper_msgsnd(target_ulong rb) | ||
3191 | ppc_set_irq(cpu, irq, 1); | ||
3192 | } | ||
3193 | } | ||
3194 | - qemu_mutex_unlock_iothread(); | ||
3195 | + bql_unlock(); | ||
3196 | } | ||
3197 | |||
3198 | /* Server Processor Control */ | ||
3199 | @@ -XXX,XX +XXX,XX @@ static void book3s_msgsnd_common(int pir, int irq) | ||
3200 | { | ||
3201 | CPUState *cs; | ||
3202 | |||
3203 | - qemu_mutex_lock_iothread(); | ||
3204 | + bql_lock(); | ||
3205 | CPU_FOREACH(cs) { | ||
3206 | PowerPCCPU *cpu = POWERPC_CPU(cs); | ||
3207 | CPUPPCState *cenv = &cpu->env; | ||
3208 | @@ -XXX,XX +XXX,XX @@ static void book3s_msgsnd_common(int pir, int irq) | ||
3209 | ppc_set_irq(cpu, irq, 1); | ||
3210 | } | ||
3211 | } | ||
3212 | - qemu_mutex_unlock_iothread(); | ||
3213 | + bql_unlock(); | ||
3214 | } | ||
3215 | |||
3216 | void helper_book3s_msgsnd(target_ulong rb) | ||
3217 | @@ -XXX,XX +XXX,XX @@ void helper_book3s_msgsndp(CPUPPCState *env, target_ulong rb) | ||
3218 | } | ||
3219 | |||
3220 | /* Does iothread need to be locked for walking CPU list? */ | ||
3221 | - qemu_mutex_lock_iothread(); | ||
3222 | + bql_lock(); | ||
3223 | THREAD_SIBLING_FOREACH(cs, ccs) { | ||
3224 | PowerPCCPU *ccpu = POWERPC_CPU(ccs); | ||
3225 | uint32_t thread_id = ppc_cpu_tir(ccpu); | ||
3226 | |||
3227 | if (ttir == thread_id) { | ||
3228 | ppc_set_irq(ccpu, PPC_INTERRUPT_DOORBELL, 1); | ||
3229 | - qemu_mutex_unlock_iothread(); | ||
3230 | + bql_unlock(); | ||
3231 | return; | ||
3232 | } | ||
3233 | } | ||
3234 | diff --git a/target/ppc/kvm.c b/target/ppc/kvm.c | ||
3235 | index XXXXXXX..XXXXXXX 100644 | ||
3236 | --- a/target/ppc/kvm.c | ||
3237 | +++ b/target/ppc/kvm.c | ||
3238 | @@ -XXX,XX +XXX,XX @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) | ||
3239 | CPUPPCState *env = &cpu->env; | ||
3240 | int ret; | ||
3241 | |||
3242 | - qemu_mutex_lock_iothread(); | ||
3243 | + bql_lock(); | ||
3244 | |||
3245 | switch (run->exit_reason) { | ||
3246 | case KVM_EXIT_DCR: | ||
3247 | @@ -XXX,XX +XXX,XX @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) | ||
3248 | break; | ||
3249 | } | ||
3250 | |||
3251 | - qemu_mutex_unlock_iothread(); | ||
3252 | + bql_unlock(); | ||
3253 | return ret; | ||
3254 | } | ||
3255 | |||
3256 | diff --git a/target/ppc/misc_helper.c b/target/ppc/misc_helper.c | ||
3257 | index XXXXXXX..XXXXXXX 100644 | ||
3258 | --- a/target/ppc/misc_helper.c | ||
3259 | +++ b/target/ppc/misc_helper.c | ||
3260 | @@ -XXX,XX +XXX,XX @@ target_ulong helper_load_dpdes(CPUPPCState *env) | ||
3261 | return dpdes; | ||
3262 | } | ||
3263 | |||
3264 | - qemu_mutex_lock_iothread(); | ||
3265 | + bql_lock(); | ||
3266 | THREAD_SIBLING_FOREACH(cs, ccs) { | ||
3267 | PowerPCCPU *ccpu = POWERPC_CPU(ccs); | ||
3268 | CPUPPCState *cenv = &ccpu->env; | ||
3269 | @@ -XXX,XX +XXX,XX @@ target_ulong helper_load_dpdes(CPUPPCState *env) | ||
3270 | dpdes |= (0x1 << thread_id); | ||
3271 | } | ||
3272 | } | ||
3273 | - qemu_mutex_unlock_iothread(); | ||
3274 | + bql_unlock(); | ||
3275 | |||
3276 | return dpdes; | ||
3277 | } | ||
3278 | @@ -XXX,XX +XXX,XX @@ void helper_store_dpdes(CPUPPCState *env, target_ulong val) | ||
3279 | } | ||
3280 | |||
3281 | /* Does iothread need to be locked for walking CPU list? */ | ||
3282 | - qemu_mutex_lock_iothread(); | ||
3283 | + bql_lock(); | ||
3284 | THREAD_SIBLING_FOREACH(cs, ccs) { | ||
3285 | PowerPCCPU *ccpu = POWERPC_CPU(ccs); | ||
3286 | uint32_t thread_id = ppc_cpu_tir(ccpu); | ||
3287 | |||
3288 | ppc_set_irq(cpu, PPC_INTERRUPT_DOORBELL, val & (0x1 << thread_id)); | ||
3289 | } | ||
3290 | - qemu_mutex_unlock_iothread(); | ||
3291 | + bql_unlock(); | ||
3292 | } | ||
3293 | #endif /* defined(TARGET_PPC64) */ | ||
3294 | |||
3295 | diff --git a/target/ppc/timebase_helper.c b/target/ppc/timebase_helper.c | ||
3296 | index XXXXXXX..XXXXXXX 100644 | ||
3297 | --- a/target/ppc/timebase_helper.c | ||
3298 | +++ b/target/ppc/timebase_helper.c | ||
3299 | @@ -XXX,XX +XXX,XX @@ target_ulong helper_load_dcr(CPUPPCState *env, target_ulong dcrn) | ||
3300 | } else { | ||
3301 | int ret; | ||
3302 | |||
3303 | - qemu_mutex_lock_iothread(); | ||
3304 | + bql_lock(); | ||
3305 | ret = ppc_dcr_read(env->dcr_env, (uint32_t)dcrn, &val); | ||
3306 | - qemu_mutex_unlock_iothread(); | ||
3307 | + bql_unlock(); | ||
3308 | if (unlikely(ret != 0)) { | ||
3309 | qemu_log_mask(LOG_GUEST_ERROR, "DCR read error %d %03x\n", | ||
3310 | (uint32_t)dcrn, (uint32_t)dcrn); | ||
3311 | @@ -XXX,XX +XXX,XX @@ void helper_store_dcr(CPUPPCState *env, target_ulong dcrn, target_ulong val) | ||
3312 | POWERPC_EXCP_INVAL_INVAL, GETPC()); | ||
3313 | } else { | ||
3314 | int ret; | ||
3315 | - qemu_mutex_lock_iothread(); | ||
3316 | + bql_lock(); | ||
3317 | ret = ppc_dcr_write(env->dcr_env, (uint32_t)dcrn, (uint32_t)val); | ||
3318 | - qemu_mutex_unlock_iothread(); | ||
3319 | + bql_unlock(); | ||
3320 | if (unlikely(ret != 0)) { | ||
3321 | qemu_log_mask(LOG_GUEST_ERROR, "DCR write error %d %03x\n", | ||
3322 | (uint32_t)dcrn, (uint32_t)dcrn); | ||
3323 | diff --git a/target/s390x/kvm/kvm.c b/target/s390x/kvm/kvm.c | ||
3324 | index XXXXXXX..XXXXXXX 100644 | ||
3325 | --- a/target/s390x/kvm/kvm.c | ||
3326 | +++ b/target/s390x/kvm/kvm.c | ||
3327 | @@ -XXX,XX +XXX,XX @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) | ||
3328 | S390CPU *cpu = S390_CPU(cs); | ||
3329 | int ret = 0; | ||
3330 | |||
3331 | - qemu_mutex_lock_iothread(); | ||
3332 | + bql_lock(); | ||
3333 | |||
3334 | kvm_cpu_synchronize_state(cs); | ||
3335 | |||
3336 | @@ -XXX,XX +XXX,XX @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run) | ||
3337 | fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason); | ||
3338 | break; | ||
3339 | } | ||
3340 | - qemu_mutex_unlock_iothread(); | ||
3341 | + bql_unlock(); | ||
3342 | |||
3343 | if (ret == 0) { | ||
3344 | ret = EXCP_INTERRUPT; | ||
3345 | diff --git a/target/s390x/tcg/misc_helper.c b/target/s390x/tcg/misc_helper.c | ||
3346 | index XXXXXXX..XXXXXXX 100644 | ||
3347 | --- a/target/s390x/tcg/misc_helper.c | ||
3348 | +++ b/target/s390x/tcg/misc_helper.c | ||
3349 | @@ -XXX,XX +XXX,XX @@ uint64_t HELPER(stck)(CPUS390XState *env) | ||
3350 | /* SCLP service call */ | ||
3351 | uint32_t HELPER(servc)(CPUS390XState *env, uint64_t r1, uint64_t r2) | ||
3352 | { | ||
3353 | - qemu_mutex_lock_iothread(); | ||
3354 | + bql_lock(); | ||
3355 | int r = sclp_service_call(env_archcpu(env), r1, r2); | ||
3356 | - qemu_mutex_unlock_iothread(); | ||
3357 | + bql_unlock(); | ||
3358 | if (r < 0) { | ||
3359 | tcg_s390_program_interrupt(env, -r, GETPC()); | ||
3360 | } | ||
3361 | @@ -XXX,XX +XXX,XX @@ void HELPER(diag)(CPUS390XState *env, uint32_t r1, uint32_t r3, uint32_t num) | ||
3362 | switch (num) { | ||
3363 | case 0x500: | ||
3364 | /* KVM hypercall */ | ||
3365 | - qemu_mutex_lock_iothread(); | ||
3366 | + bql_lock(); | ||
3367 | r = s390_virtio_hypercall(env); | ||
3368 | - qemu_mutex_unlock_iothread(); | ||
3369 | + bql_unlock(); | ||
3370 | break; | ||
3371 | case 0x44: | ||
3372 | /* yield */ | ||
3373 | @@ -XXX,XX +XXX,XX @@ void HELPER(diag)(CPUS390XState *env, uint32_t r1, uint32_t r3, uint32_t num) | ||
3374 | break; | ||
3375 | case 0x308: | ||
3376 | /* ipl */ | ||
3377 | - qemu_mutex_lock_iothread(); | ||
3378 | + bql_lock(); | ||
3379 | handle_diag_308(env, r1, r3, GETPC()); | ||
3380 | - qemu_mutex_unlock_iothread(); | ||
3381 | + bql_unlock(); | ||
3382 | r = 0; | ||
3383 | break; | ||
3384 | case 0x288: | ||
3385 | @@ -XXX,XX +XXX,XX @@ static void update_ckc_timer(CPUS390XState *env) | ||
3386 | |||
3387 | /* stop the timer and remove pending CKC IRQs */ | ||
3388 | timer_del(env->tod_timer); | ||
3389 | - g_assert(qemu_mutex_iothread_locked()); | ||
3390 | + g_assert(bql_locked()); | ||
3391 | env->pending_int &= ~INTERRUPT_EXT_CLOCK_COMPARATOR; | ||
3392 | |||
3393 | /* the tod has to exceed the ckc, this can never happen if ckc is all 1's */ | ||
3394 | @@ -XXX,XX +XXX,XX @@ void HELPER(sckc)(CPUS390XState *env, uint64_t ckc) | ||
3395 | { | ||
3396 | env->ckc = ckc; | ||
3397 | |||
3398 | - qemu_mutex_lock_iothread(); | ||
3399 | + bql_lock(); | ||
3400 | update_ckc_timer(env); | ||
3401 | - qemu_mutex_unlock_iothread(); | ||
3402 | + bql_unlock(); | ||
3403 | } | ||
3404 | |||
3405 | void tcg_s390_tod_updated(CPUState *cs, run_on_cpu_data opaque) | ||
3406 | @@ -XXX,XX +XXX,XX @@ uint32_t HELPER(sck)(CPUS390XState *env, uint64_t tod_low) | ||
3407 | .low = tod_low, | ||
3408 | }; | ||
3409 | |||
3410 | - qemu_mutex_lock_iothread(); | ||
3411 | + bql_lock(); | ||
3412 | tdc->set(td, &tod, &error_abort); | ||
3413 | - qemu_mutex_unlock_iothread(); | ||
3414 | + bql_unlock(); | ||
3415 | return 0; | ||
3416 | } | ||
3417 | |||
3418 | @@ -XXX,XX +XXX,XX @@ uint32_t HELPER(sigp)(CPUS390XState *env, uint64_t order_code, uint32_t r1, | ||
3419 | int cc; | ||
3420 | |||
3421 | /* TODO: needed to inject interrupts - push further down */ | ||
3422 | - qemu_mutex_lock_iothread(); | ||
3423 | + bql_lock(); | ||
3424 | cc = handle_sigp(env, order_code & SIGP_ORDER_MASK, r1, r3); | ||
3425 | - qemu_mutex_unlock_iothread(); | ||
3426 | + bql_unlock(); | ||
3427 | |||
3428 | return cc; | ||
3429 | } | ||
3430 | @@ -XXX,XX +XXX,XX @@ uint32_t HELPER(sigp)(CPUS390XState *env, uint64_t order_code, uint32_t r1, | ||
3431 | void HELPER(xsch)(CPUS390XState *env, uint64_t r1) | ||
3432 | { | ||
3433 | S390CPU *cpu = env_archcpu(env); | ||
3434 | - qemu_mutex_lock_iothread(); | ||
3435 | + bql_lock(); | ||
3436 | ioinst_handle_xsch(cpu, r1, GETPC()); | ||
3437 | - qemu_mutex_unlock_iothread(); | ||
3438 | + bql_unlock(); | ||
3439 | } | ||
3440 | |||
3441 | void HELPER(csch)(CPUS390XState *env, uint64_t r1) | ||
3442 | { | ||
3443 | S390CPU *cpu = env_archcpu(env); | ||
3444 | - qemu_mutex_lock_iothread(); | ||
3445 | + bql_lock(); | ||
3446 | ioinst_handle_csch(cpu, r1, GETPC()); | ||
3447 | - qemu_mutex_unlock_iothread(); | ||
3448 | + bql_unlock(); | ||
3449 | } | ||
3450 | |||
3451 | void HELPER(hsch)(CPUS390XState *env, uint64_t r1) | ||
3452 | { | ||
3453 | S390CPU *cpu = env_archcpu(env); | ||
3454 | - qemu_mutex_lock_iothread(); | ||
3455 | + bql_lock(); | ||
3456 | ioinst_handle_hsch(cpu, r1, GETPC()); | ||
3457 | - qemu_mutex_unlock_iothread(); | ||
3458 | + bql_unlock(); | ||
3459 | } | ||
3460 | |||
3461 | void HELPER(msch)(CPUS390XState *env, uint64_t r1, uint64_t inst) | ||
3462 | { | ||
3463 | S390CPU *cpu = env_archcpu(env); | ||
3464 | - qemu_mutex_lock_iothread(); | ||
3465 | + bql_lock(); | ||
3466 | ioinst_handle_msch(cpu, r1, inst >> 16, GETPC()); | ||
3467 | - qemu_mutex_unlock_iothread(); | ||
3468 | + bql_unlock(); | ||
3469 | } | ||
3470 | |||
3471 | void HELPER(rchp)(CPUS390XState *env, uint64_t r1) | ||
3472 | { | ||
3473 | S390CPU *cpu = env_archcpu(env); | ||
3474 | - qemu_mutex_lock_iothread(); | ||
3475 | + bql_lock(); | ||
3476 | ioinst_handle_rchp(cpu, r1, GETPC()); | ||
3477 | - qemu_mutex_unlock_iothread(); | ||
3478 | + bql_unlock(); | ||
3479 | } | ||
3480 | |||
3481 | void HELPER(rsch)(CPUS390XState *env, uint64_t r1) | ||
3482 | { | ||
3483 | S390CPU *cpu = env_archcpu(env); | ||
3484 | - qemu_mutex_lock_iothread(); | ||
3485 | + bql_lock(); | ||
3486 | ioinst_handle_rsch(cpu, r1, GETPC()); | ||
3487 | - qemu_mutex_unlock_iothread(); | ||
3488 | + bql_unlock(); | ||
3489 | } | ||
3490 | |||
3491 | void HELPER(sal)(CPUS390XState *env, uint64_t r1) | ||
3492 | { | ||
3493 | S390CPU *cpu = env_archcpu(env); | ||
3494 | |||
3495 | - qemu_mutex_lock_iothread(); | ||
3496 | + bql_lock(); | ||
3497 | ioinst_handle_sal(cpu, r1, GETPC()); | ||
3498 | - qemu_mutex_unlock_iothread(); | ||
3499 | + bql_unlock(); | ||
3500 | } | ||
3501 | |||
3502 | void HELPER(schm)(CPUS390XState *env, uint64_t r1, uint64_t r2, uint64_t inst) | ||
3503 | { | ||
3504 | S390CPU *cpu = env_archcpu(env); | ||
3505 | |||
3506 | - qemu_mutex_lock_iothread(); | ||
3507 | + bql_lock(); | ||
3508 | ioinst_handle_schm(cpu, r1, r2, inst >> 16, GETPC()); | ||
3509 | - qemu_mutex_unlock_iothread(); | ||
3510 | + bql_unlock(); | ||
3511 | } | ||
3512 | |||
3513 | void HELPER(ssch)(CPUS390XState *env, uint64_t r1, uint64_t inst) | ||
3514 | { | ||
3515 | S390CPU *cpu = env_archcpu(env); | ||
3516 | - qemu_mutex_lock_iothread(); | ||
3517 | + bql_lock(); | ||
3518 | ioinst_handle_ssch(cpu, r1, inst >> 16, GETPC()); | ||
3519 | - qemu_mutex_unlock_iothread(); | ||
3520 | + bql_unlock(); | ||
3521 | } | ||
3522 | |||
3523 | void HELPER(stcrw)(CPUS390XState *env, uint64_t inst) | ||
3524 | { | ||
3525 | S390CPU *cpu = env_archcpu(env); | ||
3526 | |||
3527 | - qemu_mutex_lock_iothread(); | ||
3528 | + bql_lock(); | ||
3529 | ioinst_handle_stcrw(cpu, inst >> 16, GETPC()); | ||
3530 | - qemu_mutex_unlock_iothread(); | ||
3531 | + bql_unlock(); | ||
3532 | } | ||
3533 | |||
3534 | void HELPER(stsch)(CPUS390XState *env, uint64_t r1, uint64_t inst) | ||
3535 | { | ||
3536 | S390CPU *cpu = env_archcpu(env); | ||
3537 | - qemu_mutex_lock_iothread(); | ||
3538 | + bql_lock(); | ||
3539 | ioinst_handle_stsch(cpu, r1, inst >> 16, GETPC()); | ||
3540 | - qemu_mutex_unlock_iothread(); | ||
3541 | + bql_unlock(); | ||
3542 | } | ||
3543 | |||
3544 | uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr) | ||
3545 | @@ -XXX,XX +XXX,XX @@ uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr) | ||
3546 | tcg_s390_program_interrupt(env, PGM_SPECIFICATION, ra); | ||
3547 | } | ||
3548 | |||
3549 | - qemu_mutex_lock_iothread(); | ||
3550 | + bql_lock(); | ||
3551 | io = qemu_s390_flic_dequeue_io(flic, env->cregs[6]); | ||
3552 | if (!io) { | ||
3553 | - qemu_mutex_unlock_iothread(); | ||
3554 | + bql_unlock(); | ||
3555 | return 0; | ||
3556 | } | ||
3557 | |||
3558 | @@ -XXX,XX +XXX,XX @@ uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr) | ||
3559 | if (s390_cpu_virt_mem_write(cpu, addr, 0, &intc, sizeof(intc))) { | ||
3560 | /* writing failed, reinject and properly clean up */ | ||
3561 | s390_io_interrupt(io->id, io->nr, io->parm, io->word); | ||
3562 | - qemu_mutex_unlock_iothread(); | ||
3563 | + bql_unlock(); | ||
3564 | g_free(io); | ||
3565 | s390_cpu_virt_mem_handle_exc(cpu, ra); | ||
3566 | return 0; | ||
3567 | @@ -XXX,XX +XXX,XX @@ uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr) | ||
3568 | } | ||
3569 | |||
3570 | g_free(io); | ||
3571 | - qemu_mutex_unlock_iothread(); | ||
3572 | + bql_unlock(); | ||
3573 | return 1; | ||
3574 | } | ||
3575 | |||
3576 | void HELPER(tsch)(CPUS390XState *env, uint64_t r1, uint64_t inst) | ||
3577 | { | ||
3578 | S390CPU *cpu = env_archcpu(env); | ||
3579 | - qemu_mutex_lock_iothread(); | ||
3580 | + bql_lock(); | ||
3581 | ioinst_handle_tsch(cpu, r1, inst >> 16, GETPC()); | ||
3582 | - qemu_mutex_unlock_iothread(); | ||
3583 | + bql_unlock(); | ||
3584 | } | ||
3585 | |||
3586 | void HELPER(chsc)(CPUS390XState *env, uint64_t inst) | ||
3587 | { | ||
3588 | S390CPU *cpu = env_archcpu(env); | ||
3589 | - qemu_mutex_lock_iothread(); | ||
3590 | + bql_lock(); | ||
3591 | ioinst_handle_chsc(cpu, inst >> 16, GETPC()); | ||
3592 | - qemu_mutex_unlock_iothread(); | ||
3593 | + bql_unlock(); | ||
3594 | } | ||
3595 | #endif | ||
3596 | |||
3597 | @@ -XXX,XX +XXX,XX @@ void HELPER(clp)(CPUS390XState *env, uint32_t r2) | ||
3598 | { | ||
3599 | S390CPU *cpu = env_archcpu(env); | ||
3600 | |||
3601 | - qemu_mutex_lock_iothread(); | ||
3602 | + bql_lock(); | ||
3603 | clp_service_call(cpu, r2, GETPC()); | ||
3604 | - qemu_mutex_unlock_iothread(); | ||
3605 | + bql_unlock(); | ||
3606 | } | ||
3607 | |||
3608 | void HELPER(pcilg)(CPUS390XState *env, uint32_t r1, uint32_t r2) | ||
3609 | { | ||
3610 | S390CPU *cpu = env_archcpu(env); | ||
3611 | |||
3612 | - qemu_mutex_lock_iothread(); | ||
3613 | + bql_lock(); | ||
3614 | pcilg_service_call(cpu, r1, r2, GETPC()); | ||
3615 | - qemu_mutex_unlock_iothread(); | ||
3616 | + bql_unlock(); | ||
3617 | } | ||
3618 | |||
3619 | void HELPER(pcistg)(CPUS390XState *env, uint32_t r1, uint32_t r2) | ||
3620 | { | ||
3621 | S390CPU *cpu = env_archcpu(env); | ||
3622 | |||
3623 | - qemu_mutex_lock_iothread(); | ||
3624 | + bql_lock(); | ||
3625 | pcistg_service_call(cpu, r1, r2, GETPC()); | ||
3626 | - qemu_mutex_unlock_iothread(); | ||
3627 | + bql_unlock(); | ||
3628 | } | ||
3629 | |||
3630 | void HELPER(stpcifc)(CPUS390XState *env, uint32_t r1, uint64_t fiba, | ||
3631 | @@ -XXX,XX +XXX,XX @@ void HELPER(stpcifc)(CPUS390XState *env, uint32_t r1, uint64_t fiba, | ||
3632 | { | ||
3633 | S390CPU *cpu = env_archcpu(env); | ||
3634 | |||
3635 | - qemu_mutex_lock_iothread(); | ||
3636 | + bql_lock(); | ||
3637 | stpcifc_service_call(cpu, r1, fiba, ar, GETPC()); | ||
3638 | - qemu_mutex_unlock_iothread(); | ||
3639 | + bql_unlock(); | ||
3640 | } | ||
3641 | |||
3642 | void HELPER(sic)(CPUS390XState *env, uint64_t r1, uint64_t r3) | ||
3643 | @@ -XXX,XX +XXX,XX @@ void HELPER(sic)(CPUS390XState *env, uint64_t r1, uint64_t r3) | ||
3644 | S390CPU *cpu = env_archcpu(env); | ||
3645 | int r; | ||
3646 | |||
3647 | - qemu_mutex_lock_iothread(); | ||
3648 | + bql_lock(); | ||
3649 | r = css_do_sic(cpu, (r3 >> 27) & 0x7, r1 & 0xffff); | ||
3650 | - qemu_mutex_unlock_iothread(); | ||
3651 | + bql_unlock(); | ||
3652 | /* css_do_sic() may actually return a PGM_xxx value to inject */ | ||
3653 | if (r) { | ||
3654 | tcg_s390_program_interrupt(env, -r, GETPC()); | ||
3655 | @@ -XXX,XX +XXX,XX @@ void HELPER(rpcit)(CPUS390XState *env, uint32_t r1, uint32_t r2) | ||
3656 | { | ||
3657 | S390CPU *cpu = env_archcpu(env); | ||
3658 | |||
3659 | - qemu_mutex_lock_iothread(); | ||
3660 | + bql_lock(); | ||
3661 | rpcit_service_call(cpu, r1, r2, GETPC()); | ||
3662 | - qemu_mutex_unlock_iothread(); | ||
3663 | + bql_unlock(); | ||
3664 | } | ||
3665 | |||
3666 | void HELPER(pcistb)(CPUS390XState *env, uint32_t r1, uint32_t r3, | ||
3667 | @@ -XXX,XX +XXX,XX @@ void HELPER(pcistb)(CPUS390XState *env, uint32_t r1, uint32_t r3, | ||
3668 | { | ||
3669 | S390CPU *cpu = env_archcpu(env); | ||
3670 | |||
3671 | - qemu_mutex_lock_iothread(); | ||
3672 | + bql_lock(); | ||
3673 | pcistb_service_call(cpu, r1, r3, gaddr, ar, GETPC()); | ||
3674 | - qemu_mutex_unlock_iothread(); | ||
3675 | + bql_unlock(); | ||
3676 | } | ||
3677 | |||
3678 | void HELPER(mpcifc)(CPUS390XState *env, uint32_t r1, uint64_t fiba, | ||
3679 | @@ -XXX,XX +XXX,XX @@ void HELPER(mpcifc)(CPUS390XState *env, uint32_t r1, uint64_t fiba, | ||
3680 | { | ||
3681 | S390CPU *cpu = env_archcpu(env); | ||
3682 | |||
3683 | - qemu_mutex_lock_iothread(); | ||
3684 | + bql_lock(); | ||
3685 | mpcifc_service_call(cpu, r1, fiba, ar, GETPC()); | ||
3686 | - qemu_mutex_unlock_iothread(); | ||
3687 | + bql_unlock(); | ||
3688 | } | ||
3689 | #endif | ||
3690 | diff --git a/target/sparc/int32_helper.c b/target/sparc/int32_helper.c | ||
3691 | index XXXXXXX..XXXXXXX 100644 | ||
3692 | --- a/target/sparc/int32_helper.c | ||
3693 | +++ b/target/sparc/int32_helper.c | ||
3694 | @@ -XXX,XX +XXX,XX @@ void cpu_check_irqs(CPUSPARCState *env) | ||
3695 | CPUState *cs; | ||
3696 | |||
3697 | /* We should be holding the BQL before we mess with IRQs */ | ||
3698 | - g_assert(qemu_mutex_iothread_locked()); | ||
3699 | + g_assert(bql_locked()); | ||
3700 | |||
3701 | if (env->pil_in && (env->interrupt_index == 0 || | ||
3702 | (env->interrupt_index & ~15) == TT_EXTINT)) { | ||
3703 | diff --git a/target/sparc/int64_helper.c b/target/sparc/int64_helper.c | ||
3704 | index XXXXXXX..XXXXXXX 100644 | ||
3705 | --- a/target/sparc/int64_helper.c | ||
3706 | +++ b/target/sparc/int64_helper.c | ||
3707 | @@ -XXX,XX +XXX,XX @@ void cpu_check_irqs(CPUSPARCState *env) | ||
3708 | (env->softint & ~(SOFTINT_TIMER | SOFTINT_STIMER)); | ||
3709 | |||
3710 | /* We should be holding the BQL before we mess with IRQs */ | ||
3711 | - g_assert(qemu_mutex_iothread_locked()); | ||
3712 | + g_assert(bql_locked()); | ||
3713 | |||
3714 | /* TT_IVEC has a higher priority (16) than TT_EXTINT (31..17) */ | ||
3715 | if (env->ivec_status & 0x20) { | ||
3716 | @@ -XXX,XX +XXX,XX @@ static bool do_modify_softint(CPUSPARCState *env, uint32_t value) | ||
3717 | env->softint = value; | ||
3718 | #if !defined(CONFIG_USER_ONLY) | ||
3719 | if (cpu_interrupts_enabled(env)) { | ||
3720 | - qemu_mutex_lock_iothread(); | ||
3721 | + bql_lock(); | ||
3722 | cpu_check_irqs(env); | ||
3723 | - qemu_mutex_unlock_iothread(); | ||
3724 | + bql_unlock(); | ||
3725 | } | ||
3726 | #endif | ||
3727 | return true; | ||
3728 | diff --git a/target/sparc/win_helper.c b/target/sparc/win_helper.c | ||
3729 | index XXXXXXX..XXXXXXX 100644 | ||
3730 | --- a/target/sparc/win_helper.c | ||
3731 | +++ b/target/sparc/win_helper.c | ||
3732 | @@ -XXX,XX +XXX,XX @@ void helper_wrpsr(CPUSPARCState *env, target_ulong new_psr) | ||
3733 | cpu_raise_exception_ra(env, TT_ILL_INSN, GETPC()); | ||
3734 | } else { | ||
3735 | /* cpu_put_psr may trigger interrupts, hence BQL */ | ||
3736 | - qemu_mutex_lock_iothread(); | ||
3737 | + bql_lock(); | ||
3738 | cpu_put_psr(env, new_psr); | ||
3739 | - qemu_mutex_unlock_iothread(); | ||
3740 | + bql_unlock(); | ||
3741 | } | ||
3742 | } | ||
3743 | |||
3744 | @@ -XXX,XX +XXX,XX @@ void helper_wrpstate(CPUSPARCState *env, target_ulong new_state) | ||
3745 | |||
3746 | #if !defined(CONFIG_USER_ONLY) | ||
3747 | if (cpu_interrupts_enabled(env)) { | ||
3748 | - qemu_mutex_lock_iothread(); | ||
3749 | + bql_lock(); | ||
3750 | cpu_check_irqs(env); | ||
3751 | - qemu_mutex_unlock_iothread(); | ||
3752 | + bql_unlock(); | ||
3753 | } | ||
3754 | #endif | ||
3755 | } | ||
3756 | @@ -XXX,XX +XXX,XX @@ void helper_wrpil(CPUSPARCState *env, target_ulong new_pil) | ||
3757 | env->psrpil = new_pil; | ||
3758 | |||
3759 | if (cpu_interrupts_enabled(env)) { | ||
3760 | - qemu_mutex_lock_iothread(); | ||
3761 | + bql_lock(); | ||
3762 | cpu_check_irqs(env); | ||
3763 | - qemu_mutex_unlock_iothread(); | ||
3764 | + bql_unlock(); | ||
3765 | } | ||
3766 | #endif | ||
3767 | } | ||
3768 | @@ -XXX,XX +XXX,XX @@ void helper_done(CPUSPARCState *env) | ||
3769 | |||
3770 | #if !defined(CONFIG_USER_ONLY) | ||
3771 | if (cpu_interrupts_enabled(env)) { | ||
3772 | - qemu_mutex_lock_iothread(); | ||
3773 | + bql_lock(); | ||
3774 | cpu_check_irqs(env); | ||
3775 | - qemu_mutex_unlock_iothread(); | ||
3776 | + bql_unlock(); | ||
3777 | } | ||
3778 | #endif | ||
3779 | } | ||
3780 | @@ -XXX,XX +XXX,XX @@ void helper_retry(CPUSPARCState *env) | ||
3781 | |||
3782 | #if !defined(CONFIG_USER_ONLY) | ||
3783 | if (cpu_interrupts_enabled(env)) { | ||
3784 | - qemu_mutex_lock_iothread(); | ||
3785 | + bql_lock(); | ||
3786 | cpu_check_irqs(env); | ||
3787 | - qemu_mutex_unlock_iothread(); | ||
3788 | + bql_unlock(); | ||
3789 | } | ||
3790 | #endif | ||
3791 | } | ||
3792 | diff --git a/target/xtensa/exc_helper.c b/target/xtensa/exc_helper.c | ||
3793 | index XXXXXXX..XXXXXXX 100644 | ||
3794 | --- a/target/xtensa/exc_helper.c | ||
3795 | +++ b/target/xtensa/exc_helper.c | ||
3796 | @@ -XXX,XX +XXX,XX @@ void HELPER(waiti)(CPUXtensaState *env, uint32_t pc, uint32_t intlevel) | ||
3797 | env->sregs[PS] = (env->sregs[PS] & ~PS_INTLEVEL) | | ||
3798 | (intlevel << PS_INTLEVEL_SHIFT); | ||
3799 | |||
3800 | - qemu_mutex_lock_iothread(); | ||
3801 | + bql_lock(); | ||
3802 | check_interrupts(env); | ||
3803 | - qemu_mutex_unlock_iothread(); | ||
3804 | + bql_unlock(); | ||
3805 | |||
3806 | if (env->pending_irq_level) { | ||
3807 | cpu_loop_exit(cpu); | ||
3808 | @@ -XXX,XX +XXX,XX @@ void HELPER(waiti)(CPUXtensaState *env, uint32_t pc, uint32_t intlevel) | ||
3809 | |||
3810 | void HELPER(check_interrupts)(CPUXtensaState *env) | ||
3811 | { | ||
3812 | - qemu_mutex_lock_iothread(); | ||
3813 | + bql_lock(); | ||
3814 | check_interrupts(env); | ||
3815 | - qemu_mutex_unlock_iothread(); | ||
3816 | + bql_unlock(); | ||
3817 | } | ||
3818 | |||
3819 | void HELPER(intset)(CPUXtensaState *env, uint32_t v) | ||
3820 | diff --git a/ui/spice-core.c b/ui/spice-core.c | ||
3821 | index XXXXXXX..XXXXXXX 100644 | ||
3822 | --- a/ui/spice-core.c | ||
3823 | +++ b/ui/spice-core.c | ||
3824 | @@ -XXX,XX +XXX,XX @@ static void channel_event(int event, SpiceChannelEventInfo *info) | ||
3825 | */ | ||
3826 | bool need_lock = !qemu_thread_is_self(&me); | ||
3827 | if (need_lock) { | ||
3828 | - qemu_mutex_lock_iothread(); | ||
3829 | + bql_lock(); | ||
3830 | } | ||
3831 | |||
3832 | if (info->flags & SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT) { | ||
3833 | @@ -XXX,XX +XXX,XX @@ static void channel_event(int event, SpiceChannelEventInfo *info) | ||
3834 | } | ||
3835 | |||
3836 | if (need_lock) { | ||
3837 | - qemu_mutex_unlock_iothread(); | ||
3838 | + bql_unlock(); | ||
3839 | } | ||
3840 | |||
3841 | qapi_free_SpiceServerInfo(server); | ||
3842 | diff --git a/util/async.c b/util/async.c | ||
3843 | index XXXXXXX..XXXXXXX 100644 | ||
3844 | --- a/util/async.c | ||
3845 | +++ b/util/async.c | ||
3846 | @@ -XXX,XX +XXX,XX @@ AioContext *qemu_get_current_aio_context(void) | ||
3847 | if (ctx) { | ||
3848 | return ctx; | ||
3849 | } | ||
3850 | - if (qemu_mutex_iothread_locked()) { | ||
3851 | + if (bql_locked()) { | ||
3852 | /* Possibly in a vCPU thread. */ | ||
3853 | return qemu_get_aio_context(); | ||
3854 | } | ||
3855 | diff --git a/util/main-loop.c b/util/main-loop.c | ||
3856 | index XXXXXXX..XXXXXXX 100644 | ||
3857 | --- a/util/main-loop.c | ||
3858 | +++ b/util/main-loop.c | ||
3859 | @@ -XXX,XX +XXX,XX @@ static int os_host_main_loop_wait(int64_t timeout) | ||
3860 | |||
3861 | glib_pollfds_fill(&timeout); | ||
3862 | |||
3863 | - qemu_mutex_unlock_iothread(); | ||
3864 | + bql_unlock(); | ||
3865 | replay_mutex_unlock(); | ||
3866 | |||
3867 | ret = qemu_poll_ns((GPollFD *)gpollfds->data, gpollfds->len, timeout); | ||
3868 | |||
3869 | replay_mutex_lock(); | ||
3870 | - qemu_mutex_lock_iothread(); | ||
3871 | + bql_lock(); | ||
3872 | |||
3873 | glib_pollfds_poll(); | ||
3874 | |||
3875 | @@ -XXX,XX +XXX,XX @@ static int os_host_main_loop_wait(int64_t timeout) | ||
3876 | |||
3877 | poll_timeout_ns = qemu_soonest_timeout(poll_timeout_ns, timeout); | ||
3878 | |||
3879 | - qemu_mutex_unlock_iothread(); | ||
3880 | + bql_unlock(); | ||
3881 | |||
3882 | replay_mutex_unlock(); | ||
3883 | |||
3884 | @@ -XXX,XX +XXX,XX @@ static int os_host_main_loop_wait(int64_t timeout) | ||
3885 | |||
3886 | replay_mutex_lock(); | ||
3887 | |||
3888 | - qemu_mutex_lock_iothread(); | ||
3889 | + bql_lock(); | ||
3890 | if (g_poll_ret > 0) { | ||
3891 | for (i = 0; i < w->num; i++) { | ||
3892 | w->revents[i] = poll_fds[n_poll_fds + i].revents; | ||
3893 | diff --git a/util/qsp.c b/util/qsp.c | ||
3894 | index XXXXXXX..XXXXXXX 100644 | ||
3895 | --- a/util/qsp.c | ||
3896 | +++ b/util/qsp.c | ||
3897 | @@ -XXX,XX +XXX,XX @@ static const char * const qsp_typenames[] = { | ||
3898 | [QSP_CONDVAR] = "condvar", | ||
3899 | }; | ||
3900 | |||
3901 | -QemuMutexLockFunc qemu_bql_mutex_lock_func = qemu_mutex_lock_impl; | ||
3902 | +QemuMutexLockFunc bql_mutex_lock_func = qemu_mutex_lock_impl; | ||
3903 | QemuMutexLockFunc qemu_mutex_lock_func = qemu_mutex_lock_impl; | ||
3904 | QemuMutexTrylockFunc qemu_mutex_trylock_func = qemu_mutex_trylock_impl; | ||
3905 | QemuRecMutexLockFunc qemu_rec_mutex_lock_func = qemu_rec_mutex_lock_impl; | ||
3906 | @@ -XXX,XX +XXX,XX @@ void qsp_enable(void) | ||
3907 | { | ||
3908 | qatomic_set(&qemu_mutex_lock_func, qsp_mutex_lock); | ||
3909 | qatomic_set(&qemu_mutex_trylock_func, qsp_mutex_trylock); | ||
3910 | - qatomic_set(&qemu_bql_mutex_lock_func, qsp_bql_mutex_lock); | ||
3911 | + qatomic_set(&bql_mutex_lock_func, qsp_bql_mutex_lock); | ||
3912 | qatomic_set(&qemu_rec_mutex_lock_func, qsp_rec_mutex_lock); | ||
3913 | qatomic_set(&qemu_rec_mutex_trylock_func, qsp_rec_mutex_trylock); | ||
3914 | qatomic_set(&qemu_cond_wait_func, qsp_cond_wait); | ||
3915 | @@ -XXX,XX +XXX,XX @@ void qsp_disable(void) | ||
3916 | { | ||
3917 | qatomic_set(&qemu_mutex_lock_func, qemu_mutex_lock_impl); | ||
3918 | qatomic_set(&qemu_mutex_trylock_func, qemu_mutex_trylock_impl); | ||
3919 | - qatomic_set(&qemu_bql_mutex_lock_func, qemu_mutex_lock_impl); | ||
3920 | + qatomic_set(&bql_mutex_lock_func, qemu_mutex_lock_impl); | ||
3921 | qatomic_set(&qemu_rec_mutex_lock_func, qemu_rec_mutex_lock_impl); | ||
3922 | qatomic_set(&qemu_rec_mutex_trylock_func, qemu_rec_mutex_trylock_impl); | ||
3923 | qatomic_set(&qemu_cond_wait_func, qemu_cond_wait_impl); | ||
3924 | diff --git a/util/rcu.c b/util/rcu.c | ||
3925 | index XXXXXXX..XXXXXXX 100644 | ||
3926 | --- a/util/rcu.c | ||
3927 | +++ b/util/rcu.c | ||
3928 | @@ -XXX,XX +XXX,XX @@ static void *call_rcu_thread(void *opaque) | ||
3929 | |||
3930 | qatomic_sub(&rcu_call_count, n); | ||
3931 | synchronize_rcu(); | ||
3932 | - qemu_mutex_lock_iothread(); | ||
3933 | + bql_lock(); | ||
3934 | while (n > 0) { | ||
3935 | node = try_dequeue(); | ||
3936 | while (!node) { | ||
3937 | - qemu_mutex_unlock_iothread(); | ||
3938 | + bql_unlock(); | ||
3939 | qemu_event_reset(&rcu_call_ready_event); | ||
3940 | node = try_dequeue(); | ||
3941 | if (!node) { | ||
3942 | qemu_event_wait(&rcu_call_ready_event); | ||
3943 | node = try_dequeue(); | ||
3944 | } | ||
3945 | - qemu_mutex_lock_iothread(); | ||
3946 | + bql_lock(); | ||
3947 | } | ||
3948 | |||
3949 | n--; | ||
3950 | node->func(node); | ||
3951 | } | ||
3952 | - qemu_mutex_unlock_iothread(); | ||
3953 | + bql_unlock(); | ||
3954 | } | ||
3955 | abort(); | ||
3956 | } | ||
3957 | @@ -XXX,XX +XXX,XX @@ static void drain_rcu_callback(struct rcu_head *node) | ||
3958 | void drain_call_rcu(void) | ||
3959 | { | ||
3960 | struct rcu_drain rcu_drain; | ||
3961 | - bool locked = qemu_mutex_iothread_locked(); | ||
3962 | + bool locked = bql_locked(); | ||
3963 | |||
3964 | memset(&rcu_drain, 0, sizeof(struct rcu_drain)); | ||
3965 | qemu_event_init(&rcu_drain.drain_complete_event, false); | ||
3966 | |||
3967 | if (locked) { | ||
3968 | - qemu_mutex_unlock_iothread(); | ||
3969 | + bql_unlock(); | ||
3970 | } | ||
3971 | |||
3972 | |||
3973 | @@ -XXX,XX +XXX,XX @@ void drain_call_rcu(void) | ||
3974 | qatomic_dec(&in_drain_call_rcu); | ||
3975 | |||
3976 | if (locked) { | ||
3977 | - qemu_mutex_lock_iothread(); | ||
3978 | + bql_lock(); | ||
3979 | } | ||
3980 | |||
3981 | } | ||
3982 | diff --git a/audio/coreaudio.m b/audio/coreaudio.m | ||
3983 | index XXXXXXX..XXXXXXX 100644 | ||
3984 | --- a/audio/coreaudio.m | ||
3985 | +++ b/audio/coreaudio.m | ||
3986 | @@ -XXX,XX +XXX,XX @@ static OSStatus handle_voice_change( | ||
3987 | { | ||
3988 | coreaudioVoiceOut *core = in_client_data; | ||
3989 | |||
3990 | - qemu_mutex_lock_iothread(); | ||
3991 | + bql_lock(); | ||
3992 | |||
3993 | if (core->outputDeviceID) { | ||
3994 | fini_out_device(core); | ||
3995 | @@ -XXX,XX +XXX,XX @@ static OSStatus handle_voice_change( | ||
3996 | update_device_playback_state(core); | ||
3997 | } | ||
3998 | |||
3999 | - qemu_mutex_unlock_iothread(); | ||
4000 | + bql_unlock(); | ||
4001 | return 0; | ||
4002 | } | ||
4003 | |||
4004 | diff --git a/memory_ldst.c.inc b/memory_ldst.c.inc | ||
4005 | index XXXXXXX..XXXXXXX 100644 | ||
4006 | --- a/memory_ldst.c.inc | ||
4007 | +++ b/memory_ldst.c.inc | ||
4008 | @@ -XXX,XX +XXX,XX @@ static inline uint32_t glue(address_space_ldl_internal, SUFFIX)(ARG1_DECL, | ||
4009 | *result = r; | ||
4010 | } | ||
4011 | if (release_lock) { | ||
4012 | - qemu_mutex_unlock_iothread(); | ||
4013 | + bql_unlock(); | ||
4014 | } | ||
4015 | RCU_READ_UNLOCK(); | ||
4016 | return val; | ||
4017 | @@ -XXX,XX +XXX,XX @@ static inline uint64_t glue(address_space_ldq_internal, SUFFIX)(ARG1_DECL, | ||
4018 | *result = r; | ||
4019 | } | ||
4020 | if (release_lock) { | ||
4021 | - qemu_mutex_unlock_iothread(); | ||
4022 | + bql_unlock(); | ||
4023 | } | ||
4024 | RCU_READ_UNLOCK(); | ||
4025 | return val; | ||
4026 | @@ -XXX,XX +XXX,XX @@ uint8_t glue(address_space_ldub, SUFFIX)(ARG1_DECL, | ||
4027 | *result = r; | ||
4028 | } | ||
4029 | if (release_lock) { | ||
4030 | - qemu_mutex_unlock_iothread(); | ||
4031 | + bql_unlock(); | ||
4032 | } | ||
4033 | RCU_READ_UNLOCK(); | ||
4034 | return val; | ||
4035 | @@ -XXX,XX +XXX,XX @@ static inline uint16_t glue(address_space_lduw_internal, SUFFIX)(ARG1_DECL, | ||
4036 | *result = r; | ||
4037 | } | ||
4038 | if (release_lock) { | ||
4039 | - qemu_mutex_unlock_iothread(); | ||
4040 | + bql_unlock(); | ||
4041 | } | ||
4042 | RCU_READ_UNLOCK(); | ||
4043 | return val; | ||
4044 | @@ -XXX,XX +XXX,XX @@ void glue(address_space_stl_notdirty, SUFFIX)(ARG1_DECL, | ||
4045 | *result = r; | ||
4046 | } | ||
4047 | if (release_lock) { | ||
4048 | - qemu_mutex_unlock_iothread(); | ||
4049 | + bql_unlock(); | ||
4050 | } | ||
4051 | RCU_READ_UNLOCK(); | ||
4052 | } | ||
4053 | @@ -XXX,XX +XXX,XX @@ static inline void glue(address_space_stl_internal, SUFFIX)(ARG1_DECL, | ||
4054 | *result = r; | ||
4055 | } | ||
4056 | if (release_lock) { | ||
4057 | - qemu_mutex_unlock_iothread(); | ||
4058 | + bql_unlock(); | ||
4059 | } | ||
4060 | RCU_READ_UNLOCK(); | ||
4061 | } | ||
4062 | @@ -XXX,XX +XXX,XX @@ void glue(address_space_stb, SUFFIX)(ARG1_DECL, | ||
4063 | *result = r; | ||
4064 | } | ||
4065 | if (release_lock) { | ||
4066 | - qemu_mutex_unlock_iothread(); | ||
4067 | + bql_unlock(); | ||
4068 | } | ||
4069 | RCU_READ_UNLOCK(); | ||
4070 | } | ||
4071 | @@ -XXX,XX +XXX,XX @@ static inline void glue(address_space_stw_internal, SUFFIX)(ARG1_DECL, | ||
4072 | *result = r; | ||
4073 | } | ||
4074 | if (release_lock) { | ||
4075 | - qemu_mutex_unlock_iothread(); | ||
4076 | + bql_unlock(); | ||
4077 | } | ||
4078 | RCU_READ_UNLOCK(); | ||
4079 | } | ||
4080 | @@ -XXX,XX +XXX,XX @@ static void glue(address_space_stq_internal, SUFFIX)(ARG1_DECL, | ||
4081 | *result = r; | ||
4082 | } | ||
4083 | if (release_lock) { | ||
4084 | - qemu_mutex_unlock_iothread(); | ||
4085 | + bql_unlock(); | ||
4086 | } | ||
4087 | RCU_READ_UNLOCK(); | ||
4088 | } | ||
4089 | diff --git a/target/i386/hvf/README.md b/target/i386/hvf/README.md | ||
4090 | index XXXXXXX..XXXXXXX 100644 | ||
4091 | --- a/target/i386/hvf/README.md | ||
4092 | +++ b/target/i386/hvf/README.md | ||
4093 | @@ -XXX,XX +XXX,XX @@ These sources (and ../hvf-all.c) are adapted from Veertu Inc's vdhh (Veertu Desk | ||
4094 | |||
4095 | 1. Adapt to our current QEMU's `CPUState` structure and `address_space_rw` API; many struct members have been moved around (emulated x86 state, xsave_buf) due to historical differences + QEMU needing to handle more emulation targets. | ||
4096 | 2. Removal of `apic_page` and hyperv-related functionality. | ||
4097 | -3. More relaxed use of `qemu_mutex_lock_iothread`. | ||
4098 | +3. More relaxed use of `bql_lock`. | ||
4099 | diff --git a/ui/cocoa.m b/ui/cocoa.m | ||
4100 | index XXXXXXX..XXXXXXX 100644 | ||
4101 | --- a/ui/cocoa.m | ||
4102 | +++ b/ui/cocoa.m | ||
4103 | @@ -XXX,XX +XXX,XX @@ static void cocoa_switch(DisplayChangeListener *dcl, | ||
4104 | typedef void (^CodeBlock)(void); | ||
4105 | typedef bool (^BoolCodeBlock)(void); | ||
4106 | |||
4107 | -static void with_iothread_lock(CodeBlock block) | ||
4108 | +static void with_bql(CodeBlock block) | ||
4109 | { | ||
4110 | - bool locked = qemu_mutex_iothread_locked(); | ||
4111 | + bool locked = bql_locked(); | ||
4112 | if (!locked) { | ||
4113 | - qemu_mutex_lock_iothread(); | ||
4114 | + bql_lock(); | ||
4115 | } | ||
4116 | block(); | ||
4117 | if (!locked) { | ||
4118 | - qemu_mutex_unlock_iothread(); | ||
4119 | + bql_unlock(); | ||
4120 | } | ||
4121 | } | ||
4122 | |||
4123 | -static bool bool_with_iothread_lock(BoolCodeBlock block) | ||
4124 | +static bool bool_with_bql(BoolCodeBlock block) | ||
4125 | { | ||
4126 | - bool locked = qemu_mutex_iothread_locked(); | ||
4127 | + bool locked = bql_locked(); | ||
4128 | bool val; | ||
4129 | |||
4130 | if (!locked) { | ||
4131 | - qemu_mutex_lock_iothread(); | ||
4132 | + bql_lock(); | ||
4133 | } | ||
4134 | val = block(); | ||
4135 | if (!locked) { | ||
4136 | - qemu_mutex_unlock_iothread(); | ||
4137 | + bql_unlock(); | ||
4138 | } | ||
4139 | return val; | ||
4140 | } | ||
4141 | @@ -XXX,XX +XXX,XX @@ - (void) updateUIInfo | ||
4142 | return; | ||
4143 | } | ||
4144 | |||
4145 | - with_iothread_lock(^{ | ||
4146 | + with_bql(^{ | ||
4147 | [self updateUIInfoLocked]; | ||
4148 | }); | ||
4149 | } | ||
4150 | @@ -XXX,XX +XXX,XX @@ - (void) handleMonitorInput:(NSEvent *)event | ||
4151 | |||
4152 | - (bool) handleEvent:(NSEvent *)event | ||
4153 | { | ||
4154 | - return bool_with_iothread_lock(^{ | ||
4155 | + return bool_with_bql(^{ | ||
4156 | return [self handleEventLocked:event]; | ||
4157 | }); | ||
4158 | } | ||
4159 | @@ -XXX,XX +XXX,XX @@ - (QEMUScreen) gscreen {return screen;} | ||
4160 | */ | ||
4161 | - (void) raiseAllKeys | ||
4162 | { | ||
4163 | - with_iothread_lock(^{ | ||
4164 | + with_bql(^{ | ||
4165 | qkbd_state_lift_all_keys(kbd); | ||
4166 | }); | ||
4167 | } | ||
4168 | @@ -XXX,XX +XXX,XX @@ - (void)applicationWillTerminate:(NSNotification *)aNotification | ||
4169 | { | ||
4170 | COCOA_DEBUG("QemuCocoaAppController: applicationWillTerminate\n"); | ||
4171 | |||
4172 | - with_iothread_lock(^{ | ||
4173 | + with_bql(^{ | ||
4174 | shutdown_action = SHUTDOWN_ACTION_POWEROFF; | ||
4175 | qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_UI); | ||
4176 | }); | ||
4177 | @@ -XXX,XX +XXX,XX @@ - (void)displayConsole:(id)sender | ||
4178 | /* Pause the guest */ | ||
4179 | - (void)pauseQEMU:(id)sender | ||
4180 | { | ||
4181 | - with_iothread_lock(^{ | ||
4182 | + with_bql(^{ | ||
4183 | qmp_stop(NULL); | ||
4184 | }); | ||
4185 | [sender setEnabled: NO]; | ||
4186 | @@ -XXX,XX +XXX,XX @@ - (void)pauseQEMU:(id)sender | ||
4187 | /* Resume running the guest operating system */ | ||
4188 | - (void)resumeQEMU:(id) sender | ||
4189 | { | ||
4190 | - with_iothread_lock(^{ | ||
4191 | + with_bql(^{ | ||
4192 | qmp_cont(NULL); | ||
4193 | }); | ||
4194 | [sender setEnabled: NO]; | ||
4195 | @@ -XXX,XX +XXX,XX @@ - (void)removePause | ||
4196 | /* Restarts QEMU */ | ||
4197 | - (void)restartQEMU:(id)sender | ||
4198 | { | ||
4199 | - with_iothread_lock(^{ | ||
4200 | + with_bql(^{ | ||
4201 | qmp_system_reset(NULL); | ||
4202 | }); | ||
4203 | } | ||
4204 | @@ -XXX,XX +XXX,XX @@ - (void)restartQEMU:(id)sender | ||
4205 | /* Powers down QEMU */ | ||
4206 | - (void)powerDownQEMU:(id)sender | ||
4207 | { | ||
4208 | - with_iothread_lock(^{ | ||
4209 | + with_bql(^{ | ||
4210 | qmp_system_powerdown(NULL); | ||
4211 | }); | ||
4212 | } | ||
4213 | @@ -XXX,XX +XXX,XX @@ - (void)ejectDeviceMedia:(id)sender | ||
4214 | } | ||
4215 | |||
4216 | __block Error *err = NULL; | ||
4217 | - with_iothread_lock(^{ | ||
4218 | + with_bql(^{ | ||
4219 | qmp_eject([drive cStringUsingEncoding: NSASCIIStringEncoding], | ||
4220 | NULL, false, false, &err); | ||
4221 | }); | ||
4222 | @@ -XXX,XX +XXX,XX @@ - (void)changeDeviceMedia:(id)sender | ||
4223 | } | ||
4224 | |||
4225 | __block Error *err = NULL; | ||
4226 | - with_iothread_lock(^{ | ||
4227 | + with_bql(^{ | ||
4228 | qmp_blockdev_change_medium([drive cStringUsingEncoding: | ||
4229 | NSASCIIStringEncoding], | ||
4230 | NULL, | ||
4231 | @@ -XXX,XX +XXX,XX @@ - (void)adjustSpeed:(id)sender | ||
4232 | // get the throttle percentage | ||
4233 | throttle_pct = [sender tag]; | ||
4234 | |||
4235 | - with_iothread_lock(^{ | ||
4236 | + with_bql(^{ | ||
4237 | cpu_throttle_set(throttle_pct); | ||
4238 | }); | ||
4239 | COCOA_DEBUG("cpu throttling at %d%c\n", cpu_throttle_get_percentage(), '%'); | ||
4240 | @@ -XXX,XX +XXX,XX @@ - (void)pasteboard:(NSPasteboard *)sender provideDataForType:(NSPasteboardType)t | ||
4241 | return; | ||
4242 | } | ||
4243 | |||
4244 | - with_iothread_lock(^{ | ||
4245 | + with_bql(^{ | ||
4246 | QemuClipboardInfo *info = qemu_clipboard_info_ref(cbinfo); | ||
4247 | qemu_event_reset(&cbevent); | ||
4248 | qemu_clipboard_request(info, QEMU_CLIPBOARD_TYPE_TEXT); | ||
4249 | @@ -XXX,XX +XXX,XX @@ - (void)pasteboard:(NSPasteboard *)sender provideDataForType:(NSPasteboardType)t | ||
4250 | while (info == cbinfo && | ||
4251 | info->types[QEMU_CLIPBOARD_TYPE_TEXT].available && | ||
4252 | info->types[QEMU_CLIPBOARD_TYPE_TEXT].data == NULL) { | ||
4253 | - qemu_mutex_unlock_iothread(); | ||
4254 | + bql_unlock(); | ||
4255 | qemu_event_wait(&cbevent); | ||
4256 | - qemu_mutex_lock_iothread(); | ||
4257 | + bql_lock(); | ||
4258 | } | ||
4259 | |||
4260 | if (info == cbinfo) { | ||
4261 | @@ -XXX,XX +XXX,XX @@ static void cocoa_clipboard_request(QemuClipboardInfo *info, | ||
4262 | int status; | ||
4263 | |||
4264 | COCOA_DEBUG("Second thread: calling qemu_default_main()\n"); | ||
4265 | - qemu_mutex_lock_iothread(); | ||
4266 | + bql_lock(); | ||
4267 | status = qemu_default_main(); | ||
4268 | - qemu_mutex_unlock_iothread(); | ||
4269 | + bql_unlock(); | ||
4270 | COCOA_DEBUG("Second thread: qemu_default_main() returned, exiting\n"); | ||
4271 | [cbowner release]; | ||
4272 | exit(status); | ||
4273 | @@ -XXX,XX +XXX,XX @@ static int cocoa_main(void) | ||
4274 | |||
4275 | COCOA_DEBUG("Entered %s()\n", __func__); | ||
4276 | |||
4277 | - qemu_mutex_unlock_iothread(); | ||
4278 | + bql_unlock(); | ||
4279 | qemu_thread_create(&thread, "qemu_main", call_qemu_main, | ||
4280 | NULL, QEMU_THREAD_DETACHED); | ||
60 | 4281 | ||
61 | -- | 4282 | -- |
62 | 2.24.1 | 4283 | 2.43.0 |
63 | 4284 | ||
64 | 4285 | diff view generated by jsdifflib |
1 | From: Philippe Mathieu-Daudé <philmd@redhat.com> | 1 | The name "iothread" is overloaded. Use the term Big QEMU Lock (BQL) |
---|---|---|---|
2 | 2 | instead, it is already widely used and unambiguous. | |
3 | Commit 6f6e1698a6 desugarized "-machine accel=" to a list | 3 | |
4 | of "-accel" options. Since now "-machine accel" and "-accel" | 4 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
5 | became incompatible, update the iotests to the new format. | 5 | Reviewed-by: Paul Durrant <paul@xen.org> |
6 | 6 | Acked-by: David Woodhouse <dwmw@amazon.co.uk> | |
7 | Error reported here: | 7 | Reviewed-by: Cédric Le Goater <clg@kaod.org> |
8 | https://gitlab.com/qemu-project/qemu/-/jobs/385801004#L3400 | 8 | Acked-by: Ilya Leoshkevich <iii@linux.ibm.com> |
9 | 9 | Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com> | |
10 | Reported-by: GitLab CI | 10 | Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com> |
11 | Fixes: 6f6e1698a6 (vl: configure accelerators from -accel options) | 11 | Message-id: 20240102153529.486531-3-stefanha@redhat.com |
12 | Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com> | 12 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
13 | Message-id: 20200106130951.29873-1-philmd@redhat.com | ||
14 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
15 | --- | 13 | --- |
16 | tests/qemu-iotests/235 | 2 +- | 14 | include/qemu/main-loop.h | 19 +++++++++---------- |
17 | tests/qemu-iotests/check | 6 +++--- | 15 | hw/i386/kvm/xen_evtchn.c | 14 +++++++------- |
18 | 2 files changed, 4 insertions(+), 4 deletions(-) | 16 | hw/i386/kvm/xen_gnttab.c | 2 +- |
19 | 17 | hw/mips/mips_int.c | 2 +- | |
20 | diff --git a/tests/qemu-iotests/235 b/tests/qemu-iotests/235 | 18 | hw/ppc/ppc.c | 2 +- |
21 | index XXXXXXX..XXXXXXX 100755 | 19 | target/i386/kvm/xen-emu.c | 2 +- |
22 | --- a/tests/qemu-iotests/235 | 20 | target/ppc/excp_helper.c | 2 +- |
23 | +++ b/tests/qemu-iotests/235 | 21 | target/ppc/helper_regs.c | 2 +- |
24 | @@ -XXX,XX +XXX,XX @@ qemu_img_create('-f', iotests.imgfmt, '-o', 'preallocation=metadata', disk, | 22 | target/riscv/cpu_helper.c | 4 ++-- |
25 | str(size)) | 23 | 9 files changed, 24 insertions(+), 25 deletions(-) |
26 | 24 | ||
27 | vm = QEMUMachine(iotests.qemu_prog) | 25 | diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h |
28 | -vm.add_args('-machine', 'accel=kvm:tcg') | 26 | index XXXXXXX..XXXXXXX 100644 |
29 | +vm.add_args('-accel', 'kvm', '-accel', 'tcg') | 27 | --- a/include/qemu/main-loop.h |
30 | if iotests.qemu_default_machine == 's390-ccw-virtio': | 28 | +++ b/include/qemu/main-loop.h |
31 | vm.add_args('-no-shutdown') | 29 | @@ -XXX,XX +XXX,XX @@ void bql_lock_impl(const char *file, int line); |
32 | vm.add_args('-drive', 'id=src,file=' + disk) | 30 | void bql_unlock(void); |
33 | diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check | 31 | |
34 | index XXXXXXX..XXXXXXX 100755 | 32 | /** |
35 | --- a/tests/qemu-iotests/check | 33 | - * QEMU_IOTHREAD_LOCK_GUARD |
36 | +++ b/tests/qemu-iotests/check | 34 | + * BQL_LOCK_GUARD |
37 | @@ -XXX,XX +XXX,XX @@ export QEMU_PROG="$(type -p "$QEMU_PROG")" | 35 | * |
38 | 36 | * Wrap a block of code in a conditional bql_{lock,unlock}. | |
39 | case "$QEMU_PROG" in | 37 | */ |
40 | *qemu-system-arm|*qemu-system-aarch64) | 38 | -typedef struct IOThreadLockAuto IOThreadLockAuto; |
41 | - export QEMU_OPTIONS="-nodefaults -display none -machine virt,accel=qtest" | 39 | +typedef struct BQLLockAuto BQLLockAuto; |
42 | + export QEMU_OPTIONS="-nodefaults -display none -machine virt -accel qtest" | 40 | |
43 | ;; | 41 | -static inline IOThreadLockAuto *qemu_iothread_auto_lock(const char *file, |
44 | *qemu-system-tricore) | 42 | - int line) |
45 | - export QEMU_OPTIONS="-nodefaults -display none -machine tricore_testboard,accel=qtest" | 43 | +static inline BQLLockAuto *bql_auto_lock(const char *file, int line) |
46 | + export QEMU_OPTIONS="-nodefaults -display none -machine tricore_testboard -accel qtest" | 44 | { |
47 | ;; | 45 | if (bql_locked()) { |
48 | *) | 46 | return NULL; |
49 | - export QEMU_OPTIONS="-nodefaults -display none -machine accel=qtest" | 47 | } |
50 | + export QEMU_OPTIONS="-nodefaults -display none -accel qtest" | 48 | bql_lock_impl(file, line); |
51 | ;; | 49 | /* Anything non-NULL causes the cleanup function to be called */ |
52 | esac | 50 | - return (IOThreadLockAuto *)(uintptr_t)1; |
51 | + return (BQLLockAuto *)(uintptr_t)1; | ||
52 | } | ||
53 | |||
54 | -static inline void qemu_iothread_auto_unlock(IOThreadLockAuto *l) | ||
55 | +static inline void bql_auto_unlock(BQLLockAuto *l) | ||
56 | { | ||
57 | bql_unlock(); | ||
58 | } | ||
59 | |||
60 | -G_DEFINE_AUTOPTR_CLEANUP_FUNC(IOThreadLockAuto, qemu_iothread_auto_unlock) | ||
61 | +G_DEFINE_AUTOPTR_CLEANUP_FUNC(BQLLockAuto, bql_auto_unlock) | ||
62 | |||
63 | -#define QEMU_IOTHREAD_LOCK_GUARD() \ | ||
64 | - g_autoptr(IOThreadLockAuto) _iothread_lock_auto __attribute__((unused)) \ | ||
65 | - = qemu_iothread_auto_lock(__FILE__, __LINE__) | ||
66 | +#define BQL_LOCK_GUARD() \ | ||
67 | + g_autoptr(BQLLockAuto) _bql_lock_auto __attribute__((unused)) \ | ||
68 | + = bql_auto_lock(__FILE__, __LINE__) | ||
69 | |||
70 | /* | ||
71 | * qemu_cond_wait_iothread: Wait on condition for the main loop mutex | ||
72 | diff --git a/hw/i386/kvm/xen_evtchn.c b/hw/i386/kvm/xen_evtchn.c | ||
73 | index XXXXXXX..XXXXXXX 100644 | ||
74 | --- a/hw/i386/kvm/xen_evtchn.c | ||
75 | +++ b/hw/i386/kvm/xen_evtchn.c | ||
76 | @@ -XXX,XX +XXX,XX @@ int xen_evtchn_reset_op(struct evtchn_reset *reset) | ||
77 | return -ESRCH; | ||
78 | } | ||
79 | |||
80 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
81 | + BQL_LOCK_GUARD(); | ||
82 | return xen_evtchn_soft_reset(); | ||
83 | } | ||
84 | |||
85 | @@ -XXX,XX +XXX,XX @@ int xen_evtchn_close_op(struct evtchn_close *close) | ||
86 | return -EINVAL; | ||
87 | } | ||
88 | |||
89 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
90 | + BQL_LOCK_GUARD(); | ||
91 | qemu_mutex_lock(&s->port_lock); | ||
92 | |||
93 | ret = close_port(s, close->port, &flush_kvm_routes); | ||
94 | @@ -XXX,XX +XXX,XX @@ int xen_evtchn_bind_pirq_op(struct evtchn_bind_pirq *pirq) | ||
95 | return -EINVAL; | ||
96 | } | ||
97 | |||
98 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
99 | + BQL_LOCK_GUARD(); | ||
100 | |||
101 | if (s->pirq[pirq->pirq].port) { | ||
102 | return -EBUSY; | ||
103 | @@ -XXX,XX +XXX,XX @@ int xen_physdev_map_pirq(struct physdev_map_pirq *map) | ||
104 | return -ENOTSUP; | ||
105 | } | ||
106 | |||
107 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
108 | + BQL_LOCK_GUARD(); | ||
109 | QEMU_LOCK_GUARD(&s->port_lock); | ||
110 | |||
111 | if (map->domid != DOMID_SELF && map->domid != xen_domid) { | ||
112 | @@ -XXX,XX +XXX,XX @@ int xen_physdev_unmap_pirq(struct physdev_unmap_pirq *unmap) | ||
113 | return -EINVAL; | ||
114 | } | ||
115 | |||
116 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
117 | + BQL_LOCK_GUARD(); | ||
118 | qemu_mutex_lock(&s->port_lock); | ||
119 | |||
120 | if (!pirq_inuse(s, pirq)) { | ||
121 | @@ -XXX,XX +XXX,XX @@ int xen_physdev_eoi_pirq(struct physdev_eoi *eoi) | ||
122 | return -ENOTSUP; | ||
123 | } | ||
124 | |||
125 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
126 | + BQL_LOCK_GUARD(); | ||
127 | QEMU_LOCK_GUARD(&s->port_lock); | ||
128 | |||
129 | if (!pirq_inuse(s, pirq)) { | ||
130 | @@ -XXX,XX +XXX,XX @@ int xen_physdev_query_pirq(struct physdev_irq_status_query *query) | ||
131 | return -ENOTSUP; | ||
132 | } | ||
133 | |||
134 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
135 | + BQL_LOCK_GUARD(); | ||
136 | QEMU_LOCK_GUARD(&s->port_lock); | ||
137 | |||
138 | if (!pirq_inuse(s, pirq)) { | ||
139 | diff --git a/hw/i386/kvm/xen_gnttab.c b/hw/i386/kvm/xen_gnttab.c | ||
140 | index XXXXXXX..XXXXXXX 100644 | ||
141 | --- a/hw/i386/kvm/xen_gnttab.c | ||
142 | +++ b/hw/i386/kvm/xen_gnttab.c | ||
143 | @@ -XXX,XX +XXX,XX @@ int xen_gnttab_map_page(uint64_t idx, uint64_t gfn) | ||
144 | return -EINVAL; | ||
145 | } | ||
146 | |||
147 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
148 | + BQL_LOCK_GUARD(); | ||
149 | QEMU_LOCK_GUARD(&s->gnt_lock); | ||
150 | |||
151 | xen_overlay_do_map_page(&s->gnt_aliases[idx], gpa); | ||
152 | diff --git a/hw/mips/mips_int.c b/hw/mips/mips_int.c | ||
153 | index XXXXXXX..XXXXXXX 100644 | ||
154 | --- a/hw/mips/mips_int.c | ||
155 | +++ b/hw/mips/mips_int.c | ||
156 | @@ -XXX,XX +XXX,XX @@ static void cpu_mips_irq_request(void *opaque, int irq, int level) | ||
157 | return; | ||
158 | } | ||
159 | |||
160 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
161 | + BQL_LOCK_GUARD(); | ||
162 | |||
163 | if (level) { | ||
164 | env->CP0_Cause |= 1 << (irq + CP0Ca_IP); | ||
165 | diff --git a/hw/ppc/ppc.c b/hw/ppc/ppc.c | ||
166 | index XXXXXXX..XXXXXXX 100644 | ||
167 | --- a/hw/ppc/ppc.c | ||
168 | +++ b/hw/ppc/ppc.c | ||
169 | @@ -XXX,XX +XXX,XX @@ void ppc_set_irq(PowerPCCPU *cpu, int irq, int level) | ||
170 | unsigned int old_pending; | ||
171 | |||
172 | /* We may already have the BQL if coming from the reset path */ | ||
173 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
174 | + BQL_LOCK_GUARD(); | ||
175 | |||
176 | old_pending = env->pending_interrupts; | ||
177 | |||
178 | diff --git a/target/i386/kvm/xen-emu.c b/target/i386/kvm/xen-emu.c | ||
179 | index XXXXXXX..XXXXXXX 100644 | ||
180 | --- a/target/i386/kvm/xen-emu.c | ||
181 | +++ b/target/i386/kvm/xen-emu.c | ||
182 | @@ -XXX,XX +XXX,XX @@ static int xen_set_shared_info(uint64_t gfn) | ||
183 | uint64_t gpa = gfn << TARGET_PAGE_BITS; | ||
184 | int i, err; | ||
185 | |||
186 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
187 | + BQL_LOCK_GUARD(); | ||
188 | |||
189 | /* | ||
190 | * The xen_overlay device tells KVM about it too, since it had to | ||
191 | diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c | ||
192 | index XXXXXXX..XXXXXXX 100644 | ||
193 | --- a/target/ppc/excp_helper.c | ||
194 | +++ b/target/ppc/excp_helper.c | ||
195 | @@ -XXX,XX +XXX,XX @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env) | ||
196 | void ppc_maybe_interrupt(CPUPPCState *env) | ||
197 | { | ||
198 | CPUState *cs = env_cpu(env); | ||
199 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
200 | + BQL_LOCK_GUARD(); | ||
201 | |||
202 | if (ppc_next_unmasked_interrupt(env)) { | ||
203 | cpu_interrupt(cs, CPU_INTERRUPT_HARD); | ||
204 | diff --git a/target/ppc/helper_regs.c b/target/ppc/helper_regs.c | ||
205 | index XXXXXXX..XXXXXXX 100644 | ||
206 | --- a/target/ppc/helper_regs.c | ||
207 | +++ b/target/ppc/helper_regs.c | ||
208 | @@ -XXX,XX +XXX,XX @@ void cpu_interrupt_exittb(CPUState *cs) | ||
209 | * unless running with TCG. | ||
210 | */ | ||
211 | if (tcg_enabled()) { | ||
212 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
213 | + BQL_LOCK_GUARD(); | ||
214 | cpu_interrupt(cs, CPU_INTERRUPT_EXITTB); | ||
215 | } | ||
216 | } | ||
217 | diff --git a/target/riscv/cpu_helper.c b/target/riscv/cpu_helper.c | ||
218 | index XXXXXXX..XXXXXXX 100644 | ||
219 | --- a/target/riscv/cpu_helper.c | ||
220 | +++ b/target/riscv/cpu_helper.c | ||
221 | @@ -XXX,XX +XXX,XX @@ void riscv_cpu_interrupt(CPURISCVState *env) | ||
222 | uint64_t gein, vsgein = 0, vstip = 0, irqf = 0; | ||
223 | CPUState *cs = env_cpu(env); | ||
224 | |||
225 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
226 | + BQL_LOCK_GUARD(); | ||
227 | |||
228 | if (env->virt_enabled) { | ||
229 | gein = get_field(env->hstatus, HSTATUS_VGEIN); | ||
230 | @@ -XXX,XX +XXX,XX @@ uint64_t riscv_cpu_update_mip(CPURISCVState *env, uint64_t mask, uint64_t value) | ||
231 | /* No need to update mip for VSTIP */ | ||
232 | mask = ((mask == MIP_VSTIP) && env->vstime_irq) ? 0 : mask; | ||
233 | |||
234 | - QEMU_IOTHREAD_LOCK_GUARD(); | ||
235 | + BQL_LOCK_GUARD(); | ||
236 | |||
237 | env->mip = (env->mip & ~mask) | (value & mask); | ||
53 | 238 | ||
54 | -- | 239 | -- |
55 | 2.24.1 | 240 | 2.43.0 |
56 | 241 | ||
57 | 242 | diff view generated by jsdifflib |
1 | Sometimes it is useful to be able to add a node to the block graph that | 1 | The name "iothread" is overloaded. Use the term Big QEMU Lock (BQL) |
---|---|---|---|
2 | takes or unshare a certain set of permissions for debugging purposes. | 2 | instead, it is already widely used and unambiguous. |
3 | This patch adds this capability to blkdebug. | ||
4 | 3 | ||
5 | (Note that you cannot make blkdebug release or share permissions that it | 4 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
6 | needs to take or cannot share, because this might result in assertion | 5 | Reviewed-by: Cédric Le Goater <clg@kaod.org> |
7 | failures in the block layer. But if the blkdebug node has no parents, | 6 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
8 | it will not take any permissions and share everything by default, so you | 7 | Reviewed-by: Paul Durrant <paul@xen.org> |
9 | can then freely choose what permissions to take and share.) | 8 | Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com> |
9 | Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com> | ||
10 | Message-id: 20240102153529.486531-4-stefanha@redhat.com | ||
11 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
12 | --- | ||
13 | include/qemu/main-loop.h | 10 +++++----- | ||
14 | accel/tcg/tcg-accel-ops-rr.c | 4 ++-- | ||
15 | hw/display/virtio-gpu.c | 2 +- | ||
16 | hw/ppc/spapr_events.c | 2 +- | ||
17 | system/cpu-throttle.c | 2 +- | ||
18 | system/cpus.c | 4 ++-- | ||
19 | target/i386/nvmm/nvmm-accel-ops.c | 2 +- | ||
20 | target/i386/whpx/whpx-accel-ops.c | 2 +- | ||
21 | 8 files changed, 14 insertions(+), 14 deletions(-) | ||
10 | 22 | ||
11 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 23 | diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h |
12 | Message-id: 20191108123455.39445-4-mreitz@redhat.com | ||
13 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
14 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
15 | --- | ||
16 | block/blkdebug.c | 93 +++++++++++++++++++++++++++++++++++++++++++- | ||
17 | qapi/block-core.json | 14 ++++++- | ||
18 | 2 files changed, 105 insertions(+), 2 deletions(-) | ||
19 | |||
20 | diff --git a/block/blkdebug.c b/block/blkdebug.c | ||
21 | index XXXXXXX..XXXXXXX 100644 | 24 | index XXXXXXX..XXXXXXX 100644 |
22 | --- a/block/blkdebug.c | 25 | --- a/include/qemu/main-loop.h |
23 | +++ b/block/blkdebug.c | 26 | +++ b/include/qemu/main-loop.h |
24 | @@ -XXX,XX +XXX,XX @@ | 27 | @@ -XXX,XX +XXX,XX @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(BQLLockAuto, bql_auto_unlock) |
25 | #include "qemu/cutils.h" | 28 | = bql_auto_lock(__FILE__, __LINE__) |
26 | #include "qemu/config-file.h" | 29 | |
27 | #include "block/block_int.h" | 30 | /* |
28 | +#include "block/qdict.h" | 31 | - * qemu_cond_wait_iothread: Wait on condition for the main loop mutex |
29 | #include "qemu/module.h" | 32 | + * qemu_cond_wait_bql: Wait on condition for the Big QEMU Lock (BQL) |
30 | #include "qemu/option.h" | 33 | * |
31 | +#include "qapi/qapi-visit-block-core.h" | 34 | - * This function atomically releases the main loop mutex and causes |
32 | #include "qapi/qmp/qdict.h" | 35 | + * This function atomically releases the Big QEMU Lock (BQL) and causes |
33 | +#include "qapi/qmp/qlist.h" | 36 | * the calling thread to block on the condition. |
34 | #include "qapi/qmp/qstring.h" | 37 | */ |
35 | +#include "qapi/qobject-input-visitor.h" | 38 | -void qemu_cond_wait_iothread(QemuCond *cond); |
36 | #include "sysemu/qtest.h" | 39 | +void qemu_cond_wait_bql(QemuCond *cond); |
37 | 40 | ||
38 | typedef struct BDRVBlkdebugState { | 41 | /* |
39 | @@ -XXX,XX +XXX,XX @@ typedef struct BDRVBlkdebugState { | 42 | - * qemu_cond_timedwait_iothread: like the previous, but with timeout |
40 | uint64_t opt_discard; | 43 | + * qemu_cond_timedwait_bql: like the previous, but with timeout |
41 | uint64_t max_discard; | 44 | */ |
42 | 45 | -void qemu_cond_timedwait_iothread(QemuCond *cond, int ms); | |
43 | + uint64_t take_child_perms; | 46 | +void qemu_cond_timedwait_bql(QemuCond *cond, int ms); |
44 | + uint64_t unshare_child_perms; | 47 | |
45 | + | 48 | /* internal interfaces */ |
46 | /* For blkdebug_refresh_filename() */ | 49 | |
47 | char *config_file; | 50 | diff --git a/accel/tcg/tcg-accel-ops-rr.c b/accel/tcg/tcg-accel-ops-rr.c |
48 | 51 | index XXXXXXX..XXXXXXX 100644 | |
49 | @@ -XXX,XX +XXX,XX @@ static void blkdebug_parse_filename(const char *filename, QDict *options, | 52 | --- a/accel/tcg/tcg-accel-ops-rr.c |
50 | qdict_put_str(options, "x-image", filename); | 53 | +++ b/accel/tcg/tcg-accel-ops-rr.c |
54 | @@ -XXX,XX +XXX,XX @@ static void rr_wait_io_event(void) | ||
55 | |||
56 | while (all_cpu_threads_idle()) { | ||
57 | rr_stop_kick_timer(); | ||
58 | - qemu_cond_wait_iothread(first_cpu->halt_cond); | ||
59 | + qemu_cond_wait_bql(first_cpu->halt_cond); | ||
60 | } | ||
61 | |||
62 | rr_start_kick_timer(); | ||
63 | @@ -XXX,XX +XXX,XX @@ static void *rr_cpu_thread_fn(void *arg) | ||
64 | |||
65 | /* wait for initial kick-off after machine start */ | ||
66 | while (first_cpu->stopped) { | ||
67 | - qemu_cond_wait_iothread(first_cpu->halt_cond); | ||
68 | + qemu_cond_wait_bql(first_cpu->halt_cond); | ||
69 | |||
70 | /* process any pending work */ | ||
71 | CPU_FOREACH(cpu) { | ||
72 | diff --git a/hw/display/virtio-gpu.c b/hw/display/virtio-gpu.c | ||
73 | index XXXXXXX..XXXXXXX 100644 | ||
74 | --- a/hw/display/virtio-gpu.c | ||
75 | +++ b/hw/display/virtio-gpu.c | ||
76 | @@ -XXX,XX +XXX,XX @@ void virtio_gpu_reset(VirtIODevice *vdev) | ||
77 | g->reset_finished = false; | ||
78 | qemu_bh_schedule(g->reset_bh); | ||
79 | while (!g->reset_finished) { | ||
80 | - qemu_cond_wait_iothread(&g->reset_cond); | ||
81 | + qemu_cond_wait_bql(&g->reset_cond); | ||
82 | } | ||
83 | } else { | ||
84 | virtio_gpu_reset_bh(g); | ||
85 | diff --git a/hw/ppc/spapr_events.c b/hw/ppc/spapr_events.c | ||
86 | index XXXXXXX..XXXXXXX 100644 | ||
87 | --- a/hw/ppc/spapr_events.c | ||
88 | +++ b/hw/ppc/spapr_events.c | ||
89 | @@ -XXX,XX +XXX,XX @@ void spapr_mce_req_event(PowerPCCPU *cpu, bool recovered) | ||
90 | } | ||
91 | return; | ||
92 | } | ||
93 | - qemu_cond_wait_iothread(&spapr->fwnmi_machine_check_interlock_cond); | ||
94 | + qemu_cond_wait_bql(&spapr->fwnmi_machine_check_interlock_cond); | ||
95 | if (spapr->fwnmi_machine_check_addr == -1) { | ||
96 | /* | ||
97 | * If the machine was reset while waiting for the interlock, | ||
98 | diff --git a/system/cpu-throttle.c b/system/cpu-throttle.c | ||
99 | index XXXXXXX..XXXXXXX 100644 | ||
100 | --- a/system/cpu-throttle.c | ||
101 | +++ b/system/cpu-throttle.c | ||
102 | @@ -XXX,XX +XXX,XX @@ static void cpu_throttle_thread(CPUState *cpu, run_on_cpu_data opaque) | ||
103 | endtime_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + sleeptime_ns; | ||
104 | while (sleeptime_ns > 0 && !cpu->stop) { | ||
105 | if (sleeptime_ns > SCALE_MS) { | ||
106 | - qemu_cond_timedwait_iothread(cpu->halt_cond, | ||
107 | + qemu_cond_timedwait_bql(cpu->halt_cond, | ||
108 | sleeptime_ns / SCALE_MS); | ||
109 | } else { | ||
110 | bql_unlock(); | ||
111 | diff --git a/system/cpus.c b/system/cpus.c | ||
112 | index XXXXXXX..XXXXXXX 100644 | ||
113 | --- a/system/cpus.c | ||
114 | +++ b/system/cpus.c | ||
115 | @@ -XXX,XX +XXX,XX @@ void bql_unlock(void) | ||
116 | qemu_mutex_unlock(&bql); | ||
51 | } | 117 | } |
52 | 118 | ||
53 | +static int blkdebug_parse_perm_list(uint64_t *dest, QDict *options, | 119 | -void qemu_cond_wait_iothread(QemuCond *cond) |
54 | + const char *prefix, Error **errp) | 120 | +void qemu_cond_wait_bql(QemuCond *cond) |
55 | +{ | 121 | { |
56 | + int ret = 0; | 122 | qemu_cond_wait(cond, &bql); |
57 | + QDict *subqdict = NULL; | ||
58 | + QObject *crumpled_subqdict = NULL; | ||
59 | + Visitor *v = NULL; | ||
60 | + BlockPermissionList *perm_list = NULL, *element; | ||
61 | + Error *local_err = NULL; | ||
62 | + | ||
63 | + *dest = 0; | ||
64 | + | ||
65 | + qdict_extract_subqdict(options, &subqdict, prefix); | ||
66 | + if (!qdict_size(subqdict)) { | ||
67 | + goto out; | ||
68 | + } | ||
69 | + | ||
70 | + crumpled_subqdict = qdict_crumple(subqdict, errp); | ||
71 | + if (!crumpled_subqdict) { | ||
72 | + ret = -EINVAL; | ||
73 | + goto out; | ||
74 | + } | ||
75 | + | ||
76 | + v = qobject_input_visitor_new(crumpled_subqdict); | ||
77 | + visit_type_BlockPermissionList(v, NULL, &perm_list, &local_err); | ||
78 | + if (local_err) { | ||
79 | + error_propagate(errp, local_err); | ||
80 | + ret = -EINVAL; | ||
81 | + goto out; | ||
82 | + } | ||
83 | + | ||
84 | + for (element = perm_list; element; element = element->next) { | ||
85 | + *dest |= bdrv_qapi_perm_to_blk_perm(element->value); | ||
86 | + } | ||
87 | + | ||
88 | +out: | ||
89 | + qapi_free_BlockPermissionList(perm_list); | ||
90 | + visit_free(v); | ||
91 | + qobject_unref(subqdict); | ||
92 | + qobject_unref(crumpled_subqdict); | ||
93 | + return ret; | ||
94 | +} | ||
95 | + | ||
96 | +static int blkdebug_parse_perms(BDRVBlkdebugState *s, QDict *options, | ||
97 | + Error **errp) | ||
98 | +{ | ||
99 | + int ret; | ||
100 | + | ||
101 | + ret = blkdebug_parse_perm_list(&s->take_child_perms, options, | ||
102 | + "take-child-perms.", errp); | ||
103 | + if (ret < 0) { | ||
104 | + return ret; | ||
105 | + } | ||
106 | + | ||
107 | + ret = blkdebug_parse_perm_list(&s->unshare_child_perms, options, | ||
108 | + "unshare-child-perms.", errp); | ||
109 | + if (ret < 0) { | ||
110 | + return ret; | ||
111 | + } | ||
112 | + | ||
113 | + return 0; | ||
114 | +} | ||
115 | + | ||
116 | static QemuOptsList runtime_opts = { | ||
117 | .name = "blkdebug", | ||
118 | .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), | ||
119 | @@ -XXX,XX +XXX,XX @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, | ||
120 | /* Set initial state */ | ||
121 | s->state = 1; | ||
122 | |||
123 | + /* Parse permissions modifiers before opening the image file */ | ||
124 | + ret = blkdebug_parse_perms(s, options, errp); | ||
125 | + if (ret < 0) { | ||
126 | + goto out; | ||
127 | + } | ||
128 | + | ||
129 | /* Open the image file */ | ||
130 | bs->file = bdrv_open_child(qemu_opt_get(opts, "x-image"), options, "image", | ||
131 | bs, &child_file, false, &local_err); | ||
132 | @@ -XXX,XX +XXX,XX @@ static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state, | ||
133 | return 0; | ||
134 | } | 123 | } |
135 | 124 | ||
136 | +static void blkdebug_child_perm(BlockDriverState *bs, BdrvChild *c, | 125 | -void qemu_cond_timedwait_iothread(QemuCond *cond, int ms) |
137 | + const BdrvChildRole *role, | 126 | +void qemu_cond_timedwait_bql(QemuCond *cond, int ms) |
138 | + BlockReopenQueue *reopen_queue, | 127 | { |
139 | + uint64_t perm, uint64_t shared, | 128 | qemu_cond_timedwait(cond, &bql, ms); |
140 | + uint64_t *nperm, uint64_t *nshared) | 129 | } |
141 | +{ | 130 | diff --git a/target/i386/nvmm/nvmm-accel-ops.c b/target/i386/nvmm/nvmm-accel-ops.c |
142 | + BDRVBlkdebugState *s = bs->opaque; | ||
143 | + | ||
144 | + bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared, | ||
145 | + nperm, nshared); | ||
146 | + | ||
147 | + *nperm |= s->take_child_perms; | ||
148 | + *nshared &= ~s->unshare_child_perms; | ||
149 | +} | ||
150 | + | ||
151 | static const char *const blkdebug_strong_runtime_opts[] = { | ||
152 | "config", | ||
153 | "inject-error.", | ||
154 | @@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_blkdebug = { | ||
155 | .bdrv_file_open = blkdebug_open, | ||
156 | .bdrv_close = blkdebug_close, | ||
157 | .bdrv_reopen_prepare = blkdebug_reopen_prepare, | ||
158 | - .bdrv_child_perm = bdrv_filter_default_perms, | ||
159 | + .bdrv_child_perm = blkdebug_child_perm, | ||
160 | |||
161 | .bdrv_getlength = blkdebug_getlength, | ||
162 | .bdrv_refresh_filename = blkdebug_refresh_filename, | ||
163 | diff --git a/qapi/block-core.json b/qapi/block-core.json | ||
164 | index XXXXXXX..XXXXXXX 100644 | 131 | index XXXXXXX..XXXXXXX 100644 |
165 | --- a/qapi/block-core.json | 132 | --- a/target/i386/nvmm/nvmm-accel-ops.c |
166 | +++ b/qapi/block-core.json | 133 | +++ b/target/i386/nvmm/nvmm-accel-ops.c |
167 | @@ -XXX,XX +XXX,XX @@ | 134 | @@ -XXX,XX +XXX,XX @@ static void *qemu_nvmm_cpu_thread_fn(void *arg) |
168 | # | 135 | } |
169 | # @set-state: array of state-change descriptions | 136 | } |
170 | # | 137 | while (cpu_thread_is_idle(cpu)) { |
171 | +# @take-child-perms: Permissions to take on @image in addition to what | 138 | - qemu_cond_wait_iothread(cpu->halt_cond); |
172 | +# is necessary anyway (which depends on how the | 139 | + qemu_cond_wait_bql(cpu->halt_cond); |
173 | +# blkdebug node is used). Defaults to none. | 140 | } |
174 | +# (since 5.0) | 141 | qemu_wait_io_event_common(cpu); |
175 | +# | 142 | } while (!cpu->unplug || cpu_can_run(cpu)); |
176 | +# @unshare-child-perms: Permissions not to share on @image in addition | 143 | diff --git a/target/i386/whpx/whpx-accel-ops.c b/target/i386/whpx/whpx-accel-ops.c |
177 | +# to what cannot be shared anyway (which depends | 144 | index XXXXXXX..XXXXXXX 100644 |
178 | +# on how the blkdebug node is used). Defaults | 145 | --- a/target/i386/whpx/whpx-accel-ops.c |
179 | +# to none. (since 5.0) | 146 | +++ b/target/i386/whpx/whpx-accel-ops.c |
180 | +# | 147 | @@ -XXX,XX +XXX,XX @@ static void *whpx_cpu_thread_fn(void *arg) |
181 | # Since: 2.9 | 148 | } |
182 | ## | 149 | } |
183 | { 'struct': 'BlockdevOptionsBlkdebug', | 150 | while (cpu_thread_is_idle(cpu)) { |
184 | @@ -XXX,XX +XXX,XX @@ | 151 | - qemu_cond_wait_iothread(cpu->halt_cond); |
185 | '*opt-write-zero': 'int32', '*max-write-zero': 'int32', | 152 | + qemu_cond_wait_bql(cpu->halt_cond); |
186 | '*opt-discard': 'int32', '*max-discard': 'int32', | 153 | } |
187 | '*inject-error': ['BlkdebugInjectErrorOptions'], | 154 | qemu_wait_io_event_common(cpu); |
188 | - '*set-state': ['BlkdebugSetStateOptions'] } } | 155 | } while (!cpu->unplug || cpu_can_run(cpu)); |
189 | + '*set-state': ['BlkdebugSetStateOptions'], | ||
190 | + '*take-child-perms': ['BlockPermission'], | ||
191 | + '*unshare-child-perms': ['BlockPermission'] } } | ||
192 | |||
193 | ## | ||
194 | # @BlockdevOptionsBlklogwrites: | ||
195 | -- | 156 | -- |
196 | 2.24.1 | 157 | 2.43.0 |
197 | 158 | ||
198 | 159 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Callers can use this new parameter to expect failure during the | ||
2 | completion process. | ||
3 | 1 | ||
4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
5 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
6 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
7 | Message-id: 20191108123455.39445-5-mreitz@redhat.com | ||
8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
9 | --- | ||
10 | tests/qemu-iotests/iotests.py | 18 ++++++++++++------ | ||
11 | 1 file changed, 12 insertions(+), 6 deletions(-) | ||
12 | |||
13 | diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py | ||
14 | index XXXXXXX..XXXXXXX 100644 | ||
15 | --- a/tests/qemu-iotests/iotests.py | ||
16 | +++ b/tests/qemu-iotests/iotests.py | ||
17 | @@ -XXX,XX +XXX,XX @@ class QMPTestCase(unittest.TestCase): | ||
18 | self.assert_no_active_block_jobs() | ||
19 | return result | ||
20 | |||
21 | - def wait_until_completed(self, drive='drive0', check_offset=True, wait=60.0): | ||
22 | + def wait_until_completed(self, drive='drive0', check_offset=True, wait=60.0, | ||
23 | + error=None): | ||
24 | '''Wait for a block job to finish, returning the event''' | ||
25 | while True: | ||
26 | for event in self.vm.get_qmp_events(wait=wait): | ||
27 | if event['event'] == 'BLOCK_JOB_COMPLETED': | ||
28 | self.assert_qmp(event, 'data/device', drive) | ||
29 | - self.assert_qmp_absent(event, 'data/error') | ||
30 | - if check_offset: | ||
31 | - self.assert_qmp(event, 'data/offset', event['data']['len']) | ||
32 | + if error is None: | ||
33 | + self.assert_qmp_absent(event, 'data/error') | ||
34 | + if check_offset: | ||
35 | + self.assert_qmp(event, 'data/offset', | ||
36 | + event['data']['len']) | ||
37 | + else: | ||
38 | + self.assert_qmp(event, 'data/error', error) | ||
39 | self.assert_no_active_block_jobs() | ||
40 | return event | ||
41 | elif event['event'] == 'JOB_STATUS_CHANGE': | ||
42 | @@ -XXX,XX +XXX,XX @@ class QMPTestCase(unittest.TestCase): | ||
43 | self.assert_qmp(event, 'data/type', 'mirror') | ||
44 | self.assert_qmp(event, 'data/offset', event['data']['len']) | ||
45 | |||
46 | - def complete_and_wait(self, drive='drive0', wait_ready=True): | ||
47 | + def complete_and_wait(self, drive='drive0', wait_ready=True, | ||
48 | + completion_error=None): | ||
49 | '''Complete a block job and wait for it to finish''' | ||
50 | if wait_ready: | ||
51 | self.wait_ready(drive=drive) | ||
52 | @@ -XXX,XX +XXX,XX @@ class QMPTestCase(unittest.TestCase): | ||
53 | result = self.vm.qmp('block-job-complete', device=drive) | ||
54 | self.assert_qmp(result, 'return', {}) | ||
55 | |||
56 | - event = self.wait_until_completed(drive=drive) | ||
57 | + event = self.wait_until_completed(drive=drive, error=completion_error) | ||
58 | self.assert_qmp(event, 'data/type', 'mirror') | ||
59 | |||
60 | def pause_wait(self, job_id='job0'): | ||
61 | -- | ||
62 | 2.24.1 | ||
63 | |||
64 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
2 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
3 | Tested-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
4 | Reviewed-by: John Snow <jsnow@redhat.com> | ||
5 | Message-id: 20191108123455.39445-6-mreitz@redhat.com | ||
6 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
7 | --- | ||
8 | tests/qemu-iotests/041 | 44 ++++++++++++++++++++++++++++++++++++++ | ||
9 | tests/qemu-iotests/041.out | 4 ++-- | ||
10 | 2 files changed, 46 insertions(+), 2 deletions(-) | ||
11 | 1 | ||
12 | diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041 | ||
13 | index XXXXXXX..XXXXXXX 100755 | ||
14 | --- a/tests/qemu-iotests/041 | ||
15 | +++ b/tests/qemu-iotests/041 | ||
16 | @@ -XXX,XX +XXX,XX @@ class TestOrphanedSource(iotests.QMPTestCase): | ||
17 | target='dest-ro') | ||
18 | self.assert_qmp(result, 'error/class', 'GenericError') | ||
19 | |||
20 | + def test_failing_permission_in_complete(self): | ||
21 | + self.assert_no_active_block_jobs() | ||
22 | + | ||
23 | + # Unshare consistent-read on the target | ||
24 | + # (The mirror job does not care) | ||
25 | + result = self.vm.qmp('blockdev-add', | ||
26 | + driver='blkdebug', | ||
27 | + node_name='dest-perm', | ||
28 | + image='dest', | ||
29 | + unshare_child_perms=['consistent-read']) | ||
30 | + self.assert_qmp(result, 'return', {}) | ||
31 | + | ||
32 | + result = self.vm.qmp('blockdev-mirror', job_id='job', device='src', | ||
33 | + sync='full', target='dest', | ||
34 | + filter_node_name='mirror-filter') | ||
35 | + self.assert_qmp(result, 'return', {}) | ||
36 | + | ||
37 | + # Require consistent-read on the source | ||
38 | + # (We can only add this node once the job has started, or it | ||
39 | + # will complain that it does not want to run on non-root nodes) | ||
40 | + result = self.vm.qmp('blockdev-add', | ||
41 | + driver='blkdebug', | ||
42 | + node_name='src-perm', | ||
43 | + image='src', | ||
44 | + take_child_perms=['consistent-read']) | ||
45 | + self.assert_qmp(result, 'return', {}) | ||
46 | + | ||
47 | + # While completing, mirror will attempt to replace src by | ||
48 | + # dest, which must fail because src-perm requires | ||
49 | + # consistent-read but dest-perm does not share it; thus | ||
50 | + # aborting the job when it is supposed to complete | ||
51 | + self.complete_and_wait('job', | ||
52 | + completion_error='Operation not permitted') | ||
53 | + | ||
54 | + # Assert that all of our nodes are still there (except for the | ||
55 | + # mirror filter, which should be gone despite the failure) | ||
56 | + nodes = self.vm.qmp('query-named-block-nodes')['return'] | ||
57 | + nodes = [node['node-name'] for node in nodes] | ||
58 | + | ||
59 | + for expect in ('src', 'src-perm', 'dest', 'dest-perm'): | ||
60 | + self.assertTrue(expect in nodes, '%s disappeared' % expect) | ||
61 | + self.assertFalse('mirror-filter' in nodes, | ||
62 | + 'Mirror filter node did not disappear') | ||
63 | + | ||
64 | if __name__ == '__main__': | ||
65 | iotests.main(supported_fmts=['qcow2', 'qed'], | ||
66 | supported_protocols=['file']) | ||
67 | diff --git a/tests/qemu-iotests/041.out b/tests/qemu-iotests/041.out | ||
68 | index XXXXXXX..XXXXXXX 100644 | ||
69 | --- a/tests/qemu-iotests/041.out | ||
70 | +++ b/tests/qemu-iotests/041.out | ||
71 | @@ -XXX,XX +XXX,XX @@ | ||
72 | -.......................................................................................... | ||
73 | +........................................................................................... | ||
74 | ---------------------------------------------------------------------- | ||
75 | -Ran 90 tests | ||
76 | +Ran 91 tests | ||
77 | |||
78 | OK | ||
79 | -- | ||
80 | 2.24.1 | ||
81 | |||
82 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | From: PanNengyuan <pannengyuan@huawei.com> | ||
2 | 1 | ||
3 | This avoid a memory leak when qom-set is called to set throttle_group | ||
4 | limits, here is an easy way to reproduce: | ||
5 | |||
6 | 1. run qemu-iotests as follow and check the result with asan: | ||
7 | ./check -qcow2 184 | ||
8 | |||
9 | Following is the asan output backtrack: | ||
10 | Direct leak of 912 byte(s) in 3 object(s) allocated from: | ||
11 | #0 0xffff8d7ab3c3 in __interceptor_calloc (/lib64/libasan.so.4+0xd33c3) | ||
12 | #1 0xffff8d4c31cb in g_malloc0 (/lib64/libglib-2.0.so.0+0x571cb) | ||
13 | #2 0x190c857 in qobject_input_start_struct /mnt/sdc/qemu-master/qemu-4.2.0-rc0/qapi/qobject-input-visitor.c:295 | ||
14 | #3 0x19070df in visit_start_struct /mnt/sdc/qemu-master/qemu-4.2.0-rc0/qapi/qapi-visit-core.c:49 | ||
15 | #4 0x1948b87 in visit_type_ThrottleLimits qapi/qapi-visit-block-core.c:3759 | ||
16 | #5 0x17e4aa3 in throttle_group_set_limits /mnt/sdc/qemu-master/qemu-4.2.0-rc0/block/throttle-groups.c:900 | ||
17 | #6 0x1650eff in object_property_set /mnt/sdc/qemu-master/qemu-4.2.0-rc0/qom/object.c:1272 | ||
18 | #7 0x1658517 in object_property_set_qobject /mnt/sdc/qemu-master/qemu-4.2.0-rc0/qom/qom-qobject.c:26 | ||
19 | #8 0x15880bb in qmp_qom_set /mnt/sdc/qemu-master/qemu-4.2.0-rc0/qom/qom-qmp-cmds.c:74 | ||
20 | #9 0x157e3e3 in qmp_marshal_qom_set qapi/qapi-commands-qom.c:154 | ||
21 | |||
22 | Reported-by: Euler Robot <euler.robot@huawei.com> | ||
23 | Signed-off-by: PanNengyuan <pannengyuan@huawei.com> | ||
24 | Message-id: 1574835614-42028-1-git-send-email-pannengyuan@huawei.com | ||
25 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
26 | --- | ||
27 | block/throttle-groups.c | 4 ++-- | ||
28 | 1 file changed, 2 insertions(+), 2 deletions(-) | ||
29 | |||
30 | diff --git a/block/throttle-groups.c b/block/throttle-groups.c | ||
31 | index XXXXXXX..XXXXXXX 100644 | ||
32 | --- a/block/throttle-groups.c | ||
33 | +++ b/block/throttle-groups.c | ||
34 | @@ -XXX,XX +XXX,XX @@ static void throttle_group_set_limits(Object *obj, Visitor *v, | ||
35 | { | ||
36 | ThrottleGroup *tg = THROTTLE_GROUP(obj); | ||
37 | ThrottleConfig cfg; | ||
38 | - ThrottleLimits arg = { 0 }; | ||
39 | - ThrottleLimits *argp = &arg; | ||
40 | + ThrottleLimits *argp; | ||
41 | Error *local_err = NULL; | ||
42 | |||
43 | visit_type_ThrottleLimits(v, name, &argp, &local_err); | ||
44 | @@ -XXX,XX +XXX,XX @@ static void throttle_group_set_limits(Object *obj, Visitor *v, | ||
45 | unlock: | ||
46 | qemu_mutex_unlock(&tg->lock); | ||
47 | ret: | ||
48 | + qapi_free_ThrottleLimits(argp); | ||
49 | error_propagate(errp, local_err); | ||
50 | return; | ||
51 | } | ||
52 | -- | ||
53 | 2.24.1 | ||
54 | |||
55 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
2 | 1 | ||
3 | qcow2_can_store_new_dirty_bitmap works wrong, as it considers only | ||
4 | bitmaps already stored in the qcow2 image and ignores persistent | ||
5 | BdrvDirtyBitmap objects. | ||
6 | |||
7 | So, let's instead count persistent BdrvDirtyBitmaps. We load all qcow2 | ||
8 | bitmaps on open, so there should not be any bitmap in the image for | ||
9 | which we don't have BdrvDirtyBitmaps version. If it is - it's a kind of | ||
10 | corruption, and no reason to check for corruptions here (open() and | ||
11 | close() are better places for it). | ||
12 | |||
13 | Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
14 | Message-id: 20191014115126.15360-2-vsementsov@virtuozzo.com | ||
15 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
16 | Cc: qemu-stable@nongnu.org | ||
17 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
18 | --- | ||
19 | block/qcow2-bitmap.c | 41 ++++++++++++++++++----------------------- | ||
20 | 1 file changed, 18 insertions(+), 23 deletions(-) | ||
21 | |||
22 | diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c | ||
23 | index XXXXXXX..XXXXXXX 100644 | ||
24 | --- a/block/qcow2-bitmap.c | ||
25 | +++ b/block/qcow2-bitmap.c | ||
26 | @@ -XXX,XX +XXX,XX @@ bool coroutine_fn qcow2_co_can_store_new_dirty_bitmap(BlockDriverState *bs, | ||
27 | Error **errp) | ||
28 | { | ||
29 | BDRVQcow2State *s = bs->opaque; | ||
30 | - bool found; | ||
31 | - Qcow2BitmapList *bm_list; | ||
32 | + BdrvDirtyBitmap *bitmap; | ||
33 | + uint64_t bitmap_directory_size = 0; | ||
34 | + uint32_t nb_bitmaps = 0; | ||
35 | + | ||
36 | + if (bdrv_find_dirty_bitmap(bs, name)) { | ||
37 | + error_setg(errp, "Bitmap already exists: %s", name); | ||
38 | + return false; | ||
39 | + } | ||
40 | |||
41 | if (s->qcow_version < 3) { | ||
42 | /* Without autoclear_features, we would always have to assume | ||
43 | @@ -XXX,XX +XXX,XX @@ bool coroutine_fn qcow2_co_can_store_new_dirty_bitmap(BlockDriverState *bs, | ||
44 | goto fail; | ||
45 | } | ||
46 | |||
47 | - if (s->nb_bitmaps == 0) { | ||
48 | - return true; | ||
49 | + FOR_EACH_DIRTY_BITMAP(bs, bitmap) { | ||
50 | + if (bdrv_dirty_bitmap_get_persistence(bitmap)) { | ||
51 | + nb_bitmaps++; | ||
52 | + bitmap_directory_size += | ||
53 | + calc_dir_entry_size(strlen(bdrv_dirty_bitmap_name(bitmap)), 0); | ||
54 | + } | ||
55 | } | ||
56 | + nb_bitmaps++; | ||
57 | + bitmap_directory_size += calc_dir_entry_size(strlen(name), 0); | ||
58 | |||
59 | - if (s->nb_bitmaps >= QCOW2_MAX_BITMAPS) { | ||
60 | + if (nb_bitmaps > QCOW2_MAX_BITMAPS) { | ||
61 | error_setg(errp, | ||
62 | "Maximum number of persistent bitmaps is already reached"); | ||
63 | goto fail; | ||
64 | } | ||
65 | |||
66 | - if (s->bitmap_directory_size + calc_dir_entry_size(strlen(name), 0) > | ||
67 | - QCOW2_MAX_BITMAP_DIRECTORY_SIZE) | ||
68 | - { | ||
69 | + if (bitmap_directory_size > QCOW2_MAX_BITMAP_DIRECTORY_SIZE) { | ||
70 | error_setg(errp, "Not enough space in the bitmap directory"); | ||
71 | goto fail; | ||
72 | } | ||
73 | |||
74 | - qemu_co_mutex_lock(&s->lock); | ||
75 | - bm_list = bitmap_list_load(bs, s->bitmap_directory_offset, | ||
76 | - s->bitmap_directory_size, errp); | ||
77 | - qemu_co_mutex_unlock(&s->lock); | ||
78 | - if (bm_list == NULL) { | ||
79 | - goto fail; | ||
80 | - } | ||
81 | - | ||
82 | - found = find_bitmap_by_name(bm_list, name); | ||
83 | - bitmap_list_free(bm_list); | ||
84 | - if (found) { | ||
85 | - error_setg(errp, "Bitmap with the same name is already stored"); | ||
86 | - goto fail; | ||
87 | - } | ||
88 | - | ||
89 | return true; | ||
90 | |||
91 | fail: | ||
92 | -- | ||
93 | 2.24.1 | ||
94 | |||
95 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Probably due to blind copy-pasting, we have several instances of "qocw2" | ||
2 | in our iotests. Fix them. | ||
3 | 1 | ||
4 | Reported-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
5 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
6 | Message-id: 20191107163708.833192-2-mreitz@redhat.com | ||
7 | Reviewed-by: Eric Blake <eblake@redhat.com> | ||
8 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
9 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
10 | --- | ||
11 | tests/qemu-iotests/060 | 2 +- | ||
12 | tests/qemu-iotests/061 | 2 +- | ||
13 | tests/qemu-iotests/062 | 2 +- | ||
14 | tests/qemu-iotests/066 | 2 +- | ||
15 | tests/qemu-iotests/068 | 2 +- | ||
16 | tests/qemu-iotests/108 | 2 +- | ||
17 | tests/qemu-iotests/138 | 2 +- | ||
18 | tests/qemu-iotests/261 | 2 +- | ||
19 | 8 files changed, 8 insertions(+), 8 deletions(-) | ||
20 | |||
21 | diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060 | ||
22 | index XXXXXXX..XXXXXXX 100755 | ||
23 | --- a/tests/qemu-iotests/060 | ||
24 | +++ b/tests/qemu-iotests/060 | ||
25 | @@ -XXX,XX +XXX,XX @@ _filter_io_error() | ||
26 | . ./common.rc | ||
27 | . ./common.filter | ||
28 | |||
29 | -# This tests qocw2-specific low-level functionality | ||
30 | +# This tests qcow2-specific low-level functionality | ||
31 | _supported_fmt qcow2 | ||
32 | _supported_proto file | ||
33 | _supported_os Linux | ||
34 | diff --git a/tests/qemu-iotests/061 b/tests/qemu-iotests/061 | ||
35 | index XXXXXXX..XXXXXXX 100755 | ||
36 | --- a/tests/qemu-iotests/061 | ||
37 | +++ b/tests/qemu-iotests/061 | ||
38 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
39 | . ./common.rc | ||
40 | . ./common.filter | ||
41 | |||
42 | -# This tests qocw2-specific low-level functionality | ||
43 | +# This tests qcow2-specific low-level functionality | ||
44 | _supported_fmt qcow2 | ||
45 | _supported_proto file | ||
46 | _supported_os Linux | ||
47 | diff --git a/tests/qemu-iotests/062 b/tests/qemu-iotests/062 | ||
48 | index XXXXXXX..XXXXXXX 100755 | ||
49 | --- a/tests/qemu-iotests/062 | ||
50 | +++ b/tests/qemu-iotests/062 | ||
51 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
52 | . ./common.rc | ||
53 | . ./common.filter | ||
54 | |||
55 | -# This tests qocw2-specific low-level functionality | ||
56 | +# This tests qcow2-specific low-level functionality | ||
57 | _supported_fmt qcow2 | ||
58 | _supported_proto generic | ||
59 | |||
60 | diff --git a/tests/qemu-iotests/066 b/tests/qemu-iotests/066 | ||
61 | index XXXXXXX..XXXXXXX 100755 | ||
62 | --- a/tests/qemu-iotests/066 | ||
63 | +++ b/tests/qemu-iotests/066 | ||
64 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
65 | . ./common.rc | ||
66 | . ./common.filter | ||
67 | |||
68 | -# This tests qocw2-specific low-level functionality | ||
69 | +# This tests qcow2-specific low-level functionality | ||
70 | _supported_fmt qcow2 | ||
71 | _supported_proto generic | ||
72 | |||
73 | diff --git a/tests/qemu-iotests/068 b/tests/qemu-iotests/068 | ||
74 | index XXXXXXX..XXXXXXX 100755 | ||
75 | --- a/tests/qemu-iotests/068 | ||
76 | +++ b/tests/qemu-iotests/068 | ||
77 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
78 | . ./common.rc | ||
79 | . ./common.filter | ||
80 | |||
81 | -# This tests qocw2-specific low-level functionality | ||
82 | +# This tests qcow2-specific low-level functionality | ||
83 | _supported_fmt qcow2 | ||
84 | _supported_proto generic | ||
85 | |||
86 | diff --git a/tests/qemu-iotests/108 b/tests/qemu-iotests/108 | ||
87 | index XXXXXXX..XXXXXXX 100755 | ||
88 | --- a/tests/qemu-iotests/108 | ||
89 | +++ b/tests/qemu-iotests/108 | ||
90 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
91 | . ./common.rc | ||
92 | . ./common.filter | ||
93 | |||
94 | -# This tests qocw2-specific low-level functionality | ||
95 | +# This tests qcow2-specific low-level functionality | ||
96 | _supported_fmt qcow2 | ||
97 | _supported_proto file | ||
98 | _supported_os Linux | ||
99 | diff --git a/tests/qemu-iotests/138 b/tests/qemu-iotests/138 | ||
100 | index XXXXXXX..XXXXXXX 100755 | ||
101 | --- a/tests/qemu-iotests/138 | ||
102 | +++ b/tests/qemu-iotests/138 | ||
103 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
104 | . ./common.rc | ||
105 | . ./common.filter | ||
106 | |||
107 | -# This tests qocw2-specific low-level functionality | ||
108 | +# This tests qcow2-specific low-level functionality | ||
109 | _supported_fmt qcow2 | ||
110 | _supported_proto file | ||
111 | _supported_os Linux | ||
112 | diff --git a/tests/qemu-iotests/261 b/tests/qemu-iotests/261 | ||
113 | index XXXXXXX..XXXXXXX 100755 | ||
114 | --- a/tests/qemu-iotests/261 | ||
115 | +++ b/tests/qemu-iotests/261 | ||
116 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
117 | . ./common.rc | ||
118 | . ./common.filter | ||
119 | |||
120 | -# This tests qocw2-specific low-level functionality | ||
121 | +# This tests qcow2-specific low-level functionality | ||
122 | _supported_fmt qcow2 | ||
123 | _supported_proto file | ||
124 | _supported_os Linux | ||
125 | -- | ||
126 | 2.24.1 | ||
127 | |||
128 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | This is useful for tests that want to whitelist fields from dump-header | ||
2 | (with grep) but still print all header extensions. | ||
3 | 1 | ||
4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
5 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
6 | Message-id: 20191107163708.833192-3-mreitz@redhat.com | ||
7 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
8 | --- | ||
9 | tests/qemu-iotests/qcow2.py | 5 +++++ | ||
10 | 1 file changed, 5 insertions(+) | ||
11 | |||
12 | diff --git a/tests/qemu-iotests/qcow2.py b/tests/qemu-iotests/qcow2.py | ||
13 | index XXXXXXX..XXXXXXX 100755 | ||
14 | --- a/tests/qemu-iotests/qcow2.py | ||
15 | +++ b/tests/qemu-iotests/qcow2.py | ||
16 | @@ -XXX,XX +XXX,XX @@ def cmd_dump_header(fd): | ||
17 | h.dump() | ||
18 | h.dump_extensions() | ||
19 | |||
20 | +def cmd_dump_header_exts(fd): | ||
21 | + h = QcowHeader(fd) | ||
22 | + h.dump_extensions() | ||
23 | + | ||
24 | def cmd_set_header(fd, name, value): | ||
25 | try: | ||
26 | value = int(value, 0) | ||
27 | @@ -XXX,XX +XXX,XX @@ def cmd_set_feature_bit(fd, group, bit): | ||
28 | |||
29 | cmds = [ | ||
30 | [ 'dump-header', cmd_dump_header, 0, 'Dump image header and header extensions' ], | ||
31 | + [ 'dump-header-exts', cmd_dump_header_exts, 0, 'Dump image header extensions' ], | ||
32 | [ 'set-header', cmd_set_header, 2, 'Set a field in the header'], | ||
33 | [ 'add-header-ext', cmd_add_header_ext, 2, 'Add a header extension' ], | ||
34 | [ 'add-header-ext-stdio', cmd_add_header_ext_stdio, 1, 'Add a header extension, data from stdin' ], | ||
35 | -- | ||
36 | 2.24.1 | ||
37 | |||
38 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Print the feature fields as a set of bits so that filtering is easier. | ||
2 | 1 | ||
3 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
4 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
5 | Message-id: 20191107163708.833192-4-mreitz@redhat.com | ||
6 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
7 | --- | ||
8 | tests/qemu-iotests/031.out | 36 +++++++++---------- | ||
9 | tests/qemu-iotests/036.out | 18 +++++----- | ||
10 | tests/qemu-iotests/039.out | 22 ++++++------ | ||
11 | tests/qemu-iotests/060.out | 20 +++++------ | ||
12 | tests/qemu-iotests/061.out | 72 ++++++++++++++++++------------------- | ||
13 | tests/qemu-iotests/137.out | 2 +- | ||
14 | tests/qemu-iotests/qcow2.py | 18 +++++++--- | ||
15 | 7 files changed, 99 insertions(+), 89 deletions(-) | ||
16 | |||
17 | diff --git a/tests/qemu-iotests/031.out b/tests/qemu-iotests/031.out | ||
18 | index XXXXXXX..XXXXXXX 100644 | ||
19 | --- a/tests/qemu-iotests/031.out | ||
20 | +++ b/tests/qemu-iotests/031.out | ||
21 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
22 | refcount_table_clusters 1 | ||
23 | nb_snapshots 0 | ||
24 | snapshot_offset 0x0 | ||
25 | -incompatible_features 0x0 | ||
26 | -compatible_features 0x0 | ||
27 | -autoclear_features 0x0 | ||
28 | +incompatible_features [] | ||
29 | +compatible_features [] | ||
30 | +autoclear_features [] | ||
31 | refcount_order 4 | ||
32 | header_length 72 | ||
33 | |||
34 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
35 | refcount_table_clusters 1 | ||
36 | nb_snapshots 0 | ||
37 | snapshot_offset 0x0 | ||
38 | -incompatible_features 0x0 | ||
39 | -compatible_features 0x0 | ||
40 | -autoclear_features 0x0 | ||
41 | +incompatible_features [] | ||
42 | +compatible_features [] | ||
43 | +autoclear_features [] | ||
44 | refcount_order 4 | ||
45 | header_length 72 | ||
46 | |||
47 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
48 | refcount_table_clusters 1 | ||
49 | nb_snapshots 0 | ||
50 | snapshot_offset 0x0 | ||
51 | -incompatible_features 0x0 | ||
52 | -compatible_features 0x0 | ||
53 | -autoclear_features 0x0 | ||
54 | +incompatible_features [] | ||
55 | +compatible_features [] | ||
56 | +autoclear_features [] | ||
57 | refcount_order 4 | ||
58 | header_length 72 | ||
59 | |||
60 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
61 | refcount_table_clusters 1 | ||
62 | nb_snapshots 0 | ||
63 | snapshot_offset 0x0 | ||
64 | -incompatible_features 0x0 | ||
65 | -compatible_features 0x0 | ||
66 | -autoclear_features 0x0 | ||
67 | +incompatible_features [] | ||
68 | +compatible_features [] | ||
69 | +autoclear_features [] | ||
70 | refcount_order 4 | ||
71 | header_length 104 | ||
72 | |||
73 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
74 | refcount_table_clusters 1 | ||
75 | nb_snapshots 0 | ||
76 | snapshot_offset 0x0 | ||
77 | -incompatible_features 0x0 | ||
78 | -compatible_features 0x0 | ||
79 | -autoclear_features 0x0 | ||
80 | +incompatible_features [] | ||
81 | +compatible_features [] | ||
82 | +autoclear_features [] | ||
83 | refcount_order 4 | ||
84 | header_length 104 | ||
85 | |||
86 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
87 | refcount_table_clusters 1 | ||
88 | nb_snapshots 0 | ||
89 | snapshot_offset 0x0 | ||
90 | -incompatible_features 0x0 | ||
91 | -compatible_features 0x0 | ||
92 | -autoclear_features 0x0 | ||
93 | +incompatible_features [] | ||
94 | +compatible_features [] | ||
95 | +autoclear_features [] | ||
96 | refcount_order 4 | ||
97 | header_length 104 | ||
98 | |||
99 | diff --git a/tests/qemu-iotests/036.out b/tests/qemu-iotests/036.out | ||
100 | index XXXXXXX..XXXXXXX 100644 | ||
101 | --- a/tests/qemu-iotests/036.out | ||
102 | +++ b/tests/qemu-iotests/036.out | ||
103 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
104 | refcount_table_clusters 1 | ||
105 | nb_snapshots 0 | ||
106 | snapshot_offset 0x0 | ||
107 | -incompatible_features 0x8000000000000000 | ||
108 | -compatible_features 0x0 | ||
109 | -autoclear_features 0x0 | ||
110 | +incompatible_features [63] | ||
111 | +compatible_features [] | ||
112 | +autoclear_features [] | ||
113 | refcount_order 4 | ||
114 | header_length 104 | ||
115 | |||
116 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
117 | refcount_table_clusters 1 | ||
118 | nb_snapshots 0 | ||
119 | snapshot_offset 0x0 | ||
120 | -incompatible_features 0x0 | ||
121 | -compatible_features 0x0 | ||
122 | -autoclear_features 0x8000000000000000 | ||
123 | +incompatible_features [] | ||
124 | +compatible_features [] | ||
125 | +autoclear_features [63] | ||
126 | refcount_order 4 | ||
127 | header_length 104 | ||
128 | |||
129 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
130 | refcount_table_clusters 1 | ||
131 | nb_snapshots 0 | ||
132 | snapshot_offset 0x0 | ||
133 | -incompatible_features 0x0 | ||
134 | -compatible_features 0x0 | ||
135 | -autoclear_features 0x0 | ||
136 | +incompatible_features [] | ||
137 | +compatible_features [] | ||
138 | +autoclear_features [] | ||
139 | refcount_order 4 | ||
140 | header_length 104 | ||
141 | |||
142 | diff --git a/tests/qemu-iotests/039.out b/tests/qemu-iotests/039.out | ||
143 | index XXXXXXX..XXXXXXX 100644 | ||
144 | --- a/tests/qemu-iotests/039.out | ||
145 | +++ b/tests/qemu-iotests/039.out | ||
146 | @@ -XXX,XX +XXX,XX @@ QA output created by 039 | ||
147 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 | ||
148 | wrote 512/512 bytes at offset 0 | ||
149 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
150 | -incompatible_features 0x0 | ||
151 | +incompatible_features [] | ||
152 | No errors were found on the image. | ||
153 | |||
154 | == Creating a dirty image file == | ||
155 | @@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 | ||
156 | wrote 512/512 bytes at offset 0 | ||
157 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
158 | ./common.rc: Killed ( VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@" ) | ||
159 | -incompatible_features 0x1 | ||
160 | +incompatible_features [0] | ||
161 | ERROR cluster 5 refcount=0 reference=1 | ||
162 | ERROR OFLAG_COPIED data cluster: l2_entry=8000000000050000 refcount=0 | ||
163 | |||
164 | @@ -XXX,XX +XXX,XX @@ Data may be corrupted, or further writes to the image may corrupt it. | ||
165 | == Read-only access must still work == | ||
166 | read 512/512 bytes at offset 0 | ||
167 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
168 | -incompatible_features 0x1 | ||
169 | +incompatible_features [0] | ||
170 | |||
171 | == Repairing the image file must succeed == | ||
172 | ERROR cluster 5 refcount=0 reference=1 | ||
173 | @@ -XXX,XX +XXX,XX @@ The following inconsistencies were found and repaired: | ||
174 | |||
175 | Double checking the fixed image now... | ||
176 | No errors were found on the image. | ||
177 | -incompatible_features 0x0 | ||
178 | +incompatible_features [] | ||
179 | |||
180 | == Data should still be accessible after repair == | ||
181 | read 512/512 bytes at offset 0 | ||
182 | @@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 | ||
183 | wrote 512/512 bytes at offset 0 | ||
184 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
185 | ./common.rc: Killed ( VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@" ) | ||
186 | -incompatible_features 0x1 | ||
187 | +incompatible_features [0] | ||
188 | ERROR cluster 5 refcount=0 reference=1 | ||
189 | Rebuilding refcount structure | ||
190 | Repairing cluster 1 refcount=1 reference=0 | ||
191 | Repairing cluster 2 refcount=1 reference=0 | ||
192 | wrote 512/512 bytes at offset 0 | ||
193 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
194 | -incompatible_features 0x0 | ||
195 | +incompatible_features [] | ||
196 | |||
197 | == Creating an image file with lazy_refcounts=off == | ||
198 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 | ||
199 | wrote 512/512 bytes at offset 0 | ||
200 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
201 | ./common.rc: Killed ( VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@" ) | ||
202 | -incompatible_features 0x0 | ||
203 | +incompatible_features [] | ||
204 | No errors were found on the image. | ||
205 | |||
206 | == Committing to a backing file with lazy_refcounts=on == | ||
207 | @@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/ | ||
208 | wrote 512/512 bytes at offset 0 | ||
209 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
210 | Image committed. | ||
211 | -incompatible_features 0x0 | ||
212 | -incompatible_features 0x0 | ||
213 | +incompatible_features [] | ||
214 | +incompatible_features [] | ||
215 | No errors were found on the image. | ||
216 | No errors were found on the image. | ||
217 | |||
218 | @@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 | ||
219 | wrote 512/512 bytes at offset 0 | ||
220 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
221 | ./common.rc: Killed ( VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@" ) | ||
222 | -incompatible_features 0x1 | ||
223 | +incompatible_features [0] | ||
224 | ERROR cluster 5 refcount=0 reference=1 | ||
225 | ERROR OFLAG_COPIED data cluster: l2_entry=8000000000050000 refcount=0 | ||
226 | |||
227 | @@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 | ||
228 | wrote 512/512 bytes at offset 0 | ||
229 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
230 | ./common.rc: Killed ( VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@" ) | ||
231 | -incompatible_features 0x0 | ||
232 | +incompatible_features [] | ||
233 | No errors were found on the image. | ||
234 | *** done | ||
235 | diff --git a/tests/qemu-iotests/060.out b/tests/qemu-iotests/060.out | ||
236 | index XXXXXXX..XXXXXXX 100644 | ||
237 | --- a/tests/qemu-iotests/060.out | ||
238 | +++ b/tests/qemu-iotests/060.out | ||
239 | @@ -XXX,XX +XXX,XX @@ ERROR cluster 3 refcount=1 reference=3 | ||
240 | |||
241 | 1 errors were found on the image. | ||
242 | Data may be corrupted, or further writes to the image may corrupt it. | ||
243 | -incompatible_features 0x0 | ||
244 | +incompatible_features [] | ||
245 | qcow2: Marking image as corrupt: Preventing invalid write on metadata (overlaps with active L1 table); further corruption events will be suppressed | ||
246 | write failed: Input/output error | ||
247 | -incompatible_features 0x2 | ||
248 | +incompatible_features [1] | ||
249 | image: TEST_DIR/t.IMGFMT | ||
250 | file format: IMGFMT | ||
251 | virtual size: 64 MiB (67108864 bytes) | ||
252 | @@ -XXX,XX +XXX,XX @@ ERROR cluster 2 refcount=1 reference=2 | ||
253 | |||
254 | 2 errors were found on the image. | ||
255 | Data may be corrupted, or further writes to the image may corrupt it. | ||
256 | -incompatible_features 0x0 | ||
257 | +incompatible_features [] | ||
258 | qcow2: Marking image as corrupt: Preventing invalid write on metadata (overlaps with refcount block); further corruption events will be suppressed | ||
259 | write failed: Input/output error | ||
260 | -incompatible_features 0x2 | ||
261 | +incompatible_features [1] | ||
262 | ERROR refcount block 0 refcount=2 | ||
263 | ERROR cluster 2 refcount=1 reference=2 | ||
264 | Rebuilding refcount structure | ||
265 | @@ -XXX,XX +XXX,XX @@ The following inconsistencies were found and repaired: | ||
266 | |||
267 | Double checking the fixed image now... | ||
268 | No errors were found on the image. | ||
269 | -incompatible_features 0x0 | ||
270 | +incompatible_features [] | ||
271 | wrote 512/512 bytes at offset 0 | ||
272 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
273 | -incompatible_features 0x0 | ||
274 | +incompatible_features [] | ||
275 | |||
276 | === Testing cluster data reference into inactive L2 table === | ||
277 | |||
278 | @@ -XXX,XX +XXX,XX @@ Data may be corrupted, or further writes to the image may corrupt it. | ||
279 | |||
280 | 1 leaked clusters were found on the image. | ||
281 | This means waste of disk space, but no harm to data. | ||
282 | -incompatible_features 0x0 | ||
283 | +incompatible_features [] | ||
284 | qcow2: Marking image as corrupt: Preventing invalid write on metadata (overlaps with inactive L2 table); further corruption events will be suppressed | ||
285 | write failed: Input/output error | ||
286 | -incompatible_features 0x2 | ||
287 | +incompatible_features [1] | ||
288 | ERROR cluster 4 refcount=1 reference=2 | ||
289 | Leaked cluster 9 refcount=1 reference=0 | ||
290 | Repairing cluster 4 refcount=1 reference=2 | ||
291 | @@ -XXX,XX +XXX,XX @@ The following inconsistencies were found and repaired: | ||
292 | |||
293 | Double checking the fixed image now... | ||
294 | No errors were found on the image. | ||
295 | -incompatible_features 0x0 | ||
296 | +incompatible_features [] | ||
297 | wrote 512/512 bytes at offset 0 | ||
298 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
299 | -incompatible_features 0x0 | ||
300 | +incompatible_features [] | ||
301 | read 512/512 bytes at offset 0 | ||
302 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
303 | No errors were found on the image. | ||
304 | diff --git a/tests/qemu-iotests/061.out b/tests/qemu-iotests/061.out | ||
305 | index XXXXXXX..XXXXXXX 100644 | ||
306 | --- a/tests/qemu-iotests/061.out | ||
307 | +++ b/tests/qemu-iotests/061.out | ||
308 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
309 | refcount_table_clusters 1 | ||
310 | nb_snapshots 0 | ||
311 | snapshot_offset 0x0 | ||
312 | -incompatible_features 0x0 | ||
313 | -compatible_features 0x1 | ||
314 | -autoclear_features 0x0 | ||
315 | +incompatible_features [] | ||
316 | +compatible_features [0] | ||
317 | +autoclear_features [] | ||
318 | refcount_order 4 | ||
319 | header_length 104 | ||
320 | |||
321 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
322 | refcount_table_clusters 1 | ||
323 | nb_snapshots 0 | ||
324 | snapshot_offset 0x0 | ||
325 | -incompatible_features 0x0 | ||
326 | -compatible_features 0x0 | ||
327 | -autoclear_features 0x0 | ||
328 | +incompatible_features [] | ||
329 | +compatible_features [] | ||
330 | +autoclear_features [] | ||
331 | refcount_order 4 | ||
332 | header_length 72 | ||
333 | |||
334 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
335 | refcount_table_clusters 1 | ||
336 | nb_snapshots 0 | ||
337 | snapshot_offset 0x0 | ||
338 | -incompatible_features 0x0 | ||
339 | -compatible_features 0x1 | ||
340 | -autoclear_features 0x0 | ||
341 | +incompatible_features [] | ||
342 | +compatible_features [0] | ||
343 | +autoclear_features [] | ||
344 | refcount_order 4 | ||
345 | header_length 104 | ||
346 | |||
347 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
348 | refcount_table_clusters 1 | ||
349 | nb_snapshots 0 | ||
350 | snapshot_offset 0x0 | ||
351 | -incompatible_features 0x0 | ||
352 | -compatible_features 0x0 | ||
353 | -autoclear_features 0x0 | ||
354 | +incompatible_features [] | ||
355 | +compatible_features [] | ||
356 | +autoclear_features [] | ||
357 | refcount_order 4 | ||
358 | header_length 72 | ||
359 | |||
360 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
361 | refcount_table_clusters 1 | ||
362 | nb_snapshots 0 | ||
363 | snapshot_offset 0x0 | ||
364 | -incompatible_features 0x1 | ||
365 | -compatible_features 0x1 | ||
366 | -autoclear_features 0x0 | ||
367 | +incompatible_features [0] | ||
368 | +compatible_features [0] | ||
369 | +autoclear_features [] | ||
370 | refcount_order 4 | ||
371 | header_length 104 | ||
372 | |||
373 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x80000 | ||
374 | refcount_table_clusters 1 | ||
375 | nb_snapshots 0 | ||
376 | snapshot_offset 0x0 | ||
377 | -incompatible_features 0x0 | ||
378 | -compatible_features 0x0 | ||
379 | -autoclear_features 0x0 | ||
380 | +incompatible_features [] | ||
381 | +compatible_features [] | ||
382 | +autoclear_features [] | ||
383 | refcount_order 4 | ||
384 | header_length 72 | ||
385 | |||
386 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
387 | refcount_table_clusters 1 | ||
388 | nb_snapshots 0 | ||
389 | snapshot_offset 0x0 | ||
390 | -incompatible_features 0x0 | ||
391 | -compatible_features 0x40000000000 | ||
392 | -autoclear_features 0x40000000000 | ||
393 | +incompatible_features [] | ||
394 | +compatible_features [42] | ||
395 | +autoclear_features [42] | ||
396 | refcount_order 4 | ||
397 | header_length 104 | ||
398 | |||
399 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
400 | refcount_table_clusters 1 | ||
401 | nb_snapshots 0 | ||
402 | snapshot_offset 0x0 | ||
403 | -incompatible_features 0x0 | ||
404 | -compatible_features 0x0 | ||
405 | -autoclear_features 0x0 | ||
406 | +incompatible_features [] | ||
407 | +compatible_features [] | ||
408 | +autoclear_features [] | ||
409 | refcount_order 4 | ||
410 | header_length 72 | ||
411 | |||
412 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
413 | refcount_table_clusters 1 | ||
414 | nb_snapshots 0 | ||
415 | snapshot_offset 0x0 | ||
416 | -incompatible_features 0x0 | ||
417 | -compatible_features 0x0 | ||
418 | -autoclear_features 0x0 | ||
419 | +incompatible_features [] | ||
420 | +compatible_features [] | ||
421 | +autoclear_features [] | ||
422 | refcount_order 4 | ||
423 | header_length 72 | ||
424 | |||
425 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
426 | refcount_table_clusters 1 | ||
427 | nb_snapshots 0 | ||
428 | snapshot_offset 0x0 | ||
429 | -incompatible_features 0x0 | ||
430 | -compatible_features 0x1 | ||
431 | -autoclear_features 0x0 | ||
432 | +incompatible_features [] | ||
433 | +compatible_features [0] | ||
434 | +autoclear_features [] | ||
435 | refcount_order 4 | ||
436 | header_length 104 | ||
437 | |||
438 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x10000 | ||
439 | refcount_table_clusters 1 | ||
440 | nb_snapshots 0 | ||
441 | snapshot_offset 0x0 | ||
442 | -incompatible_features 0x1 | ||
443 | -compatible_features 0x1 | ||
444 | -autoclear_features 0x0 | ||
445 | +incompatible_features [0] | ||
446 | +compatible_features [0] | ||
447 | +autoclear_features [] | ||
448 | refcount_order 4 | ||
449 | header_length 104 | ||
450 | |||
451 | @@ -XXX,XX +XXX,XX @@ refcount_table_offset 0x80000 | ||
452 | refcount_table_clusters 1 | ||
453 | nb_snapshots 0 | ||
454 | snapshot_offset 0x0 | ||
455 | -incompatible_features 0x0 | ||
456 | -compatible_features 0x0 | ||
457 | -autoclear_features 0x0 | ||
458 | +incompatible_features [] | ||
459 | +compatible_features [] | ||
460 | +autoclear_features [] | ||
461 | refcount_order 4 | ||
462 | header_length 104 | ||
463 | |||
464 | diff --git a/tests/qemu-iotests/137.out b/tests/qemu-iotests/137.out | ||
465 | index XXXXXXX..XXXXXXX 100644 | ||
466 | --- a/tests/qemu-iotests/137.out | ||
467 | +++ b/tests/qemu-iotests/137.out | ||
468 | @@ -XXX,XX +XXX,XX @@ qemu-io: Unsupported value 'blubb' for qcow2 option 'overlap-check'. Allowed are | ||
469 | wrote 512/512 bytes at offset 0 | ||
470 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
471 | ./common.rc: Killed ( VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@" ) | ||
472 | -incompatible_features 0x0 | ||
473 | +incompatible_features [] | ||
474 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 | ||
475 | wrote 65536/65536 bytes at offset 0 | ||
476 | 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
477 | diff --git a/tests/qemu-iotests/qcow2.py b/tests/qemu-iotests/qcow2.py | ||
478 | index XXXXXXX..XXXXXXX 100755 | ||
479 | --- a/tests/qemu-iotests/qcow2.py | ||
480 | +++ b/tests/qemu-iotests/qcow2.py | ||
481 | @@ -XXX,XX +XXX,XX @@ class QcowHeader: | ||
482 | [ uint64_t, '%#x', 'snapshot_offset' ], | ||
483 | |||
484 | # Version 3 header fields | ||
485 | - [ uint64_t, '%#x', 'incompatible_features' ], | ||
486 | - [ uint64_t, '%#x', 'compatible_features' ], | ||
487 | - [ uint64_t, '%#x', 'autoclear_features' ], | ||
488 | + [ uint64_t, 'mask', 'incompatible_features' ], | ||
489 | + [ uint64_t, 'mask', 'compatible_features' ], | ||
490 | + [ uint64_t, 'mask', 'autoclear_features' ], | ||
491 | [ uint32_t, '%d', 'refcount_order' ], | ||
492 | [ uint32_t, '%d', 'header_length' ], | ||
493 | ]; | ||
494 | @@ -XXX,XX +XXX,XX @@ class QcowHeader: | ||
495 | |||
496 | def dump(self): | ||
497 | for f in QcowHeader.fields: | ||
498 | - print("%-25s" % f[2], f[1] % self.__dict__[f[2]]) | ||
499 | + value = self.__dict__[f[2]] | ||
500 | + if f[1] == 'mask': | ||
501 | + bits = [] | ||
502 | + for bit in range(64): | ||
503 | + if value & (1 << bit): | ||
504 | + bits.append(bit) | ||
505 | + value_str = str(bits) | ||
506 | + else: | ||
507 | + value_str = f[1] % value | ||
508 | + | ||
509 | + print("%-25s" % f[2], value_str) | ||
510 | print("") | ||
511 | |||
512 | def dump_extensions(self): | ||
513 | -- | ||
514 | 2.24.1 | ||
515 | |||
516 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
2 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
3 | Message-id: 20191107163708.833192-5-mreitz@redhat.com | ||
4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
5 | --- | ||
6 | tests/qemu-iotests/common.filter | 24 ++++++++++++++++++++++++ | ||
7 | 1 file changed, 24 insertions(+) | ||
8 | 1 | ||
9 | diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter | ||
10 | index XXXXXXX..XXXXXXX 100644 | ||
11 | --- a/tests/qemu-iotests/common.filter | ||
12 | +++ b/tests/qemu-iotests/common.filter | ||
13 | @@ -XXX,XX +XXX,XX @@ _filter_qmp_empty_return() | ||
14 | grep -v '{"return": {}}' | ||
15 | } | ||
16 | |||
17 | +_filter_json_filename() | ||
18 | +{ | ||
19 | + $PYTHON -c 'import sys | ||
20 | +result, *fnames = sys.stdin.read().split("json:{") | ||
21 | +depth = 0 | ||
22 | +for fname in fnames: | ||
23 | + depth += 1 # For the opening brace in the split separator | ||
24 | + for chr_i, chr in enumerate(fname): | ||
25 | + if chr == "{": | ||
26 | + depth += 1 | ||
27 | + elif chr == "}": | ||
28 | + depth -= 1 | ||
29 | + if depth == 0: | ||
30 | + break | ||
31 | + | ||
32 | + # json:{} filenames may be nested; filter out everything from | ||
33 | + # inside the outermost one | ||
34 | + if depth == 0: | ||
35 | + chr_i += 1 # First character past the filename | ||
36 | + result += "json:{ /* filtered */ }" + fname[chr_i:] | ||
37 | + | ||
38 | +sys.stdout.write(result)' | ||
39 | +} | ||
40 | + | ||
41 | # make sure this script returns success | ||
42 | true | ||
43 | -- | ||
44 | 2.24.1 | ||
45 | |||
46 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | This test can run just fine with other values for refcount_bits, so we | ||
2 | should filter the value from qcow2.py's dump-header. In fact, we can | ||
3 | filter everything but the feature bits and header extensions, because | ||
4 | that is what the test is about. | ||
5 | 1 | ||
6 | (036 currently ignores user-specified image options, but that will be | ||
7 | fixed in the next patch.) | ||
8 | |||
9 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
10 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
11 | Message-id: 20191107163708.833192-6-mreitz@redhat.com | ||
12 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
13 | --- | ||
14 | tests/qemu-iotests/036 | 9 ++++--- | ||
15 | tests/qemu-iotests/036.out | 48 -------------------------------------- | ||
16 | 2 files changed, 6 insertions(+), 51 deletions(-) | ||
17 | |||
18 | diff --git a/tests/qemu-iotests/036 b/tests/qemu-iotests/036 | ||
19 | index XXXXXXX..XXXXXXX 100755 | ||
20 | --- a/tests/qemu-iotests/036 | ||
21 | +++ b/tests/qemu-iotests/036 | ||
22 | @@ -XXX,XX +XXX,XX @@ $PYTHON qcow2.py "$TEST_IMG" set-feature-bit incompatible 63 | ||
23 | |||
24 | # Without feature table | ||
25 | $PYTHON qcow2.py "$TEST_IMG" del-header-ext 0x6803f857 | ||
26 | -$PYTHON qcow2.py "$TEST_IMG" dump-header | ||
27 | +$PYTHON qcow2.py "$TEST_IMG" dump-header | grep features | ||
28 | +$PYTHON qcow2.py "$TEST_IMG" dump-header-exts | ||
29 | _img_info | ||
30 | |||
31 | # With feature table containing bit 63 | ||
32 | @@ -XXX,XX +XXX,XX @@ echo === Create image with unknown autoclear feature bit === | ||
33 | echo | ||
34 | _make_test_img 64M | ||
35 | $PYTHON qcow2.py "$TEST_IMG" set-feature-bit autoclear 63 | ||
36 | -$PYTHON qcow2.py "$TEST_IMG" dump-header | ||
37 | +$PYTHON qcow2.py "$TEST_IMG" dump-header | grep features | ||
38 | +$PYTHON qcow2.py "$TEST_IMG" dump-header-exts | ||
39 | |||
40 | echo | ||
41 | echo === Repair image === | ||
42 | echo | ||
43 | _check_test_img -r all | ||
44 | |||
45 | -$PYTHON qcow2.py "$TEST_IMG" dump-header | ||
46 | +$PYTHON qcow2.py "$TEST_IMG" dump-header | grep features | ||
47 | +$PYTHON qcow2.py "$TEST_IMG" dump-header-exts | ||
48 | |||
49 | # success, all done | ||
50 | echo "*** done" | ||
51 | diff --git a/tests/qemu-iotests/036.out b/tests/qemu-iotests/036.out | ||
52 | index XXXXXXX..XXXXXXX 100644 | ||
53 | --- a/tests/qemu-iotests/036.out | ||
54 | +++ b/tests/qemu-iotests/036.out | ||
55 | @@ -XXX,XX +XXX,XX @@ QA output created by 036 | ||
56 | === Image with unknown incompatible feature bit === | ||
57 | |||
58 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 | ||
59 | -magic 0x514649fb | ||
60 | -version 3 | ||
61 | -backing_file_offset 0x0 | ||
62 | -backing_file_size 0x0 | ||
63 | -cluster_bits 16 | ||
64 | -size 67108864 | ||
65 | -crypt_method 0 | ||
66 | -l1_size 1 | ||
67 | -l1_table_offset 0x30000 | ||
68 | -refcount_table_offset 0x10000 | ||
69 | -refcount_table_clusters 1 | ||
70 | -nb_snapshots 0 | ||
71 | -snapshot_offset 0x0 | ||
72 | incompatible_features [63] | ||
73 | compatible_features [] | ||
74 | autoclear_features [] | ||
75 | -refcount_order 4 | ||
76 | -header_length 104 | ||
77 | - | ||
78 | qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Unsupported IMGFMT feature(s): Unknown incompatible feature: 8000000000000000 | ||
79 | qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Unsupported IMGFMT feature(s): Test feature | ||
80 | |||
81 | @@ -XXX,XX +XXX,XX @@ qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Unsupported IMGFMT feature(s): tes | ||
82 | === Create image with unknown autoclear feature bit === | ||
83 | |||
84 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 | ||
85 | -magic 0x514649fb | ||
86 | -version 3 | ||
87 | -backing_file_offset 0x0 | ||
88 | -backing_file_size 0x0 | ||
89 | -cluster_bits 16 | ||
90 | -size 67108864 | ||
91 | -crypt_method 0 | ||
92 | -l1_size 1 | ||
93 | -l1_table_offset 0x30000 | ||
94 | -refcount_table_offset 0x10000 | ||
95 | -refcount_table_clusters 1 | ||
96 | -nb_snapshots 0 | ||
97 | -snapshot_offset 0x0 | ||
98 | incompatible_features [] | ||
99 | compatible_features [] | ||
100 | autoclear_features [63] | ||
101 | -refcount_order 4 | ||
102 | -header_length 104 | ||
103 | - | ||
104 | Header extension: | ||
105 | magic 0x6803f857 | ||
106 | length 192 | ||
107 | @@ -XXX,XX +XXX,XX @@ data <binary> | ||
108 | === Repair image === | ||
109 | |||
110 | No errors were found on the image. | ||
111 | -magic 0x514649fb | ||
112 | -version 3 | ||
113 | -backing_file_offset 0x0 | ||
114 | -backing_file_size 0x0 | ||
115 | -cluster_bits 16 | ||
116 | -size 67108864 | ||
117 | -crypt_method 0 | ||
118 | -l1_size 1 | ||
119 | -l1_table_offset 0x30000 | ||
120 | -refcount_table_offset 0x10000 | ||
121 | -refcount_table_clusters 1 | ||
122 | -nb_snapshots 0 | ||
123 | -snapshot_offset 0x0 | ||
124 | incompatible_features [] | ||
125 | compatible_features [] | ||
126 | autoclear_features [] | ||
127 | -refcount_order 4 | ||
128 | -header_length 104 | ||
129 | - | ||
130 | Header extension: | ||
131 | magic 0x6803f857 | ||
132 | length 192 | ||
133 | -- | ||
134 | 2.24.1 | ||
135 | |||
136 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Some tests require compat=1.1 and thus set IMGOPTS='compat=1.1' | ||
2 | globally. That is not how it should be done; instead, they should | ||
3 | simply set _unsupported_imgopts to compat=0.10 (compat=1.1 is the | ||
4 | default anyway). | ||
5 | 1 | ||
6 | This makes the tests heed user-specified $IMGOPTS. Some do not work | ||
7 | with all image options, though, so we need to disable them accordingly. | ||
8 | |||
9 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
10 | Reviewed-by: Maxim Levitsky <mlevitsky@redhat.com> | ||
11 | Message-id: 20191107163708.833192-7-mreitz@redhat.com | ||
12 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
13 | --- | ||
14 | tests/qemu-iotests/036 | 3 +-- | ||
15 | tests/qemu-iotests/060 | 4 ++-- | ||
16 | tests/qemu-iotests/062 | 3 ++- | ||
17 | tests/qemu-iotests/066 | 3 ++- | ||
18 | tests/qemu-iotests/068 | 3 ++- | ||
19 | tests/qemu-iotests/098 | 4 ++-- | ||
20 | 6 files changed, 11 insertions(+), 9 deletions(-) | ||
21 | |||
22 | diff --git a/tests/qemu-iotests/036 b/tests/qemu-iotests/036 | ||
23 | index XXXXXXX..XXXXXXX 100755 | ||
24 | --- a/tests/qemu-iotests/036 | ||
25 | +++ b/tests/qemu-iotests/036 | ||
26 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
27 | # This tests qcow2-specific low-level functionality | ||
28 | _supported_fmt qcow2 | ||
29 | _supported_proto file | ||
30 | - | ||
31 | # Only qcow2v3 and later supports feature bits | ||
32 | -IMGOPTS="compat=1.1" | ||
33 | +_unsupported_imgopts 'compat=0.10' | ||
34 | |||
35 | echo | ||
36 | echo === Image with unknown incompatible feature bit === | ||
37 | diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060 | ||
38 | index XXXXXXX..XXXXXXX 100755 | ||
39 | --- a/tests/qemu-iotests/060 | ||
40 | +++ b/tests/qemu-iotests/060 | ||
41 | @@ -XXX,XX +XXX,XX @@ _filter_io_error() | ||
42 | _supported_fmt qcow2 | ||
43 | _supported_proto file | ||
44 | _supported_os Linux | ||
45 | +# These tests only work for compat=1.1 images with refcount_bits=16 | ||
46 | +_unsupported_imgopts 'compat=0.10' 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
47 | |||
48 | # The repair process will create a large file - so check for availability first | ||
49 | _require_large_file 64G | ||
50 | @@ -XXX,XX +XXX,XX @@ l1_offset=196608 # 0x30000 (XXX: just an assumption) | ||
51 | l2_offset=262144 # 0x40000 (XXX: just an assumption) | ||
52 | l2_offset_after_snapshot=524288 # 0x80000 (XXX: just an assumption) | ||
53 | |||
54 | -IMGOPTS="compat=1.1" | ||
55 | - | ||
56 | OPEN_RW="open -o overlap-check=all $TEST_IMG" | ||
57 | # Overlap checks are done before write operations only, therefore opening an | ||
58 | # image read-only makes the overlap-check option irrelevant | ||
59 | diff --git a/tests/qemu-iotests/062 b/tests/qemu-iotests/062 | ||
60 | index XXXXXXX..XXXXXXX 100755 | ||
61 | --- a/tests/qemu-iotests/062 | ||
62 | +++ b/tests/qemu-iotests/062 | ||
63 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
64 | # This tests qcow2-specific low-level functionality | ||
65 | _supported_fmt qcow2 | ||
66 | _supported_proto generic | ||
67 | +# We need zero clusters and snapshots | ||
68 | +_unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' | ||
69 | |||
70 | -IMGOPTS="compat=1.1" | ||
71 | IMG_SIZE=64M | ||
72 | |||
73 | echo | ||
74 | diff --git a/tests/qemu-iotests/066 b/tests/qemu-iotests/066 | ||
75 | index XXXXXXX..XXXXXXX 100755 | ||
76 | --- a/tests/qemu-iotests/066 | ||
77 | +++ b/tests/qemu-iotests/066 | ||
78 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
79 | # This tests qcow2-specific low-level functionality | ||
80 | _supported_fmt qcow2 | ||
81 | _supported_proto generic | ||
82 | +# We need zero clusters and snapshots | ||
83 | +_unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' | ||
84 | |||
85 | # Intentionally create an unaligned image | ||
86 | -IMGOPTS="compat=1.1" | ||
87 | IMG_SIZE=$((64 * 1024 * 1024 + 512)) | ||
88 | |||
89 | echo | ||
90 | diff --git a/tests/qemu-iotests/068 b/tests/qemu-iotests/068 | ||
91 | index XXXXXXX..XXXXXXX 100755 | ||
92 | --- a/tests/qemu-iotests/068 | ||
93 | +++ b/tests/qemu-iotests/068 | ||
94 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
95 | # This tests qcow2-specific low-level functionality | ||
96 | _supported_fmt qcow2 | ||
97 | _supported_proto generic | ||
98 | +# Internal snapshots are (currently) impossible with refcount_bits=1 | ||
99 | +_unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' | ||
100 | |||
101 | -IMGOPTS="compat=1.1" | ||
102 | IMG_SIZE=128K | ||
103 | |||
104 | case "$QEMU_DEFAULT_MACHINE" in | ||
105 | diff --git a/tests/qemu-iotests/098 b/tests/qemu-iotests/098 | ||
106 | index XXXXXXX..XXXXXXX 100755 | ||
107 | --- a/tests/qemu-iotests/098 | ||
108 | +++ b/tests/qemu-iotests/098 | ||
109 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
110 | |||
111 | _supported_fmt qcow2 | ||
112 | _supported_proto file | ||
113 | - | ||
114 | -IMGOPTS="compat=1.1" | ||
115 | +# The code path we want to test here only works for compat=1.1 images | ||
116 | +_unsupported_imgopts 'compat=0.10' | ||
117 | |||
118 | for event in l1_update empty_image_prepare reftable_update refblock_alloc; do | ||
119 | |||
120 | -- | ||
121 | 2.24.1 | ||
122 | |||
123 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | IMGOPTS can never be empty for qcow2, because the check scripts adds | ||
2 | compat=1.1 unless the user specified any compat option themselves. | ||
3 | Thus, this block does not do anything and can be dropped. | ||
4 | 1 | ||
5 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
6 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
7 | Message-id: 20191107163708.833192-8-mreitz@redhat.com | ||
8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
9 | --- | ||
10 | tests/qemu-iotests/050 | 4 ---- | ||
11 | 1 file changed, 4 deletions(-) | ||
12 | |||
13 | diff --git a/tests/qemu-iotests/050 b/tests/qemu-iotests/050 | ||
14 | index XXXXXXX..XXXXXXX 100755 | ||
15 | --- a/tests/qemu-iotests/050 | ||
16 | +++ b/tests/qemu-iotests/050 | ||
17 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
18 | _supported_fmt qcow2 qed | ||
19 | _supported_proto file | ||
20 | |||
21 | -if test "$IMGFMT" = qcow2 && test $IMGOPTS = ""; then | ||
22 | - IMGOPTS=compat=1.1 | ||
23 | -fi | ||
24 | - | ||
25 | echo | ||
26 | echo "== Creating images ==" | ||
27 | |||
28 | -- | ||
29 | 2.24.1 | ||
30 | |||
31 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | This will allow us to add more options than just -b. | ||
2 | 1 | ||
3 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
4 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
5 | Message-id: 20191107163708.833192-9-mreitz@redhat.com | ||
6 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
7 | --- | ||
8 | tests/qemu-iotests/common.rc | 28 ++++++++++++++++++++-------- | ||
9 | 1 file changed, 20 insertions(+), 8 deletions(-) | ||
10 | |||
11 | diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc | ||
12 | index XXXXXXX..XXXXXXX 100644 | ||
13 | --- a/tests/qemu-iotests/common.rc | ||
14 | +++ b/tests/qemu-iotests/common.rc | ||
15 | @@ -XXX,XX +XXX,XX @@ _make_test_img() | ||
16 | # extra qemu-img options can be added by tests | ||
17 | # at least one argument (the image size) needs to be added | ||
18 | local extra_img_options="" | ||
19 | - local image_size=$* | ||
20 | local optstr="" | ||
21 | local img_name="" | ||
22 | local use_backing=0 | ||
23 | local backing_file="" | ||
24 | local object_options="" | ||
25 | + local misc_params=() | ||
26 | |||
27 | if [ -n "$TEST_IMG_FILE" ]; then | ||
28 | img_name=$TEST_IMG_FILE | ||
29 | @@ -XXX,XX +XXX,XX @@ _make_test_img() | ||
30 | optstr=$(_optstr_add "$optstr" "key-secret=keysec0") | ||
31 | fi | ||
32 | |||
33 | - if [ "$1" = "-b" ]; then | ||
34 | - use_backing=1 | ||
35 | - backing_file=$2 | ||
36 | - image_size=$3 | ||
37 | - fi | ||
38 | + for param; do | ||
39 | + if [ "$use_backing" = "1" -a -z "$backing_file" ]; then | ||
40 | + backing_file=$param | ||
41 | + continue | ||
42 | + fi | ||
43 | + | ||
44 | + case "$param" in | ||
45 | + -b) | ||
46 | + use_backing=1 | ||
47 | + ;; | ||
48 | + | ||
49 | + *) | ||
50 | + misc_params=("${misc_params[@]}" "$param") | ||
51 | + ;; | ||
52 | + esac | ||
53 | + done | ||
54 | + | ||
55 | if [ \( "$IMGFMT" = "qcow2" -o "$IMGFMT" = "qed" \) -a -n "$CLUSTER_SIZE" ]; then | ||
56 | optstr=$(_optstr_add "$optstr" "cluster_size=$CLUSTER_SIZE") | ||
57 | fi | ||
58 | @@ -XXX,XX +XXX,XX @@ _make_test_img() | ||
59 | # XXX(hch): have global image options? | ||
60 | ( | ||
61 | if [ $use_backing = 1 ]; then | ||
62 | - $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" $image_size 2>&1 | ||
63 | + $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" "${misc_params[@]}" 2>&1 | ||
64 | else | ||
65 | - $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options "$img_name" $image_size 2>&1 | ||
66 | + $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options "$img_name" "${misc_params[@]}" 2>&1 | ||
67 | fi | ||
68 | ) | _filter_img_create | ||
69 | |||
70 | -- | ||
71 | 2.24.1 | ||
72 | |||
73 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Blindly overriding IMGOPTS is suboptimal as this discards user-specified | ||
2 | options. Whatever options the test needs should simply be appended. | ||
3 | 1 | ||
4 | Some tests do this (with IMGOPTS=$(_optstr_add "$IMGOPTS" "...")), but | ||
5 | that is cumbersome. It’s simpler to just give _make_test_img an -o | ||
6 | parameter with which tests can add options. | ||
7 | |||
8 | Some tests actually must override the user-specified options, though, | ||
9 | for example when creating an image in a different format than the test | ||
10 | $IMGFMT. For such cases, --no-opts allows clearing the current option | ||
11 | list. | ||
12 | |||
13 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
14 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
15 | Message-id: 20191107163708.833192-10-mreitz@redhat.com | ||
16 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
17 | --- | ||
18 | tests/qemu-iotests/common.rc | 13 +++++++++++++ | ||
19 | 1 file changed, 13 insertions(+) | ||
20 | |||
21 | diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc | ||
22 | index XXXXXXX..XXXXXXX 100644 | ||
23 | --- a/tests/qemu-iotests/common.rc | ||
24 | +++ b/tests/qemu-iotests/common.rc | ||
25 | @@ -XXX,XX +XXX,XX @@ _make_test_img() | ||
26 | local use_backing=0 | ||
27 | local backing_file="" | ||
28 | local object_options="" | ||
29 | + local opts_param=false | ||
30 | local misc_params=() | ||
31 | |||
32 | if [ -n "$TEST_IMG_FILE" ]; then | ||
33 | @@ -XXX,XX +XXX,XX @@ _make_test_img() | ||
34 | if [ "$use_backing" = "1" -a -z "$backing_file" ]; then | ||
35 | backing_file=$param | ||
36 | continue | ||
37 | + elif $opts_param; then | ||
38 | + optstr=$(_optstr_add "$optstr" "$param") | ||
39 | + opts_param=false | ||
40 | + continue | ||
41 | fi | ||
42 | |||
43 | case "$param" in | ||
44 | @@ -XXX,XX +XXX,XX @@ _make_test_img() | ||
45 | use_backing=1 | ||
46 | ;; | ||
47 | |||
48 | + -o) | ||
49 | + opts_param=true | ||
50 | + ;; | ||
51 | + | ||
52 | + --no-opts) | ||
53 | + optstr="" | ||
54 | + ;; | ||
55 | + | ||
56 | *) | ||
57 | misc_params=("${misc_params[@]}" "$param") | ||
58 | ;; | ||
59 | -- | ||
60 | 2.24.1 | ||
61 | |||
62 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | It did not matter before, but now that _make_test_img understands -o, we | ||
2 | should use it properly here. | ||
3 | 1 | ||
4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
5 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
6 | Message-id: 20191107163708.833192-11-mreitz@redhat.com | ||
7 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
8 | --- | ||
9 | tests/qemu-iotests/051 | 2 +- | ||
10 | 1 file changed, 1 insertion(+), 1 deletion(-) | ||
11 | |||
12 | diff --git a/tests/qemu-iotests/051 b/tests/qemu-iotests/051 | ||
13 | index XXXXXXX..XXXXXXX 100755 | ||
14 | --- a/tests/qemu-iotests/051 | ||
15 | +++ b/tests/qemu-iotests/051 | ||
16 | @@ -XXX,XX +XXX,XX @@ echo | ||
17 | echo === With version 2 images enabling lazy refcounts must fail === | ||
18 | echo | ||
19 | |||
20 | -_make_test_img -ocompat=0.10 $size | ||
21 | +_make_test_img -o compat=0.10 $size | ||
22 | |||
23 | run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=on | ||
24 | run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=off | ||
25 | -- | ||
26 | 2.24.1 | ||
27 | |||
28 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Tests should not overwrite all user-supplied image options, but only add | ||
2 | to it (which will effectively overwrite conflicting values). Accomplish | ||
3 | this by passing options to _make_test_img via -o instead of $IMGOPTS. | ||
4 | 1 | ||
5 | For some tests, there is no functional change because they already only | ||
6 | appended options to IMGOPTS. For these, this patch is just a | ||
7 | simplification. | ||
8 | |||
9 | For others, this is a change, so they now heed user-specified $IMGOPTS. | ||
10 | Some of those tests do not work with all image options, though, so we | ||
11 | need to disable them accordingly. | ||
12 | |||
13 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
14 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
15 | Message-id: 20191107163708.833192-12-mreitz@redhat.com | ||
16 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
17 | --- | ||
18 | tests/qemu-iotests/031 | 9 ++++--- | ||
19 | tests/qemu-iotests/039 | 24 ++++++------------ | ||
20 | tests/qemu-iotests/059 | 18 ++++++------- | ||
21 | tests/qemu-iotests/060 | 6 ++--- | ||
22 | tests/qemu-iotests/061 | 57 ++++++++++++++++++++++-------------------- | ||
23 | tests/qemu-iotests/079 | 3 +-- | ||
24 | tests/qemu-iotests/106 | 2 +- | ||
25 | tests/qemu-iotests/108 | 2 +- | ||
26 | tests/qemu-iotests/112 | 32 ++++++++++++------------ | ||
27 | tests/qemu-iotests/115 | 3 +-- | ||
28 | tests/qemu-iotests/121 | 6 ++--- | ||
29 | tests/qemu-iotests/125 | 2 +- | ||
30 | tests/qemu-iotests/137 | 2 +- | ||
31 | tests/qemu-iotests/138 | 3 +-- | ||
32 | tests/qemu-iotests/175 | 2 +- | ||
33 | tests/qemu-iotests/190 | 2 +- | ||
34 | tests/qemu-iotests/191 | 3 +-- | ||
35 | tests/qemu-iotests/220 | 4 ++- | ||
36 | tests/qemu-iotests/243 | 6 +++-- | ||
37 | tests/qemu-iotests/244 | 10 +++++--- | ||
38 | tests/qemu-iotests/250 | 3 +-- | ||
39 | tests/qemu-iotests/265 | 2 +- | ||
40 | 22 files changed, 100 insertions(+), 101 deletions(-) | ||
41 | |||
42 | diff --git a/tests/qemu-iotests/031 b/tests/qemu-iotests/031 | ||
43 | index XXXXXXX..XXXXXXX 100755 | ||
44 | --- a/tests/qemu-iotests/031 | ||
45 | +++ b/tests/qemu-iotests/031 | ||
46 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
47 | # This tests qcow2-specific low-level functionality | ||
48 | _supported_fmt qcow2 | ||
49 | _supported_proto file | ||
50 | +# We want to test compat=0.10, which does not support refcount widths | ||
51 | +# other than 16 | ||
52 | +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
53 | |||
54 | CLUSTER_SIZE=65536 | ||
55 | |||
56 | # qcow2.py output depends on the exact options used, so override the command | ||
57 | # line here as an exception | ||
58 | -for IMGOPTS in "compat=0.10" "compat=1.1"; do | ||
59 | +for compat in "compat=0.10" "compat=1.1"; do | ||
60 | |||
61 | echo | ||
62 | - echo ===== Testing with -o $IMGOPTS ===== | ||
63 | + echo ===== Testing with -o $compat ===== | ||
64 | echo | ||
65 | echo === Create image with unknown header extension === | ||
66 | echo | ||
67 | - _make_test_img 64M | ||
68 | + _make_test_img -o $compat 64M | ||
69 | $PYTHON qcow2.py "$TEST_IMG" add-header-ext 0x12345678 "This is a test header extension" | ||
70 | $PYTHON qcow2.py "$TEST_IMG" dump-header | ||
71 | _check_test_img | ||
72 | diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039 | ||
73 | index XXXXXXX..XXXXXXX 100755 | ||
74 | --- a/tests/qemu-iotests/039 | ||
75 | +++ b/tests/qemu-iotests/039 | ||
76 | @@ -XXX,XX +XXX,XX @@ size=128M | ||
77 | echo | ||
78 | echo "== Checking that image is clean on shutdown ==" | ||
79 | |||
80 | -IMGOPTS="compat=1.1,lazy_refcounts=on" | ||
81 | -_make_test_img $size | ||
82 | +_make_test_img -o "compat=1.1,lazy_refcounts=on" $size | ||
83 | |||
84 | $QEMU_IO -c "write -P 0x5a 0 512" "$TEST_IMG" | _filter_qemu_io | ||
85 | |||
86 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
87 | echo | ||
88 | echo "== Creating a dirty image file ==" | ||
89 | |||
90 | -IMGOPTS="compat=1.1,lazy_refcounts=on" | ||
91 | -_make_test_img $size | ||
92 | +_make_test_img -o "compat=1.1,lazy_refcounts=on" $size | ||
93 | |||
94 | _NO_VALGRIND \ | ||
95 | $QEMU_IO -c "write -P 0x5a 0 512" \ | ||
96 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "read -P 0x5a 0 512" "$TEST_IMG" | _filter_qemu_io | ||
97 | echo | ||
98 | echo "== Opening a dirty image read/write should repair it ==" | ||
99 | |||
100 | -IMGOPTS="compat=1.1,lazy_refcounts=on" | ||
101 | -_make_test_img $size | ||
102 | +_make_test_img -o "compat=1.1,lazy_refcounts=on" $size | ||
103 | |||
104 | _NO_VALGRIND \ | ||
105 | $QEMU_IO -c "write -P 0x5a 0 512" \ | ||
106 | @@ -XXX,XX +XXX,XX @@ $PYTHON qcow2.py "$TEST_IMG" dump-header | grep incompatible_features | ||
107 | echo | ||
108 | echo "== Creating an image file with lazy_refcounts=off ==" | ||
109 | |||
110 | -IMGOPTS="compat=1.1,lazy_refcounts=off" | ||
111 | -_make_test_img $size | ||
112 | +_make_test_img -o "compat=1.1,lazy_refcounts=off" $size | ||
113 | |||
114 | _NO_VALGRIND \ | ||
115 | $QEMU_IO -c "write -P 0x5a 0 512" \ | ||
116 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
117 | echo | ||
118 | echo "== Committing to a backing file with lazy_refcounts=on ==" | ||
119 | |||
120 | -IMGOPTS="compat=1.1,lazy_refcounts=on" | ||
121 | -TEST_IMG="$TEST_IMG".base _make_test_img $size | ||
122 | +TEST_IMG="$TEST_IMG".base _make_test_img -o "compat=1.1,lazy_refcounts=on" $size | ||
123 | |||
124 | -IMGOPTS="compat=1.1,lazy_refcounts=on,backing_file=$TEST_IMG.base" | ||
125 | -_make_test_img $size | ||
126 | +_make_test_img -o "compat=1.1,lazy_refcounts=on,backing_file=$TEST_IMG.base" $size | ||
127 | |||
128 | $QEMU_IO -c "write 0 512" "$TEST_IMG" | _filter_qemu_io | ||
129 | $QEMU_IMG commit "$TEST_IMG" | ||
130 | @@ -XXX,XX +XXX,XX @@ TEST_IMG="$TEST_IMG".base _check_test_img | ||
131 | echo | ||
132 | echo "== Changing lazy_refcounts setting at runtime ==" | ||
133 | |||
134 | -IMGOPTS="compat=1.1,lazy_refcounts=off" | ||
135 | -_make_test_img $size | ||
136 | +_make_test_img -o "compat=1.1,lazy_refcounts=off" $size | ||
137 | |||
138 | _NO_VALGRIND \ | ||
139 | $QEMU_IO -c "reopen -o lazy-refcounts=on" \ | ||
140 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "reopen -o lazy-refcounts=on" \ | ||
141 | $PYTHON qcow2.py "$TEST_IMG" dump-header | grep incompatible_features | ||
142 | _check_test_img | ||
143 | |||
144 | -IMGOPTS="compat=1.1,lazy_refcounts=on" | ||
145 | -_make_test_img $size | ||
146 | +_make_test_img -o "compat=1.1,lazy_refcounts=on" $size | ||
147 | |||
148 | _NO_VALGRIND \ | ||
149 | $QEMU_IO -c "reopen -o lazy-refcounts=off" \ | ||
150 | diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059 | ||
151 | index XXXXXXX..XXXXXXX 100755 | ||
152 | --- a/tests/qemu-iotests/059 | ||
153 | +++ b/tests/qemu-iotests/059 | ||
154 | @@ -XXX,XX +XXX,XX @@ poke_file "$TEST_IMG" "$grain_table_size_offset" "\x01\x00\x00\x00" | ||
155 | |||
156 | echo | ||
157 | echo "=== Testing monolithicFlat creation and opening ===" | ||
158 | -IMGOPTS="subformat=monolithicFlat" _make_test_img 2G | ||
159 | +_make_test_img -o "subformat=monolithicFlat" 2G | ||
160 | _img_info | ||
161 | _cleanup_test_img | ||
162 | |||
163 | echo | ||
164 | echo "=== Testing monolithicFlat with zeroed_grain ===" | ||
165 | -IMGOPTS="subformat=monolithicFlat,zeroed_grain=on" _make_test_img 2G | ||
166 | +_make_test_img -o "subformat=monolithicFlat,zeroed_grain=on" 2G | ||
167 | _cleanup_test_img | ||
168 | |||
169 | echo | ||
170 | echo "=== Testing big twoGbMaxExtentFlat ===" | ||
171 | -IMGOPTS="subformat=twoGbMaxExtentFlat" _make_test_img 1000G | ||
172 | +_make_test_img -o "subformat=twoGbMaxExtentFlat" 1000G | ||
173 | $QEMU_IMG info $TEST_IMG | _filter_testdir | sed -e 's/cid: [0-9]*/cid: XXXXXXXX/' | ||
174 | _cleanup_test_img | ||
175 | |||
176 | @@ -XXX,XX +XXX,XX @@ _img_info | ||
177 | |||
178 | echo | ||
179 | echo "=== Testing truncated sparse ===" | ||
180 | -IMGOPTS="subformat=monolithicSparse" _make_test_img 100G | ||
181 | +_make_test_img -o "subformat=monolithicSparse" 100G | ||
182 | truncate -s 10M $TEST_IMG | ||
183 | _img_info | ||
184 | |||
185 | echo | ||
186 | echo "=== Converting to streamOptimized from image with small cluster size===" | ||
187 | -TEST_IMG="$TEST_IMG.qcow2" IMGFMT=qcow2 IMGOPTS="cluster_size=4096" _make_test_img 1G | ||
188 | +TEST_IMG="$TEST_IMG.qcow2" IMGFMT=qcow2 _make_test_img -o "cluster_size=4096" 1G | ||
189 | $QEMU_IO -f qcow2 -c "write -P 0xa 0 512" "$TEST_IMG.qcow2" | _filter_qemu_io | ||
190 | $QEMU_IO -f qcow2 -c "write -P 0xb 10240 512" "$TEST_IMG.qcow2" | _filter_qemu_io | ||
191 | $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2" "$TEST_IMG" 2>&1 | ||
192 | @@ -XXX,XX +XXX,XX @@ echo "=== Testing monolithicFlat with internally generated JSON file name ===" | ||
193 | |||
194 | echo '--- blkdebug ---' | ||
195 | # Should work, because bdrv_dirname() works fine with blkdebug | ||
196 | -IMGOPTS="subformat=monolithicFlat" _make_test_img 64M | ||
197 | +_make_test_img -o "subformat=monolithicFlat" 64M | ||
198 | $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \ | ||
199 | -c info \ | ||
200 | 2>&1 \ | ||
201 | @@ -XXX,XX +XXX,XX @@ _cleanup_test_img | ||
202 | |||
203 | echo '--- quorum ---' | ||
204 | # Should not work, because bdrv_dirname() does not work with quorum | ||
205 | -IMGOPTS="subformat=monolithicFlat" _make_test_img 64M | ||
206 | +_make_test_img -o "subformat=monolithicFlat" 64M | ||
207 | cp "$TEST_IMG" "$TEST_IMG.orig" | ||
208 | |||
209 | filename="json:{ | ||
210 | @@ -XXX,XX +XXX,XX @@ _cleanup_test_img | ||
211 | |||
212 | echo | ||
213 | echo "=== Testing 4TB monolithicFlat creation and IO ===" | ||
214 | -IMGOPTS="subformat=monolithicFlat" _make_test_img 4T | ||
215 | +_make_test_img -o "subformat=monolithicFlat" 4T | ||
216 | _img_info | ||
217 | $QEMU_IO -c "write -P 0xa 900G 512" "$TEST_IMG" | _filter_qemu_io | ||
218 | $QEMU_IO -c "read -v 900G 1024" "$TEST_IMG" | _filter_qemu_io | ||
219 | @@ -XXX,XX +XXX,XX @@ _cleanup_test_img | ||
220 | echo | ||
221 | echo "=== Testing qemu-img map on extents ===" | ||
222 | for fmt in monolithicSparse twoGbMaxExtentSparse; do | ||
223 | - IMGOPTS="subformat=$fmt" _make_test_img 31G | ||
224 | + _make_test_img -o "subformat=$fmt" 31G | ||
225 | $QEMU_IO -c "write 65024 1k" "$TEST_IMG" | _filter_qemu_io | ||
226 | $QEMU_IO -c "write 2147483136 1k" "$TEST_IMG" | _filter_qemu_io | ||
227 | $QEMU_IO -c "write 5G 1k" "$TEST_IMG" | _filter_qemu_io | ||
228 | diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060 | ||
229 | index XXXXXXX..XXXXXXX 100755 | ||
230 | --- a/tests/qemu-iotests/060 | ||
231 | +++ b/tests/qemu-iotests/060 | ||
232 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'write 0k 64k' "$BACKING_IMG" | _filter_qemu_io | ||
233 | # compat=0.10 is required in order to make the following discard actually | ||
234 | # unallocate the sector rather than make it a zero sector - we want COW, after | ||
235 | # all. | ||
236 | -IMGOPTS='compat=0.10' _make_test_img -b "$BACKING_IMG" 1G | ||
237 | +_make_test_img -o 'compat=0.10' -b "$BACKING_IMG" 1G | ||
238 | # Write two clusters, the second one enforces creation of an L2 table after | ||
239 | # the first data cluster. | ||
240 | $QEMU_IO -c 'write 0k 64k' -c 'write 512M 64k' "$TEST_IMG" | _filter_qemu_io | ||
241 | @@ -XXX,XX +XXX,XX @@ echo | ||
242 | echo "=== Discarding a non-covered in-bounds refblock ===" | ||
243 | echo | ||
244 | |||
245 | -IMGOPTS='refcount_bits=1' _make_test_img 64M | ||
246 | +_make_test_img -o 'refcount_bits=1' 64M | ||
247 | |||
248 | # Pretend there's a refblock somewhere where there is no refblock to | ||
249 | # cover it (but the covering refblock has a valid index in the | ||
250 | @@ -XXX,XX +XXX,XX @@ echo | ||
251 | echo "=== Discarding a refblock covered by an unaligned refblock ===" | ||
252 | echo | ||
253 | |||
254 | -IMGOPTS='refcount_bits=1' _make_test_img 64M | ||
255 | +_make_test_img -o 'refcount_bits=1' 64M | ||
256 | |||
257 | # Same as above | ||
258 | poke_file "$TEST_IMG" "$(($rt_offset+8))" "\x00\x00\x00\x10\x00\x00\x00\x00" | ||
259 | diff --git a/tests/qemu-iotests/061 b/tests/qemu-iotests/061 | ||
260 | index XXXXXXX..XXXXXXX 100755 | ||
261 | --- a/tests/qemu-iotests/061 | ||
262 | +++ b/tests/qemu-iotests/061 | ||
263 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
264 | _supported_fmt qcow2 | ||
265 | _supported_proto file | ||
266 | _supported_os Linux | ||
267 | +# Conversion between different compat versions can only really work | ||
268 | +# with refcount_bits=16 | ||
269 | +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
270 | |||
271 | echo | ||
272 | echo "=== Testing version downgrade with zero expansion ===" | ||
273 | echo | ||
274 | -IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M | ||
275 | +_make_test_img -o "compat=1.1,lazy_refcounts=on" 64M | ||
276 | $QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
277 | $PYTHON qcow2.py "$TEST_IMG" dump-header | ||
278 | $QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" | ||
279 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
280 | echo | ||
281 | echo "=== Testing version downgrade with zero expansion and 4K cache entries ===" | ||
282 | echo | ||
283 | -IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M | ||
284 | +_make_test_img -o "compat=1.1,lazy_refcounts=on" 64M | ||
285 | $QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
286 | $QEMU_IO -c "write -z 32M 128k" "$TEST_IMG" | _filter_qemu_io | ||
287 | $QEMU_IO -c map "$TEST_IMG" | _filter_qemu_io | ||
288 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
289 | echo | ||
290 | echo "=== Testing dirty version downgrade ===" | ||
291 | echo | ||
292 | -IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M | ||
293 | +_make_test_img -o "compat=1.1,lazy_refcounts=on" 64M | ||
294 | _NO_VALGRIND \ | ||
295 | $QEMU_IO -c "write -P 0x2a 0 128k" -c flush \ | ||
296 | -c "sigraise $(kill -l KILL)" "$TEST_IMG" 2>&1 | _filter_qemu_io | ||
297 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
298 | echo | ||
299 | echo "=== Testing version downgrade with unknown compat/autoclear flags ===" | ||
300 | echo | ||
301 | -IMGOPTS="compat=1.1" _make_test_img 64M | ||
302 | +_make_test_img -o "compat=1.1" 64M | ||
303 | $PYTHON qcow2.py "$TEST_IMG" set-feature-bit compatible 42 | ||
304 | $PYTHON qcow2.py "$TEST_IMG" set-feature-bit autoclear 42 | ||
305 | $PYTHON qcow2.py "$TEST_IMG" dump-header | ||
306 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
307 | echo | ||
308 | echo "=== Testing version upgrade and resize ===" | ||
309 | echo | ||
310 | -IMGOPTS="compat=0.10" _make_test_img 64M | ||
311 | +_make_test_img -o "compat=0.10" 64M | ||
312 | $QEMU_IO -c "write -P 0x2a 42M 64k" "$TEST_IMG" | _filter_qemu_io | ||
313 | $PYTHON qcow2.py "$TEST_IMG" dump-header | ||
314 | $QEMU_IMG amend -o "compat=1.1,lazy_refcounts=on,size=128M" "$TEST_IMG" | ||
315 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
316 | echo | ||
317 | echo "=== Testing dirty lazy_refcounts=off ===" | ||
318 | echo | ||
319 | -IMGOPTS="compat=1.1,lazy_refcounts=on" _make_test_img 64M | ||
320 | +_make_test_img -o "compat=1.1,lazy_refcounts=on" 64M | ||
321 | _NO_VALGRIND \ | ||
322 | $QEMU_IO -c "write -P 0x2a 0 128k" -c flush \ | ||
323 | -c "sigraise $(kill -l KILL)" "$TEST_IMG" 2>&1 | _filter_qemu_io | ||
324 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
325 | echo | ||
326 | echo "=== Testing backing file ===" | ||
327 | echo | ||
328 | -IMGOPTS="compat=1.1" _make_test_img 64M | ||
329 | -IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M | ||
330 | +_make_test_img -o "compat=1.1" 64M | ||
331 | +TEST_IMG="$TEST_IMG.base" _make_test_img -o "compat=1.1" 64M | ||
332 | $QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io | ||
333 | $QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
334 | $QEMU_IMG amend -o "backing_file=$TEST_IMG.base,backing_fmt=qcow2" "$TEST_IMG" | ||
335 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
336 | echo | ||
337 | echo "=== Testing invalid configurations ===" | ||
338 | echo | ||
339 | -IMGOPTS="compat=0.10" _make_test_img 64M | ||
340 | +_make_test_img -o "compat=0.10" 64M | ||
341 | $QEMU_IMG amend -o "lazy_refcounts=on" "$TEST_IMG" | ||
342 | $QEMU_IMG amend -o "compat=1.1" "$TEST_IMG" # actually valid | ||
343 | $QEMU_IMG amend -o "compat=0.10,lazy_refcounts=on" "$TEST_IMG" | ||
344 | @@ -XXX,XX +XXX,XX @@ $QEMU_IMG amend -o "preallocation=on" "$TEST_IMG" | ||
345 | echo | ||
346 | echo "=== Testing correct handling of unset value ===" | ||
347 | echo | ||
348 | -IMGOPTS="compat=1.1,cluster_size=1k" _make_test_img 64M | ||
349 | +_make_test_img -o "compat=1.1,cluster_size=1k" 64M | ||
350 | echo "Should work:" | ||
351 | $QEMU_IMG amend -o "lazy_refcounts=on" "$TEST_IMG" | ||
352 | echo "Should not work:" # Just to know which of these tests actually fails | ||
353 | @@ -XXX,XX +XXX,XX @@ $QEMU_IMG amend -o "cluster_size=64k" "$TEST_IMG" | ||
354 | echo | ||
355 | echo "=== Testing zero expansion on inactive clusters ===" | ||
356 | echo | ||
357 | -IMGOPTS="compat=1.1" _make_test_img 64M | ||
358 | +_make_test_img -o "compat=1.1" 64M | ||
359 | $QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
360 | $QEMU_IMG snapshot -c foo "$TEST_IMG" | ||
361 | $QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
362 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
363 | echo | ||
364 | echo "=== Testing zero expansion on shared L2 table ===" | ||
365 | echo | ||
366 | -IMGOPTS="compat=1.1" _make_test_img 64M | ||
367 | +_make_test_img -o "compat=1.1" 64M | ||
368 | $QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
369 | $QEMU_IMG snapshot -c foo "$TEST_IMG" | ||
370 | $QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" | ||
371 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
372 | echo | ||
373 | echo "=== Testing zero expansion on backed image ===" | ||
374 | echo | ||
375 | -IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M | ||
376 | +TEST_IMG="$TEST_IMG.base" _make_test_img -o "compat=1.1" 64M | ||
377 | $QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io | ||
378 | -IMGOPTS="compat=1.1" _make_test_img -b "$TEST_IMG.base" 64M | ||
379 | +_make_test_img -o "compat=1.1" -b "$TEST_IMG.base" 64M | ||
380 | $QEMU_IO -c "read -P 0x2a 0 128k" -c "write -z 0 64k" "$TEST_IMG" | _filter_qemu_io | ||
381 | $QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" | ||
382 | _check_test_img | ||
383 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "read -P 0 0 64k" -c "read -P 0x2a 64k 64k" "$TEST_IMG" | _filter_qe | ||
384 | echo | ||
385 | echo "=== Testing zero expansion on backed inactive clusters ===" | ||
386 | echo | ||
387 | -IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M | ||
388 | +TEST_IMG="$TEST_IMG.base" _make_test_img -o "compat=1.1" 64M | ||
389 | $QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io | ||
390 | -IMGOPTS="compat=1.1" _make_test_img -b "$TEST_IMG.base" 64M | ||
391 | +_make_test_img -o "compat=1.1" -b "$TEST_IMG.base" 64M | ||
392 | $QEMU_IO -c "write -z 0 64k" "$TEST_IMG" | _filter_qemu_io | ||
393 | $QEMU_IMG snapshot -c foo "$TEST_IMG" | ||
394 | $QEMU_IO -c "write -P 0x42 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
395 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "read -P 0 0 64k" -c "read -P 0x2a 64k 64k" "$TEST_IMG" | _filter_qe | ||
396 | echo | ||
397 | echo "=== Testing zero expansion on backed image with shared L2 table ===" | ||
398 | echo | ||
399 | -IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 64M | ||
400 | +TEST_IMG="$TEST_IMG.base" _make_test_img -o "compat=1.1" 64M | ||
401 | $QEMU_IO -c "write -P 0x2a 0 128k" "$TEST_IMG.base" | _filter_qemu_io | ||
402 | -IMGOPTS="compat=1.1" _make_test_img -b "$TEST_IMG.base" 64M | ||
403 | +_make_test_img -o "compat=1.1" -b "$TEST_IMG.base" 64M | ||
404 | $QEMU_IO -c "write -z 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
405 | $QEMU_IMG snapshot -c foo "$TEST_IMG" | ||
406 | $QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" | ||
407 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "read -P 0 0 128k" "$TEST_IMG" | _filter_qemu_io | ||
408 | echo | ||
409 | echo "=== Testing preallocated zero expansion on full image ===" | ||
410 | echo | ||
411 | -IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG" _make_test_img 64M | ||
412 | +TEST_IMG="$TEST_IMG" _make_test_img -o "compat=1.1" 64M | ||
413 | $QEMU_IO -c "write -P 0x2a 0 64M" "$TEST_IMG" -c "write -z 0 64M" | _filter_qemu_io | ||
414 | $QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" | ||
415 | _check_test_img | ||
416 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "read -P 0 0 64M" "$TEST_IMG" | _filter_qemu_io | ||
417 | echo | ||
418 | echo "=== Testing progress report without snapshot ===" | ||
419 | echo | ||
420 | -IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 4G | ||
421 | -IMGOPTS="compat=1.1" _make_test_img -b "$TEST_IMG.base" 4G | ||
422 | +TEST_IMG="$TEST_IMG.base" _make_test_img -o "compat=1.1" 4G | ||
423 | +_make_test_img -o "compat=1.1" -b "$TEST_IMG.base" 4G | ||
424 | $QEMU_IO -c "write -z 0 64k" \ | ||
425 | -c "write -z 1G 64k" \ | ||
426 | -c "write -z 2G 64k" \ | ||
427 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
428 | echo | ||
429 | echo "=== Testing progress report with snapshot ===" | ||
430 | echo | ||
431 | -IMGOPTS="compat=1.1" TEST_IMG="$TEST_IMG.base" _make_test_img 4G | ||
432 | -IMGOPTS="compat=1.1" _make_test_img -b "$TEST_IMG.base" 4G | ||
433 | +TEST_IMG="$TEST_IMG.base" _make_test_img -o "compat=1.1" 4G | ||
434 | +_make_test_img -o "compat=1.1" -b "$TEST_IMG.base" 4G | ||
435 | $QEMU_IO -c "write -z 0 64k" \ | ||
436 | -c "write -z 1G 64k" \ | ||
437 | -c "write -z 2G 64k" \ | ||
438 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
439 | echo | ||
440 | echo "=== Testing version downgrade with external data file ===" | ||
441 | echo | ||
442 | -IMGOPTS="compat=1.1,data_file=$TEST_IMG.data" _make_test_img 64M | ||
443 | +_make_test_img -o "compat=1.1,data_file=$TEST_IMG.data" 64M | ||
444 | $QEMU_IMG amend -o "compat=0.10" "$TEST_IMG" | ||
445 | _img_info --format-specific | ||
446 | _check_test_img | ||
447 | @@ -XXX,XX +XXX,XX @@ _check_test_img | ||
448 | echo | ||
449 | echo "=== Try changing the external data file ===" | ||
450 | echo | ||
451 | -IMGOPTS="compat=1.1" _make_test_img 64M | ||
452 | +_make_test_img -o "compat=1.1" 64M | ||
453 | $QEMU_IMG amend -o "data_file=foo" "$TEST_IMG" | ||
454 | |||
455 | echo | ||
456 | -IMGOPTS="compat=1.1,data_file=$TEST_IMG.data" _make_test_img 64M | ||
457 | +_make_test_img -o "compat=1.1,data_file=$TEST_IMG.data" 64M | ||
458 | $QEMU_IMG amend -o "data_file=foo" "$TEST_IMG" | ||
459 | _img_info --format-specific | ||
460 | TEST_IMG="data-file.filename=$TEST_IMG.data,file.filename=$TEST_IMG" _img_info --format-specific --image-opts | ||
461 | @@ -XXX,XX +XXX,XX @@ TEST_IMG="data-file.filename=$TEST_IMG.data,file.filename=$TEST_IMG" _img_info - | ||
462 | echo | ||
463 | echo "=== Clearing and setting data-file-raw ===" | ||
464 | echo | ||
465 | -IMGOPTS="compat=1.1,data_file=$TEST_IMG.data,data_file_raw=on" _make_test_img 64M | ||
466 | +_make_test_img -o "compat=1.1,data_file=$TEST_IMG.data,data_file_raw=on" 64M | ||
467 | $QEMU_IMG amend -o "data_file_raw=on" "$TEST_IMG" | ||
468 | _img_info --format-specific | ||
469 | _check_test_img | ||
470 | diff --git a/tests/qemu-iotests/079 b/tests/qemu-iotests/079 | ||
471 | index XXXXXXX..XXXXXXX 100755 | ||
472 | --- a/tests/qemu-iotests/079 | ||
473 | +++ b/tests/qemu-iotests/079 | ||
474 | @@ -XXX,XX +XXX,XX @@ echo | ||
475 | cluster_sizes="16384 32768 65536 131072 262144 524288 1048576 2097152 4194304" | ||
476 | |||
477 | for s in $cluster_sizes; do | ||
478 | - IMGOPTS=$(_optstr_add "$IMGOPTS" "preallocation=metadata,cluster_size=$s") \ | ||
479 | - _make_test_img 4G | ||
480 | + _make_test_img -o "preallocation=metadata,cluster_size=$s" 4G | ||
481 | done | ||
482 | |||
483 | # success, all done | ||
484 | diff --git a/tests/qemu-iotests/106 b/tests/qemu-iotests/106 | ||
485 | index XXXXXXX..XXXXXXX 100755 | ||
486 | --- a/tests/qemu-iotests/106 | ||
487 | +++ b/tests/qemu-iotests/106 | ||
488 | @@ -XXX,XX +XXX,XX @@ for create_mode in off falloc full; do | ||
489 | echo | ||
490 | echo "--- create_mode=$create_mode growth_mode=$growth_mode ---" | ||
491 | |||
492 | - IMGOPTS="preallocation=$create_mode" _make_test_img ${CREATION_SIZE}K | ||
493 | + _make_test_img -o "preallocation=$create_mode" ${CREATION_SIZE}K | ||
494 | $QEMU_IMG resize -f "$IMGFMT" --preallocation=$growth_mode "$TEST_IMG" +${GROWTH_SIZE}K | ||
495 | |||
496 | expected_size=0 | ||
497 | diff --git a/tests/qemu-iotests/108 b/tests/qemu-iotests/108 | ||
498 | index XXXXXXX..XXXXXXX 100755 | ||
499 | --- a/tests/qemu-iotests/108 | ||
500 | +++ b/tests/qemu-iotests/108 | ||
501 | @@ -XXX,XX +XXX,XX @@ echo | ||
502 | echo '=== Repairing unreferenced data cluster in new refblock area ===' | ||
503 | echo | ||
504 | |||
505 | -IMGOPTS='cluster_size=512' _make_test_img 64M | ||
506 | +_make_test_img -o 'cluster_size=512' 64M | ||
507 | # Allocate the first 128 kB in the image (first refblock) | ||
508 | $QEMU_IO -c 'write 0 0x1b200' "$TEST_IMG" | _filter_qemu_io | ||
509 | # should be 131072 == 0x20000 | ||
510 | diff --git a/tests/qemu-iotests/112 b/tests/qemu-iotests/112 | ||
511 | index XXXXXXX..XXXXXXX 100755 | ||
512 | --- a/tests/qemu-iotests/112 | ||
513 | +++ b/tests/qemu-iotests/112 | ||
514 | @@ -XXX,XX +XXX,XX @@ echo '=== refcount_bits limits ===' | ||
515 | echo | ||
516 | |||
517 | # Must be positive (non-zero) | ||
518 | -IMGOPTS="$IMGOPTS,refcount_bits=0" _make_test_img 64M | ||
519 | +_make_test_img -o "refcount_bits=0" 64M | ||
520 | # Must be positive (non-negative) | ||
521 | -IMGOPTS="$IMGOPTS,refcount_bits=-1" _make_test_img 64M | ||
522 | +_make_test_img -o "refcount_bits=-1" 64M | ||
523 | # May not exceed 64 | ||
524 | -IMGOPTS="$IMGOPTS,refcount_bits=128" _make_test_img 64M | ||
525 | +_make_test_img -o "refcount_bits=128" 64M | ||
526 | # Must be a power of two | ||
527 | -IMGOPTS="$IMGOPTS,refcount_bits=42" _make_test_img 64M | ||
528 | +_make_test_img -o "refcount_bits=42" 64M | ||
529 | |||
530 | # 1 is the minimum | ||
531 | -IMGOPTS="$IMGOPTS,refcount_bits=1" _make_test_img 64M | ||
532 | +_make_test_img -o "refcount_bits=1" 64M | ||
533 | print_refcount_bits | ||
534 | |||
535 | # 64 is the maximum | ||
536 | -IMGOPTS="$IMGOPTS,refcount_bits=64" _make_test_img 64M | ||
537 | +_make_test_img -o "refcount_bits=64" 64M | ||
538 | print_refcount_bits | ||
539 | |||
540 | # 16 is the default | ||
541 | @@ -XXX,XX +XXX,XX @@ echo '=== refcount_bits and compat=0.10 ===' | ||
542 | echo | ||
543 | |||
544 | # Should work | ||
545 | -IMGOPTS="$IMGOPTS,compat=0.10,refcount_bits=16" _make_test_img 64M | ||
546 | +_make_test_img -o "compat=0.10,refcount_bits=16" 64M | ||
547 | print_refcount_bits | ||
548 | |||
549 | # Should not work | ||
550 | -IMGOPTS="$IMGOPTS,compat=0.10,refcount_bits=1" _make_test_img 64M | ||
551 | -IMGOPTS="$IMGOPTS,compat=0.10,refcount_bits=64" _make_test_img 64M | ||
552 | +_make_test_img -o "compat=0.10,refcount_bits=1" 64M | ||
553 | +_make_test_img -o "compat=0.10,refcount_bits=64" 64M | ||
554 | |||
555 | |||
556 | echo | ||
557 | echo '=== Snapshot limit on refcount_bits=1 ===' | ||
558 | echo | ||
559 | |||
560 | -IMGOPTS="$IMGOPTS,refcount_bits=1" _make_test_img 64M | ||
561 | +_make_test_img -o "refcount_bits=1" 64M | ||
562 | print_refcount_bits | ||
563 | |||
564 | $QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io | ||
565 | @@ -XXX,XX +XXX,XX @@ echo | ||
566 | echo '=== Snapshot limit on refcount_bits=2 ===' | ||
567 | echo | ||
568 | |||
569 | -IMGOPTS="$IMGOPTS,refcount_bits=2" _make_test_img 64M | ||
570 | +_make_test_img -o "refcount_bits=2" 64M | ||
571 | print_refcount_bits | ||
572 | |||
573 | $QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io | ||
574 | @@ -XXX,XX +XXX,XX @@ echo | ||
575 | echo '=== Compressed clusters with refcount_bits=1 ===' | ||
576 | echo | ||
577 | |||
578 | -IMGOPTS="$IMGOPTS,refcount_bits=1" _make_test_img 64M | ||
579 | +_make_test_img -o "refcount_bits=1" 64M | ||
580 | print_refcount_bits | ||
581 | |||
582 | # Both should fit into a single host cluster; instead of failing to increase the | ||
583 | @@ -XXX,XX +XXX,XX @@ echo | ||
584 | echo '=== MSb set in 64 bit refcount ===' | ||
585 | echo | ||
586 | |||
587 | -IMGOPTS="$IMGOPTS,refcount_bits=64" _make_test_img 64M | ||
588 | +_make_test_img -o "refcount_bits=64" 64M | ||
589 | print_refcount_bits | ||
590 | |||
591 | $QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io | ||
592 | @@ -XXX,XX +XXX,XX @@ echo | ||
593 | echo '=== Snapshot on maximum 64 bit refcount value ===' | ||
594 | echo | ||
595 | |||
596 | -IMGOPTS="$IMGOPTS,refcount_bits=64" _make_test_img 64M | ||
597 | +_make_test_img -o "refcount_bits=64" 64M | ||
598 | print_refcount_bits | ||
599 | |||
600 | $QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io | ||
601 | @@ -XXX,XX +XXX,XX @@ echo | ||
602 | echo '=== Testing too many references for check ===' | ||
603 | echo | ||
604 | |||
605 | -IMGOPTS="$IMGOPTS,refcount_bits=1" _make_test_img 64M | ||
606 | +_make_test_img -o "refcount_bits=1" 64M | ||
607 | print_refcount_bits | ||
608 | |||
609 | # This cluster should be created at 0x50000 | ||
610 | @@ -XXX,XX +XXX,XX @@ echo | ||
611 | echo '=== Multiple walks necessary during amend ===' | ||
612 | echo | ||
613 | |||
614 | -IMGOPTS="$IMGOPTS,refcount_bits=1,cluster_size=512" _make_test_img 64k | ||
615 | +_make_test_img -o "refcount_bits=1,cluster_size=512" 64k | ||
616 | |||
617 | # Cluster 0 is the image header, clusters 1 to 4 are used by the L1 table, a | ||
618 | # single L2 table, the reftable and a single refblock. This creates 58 data | ||
619 | diff --git a/tests/qemu-iotests/115 b/tests/qemu-iotests/115 | ||
620 | index XXXXXXX..XXXXXXX 100755 | ||
621 | --- a/tests/qemu-iotests/115 | ||
622 | +++ b/tests/qemu-iotests/115 | ||
623 | @@ -XXX,XX +XXX,XX @@ echo | ||
624 | # least 256 MB. We can achieve that by using preallocation=metadata for an image | ||
625 | # which has a guest disk size of 256 MB. | ||
626 | |||
627 | -IMGOPTS="$IMGOPTS,refcount_bits=64,cluster_size=512,preallocation=metadata" \ | ||
628 | - _make_test_img 256M | ||
629 | +_make_test_img -o "refcount_bits=64,cluster_size=512,preallocation=metadata" 256M | ||
630 | |||
631 | # We know for sure that the L1 and refcount tables do not overlap with any other | ||
632 | # structure because the metadata overlap checks would have caught that case. | ||
633 | diff --git a/tests/qemu-iotests/121 b/tests/qemu-iotests/121 | ||
634 | index XXXXXXX..XXXXXXX 100755 | ||
635 | --- a/tests/qemu-iotests/121 | ||
636 | +++ b/tests/qemu-iotests/121 | ||
637 | @@ -XXX,XX +XXX,XX @@ echo | ||
638 | # Preallocation speeds up the write operation, but preallocating everything will | ||
639 | # destroy the purpose of the write; so preallocate one KB less than what would | ||
640 | # cause a reftable growth... | ||
641 | -IMGOPTS='preallocation=metadata,cluster_size=1k' _make_test_img 64512K | ||
642 | +_make_test_img -o 'preallocation=metadata,cluster_size=1k' 64512K | ||
643 | # ...and make the image the desired size afterwards. | ||
644 | $QEMU_IMG resize "$TEST_IMG" 65M | ||
645 | |||
646 | @@ -XXX,XX +XXX,XX @@ echo | ||
647 | echo '--- Test 2 ---' | ||
648 | echo | ||
649 | |||
650 | -IMGOPTS='preallocation=metadata,cluster_size=1k' _make_test_img 64513K | ||
651 | +_make_test_img -o 'preallocation=metadata,cluster_size=1k' 64513K | ||
652 | # This results in an L1 table growth which in turn results in some clusters at | ||
653 | # the start of the image becoming free | ||
654 | $QEMU_IMG resize "$TEST_IMG" 65M | ||
655 | @@ -XXX,XX +XXX,XX @@ echo | ||
656 | echo '=== Allocating a new refcount block must not leave holes in the image ===' | ||
657 | echo | ||
658 | |||
659 | -IMGOPTS='cluster_size=512,refcount_bits=16' _make_test_img 1M | ||
660 | +_make_test_img -o 'cluster_size=512,refcount_bits=16' 1M | ||
661 | |||
662 | # This results in an image with 256 used clusters: the qcow2 header, | ||
663 | # the refcount table, one refcount block, the L1 table, four L2 tables | ||
664 | diff --git a/tests/qemu-iotests/125 b/tests/qemu-iotests/125 | ||
665 | index XXXXXXX..XXXXXXX 100755 | ||
666 | --- a/tests/qemu-iotests/125 | ||
667 | +++ b/tests/qemu-iotests/125 | ||
668 | @@ -XXX,XX +XXX,XX @@ for GROWTH_SIZE in 16 48 80; do | ||
669 | for growth_mode in off metadata falloc full; do | ||
670 | echo "--- cluster_size=$cluster_size growth_size=$GROWTH_SIZE create_mode=$create_mode growth_mode=$growth_mode ---" | ||
671 | |||
672 | - IMGOPTS="preallocation=$create_mode,cluster_size=$cluster_size" _make_test_img ${CREATION_SIZE} | ||
673 | + _make_test_img -o "preallocation=$create_mode,cluster_size=$cluster_size" ${CREATION_SIZE} | ||
674 | $QEMU_IMG resize -f "$IMGFMT" --preallocation=$growth_mode "$TEST_IMG" +${GROWTH_SIZE}K | ||
675 | |||
676 | host_size_0=$(get_image_size_on_host) | ||
677 | diff --git a/tests/qemu-iotests/137 b/tests/qemu-iotests/137 | ||
678 | index XXXXXXX..XXXXXXX 100755 | ||
679 | --- a/tests/qemu-iotests/137 | ||
680 | +++ b/tests/qemu-iotests/137 | ||
681 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO \ | ||
682 | -c "reopen -o cache-clean-interval=-1" \ | ||
683 | "$TEST_IMG" | _filter_qemu_io | ||
684 | |||
685 | -IMGOPTS="cluster_size=256k" _make_test_img 32P | ||
686 | +_make_test_img -o "cluster_size=256k" 32P | ||
687 | $QEMU_IO \ | ||
688 | -c "reopen -o l2-cache-entry-size=512,l2-cache-size=1T" \ | ||
689 | "$TEST_IMG" | _filter_qemu_io | ||
690 | diff --git a/tests/qemu-iotests/138 b/tests/qemu-iotests/138 | ||
691 | index XXXXXXX..XXXXXXX 100755 | ||
692 | --- a/tests/qemu-iotests/138 | ||
693 | +++ b/tests/qemu-iotests/138 | ||
694 | @@ -XXX,XX +XXX,XX @@ echo | ||
695 | echo '=== Check on an image with a multiple of 2^32 clusters ===' | ||
696 | echo | ||
697 | |||
698 | -IMGOPTS=$(_optstr_add "$IMGOPTS" "cluster_size=512") \ | ||
699 | - _make_test_img 512 | ||
700 | +_make_test_img -o "cluster_size=512" 512 | ||
701 | |||
702 | # Allocate L2 table | ||
703 | $QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io | ||
704 | diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175 | ||
705 | index XXXXXXX..XXXXXXX 100755 | ||
706 | --- a/tests/qemu-iotests/175 | ||
707 | +++ b/tests/qemu-iotests/175 | ||
708 | @@ -XXX,XX +XXX,XX @@ stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_block | ||
709 | for mode in off full falloc; do | ||
710 | echo | ||
711 | echo "== creating image with preallocation $mode ==" | ||
712 | - IMGOPTS=preallocation=$mode _make_test_img $size | _filter_imgfmt | ||
713 | + _make_test_img -o preallocation=$mode $size | _filter_imgfmt | ||
714 | stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size | ||
715 | done | ||
716 | |||
717 | diff --git a/tests/qemu-iotests/190 b/tests/qemu-iotests/190 | ||
718 | index XXXXXXX..XXXXXXX 100755 | ||
719 | --- a/tests/qemu-iotests/190 | ||
720 | +++ b/tests/qemu-iotests/190 | ||
721 | @@ -XXX,XX +XXX,XX @@ _supported_proto file | ||
722 | echo "== Huge file ==" | ||
723 | echo | ||
724 | |||
725 | -IMGOPTS='cluster_size=2M' _make_test_img 2T | ||
726 | +_make_test_img -o 'cluster_size=2M' 2T | ||
727 | |||
728 | $QEMU_IMG measure -O raw -f qcow2 "$TEST_IMG" | ||
729 | $QEMU_IMG measure -O qcow2 -o cluster_size=64k -f qcow2 "$TEST_IMG" | ||
730 | diff --git a/tests/qemu-iotests/191 b/tests/qemu-iotests/191 | ||
731 | index XXXXXXX..XXXXXXX 100755 | ||
732 | --- a/tests/qemu-iotests/191 | ||
733 | +++ b/tests/qemu-iotests/191 | ||
734 | @@ -XXX,XX +XXX,XX @@ echo === Preparing and starting VM === | ||
735 | echo | ||
736 | |||
737 | TEST_IMG="${TEST_IMG}.base" _make_test_img $size | ||
738 | -IMGOPTS=$(_optstr_add "$IMGOPTS" "backing_fmt=$IMGFMT") \ | ||
739 | - TEST_IMG="${TEST_IMG}.mid" _make_test_img -b "${TEST_IMG}.base" | ||
740 | +TEST_IMG="${TEST_IMG}.mid" _make_test_img -o "backing_fmt=$IMGFMT" -b "${TEST_IMG}.base" | ||
741 | _make_test_img -b "${TEST_IMG}.mid" | ||
742 | TEST_IMG="${TEST_IMG}.ovl2" _make_test_img -b "${TEST_IMG}.mid" | ||
743 | |||
744 | diff --git a/tests/qemu-iotests/220 b/tests/qemu-iotests/220 | ||
745 | index XXXXXXX..XXXXXXX 100755 | ||
746 | --- a/tests/qemu-iotests/220 | ||
747 | +++ b/tests/qemu-iotests/220 | ||
748 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
749 | _supported_fmt qcow2 | ||
750 | _supported_proto file | ||
751 | _supported_os Linux | ||
752 | +# To use a different refcount width but 16 bits we need compat=1.1 | ||
753 | +_unsupported_imgopts 'compat=0.10' | ||
754 | |||
755 | echo "== Creating huge file ==" | ||
756 | |||
757 | @@ -XXX,XX +XXX,XX @@ echo "== Creating huge file ==" | ||
758 | # of a HUGE (but very sparse) file. tmpfs works, ext4 does not. | ||
759 | _require_large_file 513T | ||
760 | |||
761 | -IMGOPTS='cluster_size=2M,refcount_bits=1' _make_test_img 513T | ||
762 | +_make_test_img -o 'cluster_size=2M,refcount_bits=1' 513T | ||
763 | |||
764 | echo "== Populating refcounts ==" | ||
765 | # We want an image with 256M refcounts * 2M clusters = 512T referenced. | ||
766 | diff --git a/tests/qemu-iotests/243 b/tests/qemu-iotests/243 | ||
767 | index XXXXXXX..XXXXXXX 100755 | ||
768 | --- a/tests/qemu-iotests/243 | ||
769 | +++ b/tests/qemu-iotests/243 | ||
770 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
771 | _supported_fmt qcow2 | ||
772 | _supported_proto file | ||
773 | _supported_os Linux | ||
774 | +# External data files do not work with compat=0.10 | ||
775 | +_unsupported_imgopts 'compat=0.10' | ||
776 | |||
777 | for mode in off metadata falloc full; do | ||
778 | |||
779 | @@ -XXX,XX +XXX,XX @@ for mode in off metadata falloc full; do | ||
780 | echo "=== preallocation=$mode ===" | ||
781 | echo | ||
782 | |||
783 | - IMGOPTS="preallocation=$mode" _make_test_img 64M | ||
784 | + _make_test_img -o "preallocation=$mode" 64M | ||
785 | |||
786 | printf "File size: " | ||
787 | du -b $TEST_IMG | cut -f1 | ||
788 | @@ -XXX,XX +XXX,XX @@ for mode in off metadata falloc full; do | ||
789 | echo "=== External data file: preallocation=$mode ===" | ||
790 | echo | ||
791 | |||
792 | - IMGOPTS="data_file=$TEST_IMG.data,preallocation=$mode" _make_test_img 64M | ||
793 | + _make_test_img -o "data_file=$TEST_IMG.data,preallocation=$mode" 64M | ||
794 | |||
795 | echo -n "qcow2 file size: " | ||
796 | du -b $TEST_IMG | cut -f1 | ||
797 | diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244 | ||
798 | index XXXXXXX..XXXXXXX 100755 | ||
799 | --- a/tests/qemu-iotests/244 | ||
800 | +++ b/tests/qemu-iotests/244 | ||
801 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
802 | _supported_fmt qcow2 | ||
803 | _supported_proto file | ||
804 | _supported_os Linux | ||
805 | +# External data files do not work with compat=0.10 | ||
806 | +_unsupported_imgopts 'compat=0.10' | ||
807 | |||
808 | echo | ||
809 | echo "=== Create and open image with external data file ===" | ||
810 | echo | ||
811 | |||
812 | echo "With data file name in the image:" | ||
813 | -IMGOPTS="data_file=$TEST_IMG.data" _make_test_img 64M | ||
814 | +_make_test_img -o "data_file=$TEST_IMG.data" 64M | ||
815 | _check_test_img | ||
816 | |||
817 | $QEMU_IO -c "open $TEST_IMG" -c "read -P 0 0 64k" 2>&1 | _filter_qemu_io | _filter_testdir | ||
818 | @@ -XXX,XX +XXX,XX @@ echo | ||
819 | echo "=== Standalone image with external data file (efficient) ===" | ||
820 | echo | ||
821 | |||
822 | -IMGOPTS="data_file=$TEST_IMG.data" _make_test_img 64M | ||
823 | +_make_test_img -o "data_file=$TEST_IMG.data" 64M | ||
824 | |||
825 | echo -n "qcow2 file size before I/O: " | ||
826 | du -b $TEST_IMG | cut -f1 | ||
827 | @@ -XXX,XX +XXX,XX @@ echo | ||
828 | echo "=== Standalone image with external data file (valid raw) ===" | ||
829 | echo | ||
830 | |||
831 | -IMGOPTS="data_file=$TEST_IMG.data,data_file_raw=on" _make_test_img 64M | ||
832 | +_make_test_img -o "data_file=$TEST_IMG.data,data_file_raw=on" 64M | ||
833 | |||
834 | echo -n "qcow2 file size before I/O: " | ||
835 | du -b $TEST_IMG | cut -f1 | ||
836 | @@ -XXX,XX +XXX,XX @@ echo | ||
837 | echo "=== bdrv_co_block_status test for file and offset=0 ===" | ||
838 | echo | ||
839 | |||
840 | -IMGOPTS="data_file=$TEST_IMG.data" _make_test_img 64M | ||
841 | +_make_test_img -o "data_file=$TEST_IMG.data" 64M | ||
842 | |||
843 | $QEMU_IO -c 'write -P 0x11 0 1M' -f $IMGFMT "$TEST_IMG" | _filter_qemu_io | ||
844 | $QEMU_IO -c 'read -P 0x11 0 1M' -f $IMGFMT "$TEST_IMG" | _filter_qemu_io | ||
845 | diff --git a/tests/qemu-iotests/250 b/tests/qemu-iotests/250 | ||
846 | index XXXXXXX..XXXXXXX 100755 | ||
847 | --- a/tests/qemu-iotests/250 | ||
848 | +++ b/tests/qemu-iotests/250 | ||
849 | @@ -XXX,XX +XXX,XX @@ disk_usage() | ||
850 | } | ||
851 | |||
852 | size=2100M | ||
853 | -IMGOPTS="cluster_size=1M,preallocation=metadata" | ||
854 | |||
855 | -_make_test_img $size | ||
856 | +_make_test_img -o "cluster_size=1M,preallocation=metadata" $size | ||
857 | $QEMU_IO -c 'discard 0 10M' -c 'discard 2090M 10M' \ | ||
858 | -c 'write 2090M 10M' -c 'write 0 10M' "$TEST_IMG" | _filter_qemu_io | ||
859 | |||
860 | diff --git a/tests/qemu-iotests/265 b/tests/qemu-iotests/265 | ||
861 | index XXXXXXX..XXXXXXX 100755 | ||
862 | --- a/tests/qemu-iotests/265 | ||
863 | +++ b/tests/qemu-iotests/265 | ||
864 | @@ -XXX,XX +XXX,XX @@ _supported_os Linux | ||
865 | echo '--- Writing to the image ---' | ||
866 | |||
867 | # Reduce cluster size so we get more and quicker I/O | ||
868 | -IMGOPTS='cluster_size=4096' _make_test_img 1M | ||
869 | +_make_test_img -o 'cluster_size=4096' 1M | ||
870 | (for ((kb = 1024 - 4; kb >= 0; kb -= 4)); do \ | ||
871 | echo "aio_write -P 42 $((kb + 1))k 2k"; \ | ||
872 | done) \ | ||
873 | -- | ||
874 | 2.24.1 | ||
875 | |||
876 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
2 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
3 | Message-id: 20191107163708.833192-13-mreitz@redhat.com | ||
4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
5 | --- | ||
6 | tests/qemu-iotests/071 | 4 ++-- | ||
7 | tests/qemu-iotests/174 | 2 +- | ||
8 | tests/qemu-iotests/178 | 4 ++-- | ||
9 | tests/qemu-iotests/197 | 4 ++-- | ||
10 | tests/qemu-iotests/215 | 4 ++-- | ||
11 | 5 files changed, 9 insertions(+), 9 deletions(-) | ||
12 | 1 | ||
13 | diff --git a/tests/qemu-iotests/071 b/tests/qemu-iotests/071 | ||
14 | index XXXXXXX..XXXXXXX 100755 | ||
15 | --- a/tests/qemu-iotests/071 | ||
16 | +++ b/tests/qemu-iotests/071 | ||
17 | @@ -XXX,XX +XXX,XX @@ echo | ||
18 | echo "=== Testing blkverify through filename ===" | ||
19 | echo | ||
20 | |||
21 | -TEST_IMG="$TEST_IMG.base" IMGOPTS="" IMGFMT="raw" _make_test_img $IMG_SIZE |\ | ||
22 | +TEST_IMG="$TEST_IMG.base" IMGFMT="raw" _make_test_img --no-opts $IMG_SIZE |\ | ||
23 | _filter_imgfmt | ||
24 | _make_test_img $IMG_SIZE | ||
25 | $QEMU_IO -c "open -o driver=raw,file.driver=blkverify,file.raw.filename=$TEST_IMG.base $TEST_IMG" \ | ||
26 | @@ -XXX,XX +XXX,XX @@ echo | ||
27 | echo "=== Testing blkverify through file blockref ===" | ||
28 | echo | ||
29 | |||
30 | -TEST_IMG="$TEST_IMG.base" IMGOPTS="" IMGFMT="raw" _make_test_img $IMG_SIZE |\ | ||
31 | +TEST_IMG="$TEST_IMG.base" IMGFMT="raw" _make_test_img --no-opts $IMG_SIZE |\ | ||
32 | _filter_imgfmt | ||
33 | _make_test_img $IMG_SIZE | ||
34 | $QEMU_IO -c "open -o driver=raw,file.driver=blkverify,file.raw.filename=$TEST_IMG.base,file.test.driver=$IMGFMT,file.test.file.filename=$TEST_IMG" \ | ||
35 | diff --git a/tests/qemu-iotests/174 b/tests/qemu-iotests/174 | ||
36 | index XXXXXXX..XXXXXXX 100755 | ||
37 | --- a/tests/qemu-iotests/174 | ||
38 | +++ b/tests/qemu-iotests/174 | ||
39 | @@ -XXX,XX +XXX,XX @@ _unsupported_fmt raw | ||
40 | |||
41 | |||
42 | size=256K | ||
43 | -IMGFMT=raw IMGKEYSECRET= IMGOPTS= _make_test_img $size | _filter_imgfmt | ||
44 | +IMGFMT=raw IMGKEYSECRET= _make_test_img --no-opts $size | _filter_imgfmt | ||
45 | |||
46 | echo | ||
47 | echo "== reading wrong format should fail ==" | ||
48 | diff --git a/tests/qemu-iotests/178 b/tests/qemu-iotests/178 | ||
49 | index XXXXXXX..XXXXXXX 100755 | ||
50 | --- a/tests/qemu-iotests/178 | ||
51 | +++ b/tests/qemu-iotests/178 | ||
52 | @@ -XXX,XX +XXX,XX @@ $QEMU_IMG measure -O foo "$TEST_IMG" # unknown image file format | ||
53 | |||
54 | make_test_img_with_fmt() { | ||
55 | # Shadow global variables within this function | ||
56 | - local IMGFMT="$1" IMGOPTS="" | ||
57 | - _make_test_img "$2" | ||
58 | + local IMGFMT="$1" | ||
59 | + _make_test_img --no-opts "$2" | ||
60 | } | ||
61 | |||
62 | qemu_io_with_fmt() { | ||
63 | diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197 | ||
64 | index XXXXXXX..XXXXXXX 100755 | ||
65 | --- a/tests/qemu-iotests/197 | ||
66 | +++ b/tests/qemu-iotests/197 | ||
67 | @@ -XXX,XX +XXX,XX @@ if [ "$IMGFMT" = "vpc" ]; then | ||
68 | fi | ||
69 | _make_test_img 4G | ||
70 | $QEMU_IO -c "write -P 55 3G 1k" "$TEST_IMG" | _filter_qemu_io | ||
71 | -IMGPROTO=file IMGFMT=qcow2 IMGOPTS= TEST_IMG_FILE="$TEST_WRAP" \ | ||
72 | - _make_test_img -F "$IMGFMT" -b "$TEST_IMG" | _filter_img_create | ||
73 | +IMGPROTO=file IMGFMT=qcow2 TEST_IMG_FILE="$TEST_WRAP" \ | ||
74 | + _make_test_img --no-opts -F "$IMGFMT" -b "$TEST_IMG" | _filter_img_create | ||
75 | $QEMU_IO -f qcow2 -c "write -z -u 1M 64k" "$TEST_WRAP" | _filter_qemu_io | ||
76 | |||
77 | # Ensure that a read of two clusters, but where one is already allocated, | ||
78 | diff --git a/tests/qemu-iotests/215 b/tests/qemu-iotests/215 | ||
79 | index XXXXXXX..XXXXXXX 100755 | ||
80 | --- a/tests/qemu-iotests/215 | ||
81 | +++ b/tests/qemu-iotests/215 | ||
82 | @@ -XXX,XX +XXX,XX @@ if [ "$IMGFMT" = "vpc" ]; then | ||
83 | fi | ||
84 | _make_test_img 4G | ||
85 | $QEMU_IO -c "write -P 55 3G 1k" "$TEST_IMG" | _filter_qemu_io | ||
86 | -IMGPROTO=file IMGFMT=qcow2 IMGOPTS= TEST_IMG_FILE="$TEST_WRAP" \ | ||
87 | - _make_test_img -F "$IMGFMT" -b "$TEST_IMG" | _filter_img_create | ||
88 | +IMGPROTO=file IMGFMT=qcow2 TEST_IMG_FILE="$TEST_WRAP" \ | ||
89 | + _make_test_img --no-opts -F "$IMGFMT" -b "$TEST_IMG" | _filter_img_create | ||
90 | $QEMU_IO -f qcow2 -c "write -z -u 1M 64k" "$TEST_WRAP" | _filter_qemu_io | ||
91 | |||
92 | # Ensure that a read of two clusters, but where one is already allocated, | ||
93 | -- | ||
94 | 2.24.1 | ||
95 | |||
96 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Overwriting IMGOPTS means ignoring all user-supplied options, which is | ||
2 | not what we want. Replace the current IMGOPTS use by a new BACKING_FILE | ||
3 | variable. | ||
4 | 1 | ||
5 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
6 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
7 | Message-id: 20191107163708.833192-14-mreitz@redhat.com | ||
8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
9 | --- | ||
10 | tests/qemu-iotests/267 | 12 ++++++++---- | ||
11 | 1 file changed, 8 insertions(+), 4 deletions(-) | ||
12 | |||
13 | diff --git a/tests/qemu-iotests/267 b/tests/qemu-iotests/267 | ||
14 | index XXXXXXX..XXXXXXX 100755 | ||
15 | --- a/tests/qemu-iotests/267 | ||
16 | +++ b/tests/qemu-iotests/267 | ||
17 | @@ -XXX,XX +XXX,XX @@ size=128M | ||
18 | |||
19 | run_test() | ||
20 | { | ||
21 | - _make_test_img $size | ||
22 | + if [ -n "$BACKING_FILE" ]; then | ||
23 | + _make_test_img -b "$BACKING_FILE" $size | ||
24 | + else | ||
25 | + _make_test_img $size | ||
26 | + fi | ||
27 | printf "savevm snap0\ninfo snapshots\nloadvm snap0\n" | run_qemu "$@" | _filter_date | ||
28 | } | ||
29 | |||
30 | @@ -XXX,XX +XXX,XX @@ echo | ||
31 | |||
32 | TEST_IMG="$TEST_IMG.base" _make_test_img $size | ||
33 | |||
34 | -IMGOPTS="backing_file=$TEST_IMG.base" \ | ||
35 | +BACKING_FILE="$TEST_IMG.base" \ | ||
36 | run_test -blockdev driver=file,filename="$TEST_IMG.base",node-name=backing-file \ | ||
37 | -blockdev driver=file,filename="$TEST_IMG",node-name=file \ | ||
38 | -blockdev driver=$IMGFMT,file=file,backing=backing-file,node-name=fmt | ||
39 | |||
40 | -IMGOPTS="backing_file=$TEST_IMG.base" \ | ||
41 | +BACKING_FILE="$TEST_IMG.base" \ | ||
42 | run_test -blockdev driver=file,filename="$TEST_IMG.base",node-name=backing-file \ | ||
43 | -blockdev driver=$IMGFMT,file=backing-file,node-name=backing-fmt \ | ||
44 | -blockdev driver=file,filename="$TEST_IMG",node-name=file \ | ||
45 | @@ -XXX,XX +XXX,XX @@ echo | ||
46 | echo "=== -blockdev with NBD server on the backing file ===" | ||
47 | echo | ||
48 | |||
49 | -IMGOPTS="backing_file=$TEST_IMG.base" _make_test_img $size | ||
50 | +_make_test_img -b "$TEST_IMG.base" $size | ||
51 | cat <<EOF | | ||
52 | nbd_server_start unix:$SOCK_DIR/nbd | ||
53 | nbd_server_add -w backing-fmt | ||
54 | -- | ||
55 | 2.24.1 | ||
56 | |||
57 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Use _make_test_img whenever possible. This way, we will not ignore | ||
2 | user-specified image options. | ||
3 | 1 | ||
4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
5 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
6 | Message-id: 20191107163708.833192-15-mreitz@redhat.com | ||
7 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
8 | --- | ||
9 | tests/qemu-iotests/094 | 2 +- | ||
10 | tests/qemu-iotests/111 | 3 +-- | ||
11 | tests/qemu-iotests/123 | 2 +- | ||
12 | tests/qemu-iotests/153 | 2 +- | ||
13 | tests/qemu-iotests/200 | 4 ++-- | ||
14 | 5 files changed, 6 insertions(+), 7 deletions(-) | ||
15 | |||
16 | diff --git a/tests/qemu-iotests/094 b/tests/qemu-iotests/094 | ||
17 | index XXXXXXX..XXXXXXX 100755 | ||
18 | --- a/tests/qemu-iotests/094 | ||
19 | +++ b/tests/qemu-iotests/094 | ||
20 | @@ -XXX,XX +XXX,XX @@ _supported_proto nbd | ||
21 | _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" | ||
22 | |||
23 | _make_test_img 64M | ||
24 | -$QEMU_IMG create -f $IMGFMT "$TEST_DIR/source.$IMGFMT" 64M | _filter_img_create | ||
25 | +TEST_IMG_FILE="$TEST_DIR/source.$IMGFMT" IMGPROTO=file _make_test_img 64M | ||
26 | |||
27 | _launch_qemu -drive if=none,id=src,file="$TEST_DIR/source.$IMGFMT",format=raw \ | ||
28 | -nodefaults | ||
29 | diff --git a/tests/qemu-iotests/111 b/tests/qemu-iotests/111 | ||
30 | index XXXXXXX..XXXXXXX 100755 | ||
31 | --- a/tests/qemu-iotests/111 | ||
32 | +++ b/tests/qemu-iotests/111 | ||
33 | @@ -XXX,XX +XXX,XX @@ _supported_fmt qed qcow qcow2 vmdk | ||
34 | _supported_proto file | ||
35 | _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" | ||
36 | |||
37 | -$QEMU_IMG create -f $IMGFMT -b "$TEST_IMG.inexistent" "$TEST_IMG" 2>&1 \ | ||
38 | - | _filter_testdir | _filter_imgfmt | ||
39 | +_make_test_img -b "$TEST_IMG.inexistent" | ||
40 | |||
41 | # success, all done | ||
42 | echo '*** done' | ||
43 | diff --git a/tests/qemu-iotests/123 b/tests/qemu-iotests/123 | ||
44 | index XXXXXXX..XXXXXXX 100755 | ||
45 | --- a/tests/qemu-iotests/123 | ||
46 | +++ b/tests/qemu-iotests/123 | ||
47 | @@ -XXX,XX +XXX,XX @@ _supported_os Linux | ||
48 | SRC_IMG="$TEST_DIR/source.$IMGFMT" | ||
49 | |||
50 | _make_test_img 1M | ||
51 | -$QEMU_IMG create -f $IMGFMT "$SRC_IMG" 1M | _filter_img_create | ||
52 | +TEST_IMG_FILE=$SRC_IMG IMGPROTO=file _make_test_img 1M | ||
53 | |||
54 | $QEMU_IO -c 'write -P 42 0 1M' "$SRC_IMG" | _filter_qemu_io | ||
55 | |||
56 | diff --git a/tests/qemu-iotests/153 b/tests/qemu-iotests/153 | ||
57 | index XXXXXXX..XXXXXXX 100755 | ||
58 | --- a/tests/qemu-iotests/153 | ||
59 | +++ b/tests/qemu-iotests/153 | ||
60 | @@ -XXX,XX +XXX,XX @@ for opts1 in "" "read-only=on" "read-only=on,force-share=on"; do | ||
61 | |||
62 | echo | ||
63 | echo "== Creating test image ==" | ||
64 | - $QEMU_IMG create -f $IMGFMT "${TEST_IMG}" -b ${TEST_IMG}.base | _filter_img_create | ||
65 | + _make_test_img -b "${TEST_IMG}.base" | ||
66 | |||
67 | echo | ||
68 | echo "== Launching QEMU, opts: '$opts1' ==" | ||
69 | diff --git a/tests/qemu-iotests/200 b/tests/qemu-iotests/200 | ||
70 | index XXXXXXX..XXXXXXX 100755 | ||
71 | --- a/tests/qemu-iotests/200 | ||
72 | +++ b/tests/qemu-iotests/200 | ||
73 | @@ -XXX,XX +XXX,XX @@ _supported_proto file | ||
74 | BACKING_IMG="${TEST_DIR}/backing.img" | ||
75 | TEST_IMG="${TEST_DIR}/test.img" | ||
76 | |||
77 | -${QEMU_IMG} create -f $IMGFMT "${BACKING_IMG}" 512M | _filter_img_create | ||
78 | -${QEMU_IMG} create -f $IMGFMT -F $IMGFMT "${TEST_IMG}" -b "${BACKING_IMG}" 512M | _filter_img_create | ||
79 | +TEST_IMG="$BACKING_IMG" _make_test_img 512M | ||
80 | +_make_test_img -F $IMGFMT -b "$BACKING_IMG" 512M | ||
81 | |||
82 | ${QEMU_IO} -c "write -P 0xa5 512 300M" "${BACKING_IMG}" | _filter_qemu_io | ||
83 | |||
84 | -- | ||
85 | 2.24.1 | ||
86 | |||
87 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Just rm will not delete external data files. Use _rm_test_img every | ||
2 | time we delete a test image. | ||
3 | 1 | ||
4 | (In the process, clean up the indentation of every _cleanup() this patch | ||
5 | touches.) | ||
6 | |||
7 | ((Also, use quotes consistently. I am happy to see unquoted instances | ||
8 | like "rm -rf $TEST_DIR/..." go.)) | ||
9 | |||
10 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
11 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
12 | Message-id: 20191107163708.833192-16-mreitz@redhat.com | ||
13 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
14 | --- | ||
15 | tests/qemu-iotests/019 | 6 +++--- | ||
16 | tests/qemu-iotests/020 | 6 +++--- | ||
17 | tests/qemu-iotests/024 | 10 +++++----- | ||
18 | tests/qemu-iotests/028 | 2 +- | ||
19 | tests/qemu-iotests/029 | 2 +- | ||
20 | tests/qemu-iotests/043 | 4 +++- | ||
21 | tests/qemu-iotests/048 | 2 +- | ||
22 | tests/qemu-iotests/050 | 4 ++-- | ||
23 | tests/qemu-iotests/053 | 4 ++-- | ||
24 | tests/qemu-iotests/058 | 2 +- | ||
25 | tests/qemu-iotests/059 | 2 +- | ||
26 | tests/qemu-iotests/061 | 2 +- | ||
27 | tests/qemu-iotests/063 | 6 ++++-- | ||
28 | tests/qemu-iotests/069 | 2 +- | ||
29 | tests/qemu-iotests/074 | 2 +- | ||
30 | tests/qemu-iotests/080 | 2 +- | ||
31 | tests/qemu-iotests/081 | 6 +++--- | ||
32 | tests/qemu-iotests/085 | 9 ++++++--- | ||
33 | tests/qemu-iotests/088 | 2 +- | ||
34 | tests/qemu-iotests/092 | 2 +- | ||
35 | tests/qemu-iotests/094 | 2 +- | ||
36 | tests/qemu-iotests/095 | 5 +++-- | ||
37 | tests/qemu-iotests/099 | 7 ++++--- | ||
38 | tests/qemu-iotests/109 | 4 ++-- | ||
39 | tests/qemu-iotests/110 | 4 ++-- | ||
40 | tests/qemu-iotests/122 | 6 ++++-- | ||
41 | tests/qemu-iotests/123 | 2 +- | ||
42 | tests/qemu-iotests/141 | 4 +++- | ||
43 | tests/qemu-iotests/142 | 2 +- | ||
44 | tests/qemu-iotests/144 | 4 +++- | ||
45 | tests/qemu-iotests/153 | 10 +++------- | ||
46 | tests/qemu-iotests/156 | 8 ++++++-- | ||
47 | tests/qemu-iotests/159 | 2 +- | ||
48 | tests/qemu-iotests/160 | 3 ++- | ||
49 | tests/qemu-iotests/161 | 4 ++-- | ||
50 | tests/qemu-iotests/170 | 2 +- | ||
51 | tests/qemu-iotests/172 | 6 +++--- | ||
52 | tests/qemu-iotests/173 | 3 ++- | ||
53 | tests/qemu-iotests/178 | 2 +- | ||
54 | tests/qemu-iotests/182 | 2 +- | ||
55 | tests/qemu-iotests/183 | 2 +- | ||
56 | tests/qemu-iotests/185 | 4 ++-- | ||
57 | tests/qemu-iotests/187 | 6 +++--- | ||
58 | tests/qemu-iotests/190 | 2 +- | ||
59 | tests/qemu-iotests/191 | 6 +++--- | ||
60 | tests/qemu-iotests/195 | 2 +- | ||
61 | tests/qemu-iotests/197 | 2 +- | ||
62 | tests/qemu-iotests/200 | 3 ++- | ||
63 | tests/qemu-iotests/215 | 2 +- | ||
64 | tests/qemu-iotests/225 | 2 +- | ||
65 | tests/qemu-iotests/229 | 3 ++- | ||
66 | tests/qemu-iotests/232 | 4 +++- | ||
67 | tests/qemu-iotests/243 | 2 +- | ||
68 | tests/qemu-iotests/244 | 4 ++-- | ||
69 | tests/qemu-iotests/247 | 4 +++- | ||
70 | tests/qemu-iotests/249 | 4 ++-- | ||
71 | tests/qemu-iotests/252 | 2 +- | ||
72 | 57 files changed, 118 insertions(+), 95 deletions(-) | ||
73 | |||
74 | diff --git a/tests/qemu-iotests/019 b/tests/qemu-iotests/019 | ||
75 | index XXXXXXX..XXXXXXX 100755 | ||
76 | --- a/tests/qemu-iotests/019 | ||
77 | +++ b/tests/qemu-iotests/019 | ||
78 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
79 | |||
80 | _cleanup() | ||
81 | { | ||
82 | - _cleanup_test_img | ||
83 | - rm -f "$TEST_IMG.base" | ||
84 | - rm -f "$TEST_IMG.orig" | ||
85 | + _cleanup_test_img | ||
86 | + _rm_test_img "$TEST_IMG.base" | ||
87 | + _rm_test_img "$TEST_IMG.orig" | ||
88 | } | ||
89 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
90 | |||
91 | diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020 | ||
92 | index XXXXXXX..XXXXXXX 100755 | ||
93 | --- a/tests/qemu-iotests/020 | ||
94 | +++ b/tests/qemu-iotests/020 | ||
95 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
96 | |||
97 | _cleanup() | ||
98 | { | ||
99 | - _cleanup_test_img | ||
100 | - rm -f "$TEST_IMG.base" | ||
101 | - rm -f "$TEST_IMG.orig" | ||
102 | + _cleanup_test_img | ||
103 | + _rm_test_img "$TEST_IMG.base" | ||
104 | + _rm_test_img "$TEST_IMG.orig" | ||
105 | } | ||
106 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
107 | |||
108 | diff --git a/tests/qemu-iotests/024 b/tests/qemu-iotests/024 | ||
109 | index XXXXXXX..XXXXXXX 100755 | ||
110 | --- a/tests/qemu-iotests/024 | ||
111 | +++ b/tests/qemu-iotests/024 | ||
112 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
113 | _cleanup() | ||
114 | { | ||
115 | _cleanup_test_img | ||
116 | - rm -f "$TEST_DIR/t.$IMGFMT.base_old" | ||
117 | - rm -f "$TEST_DIR/t.$IMGFMT.base_new" | ||
118 | + _rm_test_img "$TEST_DIR/t.$IMGFMT.base_old" | ||
119 | + _rm_test_img "$TEST_DIR/t.$IMGFMT.base_new" | ||
120 | |||
121 | - rm -f "$TEST_DIR/subdir/t.$IMGFMT" | ||
122 | - rm -f "$TEST_DIR/subdir/t.$IMGFMT.base_old" | ||
123 | - rm -f "$TEST_DIR/subdir/t.$IMGFMT.base_new" | ||
124 | + _rm_test_img "$TEST_DIR/subdir/t.$IMGFMT" | ||
125 | + _rm_test_img "$TEST_DIR/subdir/t.$IMGFMT.base_old" | ||
126 | + _rm_test_img "$TEST_DIR/subdir/t.$IMGFMT.base_new" | ||
127 | rmdir "$TEST_DIR/subdir" 2> /dev/null | ||
128 | } | ||
129 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
130 | diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028 | ||
131 | index XXXXXXX..XXXXXXX 100755 | ||
132 | --- a/tests/qemu-iotests/028 | ||
133 | +++ b/tests/qemu-iotests/028 | ||
134 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
135 | _cleanup() | ||
136 | { | ||
137 | _cleanup_qemu | ||
138 | - rm -f "${TEST_IMG}.copy" | ||
139 | + _rm_test_img "${TEST_IMG}.copy" | ||
140 | _cleanup_test_img | ||
141 | } | ||
142 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
143 | diff --git a/tests/qemu-iotests/029 b/tests/qemu-iotests/029 | ||
144 | index XXXXXXX..XXXXXXX 100755 | ||
145 | --- a/tests/qemu-iotests/029 | ||
146 | +++ b/tests/qemu-iotests/029 | ||
147 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
148 | |||
149 | _cleanup() | ||
150 | { | ||
151 | - rm -f $TEST_IMG.snap | ||
152 | + _rm_test_img "$TEST_IMG.snap" | ||
153 | _cleanup_test_img | ||
154 | } | ||
155 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
156 | diff --git a/tests/qemu-iotests/043 b/tests/qemu-iotests/043 | ||
157 | index XXXXXXX..XXXXXXX 100755 | ||
158 | --- a/tests/qemu-iotests/043 | ||
159 | +++ b/tests/qemu-iotests/043 | ||
160 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
161 | _cleanup() | ||
162 | { | ||
163 | _cleanup_test_img | ||
164 | - rm -f "$TEST_IMG".[123].base | ||
165 | + for img in "$TEST_IMG".[123].base; do | ||
166 | + _rm_test_img "$img" | ||
167 | + done | ||
168 | } | ||
169 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
170 | |||
171 | diff --git a/tests/qemu-iotests/048 b/tests/qemu-iotests/048 | ||
172 | index XXXXXXX..XXXXXXX 100755 | ||
173 | --- a/tests/qemu-iotests/048 | ||
174 | +++ b/tests/qemu-iotests/048 | ||
175 | @@ -XXX,XX +XXX,XX @@ _cleanup() | ||
176 | { | ||
177 | echo "Cleanup" | ||
178 | _cleanup_test_img | ||
179 | - rm "${TEST_IMG_FILE2}" | ||
180 | + _rm_test_img "${TEST_IMG_FILE2}" | ||
181 | } | ||
182 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
183 | |||
184 | diff --git a/tests/qemu-iotests/050 b/tests/qemu-iotests/050 | ||
185 | index XXXXXXX..XXXXXXX 100755 | ||
186 | --- a/tests/qemu-iotests/050 | ||
187 | +++ b/tests/qemu-iotests/050 | ||
188 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
189 | _cleanup() | ||
190 | { | ||
191 | _cleanup_test_img | ||
192 | - rm -f "$TEST_IMG.old" | ||
193 | - rm -f "$TEST_IMG.new" | ||
194 | + _rm_test_img "$TEST_IMG.old" | ||
195 | + _rm_test_img "$TEST_IMG.new" | ||
196 | } | ||
197 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
198 | |||
199 | diff --git a/tests/qemu-iotests/053 b/tests/qemu-iotests/053 | ||
200 | index XXXXXXX..XXXXXXX 100755 | ||
201 | --- a/tests/qemu-iotests/053 | ||
202 | +++ b/tests/qemu-iotests/053 | ||
203 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
204 | |||
205 | _cleanup() | ||
206 | { | ||
207 | - rm -f "$TEST_IMG.orig" | ||
208 | - _cleanup_test_img | ||
209 | + _rm_test_img "$TEST_IMG.orig" | ||
210 | + _cleanup_test_img | ||
211 | } | ||
212 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
213 | |||
214 | diff --git a/tests/qemu-iotests/058 b/tests/qemu-iotests/058 | ||
215 | index XXXXXXX..XXXXXXX 100755 | ||
216 | --- a/tests/qemu-iotests/058 | ||
217 | +++ b/tests/qemu-iotests/058 | ||
218 | @@ -XXX,XX +XXX,XX @@ _cleanup() | ||
219 | { | ||
220 | nbd_server_stop | ||
221 | _cleanup_test_img | ||
222 | - rm -f "$converted_image" | ||
223 | + _rm_test_img "$converted_image" | ||
224 | } | ||
225 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
226 | |||
227 | diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059 | ||
228 | index XXXXXXX..XXXXXXX 100755 | ||
229 | --- a/tests/qemu-iotests/059 | ||
230 | +++ b/tests/qemu-iotests/059 | ||
231 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
232 | _cleanup() | ||
233 | { | ||
234 | _cleanup_test_img | ||
235 | - rm -f "$TEST_IMG.qcow2" | ||
236 | + IMGFMT=qcow2 _rm_test_img "$TEST_IMG.qcow2" | ||
237 | } | ||
238 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
239 | |||
240 | diff --git a/tests/qemu-iotests/061 b/tests/qemu-iotests/061 | ||
241 | index XXXXXXX..XXXXXXX 100755 | ||
242 | --- a/tests/qemu-iotests/061 | ||
243 | +++ b/tests/qemu-iotests/061 | ||
244 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
245 | _cleanup() | ||
246 | { | ||
247 | _cleanup_test_img | ||
248 | - rm -f $TEST_IMG.data | ||
249 | + _rm_test_img "$TEST_IMG.data" | ||
250 | } | ||
251 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
252 | |||
253 | diff --git a/tests/qemu-iotests/063 b/tests/qemu-iotests/063 | ||
254 | index XXXXXXX..XXXXXXX 100755 | ||
255 | --- a/tests/qemu-iotests/063 | ||
256 | +++ b/tests/qemu-iotests/063 | ||
257 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
258 | |||
259 | _cleanup() | ||
260 | { | ||
261 | - _cleanup_test_img | ||
262 | - rm -f "$TEST_IMG.orig" "$TEST_IMG.raw1" "$TEST_IMG.raw2" | ||
263 | + _cleanup_test_img | ||
264 | + for img in "$TEST_IMG".{orig,raw1,raw2,target}; do | ||
265 | + _rm_test_img "$img" | ||
266 | + done | ||
267 | } | ||
268 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
269 | |||
270 | diff --git a/tests/qemu-iotests/069 b/tests/qemu-iotests/069 | ||
271 | index XXXXXXX..XXXXXXX 100755 | ||
272 | --- a/tests/qemu-iotests/069 | ||
273 | +++ b/tests/qemu-iotests/069 | ||
274 | @@ -XXX,XX +XXX,XX @@ echo "=== Creating an image with a backing file and deleting that file ===" | ||
275 | echo | ||
276 | TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE | ||
277 | _make_test_img -b "$TEST_IMG.base" $IMG_SIZE | ||
278 | -rm -f "$TEST_IMG.base" | ||
279 | +_rm_test_img "$TEST_IMG.base" | ||
280 | # Just open the image and close it right again (this should print an error message) | ||
281 | $QEMU_IO -c quit "$TEST_IMG" 2>&1 | _filter_testdir | _filter_imgfmt | ||
282 | |||
283 | diff --git a/tests/qemu-iotests/074 b/tests/qemu-iotests/074 | ||
284 | index XXXXXXX..XXXXXXX 100755 | ||
285 | --- a/tests/qemu-iotests/074 | ||
286 | +++ b/tests/qemu-iotests/074 | ||
287 | @@ -XXX,XX +XXX,XX @@ _cleanup() | ||
288 | { | ||
289 | echo "Cleanup" | ||
290 | _cleanup_test_img | ||
291 | - rm "${TEST_IMG2}" | ||
292 | + _rm_test_img "${TEST_IMG2}" | ||
293 | rm -f "$TEST_DIR/blkdebug.conf" | ||
294 | } | ||
295 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
296 | diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 | ||
297 | index XXXXXXX..XXXXXXX 100755 | ||
298 | --- a/tests/qemu-iotests/080 | ||
299 | +++ b/tests/qemu-iotests/080 | ||
300 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
301 | |||
302 | _cleanup() | ||
303 | { | ||
304 | - rm -f $TEST_IMG.snap | ||
305 | + _rm_test_img "$TEST_IMG.snap" | ||
306 | _cleanup_test_img | ||
307 | } | ||
308 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
309 | diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081 | ||
310 | index XXXXXXX..XXXXXXX 100755 | ||
311 | --- a/tests/qemu-iotests/081 | ||
312 | +++ b/tests/qemu-iotests/081 | ||
313 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
314 | |||
315 | _cleanup() | ||
316 | { | ||
317 | - rm -rf $TEST_DIR/1.raw | ||
318 | - rm -rf $TEST_DIR/2.raw | ||
319 | - rm -rf $TEST_DIR/3.raw | ||
320 | + _rm_test_img "$TEST_DIR/1.raw" | ||
321 | + _rm_test_img "$TEST_DIR/2.raw" | ||
322 | + _rm_test_img "$TEST_DIR/3.raw" | ||
323 | } | ||
324 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
325 | |||
326 | diff --git a/tests/qemu-iotests/085 b/tests/qemu-iotests/085 | ||
327 | index XXXXXXX..XXXXXXX 100755 | ||
328 | --- a/tests/qemu-iotests/085 | ||
329 | +++ b/tests/qemu-iotests/085 | ||
330 | @@ -XXX,XX +XXX,XX @@ _cleanup() | ||
331 | _cleanup_qemu | ||
332 | for i in $(seq 1 ${SNAPSHOTS}) | ||
333 | do | ||
334 | - rm -f "${TEST_DIR}/${i}-${snapshot_virt0}" | ||
335 | - rm -f "${TEST_DIR}/${i}-${snapshot_virt1}" | ||
336 | + _rm_test_img "${TEST_DIR}/${i}-${snapshot_virt0}" | ||
337 | + _rm_test_img "${TEST_DIR}/${i}-${snapshot_virt1}" | ||
338 | + done | ||
339 | + for img in "${TEST_IMG}".{1,2,base} | ||
340 | + do | ||
341 | + _rm_test_img "$img" | ||
342 | done | ||
343 | - rm -f "${TEST_IMG}" "${TEST_IMG}.1" "${TEST_IMG}.2" "${TEST_IMG}.base" | ||
344 | |||
345 | } | ||
346 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
347 | diff --git a/tests/qemu-iotests/088 b/tests/qemu-iotests/088 | ||
348 | index XXXXXXX..XXXXXXX 100755 | ||
349 | --- a/tests/qemu-iotests/088 | ||
350 | +++ b/tests/qemu-iotests/088 | ||
351 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
352 | |||
353 | _cleanup() | ||
354 | { | ||
355 | - rm -f $TEST_IMG.snap | ||
356 | + _rm_test_img "$TEST_IMG.snap" | ||
357 | _cleanup_test_img | ||
358 | } | ||
359 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
360 | diff --git a/tests/qemu-iotests/092 b/tests/qemu-iotests/092 | ||
361 | index XXXXXXX..XXXXXXX 100755 | ||
362 | --- a/tests/qemu-iotests/092 | ||
363 | +++ b/tests/qemu-iotests/092 | ||
364 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
365 | |||
366 | _cleanup() | ||
367 | { | ||
368 | - rm -f $TEST_IMG.snap | ||
369 | + _rm_test_img "$TEST_IMG.snap" | ||
370 | _cleanup_test_img | ||
371 | } | ||
372 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
373 | diff --git a/tests/qemu-iotests/094 b/tests/qemu-iotests/094 | ||
374 | index XXXXXXX..XXXXXXX 100755 | ||
375 | --- a/tests/qemu-iotests/094 | ||
376 | +++ b/tests/qemu-iotests/094 | ||
377 | @@ -XXX,XX +XXX,XX @@ _cleanup() | ||
378 | { | ||
379 | _cleanup_qemu | ||
380 | _cleanup_test_img | ||
381 | - rm -f "$TEST_DIR/source.$IMGFMT" | ||
382 | + _rm_test_img "$TEST_DIR/source.$IMGFMT" | ||
383 | } | ||
384 | |||
385 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
386 | diff --git a/tests/qemu-iotests/095 b/tests/qemu-iotests/095 | ||
387 | index XXXXXXX..XXXXXXX 100755 | ||
388 | --- a/tests/qemu-iotests/095 | ||
389 | +++ b/tests/qemu-iotests/095 | ||
390 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
391 | _cleanup() | ||
392 | { | ||
393 | _cleanup_qemu | ||
394 | - rm -f "${TEST_IMG}.base" "${TEST_IMG}.snp1" | ||
395 | - _cleanup_test_img | ||
396 | + _rm_test_img "${TEST_IMG}.base" | ||
397 | + _rm_test_img "${TEST_IMG}.snp1" | ||
398 | + _cleanup_test_img | ||
399 | } | ||
400 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
401 | |||
402 | diff --git a/tests/qemu-iotests/099 b/tests/qemu-iotests/099 | ||
403 | index XXXXXXX..XXXXXXX 100755 | ||
404 | --- a/tests/qemu-iotests/099 | ||
405 | +++ b/tests/qemu-iotests/099 | ||
406 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
407 | |||
408 | _cleanup() | ||
409 | { | ||
410 | - _cleanup_test_img | ||
411 | + _cleanup_test_img | ||
412 | + _rm_test_img "$TEST_IMG.compare" | ||
413 | + rm -f "$TEST_DIR/blkdebug.conf" | ||
414 | + | ||
415 | } | ||
416 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
417 | |||
418 | @@ -XXX,XX +XXX,XX @@ echo | ||
419 | test_qemu "file.driver=blkdebug,file.image.filename=$TEST_IMG" | ||
420 | |||
421 | |||
422 | -rm -f "$TEST_IMG.compare" "$TEST_DIR/blkdebug.conf" | ||
423 | - | ||
424 | # success, all done | ||
425 | echo "*** done" | ||
426 | rm -f $seq.full | ||
427 | diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109 | ||
428 | index XXXXXXX..XXXXXXX 100755 | ||
429 | --- a/tests/qemu-iotests/109 | ||
430 | +++ b/tests/qemu-iotests/109 | ||
431 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
432 | _cleanup() | ||
433 | { | ||
434 | _cleanup_qemu | ||
435 | - rm -f $TEST_IMG.src | ||
436 | - _cleanup_test_img | ||
437 | + _rm_test_img "$TEST_IMG.src" | ||
438 | + _cleanup_test_img | ||
439 | } | ||
440 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
441 | |||
442 | diff --git a/tests/qemu-iotests/110 b/tests/qemu-iotests/110 | ||
443 | index XXXXXXX..XXXXXXX 100755 | ||
444 | --- a/tests/qemu-iotests/110 | ||
445 | +++ b/tests/qemu-iotests/110 | ||
446 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
447 | |||
448 | _cleanup() | ||
449 | { | ||
450 | - _cleanup_test_img | ||
451 | - rm -f "$TEST_IMG.copy" | ||
452 | + _cleanup_test_img | ||
453 | + _rm_test_img "$TEST_IMG.copy" | ||
454 | } | ||
455 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
456 | |||
457 | diff --git a/tests/qemu-iotests/122 b/tests/qemu-iotests/122 | ||
458 | index XXXXXXX..XXXXXXX 100755 | ||
459 | --- a/tests/qemu-iotests/122 | ||
460 | +++ b/tests/qemu-iotests/122 | ||
461 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
462 | |||
463 | _cleanup() | ||
464 | { | ||
465 | - rm -f "$TEST_IMG".[123] | ||
466 | - _cleanup_test_img | ||
467 | + for img in "$TEST_IMG".[123]; do | ||
468 | + _rm_test_img "$img" | ||
469 | + done | ||
470 | + _cleanup_test_img | ||
471 | } | ||
472 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
473 | |||
474 | diff --git a/tests/qemu-iotests/123 b/tests/qemu-iotests/123 | ||
475 | index XXXXXXX..XXXXXXX 100755 | ||
476 | --- a/tests/qemu-iotests/123 | ||
477 | +++ b/tests/qemu-iotests/123 | ||
478 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
479 | _cleanup() | ||
480 | { | ||
481 | _cleanup_test_img | ||
482 | - rm -f "$SRC_IMG" | ||
483 | + _rm_test_img "$SRC_IMG" | ||
484 | } | ||
485 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
486 | |||
487 | diff --git a/tests/qemu-iotests/141 b/tests/qemu-iotests/141 | ||
488 | index XXXXXXX..XXXXXXX 100755 | ||
489 | --- a/tests/qemu-iotests/141 | ||
490 | +++ b/tests/qemu-iotests/141 | ||
491 | @@ -XXX,XX +XXX,XX @@ _cleanup() | ||
492 | { | ||
493 | _cleanup_qemu | ||
494 | _cleanup_test_img | ||
495 | - rm -f "$TEST_DIR"/{b,m,o}.$IMGFMT | ||
496 | + for img in "$TEST_DIR"/{b,m,o}.$IMGFMT; do | ||
497 | + _rm_test_img "$img" | ||
498 | + done | ||
499 | } | ||
500 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
501 | |||
502 | diff --git a/tests/qemu-iotests/142 b/tests/qemu-iotests/142 | ||
503 | index XXXXXXX..XXXXXXX 100755 | ||
504 | --- a/tests/qemu-iotests/142 | ||
505 | +++ b/tests/qemu-iotests/142 | ||
506 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
507 | _cleanup() | ||
508 | { | ||
509 | _cleanup_test_img | ||
510 | - rm -f $TEST_IMG.snap | ||
511 | + _rm_test_img "$TEST_IMG.snap" | ||
512 | } | ||
513 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
514 | |||
515 | diff --git a/tests/qemu-iotests/144 b/tests/qemu-iotests/144 | ||
516 | index XXXXXXX..XXXXXXX 100755 | ||
517 | --- a/tests/qemu-iotests/144 | ||
518 | +++ b/tests/qemu-iotests/144 | ||
519 | @@ -XXX,XX +XXX,XX @@ TMP_SNAP2=${TEST_DIR}/tmp2.qcow2 | ||
520 | _cleanup() | ||
521 | { | ||
522 | _cleanup_qemu | ||
523 | - rm -f "${TEST_IMG}" "${TMP_SNAP1}" "${TMP_SNAP2}" | ||
524 | + for img in "${TEST_IMG}" "${TMP_SNAP1}" "${TMP_SNAP2}"; do | ||
525 | + _rm_test_img "$img" | ||
526 | + done | ||
527 | } | ||
528 | |||
529 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
530 | diff --git a/tests/qemu-iotests/153 b/tests/qemu-iotests/153 | ||
531 | index XXXXXXX..XXXXXXX 100755 | ||
532 | --- a/tests/qemu-iotests/153 | ||
533 | +++ b/tests/qemu-iotests/153 | ||
534 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
535 | _cleanup() | ||
536 | { | ||
537 | _cleanup_test_img | ||
538 | - rm -f "${TEST_IMG}.base" | ||
539 | - rm -f "${TEST_IMG}.overlay" | ||
540 | - rm -f "${TEST_IMG}.convert" | ||
541 | - rm -f "${TEST_IMG}.a" | ||
542 | - rm -f "${TEST_IMG}.b" | ||
543 | - rm -f "${TEST_IMG}.c" | ||
544 | - rm -f "${TEST_IMG}.lnk" | ||
545 | + for img in "${TEST_IMG}".{base,overlay,convert,a,b,c,lnk}; do | ||
546 | + _rm_test_img "$img" | ||
547 | + done | ||
548 | } | ||
549 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
550 | |||
551 | diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156 | ||
552 | index XXXXXXX..XXXXXXX 100755 | ||
553 | --- a/tests/qemu-iotests/156 | ||
554 | +++ b/tests/qemu-iotests/156 | ||
555 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
556 | _cleanup() | ||
557 | { | ||
558 | _cleanup_qemu | ||
559 | - rm -f "$TEST_IMG"{,.target}{,.backing,.overlay} | ||
560 | + for img in "$TEST_IMG"{,.target}{,.backing,.overlay}; do | ||
561 | + _rm_test_img "$img" | ||
562 | + done | ||
563 | } | ||
564 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
565 | |||
566 | @@ -XXX,XX +XXX,XX @@ _send_qemu_cmd $QEMU_HANDLE \ | ||
567 | '"status": "null"' | ||
568 | |||
569 | # Remove the source images | ||
570 | -rm -f "$TEST_IMG{,.backing,.overlay}" | ||
571 | +for img in "$TEST_IMG{,.backing,.overlay}"; do | ||
572 | + _rm_test_img "$img" | ||
573 | +done | ||
574 | |||
575 | echo | ||
576 | |||
577 | diff --git a/tests/qemu-iotests/159 b/tests/qemu-iotests/159 | ||
578 | index XXXXXXX..XXXXXXX 100755 | ||
579 | --- a/tests/qemu-iotests/159 | ||
580 | +++ b/tests/qemu-iotests/159 | ||
581 | @@ -XXX,XX +XXX,XX @@ status=1 | ||
582 | _cleanup() | ||
583 | { | ||
584 | _cleanup_test_img | ||
585 | - rm -f "$TEST_IMG.out" | ||
586 | + _rm_test_img "$TEST_IMG.out" | ||
587 | } | ||
588 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
589 | |||
590 | diff --git a/tests/qemu-iotests/160 b/tests/qemu-iotests/160 | ||
591 | index XXXXXXX..XXXXXXX 100755 | ||
592 | --- a/tests/qemu-iotests/160 | ||
593 | +++ b/tests/qemu-iotests/160 | ||
594 | @@ -XXX,XX +XXX,XX @@ status=1 | ||
595 | _cleanup() | ||
596 | { | ||
597 | _cleanup_test_img | ||
598 | - rm -f "$TEST_IMG.out" "$TEST_IMG.out.dd" | ||
599 | + _rm_test_img "$TEST_IMG.out" | ||
600 | + _rm_test_img "$TEST_IMG.out.dd" | ||
601 | } | ||
602 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
603 | |||
604 | diff --git a/tests/qemu-iotests/161 b/tests/qemu-iotests/161 | ||
605 | index XXXXXXX..XXXXXXX 100755 | ||
606 | --- a/tests/qemu-iotests/161 | ||
607 | +++ b/tests/qemu-iotests/161 | ||
608 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
609 | _cleanup() | ||
610 | { | ||
611 | _cleanup_test_img | ||
612 | - rm -f "$TEST_IMG.base" | ||
613 | - rm -f "$TEST_IMG.int" | ||
614 | + _rm_test_img "$TEST_IMG.base" | ||
615 | + _rm_test_img "$TEST_IMG.int" | ||
616 | } | ||
617 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
618 | |||
619 | diff --git a/tests/qemu-iotests/170 b/tests/qemu-iotests/170 | ||
620 | index XXXXXXX..XXXXXXX 100755 | ||
621 | --- a/tests/qemu-iotests/170 | ||
622 | +++ b/tests/qemu-iotests/170 | ||
623 | @@ -XXX,XX +XXX,XX @@ status=1 | ||
624 | _cleanup() | ||
625 | { | ||
626 | _cleanup_test_img | ||
627 | - rm -f "$TEST_IMG.out" | ||
628 | + _rm_test_img "$TEST_IMG.out" | ||
629 | } | ||
630 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
631 | |||
632 | diff --git a/tests/qemu-iotests/172 b/tests/qemu-iotests/172 | ||
633 | index XXXXXXX..XXXXXXX 100755 | ||
634 | --- a/tests/qemu-iotests/172 | ||
635 | +++ b/tests/qemu-iotests/172 | ||
636 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
637 | |||
638 | _cleanup() | ||
639 | { | ||
640 | - _cleanup_test_img | ||
641 | - rm -f "$TEST_IMG.2" | ||
642 | - rm -f "$TEST_IMG.3" | ||
643 | + _cleanup_test_img | ||
644 | + _rm_test_img "$TEST_IMG.2" | ||
645 | + _rm_test_img "$TEST_IMG.3" | ||
646 | } | ||
647 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
648 | |||
649 | diff --git a/tests/qemu-iotests/173 b/tests/qemu-iotests/173 | ||
650 | index XXXXXXX..XXXXXXX 100755 | ||
651 | --- a/tests/qemu-iotests/173 | ||
652 | +++ b/tests/qemu-iotests/173 | ||
653 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
654 | _cleanup() | ||
655 | { | ||
656 | _cleanup_qemu | ||
657 | - rm -f "${QEMU_TEST_DIR}/image.base" "${QEMU_TEST_DIR}/image.snp1" | ||
658 | + _rm_test_img "${TEST_DIR}/image.base" | ||
659 | + _rm_test_img "${TEST_DIR}/image.snp1" | ||
660 | _cleanup_test_img | ||
661 | } | ||
662 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
663 | diff --git a/tests/qemu-iotests/178 b/tests/qemu-iotests/178 | ||
664 | index XXXXXXX..XXXXXXX 100755 | ||
665 | --- a/tests/qemu-iotests/178 | ||
666 | +++ b/tests/qemu-iotests/178 | ||
667 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
668 | _cleanup() | ||
669 | { | ||
670 | _cleanup_test_img | ||
671 | - rm -f "$TEST_IMG.converted" | ||
672 | + _rm_test_img "$TEST_IMG.converted" | ||
673 | } | ||
674 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
675 | |||
676 | diff --git a/tests/qemu-iotests/182 b/tests/qemu-iotests/182 | ||
677 | index XXXXXXX..XXXXXXX 100755 | ||
678 | --- a/tests/qemu-iotests/182 | ||
679 | +++ b/tests/qemu-iotests/182 | ||
680 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
681 | _cleanup() | ||
682 | { | ||
683 | _cleanup_test_img | ||
684 | - rm -f "$TEST_IMG.overlay" | ||
685 | + _rm_test_img "$TEST_IMG.overlay" | ||
686 | rm -f "$SOCK_DIR/nbd.socket" | ||
687 | } | ||
688 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
689 | diff --git a/tests/qemu-iotests/183 b/tests/qemu-iotests/183 | ||
690 | index XXXXXXX..XXXXXXX 100755 | ||
691 | --- a/tests/qemu-iotests/183 | ||
692 | +++ b/tests/qemu-iotests/183 | ||
693 | @@ -XXX,XX +XXX,XX @@ MIG_SOCKET="${SOCK_DIR}/migrate" | ||
694 | _cleanup() | ||
695 | { | ||
696 | rm -f "${MIG_SOCKET}" | ||
697 | - rm -f "${TEST_IMG}.dest" | ||
698 | + _rm_test_img "${TEST_IMG}.dest" | ||
699 | _cleanup_test_img | ||
700 | _cleanup_qemu | ||
701 | } | ||
702 | diff --git a/tests/qemu-iotests/185 b/tests/qemu-iotests/185 | ||
703 | index XXXXXXX..XXXXXXX 100755 | ||
704 | --- a/tests/qemu-iotests/185 | ||
705 | +++ b/tests/qemu-iotests/185 | ||
706 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
707 | |||
708 | _cleanup() | ||
709 | { | ||
710 | - rm -f "${TEST_IMG}.mid" | ||
711 | - rm -f "${TEST_IMG}.copy" | ||
712 | + _rm_test_img "${TEST_IMG}.mid" | ||
713 | + _rm_test_img "${TEST_IMG}.copy" | ||
714 | _cleanup_test_img | ||
715 | _cleanup_qemu | ||
716 | } | ||
717 | diff --git a/tests/qemu-iotests/187 b/tests/qemu-iotests/187 | ||
718 | index XXXXXXX..XXXXXXX 100755 | ||
719 | --- a/tests/qemu-iotests/187 | ||
720 | +++ b/tests/qemu-iotests/187 | ||
721 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
722 | |||
723 | _cleanup() | ||
724 | { | ||
725 | - _cleanup_test_img | ||
726 | - rm -f "$TEST_IMG.2" | ||
727 | - rm -f "$TEST_IMG.3" | ||
728 | + _cleanup_test_img | ||
729 | + _rm_test_img "$TEST_IMG.2" | ||
730 | + _rm_test_img "$TEST_IMG.3" | ||
731 | } | ||
732 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
733 | |||
734 | diff --git a/tests/qemu-iotests/190 b/tests/qemu-iotests/190 | ||
735 | index XXXXXXX..XXXXXXX 100755 | ||
736 | --- a/tests/qemu-iotests/190 | ||
737 | +++ b/tests/qemu-iotests/190 | ||
738 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
739 | _cleanup() | ||
740 | { | ||
741 | _cleanup_test_img | ||
742 | - rm -f "$TEST_IMG.converted" | ||
743 | + _rm_test_img "$TEST_IMG.converted" | ||
744 | } | ||
745 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
746 | |||
747 | diff --git a/tests/qemu-iotests/191 b/tests/qemu-iotests/191 | ||
748 | index XXXXXXX..XXXXXXX 100755 | ||
749 | --- a/tests/qemu-iotests/191 | ||
750 | +++ b/tests/qemu-iotests/191 | ||
751 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
752 | |||
753 | _cleanup() | ||
754 | { | ||
755 | - rm -f "${TEST_IMG}.mid" | ||
756 | - rm -f "${TEST_IMG}.ovl2" | ||
757 | - rm -f "${TEST_IMG}.ovl3" | ||
758 | + _rm_test_img "${TEST_IMG}.mid" | ||
759 | + _rm_test_img "${TEST_IMG}.ovl2" | ||
760 | + _rm_test_img "${TEST_IMG}.ovl3" | ||
761 | _cleanup_test_img | ||
762 | _cleanup_qemu | ||
763 | } | ||
764 | diff --git a/tests/qemu-iotests/195 b/tests/qemu-iotests/195 | ||
765 | index XXXXXXX..XXXXXXX 100755 | ||
766 | --- a/tests/qemu-iotests/195 | ||
767 | +++ b/tests/qemu-iotests/195 | ||
768 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
769 | _cleanup() | ||
770 | { | ||
771 | _cleanup_test_img | ||
772 | - rm -f "$TEST_IMG.mid" | ||
773 | + _rm_test_img "$TEST_IMG.mid" | ||
774 | } | ||
775 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
776 | |||
777 | diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197 | ||
778 | index XXXXXXX..XXXXXXX 100755 | ||
779 | --- a/tests/qemu-iotests/197 | ||
780 | +++ b/tests/qemu-iotests/197 | ||
781 | @@ -XXX,XX +XXX,XX @@ esac | ||
782 | _cleanup() | ||
783 | { | ||
784 | _cleanup_test_img | ||
785 | - rm -f "$TEST_WRAP" | ||
786 | + _rm_test_img "$TEST_WRAP" | ||
787 | rm -f "$BLKDBG_CONF" | ||
788 | } | ||
789 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
790 | diff --git a/tests/qemu-iotests/200 b/tests/qemu-iotests/200 | ||
791 | index XXXXXXX..XXXXXXX 100755 | ||
792 | --- a/tests/qemu-iotests/200 | ||
793 | +++ b/tests/qemu-iotests/200 | ||
794 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
795 | _cleanup() | ||
796 | { | ||
797 | _cleanup_qemu | ||
798 | - rm -f "${TEST_IMG}" "${BACKING_IMG}" | ||
799 | + _rm_test_img "${TEST_IMG}" | ||
800 | + _rm_test_img "${BACKING_IMG}" | ||
801 | } | ||
802 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
803 | |||
804 | diff --git a/tests/qemu-iotests/215 b/tests/qemu-iotests/215 | ||
805 | index XXXXXXX..XXXXXXX 100755 | ||
806 | --- a/tests/qemu-iotests/215 | ||
807 | +++ b/tests/qemu-iotests/215 | ||
808 | @@ -XXX,XX +XXX,XX @@ esac | ||
809 | _cleanup() | ||
810 | { | ||
811 | _cleanup_test_img | ||
812 | - rm -f "$TEST_WRAP" | ||
813 | + _rm_test_img "$TEST_WRAP" | ||
814 | rm -f "$BLKDBG_CONF" | ||
815 | } | ||
816 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
817 | diff --git a/tests/qemu-iotests/225 b/tests/qemu-iotests/225 | ||
818 | index XXXXXXX..XXXXXXX 100755 | ||
819 | --- a/tests/qemu-iotests/225 | ||
820 | +++ b/tests/qemu-iotests/225 | ||
821 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
822 | _cleanup() | ||
823 | { | ||
824 | _cleanup_test_img | ||
825 | - rm -f "$TEST_IMG.not_base" | ||
826 | + _rm_test_img "$TEST_IMG.not_base" | ||
827 | } | ||
828 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
829 | |||
830 | diff --git a/tests/qemu-iotests/229 b/tests/qemu-iotests/229 | ||
831 | index XXXXXXX..XXXXXXX 100755 | ||
832 | --- a/tests/qemu-iotests/229 | ||
833 | +++ b/tests/qemu-iotests/229 | ||
834 | @@ -XXX,XX +XXX,XX @@ _cleanup() | ||
835 | { | ||
836 | _cleanup_qemu | ||
837 | _cleanup_test_img | ||
838 | - rm -f "$TEST_IMG" "$DEST_IMG" | ||
839 | + _rm_test_img "$TEST_IMG" | ||
840 | + _rm_test_img "$DEST_IMG" | ||
841 | } | ||
842 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
843 | |||
844 | diff --git a/tests/qemu-iotests/232 b/tests/qemu-iotests/232 | ||
845 | index XXXXXXX..XXXXXXX 100755 | ||
846 | --- a/tests/qemu-iotests/232 | ||
847 | +++ b/tests/qemu-iotests/232 | ||
848 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
849 | _cleanup() | ||
850 | { | ||
851 | _cleanup_test_img | ||
852 | - rm -f $TEST_IMG.[01234] | ||
853 | + for img in "$TEST_IMG".[01234]; do | ||
854 | + _rm_test_img "$img" | ||
855 | + done | ||
856 | } | ||
857 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
858 | |||
859 | diff --git a/tests/qemu-iotests/243 b/tests/qemu-iotests/243 | ||
860 | index XXXXXXX..XXXXXXX 100755 | ||
861 | --- a/tests/qemu-iotests/243 | ||
862 | +++ b/tests/qemu-iotests/243 | ||
863 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
864 | _cleanup() | ||
865 | { | ||
866 | _cleanup_test_img | ||
867 | - rm -f $TEST_IMG.data | ||
868 | + _rm_test_img "$TEST_IMG.data" | ||
869 | } | ||
870 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
871 | |||
872 | diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244 | ||
873 | index XXXXXXX..XXXXXXX 100755 | ||
874 | --- a/tests/qemu-iotests/244 | ||
875 | +++ b/tests/qemu-iotests/244 | ||
876 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
877 | _cleanup() | ||
878 | { | ||
879 | _cleanup_test_img | ||
880 | - rm -f $TEST_IMG.data | ||
881 | - rm -f $TEST_IMG.src | ||
882 | + _rm_test_img "$TEST_IMG.data" | ||
883 | + _rm_test_img "$TEST_IMG.src" | ||
884 | } | ||
885 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
886 | |||
887 | diff --git a/tests/qemu-iotests/247 b/tests/qemu-iotests/247 | ||
888 | index XXXXXXX..XXXXXXX 100755 | ||
889 | --- a/tests/qemu-iotests/247 | ||
890 | +++ b/tests/qemu-iotests/247 | ||
891 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
892 | _cleanup() | ||
893 | { | ||
894 | _cleanup_test_img | ||
895 | - rm -f $TEST_IMG.[01234] | ||
896 | + for img in "$TEST_IMG".[01234]; do | ||
897 | + _rm_test_img "$img" | ||
898 | + done | ||
899 | } | ||
900 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
901 | |||
902 | diff --git a/tests/qemu-iotests/249 b/tests/qemu-iotests/249 | ||
903 | index XXXXXXX..XXXXXXX 100755 | ||
904 | --- a/tests/qemu-iotests/249 | ||
905 | +++ b/tests/qemu-iotests/249 | ||
906 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
907 | _cleanup() | ||
908 | { | ||
909 | _cleanup_test_img | ||
910 | - rm -f "$TEST_IMG.base" | ||
911 | - rm -f "$TEST_IMG.int" | ||
912 | + _rm_test_img "$TEST_IMG.base" | ||
913 | + _rm_test_img "$TEST_IMG.int" | ||
914 | } | ||
915 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
916 | |||
917 | diff --git a/tests/qemu-iotests/252 b/tests/qemu-iotests/252 | ||
918 | index XXXXXXX..XXXXXXX 100755 | ||
919 | --- a/tests/qemu-iotests/252 | ||
920 | +++ b/tests/qemu-iotests/252 | ||
921 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
922 | _cleanup() | ||
923 | { | ||
924 | _cleanup_test_img | ||
925 | - rm -f "$TEST_IMG.base_new" | ||
926 | + _rm_test_img "$TEST_IMG.base_new" | ||
927 | } | ||
928 | trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
929 | |||
930 | -- | ||
931 | 2.24.1 | ||
932 | |||
933 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | This will not work with external data files, so try to get tests working | ||
2 | without it as far as possible. | ||
3 | 1 | ||
4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
5 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
6 | Message-id: 20191107163708.833192-17-mreitz@redhat.com | ||
7 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
8 | --- | ||
9 | tests/qemu-iotests/063 | 12 ++++-------- | ||
10 | tests/qemu-iotests/063.out | 3 ++- | ||
11 | tests/qemu-iotests/085 | 9 +++------ | ||
12 | tests/qemu-iotests/085.out | 8 ++++---- | ||
13 | 4 files changed, 13 insertions(+), 19 deletions(-) | ||
14 | |||
15 | diff --git a/tests/qemu-iotests/063 b/tests/qemu-iotests/063 | ||
16 | index XXXXXXX..XXXXXXX 100755 | ||
17 | --- a/tests/qemu-iotests/063 | ||
18 | +++ b/tests/qemu-iotests/063 | ||
19 | @@ -XXX,XX +XXX,XX @@ _unsupported_imgopts "subformat=monolithicFlat" \ | ||
20 | _make_test_img 4M | ||
21 | |||
22 | echo "== Testing conversion with -n fails with no target file ==" | ||
23 | -# check .orig file does not exist | ||
24 | -rm -f "$TEST_IMG.orig" | ||
25 | if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG.orig" >/dev/null 2>&1; then | ||
26 | exit 1 | ||
27 | fi | ||
28 | |||
29 | echo "== Testing conversion with -n succeeds with a target file ==" | ||
30 | -rm -f "$TEST_IMG.orig" | ||
31 | -cp "$TEST_IMG" "$TEST_IMG.orig" | ||
32 | +_rm_test_img "$TEST_IMG.orig" | ||
33 | +TEST_IMG="$TEST_IMG.orig" _make_test_img 4M | ||
34 | if ! $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG.orig" ; then | ||
35 | exit 1 | ||
36 | fi | ||
37 | @@ -XXX,XX +XXX,XX @@ fi | ||
38 | _check_test_img | ||
39 | |||
40 | echo "== Testing conversion to a smaller file fails ==" | ||
41 | -rm -f "$TEST_IMG.orig" | ||
42 | -mv "$TEST_IMG" "$TEST_IMG.orig" | ||
43 | -_make_test_img 2M | ||
44 | -if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG.orig" "$TEST_IMG" >/dev/null 2>&1; then | ||
45 | +TEST_IMG="$TEST_IMG.target" _make_test_img 2M | ||
46 | +if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG.target" >/dev/null 2>&1; then | ||
47 | exit 1 | ||
48 | fi | ||
49 | |||
50 | diff --git a/tests/qemu-iotests/063.out b/tests/qemu-iotests/063.out | ||
51 | index XXXXXXX..XXXXXXX 100644 | ||
52 | --- a/tests/qemu-iotests/063.out | ||
53 | +++ b/tests/qemu-iotests/063.out | ||
54 | @@ -XXX,XX +XXX,XX @@ QA output created by 063 | ||
55 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4194304 | ||
56 | == Testing conversion with -n fails with no target file == | ||
57 | == Testing conversion with -n succeeds with a target file == | ||
58 | +Formatting 'TEST_DIR/t.IMGFMT.orig', fmt=IMGFMT size=4194304 | ||
59 | == Testing conversion to raw is the same after conversion with -n == | ||
60 | == Testing conversion back to original format == | ||
61 | No errors were found on the image. | ||
62 | == Testing conversion to a smaller file fails == | ||
63 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2097152 | ||
64 | +Formatting 'TEST_DIR/t.IMGFMT.target', fmt=IMGFMT size=2097152 | ||
65 | == Regression testing for copy offloading bug == | ||
66 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 | ||
67 | Formatting 'TEST_DIR/t.IMGFMT.target', fmt=IMGFMT size=1048576 | ||
68 | diff --git a/tests/qemu-iotests/085 b/tests/qemu-iotests/085 | ||
69 | index XXXXXXX..XXXXXXX 100755 | ||
70 | --- a/tests/qemu-iotests/085 | ||
71 | +++ b/tests/qemu-iotests/085 | ||
72 | @@ -XXX,XX +XXX,XX @@ add_snapshot_image() | ||
73 | { | ||
74 | base_image="${TEST_DIR}/$((${1}-1))-${snapshot_virt0}" | ||
75 | snapshot_file="${TEST_DIR}/${1}-${snapshot_virt0}" | ||
76 | - _make_test_img -u -b "${base_image}" "$size" | ||
77 | - mv "${TEST_IMG}" "${snapshot_file}" | ||
78 | + TEST_IMG=$snapshot_file _make_test_img -u -b "${base_image}" "$size" | ||
79 | do_blockdev_add "$1" "'backing': null, " "${snapshot_file}" | ||
80 | } | ||
81 | |||
82 | @@ -XXX,XX +XXX,XX @@ blockdev_snapshot() | ||
83 | |||
84 | size=128M | ||
85 | |||
86 | -_make_test_img $size | ||
87 | -mv "${TEST_IMG}" "${TEST_IMG}.1" | ||
88 | -_make_test_img $size | ||
89 | -mv "${TEST_IMG}" "${TEST_IMG}.2" | ||
90 | +TEST_IMG="$TEST_IMG.1" _make_test_img $size | ||
91 | +TEST_IMG="$TEST_IMG.2" _make_test_img $size | ||
92 | |||
93 | echo | ||
94 | echo === Running QEMU === | ||
95 | diff --git a/tests/qemu-iotests/085.out b/tests/qemu-iotests/085.out | ||
96 | index XXXXXXX..XXXXXXX 100644 | ||
97 | --- a/tests/qemu-iotests/085.out | ||
98 | +++ b/tests/qemu-iotests/085.out | ||
99 | @@ -XXX,XX +XXX,XX @@ | ||
100 | QA output created by 085 | ||
101 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 | ||
102 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 | ||
103 | +Formatting 'TEST_DIR/t.IMGFMT.1', fmt=IMGFMT size=134217728 | ||
104 | +Formatting 'TEST_DIR/t.IMGFMT.2', fmt=IMGFMT size=134217728 | ||
105 | |||
106 | === Running QEMU === | ||
107 | |||
108 | @@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/10-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_fil | ||
109 | |||
110 | === Create a couple of snapshots using blockdev-snapshot === | ||
111 | |||
112 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/10-snapshot-v0.IMGFMT | ||
113 | +Formatting 'TEST_DIR/11-snapshot-v0.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/10-snapshot-v0.IMGFMT | ||
114 | { 'execute': 'blockdev-add', 'arguments': { 'driver': 'IMGFMT', 'node-name': 'snap_11', 'backing': null, 'file': { 'driver': 'file', 'filename': 'TEST_DIR/11-snapshot-v0.IMGFMT', 'node-name': 'file_11' } } } | ||
115 | {"return": {}} | ||
116 | { 'execute': 'blockdev-snapshot', 'arguments': { 'node': 'virtio0', 'overlay':'snap_11' } } | ||
117 | {"return": {}} | ||
118 | -Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/11-snapshot-v0.IMGFMT | ||
119 | +Formatting 'TEST_DIR/12-snapshot-v0.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/11-snapshot-v0.IMGFMT | ||
120 | { 'execute': 'blockdev-add', 'arguments': { 'driver': 'IMGFMT', 'node-name': 'snap_12', 'backing': null, 'file': { 'driver': 'file', 'filename': 'TEST_DIR/12-snapshot-v0.IMGFMT', 'node-name': 'file_12' } } } | ||
121 | {"return": {}} | ||
122 | { 'execute': 'blockdev-snapshot', 'arguments': { 'node': 'virtio0', 'overlay':'snap_12' } } | ||
123 | -- | ||
124 | 2.24.1 | ||
125 | |||
126 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | The image end offset as reported by qemu-img check is different when | ||
2 | using an external data file; we do not care about its value here, so we | ||
3 | can just filter it. Incidentally, common.rc already has _check_test_img | ||
4 | for us which does exactly that. | ||
5 | 1 | ||
6 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
7 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
8 | Message-id: 20191107163708.833192-18-mreitz@redhat.com | ||
9 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
10 | --- | ||
11 | tests/qemu-iotests/091 | 2 +- | ||
12 | tests/qemu-iotests/091.out | 2 -- | ||
13 | 2 files changed, 1 insertion(+), 3 deletions(-) | ||
14 | |||
15 | diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091 | ||
16 | index XXXXXXX..XXXXXXX 100755 | ||
17 | --- a/tests/qemu-iotests/091 | ||
18 | +++ b/tests/qemu-iotests/091 | ||
19 | @@ -XXX,XX +XXX,XX @@ echo "Check image pattern" | ||
20 | ${QEMU_IO} -c "read -P 0x22 0 4M" "${TEST_IMG}" | _filter_testdir | _filter_qemu_io | ||
21 | |||
22 | echo "Running 'qemu-img check -r all \$TEST_IMG'" | ||
23 | -"${QEMU_IMG}" check -r all "${TEST_IMG}" 2>&1 | _filter_testdir | _filter_qemu | ||
24 | +_check_test_img -r all | ||
25 | |||
26 | echo "*** done" | ||
27 | rm -f $seq.full | ||
28 | diff --git a/tests/qemu-iotests/091.out b/tests/qemu-iotests/091.out | ||
29 | index XXXXXXX..XXXXXXX 100644 | ||
30 | --- a/tests/qemu-iotests/091.out | ||
31 | +++ b/tests/qemu-iotests/091.out | ||
32 | @@ -XXX,XX +XXX,XX @@ read 4194304/4194304 bytes at offset 0 | ||
33 | 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
34 | Running 'qemu-img check -r all $TEST_IMG' | ||
35 | No errors were found on the image. | ||
36 | -80/16384 = 0.49% allocated, 0.00% fragmented, 0.00% compressed clusters | ||
37 | -Image end offset: 5570560 | ||
38 | *** done | ||
39 | -- | ||
40 | 2.24.1 | ||
41 | |||
42 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | The only difference is that the json:{} filename of the image looks | ||
2 | different. We actually do not care about that filename in this test, we | ||
3 | are only interested in (1) that there is a json:{} filename, and (2) | ||
4 | whether the backing filename can be constructed. | ||
5 | 1 | ||
6 | So just filter out the json:{} data, thus making this test pass both | ||
7 | with and without data_file. | ||
8 | |||
9 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
10 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
11 | Message-id: 20191107163708.833192-19-mreitz@redhat.com | ||
12 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
13 | --- | ||
14 | tests/qemu-iotests/110 | 7 +++++-- | ||
15 | tests/qemu-iotests/110.out | 4 ++-- | ||
16 | 2 files changed, 7 insertions(+), 4 deletions(-) | ||
17 | |||
18 | diff --git a/tests/qemu-iotests/110 b/tests/qemu-iotests/110 | ||
19 | index XXXXXXX..XXXXXXX 100755 | ||
20 | --- a/tests/qemu-iotests/110 | ||
21 | +++ b/tests/qemu-iotests/110 | ||
22 | @@ -XXX,XX +XXX,XX @@ echo | ||
23 | # Across blkdebug without a config file, you cannot reconstruct filenames, so | ||
24 | # qemu is incapable of knowing the directory of the top image from the filename | ||
25 | # alone. However, using bdrv_dirname(), it should still work. | ||
26 | +# (Filter out the json:{} filename so this test works with external data files) | ||
27 | TEST_IMG="json:{ | ||
28 | 'driver': '$IMGFMT', | ||
29 | 'file': { | ||
30 | @@ -XXX,XX +XXX,XX @@ TEST_IMG="json:{ | ||
31 | } | ||
32 | ] | ||
33 | } | ||
34 | -}" _img_info | _filter_img_info | grep -v 'backing file format' | ||
35 | +}" _img_info | _filter_img_info | grep -v 'backing file format' \ | ||
36 | + | _filter_json_filename | ||
37 | |||
38 | echo | ||
39 | echo '=== Backing name is always relative to the backed image ===' | ||
40 | @@ -XXX,XX +XXX,XX @@ TEST_IMG="json:{ | ||
41 | } | ||
42 | ] | ||
43 | } | ||
44 | -}" _img_info | _filter_img_info | grep -v 'backing file format' | ||
45 | +}" _img_info | _filter_img_info | grep -v 'backing file format' \ | ||
46 | + | _filter_json_filename | ||
47 | |||
48 | |||
49 | # success, all done | ||
50 | diff --git a/tests/qemu-iotests/110.out b/tests/qemu-iotests/110.out | ||
51 | index XXXXXXX..XXXXXXX 100644 | ||
52 | --- a/tests/qemu-iotests/110.out | ||
53 | +++ b/tests/qemu-iotests/110.out | ||
54 | @@ -XXX,XX +XXX,XX @@ backing file: t.IMGFMT.base (actual path: TEST_DIR/t.IMGFMT.base) | ||
55 | |||
56 | === Non-reconstructable filename === | ||
57 | |||
58 | -image: json:{"driver": "IMGFMT", "file": {"set-state.0.event": "read_aio", "image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "set-state.0.new_state": 42}} | ||
59 | +image: json:{ /* filtered */ } | ||
60 | file format: IMGFMT | ||
61 | virtual size: 64 MiB (67108864 bytes) | ||
62 | backing file: t.IMGFMT.base (actual path: TEST_DIR/t.IMGFMT.base) | ||
63 | @@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=t.IMGFMT.b | ||
64 | |||
65 | === Nodes without a common directory === | ||
66 | |||
67 | -image: json:{"driver": "IMGFMT", "file": {"children": [{"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, {"driver": "file", "filename": "TEST_DIR/t.IMGFMT.copy"}], "driver": "quorum", "vote-threshold": 1}} | ||
68 | +image: json:{ /* filtered */ } | ||
69 | file format: IMGFMT | ||
70 | virtual size: 64 MiB (67108864 bytes) | ||
71 | backing file: t.IMGFMT.base (cannot determine actual path) | ||
72 | -- | ||
73 | 2.24.1 | ||
74 | |||
75 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | When using an external data file, there are no refcounts for data | ||
2 | clusters. We thus have to adjust the corruption test in this patch to | ||
3 | not be based around a data cluster allocation, but the L2 table | ||
4 | allocation (L2 tables are still refcounted with external data files). | ||
5 | 1 | ||
6 | Furthermore, we should not print qcow2.py's list of incompatible | ||
7 | features because it differs depending on whether there is an external | ||
8 | data file or not. | ||
9 | |||
10 | With those two changes, the test will work both with and without | ||
11 | external data files (once that options works with the iotests at all). | ||
12 | |||
13 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
14 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
15 | Message-id: 20191107163708.833192-20-mreitz@redhat.com | ||
16 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
17 | --- | ||
18 | tests/qemu-iotests/137 | 15 +++++++++++---- | ||
19 | tests/qemu-iotests/137.out | 6 ++---- | ||
20 | 2 files changed, 13 insertions(+), 8 deletions(-) | ||
21 | |||
22 | diff --git a/tests/qemu-iotests/137 b/tests/qemu-iotests/137 | ||
23 | index XXXXXXX..XXXXXXX 100755 | ||
24 | --- a/tests/qemu-iotests/137 | ||
25 | +++ b/tests/qemu-iotests/137 | ||
26 | @@ -XXX,XX +XXX,XX @@ $QEMU_IO \ | ||
27 | "$TEST_IMG" 2>&1 | _filter_qemu_io | ||
28 | |||
29 | # The dirty bit must not be set | ||
30 | -$PYTHON qcow2.py "$TEST_IMG" dump-header | grep incompatible_features | ||
31 | +# (Filter the external data file bit) | ||
32 | +if $PYTHON qcow2.py "$TEST_IMG" dump-header | grep incompatible_features \ | ||
33 | + | grep -q '\<0\>' | ||
34 | +then | ||
35 | + echo 'ERROR: Dirty bit set' | ||
36 | +else | ||
37 | + echo 'OK: Dirty bit not set' | ||
38 | +fi | ||
39 | |||
40 | # Similarly we can test whether corruption detection has been enabled: | ||
41 | -# Create L1/L2, overwrite first entry in refcount block, allocate something. | ||
42 | +# Create L1, overwrite refcounts, force allocation of L2 by writing | ||
43 | +# data. | ||
44 | # Disabling the checks should fail, so the corruption must be detected. | ||
45 | _make_test_img 64M | ||
46 | -$QEMU_IO -c "write 0 64k" "$TEST_IMG" | _filter_qemu_io | ||
47 | -poke_file "$TEST_IMG" "$((0x20000))" "\x00\x00" | ||
48 | +poke_file "$TEST_IMG" "$((0x20000))" "\x00\x00\x00\x00\x00\x00\x00\x00" | ||
49 | $QEMU_IO \ | ||
50 | -c "reopen -o overlap-check=none,lazy-refcounts=42" \ | ||
51 | -c "write 64k 64k" \ | ||
52 | diff --git a/tests/qemu-iotests/137.out b/tests/qemu-iotests/137.out | ||
53 | index XXXXXXX..XXXXXXX 100644 | ||
54 | --- a/tests/qemu-iotests/137.out | ||
55 | +++ b/tests/qemu-iotests/137.out | ||
56 | @@ -XXX,XX +XXX,XX @@ qemu-io: Unsupported value 'blubb' for qcow2 option 'overlap-check'. Allowed are | ||
57 | wrote 512/512 bytes at offset 0 | ||
58 | 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
59 | ./common.rc: Killed ( VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@" ) | ||
60 | -incompatible_features [] | ||
61 | +OK: Dirty bit not set | ||
62 | Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 | ||
63 | -wrote 65536/65536 bytes at offset 0 | ||
64 | -64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
65 | qemu-io: Parameter 'lazy-refcounts' expects 'on' or 'off' | ||
66 | -qcow2: Marking image as corrupt: Preventing invalid write on metadata (overlaps with qcow2_header); further corruption events will be suppressed | ||
67 | +qcow2: Marking image as corrupt: Preventing invalid allocation of L2 table at offset 0; further corruption events will be suppressed | ||
68 | write failed: Input/output error | ||
69 | *** done | ||
70 | -- | ||
71 | 2.24.1 | ||
72 | |||
73 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | We do not care about the json:{} filenames here, so we can just filter | ||
2 | them out and thus make the test work both with and without external data | ||
3 | files. | ||
4 | 1 | ||
5 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
6 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
7 | Message-id: 20191107163708.833192-21-mreitz@redhat.com | ||
8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
9 | --- | ||
10 | tests/qemu-iotests/198 | 6 ++++-- | ||
11 | tests/qemu-iotests/198.out | 4 ++-- | ||
12 | 2 files changed, 6 insertions(+), 4 deletions(-) | ||
13 | |||
14 | diff --git a/tests/qemu-iotests/198 b/tests/qemu-iotests/198 | ||
15 | index XXXXXXX..XXXXXXX 100755 | ||
16 | --- a/tests/qemu-iotests/198 | ||
17 | +++ b/tests/qemu-iotests/198 | ||
18 | @@ -XXX,XX +XXX,XX @@ echo | ||
19 | echo "== checking image base ==" | ||
20 | $QEMU_IMG info --image-opts $IMGSPECBASE | _filter_img_info --format-specific \ | ||
21 | | sed -e "/^disk size:/ D" -e '/refcount bits:/ D' -e '/compat:/ D' \ | ||
22 | - -e '/lazy refcounts:/ D' -e '/corrupt:/ D' | ||
23 | + -e '/lazy refcounts:/ D' -e '/corrupt:/ D' -e '/^\s*data file/ D' \ | ||
24 | + | _filter_json_filename | ||
25 | |||
26 | echo | ||
27 | echo "== checking image layer ==" | ||
28 | $QEMU_IMG info --image-opts $IMGSPECLAYER | _filter_img_info --format-specific \ | ||
29 | | sed -e "/^disk size:/ D" -e '/refcount bits:/ D' -e '/compat:/ D' \ | ||
30 | - -e '/lazy refcounts:/ D' -e '/corrupt:/ D' | ||
31 | + -e '/lazy refcounts:/ D' -e '/corrupt:/ D' -e '/^\s*data file/ D' \ | ||
32 | + | _filter_json_filename | ||
33 | |||
34 | |||
35 | # success, all done | ||
36 | diff --git a/tests/qemu-iotests/198.out b/tests/qemu-iotests/198.out | ||
37 | index XXXXXXX..XXXXXXX 100644 | ||
38 | --- a/tests/qemu-iotests/198.out | ||
39 | +++ b/tests/qemu-iotests/198.out | ||
40 | @@ -XXX,XX +XXX,XX @@ read 16777216/16777216 bytes at offset 0 | ||
41 | 16 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
42 | |||
43 | == checking image base == | ||
44 | -image: json:{"encrypt.key-secret": "sec0", "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT.base"}} | ||
45 | +image: json:{ /* filtered */ } | ||
46 | file format: IMGFMT | ||
47 | virtual size: 16 MiB (16777216 bytes) | ||
48 | Format specific information: | ||
49 | @@ -XXX,XX +XXX,XX @@ Format specific information: | ||
50 | master key iters: 1024 | ||
51 | |||
52 | == checking image layer == | ||
53 | -image: json:{"encrypt.key-secret": "sec1", "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}} | ||
54 | +image: json:{ /* filtered */ } | ||
55 | file format: IMGFMT | ||
56 | virtual size: 16 MiB (16777216 bytes) | ||
57 | backing file: TEST_DIR/t.IMGFMT.base | ||
58 | -- | ||
59 | 2.24.1 | ||
60 | |||
61 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
2 | Message-id: 20191107163708.833192-22-mreitz@redhat.com | ||
3 | [mreitz: Also disable 273] | ||
4 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
5 | --- | ||
6 | tests/qemu-iotests/007 | 5 +++-- | ||
7 | tests/qemu-iotests/014 | 2 ++ | ||
8 | tests/qemu-iotests/015 | 5 +++-- | ||
9 | tests/qemu-iotests/026 | 5 ++++- | ||
10 | tests/qemu-iotests/029 | 5 +++-- | ||
11 | tests/qemu-iotests/031 | 6 +++--- | ||
12 | tests/qemu-iotests/036 | 5 +++-- | ||
13 | tests/qemu-iotests/039 | 3 +++ | ||
14 | tests/qemu-iotests/046 | 2 ++ | ||
15 | tests/qemu-iotests/048 | 2 ++ | ||
16 | tests/qemu-iotests/051 | 5 +++-- | ||
17 | tests/qemu-iotests/058 | 5 +++-- | ||
18 | tests/qemu-iotests/060 | 6 ++++-- | ||
19 | tests/qemu-iotests/061 | 6 ++++-- | ||
20 | tests/qemu-iotests/062 | 2 +- | ||
21 | tests/qemu-iotests/066 | 4 +++- | ||
22 | tests/qemu-iotests/067 | 6 ++++-- | ||
23 | tests/qemu-iotests/068 | 5 +++-- | ||
24 | tests/qemu-iotests/071 | 3 +++ | ||
25 | tests/qemu-iotests/073 | 4 ++++ | ||
26 | tests/qemu-iotests/074 | 2 ++ | ||
27 | tests/qemu-iotests/080 | 5 +++-- | ||
28 | tests/qemu-iotests/090 | 2 ++ | ||
29 | tests/qemu-iotests/098 | 6 ++++-- | ||
30 | tests/qemu-iotests/099 | 3 ++- | ||
31 | tests/qemu-iotests/103 | 5 +++-- | ||
32 | tests/qemu-iotests/108 | 6 ++++-- | ||
33 | tests/qemu-iotests/112 | 5 +++-- | ||
34 | tests/qemu-iotests/114 | 2 ++ | ||
35 | tests/qemu-iotests/121 | 3 +++ | ||
36 | tests/qemu-iotests/138 | 3 +++ | ||
37 | tests/qemu-iotests/156 | 2 ++ | ||
38 | tests/qemu-iotests/176 | 7 +++++-- | ||
39 | tests/qemu-iotests/191 | 2 ++ | ||
40 | tests/qemu-iotests/201 | 6 +++--- | ||
41 | tests/qemu-iotests/214 | 3 ++- | ||
42 | tests/qemu-iotests/217 | 3 ++- | ||
43 | tests/qemu-iotests/220 | 5 +++-- | ||
44 | tests/qemu-iotests/243 | 6 ++++-- | ||
45 | tests/qemu-iotests/244 | 5 +++-- | ||
46 | tests/qemu-iotests/250 | 2 ++ | ||
47 | tests/qemu-iotests/261 | 3 ++- | ||
48 | tests/qemu-iotests/267 | 5 +++-- | ||
49 | tests/qemu-iotests/273 | 3 +++ | ||
50 | 44 files changed, 127 insertions(+), 53 deletions(-) | ||
51 | 1 | ||
52 | diff --git a/tests/qemu-iotests/007 b/tests/qemu-iotests/007 | ||
53 | index XXXXXXX..XXXXXXX 100755 | ||
54 | --- a/tests/qemu-iotests/007 | ||
55 | +++ b/tests/qemu-iotests/007 | ||
56 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
57 | _supported_fmt qcow2 | ||
58 | _supported_proto generic | ||
59 | # refcount_bits must be at least 4 so we can create ten internal snapshots | ||
60 | -# (1 bit supports none, 2 bits support two, 4 bits support 14) | ||
61 | -_unsupported_imgopts 'refcount_bits=\(1\|2\)[^0-9]' | ||
62 | +# (1 bit supports none, 2 bits support two, 4 bits support 14); | ||
63 | +# snapshot are generally impossible with external data files | ||
64 | +_unsupported_imgopts 'refcount_bits=\(1\|2\)[^0-9]' data_file | ||
65 | |||
66 | echo | ||
67 | echo "creating image" | ||
68 | diff --git a/tests/qemu-iotests/014 b/tests/qemu-iotests/014 | ||
69 | index XXXXXXX..XXXXXXX 100755 | ||
70 | --- a/tests/qemu-iotests/014 | ||
71 | +++ b/tests/qemu-iotests/014 | ||
72 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
73 | _supported_fmt qcow2 | ||
74 | _supported_proto file | ||
75 | _supported_os Linux | ||
76 | +# Compression and snapshots do not work with external data files | ||
77 | +_unsupported_imgopts data_file | ||
78 | |||
79 | TEST_OFFSETS="0 4294967296" | ||
80 | TEST_OPS="writev read write readv" | ||
81 | diff --git a/tests/qemu-iotests/015 b/tests/qemu-iotests/015 | ||
82 | index XXXXXXX..XXXXXXX 100755 | ||
83 | --- a/tests/qemu-iotests/015 | ||
84 | +++ b/tests/qemu-iotests/015 | ||
85 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
86 | # actually any format that supports snapshots | ||
87 | _supported_fmt qcow2 | ||
88 | _supported_proto generic | ||
89 | -# Internal snapshots are (currently) impossible with refcount_bits=1 | ||
90 | -_unsupported_imgopts 'refcount_bits=1[^0-9]' | ||
91 | +# Internal snapshots are (currently) impossible with refcount_bits=1, | ||
92 | +# and generally impossible with external data files | ||
93 | +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file | ||
94 | |||
95 | echo | ||
96 | echo "creating image" | ||
97 | diff --git a/tests/qemu-iotests/026 b/tests/qemu-iotests/026 | ||
98 | index XXXXXXX..XXXXXXX 100755 | ||
99 | --- a/tests/qemu-iotests/026 | ||
100 | +++ b/tests/qemu-iotests/026 | ||
101 | @@ -XXX,XX +XXX,XX @@ _supported_cache_modes writethrough none | ||
102 | # 32 and 64 bits do not work either, however, due to different leaked cluster | ||
103 | # count on error. | ||
104 | # Thus, the only remaining option is refcount_bits=16. | ||
105 | -_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
106 | +# | ||
107 | +# As for data_file, none of the refcount tests can work for it. | ||
108 | +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' \ | ||
109 | + data_file | ||
110 | |||
111 | echo "Errors while writing 128 kB" | ||
112 | echo | ||
113 | diff --git a/tests/qemu-iotests/029 b/tests/qemu-iotests/029 | ||
114 | index XXXXXXX..XXXXXXX 100755 | ||
115 | --- a/tests/qemu-iotests/029 | ||
116 | +++ b/tests/qemu-iotests/029 | ||
117 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
118 | _supported_fmt qcow2 | ||
119 | _supported_proto generic | ||
120 | _unsupported_proto vxhs | ||
121 | -# Internal snapshots are (currently) impossible with refcount_bits=1 | ||
122 | -_unsupported_imgopts 'refcount_bits=1[^0-9]' | ||
123 | +# Internal snapshots are (currently) impossible with refcount_bits=1, | ||
124 | +# and generally impossible with external data files | ||
125 | +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file | ||
126 | |||
127 | offset_size=24 | ||
128 | offset_l1_size=36 | ||
129 | diff --git a/tests/qemu-iotests/031 b/tests/qemu-iotests/031 | ||
130 | index XXXXXXX..XXXXXXX 100755 | ||
131 | --- a/tests/qemu-iotests/031 | ||
132 | +++ b/tests/qemu-iotests/031 | ||
133 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
134 | # This tests qcow2-specific low-level functionality | ||
135 | _supported_fmt qcow2 | ||
136 | _supported_proto file | ||
137 | -# We want to test compat=0.10, which does not support refcount widths | ||
138 | -# other than 16 | ||
139 | -_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
140 | +# We want to test compat=0.10, which does not support external data | ||
141 | +# files or refcount widths other than 16 | ||
142 | +_unsupported_imgopts data_file 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
143 | |||
144 | CLUSTER_SIZE=65536 | ||
145 | |||
146 | diff --git a/tests/qemu-iotests/036 b/tests/qemu-iotests/036 | ||
147 | index XXXXXXX..XXXXXXX 100755 | ||
148 | --- a/tests/qemu-iotests/036 | ||
149 | +++ b/tests/qemu-iotests/036 | ||
150 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
151 | # This tests qcow2-specific low-level functionality | ||
152 | _supported_fmt qcow2 | ||
153 | _supported_proto file | ||
154 | -# Only qcow2v3 and later supports feature bits | ||
155 | -_unsupported_imgopts 'compat=0.10' | ||
156 | +# Only qcow2v3 and later supports feature bits; | ||
157 | +# qcow2.py does not support external data files | ||
158 | +_unsupported_imgopts 'compat=0.10' data_file | ||
159 | |||
160 | echo | ||
161 | echo === Image with unknown incompatible feature bit === | ||
162 | diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039 | ||
163 | index XXXXXXX..XXXXXXX 100755 | ||
164 | --- a/tests/qemu-iotests/039 | ||
165 | +++ b/tests/qemu-iotests/039 | ||
166 | @@ -XXX,XX +XXX,XX @@ _supported_proto file | ||
167 | _supported_os Linux | ||
168 | _default_cache_mode writethrough | ||
169 | _supported_cache_modes writethrough | ||
170 | +# Some of these test cases expect no external data file so that all | ||
171 | +# clusters are part of the qcow2 image and refcounted | ||
172 | +_unsupported_imgopts data_file | ||
173 | |||
174 | size=128M | ||
175 | |||
176 | diff --git a/tests/qemu-iotests/046 b/tests/qemu-iotests/046 | ||
177 | index XXXXXXX..XXXXXXX 100755 | ||
178 | --- a/tests/qemu-iotests/046 | ||
179 | +++ b/tests/qemu-iotests/046 | ||
180 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
181 | |||
182 | _supported_fmt qcow2 | ||
183 | _supported_proto file | ||
184 | +# data_file does not support compressed clusters | ||
185 | +_unsupported_imgopts data_file | ||
186 | |||
187 | CLUSTER_SIZE=64k | ||
188 | size=128M | ||
189 | diff --git a/tests/qemu-iotests/048 b/tests/qemu-iotests/048 | ||
190 | index XXXXXXX..XXXXXXX 100755 | ||
191 | --- a/tests/qemu-iotests/048 | ||
192 | +++ b/tests/qemu-iotests/048 | ||
193 | @@ -XXX,XX +XXX,XX @@ _compare() | ||
194 | _supported_fmt raw qcow2 qed luks | ||
195 | _supported_proto file | ||
196 | _supported_os Linux | ||
197 | +# Using 'cp' is incompatible with external data files | ||
198 | +_unsupported_imgopts data_file | ||
199 | |||
200 | # Remove once all tests are fixed to use TEST_IMG_FILE | ||
201 | # correctly and common.rc sets it unconditionally | ||
202 | diff --git a/tests/qemu-iotests/051 b/tests/qemu-iotests/051 | ||
203 | index XXXXXXX..XXXXXXX 100755 | ||
204 | --- a/tests/qemu-iotests/051 | ||
205 | +++ b/tests/qemu-iotests/051 | ||
206 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
207 | _supported_fmt qcow2 | ||
208 | _supported_proto file | ||
209 | # A compat=0.10 image is created in this test which does not support anything | ||
210 | -# other than refcount_bits=16 | ||
211 | -_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
212 | +# other than refcount_bits=16; | ||
213 | +# it also will not support an external data file | ||
214 | +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' data_file | ||
215 | _require_drivers nbd | ||
216 | |||
217 | do_run_qemu() | ||
218 | diff --git a/tests/qemu-iotests/058 b/tests/qemu-iotests/058 | ||
219 | index XXXXXXX..XXXXXXX 100755 | ||
220 | --- a/tests/qemu-iotests/058 | ||
221 | +++ b/tests/qemu-iotests/058 | ||
222 | @@ -XXX,XX +XXX,XX @@ _supported_fmt qcow2 | ||
223 | _supported_proto file | ||
224 | _supported_os Linux | ||
225 | _require_command QEMU_NBD | ||
226 | -# Internal snapshots are (currently) impossible with refcount_bits=1 | ||
227 | -_unsupported_imgopts 'refcount_bits=1[^0-9]' | ||
228 | +# Internal snapshots are (currently) impossible with refcount_bits=1, | ||
229 | +# and generally impossible with external data files | ||
230 | +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file | ||
231 | |||
232 | nbd_snapshot_img="nbd:unix:$nbd_unix_socket" | ||
233 | |||
234 | diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060 | ||
235 | index XXXXXXX..XXXXXXX 100755 | ||
236 | --- a/tests/qemu-iotests/060 | ||
237 | +++ b/tests/qemu-iotests/060 | ||
238 | @@ -XXX,XX +XXX,XX @@ _filter_io_error() | ||
239 | _supported_fmt qcow2 | ||
240 | _supported_proto file | ||
241 | _supported_os Linux | ||
242 | -# These tests only work for compat=1.1 images with refcount_bits=16 | ||
243 | -_unsupported_imgopts 'compat=0.10' 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
244 | +# These tests only work for compat=1.1 images without an external | ||
245 | +# data file with refcount_bits=16 | ||
246 | +_unsupported_imgopts 'compat=0.10' data_file \ | ||
247 | + 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
248 | |||
249 | # The repair process will create a large file - so check for availability first | ||
250 | _require_large_file 64G | ||
251 | diff --git a/tests/qemu-iotests/061 b/tests/qemu-iotests/061 | ||
252 | index XXXXXXX..XXXXXXX 100755 | ||
253 | --- a/tests/qemu-iotests/061 | ||
254 | +++ b/tests/qemu-iotests/061 | ||
255 | @@ -XXX,XX +XXX,XX @@ _supported_fmt qcow2 | ||
256 | _supported_proto file | ||
257 | _supported_os Linux | ||
258 | # Conversion between different compat versions can only really work | ||
259 | -# with refcount_bits=16 | ||
260 | -_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
261 | +# with refcount_bits=16; | ||
262 | +# we have explicit tests for data_file here, but the whole test does | ||
263 | +# not work with it | ||
264 | +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' data_file | ||
265 | |||
266 | echo | ||
267 | echo "=== Testing version downgrade with zero expansion ===" | ||
268 | diff --git a/tests/qemu-iotests/062 b/tests/qemu-iotests/062 | ||
269 | index XXXXXXX..XXXXXXX 100755 | ||
270 | --- a/tests/qemu-iotests/062 | ||
271 | +++ b/tests/qemu-iotests/062 | ||
272 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
273 | _supported_fmt qcow2 | ||
274 | _supported_proto generic | ||
275 | # We need zero clusters and snapshots | ||
276 | -_unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' | ||
277 | +_unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' data_file | ||
278 | |||
279 | IMG_SIZE=64M | ||
280 | |||
281 | diff --git a/tests/qemu-iotests/066 b/tests/qemu-iotests/066 | ||
282 | index XXXXXXX..XXXXXXX 100755 | ||
283 | --- a/tests/qemu-iotests/066 | ||
284 | +++ b/tests/qemu-iotests/066 | ||
285 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
286 | _supported_fmt qcow2 | ||
287 | _supported_proto generic | ||
288 | # We need zero clusters and snapshots | ||
289 | -_unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' | ||
290 | +# (TODO: Consider splitting the snapshot part into a separate test | ||
291 | +# file, so this one runs with refcount_bits=1 and data_file) | ||
292 | +_unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' data_file | ||
293 | |||
294 | # Intentionally create an unaligned image | ||
295 | IMG_SIZE=$((64 * 1024 * 1024 + 512)) | ||
296 | diff --git a/tests/qemu-iotests/067 b/tests/qemu-iotests/067 | ||
297 | index XXXXXXX..XXXXXXX 100755 | ||
298 | --- a/tests/qemu-iotests/067 | ||
299 | +++ b/tests/qemu-iotests/067 | ||
300 | @@ -XXX,XX +XXX,XX @@ status=1 # failure is the default! | ||
301 | |||
302 | _supported_fmt qcow2 | ||
303 | _supported_proto file | ||
304 | -# Because anything other than 16 would change the output of query-block | ||
305 | -_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
306 | +# Because anything other than 16 would change the output of query-block, | ||
307 | +# and external data files would change the output of | ||
308 | +# query-named-block-nodes | ||
309 | +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' data_file | ||
310 | |||
311 | do_run_qemu() | ||
312 | { | ||
313 | diff --git a/tests/qemu-iotests/068 b/tests/qemu-iotests/068 | ||
314 | index XXXXXXX..XXXXXXX 100755 | ||
315 | --- a/tests/qemu-iotests/068 | ||
316 | +++ b/tests/qemu-iotests/068 | ||
317 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
318 | # This tests qcow2-specific low-level functionality | ||
319 | _supported_fmt qcow2 | ||
320 | _supported_proto generic | ||
321 | -# Internal snapshots are (currently) impossible with refcount_bits=1 | ||
322 | -_unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' | ||
323 | +# Internal snapshots are (currently) impossible with refcount_bits=1, | ||
324 | +# and generally impossible with external data files | ||
325 | +_unsupported_imgopts 'compat=0.10' 'refcount_bits=1[^0-9]' data_file | ||
326 | |||
327 | IMG_SIZE=128K | ||
328 | |||
329 | diff --git a/tests/qemu-iotests/071 b/tests/qemu-iotests/071 | ||
330 | index XXXXXXX..XXXXXXX 100755 | ||
331 | --- a/tests/qemu-iotests/071 | ||
332 | +++ b/tests/qemu-iotests/071 | ||
333 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
334 | _supported_fmt qcow2 | ||
335 | _supported_proto file | ||
336 | _require_drivers blkdebug blkverify | ||
337 | +# blkdebug can only inject errors on bs->file, not on the data_file, | ||
338 | +# so thie test does not work with external data files | ||
339 | +_unsupported_imgopts data_file | ||
340 | |||
341 | do_run_qemu() | ||
342 | { | ||
343 | diff --git a/tests/qemu-iotests/073 b/tests/qemu-iotests/073 | ||
344 | index XXXXXXX..XXXXXXX 100755 | ||
345 | --- a/tests/qemu-iotests/073 | ||
346 | +++ b/tests/qemu-iotests/073 | ||
347 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
348 | _supported_fmt qcow2 | ||
349 | _supported_proto generic | ||
350 | _unsupported_proto vxhs | ||
351 | +# External data files do not support compressed clusters | ||
352 | +# (TODO: Consider writing a version for external data files that does | ||
353 | +# not test compressed clusters) | ||
354 | +_unsupported_imgopts data_file | ||
355 | |||
356 | CLUSTER_SIZE=64k | ||
357 | size=128M | ||
358 | diff --git a/tests/qemu-iotests/074 b/tests/qemu-iotests/074 | ||
359 | index XXXXXXX..XXXXXXX 100755 | ||
360 | --- a/tests/qemu-iotests/074 | ||
361 | +++ b/tests/qemu-iotests/074 | ||
362 | @@ -XXX,XX +XXX,XX @@ _compare() | ||
363 | _supported_fmt qcow2 | ||
364 | _supported_proto file | ||
365 | _supported_os Linux | ||
366 | +# blkdebug can only inject errors on bs->file | ||
367 | +_unsupported_imgopts data_file | ||
368 | |||
369 | # Setup test basic parameters | ||
370 | TEST_IMG2=$TEST_IMG.2 | ||
371 | diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 | ||
372 | index XXXXXXX..XXXXXXX 100755 | ||
373 | --- a/tests/qemu-iotests/080 | ||
374 | +++ b/tests/qemu-iotests/080 | ||
375 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
376 | _supported_fmt qcow2 | ||
377 | _supported_proto file | ||
378 | _supported_os Linux | ||
379 | -# - Internal snapshots are (currently) impossible with refcount_bits=1 | ||
380 | +# - Internal snapshots are (currently) impossible with refcount_bits=1, | ||
381 | +# and generally impossible with external data files | ||
382 | # - This is generally a test for compat=1.1 images | ||
383 | -_unsupported_imgopts 'refcount_bits=1[^0-9]' 'compat=0.10' | ||
384 | +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file 'compat=0.10' | ||
385 | |||
386 | header_size=104 | ||
387 | |||
388 | diff --git a/tests/qemu-iotests/090 b/tests/qemu-iotests/090 | ||
389 | index XXXXXXX..XXXXXXX 100755 | ||
390 | --- a/tests/qemu-iotests/090 | ||
391 | +++ b/tests/qemu-iotests/090 | ||
392 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
393 | |||
394 | _supported_fmt qcow2 | ||
395 | _supported_proto file nfs | ||
396 | +# External data files do not support compressed clusters | ||
397 | +_unsupported_imgopts data_file | ||
398 | |||
399 | IMG_SIZE=128K | ||
400 | |||
401 | diff --git a/tests/qemu-iotests/098 b/tests/qemu-iotests/098 | ||
402 | index XXXXXXX..XXXXXXX 100755 | ||
403 | --- a/tests/qemu-iotests/098 | ||
404 | +++ b/tests/qemu-iotests/098 | ||
405 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
406 | |||
407 | _supported_fmt qcow2 | ||
408 | _supported_proto file | ||
409 | -# The code path we want to test here only works for compat=1.1 images | ||
410 | -_unsupported_imgopts 'compat=0.10' | ||
411 | +# The code path we want to test here only works for compat=1.1 images; | ||
412 | +# blkdebug can only inject errors on bs->file, so external data files | ||
413 | +# do not work with this test | ||
414 | +_unsupported_imgopts 'compat=0.10' data_file | ||
415 | |||
416 | for event in l1_update empty_image_prepare reftable_update refblock_alloc; do | ||
417 | |||
418 | diff --git a/tests/qemu-iotests/099 b/tests/qemu-iotests/099 | ||
419 | index XXXXXXX..XXXXXXX 100755 | ||
420 | --- a/tests/qemu-iotests/099 | ||
421 | +++ b/tests/qemu-iotests/099 | ||
422 | @@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 qed vdi vhdx vmdk vpc | ||
423 | _supported_proto file | ||
424 | _supported_os Linux | ||
425 | _require_drivers blkdebug blkverify | ||
426 | +# data_file would change the json:{} filenames | ||
427 | _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \ | ||
428 | - "subformat=twoGbMaxExtentSparse" | ||
429 | + "subformat=twoGbMaxExtentSparse" data_file | ||
430 | |||
431 | do_run_qemu() | ||
432 | { | ||
433 | diff --git a/tests/qemu-iotests/103 b/tests/qemu-iotests/103 | ||
434 | index XXXXXXX..XXXXXXX 100755 | ||
435 | --- a/tests/qemu-iotests/103 | ||
436 | +++ b/tests/qemu-iotests/103 | ||
437 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
438 | |||
439 | _supported_fmt qcow2 | ||
440 | _supported_proto file nfs | ||
441 | -# Internal snapshots are (currently) impossible with refcount_bits=1 | ||
442 | -_unsupported_imgopts 'refcount_bits=1[^0-9]' | ||
443 | +# Internal snapshots are (currently) impossible with refcount_bits=1, | ||
444 | +# and generally impossible with external data files | ||
445 | +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file | ||
446 | |||
447 | IMG_SIZE=64K | ||
448 | |||
449 | diff --git a/tests/qemu-iotests/108 b/tests/qemu-iotests/108 | ||
450 | index XXXXXXX..XXXXXXX 100755 | ||
451 | --- a/tests/qemu-iotests/108 | ||
452 | +++ b/tests/qemu-iotests/108 | ||
453 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
454 | _supported_fmt qcow2 | ||
455 | _supported_proto file | ||
456 | _supported_os Linux | ||
457 | -# This test directly modifies a refblock so it relies on refcount_bits being 16 | ||
458 | -_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
459 | +# This test directly modifies a refblock so it relies on refcount_bits being 16; | ||
460 | +# and the low-level modification it performs are not tuned for external data | ||
461 | +# files | ||
462 | +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' data_file | ||
463 | |||
464 | echo | ||
465 | echo '=== Repairing an image without any refcount table ===' | ||
466 | diff --git a/tests/qemu-iotests/112 b/tests/qemu-iotests/112 | ||
467 | index XXXXXXX..XXXXXXX 100755 | ||
468 | --- a/tests/qemu-iotests/112 | ||
469 | +++ b/tests/qemu-iotests/112 | ||
470 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
471 | _supported_fmt qcow2 | ||
472 | _supported_proto file | ||
473 | # This test will set refcount_bits on its own which would conflict with the | ||
474 | -# manual setting; compat will be overridden as well | ||
475 | -_unsupported_imgopts refcount_bits 'compat=0.10' | ||
476 | +# manual setting; compat will be overridden as well; | ||
477 | +# and external data files do not work well with our refcount testing | ||
478 | +_unsupported_imgopts refcount_bits 'compat=0.10' data_file | ||
479 | |||
480 | print_refcount_bits() | ||
481 | { | ||
482 | diff --git a/tests/qemu-iotests/114 b/tests/qemu-iotests/114 | ||
483 | index XXXXXXX..XXXXXXX 100755 | ||
484 | --- a/tests/qemu-iotests/114 | ||
485 | +++ b/tests/qemu-iotests/114 | ||
486 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
487 | _supported_fmt qcow2 | ||
488 | _supported_proto generic | ||
489 | _unsupported_proto vxhs | ||
490 | +# qcow2.py does not work too well with external data files | ||
491 | +_unsupported_imgopts data_file | ||
492 | |||
493 | |||
494 | TEST_IMG="$TEST_IMG.base" _make_test_img 64M | ||
495 | diff --git a/tests/qemu-iotests/121 b/tests/qemu-iotests/121 | ||
496 | index XXXXXXX..XXXXXXX 100755 | ||
497 | --- a/tests/qemu-iotests/121 | ||
498 | +++ b/tests/qemu-iotests/121 | ||
499 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
500 | _supported_fmt qcow2 | ||
501 | _supported_proto file | ||
502 | _supported_os Linux | ||
503 | +# Refcount structures are used much differently with external data | ||
504 | +# files | ||
505 | +_unsupported_imgopts data_file | ||
506 | |||
507 | echo | ||
508 | echo '=== New refcount structures may not conflict with existing structures ===' | ||
509 | diff --git a/tests/qemu-iotests/138 b/tests/qemu-iotests/138 | ||
510 | index XXXXXXX..XXXXXXX 100755 | ||
511 | --- a/tests/qemu-iotests/138 | ||
512 | +++ b/tests/qemu-iotests/138 | ||
513 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
514 | _supported_fmt qcow2 | ||
515 | _supported_proto file | ||
516 | _supported_os Linux | ||
517 | +# With an external data file, data clusters are not refcounted | ||
518 | +# (and so qemu-img check does not check their refcount) | ||
519 | +_unsupported_imgopts data_file | ||
520 | |||
521 | echo | ||
522 | echo '=== Check on an image with a multiple of 2^32 clusters ===' | ||
523 | diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156 | ||
524 | index XXXXXXX..XXXXXXX 100755 | ||
525 | --- a/tests/qemu-iotests/156 | ||
526 | +++ b/tests/qemu-iotests/156 | ||
527 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
528 | _supported_fmt qcow2 qed | ||
529 | _supported_proto generic | ||
530 | _unsupported_proto vxhs | ||
531 | +# Copying files around with cp does not work with external data files | ||
532 | +_unsupported_imgopts data_file | ||
533 | |||
534 | # Create source disk | ||
535 | TEST_IMG="$TEST_IMG.backing" _make_test_img 1M | ||
536 | diff --git a/tests/qemu-iotests/176 b/tests/qemu-iotests/176 | ||
537 | index XXXXXXX..XXXXXXX 100755 | ||
538 | --- a/tests/qemu-iotests/176 | ||
539 | +++ b/tests/qemu-iotests/176 | ||
540 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
541 | _supported_fmt qcow2 | ||
542 | _supported_proto file | ||
543 | _supported_os Linux | ||
544 | -# Persistent dirty bitmaps require compat=1.1 | ||
545 | -_unsupported_imgopts 'compat=0.10' | ||
546 | +# Persistent dirty bitmaps require compat=1.1; | ||
547 | +# Internal snapshots forbid using an external data file | ||
548 | +# (they work with refcount_bits=1 here, though, because there actually | ||
549 | +# is no data when creating the snapshot) | ||
550 | +_unsupported_imgopts 'compat=0.10' data_file | ||
551 | |||
552 | run_qemu() | ||
553 | { | ||
554 | diff --git a/tests/qemu-iotests/191 b/tests/qemu-iotests/191 | ||
555 | index XXXXXXX..XXXXXXX 100755 | ||
556 | --- a/tests/qemu-iotests/191 | ||
557 | +++ b/tests/qemu-iotests/191 | ||
558 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
559 | |||
560 | _supported_fmt qcow2 | ||
561 | _supported_proto file | ||
562 | +# An external data file would change the query-named-block-nodes output | ||
563 | +_unsupported_imgopts data_file | ||
564 | |||
565 | size=64M | ||
566 | |||
567 | diff --git a/tests/qemu-iotests/201 b/tests/qemu-iotests/201 | ||
568 | index XXXXXXX..XXXXXXX 100755 | ||
569 | --- a/tests/qemu-iotests/201 | ||
570 | +++ b/tests/qemu-iotests/201 | ||
571 | @@ -XXX,XX +XXX,XX @@ _supported_fmt qcow2 | ||
572 | _supported_proto generic | ||
573 | _supported_os Linux | ||
574 | |||
575 | -# Internal snapshots are (currently) impossible with refcount_bits=1 | ||
576 | -# This was taken from test 080 | ||
577 | -_unsupported_imgopts 'refcount_bits=1[^0-9]' | ||
578 | +# Internal snapshots are (currently) impossible with refcount_bits=1, | ||
579 | +# and generally impossible with external data files | ||
580 | +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file | ||
581 | |||
582 | size=64M | ||
583 | _make_test_img $size | ||
584 | diff --git a/tests/qemu-iotests/214 b/tests/qemu-iotests/214 | ||
585 | index XXXXXXX..XXXXXXX 100755 | ||
586 | --- a/tests/qemu-iotests/214 | ||
587 | +++ b/tests/qemu-iotests/214 | ||
588 | @@ -XXX,XX +XXX,XX @@ _supported_proto file | ||
589 | |||
590 | # Repairing the corrupted image requires qemu-img check to store a | ||
591 | # refcount up to 3, which requires at least two refcount bits. | ||
592 | -_unsupported_imgopts 'refcount_bits=1[^0-9]' | ||
593 | +# External data files do not support compressed clusters. | ||
594 | +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file | ||
595 | |||
596 | |||
597 | echo | ||
598 | diff --git a/tests/qemu-iotests/217 b/tests/qemu-iotests/217 | ||
599 | index XXXXXXX..XXXXXXX 100755 | ||
600 | --- a/tests/qemu-iotests/217 | ||
601 | +++ b/tests/qemu-iotests/217 | ||
602 | @@ -XXX,XX +XXX,XX @@ _supported_proto file | ||
603 | |||
604 | # This test needs clusters with at least a refcount of 2 so that | ||
605 | # OFLAG_COPIED is not set. refcount_bits=1 is therefore unsupported. | ||
606 | -_unsupported_imgopts 'refcount_bits=1[^0-9]' | ||
607 | +# (As are external data files.) | ||
608 | +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file | ||
609 | |||
610 | echo | ||
611 | echo '=== Simulating an I/O error during snapshot deletion ===' | ||
612 | diff --git a/tests/qemu-iotests/220 b/tests/qemu-iotests/220 | ||
613 | index XXXXXXX..XXXXXXX 100755 | ||
614 | --- a/tests/qemu-iotests/220 | ||
615 | +++ b/tests/qemu-iotests/220 | ||
616 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
617 | _supported_fmt qcow2 | ||
618 | _supported_proto file | ||
619 | _supported_os Linux | ||
620 | -# To use a different refcount width but 16 bits we need compat=1.1 | ||
621 | -_unsupported_imgopts 'compat=0.10' | ||
622 | +# To use a different refcount width but 16 bits we need compat=1.1, | ||
623 | +# and external data files do not support compressed clusters. | ||
624 | +_unsupported_imgopts 'compat=0.10' data_file | ||
625 | |||
626 | echo "== Creating huge file ==" | ||
627 | |||
628 | diff --git a/tests/qemu-iotests/243 b/tests/qemu-iotests/243 | ||
629 | index XXXXXXX..XXXXXXX 100755 | ||
630 | --- a/tests/qemu-iotests/243 | ||
631 | +++ b/tests/qemu-iotests/243 | ||
632 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
633 | _supported_fmt qcow2 | ||
634 | _supported_proto file | ||
635 | _supported_os Linux | ||
636 | -# External data files do not work with compat=0.10 | ||
637 | -_unsupported_imgopts 'compat=0.10' | ||
638 | +# External data files do not work with compat=0.10, and because there | ||
639 | +# is an explicit case for external data files here, we cannot allow | ||
640 | +# the user to specify whether to use one | ||
641 | +_unsupported_imgopts 'compat=0.10' data_file | ||
642 | |||
643 | for mode in off metadata falloc full; do | ||
644 | |||
645 | diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244 | ||
646 | index XXXXXXX..XXXXXXX 100755 | ||
647 | --- a/tests/qemu-iotests/244 | ||
648 | +++ b/tests/qemu-iotests/244 | ||
649 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
650 | _supported_fmt qcow2 | ||
651 | _supported_proto file | ||
652 | _supported_os Linux | ||
653 | -# External data files do not work with compat=0.10 | ||
654 | -_unsupported_imgopts 'compat=0.10' | ||
655 | +# External data files do not work with compat=0.10, and because we use | ||
656 | +# our own external data file, we cannot let the user specify one | ||
657 | +_unsupported_imgopts 'compat=0.10' data_file | ||
658 | |||
659 | echo | ||
660 | echo "=== Create and open image with external data file ===" | ||
661 | diff --git a/tests/qemu-iotests/250 b/tests/qemu-iotests/250 | ||
662 | index XXXXXXX..XXXXXXX 100755 | ||
663 | --- a/tests/qemu-iotests/250 | ||
664 | +++ b/tests/qemu-iotests/250 | ||
665 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
666 | _supported_fmt qcow2 | ||
667 | _supported_proto file | ||
668 | _supported_os Linux | ||
669 | +# This test does not make much sense with external data files | ||
670 | +_unsupported_imgopts data_file | ||
671 | |||
672 | # This test checks that qcow2_process_discards does not truncate a discard | ||
673 | # request > 2G. | ||
674 | diff --git a/tests/qemu-iotests/261 b/tests/qemu-iotests/261 | ||
675 | index XXXXXXX..XXXXXXX 100755 | ||
676 | --- a/tests/qemu-iotests/261 | ||
677 | +++ b/tests/qemu-iotests/261 | ||
678 | @@ -XXX,XX +XXX,XX @@ _supported_os Linux | ||
679 | # (1) We create a v2 image that supports nothing but refcount_bits=16 | ||
680 | # (2) We do some refcount management on our own which expects | ||
681 | # refcount_bits=16 | ||
682 | -_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' | ||
683 | +# As for data files, they do not support snapshots at all. | ||
684 | +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' data_file | ||
685 | |||
686 | # Parameters: | ||
687 | # $1: image filename | ||
688 | diff --git a/tests/qemu-iotests/267 b/tests/qemu-iotests/267 | ||
689 | index XXXXXXX..XXXXXXX 100755 | ||
690 | --- a/tests/qemu-iotests/267 | ||
691 | +++ b/tests/qemu-iotests/267 | ||
692 | @@ -XXX,XX +XXX,XX @@ _supported_proto file | ||
693 | _supported_os Linux | ||
694 | _require_drivers copy-on-read | ||
695 | |||
696 | -# Internal snapshots are (currently) impossible with refcount_bits=1 | ||
697 | -_unsupported_imgopts 'refcount_bits=1[^0-9]' | ||
698 | +# Internal snapshots are (currently) impossible with refcount_bits=1, | ||
699 | +# and generally impossible with external data files | ||
700 | +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file | ||
701 | |||
702 | do_run_qemu() | ||
703 | { | ||
704 | diff --git a/tests/qemu-iotests/273 b/tests/qemu-iotests/273 | ||
705 | index XXXXXXX..XXXXXXX 100755 | ||
706 | --- a/tests/qemu-iotests/273 | ||
707 | +++ b/tests/qemu-iotests/273 | ||
708 | @@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15 | ||
709 | _supported_fmt qcow2 | ||
710 | _supported_proto file | ||
711 | _supported_os Linux | ||
712 | +# External data files would add nodes to the block graph, so it would | ||
713 | +# not match the reference output | ||
714 | +_unsupported_imgopts data_file | ||
715 | |||
716 | do_run_qemu() | ||
717 | { | ||
718 | -- | ||
719 | 2.24.1 | ||
720 | |||
721 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | The problem with allowing the data_file option is that you want to use a | ||
2 | different data file per image used in the test. Therefore, we need to | ||
3 | allow patterns like -o data_file='$TEST_IMG.data_file'. | ||
4 | 1 | ||
5 | Then, we need to filter it out from qemu-img map, qemu-img create, and | ||
6 | remove the data file in _rm_test_img. | ||
7 | |||
8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
9 | Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com> | ||
10 | Message-id: 20191107163708.833192-23-mreitz@redhat.com | ||
11 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
12 | --- | ||
13 | tests/qemu-iotests/common.filter | 23 +++++++++++++++++++++-- | ||
14 | tests/qemu-iotests/common.rc | 22 +++++++++++++++++++++- | ||
15 | 2 files changed, 42 insertions(+), 3 deletions(-) | ||
16 | |||
17 | diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter | ||
18 | index XXXXXXX..XXXXXXX 100644 | ||
19 | --- a/tests/qemu-iotests/common.filter | ||
20 | +++ b/tests/qemu-iotests/common.filter | ||
21 | @@ -XXX,XX +XXX,XX @@ _filter_actual_image_size() | ||
22 | # replace driver-specific options in the "Formatting..." line | ||
23 | _filter_img_create() | ||
24 | { | ||
25 | - $SED -e "s#$REMOTE_TEST_DIR#TEST_DIR#g" \ | ||
26 | + data_file_filter=() | ||
27 | + if data_file=$(_get_data_file "$TEST_IMG"); then | ||
28 | + data_file_filter=(-e "s# data_file=$data_file##") | ||
29 | + fi | ||
30 | + | ||
31 | + $SED "${data_file_filter[@]}" \ | ||
32 | + -e "s#$REMOTE_TEST_DIR#TEST_DIR#g" \ | ||
33 | -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \ | ||
34 | -e "s#$TEST_DIR#TEST_DIR#g" \ | ||
35 | -e "s#$SOCK_DIR#SOCK_DIR#g" \ | ||
36 | @@ -XXX,XX +XXX,XX @@ _filter_img_info() | ||
37 | # human and json output | ||
38 | _filter_qemu_img_map() | ||
39 | { | ||
40 | + # Assuming the data_file value in $IMGOPTS contains a '$TEST_IMG', | ||
41 | + # create a filter that replaces the data file name by $TEST_IMG. | ||
42 | + # Example: | ||
43 | + # In $IMGOPTS: 'data_file=$TEST_IMG.data_file' | ||
44 | + # Then data_file_pattern == '\(.*\).data_file' | ||
45 | + # And data_file_filter == -e 's#\(.*\).data_file#\1# | ||
46 | + data_file_filter=() | ||
47 | + if data_file_pattern=$(_get_data_file '\\(.*\\)'); then | ||
48 | + data_file_filter=(-e "s#$data_file_pattern#\\1#") | ||
49 | + fi | ||
50 | + | ||
51 | $SED -e 's/\([0-9a-fx]* *[0-9a-fx]* *\)[0-9a-fx]* */\1/g' \ | ||
52 | -e 's/"offset": [0-9]\+/"offset": OFFSET/g' \ | ||
53 | - -e 's/Mapped to *//' | _filter_testdir | _filter_imgfmt | ||
54 | + -e 's/Mapped to *//' \ | ||
55 | + "${data_file_filter[@]}" \ | ||
56 | + | _filter_testdir | _filter_imgfmt | ||
57 | } | ||
58 | |||
59 | _filter_nbd() | ||
60 | diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc | ||
61 | index XXXXXXX..XXXXXXX 100644 | ||
62 | --- a/tests/qemu-iotests/common.rc | ||
63 | +++ b/tests/qemu-iotests/common.rc | ||
64 | @@ -XXX,XX +XXX,XX @@ _stop_nbd_server() | ||
65 | fi | ||
66 | } | ||
67 | |||
68 | +# Gets the data_file value from IMGOPTS and replaces the '$TEST_IMG' | ||
69 | +# pattern by '$1' | ||
70 | +# Caution: The replacement is done with sed, so $1 must be escaped | ||
71 | +# properly. (The delimiter is '#'.) | ||
72 | +_get_data_file() | ||
73 | +{ | ||
74 | + if ! echo "$IMGOPTS" | grep -q 'data_file='; then | ||
75 | + return 1 | ||
76 | + fi | ||
77 | + | ||
78 | + echo "$IMGOPTS" | sed -e 's/.*data_file=\([^,]*\).*/\1/' \ | ||
79 | + | sed -e "s#\\\$TEST_IMG#$1#" | ||
80 | +} | ||
81 | + | ||
82 | _make_test_img() | ||
83 | { | ||
84 | # extra qemu-img options can be added by tests | ||
85 | @@ -XXX,XX +XXX,XX @@ _make_test_img() | ||
86 | fi | ||
87 | |||
88 | if [ -n "$IMGOPTS" ]; then | ||
89 | - optstr=$(_optstr_add "$optstr" "$IMGOPTS") | ||
90 | + imgopts_expanded=$(echo "$IMGOPTS" | sed -e "s#\\\$TEST_IMG#$img_name#") | ||
91 | + optstr=$(_optstr_add "$optstr" "$imgopts_expanded") | ||
92 | fi | ||
93 | if [ -n "$IMGKEYSECRET" ]; then | ||
94 | object_options="--object secret,id=keysec0,data=$IMGKEYSECRET" | ||
95 | @@ -XXX,XX +XXX,XX @@ _rm_test_img() | ||
96 | # Remove all the extents for vmdk | ||
97 | "$QEMU_IMG" info "$img" 2>/dev/null | grep 'filename:' | cut -f 2 -d: \ | ||
98 | | xargs -I {} rm -f "{}" | ||
99 | + elif [ "$IMGFMT" = "qcow2" ]; then | ||
100 | + # Remove external data file | ||
101 | + if data_file=$(_get_data_file "$img"); then | ||
102 | + rm -f "$data_file" | ||
103 | + fi | ||
104 | fi | ||
105 | rm -f "$img" | ||
106 | } | ||
107 | -- | ||
108 | 2.24.1 | ||
109 | |||
110 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | From: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com> | ||
2 | 1 | ||
3 | Allow writing all the data compressed through the filter driver. | ||
4 | The written data will be aligned by the cluster size. | ||
5 | Based on the QEMU current implementation, that data can be written to | ||
6 | unallocated clusters only. May be used for a backup job. | ||
7 | |||
8 | Suggested-by: Max Reitz <mreitz@redhat.com> | ||
9 | Signed-off-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com> | ||
10 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
11 | Message-id: 1575288906-551879-2-git-send-email-andrey.shinkevich@virtuozzo.com | ||
12 | [mreitz: Replace NULL bdrv_get_format_name() by "(no format)"] | ||
13 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
14 | --- | ||
15 | block/Makefile.objs | 1 + | ||
16 | block/filter-compress.c | 168 ++++++++++++++++++++++++++++++++++++++++ | ||
17 | qapi/block-core.json | 10 ++- | ||
18 | 3 files changed, 175 insertions(+), 4 deletions(-) | ||
19 | create mode 100644 block/filter-compress.c | ||
20 | |||
21 | diff --git a/block/Makefile.objs b/block/Makefile.objs | ||
22 | index XXXXXXX..XXXXXXX 100644 | ||
23 | --- a/block/Makefile.objs | ||
24 | +++ b/block/Makefile.objs | ||
25 | @@ -XXX,XX +XXX,XX @@ block-obj-y += crypto.o | ||
26 | |||
27 | block-obj-y += aio_task.o | ||
28 | block-obj-y += backup-top.o | ||
29 | +block-obj-y += filter-compress.o | ||
30 | |||
31 | common-obj-y += stream.o | ||
32 | |||
33 | diff --git a/block/filter-compress.c b/block/filter-compress.c | ||
34 | new file mode 100644 | ||
35 | index XXXXXXX..XXXXXXX | ||
36 | --- /dev/null | ||
37 | +++ b/block/filter-compress.c | ||
38 | @@ -XXX,XX +XXX,XX @@ | ||
39 | +/* | ||
40 | + * Compress filter block driver | ||
41 | + * | ||
42 | + * Copyright (c) 2019 Virtuozzo International GmbH | ||
43 | + * | ||
44 | + * Author: | ||
45 | + * Andrey Shinkevich <andrey.shinkevich@virtuozzo.com> | ||
46 | + * (based on block/copy-on-read.c by Max Reitz) | ||
47 | + * | ||
48 | + * This program is free software; you can redistribute it and/or | ||
49 | + * modify it under the terms of the GNU General Public License as | ||
50 | + * published by the Free Software Foundation; either version 2 or | ||
51 | + * (at your option) any later version of the License. | ||
52 | + * | ||
53 | + * This program is distributed in the hope that it will be useful, | ||
54 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
55 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
56 | + * GNU General Public License for more details. | ||
57 | + * | ||
58 | + * You should have received a copy of the GNU General Public License | ||
59 | + * along with this program; if not, see <http://www.gnu.org/licenses/>. | ||
60 | + */ | ||
61 | + | ||
62 | +#include "qemu/osdep.h" | ||
63 | +#include "block/block_int.h" | ||
64 | +#include "qemu/module.h" | ||
65 | +#include "qapi/error.h" | ||
66 | + | ||
67 | + | ||
68 | +static int compress_open(BlockDriverState *bs, QDict *options, int flags, | ||
69 | + Error **errp) | ||
70 | +{ | ||
71 | + bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, false, | ||
72 | + errp); | ||
73 | + if (!bs->file) { | ||
74 | + return -EINVAL; | ||
75 | + } | ||
76 | + | ||
77 | + if (!bs->file->bs->drv || !block_driver_can_compress(bs->file->bs->drv)) { | ||
78 | + error_setg(errp, | ||
79 | + "Compression is not supported for underlying format: %s", | ||
80 | + bdrv_get_format_name(bs->file->bs) ?: "(no format)"); | ||
81 | + | ||
82 | + return -ENOTSUP; | ||
83 | + } | ||
84 | + | ||
85 | + bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED | | ||
86 | + (BDRV_REQ_FUA & bs->file->bs->supported_write_flags); | ||
87 | + | ||
88 | + bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED | | ||
89 | + ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) & | ||
90 | + bs->file->bs->supported_zero_flags); | ||
91 | + | ||
92 | + return 0; | ||
93 | +} | ||
94 | + | ||
95 | + | ||
96 | +static int64_t compress_getlength(BlockDriverState *bs) | ||
97 | +{ | ||
98 | + return bdrv_getlength(bs->file->bs); | ||
99 | +} | ||
100 | + | ||
101 | + | ||
102 | +static int coroutine_fn compress_co_preadv_part(BlockDriverState *bs, | ||
103 | + uint64_t offset, uint64_t bytes, | ||
104 | + QEMUIOVector *qiov, | ||
105 | + size_t qiov_offset, | ||
106 | + int flags) | ||
107 | +{ | ||
108 | + return bdrv_co_preadv_part(bs->file, offset, bytes, qiov, qiov_offset, | ||
109 | + flags); | ||
110 | +} | ||
111 | + | ||
112 | + | ||
113 | +static int coroutine_fn compress_co_pwritev_part(BlockDriverState *bs, | ||
114 | + uint64_t offset, | ||
115 | + uint64_t bytes, | ||
116 | + QEMUIOVector *qiov, | ||
117 | + size_t qiov_offset, int flags) | ||
118 | +{ | ||
119 | + return bdrv_co_pwritev_part(bs->file, offset, bytes, qiov, qiov_offset, | ||
120 | + flags | BDRV_REQ_WRITE_COMPRESSED); | ||
121 | +} | ||
122 | + | ||
123 | + | ||
124 | +static int coroutine_fn compress_co_pwrite_zeroes(BlockDriverState *bs, | ||
125 | + int64_t offset, int bytes, | ||
126 | + BdrvRequestFlags flags) | ||
127 | +{ | ||
128 | + return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags); | ||
129 | +} | ||
130 | + | ||
131 | + | ||
132 | +static int coroutine_fn compress_co_pdiscard(BlockDriverState *bs, | ||
133 | + int64_t offset, int bytes) | ||
134 | +{ | ||
135 | + return bdrv_co_pdiscard(bs->file, offset, bytes); | ||
136 | +} | ||
137 | + | ||
138 | + | ||
139 | +static void compress_refresh_limits(BlockDriverState *bs, Error **errp) | ||
140 | +{ | ||
141 | + BlockDriverInfo bdi; | ||
142 | + int ret; | ||
143 | + | ||
144 | + if (!bs->file) { | ||
145 | + return; | ||
146 | + } | ||
147 | + | ||
148 | + ret = bdrv_get_info(bs->file->bs, &bdi); | ||
149 | + if (ret < 0 || bdi.cluster_size == 0) { | ||
150 | + return; | ||
151 | + } | ||
152 | + | ||
153 | + bs->bl.request_alignment = bdi.cluster_size; | ||
154 | +} | ||
155 | + | ||
156 | + | ||
157 | +static void compress_eject(BlockDriverState *bs, bool eject_flag) | ||
158 | +{ | ||
159 | + bdrv_eject(bs->file->bs, eject_flag); | ||
160 | +} | ||
161 | + | ||
162 | + | ||
163 | +static void compress_lock_medium(BlockDriverState *bs, bool locked) | ||
164 | +{ | ||
165 | + bdrv_lock_medium(bs->file->bs, locked); | ||
166 | +} | ||
167 | + | ||
168 | + | ||
169 | +static bool compress_recurse_is_first_non_filter(BlockDriverState *bs, | ||
170 | + BlockDriverState *candidate) | ||
171 | +{ | ||
172 | + return bdrv_recurse_is_first_non_filter(bs->file->bs, candidate); | ||
173 | +} | ||
174 | + | ||
175 | + | ||
176 | +static BlockDriver bdrv_compress = { | ||
177 | + .format_name = "compress", | ||
178 | + | ||
179 | + .bdrv_open = compress_open, | ||
180 | + .bdrv_child_perm = bdrv_filter_default_perms, | ||
181 | + | ||
182 | + .bdrv_getlength = compress_getlength, | ||
183 | + | ||
184 | + .bdrv_co_preadv_part = compress_co_preadv_part, | ||
185 | + .bdrv_co_pwritev_part = compress_co_pwritev_part, | ||
186 | + .bdrv_co_pwrite_zeroes = compress_co_pwrite_zeroes, | ||
187 | + .bdrv_co_pdiscard = compress_co_pdiscard, | ||
188 | + .bdrv_refresh_limits = compress_refresh_limits, | ||
189 | + | ||
190 | + .bdrv_eject = compress_eject, | ||
191 | + .bdrv_lock_medium = compress_lock_medium, | ||
192 | + | ||
193 | + .bdrv_co_block_status = bdrv_co_block_status_from_file, | ||
194 | + | ||
195 | + .bdrv_recurse_is_first_non_filter = compress_recurse_is_first_non_filter, | ||
196 | + | ||
197 | + .has_variable_length = true, | ||
198 | + .is_filter = true, | ||
199 | +}; | ||
200 | + | ||
201 | +static void bdrv_compress_init(void) | ||
202 | +{ | ||
203 | + bdrv_register(&bdrv_compress); | ||
204 | +} | ||
205 | + | ||
206 | +block_init(bdrv_compress_init); | ||
207 | diff --git a/qapi/block-core.json b/qapi/block-core.json | ||
208 | index XXXXXXX..XXXXXXX 100644 | ||
209 | --- a/qapi/block-core.json | ||
210 | +++ b/qapi/block-core.json | ||
211 | @@ -XXX,XX +XXX,XX @@ | ||
212 | # @copy-on-read: Since 3.0 | ||
213 | # @blklogwrites: Since 3.0 | ||
214 | # @blkreplay: Since 4.2 | ||
215 | +# @compress: Since 5.0 | ||
216 | # | ||
217 | # Since: 2.9 | ||
218 | ## | ||
219 | { 'enum': 'BlockdevDriver', | ||
220 | 'data': [ 'blkdebug', 'blklogwrites', 'blkreplay', 'blkverify', 'bochs', | ||
221 | - 'cloop', 'copy-on-read', 'dmg', 'file', 'ftp', 'ftps', 'gluster', | ||
222 | - 'host_cdrom', 'host_device', 'http', 'https', 'iscsi', 'luks', | ||
223 | - 'nbd', 'nfs', 'null-aio', 'null-co', 'nvme', 'parallels', 'qcow', | ||
224 | - 'qcow2', 'qed', 'quorum', 'raw', 'rbd', | ||
225 | + 'cloop', 'compress', 'copy-on-read', 'dmg', 'file', 'ftp', 'ftps', | ||
226 | + 'gluster', 'host_cdrom', 'host_device', 'http', 'https', 'iscsi', | ||
227 | + 'luks', 'nbd', 'nfs', 'null-aio', 'null-co', 'nvme', 'parallels', | ||
228 | + 'qcow', 'qcow2', 'qed', 'quorum', 'raw', 'rbd', | ||
229 | { 'name': 'replication', 'if': 'defined(CONFIG_REPLICATION)' }, | ||
230 | 'sheepdog', | ||
231 | 'ssh', 'throttle', 'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] } | ||
232 | @@ -XXX,XX +XXX,XX @@ | ||
233 | 'blkreplay': 'BlockdevOptionsBlkreplay', | ||
234 | 'bochs': 'BlockdevOptionsGenericFormat', | ||
235 | 'cloop': 'BlockdevOptionsGenericFormat', | ||
236 | + 'compress': 'BlockdevOptionsGenericFormat', | ||
237 | 'copy-on-read':'BlockdevOptionsGenericFormat', | ||
238 | 'dmg': 'BlockdevOptionsGenericFormat', | ||
239 | 'file': 'BlockdevOptionsFile', | ||
240 | -- | ||
241 | 2.24.1 | ||
242 | |||
243 | diff view generated by jsdifflib |
1 | From: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com> | 1 | The term "iothread lock" is obsolete. The APIs use Big QEMU Lock (BQL) |
---|---|---|---|
2 | in their names. Update the code comments to use "BQL" instead of | ||
3 | "iothread lock". | ||
2 | 4 | ||
3 | QEMU currently supports writing compressed data of the size equal to | 5 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
4 | one cluster. This patch allows writing QCOW2 compressed data that | 6 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
5 | exceed one cluster. Now, we split buffered data into separate clusters | 7 | Reviewed-by: Paul Durrant <paul@xen.org> |
6 | and write them compressed using the block/aio_task API. | 8 | Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com> |
9 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | ||
10 | Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com> | ||
11 | Message-id: 20240102153529.486531-5-stefanha@redhat.com | ||
12 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
13 | --- | ||
14 | docs/devel/reset.rst | 2 +- | ||
15 | hw/display/qxl.h | 2 +- | ||
16 | include/exec/cpu-common.h | 2 +- | ||
17 | include/exec/memory.h | 4 ++-- | ||
18 | include/exec/ramblock.h | 2 +- | ||
19 | include/migration/register.h | 8 ++++---- | ||
20 | target/arm/internals.h | 4 ++-- | ||
21 | accel/tcg/cputlb.c | 4 ++-- | ||
22 | accel/tcg/tcg-accel-ops-icount.c | 2 +- | ||
23 | hw/remote/mpqemu-link.c | 2 +- | ||
24 | migration/block-dirty-bitmap.c | 10 +++++----- | ||
25 | migration/block.c | 22 +++++++++++----------- | ||
26 | migration/colo.c | 2 +- | ||
27 | migration/migration.c | 2 +- | ||
28 | migration/ram.c | 4 ++-- | ||
29 | system/physmem.c | 6 +++--- | ||
30 | target/arm/helper.c | 2 +- | ||
31 | ui/spice-core.c | 2 +- | ||
32 | util/rcu.c | 2 +- | ||
33 | audio/coreaudio.m | 4 ++-- | ||
34 | ui/cocoa.m | 6 +++--- | ||
35 | 21 files changed, 47 insertions(+), 47 deletions(-) | ||
7 | 36 | ||
8 | Suggested-by: Pavel Butsykin <pbutsykin@virtuozzo.com> | 37 | diff --git a/docs/devel/reset.rst b/docs/devel/reset.rst |
9 | Suggested-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | 38 | index XXXXXXX..XXXXXXX 100644 |
10 | Signed-off-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com> | 39 | --- a/docs/devel/reset.rst |
11 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | 40 | +++ b/docs/devel/reset.rst |
12 | Reviewed-by: Max Reitz <mreitz@redhat.com> | 41 | @@ -XXX,XX +XXX,XX @@ Triggering reset |
13 | Message-id: 1575288906-551879-3-git-send-email-andrey.shinkevich@virtuozzo.com | 42 | |
14 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 43 | This section documents the APIs which "users" of a resettable object should use |
15 | --- | 44 | to control it. All resettable control functions must be called while holding |
16 | block/qcow2.c | 102 +++++++++++++++++++++++++++++++++++++------------- | 45 | -the iothread lock. |
17 | 1 file changed, 75 insertions(+), 27 deletions(-) | 46 | +the BQL. |
18 | 47 | ||
19 | diff --git a/block/qcow2.c b/block/qcow2.c | 48 | You can apply a reset to an object using ``resettable_assert_reset()``. You need |
20 | index XXXXXXX..XXXXXXX 100644 | 49 | to call ``resettable_release_reset()`` to release the object from reset. To |
21 | --- a/block/qcow2.c | 50 | diff --git a/hw/display/qxl.h b/hw/display/qxl.h |
22 | +++ b/block/qcow2.c | 51 | index XXXXXXX..XXXXXXX 100644 |
52 | --- a/hw/display/qxl.h | ||
53 | +++ b/hw/display/qxl.h | ||
54 | @@ -XXX,XX +XXX,XX @@ OBJECT_DECLARE_SIMPLE_TYPE(PCIQXLDevice, PCI_QXL) | ||
55 | * | ||
56 | * Use with care; by the time this function returns, the returned pointer is | ||
57 | * not protected by RCU anymore. If the caller is not within an RCU critical | ||
58 | - * section and does not hold the iothread lock, it must have other means of | ||
59 | + * section and does not hold the BQL, it must have other means of | ||
60 | * protecting the pointer, such as a reference to the region that includes | ||
61 | * the incoming ram_addr_t. | ||
62 | * | ||
63 | diff --git a/include/exec/cpu-common.h b/include/exec/cpu-common.h | ||
64 | index XXXXXXX..XXXXXXX 100644 | ||
65 | --- a/include/exec/cpu-common.h | ||
66 | +++ b/include/exec/cpu-common.h | ||
67 | @@ -XXX,XX +XXX,XX @@ RAMBlock *qemu_ram_block_by_name(const char *name); | ||
68 | * | ||
69 | * By the time this function returns, the returned pointer is not protected | ||
70 | * by RCU anymore. If the caller is not within an RCU critical section and | ||
71 | - * does not hold the iothread lock, it must have other means of protecting the | ||
72 | + * does not hold the BQL, it must have other means of protecting the | ||
73 | * pointer, such as a reference to the memory region that owns the RAMBlock. | ||
74 | */ | ||
75 | RAMBlock *qemu_ram_block_from_host(void *ptr, bool round_offset, | ||
76 | diff --git a/include/exec/memory.h b/include/exec/memory.h | ||
77 | index XXXXXXX..XXXXXXX 100644 | ||
78 | --- a/include/exec/memory.h | ||
79 | +++ b/include/exec/memory.h | ||
80 | @@ -XXX,XX +XXX,XX @@ int memory_region_get_fd(MemoryRegion *mr); | ||
81 | * | ||
82 | * Use with care; by the time this function returns, the returned pointer is | ||
83 | * not protected by RCU anymore. If the caller is not within an RCU critical | ||
84 | - * section and does not hold the iothread lock, it must have other means of | ||
85 | + * section and does not hold the BQL, it must have other means of | ||
86 | * protecting the pointer, such as a reference to the region that includes | ||
87 | * the incoming ram_addr_t. | ||
88 | * | ||
89 | @@ -XXX,XX +XXX,XX @@ MemoryRegion *memory_region_from_host(void *ptr, ram_addr_t *offset); | ||
90 | * | ||
91 | * Use with care; by the time this function returns, the returned pointer is | ||
92 | * not protected by RCU anymore. If the caller is not within an RCU critical | ||
93 | - * section and does not hold the iothread lock, it must have other means of | ||
94 | + * section and does not hold the BQL, it must have other means of | ||
95 | * protecting the pointer, such as a reference to the region that includes | ||
96 | * the incoming ram_addr_t. | ||
97 | * | ||
98 | diff --git a/include/exec/ramblock.h b/include/exec/ramblock.h | ||
99 | index XXXXXXX..XXXXXXX 100644 | ||
100 | --- a/include/exec/ramblock.h | ||
101 | +++ b/include/exec/ramblock.h | ||
102 | @@ -XXX,XX +XXX,XX @@ struct RAMBlock { | ||
103 | ram_addr_t max_length; | ||
104 | void (*resized)(const char*, uint64_t length, void *host); | ||
105 | uint32_t flags; | ||
106 | - /* Protected by iothread lock. */ | ||
107 | + /* Protected by the BQL. */ | ||
108 | char idstr[256]; | ||
109 | /* RCU-enabled, writes protected by the ramlist lock */ | ||
110 | QLIST_ENTRY(RAMBlock) next; | ||
111 | diff --git a/include/migration/register.h b/include/migration/register.h | ||
112 | index XXXXXXX..XXXXXXX 100644 | ||
113 | --- a/include/migration/register.h | ||
114 | +++ b/include/migration/register.h | ||
115 | @@ -XXX,XX +XXX,XX @@ | ||
116 | #include "hw/vmstate-if.h" | ||
117 | |||
118 | typedef struct SaveVMHandlers { | ||
119 | - /* This runs inside the iothread lock. */ | ||
120 | + /* This runs inside the BQL. */ | ||
121 | SaveStateHandler *save_state; | ||
122 | |||
123 | /* | ||
124 | @@ -XXX,XX +XXX,XX @@ typedef struct SaveVMHandlers { | ||
125 | int (*save_live_complete_postcopy)(QEMUFile *f, void *opaque); | ||
126 | int (*save_live_complete_precopy)(QEMUFile *f, void *opaque); | ||
127 | |||
128 | - /* This runs both outside and inside the iothread lock. */ | ||
129 | + /* This runs both outside and inside the BQL. */ | ||
130 | bool (*is_active)(void *opaque); | ||
131 | bool (*has_postcopy)(void *opaque); | ||
132 | |||
133 | @@ -XXX,XX +XXX,XX @@ typedef struct SaveVMHandlers { | ||
134 | */ | ||
135 | bool (*is_active_iterate)(void *opaque); | ||
136 | |||
137 | - /* This runs outside the iothread lock in the migration case, and | ||
138 | + /* This runs outside the BQL in the migration case, and | ||
139 | * within the lock in the savevm case. The callback had better only | ||
140 | * use data that is local to the migration thread or protected | ||
141 | * by other locks. | ||
142 | */ | ||
143 | int (*save_live_iterate)(QEMUFile *f, void *opaque); | ||
144 | |||
145 | - /* This runs outside the iothread lock! */ | ||
146 | + /* This runs outside the BQL! */ | ||
147 | /* Note for save_live_pending: | ||
148 | * must_precopy: | ||
149 | * - must be migrated in precopy or in stopped state | ||
150 | diff --git a/target/arm/internals.h b/target/arm/internals.h | ||
151 | index XXXXXXX..XXXXXXX 100644 | ||
152 | --- a/target/arm/internals.h | ||
153 | +++ b/target/arm/internals.h | ||
154 | @@ -XXX,XX +XXX,XX @@ static inline const char *aarch32_mode_name(uint32_t psr) | ||
155 | * | ||
156 | * Update the CPU_INTERRUPT_VIRQ bit in cs->interrupt_request, following | ||
157 | * a change to either the input VIRQ line from the GIC or the HCR_EL2.VI bit. | ||
158 | - * Must be called with the iothread lock held. | ||
159 | + * Must be called with the BQL held. | ||
160 | */ | ||
161 | void arm_cpu_update_virq(ARMCPU *cpu); | ||
162 | |||
163 | @@ -XXX,XX +XXX,XX @@ void arm_cpu_update_virq(ARMCPU *cpu); | ||
164 | * | ||
165 | * Update the CPU_INTERRUPT_VFIQ bit in cs->interrupt_request, following | ||
166 | * a change to either the input VFIQ line from the GIC or the HCR_EL2.VF bit. | ||
167 | - * Must be called with the iothread lock held. | ||
168 | + * Must be called with the BQL held. | ||
169 | */ | ||
170 | void arm_cpu_update_vfiq(ARMCPU *cpu); | ||
171 | |||
172 | diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c | ||
173 | index XXXXXXX..XXXXXXX 100644 | ||
174 | --- a/accel/tcg/cputlb.c | ||
175 | +++ b/accel/tcg/cputlb.c | ||
176 | @@ -XXX,XX +XXX,XX @@ static void *atomic_mmu_lookup(CPUState *cpu, vaddr addr, MemOpIdx oi, | ||
177 | * @size: number of bytes | ||
178 | * @mmu_idx: virtual address context | ||
179 | * @ra: return address into tcg generated code, or 0 | ||
180 | - * Context: iothread lock held | ||
181 | + * Context: BQL held | ||
182 | * | ||
183 | * Load @size bytes from @addr, which is memory-mapped i/o. | ||
184 | * The bytes are concatenated in big-endian order with @ret_be. | ||
185 | @@ -XXX,XX +XXX,XX @@ static Int128 do_ld16_mmu(CPUState *cpu, vaddr addr, | ||
186 | * @size: number of bytes | ||
187 | * @mmu_idx: virtual address context | ||
188 | * @ra: return address into tcg generated code, or 0 | ||
189 | - * Context: iothread lock held | ||
190 | + * Context: BQL held | ||
191 | * | ||
192 | * Store @size bytes at @addr, which is memory-mapped i/o. | ||
193 | * The bytes to store are extracted in little-endian order from @val_le; | ||
194 | diff --git a/accel/tcg/tcg-accel-ops-icount.c b/accel/tcg/tcg-accel-ops-icount.c | ||
195 | index XXXXXXX..XXXXXXX 100644 | ||
196 | --- a/accel/tcg/tcg-accel-ops-icount.c | ||
197 | +++ b/accel/tcg/tcg-accel-ops-icount.c | ||
198 | @@ -XXX,XX +XXX,XX @@ void icount_prepare_for_run(CPUState *cpu, int64_t cpu_budget) | ||
199 | |||
200 | if (cpu->icount_budget == 0) { | ||
201 | /* | ||
202 | - * We're called without the iothread lock, so must take it while | ||
203 | + * We're called without the BQL, so must take it while | ||
204 | * we're calling timer handlers. | ||
205 | */ | ||
206 | bql_lock(); | ||
207 | diff --git a/hw/remote/mpqemu-link.c b/hw/remote/mpqemu-link.c | ||
208 | index XXXXXXX..XXXXXXX 100644 | ||
209 | --- a/hw/remote/mpqemu-link.c | ||
210 | +++ b/hw/remote/mpqemu-link.c | ||
211 | @@ -XXX,XX +XXX,XX @@ bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp) | ||
212 | assert(qemu_in_coroutine() || !iothread); | ||
213 | |||
214 | /* | ||
215 | - * Skip unlocking/locking iothread lock when the IOThread is running | ||
216 | + * Skip unlocking/locking BQL when the IOThread is running | ||
217 | * in co-routine context. Co-routine context is asserted above | ||
218 | * for IOThread case. | ||
219 | * Also skip lock handling while in a co-routine in the main context. | ||
220 | diff --git a/migration/block-dirty-bitmap.c b/migration/block-dirty-bitmap.c | ||
221 | index XXXXXXX..XXXXXXX 100644 | ||
222 | --- a/migration/block-dirty-bitmap.c | ||
223 | +++ b/migration/block-dirty-bitmap.c | ||
224 | @@ -XXX,XX +XXX,XX @@ static void send_bitmap_bits(QEMUFile *f, DBMSaveState *s, | ||
225 | g_free(buf); | ||
226 | } | ||
227 | |||
228 | -/* Called with iothread lock taken. */ | ||
229 | +/* Called with the BQL taken. */ | ||
230 | static void dirty_bitmap_do_save_cleanup(DBMSaveState *s) | ||
231 | { | ||
232 | SaveBitmapState *dbms; | ||
233 | @@ -XXX,XX +XXX,XX @@ static void dirty_bitmap_do_save_cleanup(DBMSaveState *s) | ||
234 | } | ||
235 | } | ||
236 | |||
237 | -/* Called with iothread lock taken. */ | ||
238 | +/* Called with the BQL taken. */ | ||
239 | static int add_bitmaps_to_list(DBMSaveState *s, BlockDriverState *bs, | ||
240 | const char *bs_name, GHashTable *alias_map) | ||
241 | { | ||
242 | @@ -XXX,XX +XXX,XX @@ static int add_bitmaps_to_list(DBMSaveState *s, BlockDriverState *bs, | ||
243 | return 0; | ||
244 | } | ||
245 | |||
246 | -/* Called with iothread lock taken. */ | ||
247 | +/* Called with the BQL taken. */ | ||
248 | static int init_dirty_bitmap_migration(DBMSaveState *s) | ||
249 | { | ||
250 | BlockDriverState *bs; | ||
251 | @@ -XXX,XX +XXX,XX @@ static int init_dirty_bitmap_migration(DBMSaveState *s) | ||
252 | BlockBackend *blk; | ||
253 | GHashTable *alias_map = NULL; | ||
254 | |||
255 | - /* Runs in the migration thread, but holds the iothread lock */ | ||
256 | + /* Runs in the migration thread, but holds the BQL */ | ||
257 | GLOBAL_STATE_CODE(); | ||
258 | GRAPH_RDLOCK_GUARD_MAINLOOP(); | ||
259 | |||
260 | @@ -XXX,XX +XXX,XX @@ static int dirty_bitmap_save_iterate(QEMUFile *f, void *opaque) | ||
261 | return s->bulk_completed; | ||
262 | } | ||
263 | |||
264 | -/* Called with iothread lock taken. */ | ||
265 | +/* Called with the BQL taken. */ | ||
266 | |||
267 | static int dirty_bitmap_save_complete(QEMUFile *f, void *opaque) | ||
268 | { | ||
269 | diff --git a/migration/block.c b/migration/block.c | ||
270 | index XXXXXXX..XXXXXXX 100644 | ||
271 | --- a/migration/block.c | ||
272 | +++ b/migration/block.c | ||
273 | @@ -XXX,XX +XXX,XX @@ typedef struct BlkMigState { | ||
274 | int prev_progress; | ||
275 | int bulk_completed; | ||
276 | |||
277 | - /* Lock must be taken _inside_ the iothread lock. */ | ||
278 | + /* Lock must be taken _inside_ the BQL. */ | ||
279 | QemuMutex lock; | ||
280 | } BlkMigState; | ||
281 | |||
282 | @@ -XXX,XX +XXX,XX @@ static void blk_mig_unlock(void) | ||
283 | qemu_mutex_unlock(&block_mig_state.lock); | ||
284 | } | ||
285 | |||
286 | -/* Must run outside of the iothread lock during the bulk phase, | ||
287 | +/* Must run outside of the BQL during the bulk phase, | ||
288 | * or the VM will stall. | ||
289 | */ | ||
290 | |||
291 | @@ -XXX,XX +XXX,XX @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds) | ||
292 | return (bmds->cur_sector >= total_sectors); | ||
293 | } | ||
294 | |||
295 | -/* Called with iothread lock taken. */ | ||
296 | +/* Called with the BQL taken. */ | ||
297 | |||
298 | static int set_dirty_tracking(void) | ||
299 | { | ||
23 | @@ -XXX,XX +XXX,XX @@ fail: | 300 | @@ -XXX,XX +XXX,XX @@ fail: |
24 | return ret; | 301 | return ret; |
25 | } | 302 | } |
26 | 303 | ||
27 | -/* XXX: put compressed sectors first, then all the cluster aligned | 304 | -/* Called with iothread lock taken. */ |
28 | - tables to avoid losing bytes in alignment */ | 305 | +/* Called with the BQL taken. */ |
29 | static coroutine_fn int | 306 | |
30 | -qcow2_co_pwritev_compressed_part(BlockDriverState *bs, | 307 | static void unset_dirty_tracking(void) |
31 | +qcow2_co_pwritev_compressed_task(BlockDriverState *bs, | 308 | { |
32 | uint64_t offset, uint64_t bytes, | 309 | @@ -XXX,XX +XXX,XX @@ static void blk_mig_reset_dirty_cursor(void) |
33 | QEMUIOVector *qiov, size_t qiov_offset) | ||
34 | { | ||
35 | @@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs, | ||
36 | uint8_t *buf, *out_buf; | ||
37 | uint64_t cluster_offset; | ||
38 | |||
39 | - if (has_data_file(bs)) { | ||
40 | - return -ENOTSUP; | ||
41 | - } | ||
42 | - | ||
43 | - if (bytes == 0) { | ||
44 | - /* align end of file to a sector boundary to ease reading with | ||
45 | - sector based I/Os */ | ||
46 | - int64_t len = bdrv_getlength(bs->file->bs); | ||
47 | - if (len < 0) { | ||
48 | - return len; | ||
49 | - } | ||
50 | - return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL); | ||
51 | - } | ||
52 | - | ||
53 | - if (offset_into_cluster(s, offset)) { | ||
54 | - return -EINVAL; | ||
55 | - } | ||
56 | + assert(bytes == s->cluster_size || (bytes < s->cluster_size && | ||
57 | + (offset + bytes == bs->total_sectors << BDRV_SECTOR_BITS))); | ||
58 | |||
59 | buf = qemu_blockalign(bs, s->cluster_size); | ||
60 | - if (bytes != s->cluster_size) { | ||
61 | - if (bytes > s->cluster_size || | ||
62 | - offset + bytes != bs->total_sectors << BDRV_SECTOR_BITS) | ||
63 | - { | ||
64 | - qemu_vfree(buf); | ||
65 | - return -EINVAL; | ||
66 | - } | ||
67 | + if (bytes < s->cluster_size) { | ||
68 | /* Zero-pad last write if image size is not cluster aligned */ | ||
69 | memset(buf + bytes, 0, s->cluster_size - bytes); | ||
70 | } | 310 | } |
311 | } | ||
312 | |||
313 | -/* Called with iothread lock taken. */ | ||
314 | +/* Called with the BQL taken. */ | ||
315 | |||
316 | static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds, | ||
317 | int is_async) | ||
318 | @@ -XXX,XX +XXX,XX @@ error: | ||
319 | return ret; | ||
320 | } | ||
321 | |||
322 | -/* Called with iothread lock taken. | ||
323 | +/* Called with the BQL taken. | ||
324 | * | ||
325 | * return value: | ||
326 | * 0: too much data for max_downtime | ||
327 | @@ -XXX,XX +XXX,XX @@ static int flush_blks(QEMUFile *f) | ||
328 | return ret; | ||
329 | } | ||
330 | |||
331 | -/* Called with iothread lock taken. */ | ||
332 | +/* Called with the BQL taken. */ | ||
333 | |||
334 | static int64_t get_remaining_dirty(void) | ||
335 | { | ||
336 | @@ -XXX,XX +XXX,XX @@ static int64_t get_remaining_dirty(void) | ||
337 | |||
338 | |||
339 | |||
340 | -/* Called with iothread lock taken. */ | ||
341 | +/* Called with the BQL taken. */ | ||
342 | static void block_migration_cleanup_bmds(void) | ||
343 | { | ||
344 | BlkMigDevState *bmds; | ||
345 | @@ -XXX,XX +XXX,XX @@ static void block_migration_cleanup_bmds(void) | ||
346 | } | ||
347 | } | ||
348 | |||
349 | -/* Called with iothread lock taken. */ | ||
350 | +/* Called with the BQL taken. */ | ||
351 | static void block_migration_cleanup(void *opaque) | ||
352 | { | ||
353 | BlkMigBlock *blk; | ||
354 | @@ -XXX,XX +XXX,XX @@ static int block_save_iterate(QEMUFile *f, void *opaque) | ||
355 | } | ||
356 | ret = 0; | ||
357 | } else { | ||
358 | - /* Always called with iothread lock taken for | ||
359 | + /* Always called with the BQL taken for | ||
360 | * simplicity, block_save_complete also calls it. | ||
361 | */ | ||
362 | bql_lock(); | ||
363 | @@ -XXX,XX +XXX,XX @@ static int block_save_iterate(QEMUFile *f, void *opaque) | ||
364 | return (delta_bytes > 0); | ||
365 | } | ||
366 | |||
367 | -/* Called with iothread lock taken. */ | ||
368 | +/* Called with the BQL taken. */ | ||
369 | |||
370 | static int block_save_complete(QEMUFile *f, void *opaque) | ||
371 | { | ||
372 | diff --git a/migration/colo.c b/migration/colo.c | ||
373 | index XXXXXXX..XXXXXXX 100644 | ||
374 | --- a/migration/colo.c | ||
375 | +++ b/migration/colo.c | ||
376 | @@ -XXX,XX +XXX,XX @@ int coroutine_fn colo_incoming_co(void) | ||
377 | qemu_thread_join(&th); | ||
378 | bql_lock(); | ||
379 | |||
380 | - /* We hold the global iothread lock, so it is safe here */ | ||
381 | + /* We hold the global BQL, so it is safe here */ | ||
382 | colo_release_ram_cache(); | ||
383 | |||
384 | return 0; | ||
385 | diff --git a/migration/migration.c b/migration/migration.c | ||
386 | index XXXXXXX..XXXXXXX 100644 | ||
387 | --- a/migration/migration.c | ||
388 | +++ b/migration/migration.c | ||
71 | @@ -XXX,XX +XXX,XX @@ fail: | 389 | @@ -XXX,XX +XXX,XX @@ fail: |
72 | return ret; | 390 | |
73 | } | 391 | /** |
74 | 392 | * migration_maybe_pause: Pause if required to by | |
75 | +static coroutine_fn int qcow2_co_pwritev_compressed_task_entry(AioTask *task) | 393 | - * migrate_pause_before_switchover called with the iothread locked |
76 | +{ | 394 | + * migrate_pause_before_switchover called with the BQL locked |
77 | + Qcow2AioTask *t = container_of(task, Qcow2AioTask, task); | 395 | * Returns: 0 on success |
78 | + | 396 | */ |
79 | + assert(!t->cluster_type && !t->l2meta); | 397 | static int migration_maybe_pause(MigrationState *s, |
80 | + | 398 | diff --git a/migration/ram.c b/migration/ram.c |
81 | + return qcow2_co_pwritev_compressed_task(t->bs, t->offset, t->bytes, t->qiov, | 399 | index XXXXXXX..XXXXXXX 100644 |
82 | + t->qiov_offset); | 400 | --- a/migration/ram.c |
83 | +} | 401 | +++ b/migration/ram.c |
84 | + | 402 | @@ -XXX,XX +XXX,XX @@ static void ram_save_cleanup(void *opaque) |
85 | +/* | 403 | |
86 | + * XXX: put compressed sectors first, then all the cluster aligned | 404 | /* We don't use dirty log with background snapshots */ |
87 | + * tables to avoid losing bytes in alignment | 405 | if (!migrate_background_snapshot()) { |
88 | + */ | 406 | - /* caller have hold iothread lock or is in a bh, so there is |
89 | +static coroutine_fn int | 407 | + /* caller have hold BQL or is in a bh, so there is |
90 | +qcow2_co_pwritev_compressed_part(BlockDriverState *bs, | 408 | * no writing race against the migration bitmap |
91 | + uint64_t offset, uint64_t bytes, | 409 | */ |
92 | + QEMUIOVector *qiov, size_t qiov_offset) | 410 | if (global_dirty_tracking & GLOBAL_DIRTY_MIGRATION) { |
93 | +{ | 411 | @@ -XXX,XX +XXX,XX @@ out: |
94 | + BDRVQcow2State *s = bs->opaque; | 412 | * |
95 | + AioTaskPool *aio = NULL; | 413 | * Returns zero to indicate success or negative on error |
96 | + int ret = 0; | 414 | * |
97 | + | 415 | - * Called with iothread lock |
98 | + if (has_data_file(bs)) { | 416 | + * Called with the BQL |
99 | + return -ENOTSUP; | 417 | * |
100 | + } | 418 | * @f: QEMUFile where to send the data |
101 | + | 419 | * @opaque: RAMState pointer |
102 | + if (bytes == 0) { | 420 | diff --git a/system/physmem.c b/system/physmem.c |
103 | + /* | 421 | index XXXXXXX..XXXXXXX 100644 |
104 | + * align end of file to a sector boundary to ease reading with | 422 | --- a/system/physmem.c |
105 | + * sector based I/Os | 423 | +++ b/system/physmem.c |
106 | + */ | 424 | @@ -XXX,XX +XXX,XX @@ static RAMBlock *qemu_get_ram_block(ram_addr_t addr) |
107 | + int64_t len = bdrv_getlength(bs->file->bs); | 425 | abort(); |
108 | + if (len < 0) { | 426 | |
109 | + return len; | 427 | found: |
110 | + } | 428 | - /* It is safe to write mru_block outside the iothread lock. This |
111 | + return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL); | 429 | + /* It is safe to write mru_block outside the BQL. This |
112 | + } | 430 | * is what happens: |
113 | + | 431 | * |
114 | + if (offset_into_cluster(s, offset)) { | 432 | * mru_block = xxx |
115 | + return -EINVAL; | 433 | @@ -XXX,XX +XXX,XX @@ int qemu_ram_get_fd(RAMBlock *rb) |
116 | + } | 434 | return rb->fd; |
117 | + | 435 | } |
118 | + while (bytes && aio_task_pool_status(aio) == 0) { | 436 | |
119 | + uint64_t chunk_size = MIN(bytes, s->cluster_size); | 437 | -/* Called with iothread lock held. */ |
120 | + | 438 | +/* Called with the BQL held. */ |
121 | + if (!aio && chunk_size != bytes) { | 439 | void qemu_ram_set_idstr(RAMBlock *new_block, const char *name, DeviceState *dev) |
122 | + aio = aio_task_pool_new(QCOW2_MAX_WORKERS); | 440 | { |
123 | + } | 441 | RAMBlock *block; |
124 | + | 442 | @@ -XXX,XX +XXX,XX @@ void qemu_ram_set_idstr(RAMBlock *new_block, const char *name, DeviceState *dev) |
125 | + ret = qcow2_add_task(bs, aio, qcow2_co_pwritev_compressed_task_entry, | 443 | } |
126 | + 0, 0, offset, chunk_size, qiov, qiov_offset, NULL); | 444 | } |
127 | + if (ret < 0) { | 445 | |
128 | + break; | 446 | -/* Called with iothread lock held. */ |
129 | + } | 447 | +/* Called with the BQL held. */ |
130 | + qiov_offset += chunk_size; | 448 | void qemu_ram_unset_idstr(RAMBlock *block) |
131 | + offset += chunk_size; | 449 | { |
132 | + bytes -= chunk_size; | 450 | /* FIXME: arch_init.c assumes that this is not called throughout |
133 | + } | 451 | diff --git a/target/arm/helper.c b/target/arm/helper.c |
134 | + | 452 | index XXXXXXX..XXXXXXX 100644 |
135 | + if (aio) { | 453 | --- a/target/arm/helper.c |
136 | + aio_task_pool_wait_all(aio); | 454 | +++ b/target/arm/helper.c |
137 | + if (ret == 0) { | 455 | @@ -XXX,XX +XXX,XX @@ static void do_hcr_write(CPUARMState *env, uint64_t value, uint64_t valid_mask) |
138 | + ret = aio_task_pool_status(aio); | 456 | * Updates to VI and VF require us to update the status of |
139 | + } | 457 | * virtual interrupts, which are the logical OR of these bits |
140 | + g_free(aio); | 458 | * and the state of the input lines from the GIC. (This requires |
141 | + } | 459 | - * that we have the iothread lock, which is done by marking the |
142 | + | 460 | + * that we have the BQL, which is done by marking the |
143 | + return ret; | 461 | * reginfo structs as ARM_CP_IO.) |
144 | +} | 462 | * Note that if a write to HCR pends a VIRQ or VFIQ it is never |
145 | + | 463 | * possible for it to be taken immediately, because VIRQ and |
146 | static int coroutine_fn | 464 | diff --git a/ui/spice-core.c b/ui/spice-core.c |
147 | qcow2_co_preadv_compressed(BlockDriverState *bs, | 465 | index XXXXXXX..XXXXXXX 100644 |
148 | uint64_t file_cluster_offset, | 466 | --- a/ui/spice-core.c |
467 | +++ b/ui/spice-core.c | ||
468 | @@ -XXX,XX +XXX,XX @@ static void channel_event(int event, SpiceChannelEventInfo *info) | ||
469 | * not do that. It isn't that easy to fix it in spice and even | ||
470 | * when it is fixed we still should cover the already released | ||
471 | * spice versions. So detect that we've been called from another | ||
472 | - * thread and grab the iothread lock if so before calling qemu | ||
473 | + * thread and grab the BQL if so before calling qemu | ||
474 | * functions. | ||
475 | */ | ||
476 | bool need_lock = !qemu_thread_is_self(&me); | ||
477 | diff --git a/util/rcu.c b/util/rcu.c | ||
478 | index XXXXXXX..XXXXXXX 100644 | ||
479 | --- a/util/rcu.c | ||
480 | +++ b/util/rcu.c | ||
481 | @@ -XXX,XX +XXX,XX @@ static void rcu_init_complete(void) | ||
482 | |||
483 | qemu_event_init(&rcu_call_ready_event, false); | ||
484 | |||
485 | - /* The caller is assumed to have iothread lock, so the call_rcu thread | ||
486 | + /* The caller is assumed to have BQL, so the call_rcu thread | ||
487 | * must have been quiescent even after forking, just recreate it. | ||
488 | */ | ||
489 | qemu_thread_create(&thread, "call_rcu", call_rcu_thread, | ||
490 | diff --git a/audio/coreaudio.m b/audio/coreaudio.m | ||
491 | index XXXXXXX..XXXXXXX 100644 | ||
492 | --- a/audio/coreaudio.m | ||
493 | +++ b/audio/coreaudio.m | ||
494 | @@ -XXX,XX +XXX,XX @@ static ret_type glue(coreaudio_, name)args_decl \ | ||
495 | #undef COREAUDIO_WRAPPER_FUNC | ||
496 | |||
497 | /* | ||
498 | - * callback to feed audiooutput buffer. called without iothread lock. | ||
499 | + * callback to feed audiooutput buffer. called without BQL. | ||
500 | * allowed to lock "buf_mutex", but disallowed to have any other locks. | ||
501 | */ | ||
502 | static OSStatus audioDeviceIOProc( | ||
503 | @@ -XXX,XX +XXX,XX @@ static void update_device_playback_state(coreaudioVoiceOut *core) | ||
504 | } | ||
505 | } | ||
506 | |||
507 | -/* called without iothread lock. */ | ||
508 | +/* called without BQL. */ | ||
509 | static OSStatus handle_voice_change( | ||
510 | AudioObjectID in_object_id, | ||
511 | UInt32 in_number_addresses, | ||
512 | diff --git a/ui/cocoa.m b/ui/cocoa.m | ||
513 | index XXXXXXX..XXXXXXX 100644 | ||
514 | --- a/ui/cocoa.m | ||
515 | +++ b/ui/cocoa.m | ||
516 | @@ -XXX,XX +XXX,XX @@ static void cocoa_switch(DisplayChangeListener *dcl, | ||
517 | static QemuClipboardInfo *cbinfo; | ||
518 | static QemuEvent cbevent; | ||
519 | |||
520 | -// Utility functions to run specified code block with iothread lock held | ||
521 | +// Utility functions to run specified code block with the BQL held | ||
522 | typedef void (^CodeBlock)(void); | ||
523 | typedef bool (^BoolCodeBlock)(void); | ||
524 | |||
525 | @@ -XXX,XX +XXX,XX @@ - (void) setContentDimensions | ||
526 | |||
527 | - (void) updateUIInfoLocked | ||
528 | { | ||
529 | - /* Must be called with the iothread lock, i.e. via updateUIInfo */ | ||
530 | + /* Must be called with the BQL, i.e. via updateUIInfo */ | ||
531 | NSSize frameSize; | ||
532 | QemuUIInfo info; | ||
533 | |||
534 | @@ -XXX,XX +XXX,XX @@ static void cocoa_display_init(DisplayState *ds, DisplayOptions *opts) | ||
535 | * Create the menu entries which depend on QEMU state (for consoles | ||
536 | * and removable devices). These make calls back into QEMU functions, | ||
537 | * which is OK because at this point we know that the second thread | ||
538 | - * holds the iothread lock and is synchronously waiting for us to | ||
539 | + * holds the BQL and is synchronously waiting for us to | ||
540 | * finish. | ||
541 | */ | ||
542 | add_console_menu_entries(); | ||
149 | -- | 543 | -- |
150 | 2.24.1 | 544 | 2.43.0 |
151 | 545 | ||
152 | 546 | diff view generated by jsdifflib |
Deleted patch | |||
---|---|---|---|
1 | From: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com> | ||
2 | 1 | ||
3 | Add the case to the iotest #214 that checks possibility of writing | ||
4 | compressed data of more than one cluster size. The test case involves | ||
5 | the compress filter driver showing a sample usage of that. | ||
6 | |||
7 | Signed-off-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com> | ||
8 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
9 | Reviewed-by: Max Reitz <mreitz@redhat.com> | ||
10 | Message-id: 1575288906-551879-4-git-send-email-andrey.shinkevich@virtuozzo.com | ||
11 | Signed-off-by: Max Reitz <mreitz@redhat.com> | ||
12 | --- | ||
13 | tests/qemu-iotests/214 | 43 ++++++++++++++++++++++++++++++++++++++ | ||
14 | tests/qemu-iotests/214.out | 14 +++++++++++++ | ||
15 | 2 files changed, 57 insertions(+) | ||
16 | |||
17 | diff --git a/tests/qemu-iotests/214 b/tests/qemu-iotests/214 | ||
18 | index XXXXXXX..XXXXXXX 100755 | ||
19 | --- a/tests/qemu-iotests/214 | ||
20 | +++ b/tests/qemu-iotests/214 | ||
21 | @@ -XXX,XX +XXX,XX @@ _check_test_img -r all | ||
22 | $QEMU_IO -c "read -P 0x11 0 4M" "$TEST_IMG" 2>&1 | _filter_qemu_io | _filter_testdir | ||
23 | $QEMU_IO -c "read -P 0x22 4M 4M" "$TEST_IMG" 2>&1 | _filter_qemu_io | _filter_testdir | ||
24 | |||
25 | +echo | ||
26 | +echo "=== Write compressed data of multiple clusters ===" | ||
27 | +echo | ||
28 | +cluster_size=0x10000 | ||
29 | +_make_test_img 2M -o cluster_size=$cluster_size | ||
30 | + | ||
31 | +echo "Write uncompressed data:" | ||
32 | +let data_size="8 * $cluster_size" | ||
33 | +$QEMU_IO -c "write -P 0xaa 0 $data_size" "$TEST_IMG" \ | ||
34 | + 2>&1 | _filter_qemu_io | _filter_testdir | ||
35 | +sizeA=$($QEMU_IMG info --output=json "$TEST_IMG" | | ||
36 | + sed -n '/"actual-size":/ s/[^0-9]//gp') | ||
37 | + | ||
38 | +_make_test_img 2M -o cluster_size=$cluster_size | ||
39 | +echo "Write compressed data:" | ||
40 | +let data_size="3 * $cluster_size + $cluster_size / 2" | ||
41 | +# Set compress on. That will align the written data | ||
42 | +# by the cluster size and will write them compressed. | ||
43 | +QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT \ | ||
44 | +$QEMU_IO -c "write -P 0xbb 0 $data_size" --image-opts \ | ||
45 | + "driver=compress,file.driver=$IMGFMT,file.file.driver=file,file.file.filename=$TEST_IMG" \ | ||
46 | + 2>&1 | _filter_qemu_io | _filter_testdir | ||
47 | + | ||
48 | +let offset="4 * $cluster_size + $cluster_size / 4" | ||
49 | +QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT \ | ||
50 | +$QEMU_IO -c "write -P 0xcc $offset $data_size" "json:{\ | ||
51 | + 'driver': 'compress', | ||
52 | + 'file': {'driver': '$IMGFMT', | ||
53 | + 'file': {'driver': 'file', | ||
54 | + 'filename': '$TEST_IMG'}}}" | \ | ||
55 | + _filter_qemu_io | _filter_testdir | ||
56 | + | ||
57 | +sizeB=$($QEMU_IMG info --output=json "$TEST_IMG" | | ||
58 | + sed -n '/"actual-size":/ s/[^0-9]//gp') | ||
59 | + | ||
60 | +if [ $sizeA -le $sizeB ] | ||
61 | +then | ||
62 | + echo "Compression ERROR" | ||
63 | +fi | ||
64 | + | ||
65 | +$QEMU_IMG check --output=json "$TEST_IMG" | | ||
66 | + sed -n 's/,$//; /"compressed-clusters":/ s/^ *//p' | ||
67 | + | ||
68 | # success, all done | ||
69 | echo '*** done' | ||
70 | rm -f $seq.full | ||
71 | diff --git a/tests/qemu-iotests/214.out b/tests/qemu-iotests/214.out | ||
72 | index XXXXXXX..XXXXXXX 100644 | ||
73 | --- a/tests/qemu-iotests/214.out | ||
74 | +++ b/tests/qemu-iotests/214.out | ||
75 | @@ -XXX,XX +XXX,XX @@ read 4194304/4194304 bytes at offset 0 | ||
76 | 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
77 | read 4194304/4194304 bytes at offset 4194304 | ||
78 | 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
79 | + | ||
80 | +=== Write compressed data of multiple clusters === | ||
81 | + | ||
82 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2097152 | ||
83 | +Write uncompressed data: | ||
84 | +wrote 524288/524288 bytes at offset 0 | ||
85 | +512 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
86 | +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2097152 | ||
87 | +Write compressed data: | ||
88 | +wrote 229376/229376 bytes at offset 0 | ||
89 | +224 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
90 | +wrote 229376/229376 bytes at offset 278528 | ||
91 | +224 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) | ||
92 | +"compressed-clusters": 8 | ||
93 | *** done | ||
94 | -- | ||
95 | 2.24.1 | ||
96 | |||
97 | diff view generated by jsdifflib |
1 | When dropping backup-top, we need to drain the node before freeing the | 1 | The term "QEMU global mutex" is identical to the more widely used Big |
---|---|---|---|
2 | BlockCopyState. Otherwise, requests may still be in flight and then the | 2 | QEMU Lock ("BQL"). Update the code comments and documentation to use |
3 | assertion in shres_destroy() will fail. | 3 | "BQL" instead of "QEMU global mutex". |
4 | 4 | ||
5 | (This becomes visible in intermittent failure of 056.) | 5 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
6 | 6 | Acked-by: Markus Armbruster <armbru@redhat.com> | |
7 | Cc: qemu-stable@nongnu.org | 7 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> |
8 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 8 | Reviewed-by: Paul Durrant <paul@xen.org> |
9 | Message-id: 20191219182638.104621-1-mreitz@redhat.com | 9 | Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com> |
10 | Signed-off-by: Max Reitz <mreitz@redhat.com> | 10 | Reviewed-by: Cédric Le Goater <clg@kaod.org> |
11 | Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com> | ||
12 | Message-id: 20240102153529.486531-6-stefanha@redhat.com | ||
13 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
11 | --- | 14 | --- |
12 | block/backup-top.c | 4 ++-- | 15 | docs/devel/multi-thread-tcg.rst | 7 +++---- |
13 | 1 file changed, 2 insertions(+), 2 deletions(-) | 16 | docs/devel/qapi-code-gen.rst | 2 +- |
14 | 17 | docs/devel/replay.rst | 2 +- | |
15 | diff --git a/block/backup-top.c b/block/backup-top.c | 18 | docs/devel/multiple-iothreads.txt | 14 +++++++------- |
16 | index XXXXXXX..XXXXXXX 100644 | 19 | include/block/blockjob.h | 6 +++--- |
17 | --- a/block/backup-top.c | 20 | include/io/task.h | 2 +- |
18 | +++ b/block/backup-top.c | 21 | include/qemu/coroutine-core.h | 2 +- |
19 | @@ -XXX,XX +XXX,XX @@ void bdrv_backup_top_drop(BlockDriverState *bs) | 22 | include/qemu/coroutine.h | 2 +- |
20 | BDRVBackupTopState *s = bs->opaque; | 23 | hw/block/dataplane/virtio-blk.c | 8 ++++---- |
21 | AioContext *aio_context = bdrv_get_aio_context(bs); | 24 | hw/block/virtio-blk.c | 2 +- |
22 | 25 | hw/scsi/virtio-scsi-dataplane.c | 6 +++--- | |
23 | - block_copy_state_free(s->bcs); | 26 | net/tap.c | 2 +- |
24 | - | 27 | 12 files changed, 27 insertions(+), 28 deletions(-) |
25 | aio_context_acquire(aio_context); | 28 | |
26 | 29 | diff --git a/docs/devel/multi-thread-tcg.rst b/docs/devel/multi-thread-tcg.rst | |
27 | bdrv_drained_begin(bs); | 30 | index XXXXXXX..XXXXXXX 100644 |
28 | 31 | --- a/docs/devel/multi-thread-tcg.rst | |
29 | + block_copy_state_free(s->bcs); | 32 | +++ b/docs/devel/multi-thread-tcg.rst |
30 | + | 33 | @@ -XXX,XX +XXX,XX @@ instruction. This could be a future optimisation. |
31 | s->active = false; | 34 | Emulated hardware state |
32 | bdrv_child_refresh_perms(bs, bs->backing, &error_abort); | 35 | ----------------------- |
33 | bdrv_replace_node(bs, backing_bs(bs), &error_abort); | 36 | |
37 | -Currently thanks to KVM work any access to IO memory is automatically | ||
38 | -protected by the global iothread mutex, also known as the BQL (Big | ||
39 | -QEMU Lock). Any IO region that doesn't use global mutex is expected to | ||
40 | -do its own locking. | ||
41 | +Currently thanks to KVM work any access to IO memory is automatically protected | ||
42 | +by the BQL (Big QEMU Lock). Any IO region that doesn't use the BQL is expected | ||
43 | +to do its own locking. | ||
44 | |||
45 | However IO memory isn't the only way emulated hardware state can be | ||
46 | modified. Some architectures have model specific registers that | ||
47 | diff --git a/docs/devel/qapi-code-gen.rst b/docs/devel/qapi-code-gen.rst | ||
48 | index XXXXXXX..XXXXXXX 100644 | ||
49 | --- a/docs/devel/qapi-code-gen.rst | ||
50 | +++ b/docs/devel/qapi-code-gen.rst | ||
51 | @@ -XXX,XX +XXX,XX @@ blocking the guest and other background operations. | ||
52 | Coroutine safety can be hard to prove, similar to thread safety. Common | ||
53 | pitfalls are: | ||
54 | |||
55 | -- The global mutex isn't held across ``qemu_coroutine_yield()``, so | ||
56 | +- The BQL isn't held across ``qemu_coroutine_yield()``, so | ||
57 | operations that used to assume that they execute atomically may have | ||
58 | to be more careful to protect against changes in the global state. | ||
59 | |||
60 | diff --git a/docs/devel/replay.rst b/docs/devel/replay.rst | ||
61 | index XXXXXXX..XXXXXXX 100644 | ||
62 | --- a/docs/devel/replay.rst | ||
63 | +++ b/docs/devel/replay.rst | ||
64 | @@ -XXX,XX +XXX,XX @@ modes. | ||
65 | Reading and writing requests are created by CPU thread of QEMU. Later these | ||
66 | requests proceed to block layer which creates "bottom halves". Bottom | ||
67 | halves consist of callback and its parameters. They are processed when | ||
68 | -main loop locks the global mutex. These locks are not synchronized with | ||
69 | +main loop locks the BQL. These locks are not synchronized with | ||
70 | replaying process because main loop also processes the events that do not | ||
71 | affect the virtual machine state (like user interaction with monitor). | ||
72 | |||
73 | diff --git a/docs/devel/multiple-iothreads.txt b/docs/devel/multiple-iothreads.txt | ||
74 | index XXXXXXX..XXXXXXX 100644 | ||
75 | --- a/docs/devel/multiple-iothreads.txt | ||
76 | +++ b/docs/devel/multiple-iothreads.txt | ||
77 | @@ -XXX,XX +XXX,XX @@ the COPYING file in the top-level directory. | ||
78 | |||
79 | |||
80 | This document explains the IOThread feature and how to write code that runs | ||
81 | -outside the QEMU global mutex. | ||
82 | +outside the BQL. | ||
83 | |||
84 | The main loop and IOThreads | ||
85 | --------------------------- | ||
86 | @@ -XXX,XX +XXX,XX @@ scalability bottleneck on hosts with many CPUs. Work can be spread across | ||
87 | several IOThreads instead of just one main loop. When set up correctly this | ||
88 | can improve I/O latency and reduce jitter seen by the guest. | ||
89 | |||
90 | -The main loop is also deeply associated with the QEMU global mutex, which is a | ||
91 | -scalability bottleneck in itself. vCPU threads and the main loop use the QEMU | ||
92 | -global mutex to serialize execution of QEMU code. This mutex is necessary | ||
93 | -because a lot of QEMU's code historically was not thread-safe. | ||
94 | +The main loop is also deeply associated with the BQL, which is a | ||
95 | +scalability bottleneck in itself. vCPU threads and the main loop use the BQL | ||
96 | +to serialize execution of QEMU code. This mutex is necessary because a lot of | ||
97 | +QEMU's code historically was not thread-safe. | ||
98 | |||
99 | The fact that all I/O processing is done in a single main loop and that the | ||
100 | -QEMU global mutex is contended by all vCPU threads and the main loop explain | ||
101 | +BQL is contended by all vCPU threads and the main loop explain | ||
102 | why it is desirable to place work into IOThreads. | ||
103 | |||
104 | The experimental virtio-blk data-plane implementation has been benchmarked and | ||
105 | @@ -XXX,XX +XXX,XX @@ There are several old APIs that use the main loop AioContext: | ||
106 | |||
107 | Since they implicitly work on the main loop they cannot be used in code that | ||
108 | runs in an IOThread. They might cause a crash or deadlock if called from an | ||
109 | -IOThread since the QEMU global mutex is not held. | ||
110 | +IOThread since the BQL is not held. | ||
111 | |||
112 | Instead, use the AioContext functions directly (see include/block/aio.h): | ||
113 | * aio_set_fd_handler() - monitor a file descriptor | ||
114 | diff --git a/include/block/blockjob.h b/include/block/blockjob.h | ||
115 | index XXXXXXX..XXXXXXX 100644 | ||
116 | --- a/include/block/blockjob.h | ||
117 | +++ b/include/block/blockjob.h | ||
118 | @@ -XXX,XX +XXX,XX @@ typedef struct BlockJob { | ||
119 | |||
120 | /** | ||
121 | * Speed that was set with @block_job_set_speed. | ||
122 | - * Always modified and read under QEMU global mutex (GLOBAL_STATE_CODE). | ||
123 | + * Always modified and read under the BQL (GLOBAL_STATE_CODE). | ||
124 | */ | ||
125 | int64_t speed; | ||
126 | |||
127 | @@ -XXX,XX +XXX,XX @@ typedef struct BlockJob { | ||
128 | |||
129 | /** | ||
130 | * Block other operations when block job is running. | ||
131 | - * Always modified and read under QEMU global mutex (GLOBAL_STATE_CODE). | ||
132 | + * Always modified and read under the BQL (GLOBAL_STATE_CODE). | ||
133 | */ | ||
134 | Error *blocker; | ||
135 | |||
136 | @@ -XXX,XX +XXX,XX @@ typedef struct BlockJob { | ||
137 | |||
138 | /** | ||
139 | * BlockDriverStates that are involved in this block job. | ||
140 | - * Always modified and read under QEMU global mutex (GLOBAL_STATE_CODE). | ||
141 | + * Always modified and read under the BQL (GLOBAL_STATE_CODE). | ||
142 | */ | ||
143 | GSList *nodes; | ||
144 | } BlockJob; | ||
145 | diff --git a/include/io/task.h b/include/io/task.h | ||
146 | index XXXXXXX..XXXXXXX 100644 | ||
147 | --- a/include/io/task.h | ||
148 | +++ b/include/io/task.h | ||
149 | @@ -XXX,XX +XXX,XX @@ typedef void (*QIOTaskWorker)(QIOTask *task, | ||
150 | * lookups) to be easily run non-blocking. Reporting the | ||
151 | * results in the main thread context means that the caller | ||
152 | * typically does not need to be concerned about thread | ||
153 | - * safety wrt the QEMU global mutex. | ||
154 | + * safety wrt the BQL. | ||
155 | * | ||
156 | * For example, the socket_listen() method will block the caller | ||
157 | * while DNS lookups take place if given a name, instead of IP | ||
158 | diff --git a/include/qemu/coroutine-core.h b/include/qemu/coroutine-core.h | ||
159 | index XXXXXXX..XXXXXXX 100644 | ||
160 | --- a/include/qemu/coroutine-core.h | ||
161 | +++ b/include/qemu/coroutine-core.h | ||
162 | @@ -XXX,XX +XXX,XX @@ | ||
163 | * rather than callbacks, for operations that need to give up control while | ||
164 | * waiting for events to complete. | ||
165 | * | ||
166 | - * These functions are re-entrant and may be used outside the global mutex. | ||
167 | + * These functions are re-entrant and may be used outside the BQL. | ||
168 | * | ||
169 | * Functions that execute in coroutine context cannot be called | ||
170 | * directly from normal functions. Use @coroutine_fn to mark such | ||
171 | diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h | ||
172 | index XXXXXXX..XXXXXXX 100644 | ||
173 | --- a/include/qemu/coroutine.h | ||
174 | +++ b/include/qemu/coroutine.h | ||
175 | @@ -XXX,XX +XXX,XX @@ | ||
176 | * rather than callbacks, for operations that need to give up control while | ||
177 | * waiting for events to complete. | ||
178 | * | ||
179 | - * These functions are re-entrant and may be used outside the global mutex. | ||
180 | + * These functions are re-entrant and may be used outside the BQL. | ||
181 | * | ||
182 | * Functions that execute in coroutine context cannot be called | ||
183 | * directly from normal functions. Use @coroutine_fn to mark such | ||
184 | diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c | ||
185 | index XXXXXXX..XXXXXXX 100644 | ||
186 | --- a/hw/block/dataplane/virtio-blk.c | ||
187 | +++ b/hw/block/dataplane/virtio-blk.c | ||
188 | @@ -XXX,XX +XXX,XX @@ apply_vq_mapping(IOThreadVirtQueueMappingList *iothread_vq_mapping_list, | ||
189 | } | ||
190 | } | ||
191 | |||
192 | -/* Context: QEMU global mutex held */ | ||
193 | +/* Context: BQL held */ | ||
194 | bool virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, | ||
195 | VirtIOBlockDataPlane **dataplane, | ||
196 | Error **errp) | ||
197 | @@ -XXX,XX +XXX,XX @@ bool virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, | ||
198 | return true; | ||
199 | } | ||
200 | |||
201 | -/* Context: QEMU global mutex held */ | ||
202 | +/* Context: BQL held */ | ||
203 | void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s) | ||
204 | { | ||
205 | VirtIOBlock *vblk; | ||
206 | @@ -XXX,XX +XXX,XX @@ void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s) | ||
207 | g_free(s); | ||
208 | } | ||
209 | |||
210 | -/* Context: QEMU global mutex held */ | ||
211 | +/* Context: BQL held */ | ||
212 | int virtio_blk_data_plane_start(VirtIODevice *vdev) | ||
213 | { | ||
214 | VirtIOBlock *vblk = VIRTIO_BLK(vdev); | ||
215 | @@ -XXX,XX +XXX,XX @@ static void virtio_blk_data_plane_stop_vq_bh(void *opaque) | ||
216 | virtio_queue_host_notifier_read(host_notifier); | ||
217 | } | ||
218 | |||
219 | -/* Context: QEMU global mutex held */ | ||
220 | +/* Context: BQL held */ | ||
221 | void virtio_blk_data_plane_stop(VirtIODevice *vdev) | ||
222 | { | ||
223 | VirtIOBlock *vblk = VIRTIO_BLK(vdev); | ||
224 | diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c | ||
225 | index XXXXXXX..XXXXXXX 100644 | ||
226 | --- a/hw/block/virtio-blk.c | ||
227 | +++ b/hw/block/virtio-blk.c | ||
228 | @@ -XXX,XX +XXX,XX @@ static void virtio_blk_resize(void *opaque) | ||
229 | VirtIODevice *vdev = VIRTIO_DEVICE(opaque); | ||
230 | |||
231 | /* | ||
232 | - * virtio_notify_config() needs to acquire the global mutex, | ||
233 | + * virtio_notify_config() needs to acquire the BQL, | ||
234 | * so it can't be called from an iothread. Instead, schedule | ||
235 | * it to be run in the main context BH. | ||
236 | */ | ||
237 | diff --git a/hw/scsi/virtio-scsi-dataplane.c b/hw/scsi/virtio-scsi-dataplane.c | ||
238 | index XXXXXXX..XXXXXXX 100644 | ||
239 | --- a/hw/scsi/virtio-scsi-dataplane.c | ||
240 | +++ b/hw/scsi/virtio-scsi-dataplane.c | ||
241 | @@ -XXX,XX +XXX,XX @@ | ||
242 | #include "scsi/constants.h" | ||
243 | #include "hw/virtio/virtio-bus.h" | ||
244 | |||
245 | -/* Context: QEMU global mutex held */ | ||
246 | +/* Context: BQL held */ | ||
247 | void virtio_scsi_dataplane_setup(VirtIOSCSI *s, Error **errp) | ||
248 | { | ||
249 | VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s); | ||
250 | @@ -XXX,XX +XXX,XX @@ static void virtio_scsi_dataplane_stop_bh(void *opaque) | ||
251 | } | ||
252 | } | ||
253 | |||
254 | -/* Context: QEMU global mutex held */ | ||
255 | +/* Context: BQL held */ | ||
256 | int virtio_scsi_dataplane_start(VirtIODevice *vdev) | ||
257 | { | ||
258 | int i; | ||
259 | @@ -XXX,XX +XXX,XX @@ fail_guest_notifiers: | ||
260 | return -ENOSYS; | ||
261 | } | ||
262 | |||
263 | -/* Context: QEMU global mutex held */ | ||
264 | +/* Context: BQL held */ | ||
265 | void virtio_scsi_dataplane_stop(VirtIODevice *vdev) | ||
266 | { | ||
267 | BusState *qbus = qdev_get_parent_bus(DEVICE(vdev)); | ||
268 | diff --git a/net/tap.c b/net/tap.c | ||
269 | index XXXXXXX..XXXXXXX 100644 | ||
270 | --- a/net/tap.c | ||
271 | +++ b/net/tap.c | ||
272 | @@ -XXX,XX +XXX,XX @@ static void tap_send(void *opaque) | ||
273 | |||
274 | /* | ||
275 | * When the host keeps receiving more packets while tap_send() is | ||
276 | - * running we can hog the QEMU global mutex. Limit the number of | ||
277 | + * running we can hog the BQL. Limit the number of | ||
278 | * packets that are processed per tap_send() callback to prevent | ||
279 | * stalling the guest. | ||
280 | */ | ||
34 | -- | 281 | -- |
35 | 2.24.1 | 282 | 2.43.0 |
36 | 283 | ||
37 | 284 | diff view generated by jsdifflib |