The following changes since commit ffd454c67e38cc6df792733ebc5d967eee28ac0d:

Merge tag 'pull-vfio-20240107' of https://github.com/legoater/qemu into staging (2024-01-08 10:28:42 +0000)

for you to fetch changes up to 0b2675c473f68f13bc5ca1dd1c43ce421542e7b8:

Rename "QEMU global mutex" to "BQL" in comments and docs (2024-01-08 10:45:43 -0500)

Philippe Mathieu-Daudé (1):

iothread: Remove unused Error** argument in aio_context_set_aio_params

Stefan Hajnoczi (5):

system/cpus: rename qemu_mutex_lock_iothread() to bql_lock()

qemu/main-loop: rename QEMU_IOTHREAD_LOCK_GUARD to BQL_LOCK_GUARD

qemu/main-loop: rename qemu_cond_wait_iothread() to

qemu_cond_wait_bql()

Replace "iothread lock" with "BQL" in comments

Rename "QEMU global mutex" to "BQL" in comments and docs

docs/devel/multi-thread-tcg.rst | 7 +-

docs/devel/qapi-code-gen.rst | 2 +-

docs/devel/replay.rst | 2 +-

docs/devel/reset.rst | 2 +-

docs/devel/multiple-iothreads.txt | 14 ++--

hw/display/qxl.h | 2 +-

include/block/aio-wait.h | 2 +-

include/block/aio.h | 3 +-

include/block/blockjob.h | 6 +-

include/exec/cpu-common.h | 2 +-

include/exec/memory.h | 4 +-

include/exec/ramblock.h | 2 +-

include/io/task.h | 2 +-

include/migration/register.h | 8 +-

include/qemu/coroutine-core.h | 2 +-

include/qemu/coroutine.h | 2 +-

include/qemu/main-loop.h | 68 ++++++++-------

include/qemu/thread.h | 2 +-

target/arm/internals.h | 4 +-

accel/accel-blocker.c | 10 +--

accel/dummy-cpus.c | 8 +-

accel/hvf/hvf-accel-ops.c | 4 +-

accel/kvm/kvm-accel-ops.c | 4 +-

accel/kvm/kvm-all.c | 22 ++---

accel/tcg/cpu-exec.c | 26 +++---

accel/tcg/cputlb.c | 20 ++---

accel/tcg/tcg-accel-ops-icount.c | 6 +-

accel/tcg/tcg-accel-ops-mttcg.c | 12 +--

accel/tcg/tcg-accel-ops-rr.c | 18 ++--

accel/tcg/tcg-accel-ops.c | 2 +-

accel/tcg/translate-all.c | 2 +-

cpu-common.c | 4 +-

dump/dump.c | 4 +-

hw/block/dataplane/virtio-blk.c | 8 +-

hw/block/virtio-blk.c | 2 +-

hw/core/cpu-common.c | 6 +-

hw/display/virtio-gpu.c | 2 +-

hw/i386/intel_iommu.c | 6 +-

hw/i386/kvm/xen_evtchn.c | 30 +++----

hw/i386/kvm/xen_gnttab.c | 2 +-

hw/i386/kvm/xen_overlay.c | 2 +-

hw/i386/kvm/xen_xenstore.c | 2 +-

hw/intc/arm_gicv3_cpuif.c | 2 +-

hw/intc/s390_flic.c | 18 ++--

hw/mips/mips_int.c | 2 +-

hw/misc/edu.c | 4 +-

hw/misc/imx6_src.c | 2 +-

hw/misc/imx7_src.c | 2 +-

hw/net/xen_nic.c | 8 +-

hw/ppc/pegasos2.c | 2 +-

hw/ppc/ppc.c | 6 +-

hw/ppc/spapr.c | 2 +-

hw/ppc/spapr_events.c | 2 +-

hw/ppc/spapr_rng.c | 4 +-

hw/ppc/spapr_softmmu.c | 4 +-

hw/remote/mpqemu-link.c | 22 ++---

hw/remote/vfio-user-obj.c | 2 +-

hw/s390x/s390-skeys.c | 2 +-

hw/scsi/virtio-scsi-dataplane.c | 6 +-

iothread.c | 3 +-

migration/block-dirty-bitmap.c | 14 ++--

migration/block.c | 38 ++++-----

migration/colo.c | 62 +++++++-------

migration/dirtyrate.c | 12 +--

migration/migration.c | 54 ++++++------

migration/ram.c | 16 ++--

net/tap.c | 2 +-

replay/replay-internal.c | 2 +-

semihosting/console.c | 8 +-

stubs/iothread-lock.c | 6 +-

system/cpu-throttle.c | 6 +-

system/cpus.c | 55 +++++++------

system/dirtylimit.c | 4 +-

system/memory.c | 2 +-

system/physmem.c | 14 ++--

system/runstate.c | 2 +-

system/watchpoint.c | 4 +-

target/arm/arm-powerctl.c | 14 ++--

target/arm/helper.c | 6 +-

target/arm/hvf/hvf.c | 8 +-

target/arm/kvm.c | 8 +-

target/arm/ptw.c | 6 +-

target/arm/tcg/helper-a64.c | 8 +-

target/arm/tcg/m_helper.c | 6 +-

target/arm/tcg/op_helper.c | 24 +++---

target/arm/tcg/psci.c | 2 +-

target/hppa/int_helper.c | 8 +-

target/i386/hvf/hvf.c | 6 +-

target/i386/kvm/hyperv.c | 4 +-

target/i386/kvm/kvm.c | 28 +++----

target/i386/kvm/xen-emu.c | 16 ++--

target/i386/nvmm/nvmm-accel-ops.c | 6 +-

target/i386/nvmm/nvmm-all.c | 20 ++---

target/i386/tcg/sysemu/fpu_helper.c | 6 +-

target/i386/tcg/sysemu/misc_helper.c | 4 +-

target/i386/whpx/whpx-accel-ops.c | 6 +-

target/i386/whpx/whpx-all.c | 24 +++---

