1 | The following changes since commit ffd454c67e38cc6df792733ebc5d967eee28ac0d: | 1 | The following changes since commit b384cd95eb9c6f73ad84ed1bb0717a26e29cc78f: |
---|---|---|---|
2 | 2 | ||
3 | Merge tag 'pull-vfio-20240107' of https://github.com/legoater/qemu into staging (2024-01-08 10:28:42 +0000) | 3 | Merge remote-tracking branch 'remotes/ehabkost/tags/machine-next-pull-request' into staging (2018-01-19 16:35:25 +0000) |
4 | 4 | ||
5 | are available in the Git repository at: | 5 | are available in the Git repository at: |
6 | 6 | ||
7 | https://gitlab.com/stefanha/qemu.git tags/block-pull-request | 7 | git://github.com/stefanha/qemu.git tags/block-pull-request |
8 | 8 | ||
9 | for you to fetch changes up to 0b2675c473f68f13bc5ca1dd1c43ce421542e7b8: | 9 | for you to fetch changes up to bcbb3866da19cce4360c828b6ec1c2a137757927: |
10 | 10 | ||
11 | Rename "QEMU global mutex" to "BQL" in comments and docs (2024-01-08 10:45:43 -0500) | 11 | block/parallels: add backing support to readv/writev (2018-01-22 14:02:33 +0000) |
12 | 12 | ||
13 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
14 | Pull request | 14 | Pull request |
15 | 15 | ||
16 | v2: | ||
17 | * Drop merge failure from a previous pull request that broke virtio-blk on ARM | ||
18 | guests | ||
19 | * Add Parallels XML patch series | ||
20 | |||
16 | ---------------------------------------------------------------- | 21 | ---------------------------------------------------------------- |
17 | 22 | ||
18 | Philippe Mathieu-Daudé (1): | 23 | Edgar Kaziakhmedov (1): |
19 | iothread: Remove unused Error** argument in aio_context_set_aio_params | 24 | block/parallels: add backing support to readv/writev |
20 | 25 | ||
21 | Stefan Hajnoczi (5): | 26 | Klim Kireev (4): |
22 | system/cpus: rename qemu_mutex_lock_iothread() to bql_lock() | 27 | docs/interop/prl-xml: description of Parallels Disk format |
23 | qemu/main-loop: rename QEMU_IOTHREAD_LOCK_GUARD to BQL_LOCK_GUARD | 28 | configure: add dependency |
24 | qemu/main-loop: rename qemu_cond_wait_iothread() to | 29 | block/parallels: move some structures into header |
25 | qemu_cond_wait_bql() | 30 | block/parallels: replace some magic numbers |
26 | Replace "iothread lock" with "BQL" in comments | ||
27 | Rename "QEMU global mutex" to "BQL" in comments and docs | ||
28 | 31 | ||
29 | docs/devel/multi-thread-tcg.rst | 7 +- | 32 | Stefan Hajnoczi (1): |
30 | docs/devel/qapi-code-gen.rst | 2 +- | 33 | block: add block_set_io_throttle virtio-blk-pci QMP example |
31 | docs/devel/replay.rst | 2 +- | 34 | |
32 | docs/devel/reset.rst | 2 +- | 35 | docs/interop/prl-xml.txt | 158 +++++++++++++++++++++++++++++++++++++++++++++++ |
33 | docs/devel/multiple-iothreads.txt | 14 ++-- | 36 | qapi/block-core.json | 18 ++++++ |
34 | hw/display/qxl.h | 2 +- | 37 | configure | 27 ++++++++ |
35 | include/block/aio-wait.h | 2 +- | 38 | block/Makefile.objs | 2 + |
36 | include/block/aio.h | 3 +- | 39 | block/parallels.h | 88 ++++++++++++++++++++++++++ |
37 | include/block/blockjob.h | 6 +- | 40 | block/parallels.c | 108 ++++++++++++++------------------ |
38 | include/exec/cpu-common.h | 2 +- | 41 | scripts/checkpatch.pl | 1 + |
39 | include/exec/memory.h | 4 +- | 42 | 7 files changed, 342 insertions(+), 60 deletions(-) |
40 | include/exec/ramblock.h | 2 +- | 43 | create mode 100644 docs/interop/prl-xml.txt |
41 | include/io/task.h | 2 +- | 44 | create mode 100644 block/parallels.h |
42 | include/migration/register.h | 8 +- | ||
43 | include/qemu/coroutine-core.h | 2 +- | ||
44 | include/qemu/coroutine.h | 2 +- | ||
45 | include/qemu/main-loop.h | 68 ++++++++------- | ||
46 | include/qemu/thread.h | 2 +- | ||
47 | target/arm/internals.h | 4 +- | ||
48 | accel/accel-blocker.c | 10 +-- | ||
49 | accel/dummy-cpus.c | 8 +- | ||
50 | accel/hvf/hvf-accel-ops.c | 4 +- | ||
51 | accel/kvm/kvm-accel-ops.c | 4 +- | ||
52 | accel/kvm/kvm-all.c | 22 ++--- | ||
53 | accel/tcg/cpu-exec.c | 26 +++--- | ||
54 | accel/tcg/cputlb.c | 20 ++--- | ||
55 | accel/tcg/tcg-accel-ops-icount.c | 6 +- | ||
56 | accel/tcg/tcg-accel-ops-mttcg.c | 12 +-- | ||
57 | accel/tcg/tcg-accel-ops-rr.c | 18 ++-- | ||
58 | accel/tcg/tcg-accel-ops.c | 2 +- | ||
59 | accel/tcg/translate-all.c | 2 +- | ||
60 | cpu-common.c | 4 +- | ||
61 | dump/dump.c | 4 +- | ||
62 | hw/block/dataplane/virtio-blk.c | 8 +- | ||
63 | hw/block/virtio-blk.c | 2 +- | ||
64 | hw/core/cpu-common.c | 6 +- | ||
65 | hw/display/virtio-gpu.c | 2 +- | ||
66 | hw/i386/intel_iommu.c | 6 +- | ||
67 | hw/i386/kvm/xen_evtchn.c | 30 +++---- | ||
68 | hw/i386/kvm/xen_gnttab.c | 2 +- | ||
69 | hw/i386/kvm/xen_overlay.c | 2 +- | ||
70 | hw/i386/kvm/xen_xenstore.c | 2 +- | ||
71 | hw/intc/arm_gicv3_cpuif.c | 2 +- | ||
72 | hw/intc/s390_flic.c | 18 ++-- | ||
73 | hw/mips/mips_int.c | 2 +- | ||
74 | hw/misc/edu.c | 4 +- | ||
75 | hw/misc/imx6_src.c | 2 +- | ||
76 | hw/misc/imx7_src.c | 2 +- | ||
77 | hw/net/xen_nic.c | 8 +- | ||
78 | hw/ppc/pegasos2.c | 2 +- | ||
79 | hw/ppc/ppc.c | 6 +- | ||
80 | hw/ppc/spapr.c | 2 +- | ||
81 | hw/ppc/spapr_events.c | 2 +- | ||
82 | hw/ppc/spapr_rng.c | 4 +- | ||
83 | hw/ppc/spapr_softmmu.c | 4 +- | ||
84 | hw/remote/mpqemu-link.c | 22 ++--- | ||
85 | hw/remote/vfio-user-obj.c | 2 +- | ||
86 | hw/s390x/s390-skeys.c | 2 +- | ||
87 | hw/scsi/virtio-scsi-dataplane.c | 6 +- | ||
88 | iothread.c | 3 +- | ||
89 | migration/block-dirty-bitmap.c | 14 ++-- | ||
90 | migration/block.c | 38 ++++----- | ||
91 | migration/colo.c | 62 +++++++------- | ||
92 | migration/dirtyrate.c | 12 +-- | ||
93 | migration/migration.c | 54 ++++++------ | ||
94 | migration/ram.c | 16 ++-- | ||
95 | net/tap.c | 2 +- | ||
96 | replay/replay-internal.c | 2 +- | ||
97 | semihosting/console.c | 8 +- | ||
98 | stubs/iothread-lock.c | 6 +- | ||
99 | system/cpu-throttle.c | 6 +- | ||
100 | system/cpus.c | 55 +++++++------ | ||
101 | system/dirtylimit.c | 4 +- | ||
102 | system/memory.c | 2 +- | ||
103 | system/physmem.c | 14 ++-- | ||
104 | system/runstate.c | 2 +- | ||
105 | system/watchpoint.c | 4 +- | ||
106 | target/arm/arm-powerctl.c | 14 ++-- | ||
107 | target/arm/helper.c | 6 +- | ||
108 | target/arm/hvf/hvf.c | 8 +- | ||
109 | target/arm/kvm.c | 8 +- | ||
110 | target/arm/ptw.c | 6 +- | ||
111 | target/arm/tcg/helper-a64.c | 8 +- | ||
112 | target/arm/tcg/m_helper.c | 6 +- | ||
113 | target/arm/tcg/op_helper.c | 24 +++--- | ||
114 | target/arm/tcg/psci.c | 2 +- | ||
115 | target/hppa/int_helper.c | 8 +- | ||
116 | target/i386/hvf/hvf.c | 6 +- | ||
117 | target/i386/kvm/hyperv.c | 4 +- | ||
118 | target/i386/kvm/kvm.c | 28 +++---- | ||
119 | target/i386/kvm/xen-emu.c | 16 ++-- | ||
120 | target/i386/nvmm/nvmm-accel-ops.c | 6 +- | ||
121 | target/i386/nvmm/nvmm-all.c | 20 ++--- | ||
122 | target/i386/tcg/sysemu/fpu_helper.c | 6 +- | ||
123 | target/i386/tcg/sysemu/misc_helper.c | 4 +- | ||
124 | target/i386/whpx/whpx-accel-ops.c | 6 +- | ||
125 | target/i386/whpx/whpx-all.c | 24 +++--- | ||
126 | target/loongarch/tcg/csr_helper.c | 4 +- | ||
127 | target/mips/kvm.c | 4 +- | ||
128 | target/mips/tcg/sysemu/cp0_helper.c | 4 +- | ||
129 | target/openrisc/sys_helper.c | 16 ++-- | ||
130 | target/ppc/excp_helper.c | 14 ++-- | ||
131 | target/ppc/helper_regs.c | 2 +- | ||
132 | target/ppc/kvm.c | 4 +- | ||
133 | target/ppc/misc_helper.c | 8 +- | ||
134 | target/ppc/timebase_helper.c | 8 +- | ||
135 | target/riscv/cpu_helper.c | 4 +- | ||
136 | target/s390x/kvm/kvm.c | 4 +- | ||
137 | target/s390x/tcg/misc_helper.c | 118 +++++++++++++-------------- | ||
138 | target/sparc/int32_helper.c | 2 +- | ||
139 | target/sparc/int64_helper.c | 6 +- | ||
140 | target/sparc/win_helper.c | 20 ++--- | ||
141 | target/xtensa/exc_helper.c | 8 +- | ||
142 | ui/spice-core.c | 6 +- | ||
143 | util/aio-posix.c | 3 +- | ||
144 | util/aio-win32.c | 3 +- | ||
145 | util/async.c | 2 +- | ||
146 | util/main-loop.c | 13 ++- | ||
147 | util/qsp.c | 6 +- | ||
148 | util/rcu.c | 16 ++-- | ||
149 | audio/coreaudio.m | 8 +- | ||
150 | memory_ldst.c.inc | 18 ++-- | ||
151 | target/i386/hvf/README.md | 2 +- | ||
152 | ui/cocoa.m | 56 ++++++------- | ||
153 | 124 files changed, 646 insertions(+), 655 deletions(-) | ||
154 | 45 | ||
155 | -- | 46 | -- |
156 | 2.43.0 | 47 | 2.14.3 |
157 | 48 | ||
158 | 49 | diff view generated by jsdifflib |
1 | The term "QEMU global mutex" is identical to the more widely used Big | 1 | The block_set_io_throttle command can look up BlockBackends by the |
---|---|---|---|
2 | QEMU Lock ("BQL"). Update the code comments and documentation to use | 2 | attached qdev device ID. virtio-blk-pci is a special case because the |
3 | "BQL" instead of "QEMU global mutex". | 3 | actual VirtIOBlock device is the "/virtio-backend" child of the PCI |
4 | adapter device. | ||
4 | 5 | ||
6 | Add a QMP schema example so clients will know how to use | ||
7 | block_set_io_throttle on the virtio-blk-pci device. | ||
8 | |||
9 | The alternative is to implement some sort of aliasing for qmp_get_blk() | ||
10 | but that is likely to cause confusion and could break future use cases. | ||
11 | Let's not go there. | ||
12 | |||
13 | Cc: Kevin Wolf <kwolf@redhat.com> | ||
5 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | 14 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
6 | Acked-by: Markus Armbruster <armbru@redhat.com> | 15 | Reviewed-by: Alberto Garcia <berto@igalia.com> |
7 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> | 16 | Message-id: 20180117090700.25811-1-stefanha@redhat.com |
8 | Reviewed-by: Paul Durrant <paul@xen.org> | ||
9 | Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.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> | 17 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
14 | --- | 18 | --- |
15 | docs/devel/multi-thread-tcg.rst | 7 +++---- | 19 | qapi/block-core.json | 18 ++++++++++++++++++ |
16 | docs/devel/qapi-code-gen.rst | 2 +- | 20 | 1 file changed, 18 insertions(+) |
17 | docs/devel/replay.rst | 2 +- | ||
18 | docs/devel/multiple-iothreads.txt | 14 +++++++------- | ||
19 | include/block/blockjob.h | 6 +++--- | ||
20 | include/io/task.h | 2 +- | ||
21 | include/qemu/coroutine-core.h | 2 +- | ||
22 | include/qemu/coroutine.h | 2 +- | ||
23 | hw/block/dataplane/virtio-blk.c | 8 ++++---- | ||
24 | hw/block/virtio-blk.c | 2 +- | ||
25 | hw/scsi/virtio-scsi-dataplane.c | 6 +++--- | ||
26 | net/tap.c | 2 +- | ||
27 | 12 files changed, 27 insertions(+), 28 deletions(-) | ||
28 | 21 | ||
29 | diff --git a/docs/devel/multi-thread-tcg.rst b/docs/devel/multi-thread-tcg.rst | 22 | diff --git a/qapi/block-core.json b/qapi/block-core.json |
30 | index XXXXXXX..XXXXXXX 100644 | 23 | index XXXXXXX..XXXXXXX 100644 |
31 | --- a/docs/devel/multi-thread-tcg.rst | 24 | --- a/qapi/block-core.json |
32 | +++ b/docs/devel/multi-thread-tcg.rst | 25 | +++ b/qapi/block-core.json |
33 | @@ -XXX,XX +XXX,XX @@ instruction. This could be a future optimisation. | ||
34 | Emulated hardware state | ||
35 | ----------------------- | ||
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 @@ | 26 | @@ -XXX,XX +XXX,XX @@ |
163 | * rather than callbacks, for operations that need to give up control while | 27 | # Example: |
164 | * waiting for events to complete. | 28 | # |
165 | * | 29 | # -> { "execute": "block_set_io_throttle", |
166 | - * These functions are re-entrant and may be used outside the global mutex. | 30 | +# "arguments": { "id": "virtio-blk-pci0/virtio-backend", |
167 | + * These functions are re-entrant and may be used outside the BQL. | 31 | +# "bps": 0, |
168 | * | 32 | +# "bps_rd": 0, |
169 | * Functions that execute in coroutine context cannot be called | 33 | +# "bps_wr": 0, |
170 | * directly from normal functions. Use @coroutine_fn to mark such | 34 | +# "iops": 512, |
171 | diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h | 35 | +# "iops_rd": 0, |
172 | index XXXXXXX..XXXXXXX 100644 | 36 | +# "iops_wr": 0, |
173 | --- a/include/qemu/coroutine.h | 37 | +# "bps_max": 0, |
174 | +++ b/include/qemu/coroutine.h | 38 | +# "bps_rd_max": 0, |
175 | @@ -XXX,XX +XXX,XX @@ | 39 | +# "bps_wr_max": 0, |
176 | * rather than callbacks, for operations that need to give up control while | 40 | +# "iops_max": 0, |
177 | * waiting for events to complete. | 41 | +# "iops_rd_max": 0, |
178 | * | 42 | +# "iops_wr_max": 0, |
179 | - * These functions are re-entrant and may be used outside the global mutex. | 43 | +# "bps_max_length": 0, |
180 | + * These functions are re-entrant and may be used outside the BQL. | 44 | +# "iops_size": 0 } } |
181 | * | 45 | +# <- { "return": {} } |
182 | * Functions that execute in coroutine context cannot be called | 46 | +# |
183 | * directly from normal functions. Use @coroutine_fn to mark such | 47 | +# -> { "execute": "block_set_io_throttle", |
184 | diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c | 48 | # "arguments": { "id": "ide0-1-0", |
185 | index XXXXXXX..XXXXXXX 100644 | 49 | # "bps": 1000000, |
186 | --- a/hw/block/dataplane/virtio-blk.c | 50 | # "bps_rd": 0, |
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 | */ | ||
281 | -- | 51 | -- |
282 | 2.43.0 | 52 | 2.14.3 |
283 | 53 | ||
284 | 54 | diff view generated by jsdifflib |
1 | The term "iothread lock" is obsolete. The APIs use Big QEMU Lock (BQL) | 1 | From: Klim Kireev <klim.kireev@virtuozzo.com> |
---|---|---|---|
2 | in their names. Update the code comments to use "BQL" instead of | ||
3 | "iothread lock". | ||
4 | 2 | ||
5 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | 3 | This patch adds main information about Parallels Disk |
6 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> | 4 | format, which consists of DiskDescriptor.xml and other files. |
7 | Reviewed-by: Paul Durrant <paul@xen.org> | 5 | |
8 | Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com> | 6 | Signed-off-by: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com> |
9 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | 7 | Signed-off-by: Klim Kireev <klim.kireev@virtuozzo.com> |
10 | Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com> | 8 | Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> |
11 | Message-id: 20240102153529.486531-5-stefanha@redhat.com | 9 | Signed-off-by: Denis V. Lunev <den@openvz.org> |
10 | Message-id: 20180112090122.1702-2-klim.kireev@virtuozzo.com | ||
11 | CC: Stefan Hajnoczi <stefanha@redhat.com> | ||
12 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | 12 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
13 | --- | 13 | --- |
14 | docs/devel/reset.rst | 2 +- | 14 | docs/interop/prl-xml.txt | 158 +++++++++++++++++++++++++++++++++++++++++++++++ |
15 | hw/display/qxl.h | 2 +- | 15 | 1 file changed, 158 insertions(+) |
16 | include/exec/cpu-common.h | 2 +- | 16 | create mode 100644 docs/interop/prl-xml.txt |
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(-) | ||
36 | 17 | ||
37 | diff --git a/docs/devel/reset.rst b/docs/devel/reset.rst | 18 | diff --git a/docs/interop/prl-xml.txt b/docs/interop/prl-xml.txt |
38 | index XXXXXXX..XXXXXXX 100644 | 19 | new file mode 100644 |
39 | --- a/docs/devel/reset.rst | 20 | index XXXXXXX..XXXXXXX |
40 | +++ b/docs/devel/reset.rst | 21 | --- /dev/null |
41 | @@ -XXX,XX +XXX,XX @@ Triggering reset | 22 | +++ b/docs/interop/prl-xml.txt |
42 | |||
43 | This section documents the APIs which "users" of a resettable object should use | ||
44 | to control it. All resettable control functions must be called while holding | ||
45 | -the iothread lock. | ||
46 | +the BQL. | ||
47 | |||
48 | You can apply a reset to an object using ``resettable_assert_reset()``. You need | ||
49 | to call ``resettable_release_reset()`` to release the object from reset. To | ||
50 | diff --git a/hw/display/qxl.h b/hw/display/qxl.h | ||
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 @@ | 23 | @@ -XXX,XX +XXX,XX @@ |
116 | #include "hw/vmstate-if.h" | 24 | += License = |
117 | 25 | + | |
118 | typedef struct SaveVMHandlers { | 26 | +Copyright (c) 2015-2017, Virtuozzo, Inc. |
119 | - /* This runs inside the iothread lock. */ | 27 | +Authors: |
120 | + /* This runs inside the BQL. */ | 28 | + 2015 Denis Lunev <den@openvz.org> |
121 | SaveStateHandler *save_state; | 29 | + 2015 Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> |
122 | 30 | + 2016-2017 Klim Kireev <klim.kireev@virtuozzo.com> | |
123 | /* | 31 | + 2016-2017 Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com> |
124 | @@ -XXX,XX +XXX,XX @@ typedef struct SaveVMHandlers { | 32 | + |
125 | int (*save_live_complete_postcopy)(QEMUFile *f, void *opaque); | 33 | +This work is licensed under the terms of the GNU GPL, version 2 or later. |
126 | int (*save_live_complete_precopy)(QEMUFile *f, void *opaque); | 34 | +See the COPYING file in the top-level directory. |
127 | 35 | + | |
128 | - /* This runs both outside and inside the iothread lock. */ | 36 | +This specification contains minimal information about Parallels Disk Format, |
129 | + /* This runs both outside and inside the BQL. */ | 37 | +which is enough to proper work with QEMU. Nevertheless, Parallels Cloud Server |
130 | bool (*is_active)(void *opaque); | 38 | +and Parallels Desktop are able to add some unspecified nodes to xml and use |
131 | bool (*has_postcopy)(void *opaque); | 39 | +them, but they are for internal work and don't affect functionality. Also it |
132 | 40 | +uses auxiliary xml "Snapshot.xml", which allows to store optional snapshot | |
133 | @@ -XXX,XX +XXX,XX @@ typedef struct SaveVMHandlers { | 41 | +information, but it doesn't influence open/read/write functionality. QEMU and |
134 | */ | 42 | +other software should not use fields not covered in this document and |
135 | bool (*is_active_iterate)(void *opaque); | 43 | +Snapshot.xml file and must leave them as is. |
136 | 44 | + | |
137 | - /* This runs outside the iothread lock in the migration case, and | 45 | += Parallels Disk Format = |
138 | + /* This runs outside the BQL in the migration case, and | 46 | + |
139 | * within the lock in the savevm case. The callback had better only | 47 | +Parallels disk consists of two parts: the set of snapshots and the disk |
140 | * use data that is local to the migration thread or protected | 48 | +descriptor file, which stores information about all files and snapshots. |
141 | * by other locks. | 49 | + |
142 | */ | 50 | +== Definitions == |
143 | int (*save_live_iterate)(QEMUFile *f, void *opaque); | 51 | + Snapshot a record of the contents captured at a particular time, |
144 | 52 | + capable of storing current state. A snapshot has UUID and | |
145 | - /* This runs outside the iothread lock! */ | 53 | + parent UUID. |
146 | + /* This runs outside the BQL! */ | 54 | + |
147 | /* Note for save_live_pending: | 55 | + Snapshot image an overlay representing the difference between this |
148 | * must_precopy: | 56 | + snapshot and some earlier snapshot. |
149 | * - must be migrated in precopy or in stopped state | 57 | + |
150 | diff --git a/target/arm/internals.h b/target/arm/internals.h | 58 | + Overlay an image storing the different sectors between two captured |
151 | index XXXXXXX..XXXXXXX 100644 | 59 | + states. |
152 | --- a/target/arm/internals.h | 60 | + |
153 | +++ b/target/arm/internals.h | 61 | + Root image snapshot image with no parent, the root of snapshot tree. |
154 | @@ -XXX,XX +XXX,XX @@ static inline const char *aarch32_mode_name(uint32_t psr) | 62 | + |
155 | * | 63 | + Storage the backing storage for a subset of the virtual disk. When |
156 | * Update the CPU_INTERRUPT_VIRQ bit in cs->interrupt_request, following | 64 | + there is more than one storage in a Parallels disk then that |
157 | * a change to either the input VIRQ line from the GIC or the HCR_EL2.VI bit. | 65 | + is referred to as a split image. In this case every storage |
158 | - * Must be called with the iothread lock held. | 66 | + covers specific address space area of the disk and has its |
159 | + * Must be called with the BQL held. | 67 | + particular root image. Split images are not considered here |
160 | */ | 68 | + and are not supported. Each storage consists of disk |
161 | void arm_cpu_update_virq(ARMCPU *cpu); | 69 | + parameters and a list of images. The list of images always |
162 | 70 | + contains a root image and may also contain overlays. The | |
163 | @@ -XXX,XX +XXX,XX @@ void arm_cpu_update_virq(ARMCPU *cpu); | 71 | + root image can be an expandable Parallels image file or |
164 | * | 72 | + plain. Overlays must be expandable. |
165 | * Update the CPU_INTERRUPT_VFIQ bit in cs->interrupt_request, following | 73 | + |
166 | * a change to either the input VFIQ line from the GIC or the HCR_EL2.VF bit. | 74 | + Description DiskDescriptor.xml stores information about disk parameters, |
167 | - * Must be called with the iothread lock held. | 75 | + file snapshots, storages. |
168 | + * Must be called with the BQL held. | 76 | + |
169 | */ | 77 | + Top The overlay between actual state and some previous snapshot. |
170 | void arm_cpu_update_vfiq(ARMCPU *cpu); | 78 | + Snapshot It is not a snapshot in the classical sense because it |
171 | 79 | + serves as the active image that the guest writes to. | |
172 | diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c | 80 | + |
173 | index XXXXXXX..XXXXXXX 100644 | 81 | + Sector a 512-byte data chunk. |
174 | --- a/accel/tcg/cputlb.c | 82 | + |
175 | +++ b/accel/tcg/cputlb.c | 83 | +== Description file == |
176 | @@ -XXX,XX +XXX,XX @@ static void *atomic_mmu_lookup(CPUState *cpu, vaddr addr, MemOpIdx oi, | 84 | +All information is placed in a single XML element Parallels_disk_image. |
177 | * @size: number of bytes | 85 | +The element has only one attribute "Version", that must be 1.0. |
178 | * @mmu_idx: virtual address context | 86 | +Schema of DiskDescriptor.xml: |
179 | * @ra: return address into tcg generated code, or 0 | 87 | + |
180 | - * Context: iothread lock held | 88 | +<Parallels_disk_image Version="1.0"> |
181 | + * Context: BQL held | 89 | + <Disk_Parameters> |
182 | * | 90 | + ... |
183 | * Load @size bytes from @addr, which is memory-mapped i/o. | 91 | + </Disk_Parameters> |
184 | * The bytes are concatenated in big-endian order with @ret_be. | 92 | + <StorageData> |
185 | @@ -XXX,XX +XXX,XX @@ static Int128 do_ld16_mmu(CPUState *cpu, vaddr addr, | 93 | + ... |
186 | * @size: number of bytes | 94 | + </StorageData> |
187 | * @mmu_idx: virtual address context | 95 | + <Snapshots> |
188 | * @ra: return address into tcg generated code, or 0 | 96 | + ... |
189 | - * Context: iothread lock held | 97 | + </Snapshots> |
190 | + * Context: BQL held | 98 | +</Parallels_disk_image> |
191 | * | 99 | + |
192 | * Store @size bytes at @addr, which is memory-mapped i/o. | 100 | +== Disk_Parameters element == |
193 | * The bytes to store are extracted in little-endian order from @val_le; | 101 | +The Disk_Parameters element describes the physical layout of the virtual disk |
194 | diff --git a/accel/tcg/tcg-accel-ops-icount.c b/accel/tcg/tcg-accel-ops-icount.c | 102 | +and some general settings. |
195 | index XXXXXXX..XXXXXXX 100644 | 103 | + |
196 | --- a/accel/tcg/tcg-accel-ops-icount.c | 104 | +The Disk_Parameters element MUST contain the following child elements: |
197 | +++ b/accel/tcg/tcg-accel-ops-icount.c | 105 | + * Disk_size - number of sectors in the disk, |
198 | @@ -XXX,XX +XXX,XX @@ void icount_prepare_for_run(CPUState *cpu, int64_t cpu_budget) | 106 | + desired size of the disk. |
199 | 107 | + * Cylinders - number of the disk cylinders. | |
200 | if (cpu->icount_budget == 0) { | 108 | + * Heads - number of the disk heads. |
201 | /* | 109 | + * Sectors - number of the disk sectors per cylinder |
202 | - * We're called without the iothread lock, so must take it while | 110 | + (sector size is 512 bytes) |
203 | + * We're called without the BQL, so must take it while | 111 | + Limitation: Product of the Heads, Sectors and Cylinders |
204 | * we're calling timer handlers. | 112 | + values MUST be equal to the value of the Disk_size parameter. |
205 | */ | 113 | + * Padding - must be 0. Parallels Cloud Server and Parallels Desktop may |
206 | bql_lock(); | 114 | + use padding set to 1, however this case is not covered |
207 | diff --git a/hw/remote/mpqemu-link.c b/hw/remote/mpqemu-link.c | 115 | + by this spec, QEMU and other software should not open |
208 | index XXXXXXX..XXXXXXX 100644 | 116 | + such disks and should not create them. |
209 | --- a/hw/remote/mpqemu-link.c | 117 | + |
210 | +++ b/hw/remote/mpqemu-link.c | 118 | +== StorageData element == |
211 | @@ -XXX,XX +XXX,XX @@ bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp) | 119 | +This element of the file describes the root image and all snapshot images. |
212 | assert(qemu_in_coroutine() || !iothread); | 120 | + |
213 | 121 | +The StorageData element consists of the Storage child element, as shown below: | |
214 | /* | 122 | +<StorageData> |
215 | - * Skip unlocking/locking iothread lock when the IOThread is running | 123 | + <Storage> |
216 | + * Skip unlocking/locking BQL when the IOThread is running | 124 | + ... |
217 | * in co-routine context. Co-routine context is asserted above | 125 | + </Storage> |
218 | * for IOThread case. | 126 | +</StorageData> |
219 | * Also skip lock handling while in a co-routine in the main context. | 127 | + |
220 | diff --git a/migration/block-dirty-bitmap.c b/migration/block-dirty-bitmap.c | 128 | +A Storage element has following child elements: |
221 | index XXXXXXX..XXXXXXX 100644 | 129 | + * Start - start sector of the storage, in case of non split storage |
222 | --- a/migration/block-dirty-bitmap.c | 130 | + equals to 0. |
223 | +++ b/migration/block-dirty-bitmap.c | 131 | + * End - number of sector following the last sector, in case of non |
224 | @@ -XXX,XX +XXX,XX @@ static void send_bitmap_bits(QEMUFile *f, DBMSaveState *s, | 132 | + split storage equals to Disk_size. |
225 | g_free(buf); | 133 | + * Blocksize - storage cluster size, number of sectors per one cluster. |
226 | } | 134 | + Cluster size for each "Compressed" (see below) image in |
227 | 135 | + parallels disk must be equal to this field. Note: cluster | |
228 | -/* Called with iothread lock taken. */ | 136 | + size for Parallels Expandable Image is in 'tracks' field of |
229 | +/* Called with the BQL taken. */ | 137 | + its header (see docs/interop/parallels.txt). |
230 | static void dirty_bitmap_do_save_cleanup(DBMSaveState *s) | 138 | + * Several Image child elements. |
231 | { | 139 | + |
232 | SaveBitmapState *dbms; | 140 | +Each Image element has following child elements: |
233 | @@ -XXX,XX +XXX,XX @@ static void dirty_bitmap_do_save_cleanup(DBMSaveState *s) | 141 | + * GUID - image identifier, UUID in curly brackets. |
234 | } | 142 | + For instance, {12345678-9abc-def1-2345-6789abcdef12}. |
235 | } | 143 | + The GUID is used by the Snapshots element to reference images |
236 | 144 | + (see below) | |
237 | -/* Called with iothread lock taken. */ | 145 | + * Type - image type of the element. It can be: |
238 | +/* Called with the BQL taken. */ | 146 | + "Plain" for raw files. |
239 | static int add_bitmaps_to_list(DBMSaveState *s, BlockDriverState *bs, | 147 | + "Compressed" for expanding disks. |
240 | const char *bs_name, GHashTable *alias_map) | 148 | + * File - path to image file. Path can be relative to DiskDecriptor.xml or |
241 | { | 149 | + absolute. |
242 | @@ -XXX,XX +XXX,XX @@ static int add_bitmaps_to_list(DBMSaveState *s, BlockDriverState *bs, | 150 | + |
243 | return 0; | 151 | +== Snapshots element == |
244 | } | 152 | +The Snapshots element describes the snapshot relations with the snapshot tree. |
245 | 153 | + | |
246 | -/* Called with iothread lock taken. */ | 154 | +The element contains the set of Shot child elements, as shown below: |
247 | +/* Called with the BQL taken. */ | 155 | +<Snapshots> |
248 | static int init_dirty_bitmap_migration(DBMSaveState *s) | 156 | + <TopGUID> ... </TopGUID> /* Optional child element */ |
249 | { | 157 | + <Shot> |
250 | BlockDriverState *bs; | 158 | + ... |
251 | @@ -XXX,XX +XXX,XX @@ static int init_dirty_bitmap_migration(DBMSaveState *s) | 159 | + </Shot> |
252 | BlockBackend *blk; | 160 | + <Shot> |
253 | GHashTable *alias_map = NULL; | 161 | + ... |
254 | 162 | + </Shot> | |
255 | - /* Runs in the migration thread, but holds the iothread lock */ | 163 | + ... |
256 | + /* Runs in the migration thread, but holds the BQL */ | 164 | +</Snapshots> |
257 | GLOBAL_STATE_CODE(); | 165 | + |
258 | GRAPH_RDLOCK_GUARD_MAINLOOP(); | 166 | +Each Shot element contains the following child elements: |
259 | 167 | + * GUID - an image GUID. | |
260 | @@ -XXX,XX +XXX,XX @@ static int dirty_bitmap_save_iterate(QEMUFile *f, void *opaque) | 168 | + * ParentGUID - GUID of the image of the parent snapshot. |
261 | return s->bulk_completed; | 169 | + |
262 | } | 170 | +The software may traverse snapshots from child to parent using <ParentGUID> |
263 | 171 | +field as reference. ParentGUID of root snapshot is | |
264 | -/* Called with iothread lock taken. */ | 172 | +{00000000-0000-0000-0000-000000000000}. There should be only one root |
265 | +/* Called with the BQL taken. */ | 173 | +snapshot. Top snapshot could be described via two ways: via TopGUID child |
266 | 174 | +element of the Snapshots element or via predefined GUID | |
267 | static int dirty_bitmap_save_complete(QEMUFile *f, void *opaque) | 175 | +{5fbaabe3-6958-40ff-92a7-860e329aab41}. If TopGUID is defined, predefined GUID is |
268 | { | 176 | +interpreted as usual GUID. All snapshot images (except Top Snapshot) should be |
269 | diff --git a/migration/block.c b/migration/block.c | 177 | +opened read-only. There is another predefined GUID, |
270 | index XXXXXXX..XXXXXXX 100644 | 178 | +BackupID = {704718e1-2314-44c8-9087-d78ed36b0f4e}, which is used by original and |
271 | --- a/migration/block.c | 179 | +some third-party software for backup, QEMU and other software may operate with |
272 | +++ b/migration/block.c | 180 | +images with GUID = BackupID as usual, however, it is not recommended to use this |
273 | @@ -XXX,XX +XXX,XX @@ typedef struct BlkMigState { | 181 | +GUID for new disks. Top snapshot cannot have this GUID. |
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 | { | ||
300 | @@ -XXX,XX +XXX,XX @@ fail: | ||
301 | return ret; | ||
302 | } | ||
303 | |||
304 | -/* Called with iothread lock taken. */ | ||
305 | +/* Called with the BQL taken. */ | ||
306 | |||
307 | static void unset_dirty_tracking(void) | ||
308 | { | ||
309 | @@ -XXX,XX +XXX,XX @@ static void blk_mig_reset_dirty_cursor(void) | ||
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 | ||
389 | @@ -XXX,XX +XXX,XX @@ fail: | ||
390 | |||
391 | /** | ||
392 | * migration_maybe_pause: Pause if required to by | ||
393 | - * migrate_pause_before_switchover called with the iothread locked | ||
394 | + * migrate_pause_before_switchover called with the BQL locked | ||
395 | * Returns: 0 on success | ||
396 | */ | ||
397 | static int migration_maybe_pause(MigrationState *s, | ||
398 | diff --git a/migration/ram.c b/migration/ram.c | ||
399 | index XXXXXXX..XXXXXXX 100644 | ||
400 | --- a/migration/ram.c | ||
401 | +++ b/migration/ram.c | ||
402 | @@ -XXX,XX +XXX,XX @@ static void ram_save_cleanup(void *opaque) | ||
403 | |||
404 | /* We don't use dirty log with background snapshots */ | ||
405 | if (!migrate_background_snapshot()) { | ||
406 | - /* caller have hold iothread lock or is in a bh, so there is | ||
407 | + /* caller have hold BQL or is in a bh, so there is | ||
408 | * no writing race against the migration bitmap | ||
409 | */ | ||
410 | if (global_dirty_tracking & GLOBAL_DIRTY_MIGRATION) { | ||
411 | @@ -XXX,XX +XXX,XX @@ out: | ||
412 | * | ||
413 | * Returns zero to indicate success or negative on error | ||
414 | * | ||
415 | - * Called with iothread lock | ||
416 | + * Called with the BQL | ||
417 | * | ||
418 | * @f: QEMUFile where to send the data | ||
419 | * @opaque: RAMState pointer | ||
420 | diff --git a/system/physmem.c b/system/physmem.c | ||
421 | index XXXXXXX..XXXXXXX 100644 | ||
422 | --- a/system/physmem.c | ||
423 | +++ b/system/physmem.c | ||
424 | @@ -XXX,XX +XXX,XX @@ static RAMBlock *qemu_get_ram_block(ram_addr_t addr) | ||
425 | abort(); | ||
426 | |||
427 | found: | ||
428 | - /* It is safe to write mru_block outside the iothread lock. This | ||
429 | + /* It is safe to write mru_block outside the BQL. This | ||
430 | * is what happens: | ||
431 | * | ||
432 | * mru_block = xxx | ||
433 | @@ -XXX,XX +XXX,XX @@ int qemu_ram_get_fd(RAMBlock *rb) | ||
434 | return rb->fd; | ||
435 | } | ||
436 | |||
437 | -/* Called with iothread lock held. */ | ||
438 | +/* Called with the BQL held. */ | ||
439 | void qemu_ram_set_idstr(RAMBlock *new_block, const char *name, DeviceState *dev) | ||
440 | { | ||
441 | RAMBlock *block; | ||
442 | @@ -XXX,XX +XXX,XX @@ void qemu_ram_set_idstr(RAMBlock *new_block, const char *name, DeviceState *dev) | ||
443 | } | ||
444 | } | ||
445 | |||
446 | -/* Called with iothread lock held. */ | ||
447 | +/* Called with the BQL held. */ | ||
448 | void qemu_ram_unset_idstr(RAMBlock *block) | ||
449 | { | ||
450 | /* FIXME: arch_init.c assumes that this is not called throughout | ||
451 | diff --git a/target/arm/helper.c b/target/arm/helper.c | ||
452 | index XXXXXXX..XXXXXXX 100644 | ||
453 | --- a/target/arm/helper.c | ||
454 | +++ b/target/arm/helper.c | ||
455 | @@ -XXX,XX +XXX,XX @@ static void do_hcr_write(CPUARMState *env, uint64_t value, uint64_t valid_mask) | ||
456 | * Updates to VI and VF require us to update the status of | ||
457 | * virtual interrupts, which are the logical OR of these bits | ||
458 | * and the state of the input lines from the GIC. (This requires | ||
459 | - * that we have the iothread lock, which is done by marking the | ||
460 | + * that we have the BQL, which is done by marking the | ||
461 | * reginfo structs as ARM_CP_IO.) | ||
462 | * Note that if a write to HCR pends a VIRQ or VFIQ it is never | ||
463 | * possible for it to be taken immediately, because VIRQ and | ||
464 | diff --git a/ui/spice-core.c b/ui/spice-core.c | ||
465 | index XXXXXXX..XXXXXXX 100644 | ||
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(); | ||
543 | -- | 182 | -- |
544 | 2.43.0 | 183 | 2.14.3 |
545 | 184 | ||
546 | 185 | diff view generated by jsdifflib |
1 | The name "iothread" is overloaded. Use the term Big QEMU Lock (BQL) | 1 | From: Klim Kireev <klim.kireev@virtuozzo.com> |
---|---|---|---|
2 | instead, it is already widely used and unambiguous. | ||
3 | 2 | ||
4 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | 3 | This dependency is required for adequate Parallels images support. |
5 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | 4 | Typically the disk consists of several images which are glued by |
6 | Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> | 5 | XML disk descriptor. Also XML hides inside several important parameters |
7 | Reviewed-by: Paul Durrant <paul@xen.org> | 6 | which are not available in the image header. |
8 | Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com> | 7 | |
9 | Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com> | 8 | The patch also adds clause to checkpatch.pl to understand libxml2 types. |
10 | Message-id: 20240102153529.486531-4-stefanha@redhat.com | 9 | |
10 | Signed-off-by: Denis V. Lunev <den@openvz.org> | ||
11 | Signed-off-by: Klim Kireev <klim.kireev@virtuozzo.com> | ||
12 | Signed-off-by: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com> | ||
13 | Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
14 | Message-id: 20180112090122.1702-3-klim.kireev@virtuozzo.com | ||
15 | CC: Stefan Hajnoczi <stefanha@redhat.com> | ||
11 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | 16 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
12 | --- | 17 | --- |
13 | include/qemu/main-loop.h | 10 +++++----- | 18 | configure | 27 +++++++++++++++++++++++++++ |
14 | accel/tcg/tcg-accel-ops-rr.c | 4 ++-- | 19 | block/Makefile.objs | 2 ++ |
15 | hw/display/virtio-gpu.c | 2 +- | 20 | scripts/checkpatch.pl | 1 + |
16 | hw/ppc/spapr_events.c | 2 +- | 21 | 3 files changed, 30 insertions(+) |
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(-) | ||
22 | 22 | ||
23 | diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h | 23 | diff --git a/configure b/configure |
24 | index XXXXXXX..XXXXXXX 100755 | ||
25 | --- a/configure | ||
26 | +++ b/configure | ||
27 | @@ -XXX,XX +XXX,XX @@ tcmalloc="no" | ||
28 | jemalloc="no" | ||
29 | replication="yes" | ||
30 | vxhs="" | ||
31 | +libxml2="" | ||
32 | |||
33 | supported_cpu="no" | ||
34 | supported_os="no" | ||
35 | @@ -XXX,XX +XXX,XX @@ for opt do | ||
36 | ;; | ||
37 | --enable-numa) numa="yes" | ||
38 | ;; | ||
39 | + --disable-libxml2) libxml2="no" | ||
40 | + ;; | ||
41 | + --enable-libxml2) libxml2="yes" | ||
42 | + ;; | ||
43 | --disable-tcmalloc) tcmalloc="no" | ||
44 | ;; | ||
45 | --enable-tcmalloc) tcmalloc="yes" | ||
46 | @@ -XXX,XX +XXX,XX @@ disabled with --disable-FEATURE, default is enabled if available: | ||
47 | tpm TPM support | ||
48 | libssh2 ssh block device support | ||
49 | numa libnuma support | ||
50 | + libxml2 for Parallels image format | ||
51 | tcmalloc tcmalloc support | ||
52 | jemalloc jemalloc support | ||
53 | replication replication support | ||
54 | @@ -XXX,XX +XXX,XX @@ EOF | ||
55 | fi | ||
56 | fi | ||
57 | |||
58 | +########################################## | ||
59 | +# libxml2 probe | ||
60 | +if test "$libxml2" != "no" ; then | ||
61 | + if $pkg_config --exists libxml-2.0; then | ||
62 | + libxml2="yes" | ||
63 | + libxml2_cflags=$($pkg_config --cflags libxml-2.0) | ||
64 | + libxml2_libs=$($pkg_config --libs libxml-2.0) | ||
65 | + else | ||
66 | + if test "$libxml2" = "yes"; then | ||
67 | + feature_not_found "libxml2" "Install libxml2 devel" | ||
68 | + fi | ||
69 | + libxml2="no" | ||
70 | + fi | ||
71 | +fi | ||
72 | |||
73 | ########################################## | ||
74 | # glusterfs probe | ||
75 | @@ -XXX,XX +XXX,XX @@ echo "lzo support $lzo" | ||
76 | echo "snappy support $snappy" | ||
77 | echo "bzip2 support $bzip2" | ||
78 | echo "NUMA host support $numa" | ||
79 | +echo "libxml2 $libxml2" | ||
80 | echo "tcmalloc support $tcmalloc" | ||
81 | echo "jemalloc support $jemalloc" | ||
82 | echo "avx2 optimization $avx2_opt" | ||
83 | @@ -XXX,XX +XXX,XX @@ if test "$have_rtnetlink" = "yes" ; then | ||
84 | echo "CONFIG_RTNETLINK=y" >> $config_host_mak | ||
85 | fi | ||
86 | |||
87 | +if test "$libxml2" = "yes" ; then | ||
88 | + echo "CONFIG_LIBXML2=y" >> $config_host_mak | ||
89 | + echo "LIBXML2_CFLAGS=$libxml2_cflags" >> $config_host_mak | ||
90 | + echo "LIBXML2_LIBS=$libxml2_libs" >> $config_host_mak | ||
91 | +fi | ||
92 | + | ||
93 | if test "$replication" = "yes" ; then | ||
94 | echo "CONFIG_REPLICATION=y" >> $config_host_mak | ||
95 | fi | ||
96 | diff --git a/block/Makefile.objs b/block/Makefile.objs | ||
24 | index XXXXXXX..XXXXXXX 100644 | 97 | index XXXXXXX..XXXXXXX 100644 |
25 | --- a/include/qemu/main-loop.h | 98 | --- a/block/Makefile.objs |
26 | +++ b/include/qemu/main-loop.h | 99 | +++ b/block/Makefile.objs |
27 | @@ -XXX,XX +XXX,XX @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(BQLLockAuto, bql_auto_unlock) | 100 | @@ -XXX,XX +XXX,XX @@ block-obj-$(if $(CONFIG_BZIP2),m,n) += dmg-bz2.o |
28 | = bql_auto_lock(__FILE__, __LINE__) | 101 | dmg-bz2.o-libs := $(BZIP2_LIBS) |
29 | 102 | qcow.o-libs := -lz | |
30 | /* | 103 | linux-aio.o-libs := -laio |
31 | - * qemu_cond_wait_iothread: Wait on condition for the main loop mutex | 104 | +parallels.o-cflags := $(LIBXML2_CFLAGS) |
32 | + * qemu_cond_wait_bql: Wait on condition for the Big QEMU Lock (BQL) | 105 | +parallels.o-libs := $(LIBXML2_LIBS) |
33 | * | 106 | diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl |
34 | - * This function atomically releases the main loop mutex and causes | 107 | index XXXXXXX..XXXXXXX 100755 |
35 | + * This function atomically releases the Big QEMU Lock (BQL) and causes | 108 | --- a/scripts/checkpatch.pl |
36 | * the calling thread to block on the condition. | 109 | +++ b/scripts/checkpatch.pl |
37 | */ | 110 | @@ -XXX,XX +XXX,XX @@ our @typeList = ( |
38 | -void qemu_cond_wait_iothread(QemuCond *cond); | 111 | qr{${Ident}_handler_fn}, |
39 | +void qemu_cond_wait_bql(QemuCond *cond); | 112 | qr{target_(?:u)?long}, |
40 | 113 | qr{hwaddr}, | |
41 | /* | 114 | + qr{xml${Ident}}, |
42 | - * qemu_cond_timedwait_iothread: like the previous, but with timeout | 115 | ); |
43 | + * qemu_cond_timedwait_bql: like the previous, but with timeout | 116 | |
44 | */ | 117 | # This can be modified by sub possible. Since it can be empty, be careful |
45 | -void qemu_cond_timedwait_iothread(QemuCond *cond, int ms); | ||
46 | +void qemu_cond_timedwait_bql(QemuCond *cond, int ms); | ||
47 | |||
48 | /* internal interfaces */ | ||
49 | |||
50 | diff --git a/accel/tcg/tcg-accel-ops-rr.c b/accel/tcg/tcg-accel-ops-rr.c | ||
51 | index XXXXXXX..XXXXXXX 100644 | ||
52 | --- a/accel/tcg/tcg-accel-ops-rr.c | ||
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); | ||
117 | } | ||
118 | |||
119 | -void qemu_cond_wait_iothread(QemuCond *cond) | ||
120 | +void qemu_cond_wait_bql(QemuCond *cond) | ||
121 | { | ||
122 | qemu_cond_wait(cond, &bql); | ||
123 | } | ||
124 | |||
125 | -void qemu_cond_timedwait_iothread(QemuCond *cond, int ms) | ||
126 | +void qemu_cond_timedwait_bql(QemuCond *cond, int ms) | ||
127 | { | ||
128 | qemu_cond_timedwait(cond, &bql, ms); | ||
129 | } | ||
130 | diff --git a/target/i386/nvmm/nvmm-accel-ops.c b/target/i386/nvmm/nvmm-accel-ops.c | ||
131 | index XXXXXXX..XXXXXXX 100644 | ||
132 | --- a/target/i386/nvmm/nvmm-accel-ops.c | ||
133 | +++ b/target/i386/nvmm/nvmm-accel-ops.c | ||
134 | @@ -XXX,XX +XXX,XX @@ static void *qemu_nvmm_cpu_thread_fn(void *arg) | ||
135 | } | ||
136 | } | ||
137 | while (cpu_thread_is_idle(cpu)) { | ||
138 | - qemu_cond_wait_iothread(cpu->halt_cond); | ||
139 | + qemu_cond_wait_bql(cpu->halt_cond); | ||
140 | } | ||
141 | qemu_wait_io_event_common(cpu); | ||
142 | } while (!cpu->unplug || cpu_can_run(cpu)); | ||
143 | diff --git a/target/i386/whpx/whpx-accel-ops.c b/target/i386/whpx/whpx-accel-ops.c | ||
144 | index XXXXXXX..XXXXXXX 100644 | ||
145 | --- a/target/i386/whpx/whpx-accel-ops.c | ||
146 | +++ b/target/i386/whpx/whpx-accel-ops.c | ||
147 | @@ -XXX,XX +XXX,XX @@ static void *whpx_cpu_thread_fn(void *arg) | ||
148 | } | ||
149 | } | ||
150 | while (cpu_thread_is_idle(cpu)) { | ||
151 | - qemu_cond_wait_iothread(cpu->halt_cond); | ||
152 | + qemu_cond_wait_bql(cpu->halt_cond); | ||
153 | } | ||
154 | qemu_wait_io_event_common(cpu); | ||
155 | } while (!cpu->unplug || cpu_can_run(cpu)); | ||
156 | -- | 118 | -- |
157 | 2.43.0 | 119 | 2.14.3 |
158 | 120 | ||
159 | 121 | diff view generated by jsdifflib |
1 | The Big QEMU Lock (BQL) has many names and they are confusing. The | 1 | From: Klim Kireev <klim.kireev@virtuozzo.com> |
---|---|---|---|
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(). | ||
6 | 2 | ||
7 | The "iothread" name is historic and comes from when the main thread was | 3 | To implement xml format, some defines and structures |
8 | split into into KVM vcpu threads and the "iothread" (now called the main | 4 | from parallels.c are required. |
9 | loop thread). I have contributed to the confusion myself by introducing | ||
10 | a separate --object iothread, a separate concept unrelated to the BQL. | ||
11 | 5 | ||
12 | The "iothread" name is no longer appropriate for the BQL. Rename the | 6 | Signed-off-by: Klim Kireev <klim.kireev@virtuozzo.com> |
13 | locking APIs to: | 7 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> |
14 | - void bql_lock(void) | 8 | Signed-off-by: Denis V. Lunev <den@openvz.org> |
15 | - void bql_unlock(void) | 9 | Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> |
16 | - bool bql_locked(void) | 10 | Signed-off-by: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com> |
17 | 11 | Message-id: 20180112090122.1702-4-klim.kireev@virtuozzo.com | |
18 | There are more APIs with "iothread" in their names. Subsequent patches | 12 | CC: Stefan Hajnoczi <stefanha@redhat.com> |
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> | 13 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
34 | --- | 14 | --- |
35 | include/block/aio-wait.h | 2 +- | 15 | block/parallels.h | 86 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
36 | include/qemu/main-loop.h | 39 +++++---- | 16 | block/parallels.c | 53 +--------------------------------- |
37 | include/qemu/thread.h | 2 +- | 17 | 2 files changed, 87 insertions(+), 52 deletions(-) |
38 | accel/accel-blocker.c | 10 +-- | 18 | create mode 100644 block/parallels.h |
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(-) | ||
131 | 19 | ||
132 | diff --git a/include/block/aio-wait.h b/include/block/aio-wait.h | 20 | diff --git a/block/parallels.h b/block/parallels.h |
21 | new file mode 100644 | ||
22 | index XXXXXXX..XXXXXXX | ||
23 | --- /dev/null | ||
24 | +++ b/block/parallels.h | ||
25 | @@ -XXX,XX +XXX,XX @@ | ||
26 | +/* | ||
27 | +* Block driver for Parallels disk image format | ||
28 | +* | ||
29 | +* Copyright (c) 2015-2017 Virtuozzo, Inc. | ||
30 | +* Authors: | ||
31 | +* 2016-2017 Klim S. Kireev <klim.kireev@virtuozzo.com> | ||
32 | +* 2015 Denis V. Lunev <den@openvz.org> | ||
33 | +* | ||
34 | +* This code was originally based on comparing different disk images created | ||
35 | +* by Parallels. Currently it is based on opened OpenVZ sources | ||
36 | +* available at | ||
37 | +* https://github.com/OpenVZ/ploop | ||
38 | +* | ||
39 | +* Permission is hereby granted, free of charge, to any person obtaining a copy | ||
40 | +* of this software and associated documentation files (the "Software"), to deal | ||
41 | +* in the Software without restriction, including without limitation the rights | ||
42 | +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
43 | +* copies of the Software, and to permit persons to whom the Software is | ||
44 | +* furnished to do so, subject to the following conditions: | ||
45 | +* | ||
46 | +* The above copyright notice and this permission notice shall be included in | ||
47 | +* all copies or substantial portions of the Software. | ||
48 | +* | ||
49 | +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
50 | +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
51 | +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
52 | +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
53 | +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
54 | +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
55 | +* THE SOFTWARE. | ||
56 | +*/ | ||
57 | +#ifndef BLOCK_PARALLELS_H | ||
58 | +#define BLOCK_PARALLELS_H | ||
59 | +#include "qemu/coroutine.h" | ||
60 | +#include "qemu/typedefs.h" | ||
61 | + | ||
62 | +#define DEFAULT_CLUSTER_SIZE 1048576 /* 1 MiB */ | ||
63 | + | ||
64 | +/* always little-endian */ | ||
65 | +typedef struct ParallelsHeader { | ||
66 | + char magic[16]; /* "WithoutFreeSpace" */ | ||
67 | + uint32_t version; | ||
68 | + uint32_t heads; | ||
69 | + uint32_t cylinders; | ||
70 | + uint32_t tracks; | ||
71 | + uint32_t bat_entries; | ||
72 | + uint64_t nb_sectors; | ||
73 | + uint32_t inuse; | ||
74 | + uint32_t data_off; | ||
75 | + char padding[12]; | ||
76 | +} QEMU_PACKED ParallelsHeader; | ||
77 | + | ||
78 | +typedef enum ParallelsPreallocMode { | ||
79 | + PRL_PREALLOC_MODE_FALLOCATE = 0, | ||
80 | + PRL_PREALLOC_MODE_TRUNCATE = 1, | ||
81 | + PRL_PREALLOC_MODE__MAX = 2, | ||
82 | +} ParallelsPreallocMode; | ||
83 | + | ||
84 | +typedef struct BDRVParallelsState { | ||
85 | + /** Locking is conservative, the lock protects | ||
86 | + * - image file extending (truncate, fallocate) | ||
87 | + * - any access to block allocation table | ||
88 | + */ | ||
89 | + CoMutex lock; | ||
90 | + | ||
91 | + ParallelsHeader *header; | ||
92 | + uint32_t header_size; | ||
93 | + bool header_unclean; | ||
94 | + | ||
95 | + unsigned long *bat_dirty_bmap; | ||
96 | + unsigned int bat_dirty_block; | ||
97 | + | ||
98 | + uint32_t *bat_bitmap; | ||
99 | + unsigned int bat_size; | ||
100 | + | ||
101 | + int64_t data_end; | ||
102 | + uint64_t prealloc_size; | ||
103 | + ParallelsPreallocMode prealloc_mode; | ||
104 | + | ||
105 | + unsigned int tracks; | ||
106 | + | ||
107 | + unsigned int off_multiplier; | ||
108 | + Error *migration_blocker; | ||
109 | +} BDRVParallelsState; | ||
110 | + | ||
111 | +#endif | ||
112 | diff --git a/block/parallels.c b/block/parallels.c | ||
133 | index XXXXXXX..XXXXXXX 100644 | 113 | index XXXXXXX..XXXXXXX 100644 |
134 | --- a/include/block/aio-wait.h | 114 | --- a/block/parallels.c |
135 | +++ b/include/block/aio-wait.h | 115 | +++ b/block/parallels.c |
136 | @@ -XXX,XX +XXX,XX @@ static inline bool in_aio_context_home_thread(AioContext *ctx) | ||
137 | } | ||
138 | |||
139 | if (ctx == qemu_get_aio_context()) { | ||
140 | - return qemu_mutex_iothread_locked(); | ||
141 | + return bql_locked(); | ||
142 | } else { | ||
143 | return false; | ||
144 | } | ||
145 | diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h | ||
146 | index XXXXXXX..XXXXXXX 100644 | ||
147 | --- a/include/qemu/main-loop.h | ||
148 | +++ b/include/qemu/main-loop.h | ||
149 | @@ -XXX,XX +XXX,XX @@ GSource *iohandler_get_g_source(void); | ||
150 | AioContext *iohandler_get_aio_context(void); | ||
151 | |||
152 | /** | ||
153 | - * qemu_mutex_iothread_locked: Return lock status of the main loop mutex. | ||
154 | + * bql_locked: Return lock status of the Big QEMU Lock (BQL) | ||
155 | * | ||
156 | - * The main loop mutex is the coarsest lock in QEMU, and as such it | ||
157 | + * The Big QEMU Lock (BQL) is the coarsest lock in QEMU, and as such it | ||
158 | * must always be taken outside other locks. This function helps | ||
159 | * functions take different paths depending on whether the current | ||
160 | - * thread is running within the main loop mutex. | ||
161 | + * thread is running within the BQL. | ||
162 | * | ||
163 | * This function should never be used in the block layer, because | ||
164 | * unit tests, block layer tools and qemu-storage-daemon do not | ||
165 | * have a BQL. | ||
166 | * Please instead refer to qemu_in_main_thread(). | ||
167 | */ | ||
168 | -bool qemu_mutex_iothread_locked(void); | ||
169 | +bool bql_locked(void); | ||
170 | |||
171 | /** | ||
172 | * qemu_in_main_thread: return whether it's possible to safely access | ||
173 | @@ -XXX,XX +XXX,XX @@ bool qemu_in_main_thread(void); | ||
174 | } while (0) | ||
175 | |||
176 | /** | ||
177 | - * qemu_mutex_lock_iothread: Lock the main loop mutex. | ||
178 | + * bql_lock: Lock the Big QEMU Lock (BQL). | ||
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 @@ | 116 | @@ -XXX,XX +XXX,XX @@ |
1241 | */ | 117 | #include "qemu/bswap.h" |
1242 | bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp) | 118 | #include "qemu/bitmap.h" |
1243 | { | 119 | #include "migration/blocker.h" |
1244 | - bool iolock = qemu_mutex_iothread_locked(); | 120 | +#include "parallels.h" |
1245 | + bool drop_bql = bql_locked(); | 121 | |
1246 | bool iothread = qemu_in_iothread(); | 122 | /**************************************************************/ |
1247 | struct iovec send[2] = {}; | 123 | |
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 @@ | 124 | @@ -XXX,XX +XXX,XX @@ |
1991 | #include "qemu/osdep.h" | 125 | #define HEADER_INUSE_MAGIC (0x746F6E59) |
1992 | #include "qemu/main-loop.h" | 126 | #define MAX_PARALLELS_IMAGE_FACTOR (1ull << 32) |
1993 | 127 | ||
1994 | -bool qemu_mutex_iothread_locked(void) | 128 | -#define DEFAULT_CLUSTER_SIZE 1048576 /* 1 MiB */ |
1995 | +bool bql_locked(void) | 129 | - |
1996 | { | 130 | - |
1997 | return false; | 131 | -// always little-endian |
1998 | } | 132 | -typedef struct ParallelsHeader { |
1999 | 133 | - char magic[16]; // "WithoutFreeSpace" | |
2000 | -void qemu_mutex_lock_iothread_impl(const char *file, int line) | 134 | - uint32_t version; |
2001 | +void bql_lock_impl(const char *file, int line) | 135 | - uint32_t heads; |
2002 | { | 136 | - uint32_t cylinders; |
2003 | } | 137 | - uint32_t tracks; |
2004 | 138 | - uint32_t bat_entries; | |
2005 | -void qemu_mutex_unlock_iothread(void) | 139 | - uint64_t nb_sectors; |
2006 | +void bql_unlock(void) | 140 | - uint32_t inuse; |
2007 | { | 141 | - uint32_t data_off; |
2008 | } | 142 | - char padding[12]; |
2009 | diff --git a/system/cpu-throttle.c b/system/cpu-throttle.c | 143 | -} QEMU_PACKED ParallelsHeader; |
2010 | index XXXXXXX..XXXXXXX 100644 | 144 | - |
2011 | --- a/system/cpu-throttle.c | 145 | - |
2012 | +++ b/system/cpu-throttle.c | 146 | -typedef enum ParallelsPreallocMode { |
2013 | @@ -XXX,XX +XXX,XX @@ static void cpu_throttle_thread(CPUState *cpu, run_on_cpu_data opaque) | 147 | - PRL_PREALLOC_MODE_FALLOCATE = 0, |
2014 | qemu_cond_timedwait_iothread(cpu->halt_cond, | 148 | - PRL_PREALLOC_MODE_TRUNCATE = 1, |
2015 | sleeptime_ns / SCALE_MS); | 149 | - PRL_PREALLOC_MODE__MAX = 2, |
2016 | } else { | 150 | -} ParallelsPreallocMode; |
2017 | - qemu_mutex_unlock_iothread(); | 151 | - |
2018 | + bql_unlock(); | 152 | static QEnumLookup prealloc_mode_lookup = { |
2019 | g_usleep(sleeptime_ns / SCALE_US); | 153 | .array = (const char *const[]) { |
2020 | - qemu_mutex_lock_iothread(); | 154 | "falloc", |
2021 | + bql_lock(); | 155 | @@ -XXX,XX +XXX,XX @@ static QEnumLookup prealloc_mode_lookup = { |
2022 | } | 156 | .size = PRL_PREALLOC_MODE__MAX |
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 | }; | 157 | }; |
3900 | 158 | ||
3901 | -QemuMutexLockFunc qemu_bql_mutex_lock_func = qemu_mutex_lock_impl; | 159 | -typedef struct BDRVParallelsState { |
3902 | +QemuMutexLockFunc bql_mutex_lock_func = qemu_mutex_lock_impl; | 160 | - /** Locking is conservative, the lock protects |
3903 | QemuMutexLockFunc qemu_mutex_lock_func = qemu_mutex_lock_impl; | 161 | - * - image file extending (truncate, fallocate) |
3904 | QemuMutexTrylockFunc qemu_mutex_trylock_func = qemu_mutex_trylock_impl; | 162 | - * - any access to block allocation table |
3905 | QemuRecMutexLockFunc qemu_rec_mutex_lock_func = qemu_rec_mutex_lock_impl; | 163 | - */ |
3906 | @@ -XXX,XX +XXX,XX @@ void qsp_enable(void) | 164 | - CoMutex lock; |
3907 | { | 165 | - |
3908 | qatomic_set(&qemu_mutex_lock_func, qsp_mutex_lock); | 166 | - ParallelsHeader *header; |
3909 | qatomic_set(&qemu_mutex_trylock_func, qsp_mutex_trylock); | 167 | - uint32_t header_size; |
3910 | - qatomic_set(&qemu_bql_mutex_lock_func, qsp_bql_mutex_lock); | 168 | - bool header_unclean; |
3911 | + qatomic_set(&bql_mutex_lock_func, qsp_bql_mutex_lock); | 169 | - |
3912 | qatomic_set(&qemu_rec_mutex_lock_func, qsp_rec_mutex_lock); | 170 | - unsigned long *bat_dirty_bmap; |
3913 | qatomic_set(&qemu_rec_mutex_trylock_func, qsp_rec_mutex_trylock); | 171 | - unsigned int bat_dirty_block; |
3914 | qatomic_set(&qemu_cond_wait_func, qsp_cond_wait); | 172 | - |
3915 | @@ -XXX,XX +XXX,XX @@ void qsp_disable(void) | 173 | - uint32_t *bat_bitmap; |
3916 | { | 174 | - unsigned int bat_size; |
3917 | qatomic_set(&qemu_mutex_lock_func, qemu_mutex_lock_impl); | 175 | - |
3918 | qatomic_set(&qemu_mutex_trylock_func, qemu_mutex_trylock_impl); | 176 | - int64_t data_end; |
3919 | - qatomic_set(&qemu_bql_mutex_lock_func, qemu_mutex_lock_impl); | 177 | - uint64_t prealloc_size; |
3920 | + qatomic_set(&bql_mutex_lock_func, qemu_mutex_lock_impl); | 178 | - ParallelsPreallocMode prealloc_mode; |
3921 | qatomic_set(&qemu_rec_mutex_lock_func, qemu_rec_mutex_lock_impl); | 179 | - |
3922 | qatomic_set(&qemu_rec_mutex_trylock_func, qemu_rec_mutex_trylock_impl); | 180 | - unsigned int tracks; |
3923 | qatomic_set(&qemu_cond_wait_func, qemu_cond_wait_impl); | 181 | - |
3924 | diff --git a/util/rcu.c b/util/rcu.c | 182 | - unsigned int off_multiplier; |
3925 | index XXXXXXX..XXXXXXX 100644 | 183 | - Error *migration_blocker; |
3926 | --- a/util/rcu.c | 184 | -} BDRVParallelsState; |
3927 | +++ b/util/rcu.c | 185 | - |
3928 | @@ -XXX,XX +XXX,XX @@ static void *call_rcu_thread(void *opaque) | 186 | - |
3929 | 187 | #define PARALLELS_OPT_PREALLOC_MODE "prealloc-mode" | |
3930 | qatomic_sub(&rcu_call_count, n); | 188 | #define PARALLELS_OPT_PREALLOC_SIZE "prealloc-size" |
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); | ||
4281 | 189 | ||
4282 | -- | 190 | -- |
4283 | 2.43.0 | 191 | 2.14.3 |
4284 | 192 | ||
4285 | 193 | diff view generated by jsdifflib |
1 | From: Philippe Mathieu-Daudé <philmd@linaro.org> | 1 | From: Klim Kireev <klim.kireev@virtuozzo.com> |
---|---|---|---|
2 | 2 | ||
3 | aio_context_set_aio_params() doesn't use its undocumented | 3 | Signed-off-by: Klim Kireev <klim.kireev@virtuozzo.com> |
4 | Error** argument. Remove it to simplify. | 4 | Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> |
5 | Signed-off-by: Denis V. Lunev <den@openvz.org> | ||
6 | Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> | ||
7 | Signed-off-by: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com> | ||
8 | Message-id: 20180112090122.1702-5-klim.kireev@virtuozzo.com | ||
9 | CC: Stefan Hajnoczi <stefanha@redhat.com> | ||
10 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | ||
11 | --- | ||
12 | block/parallels.h | 2 ++ | ||
13 | block/parallels.c | 5 +++-- | ||
14 | 2 files changed, 5 insertions(+), 2 deletions(-) | ||
5 | 15 | ||
6 | Note this removes a use of "unchecked Error**" in | 16 | diff --git a/block/parallels.h b/block/parallels.h |
7 | iothread_set_aio_context_params(). | ||
8 | |||
9 | Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org> | ||
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(-) | ||
20 | |||
21 | diff --git a/include/block/aio.h b/include/block/aio.h | ||
22 | index XXXXXXX..XXXXXXX 100644 | 17 | index XXXXXXX..XXXXXXX 100644 |
23 | --- a/include/block/aio.h | 18 | --- a/block/parallels.h |
24 | +++ b/include/block/aio.h | 19 | +++ b/block/parallels.h |
25 | @@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns, | 20 | @@ -XXX,XX +XXX,XX @@ |
26 | * @max_batch: maximum number of requests in a batch, 0 means that the | 21 | #include "qemu/coroutine.h" |
27 | * engine will use its default | 22 | #include "qemu/typedefs.h" |
28 | */ | 23 | |
29 | -void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch, | 24 | +#define HEADS_NUMBER 16 |
30 | - Error **errp); | 25 | +#define SEC_IN_CYL 32 |
31 | +void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch); | 26 | #define DEFAULT_CLUSTER_SIZE 1048576 /* 1 MiB */ |
32 | 27 | ||
33 | /** | 28 | /* always little-endian */ |
34 | * aio_context_set_thread_pool_params: | 29 | diff --git a/block/parallels.c b/block/parallels.c |
35 | diff --git a/iothread.c b/iothread.c | ||
36 | index XXXXXXX..XXXXXXX 100644 | 30 | index XXXXXXX..XXXXXXX 100644 |
37 | --- a/iothread.c | 31 | --- a/block/parallels.c |
38 | +++ b/iothread.c | 32 | +++ b/block/parallels.c |
39 | @@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp) | 33 | @@ -XXX,XX +XXX,XX @@ static int parallels_create(const char *filename, QemuOpts *opts, Error **errp) |
40 | } | 34 | memcpy(header.magic, HEADER_MAGIC2, sizeof(header.magic)); |
41 | 35 | header.version = cpu_to_le32(HEADER_VERSION); | |
42 | aio_context_set_aio_params(iothread->ctx, | 36 | /* don't care much about geometry, it is not used on image level */ |
43 | - iothread->parent_obj.aio_max_batch, | 37 | - header.heads = cpu_to_le32(16); |
44 | - errp); | 38 | - header.cylinders = cpu_to_le32(total_size / BDRV_SECTOR_SIZE / 16 / 32); |
45 | + iothread->parent_obj.aio_max_batch); | 39 | + header.heads = cpu_to_le32(HEADS_NUMBER); |
46 | 40 | + header.cylinders = cpu_to_le32(total_size / BDRV_SECTOR_SIZE | |
47 | aio_context_set_thread_pool_params(iothread->ctx, base->thread_pool_min, | 41 | + / HEADS_NUMBER / SEC_IN_CYL); |
48 | base->thread_pool_max, errp); | 42 | header.tracks = cpu_to_le32(cl_size >> BDRV_SECTOR_BITS); |
49 | diff --git a/util/aio-posix.c b/util/aio-posix.c | 43 | header.bat_entries = cpu_to_le32(bat_entries); |
50 | index XXXXXXX..XXXXXXX 100644 | 44 | header.nb_sectors = cpu_to_le64(DIV_ROUND_UP(total_size, BDRV_SECTOR_SIZE)); |
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); | ||
55 | } | ||
56 | |||
57 | -void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch, | ||
58 | - Error **errp) | ||
59 | +void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch) | ||
60 | { | ||
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 | ||
64 | index XXXXXXX..XXXXXXX 100644 | ||
65 | --- a/util/aio-win32.c | ||
66 | +++ b/util/aio-win32.c | ||
67 | @@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns, | ||
68 | } | ||
69 | } | ||
70 | |||
71 | -void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch, | ||
72 | - Error **errp) | ||
73 | +void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch) | ||
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); | ||
92 | -- | 45 | -- |
93 | 2.43.0 | 46 | 2.14.3 |
94 | 47 | ||
95 | 48 | diff view generated by jsdifflib |
1 | The name "iothread" is overloaded. Use the term Big QEMU Lock (BQL) | 1 | From: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com> |
---|---|---|---|
2 | instead, it is already widely used and unambiguous. | ||
3 | 2 | ||
4 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | 3 | Since parallels format supports backing files, refine |
5 | Reviewed-by: Paul Durrant <paul@xen.org> | 4 | readv/writev (allocate_clusters) to redirect read/write requests |
6 | Acked-by: David Woodhouse <dwmw@amazon.co.uk> | 5 | to a backing file (if cluster is not available in the current bs). |
7 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | 6 | |
8 | Acked-by: Ilya Leoshkevich <iii@linux.ibm.com> | 7 | Signed-off-by: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com> |
9 | Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com> | 8 | Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> |
10 | Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com> | 9 | Signed-off-by: Denis V. Lunev <den@openvz.org> |
11 | Message-id: 20240102153529.486531-3-stefanha@redhat.com | 10 | Signed-off-by: Klim Kireev <klim.kireev@virtuozzo.com> |
11 | Message-id: 20180112090122.1702-6-klim.kireev@virtuozzo.com | ||
12 | CC: Stefan Hajnoczi <stefanha@redhat.com> | ||
12 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> | 13 | Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com> |
13 | --- | 14 | --- |
14 | include/qemu/main-loop.h | 19 +++++++++---------- | 15 | block/parallels.c | 50 ++++++++++++++++++++++++++++++++++++++++++++------ |
15 | hw/i386/kvm/xen_evtchn.c | 14 +++++++------- | 16 | 1 file changed, 44 insertions(+), 6 deletions(-) |
16 | hw/i386/kvm/xen_gnttab.c | 2 +- | ||
17 | hw/mips/mips_int.c | 2 +- | ||
18 | hw/ppc/ppc.c | 2 +- | ||
19 | target/i386/kvm/xen-emu.c | 2 +- | ||
20 | target/ppc/excp_helper.c | 2 +- | ||
21 | target/ppc/helper_regs.c | 2 +- | ||
22 | target/riscv/cpu_helper.c | 4 ++-- | ||
23 | 9 files changed, 24 insertions(+), 25 deletions(-) | ||
24 | 17 | ||
25 | diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h | 18 | diff --git a/block/parallels.c b/block/parallels.c |
26 | index XXXXXXX..XXXXXXX 100644 | 19 | index XXXXXXX..XXXXXXX 100644 |
27 | --- a/include/qemu/main-loop.h | 20 | --- a/block/parallels.c |
28 | +++ b/include/qemu/main-loop.h | 21 | +++ b/block/parallels.c |
29 | @@ -XXX,XX +XXX,XX @@ void bql_lock_impl(const char *file, int line); | 22 | @@ -XXX,XX +XXX,XX @@ static int64_t block_status(BDRVParallelsState *s, int64_t sector_num, |
30 | void bql_unlock(void); | 23 | static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, |
31 | 24 | int nb_sectors, int *pnum) | |
32 | /** | ||
33 | - * QEMU_IOTHREAD_LOCK_GUARD | ||
34 | + * BQL_LOCK_GUARD | ||
35 | * | ||
36 | * Wrap a block of code in a conditional bql_{lock,unlock}. | ||
37 | */ | ||
38 | -typedef struct IOThreadLockAuto IOThreadLockAuto; | ||
39 | +typedef struct BQLLockAuto BQLLockAuto; | ||
40 | |||
41 | -static inline IOThreadLockAuto *qemu_iothread_auto_lock(const char *file, | ||
42 | - int line) | ||
43 | +static inline BQLLockAuto *bql_auto_lock(const char *file, int line) | ||
44 | { | 25 | { |
45 | if (bql_locked()) { | 26 | + int ret; |
46 | return NULL; | 27 | BDRVParallelsState *s = bs->opaque; |
28 | int64_t pos, space, idx, to_allocate, i, len; | ||
29 | |||
30 | @@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, | ||
31 | return len; | ||
47 | } | 32 | } |
48 | bql_lock_impl(file, line); | 33 | if (s->data_end + space > (len >> BDRV_SECTOR_BITS)) { |
49 | /* Anything non-NULL causes the cleanup function to be called */ | 34 | - int ret; |
50 | - return (IOThreadLockAuto *)(uintptr_t)1; | 35 | space += s->prealloc_size; |
51 | + return (BQLLockAuto *)(uintptr_t)1; | 36 | if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) { |
52 | } | 37 | ret = bdrv_pwrite_zeroes(bs->file, |
53 | 38 | @@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, | |
54 | -static inline void qemu_iothread_auto_unlock(IOThreadLockAuto *l) | 39 | } |
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 | } | 40 | } |
79 | 41 | ||
80 | - QEMU_IOTHREAD_LOCK_GUARD(); | 42 | + /* Try to read from backing to fill empty clusters |
81 | + BQL_LOCK_GUARD(); | 43 | + * FIXME: 1. previous write_zeroes may be redundant |
82 | return xen_evtchn_soft_reset(); | 44 | + * 2. most of data we read from backing will be rewritten by |
83 | } | 45 | + * parallels_co_writev. On aligned-to-cluster write we do not need |
84 | 46 | + * this read at all. | |
85 | @@ -XXX,XX +XXX,XX @@ int xen_evtchn_close_op(struct evtchn_close *close) | 47 | + * 3. it would be good to combine write of data from backing and new |
86 | return -EINVAL; | 48 | + * data into one write call */ |
87 | } | 49 | + if (bs->backing) { |
88 | 50 | + int64_t nb_cow_sectors = to_allocate * s->tracks; | |
89 | - QEMU_IOTHREAD_LOCK_GUARD(); | 51 | + int64_t nb_cow_bytes = nb_cow_sectors << BDRV_SECTOR_BITS; |
90 | + BQL_LOCK_GUARD(); | 52 | + QEMUIOVector qiov; |
91 | qemu_mutex_lock(&s->port_lock); | 53 | + struct iovec iov = { |
92 | 54 | + .iov_len = nb_cow_bytes, | |
93 | ret = close_port(s, close->port, &flush_kvm_routes); | 55 | + .iov_base = qemu_blockalign(bs, nb_cow_bytes) |
94 | @@ -XXX,XX +XXX,XX @@ int xen_evtchn_bind_pirq_op(struct evtchn_bind_pirq *pirq) | 56 | + }; |
95 | return -EINVAL; | 57 | + qemu_iovec_init_external(&qiov, &iov, 1); |
96 | } | 58 | + |
97 | 59 | + ret = bdrv_co_readv(bs->backing, idx * s->tracks, nb_cow_sectors, | |
98 | - QEMU_IOTHREAD_LOCK_GUARD(); | 60 | + &qiov); |
99 | + BQL_LOCK_GUARD(); | 61 | + if (ret < 0) { |
100 | 62 | + qemu_vfree(iov.iov_base); | |
101 | if (s->pirq[pirq->pirq].port) { | 63 | + return ret; |
102 | return -EBUSY; | 64 | + } |
103 | @@ -XXX,XX +XXX,XX @@ int xen_physdev_map_pirq(struct physdev_map_pirq *map) | 65 | + |
104 | return -ENOTSUP; | 66 | + ret = bdrv_co_writev(bs->file, s->data_end, nb_cow_sectors, &qiov); |
105 | } | 67 | + qemu_vfree(iov.iov_base); |
106 | 68 | + if (ret < 0) { | |
107 | - QEMU_IOTHREAD_LOCK_GUARD(); | 69 | + return ret; |
108 | + BQL_LOCK_GUARD(); | 70 | + } |
109 | QEMU_LOCK_GUARD(&s->port_lock); | 71 | + } |
110 | 72 | + | |
111 | if (map->domid != DOMID_SELF && map->domid != xen_domid) { | 73 | for (i = 0; i < to_allocate; i++) { |
112 | @@ -XXX,XX +XXX,XX @@ int xen_physdev_unmap_pirq(struct physdev_unmap_pirq *unmap) | 74 | s->bat_bitmap[idx + i] = cpu_to_le32(s->data_end / s->off_multiplier); |
113 | return -EINVAL; | 75 | s->data_end += s->tracks; |
114 | } | 76 | @@ -XXX,XX +XXX,XX @@ static coroutine_fn int parallels_co_readv(BlockDriverState *bs, |
115 | 77 | ||
116 | - QEMU_IOTHREAD_LOCK_GUARD(); | 78 | nbytes = n << BDRV_SECTOR_BITS; |
117 | + BQL_LOCK_GUARD(); | 79 | |
118 | qemu_mutex_lock(&s->port_lock); | 80 | + qemu_iovec_reset(&hd_qiov); |
119 | 81 | + qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes); | |
120 | if (!pirq_inuse(s, pirq)) { | 82 | + |
121 | @@ -XXX,XX +XXX,XX @@ int xen_physdev_eoi_pirq(struct physdev_eoi *eoi) | 83 | if (position < 0) { |
122 | return -ENOTSUP; | 84 | - qemu_iovec_memset(qiov, bytes_done, 0, nbytes); |
123 | } | 85 | + if (bs->backing) { |
124 | 86 | + ret = bdrv_co_readv(bs->backing, sector_num, n, &hd_qiov); | |
125 | - QEMU_IOTHREAD_LOCK_GUARD(); | 87 | + if (ret < 0) { |
126 | + BQL_LOCK_GUARD(); | 88 | + break; |
127 | QEMU_LOCK_GUARD(&s->port_lock); | 89 | + } |
128 | 90 | + } else { | |
129 | if (!pirq_inuse(s, pirq)) { | 91 | + qemu_iovec_memset(&hd_qiov, 0, 0, nbytes); |
130 | @@ -XXX,XX +XXX,XX @@ int xen_physdev_query_pirq(struct physdev_irq_status_query *query) | 92 | + } |
131 | return -ENOTSUP; | 93 | } else { |
132 | } | 94 | - qemu_iovec_reset(&hd_qiov); |
133 | 95 | - qemu_iovec_concat(&hd_qiov, qiov, bytes_done, nbytes); | |
134 | - QEMU_IOTHREAD_LOCK_GUARD(); | 96 | - |
135 | + BQL_LOCK_GUARD(); | 97 | ret = bdrv_co_readv(bs->file, position, n, &hd_qiov); |
136 | QEMU_LOCK_GUARD(&s->port_lock); | 98 | if (ret < 0) { |
137 | 99 | break; | |
138 | if (!pirq_inuse(s, pirq)) { | 100 | @@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_parallels = { |
139 | diff --git a/hw/i386/kvm/xen_gnttab.c b/hw/i386/kvm/xen_gnttab.c | 101 | .bdrv_co_flush_to_os = parallels_co_flush_to_os, |
140 | index XXXXXXX..XXXXXXX 100644 | 102 | .bdrv_co_readv = parallels_co_readv, |
141 | --- a/hw/i386/kvm/xen_gnttab.c | 103 | .bdrv_co_writev = parallels_co_writev, |
142 | +++ b/hw/i386/kvm/xen_gnttab.c | 104 | - |
143 | @@ -XXX,XX +XXX,XX @@ int xen_gnttab_map_page(uint64_t idx, uint64_t gfn) | 105 | + .supports_backing = true, |
144 | return -EINVAL; | 106 | .bdrv_create = parallels_create, |
145 | } | 107 | .bdrv_check = parallels_check, |
146 | 108 | .create_opts = ¶llels_create_opts, | |
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); | ||
238 | |||
239 | -- | 109 | -- |
240 | 2.43.0 | 110 | 2.14.3 |
241 | 111 | ||
242 | 112 | diff view generated by jsdifflib |