target/loongarch/tcg/csr_helper.c | 4 +-

target/mips/kvm.c | 4 +-

target/mips/tcg/sysemu/cp0_helper.c | 4 +-

target/openrisc/sys_helper.c | 16 ++--

target/ppc/excp_helper.c | 14 ++--

target/ppc/helper_regs.c | 2 +-

target/ppc/kvm.c | 4 +-

target/ppc/misc_helper.c | 8 +-

target/ppc/timebase_helper.c | 8 +-

target/riscv/cpu_helper.c | 4 +-

target/s390x/kvm/kvm.c | 4 +-

target/s390x/tcg/misc_helper.c | 118 +++++++++++++--------------

target/sparc/int32_helper.c | 2 +-

target/sparc/int64_helper.c | 6 +-

target/sparc/win_helper.c | 20 ++---

target/xtensa/exc_helper.c | 8 +-

ui/spice-core.c | 6 +-

util/aio-posix.c | 3 +-

util/aio-win32.c | 3 +-

util/async.c | 2 +-

util/main-loop.c | 13 ++-

util/qsp.c | 6 +-

util/rcu.c | 16 ++--

audio/coreaudio.m | 8 +-

memory_ldst.c.inc | 18 ++--

target/i386/hvf/README.md | 2 +-

ui/cocoa.m | 56 ++++++-------

124 files changed, 646 insertions(+), 655 deletions(-)

2.43.0

The Big QEMU Lock (BQL) has many names and they are confusing. The

actual QemuMutex variable is called qemu_global_mutex but it's commonly

referred to as the BQL in discussions and some code comments. The

locking APIs, however, are called qemu_mutex_lock_iothread() and

qemu_mutex_unlock_iothread().

The "iothread" name is historic and comes from when the main thread was

split into into KVM vcpu threads and the "iothread" (now called the main

loop thread). I have contributed to the confusion myself by introducing

a separate --object iothread, a separate concept unrelated to the BQL.

The "iothread" name is no longer appropriate for the BQL. Rename the

locking APIs to:

- void bql_lock(void)

- void bql_unlock(void)

- bool bql_locked(void)

There are more APIs with "iothread" in their names. Subsequent patches

will rename them. There are also comments and documentation that will be

updated in later patches.

Reviewed-by: Paul Durrant <paul@xen.org>

Acked-by: Fabiano Rosas <farosas@suse.de>

Acked-by: David Woodhouse <dwmw@amazon.co.uk>

Reviewed-by: Cédric Le Goater <clg@kaod.org>

Acked-by: Peter Xu <peterx@redhat.com>

Acked-by: Eric Farman <farman@linux.ibm.com>

Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com>

Acked-by: Hyman Huang <yong.huang@smartx.com>

Reviewed-by: Akihiko Odaki <akihiko.odaki@daynix.com>

Message-id: 20240102153529.486531-2-stefanha@redhat.com

include/block/aio-wait.h | 2 +-

include/qemu/main-loop.h | 39 +++++----

include/qemu/thread.h | 2 +-

accel/accel-blocker.c | 10 +--

accel/dummy-cpus.c | 8 +-

accel/hvf/hvf-accel-ops.c | 4 +-

accel/kvm/kvm-accel-ops.c | 4 +-

accel/kvm/kvm-all.c | 22 ++---

accel/tcg/cpu-exec.c | 26 +++---

accel/tcg/cputlb.c | 16 ++--

accel/tcg/tcg-accel-ops-icount.c | 4 +-

accel/tcg/tcg-accel-ops-mttcg.c | 12 +--

accel/tcg/tcg-accel-ops-rr.c | 14 ++--

accel/tcg/tcg-accel-ops.c | 2 +-

accel/tcg/translate-all.c | 2 +-

cpu-common.c | 4 +-

dump/dump.c | 4 +-

hw/core/cpu-common.c | 6 +-

hw/i386/intel_iommu.c | 6 +-

hw/i386/kvm/xen_evtchn.c | 16 ++--

hw/i386/kvm/xen_overlay.c | 2 +-

hw/i386/kvm/xen_xenstore.c | 2 +-

hw/intc/arm_gicv3_cpuif.c | 2 +-

hw/intc/s390_flic.c | 18 ++--

hw/misc/edu.c | 4 +-

hw/misc/imx6_src.c | 2 +-

hw/misc/imx7_src.c | 2 +-

hw/net/xen_nic.c | 8 +-

hw/ppc/pegasos2.c | 2 +-

hw/ppc/ppc.c | 4 +-

hw/ppc/spapr.c | 2 +-

hw/ppc/spapr_rng.c | 4 +-

hw/ppc/spapr_softmmu.c | 4 +-

hw/remote/mpqemu-link.c | 20 ++---

hw/remote/vfio-user-obj.c | 2 +-

hw/s390x/s390-skeys.c | 2 +-

migration/block-dirty-bitmap.c | 4 +-

migration/block.c | 16 ++--

migration/colo.c | 60 +++++++-------

migration/dirtyrate.c | 12 +--

migration/migration.c | 52 ++++++------

migration/ram.c | 12 +--

replay/replay-internal.c | 2 +-

semihosting/console.c | 8 +-

stubs/iothread-lock.c | 6 +-

system/cpu-throttle.c | 4 +-

system/cpus.c | 51 ++++++------

system/dirtylimit.c | 4 +-

system/memory.c | 2 +-

system/physmem.c | 8 +-

system/runstate.c | 2 +-

system/watchpoint.c | 4 +-

target/arm/arm-powerctl.c | 14 ++--

target/arm/helper.c | 4 +-

target/arm/hvf/hvf.c | 8 +-

target/arm/kvm.c | 8 +-

target/arm/ptw.c | 6 +-

target/arm/tcg/helper-a64.c | 8 +-

target/arm/tcg/m_helper.c | 6 +-

target/arm/tcg/op_helper.c | 24 +++---

target/arm/tcg/psci.c | 2 +-

target/hppa/int_helper.c | 8 +-

target/i386/hvf/hvf.c | 6 +-

target/i386/kvm/hyperv.c | 4 +-

target/i386/kvm/kvm.c | 28 +++----

target/i386/kvm/xen-emu.c | 14 ++--

target/i386/nvmm/nvmm-accel-ops.c | 4 +-

target/i386/nvmm/nvmm-all.c | 20 ++---

target/i386/tcg/sysemu/fpu_helper.c | 6 +-

target/i386/tcg/sysemu/misc_helper.c | 4 +-

target/i386/whpx/whpx-accel-ops.c | 4 +-

target/i386/whpx/whpx-all.c | 24 +++---

target/loongarch/tcg/csr_helper.c | 4 +-

target/mips/kvm.c | 4 +-

target/mips/tcg/sysemu/cp0_helper.c | 4 +-

target/openrisc/sys_helper.c | 16 ++--

target/ppc/excp_helper.c | 12 +--

target/ppc/kvm.c | 4 +-

target/ppc/misc_helper.c | 8 +-

target/ppc/timebase_helper.c | 8 +-

target/s390x/kvm/kvm.c | 4 +-

target/s390x/tcg/misc_helper.c | 118 +++++++++++++--------------

target/sparc/int32_helper.c | 2 +-

target/sparc/int64_helper.c | 6 +-

target/sparc/win_helper.c | 20 ++---

target/xtensa/exc_helper.c | 8 +-

ui/spice-core.c | 4 +-

util/async.c | 2 +-

util/main-loop.c | 8 +-

util/qsp.c | 6 +-

util/rcu.c | 14 ++--

audio/coreaudio.m | 4 +-

memory_ldst.c.inc | 18 ++--

target/i386/hvf/README.md | 2 +-

ui/cocoa.m | 50 ++++++------

95 files changed, 529 insertions(+), 529 deletions(-)

diff --git a/include/block/aio-wait.h b/include/block/aio-wait.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/aio-wait.h

+++ b/include/block/aio-wait.h

@@ -XXX,XX +XXX,XX @@ static inline bool in_aio_context_home_thread(AioContext *ctx)

}

if (ctx == qemu_get_aio_context()) {

- return qemu_mutex_iothread_locked();

+ return bql_locked();

} else {

return false;

}

diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h

index XXXXXXX..XXXXXXX 100644

--- a/include/qemu/main-loop.h

+++ b/include/qemu/main-loop.h

@@ -XXX,XX +XXX,XX @@ GSource *iohandler_get_g_source(void);

AioContext *iohandler_get_aio_context(void);

/**

- * qemu_mutex_iothread_locked: Return lock status of the main loop mutex.

+ * bql_locked: Return lock status of the Big QEMU Lock (BQL)

*

- * The main loop mutex is the coarsest lock in QEMU, and as such it

+ * The Big QEMU Lock (BQL) is the coarsest lock in QEMU, and as such it

* must always be taken outside other locks. This function helps

* functions take different paths depending on whether the current

- * thread is running within the main loop mutex.

+ * thread is running within the BQL.

*

* This function should never be used in the block layer, because

* unit tests, block layer tools and qemu-storage-daemon do not

* have a BQL.

* Please instead refer to qemu_in_main_thread().

*/

-bool qemu_mutex_iothread_locked(void);

+bool bql_locked(void);

/**

* qemu_in_main_thread: return whether it's possible to safely access

@@ -XXX,XX +XXX,XX @@ bool qemu_in_main_thread(void);

} while (0)

/**

- * qemu_mutex_lock_iothread: Lock the main loop mutex.

+ * bql_lock: Lock the Big QEMU Lock (BQL).

*

- * This function locks the main loop mutex. The mutex is taken by

+ * This function locks the Big QEMU Lock (BQL). The lock is taken by

* main() in vl.c and always taken except while waiting on

- * external events (such as with select). The mutex should be taken

+ * external events (such as with select). The lock should be taken

* by threads other than the main loop thread when calling

* qemu_bh_new(), qemu_set_fd_handler() and basically all other

* functions documented in this file.

*

- * NOTE: tools currently are single-threaded and qemu_mutex_lock_iothread

+ * NOTE: tools currently are single-threaded and bql_lock

* is a no-op there.

*/

-#define qemu_mutex_lock_iothread() \

- qemu_mutex_lock_iothread_impl(__FILE__, __LINE__)

-void qemu_mutex_lock_iothread_impl(const char *file, int line);

+#define bql_lock() bql_lock_impl(__FILE__, __LINE__)

+void bql_lock_impl(const char *file, int line);

/**

- * qemu_mutex_unlock_iothread: Unlock the main loop mutex.

+ * bql_unlock: Unlock the Big QEMU Lock (BQL).

*

- * This function unlocks the main loop mutex. The mutex is taken by

+ * This function unlocks the Big QEMU Lock. The lock is taken by

* main() in vl.c and always taken except while waiting on

- * external events (such as with select). The mutex should be unlocked

+ * external events (such as with select). The lock should be unlocked

* as soon as possible by threads other than the main loop thread,

* because it prevents the main loop from processing callbacks,

* including timers and bottom halves.

*

- * NOTE: tools currently are single-threaded and qemu_mutex_unlock_iothread

+ * NOTE: tools currently are single-threaded and bql_unlock

* is a no-op there.

*/

-void qemu_mutex_unlock_iothread(void);

+void bql_unlock(void);

/**

* QEMU_IOTHREAD_LOCK_GUARD

*

- * Wrap a block of code in a conditional qemu_mutex_{lock,unlock}_iothread.

+ * Wrap a block of code in a conditional bql_{lock,unlock}.

*/

typedef struct IOThreadLockAuto IOThreadLockAuto;

static inline IOThreadLockAuto *qemu_iothread_auto_lock(const char *file,

int line)

{

- if (qemu_mutex_iothread_locked()) {

+ if (bql_locked()) {

return NULL;

}

- qemu_mutex_lock_iothread_impl(file, line);

+ bql_lock_impl(file, line);

/* Anything non-NULL causes the cleanup function to be called */

return (IOThreadLockAuto *)(uintptr_t)1;

}

static inline void qemu_iothread_auto_unlock(IOThreadLockAuto *l)

{

- qemu_mutex_unlock_iothread();

+ bql_unlock();

}

G_DEFINE_AUTOPTR_CLEANUP_FUNC(IOThreadLockAuto, qemu_iothread_auto_unlock)

diff --git a/include/qemu/thread.h b/include/qemu/thread.h

index XXXXXXX..XXXXXXX 100644

--- a/include/qemu/thread.h

+++ b/include/qemu/thread.h

@@ -XXX,XX +XXX,XX @@ typedef void (*QemuCondWaitFunc)(QemuCond *c, QemuMutex *m, const char *f,

typedef bool (*QemuCondTimedWaitFunc)(QemuCond *c, QemuMutex *m, int ms,

const char *f, int l);

-extern QemuMutexLockFunc qemu_bql_mutex_lock_func;

+extern QemuMutexLockFunc bql_mutex_lock_func;

extern QemuMutexLockFunc qemu_mutex_lock_func;

extern QemuMutexTrylockFunc qemu_mutex_trylock_func;

extern QemuRecMutexLockFunc qemu_rec_mutex_lock_func;

diff --git a/accel/accel-blocker.c b/accel/accel-blocker.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/accel-blocker.c

+++ b/accel/accel-blocker.c

@@ -XXX,XX +XXX,XX @@ void accel_blocker_init(void)

void accel_ioctl_begin(void)

{

- if (likely(qemu_mutex_iothread_locked())) {

+ if (likely(bql_locked())) {

return;

}

@@ -XXX,XX +XXX,XX @@ void accel_ioctl_begin(void)

void accel_ioctl_end(void)

{

- if (likely(qemu_mutex_iothread_locked())) {

+ if (likely(bql_locked())) {

return;

}

@@ -XXX,XX +XXX,XX @@ void accel_ioctl_end(void)

void accel_cpu_ioctl_begin(CPUState *cpu)

{

- if (unlikely(qemu_mutex_iothread_locked())) {

+ if (unlikely(bql_locked())) {

return;

}

@@ -XXX,XX +XXX,XX @@ void accel_cpu_ioctl_begin(CPUState *cpu)

void accel_cpu_ioctl_end(CPUState *cpu)

{

- if (unlikely(qemu_mutex_iothread_locked())) {

+ if (unlikely(bql_locked())) {

return;

}

@@ -XXX,XX +XXX,XX @@ void accel_ioctl_inhibit_begin(void)

* We allow to inhibit only when holding the BQL, so we can identify

* when an inhibitor wants to issue an ioctl easily.

*/

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

/* Block further invocations of the ioctls outside the BQL. */

CPU_FOREACH(cpu) {

diff --git a/accel/dummy-cpus.c b/accel/dummy-cpus.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/dummy-cpus.c

+++ b/accel/dummy-cpus.c

@@ -XXX,XX +XXX,XX @@ static void *dummy_cpu_thread_fn(void *arg)

rcu_register_thread();

- qemu_mutex_lock_iothread();

+ bql_lock();

qemu_thread_get_self(cpu->thread);

cpu->thread_id = qemu_get_thread_id();

cpu->neg.can_do_io = true;

@@ -XXX,XX +XXX,XX @@ static void *dummy_cpu_thread_fn(void *arg)

qemu_guest_random_seed_thread_part2(cpu->random_seed);

do {

- qemu_mutex_unlock_iothread();

+ bql_unlock();

#ifndef _WIN32

do {

int sig;

@@ -XXX,XX +XXX,XX @@ static void *dummy_cpu_thread_fn(void *arg)

#else

qemu_sem_wait(&cpu->sem);

#endif

- qemu_mutex_lock_iothread();

+ bql_lock();

qemu_wait_io_event(cpu);

} while (!cpu->unplug);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

rcu_unregister_thread();

return NULL;

}

diff --git a/accel/hvf/hvf-accel-ops.c b/accel/hvf/hvf-accel-ops.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/hvf/hvf-accel-ops.c

+++ b/accel/hvf/hvf-accel-ops.c

@@ -XXX,XX +XXX,XX @@ static void *hvf_cpu_thread_fn(void *arg)

rcu_register_thread();

- qemu_mutex_lock_iothread();

+ bql_lock();

qemu_thread_get_self(cpu->thread);

cpu->thread_id = qemu_get_thread_id();

@@ -XXX,XX +XXX,XX @@ static void *hvf_cpu_thread_fn(void *arg)

hvf_vcpu_destroy(cpu);

cpu_thread_signal_destroyed(cpu);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

rcu_unregister_thread();

return NULL;

}

diff --git a/accel/kvm/kvm-accel-ops.c b/accel/kvm/kvm-accel-ops.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/kvm/kvm-accel-ops.c

+++ b/accel/kvm/kvm-accel-ops.c

@@ -XXX,XX +XXX,XX @@ static void *kvm_vcpu_thread_fn(void *arg)

rcu_register_thread();

- qemu_mutex_lock_iothread();

+ bql_lock();

qemu_thread_get_self(cpu->thread);

cpu->thread_id = qemu_get_thread_id();

cpu->neg.can_do_io = true;

@@ -XXX,XX +XXX,XX @@ static void *kvm_vcpu_thread_fn(void *arg)

kvm_destroy_vcpu(cpu);

cpu_thread_signal_destroyed(cpu);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

rcu_unregister_thread();

return NULL;

}

diff --git a/accel/kvm/kvm-all.c b/accel/kvm/kvm-all.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/kvm/kvm-all.c

+++ b/accel/kvm/kvm-all.c

@@ -XXX,XX +XXX,XX @@ static void kvm_dirty_ring_flush(void)

* should always be with BQL held, serialization is guaranteed.

* However, let's be sure of it.

*/

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

/*

* First make sure to flush the hardware buffers by kicking all

* vcpus out in a synchronous way.

@@ -XXX,XX +XXX,XX @@ static void *kvm_dirty_ring_reaper_thread(void *data)

trace_kvm_dirty_ring_reaper("wakeup");

r->reaper_state = KVM_DIRTY_RING_REAPER_REAPING;

- qemu_mutex_lock_iothread();

+ bql_lock();

kvm_dirty_ring_reap(s, NULL);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

r->reaper_iteration++;

}

@@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu)

return EXCP_HLT;

}

- qemu_mutex_unlock_iothread();

+ bql_unlock();

cpu_exec_start(cpu);

do {

@@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu)

#ifdef KVM_HAVE_MCE_INJECTION

if (unlikely(have_sigbus_pending)) {

- qemu_mutex_lock_iothread();

+ bql_lock();

kvm_arch_on_sigbus_vcpu(cpu, pending_sigbus_code,

pending_sigbus_addr);

have_sigbus_pending = false;

- qemu_mutex_unlock_iothread();

+ bql_unlock();

}

#endif

@@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu)

* still full. Got kicked by KVM_RESET_DIRTY_RINGS.

*/

trace_kvm_dirty_ring_full(cpu->cpu_index);

- qemu_mutex_lock_iothread();

+ bql_lock();

/*

* We throttle vCPU by making it sleep once it exit from kernel

* due to dirty ring full. In the dirtylimit scenario, reaping

@@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu)

} else {

kvm_dirty_ring_reap(kvm_state, NULL);

}

- qemu_mutex_unlock_iothread();

+ bql_unlock();

dirtylimit_vcpu_execute(cpu);

ret = 0;

break;

@@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu)

break;

case KVM_SYSTEM_EVENT_CRASH:

kvm_cpu_synchronize_state(cpu);

- qemu_mutex_lock_iothread();

+ bql_lock();

qemu_system_guest_panicked(cpu_get_crash_info(cpu));

- qemu_mutex_unlock_iothread();

+ bql_unlock();

ret = 0;

break;

default:

@@ -XXX,XX +XXX,XX @@ int kvm_cpu_exec(CPUState *cpu)

} while (ret == 0);

cpu_exec_end(cpu);

- qemu_mutex_lock_iothread();

+ bql_lock();

if (ret < 0) {

cpu_dump_state(cpu, stderr, CPU_DUMP_CODE);

diff --git a/accel/tcg/cpu-exec.c b/accel/tcg/cpu-exec.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/tcg/cpu-exec.c

+++ b/accel/tcg/cpu-exec.c

@@ -XXX,XX +XXX,XX @@ static void cpu_exec_longjmp_cleanup(CPUState *cpu)

tcg_ctx->gen_tb = NULL;

}

#endif

- if (qemu_mutex_iothread_locked()) {

- qemu_mutex_unlock_iothread();

+ if (bql_locked()) {

+ bql_unlock();

}

assert_no_pages_locked();

}

@@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_halt(CPUState *cpu)

#if defined(TARGET_I386)

if (cpu->interrupt_request & CPU_INTERRUPT_POLL) {

X86CPU *x86_cpu = X86_CPU(cpu);

- qemu_mutex_lock_iothread();

+ bql_lock();

apic_poll_irq(x86_cpu->apic_state);

cpu_reset_interrupt(cpu, CPU_INTERRUPT_POLL);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

}

#endif /* TARGET_I386 */

if (!cpu_has_work(cpu)) {

@@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_exception(CPUState *cpu, int *ret)

#else

if (replay_exception()) {

CPUClass *cc = CPU_GET_CLASS(cpu);

- qemu_mutex_lock_iothread();

+ bql_lock();

cc->tcg_ops->do_interrupt(cpu);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

cpu->exception_index = -1;

if (unlikely(cpu->singlestep_enabled)) {

@@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu,

if (unlikely(qatomic_read(&cpu->interrupt_request))) {

int interrupt_request;

- qemu_mutex_lock_iothread();

+ bql_lock();

interrupt_request = cpu->interrupt_request;

if (unlikely(cpu->singlestep_enabled & SSTEP_NOIRQ)) {

/* Mask out external interrupts for this step. */

@@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu,

if (interrupt_request & CPU_INTERRUPT_DEBUG) {

cpu->interrupt_request &= ~CPU_INTERRUPT_DEBUG;

cpu->exception_index = EXCP_DEBUG;

- qemu_mutex_unlock_iothread();

+ bql_unlock();

return true;

}

#if !defined(CONFIG_USER_ONLY)

@@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu,

cpu->interrupt_request &= ~CPU_INTERRUPT_HALT;

cpu->halted = 1;

cpu->exception_index = EXCP_HLT;

- qemu_mutex_unlock_iothread();

+ bql_unlock();

return true;

}

#if defined(TARGET_I386)

@@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu,

cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0, 0);

do_cpu_init(x86_cpu);

cpu->exception_index = EXCP_HALTED;

- qemu_mutex_unlock_iothread();

+ bql_unlock();

return true;

}

#else

else if (interrupt_request & CPU_INTERRUPT_RESET) {

replay_interrupt();

cpu_reset(cpu);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

return true;

}

#endif /* !TARGET_I386 */

@@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu,

*/

if (unlikely(cpu->singlestep_enabled)) {

cpu->exception_index = EXCP_DEBUG;

- qemu_mutex_unlock_iothread();

+ bql_unlock();

return true;

}

cpu->exception_index = -1;

@@ -XXX,XX +XXX,XX @@ static inline bool cpu_handle_interrupt(CPUState *cpu,

}

/* If we exit via cpu_loop_exit/longjmp it is reset in cpu_exec */

- qemu_mutex_unlock_iothread();

+ bql_unlock();

}

/* Finally, check if we need to exit to the main loop. */

diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/tcg/cputlb.c

+++ b/accel/tcg/cputlb.c

@@ -XXX,XX +XXX,XX @@ static uint64_t do_ld_mmio_beN(CPUState *cpu, CPUTLBEntryFull *full,

section = io_prepare(&mr_offset, cpu, full->xlat_section, attrs, addr, ra);

mr = section->mr;

- qemu_mutex_lock_iothread();

+ bql_lock();

ret = int_ld_mmio_beN(cpu, full, ret_be, addr, size, mmu_idx,

type, ra, mr, mr_offset);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

return ret;

}

@@ -XXX,XX +XXX,XX @@ static Int128 do_ld16_mmio_beN(CPUState *cpu, CPUTLBEntryFull *full,

section = io_prepare(&mr_offset, cpu, full->xlat_section, attrs, addr, ra);

mr = section->mr;

- qemu_mutex_lock_iothread();

+ bql_lock();

a = int_ld_mmio_beN(cpu, full, ret_be, addr, size - 8, mmu_idx,

MMU_DATA_LOAD, ra, mr, mr_offset);

b = int_ld_mmio_beN(cpu, full, ret_be, addr + size - 8, 8, mmu_idx,

MMU_DATA_LOAD, ra, mr, mr_offset + size - 8);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

return int128_make128(b, a);

}

@@ -XXX,XX +XXX,XX @@ static uint64_t do_st_mmio_leN(CPUState *cpu, CPUTLBEntryFull *full,

section = io_prepare(&mr_offset, cpu, full->xlat_section, attrs, addr, ra);

mr = section->mr;

- qemu_mutex_lock_iothread();

+ bql_lock();

ret = int_st_mmio_leN(cpu, full, val_le, addr, size, mmu_idx,

ra, mr, mr_offset);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

return ret;

}

@@ -XXX,XX +XXX,XX @@ static uint64_t do_st16_mmio_leN(CPUState *cpu, CPUTLBEntryFull *full,

section = io_prepare(&mr_offset, cpu, full->xlat_section, attrs, addr, ra);

mr = section->mr;

- qemu_mutex_lock_iothread();

+ bql_lock();

int_st_mmio_leN(cpu, full, int128_getlo(val_le), addr, 8,

mmu_idx, ra, mr, mr_offset);

ret = int_st_mmio_leN(cpu, full, int128_gethi(val_le), addr + 8,

size - 8, mmu_idx, ra, mr, mr_offset + 8);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

return ret;

}

diff --git a/accel/tcg/tcg-accel-ops-icount.c b/accel/tcg/tcg-accel-ops-icount.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/tcg/tcg-accel-ops-icount.c

+++ b/accel/tcg/tcg-accel-ops-icount.c

@@ -XXX,XX +XXX,XX @@ void icount_prepare_for_run(CPUState *cpu, int64_t cpu_budget)

* We're called without the iothread lock, so must take it while

* we're calling timer handlers.

*/

- qemu_mutex_lock_iothread();

+ bql_lock();

icount_notify_aio_contexts();

- qemu_mutex_unlock_iothread();

+ bql_unlock();

}

}

diff --git a/accel/tcg/tcg-accel-ops-mttcg.c b/accel/tcg/tcg-accel-ops-mttcg.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/tcg/tcg-accel-ops-mttcg.c

+++ b/accel/tcg/tcg-accel-ops-mttcg.c

@@ -XXX,XX +XXX,XX @@ static void *mttcg_cpu_thread_fn(void *arg)

rcu_add_force_rcu_notifier(&force_rcu.notifier);

tcg_register_thread();

- qemu_mutex_lock_iothread();

+ bql_lock();

qemu_thread_get_self(cpu->thread);

cpu->thread_id = qemu_get_thread_id();

@@ -XXX,XX +XXX,XX @@ static void *mttcg_cpu_thread_fn(void *arg)

do {

if (cpu_can_run(cpu)) {

int r;

- qemu_mutex_unlock_iothread();

+ bql_unlock();

r = tcg_cpus_exec(cpu);

- qemu_mutex_lock_iothread();

+ bql_lock();

switch (r) {

case EXCP_DEBUG:

cpu_handle_guest_debug(cpu);

@@ -XXX,XX +XXX,XX @@ static void *mttcg_cpu_thread_fn(void *arg)

*/

break;

case EXCP_ATOMIC:

- qemu_mutex_unlock_iothread();

+ bql_unlock();

cpu_exec_step_atomic(cpu);

- qemu_mutex_lock_iothread();

+ bql_lock();

default:

/* Ignore everything else? */

break;

@@ -XXX,XX +XXX,XX @@ static void *mttcg_cpu_thread_fn(void *arg)

} while (!cpu->unplug || cpu_can_run(cpu));

tcg_cpus_destroy(cpu);

- qemu_mutex_unlock_iothread();

+ bql_unlock();

rcu_remove_force_rcu_notifier(&force_rcu.notifier);

rcu_unregister_thread();

return NULL;

diff --git a/accel/tcg/tcg-accel-ops-rr.c b/accel/tcg/tcg-accel-ops-rr.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/tcg/tcg-accel-ops-rr.c

+++ b/accel/tcg/tcg-accel-ops-rr.c

@@ -XXX,XX +XXX,XX @@ static void *rr_cpu_thread_fn(void *arg)

rcu_add_force_rcu_notifier(&force_rcu);

tcg_register_thread();

- qemu_mutex_lock_iothread();

+ bql_lock();

qemu_thread_get_self(cpu->thread);

cpu->thread_id = qemu_get_thread_id();

@@ -XXX,XX +XXX,XX @@ static void *rr_cpu_thread_fn(void *arg)

/* Only used for icount_enabled() */

int64_t cpu_budget = 0;

- qemu_mutex_unlock_iothread();

+ bql_unlock();

replay_mutex_lock();

- qemu_mutex_lock_iothread();

+ bql_lock();

if (icount_enabled()) {

int cpu_count = rr_cpu_count();

@@ -XXX,XX +XXX,XX @@ static void *rr_cpu_thread_fn(void *arg)

if (cpu_can_run(cpu)) {

int r;

- qemu_mutex_unlock_iothread();

+ bql_unlock();

if (icount_enabled()) {

icount_prepare_for_run(cpu, cpu_budget);

}

@@ -XXX,XX +XXX,XX @@ static void *rr_cpu_thread_fn(void *arg)

if (icount_enabled()) {

icount_process_data(cpu);

}

- qemu_mutex_lock_iothread();

+ bql_lock();

if (r == EXCP_DEBUG) {

cpu_handle_guest_debug(cpu);

break;

} else if (r == EXCP_ATOMIC) {

- qemu_mutex_unlock_iothread();

+ bql_unlock();

cpu_exec_step_atomic(cpu);

- qemu_mutex_lock_iothread();

+ bql_lock();

break;

}

} else if (cpu->stop) {

diff --git a/accel/tcg/tcg-accel-ops.c b/accel/tcg/tcg-accel-ops.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/tcg/tcg-accel-ops.c

+++ b/accel/tcg/tcg-accel-ops.c

@@ -XXX,XX +XXX,XX @@ static void tcg_cpu_reset_hold(CPUState *cpu)

/* mask must never be zero, except for A20 change call */

void tcg_handle_interrupt(CPUState *cpu, int mask)

{

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

cpu->interrupt_request |= mask;

diff --git a/accel/tcg/translate-all.c b/accel/tcg/translate-all.c

index XXXXXXX..XXXXXXX 100644

--- a/accel/tcg/translate-all.c

+++ b/accel/tcg/translate-all.c

@@ -XXX,XX +XXX,XX @@ void cpu_io_recompile(CPUState *cpu, uintptr_t retaddr)

void cpu_interrupt(CPUState *cpu, int mask)

{

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

cpu->interrupt_request |= mask;

qatomic_set(&cpu->neg.icount_decr.u16.high, -1);

}

diff --git a/cpu-common.c b/cpu-common.c

index XXXXXXX..XXXXXXX 100644

--- a/cpu-common.c

+++ b/cpu-common.c

@@ -XXX,XX +XXX,XX @@ void process_queued_cpu_work(CPUState *cpu)

* BQL, so it goes to sleep; start_exclusive() is sleeping too, so

* neither CPU can proceed.

*/

- qemu_mutex_unlock_iothread();

+ bql_unlock();

start_exclusive();

wi->func(cpu, wi->data);

end_exclusive();

- qemu_mutex_lock_iothread();

+ bql_lock();

} else {

wi->func(cpu, wi->data);

}

diff --git a/dump/dump.c b/dump/dump.c

index XXXXXXX..XXXXXXX 100644

--- a/dump/dump.c

+++ b/dump/dump.c

@@ -XXX,XX +XXX,XX @@ static int dump_cleanup(DumpState *s)

s->guest_note = NULL;

if (s->resume) {

if (s->detached) {

- qemu_mutex_lock_iothread();

+ bql_lock();

}

vm_start();

if (s->detached) {

- qemu_mutex_unlock_iothread();

+ bql_unlock();

}

}

migrate_del_blocker(&dump_migration_blocker);

diff --git a/hw/core/cpu-common.c b/hw/core/cpu-common.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/core/cpu-common.c

+++ b/hw/core/cpu-common.c

@@ -XXX,XX +XXX,XX @@ CPUState *cpu_create(const char *typename)

* BQL here if we need to. cpu_interrupt assumes it is held.*/

void cpu_reset_interrupt(CPUState *cpu, int mask)

{

- bool need_lock = !qemu_mutex_iothread_locked();

+ bool need_lock = !bql_locked();

if (need_lock) {

- qemu_mutex_lock_iothread();

+ bql_lock();

}

cpu->interrupt_request &= ~mask;

if (need_lock) {

- qemu_mutex_unlock_iothread();

+ bql_unlock();

}

}

diff --git a/hw/i386/intel_iommu.c b/hw/i386/intel_iommu.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/i386/intel_iommu.c

+++ b/hw/i386/intel_iommu.c

@@ -XXX,XX +XXX,XX @@ static bool vtd_switch_address_space(VTDAddressSpace *as)

{

bool use_iommu, pt;

/* Whether we need to take the BQL on our own */

- bool take_bql = !qemu_mutex_iothread_locked();

+ bool take_bql = !bql_locked();

assert(as);

@@ -XXX,XX +XXX,XX @@ static bool vtd_switch_address_space(VTDAddressSpace *as)

* it. We'd better make sure we have had it already, or, take it.

*/

if (take_bql) {

- qemu_mutex_lock_iothread();

+ bql_lock();

}

/* Turn off first then on the other */

@@ -XXX,XX +XXX,XX @@ static bool vtd_switch_address_space(VTDAddressSpace *as)

}

if (take_bql) {

- qemu_mutex_unlock_iothread();

+ bql_unlock();

}

return use_iommu;

diff --git a/hw/i386/kvm/xen_evtchn.c b/hw/i386/kvm/xen_evtchn.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/i386/kvm/xen_evtchn.c

+++ b/hw/i386/kvm/xen_evtchn.c

@@ -XXX,XX +XXX,XX @@ void xen_evtchn_set_callback_level(int level)

* effect immediately. That just leaves interdomain loopback as the case

* which uses the BH.

*/

- if (!qemu_mutex_iothread_locked()) {

+ if (!bql_locked()) {

qemu_bh_schedule(s->gsi_bh);

return;

}

@@ -XXX,XX +XXX,XX @@ int xen_evtchn_set_callback_param(uint64_t param)

* We need the BQL because set_callback_pci_intx() may call into PCI code,

* and because we may need to manipulate the old and new GSI levels.

*/

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

qemu_mutex_lock(&s->port_lock);

switch (type) {

@@ -XXX,XX +XXX,XX @@ static int close_port(XenEvtchnState *s, evtchn_port_t port,

XenEvtchnPort *p = &s->port_table[port];

/* Because it *might* be a PIRQ port */

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

switch (p->type) {

case EVTCHNSTAT_closed:

@@ -XXX,XX +XXX,XX @@ int xen_evtchn_soft_reset(void)

return -ENOTSUP;

}

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

qemu_mutex_lock(&s->port_lock);

@@ -XXX,XX +XXX,XX @@ bool xen_evtchn_set_gsi(int gsi, int level)

XenEvtchnState *s = xen_evtchn_singleton;

int pirq;

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

if (!s || gsi < 0 || gsi >= IOAPIC_NUM_PINS) {

return false;

@@ -XXX,XX +XXX,XX @@ void xen_evtchn_snoop_msi(PCIDevice *dev, bool is_msix, unsigned int vector,

return;

}

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

pirq = msi_pirq_target(addr, data);

@@ -XXX,XX +XXX,XX @@ int xen_evtchn_translate_pirq_msi(struct kvm_irq_routing_entry *route,

return 1; /* Not a PIRQ */

}

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

pirq = msi_pirq_target(address, data);

if (!pirq || pirq >= s->nr_pirqs) {

@@ -XXX,XX +XXX,XX @@ bool xen_evtchn_deliver_pirq_msi(uint64_t address, uint32_t data)

return false;

}

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

pirq = msi_pirq_target(address, data);

if (!pirq || pirq >= s->nr_pirqs) {

diff --git a/hw/i386/kvm/xen_overlay.c b/hw/i386/kvm/xen_overlay.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/i386/kvm/xen_overlay.c

+++ b/hw/i386/kvm/xen_overlay.c

@@ -XXX,XX +XXX,XX @@ int xen_overlay_map_shinfo_page(uint64_t gpa)

return -ENOENT;

}

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

if (s->shinfo_gpa) {

/* If removing shinfo page, turn the kernel magic off first */

diff --git a/hw/i386/kvm/xen_xenstore.c b/hw/i386/kvm/xen_xenstore.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/i386/kvm/xen_xenstore.c

+++ b/hw/i386/kvm/xen_xenstore.c

@@ -XXX,XX +XXX,XX @@ static void fire_watch_cb(void *opaque, const char *path, const char *token)

{

XenXenstoreState *s = opaque;

- assert(qemu_mutex_iothread_locked());

+ assert(bql_locked());

/*

* If there's a response pending, we obviously can't scribble over

diff --git a/hw/intc/arm_gicv3_cpuif.c b/hw/intc/arm_gicv3_cpuif.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/intc/arm_gicv3_cpuif.c

+++ b/hw/intc/arm_gicv3_cpuif.c

@@ -XXX,XX +XXX,XX @@ void gicv3_cpuif_update(GICv3CPUState *cs)

ARMCPU *cpu = ARM_CPU(cs->cpu);

CPUARMState *env = &cpu->env;

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

trace_gicv3_cpuif_update(gicv3_redist_affid(cs), cs->hppi.irq,

cs->hppi.grp, cs->hppi.prio);

diff --git a/hw/intc/s390_flic.c b/hw/intc/s390_flic.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/intc/s390_flic.c

+++ b/hw/intc/s390_flic.c

@@ -XXX,XX +XXX,XX @@ static int qemu_s390_clear_io_flic(S390FLICState *fs, uint16_t subchannel_id,

QEMUS390FlicIO *cur, *next;

uint8_t isc;

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

if (!(flic->pending & FLIC_PENDING_IO)) {

return 0;

}

@@ -XXX,XX +XXX,XX @@ uint32_t qemu_s390_flic_dequeue_service(QEMUS390FLICState *flic)

{

uint32_t tmp;

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

g_assert(flic->pending & FLIC_PENDING_SERVICE);

tmp = flic->service_param;

flic->service_param = 0;

@@ -XXX,XX +XXX,XX @@ QEMUS390FlicIO *qemu_s390_flic_dequeue_io(QEMUS390FLICState *flic, uint64_t cr6)

QEMUS390FlicIO *io;

uint8_t isc;

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

if (!(flic->pending & CR6_TO_PENDING_IO(cr6))) {

return NULL;

}

@@ -XXX,XX +XXX,XX @@ QEMUS390FlicIO *qemu_s390_flic_dequeue_io(QEMUS390FLICState *flic, uint64_t cr6)

void qemu_s390_flic_dequeue_crw_mchk(QEMUS390FLICState *flic)

{

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

g_assert(flic->pending & FLIC_PENDING_MCHK_CR);

flic->pending &= ~FLIC_PENDING_MCHK_CR;

}

@@ -XXX,XX +XXX,XX @@ static void qemu_s390_inject_service(S390FLICState *fs, uint32_t parm)

{

QEMUS390FLICState *flic = s390_get_qemu_flic(fs);

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

/* multiplexing is good enough for sclp - kvm does it internally as well */

flic->service_param |= parm;

flic->pending |= FLIC_PENDING_SERVICE;

@@ -XXX,XX +XXX,XX @@ static void qemu_s390_inject_io(S390FLICState *fs, uint16_t subchannel_id,

QEMUS390FLICState *flic = s390_get_qemu_flic(fs);

QEMUS390FlicIO *io;

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

io = g_new0(QEMUS390FlicIO, 1);

io->id = subchannel_id;

io->nr = subchannel_nr;

@@ -XXX,XX +XXX,XX @@ static void qemu_s390_inject_crw_mchk(S390FLICState *fs)

{

QEMUS390FLICState *flic = s390_get_qemu_flic(fs);

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

flic->pending |= FLIC_PENDING_MCHK_CR;

qemu_s390_flic_notify(FLIC_PENDING_MCHK_CR);

@@ -XXX,XX +XXX,XX @@ bool qemu_s390_flic_has_crw_mchk(QEMUS390FLICState *flic)

bool qemu_s390_flic_has_any(QEMUS390FLICState *flic)

{

- g_assert(qemu_mutex_iothread_locked());

+ g_assert(bql_locked());

return !!flic->pending;

}