From: Harsh Prateek Bora <harshpb@linux.ibm.com>
To: Stefan Hajnoczi <stefanha@redhat.com>, qemu-devel@nongnu.org
Cc: "Jean-Christophe Dubois" <jcd@tribudubois.net>,
"Fabiano Rosas" <farosas@suse.de>,
qemu-s390x@nongnu.org, "Song Gao" <gaosong@loongson.cn>,
"Marcel Apfelbaum" <marcel.apfelbaum@gmail.com>,
"Thomas Huth" <thuth@redhat.com>,
"Hyman Huang" <yong.huang@smartx.com>,
"Marcelo Tosatti" <mtosatti@redhat.com>,
"David Woodhouse" <dwmw2@infradead.org>,
"Andrey Smirnov" <andrew.smirnov@gmail.com>,
"Peter Maydell" <peter.maydell@linaro.org>,
"Kevin Wolf" <kwolf@redhat.com>,
"Ilya Leoshkevich" <iii@linux.ibm.com>,
"Artyom Tarasenko" <atar4qemu@gmail.com>,
"Mark Cave-Ayland" <mark.cave-ayland@ilande.co.uk>,
"Max Filippov" <jcmvbkbc@gmail.com>,
"Alistair Francis" <alistair.francis@wdc.com>,
"Paul Durrant" <paul@xen.org>,
"Jagannathan Raman" <jag.raman@oracle.com>,
"Juan Quintela" <quintela@redhat.com>,
"Daniel P. Berrangé" <berrange@redhat.com>,
qemu-arm@nongnu.org, "Jason Wang" <jasowang@redhat.com>,
"Gerd Hoffmann" <kraxel@redhat.com>,
"Hanna Reitz" <hreitz@redhat.com>,
"Marc-André Lureau" <marcandre.lureau@redhat.com>,
"BALATON Zoltan" <balaton@eik.bme.hu>,
"Daniel Henrique Barboza" <danielhb413@gmail.com>,
"Elena Ufimtseva" <elena.ufimtseva@oracle.com>,
"Aurelien Jarno" <aurelien@aurel32.net>,
"Hailiang Zhang" <zhanghailiang@xfusion.com>,
"Roman Bolshakov" <rbolshakov@ddn.com>,
"Huacai Chen" <chenhuacai@kernel.org>,
"Fam Zheng" <fam@euphon.net>, "Eric Blake" <eblake@redhat.com>,
"Jiri Slaby" <jslaby@suse.cz>, "Alexander Graf" <agraf@csgraf.de>,
"Liu Zhiwei" <zhiwei_liu@linux.alibaba.com>,
"Weiwei Li" <liwei1518@gmail.com>,
"Eric Farman" <farman@linux.ibm.com>,
"Stafford Horne" <shorne@gmail.com>,
"David Hildenbrand" <david@redhat.com>,
"Markus Armbruster" <armbru@redhat.com>,
"Reinoud Zandijk" <reinoud@netbsd.org>,
"Palmer Dabbelt" <palmer@dabbelt.com>,
"Cameron Esfahani" <dirty@apple.com>,
xen-devel@lists.xenproject.org,
"Pavel Dovgalyuk" <pavel.dovgaluk@ispras.ru>,
qemu-riscv@nongnu.org,
"Aleksandar Rikalo" <aleksandar.rikalo@syrmia.com>,
"John Snow" <jsnow@redhat.com>,
"Sunil Muthuswamy" <sunilmut@microsoft.com>,
"Michael Roth" <michael.roth@amd.com>,
"David Gibson" <david@gibson.dropbear.id.au>,
"Michael S. Tsirkin" <mst@redhat.com>,
"Richard Henderson" <richard.henderson@linaro.org>,
"Bin Meng" <bin.meng@windriver.com>,
"Stefano Stabellini" <sstabellini@kernel.org>,
kvm@vger.kernel.org, qemu-block@nongnu.org,
"Halil Pasic" <pasic@linux.ibm.com>,
"Peter Xu" <peterx@redhat.com>,
"Anthony Perard" <anthony.perard@citrix.com>,
"Alex Bennée" <alex.bennee@linaro.org>,
"Eduardo Habkost" <eduardo@habkost.net>,
"Paolo Bonzini" <pbonzini@redhat.com>,
"Vladimir Sementsov-Ogievskiy" <vsementsov@yandex-team.ru>,
"Cédric Le Goater" <clg@kaod.org>,
qemu-ppc@nongnu.org, "Philippe Mathieu-Daudé" <philmd@linaro.org>,
"Christian Borntraeger" <borntraeger@linux.ibm.com>,
"Akihiko Odaki" <akihiko.odaki@daynix.com>,
"Leonardo Bras" <leobras@redhat.com>,
"Nicholas Piggin" <npiggin@gmail.com>,
"Jiaxun Yang" <jiaxun.yang@flygoat.com>
Subject: Re: [PATCH 1/6] system/cpus: rename qemu_mutex_lock_iothread() to qemu_bql_lock()
Date: Fri, 1 Dec 2023 10:42:43 +0530 [thread overview]
Message-ID: <8f89fbbf-454b-c5e5-5e8f-46ea42ec20ed@linux.ibm.com> (raw)
In-Reply-To: <20231129212625.1051502-2-stefanha@redhat.com>
Hi Stefan,
On 11/30/23 02:56, Stefan Hajnoczi wrote:
> 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 qemu_bql_lock(void)
> - void qemu_bql_unlock(void)
> - bool qemu_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.
>
> Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
> ---
> include/block/aio-wait.h | 2 +-
> include/qemu/main-loop.h | 26 +++---
> 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 | 12 +--
> 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 | 28 +++----
> 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 | 4 +-
> target/arm/kvm64.c | 4 +-
> target/arm/ptw.c | 6 +-
> target/arm/tcg/helper-a64.c | 8 +-
> target/arm/tcg/m_helper.c | 4 +-
> 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/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/rcu.c | 14 ++--
> audio/coreaudio.m | 4 +-
> memory_ldst.c.inc | 18 ++--
> target/i386/hvf/README.md | 2 +-
> ui/cocoa.m | 50 ++++++------
> 94 files changed, 502 insertions(+), 502 deletions(-)
>
<snip>
>
> diff --git a/hw/remote/mpqemu-link.c b/hw/remote/mpqemu-link.c
> index 9bd98e8219..ffb2c25145 100644
> --- a/hw/remote/mpqemu-link.c
> +++ b/hw/remote/mpqemu-link.c
> @@ -33,7 +33,7 @@
> */
> bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp)
> {
> - bool iolock = qemu_mutex_iothread_locked();
> + bool iolock = qemu_bql_locked();
Should var name (one more below) be updated to reflect this update ?
Otherwise,
Reviewed-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> bool iothread = qemu_in_iothread();
> struct iovec send[2] = {};
> int *fds = NULL;
> @@ -64,7 +64,7 @@ bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp)
> * Also skip lock handling while in a co-routine in the main context.
> */
> if (iolock && !iothread && !qemu_in_coroutine()) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> if (!qio_channel_writev_full_all(ioc, send, G_N_ELEMENTS(send),
> @@ -76,7 +76,7 @@ bool mpqemu_msg_send(MPQemuMsg *msg, QIOChannel *ioc, Error **errp)
>
> if (iolock && !iothread && !qemu_in_coroutine()) {
> /* See above comment why skip locking here. */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> return ret;
> @@ -96,7 +96,7 @@ static ssize_t mpqemu_read(QIOChannel *ioc, void *buf, size_t len, int **fds,
> size_t *nfds, Error **errp)
> {
> struct iovec iov = { .iov_base = buf, .iov_len = len };
> - bool iolock = qemu_mutex_iothread_locked();
> + bool iolock = qemu_bql_locked();
> bool iothread = qemu_in_iothread();
> int ret = -1;
>
> @@ -107,13 +107,13 @@ static ssize_t mpqemu_read(QIOChannel *ioc, void *buf, size_t len, int **fds,
> assert(qemu_in_coroutine() || !iothread);
>
> if (iolock && !iothread && !qemu_in_coroutine()) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> ret = qio_channel_readv_full_all_eof(ioc, &iov, 1, fds, nfds, errp);
>
> if (iolock && !iothread && !qemu_in_coroutine()) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> return (ret <= 0) ? ret : iov.iov_len;
> diff --git a/hw/remote/vfio-user-obj.c b/hw/remote/vfio-user-obj.c
> index 8b10c32a3c..d0d0386d52 100644
> --- a/hw/remote/vfio-user-obj.c
> +++ b/hw/remote/vfio-user-obj.c
> @@ -400,7 +400,7 @@ static int vfu_object_mr_rw(MemoryRegion *mr, uint8_t *buf, hwaddr offset,
> }
>
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> release_lock = false;
> }
>
> diff --git a/hw/s390x/s390-skeys.c b/hw/s390x/s390-skeys.c
> index 8f5159d85d..307344aa80 100644
> --- a/hw/s390x/s390-skeys.c
> +++ b/hw/s390x/s390-skeys.c
> @@ -153,7 +153,7 @@ void qmp_dump_skeys(const char *filename, Error **errp)
> goto out;
> }
>
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
> guest_phys_blocks_init(&guest_phys_blocks);
> guest_phys_blocks_append(&guest_phys_blocks);
>
> diff --git a/migration/block-dirty-bitmap.c b/migration/block-dirty-bitmap.c
> index 24347ab0f7..b5a2d377db 100644
> --- a/migration/block-dirty-bitmap.c
> +++ b/migration/block-dirty-bitmap.c
> @@ -774,7 +774,7 @@ static void dirty_bitmap_state_pending(void *opaque,
> SaveBitmapState *dbms;
> uint64_t pending = 0;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> QSIMPLEQ_FOREACH(dbms, &s->dbms_list, entry) {
> uint64_t gran = bdrv_dirty_bitmap_granularity(dbms->bitmap);
> @@ -784,7 +784,7 @@ static void dirty_bitmap_state_pending(void *opaque,
> pending += DIV_ROUND_UP(sectors * BDRV_SECTOR_SIZE, gran);
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> trace_dirty_bitmap_state_pending(pending);
>
> diff --git a/migration/block.c b/migration/block.c
> index a15f9bddcb..87f36e6e35 100644
> --- a/migration/block.c
> +++ b/migration/block.c
> @@ -269,7 +269,7 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
> int64_t count;
>
> if (bmds->shared_base) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> aio_context_acquire(blk_get_aio_context(bb));
> /* Skip unallocated sectors; intentionally treats failure or
> * partial sector as an allocated sector */
> @@ -282,7 +282,7 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
> cur_sector += count >> BDRV_SECTOR_BITS;
> }
> aio_context_release(blk_get_aio_context(bb));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> if (cur_sector >= total_sectors) {
> @@ -321,14 +321,14 @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
> * This is ugly and will disappear when we make bdrv_* thread-safe,
> * without the need to acquire the AioContext.
> */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> aio_context_acquire(blk_get_aio_context(bmds->blk));
> bdrv_reset_dirty_bitmap(bmds->dirty_bitmap, cur_sector * BDRV_SECTOR_SIZE,
> nr_sectors * BDRV_SECTOR_SIZE);
> blk->aiocb = blk_aio_preadv(bb, cur_sector * BDRV_SECTOR_SIZE, &blk->qiov,
> 0, blk_mig_read_cb, blk);
> aio_context_release(blk_get_aio_context(bmds->blk));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> bmds->cur_sector = cur_sector + nr_sectors;
> return (bmds->cur_sector >= total_sectors);
> @@ -786,9 +786,9 @@ static int block_save_iterate(QEMUFile *f, void *opaque)
> /* Always called with iothread lock taken for
> * simplicity, block_save_complete also calls it.
> */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ret = blk_mig_save_dirty_block(f, 1);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> if (ret < 0) {
> return ret;
> @@ -860,9 +860,9 @@ static void block_state_pending(void *opaque, uint64_t *must_precopy,
> /* Estimate pending number of bytes to send */
> uint64_t pending;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> pending = get_remaining_dirty();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> blk_mig_lock();
> pending += block_mig_state.submitted * BLK_MIG_BLOCK_SIZE +
> diff --git a/migration/colo.c b/migration/colo.c
> index 4447e34914..2e68107cfa 100644
> --- a/migration/colo.c
> +++ b/migration/colo.c
> @@ -420,13 +420,13 @@ static int colo_do_checkpoint_transaction(MigrationState *s,
> qio_channel_io_seek(QIO_CHANNEL(bioc), 0, 0, NULL);
> bioc->usage = 0;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> if (failover_get_state() != FAILOVER_STATUS_NONE) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> goto out;
> }
> vm_stop_force_state(RUN_STATE_COLO);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> trace_colo_vm_state_change("run", "stop");
> /*
> * Failover request bh could be called after vm_stop_force_state(),
> @@ -435,23 +435,23 @@ static int colo_do_checkpoint_transaction(MigrationState *s,
> if (failover_get_state() != FAILOVER_STATUS_NONE) {
> goto out;
> }
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> replication_do_checkpoint_all(&local_err);
> if (local_err) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> goto out;
> }
>
> colo_send_message(s->to_dst_file, COLO_MESSAGE_VMSTATE_SEND, &local_err);
> if (local_err) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> goto out;
> }
> /* Note: device state is saved into buffer */
> ret = qemu_save_device_state(fb);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> if (ret < 0) {
> goto out;
> }
> @@ -504,9 +504,9 @@ static int colo_do_checkpoint_transaction(MigrationState *s,
>
> ret = 0;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> vm_start();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> trace_colo_vm_state_change("stop", "run");
>
> out:
> @@ -557,15 +557,15 @@ static void colo_process_checkpoint(MigrationState *s)
> fb = qemu_file_new_output(QIO_CHANNEL(bioc));
> object_unref(OBJECT(bioc));
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> replication_start_all(REPLICATION_MODE_PRIMARY, &local_err);
> if (local_err) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> goto out;
> }
>
> vm_start();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> trace_colo_vm_state_change("stop", "run");
>
> timer_mod(s->colo_delay_timer, qemu_clock_get_ms(QEMU_CLOCK_HOST) +
> @@ -639,14 +639,14 @@ out:
>
> void migrate_start_colo_process(MigrationState *s)
> {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> qemu_event_init(&s->colo_checkpoint_event, false);
> s->colo_delay_timer = timer_new_ms(QEMU_CLOCK_HOST,
> colo_checkpoint_notify, s);
>
> qemu_sem_init(&s->colo_exit_sem, 0);
> colo_process_checkpoint(s);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> static void colo_incoming_process_checkpoint(MigrationIncomingState *mis,
> @@ -657,9 +657,9 @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis,
> Error *local_err = NULL;
> int ret;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> vm_stop_force_state(RUN_STATE_COLO);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> trace_colo_vm_state_change("run", "stop");
>
> /* FIXME: This is unnecessary for periodic checkpoint mode */
> @@ -677,10 +677,10 @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis,
> return;
> }
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_synchronize_all_states();
> ret = qemu_loadvm_state_main(mis->from_src_file, mis);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> if (ret < 0) {
> error_setg(errp, "Load VM's live state (ram) error");
> @@ -719,14 +719,14 @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis,
> return;
> }
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> vmstate_loading = true;
> colo_flush_ram_cache();
> ret = qemu_load_device_state(fb);
> if (ret < 0) {
> error_setg(errp, "COLO: load device state failed");
> vmstate_loading = false;
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return;
> }
>
> @@ -734,7 +734,7 @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis,
> if (local_err) {
> error_propagate(errp, local_err);
> vmstate_loading = false;
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return;
> }
>
> @@ -743,7 +743,7 @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis,
> if (local_err) {
> error_propagate(errp, local_err);
> vmstate_loading = false;
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return;
> }
> /* Notify all filters of all NIC to do checkpoint */
> @@ -752,13 +752,13 @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis,
> if (local_err) {
> error_propagate(errp, local_err);
> vmstate_loading = false;
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return;
> }
>
> vmstate_loading = false;
> vm_start();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> trace_colo_vm_state_change("stop", "run");
>
> if (failover_get_state() == FAILOVER_STATUS_RELAUNCH) {
> @@ -851,14 +851,14 @@ static void *colo_process_incoming_thread(void *opaque)
> fb = qemu_file_new_input(QIO_CHANNEL(bioc));
> object_unref(OBJECT(bioc));
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> replication_start_all(REPLICATION_MODE_SECONDARY, &local_err);
> if (local_err) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> goto out;
> }
> vm_start();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> trace_colo_vm_state_change("stop", "run");
>
> colo_send_message(mis->to_src_file, COLO_MESSAGE_CHECKPOINT_READY,
> @@ -920,7 +920,7 @@ int coroutine_fn colo_incoming_co(void)
> Error *local_err = NULL;
> QemuThread th;
>
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
>
> if (!migration_incoming_colo_enabled()) {
> return 0;
> @@ -940,10 +940,10 @@ int coroutine_fn colo_incoming_co(void)
> qemu_coroutine_yield();
> mis->colo_incoming_co = NULL;
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> /* Wait checkpoint incoming thread exit before free resource */
> qemu_thread_join(&th);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> /* We hold the global iothread lock, so it is safe here */
> colo_release_ram_cache();
> diff --git a/migration/dirtyrate.c b/migration/dirtyrate.c
> index 036ac017fc..1d705092cd 100644
> --- a/migration/dirtyrate.c
> +++ b/migration/dirtyrate.c
> @@ -90,13 +90,13 @@ static int64_t do_calculate_dirtyrate(DirtyPageRecord dirty_pages,
>
> void global_dirty_log_change(unsigned int flag, bool start)
> {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> if (start) {
> memory_global_dirty_log_start(flag);
> } else {
> memory_global_dirty_log_stop(flag);
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> /*
> @@ -106,12 +106,12 @@ void global_dirty_log_change(unsigned int flag, bool start)
> */
> static void global_dirty_log_sync(unsigned int flag, bool one_shot)
> {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> memory_global_dirty_log_sync(false);
> if (one_shot) {
> memory_global_dirty_log_stop(flag);
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> static DirtyPageRecord *vcpu_dirty_stat_alloc(VcpuStat *stat)
> @@ -610,7 +610,7 @@ static void calculate_dirtyrate_dirty_bitmap(struct DirtyRateConfig config)
> int64_t start_time;
> DirtyPageRecord dirty_pages;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> memory_global_dirty_log_start(GLOBAL_DIRTY_DIRTY_RATE);
>
> /*
> @@ -627,7 +627,7 @@ static void calculate_dirtyrate_dirty_bitmap(struct DirtyRateConfig config)
> * KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE cap is enabled.
> */
> dirtyrate_manual_reset_protect();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> record_dirtypages_bitmap(&dirty_pages, true);
>
> diff --git a/migration/migration.c b/migration/migration.c
> index 28a34c9068..b153133fba 100644
> --- a/migration/migration.c
> +++ b/migration/migration.c
> @@ -1293,12 +1293,12 @@ static void migrate_fd_cleanup(MigrationState *s)
> QEMUFile *tmp;
>
> trace_migrate_fd_cleanup();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> if (s->migration_thread_running) {
> qemu_thread_join(&s->thread);
> s->migration_thread_running = false;
> }
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> multifd_save_cleanup();
> qemu_mutex_lock(&s->qemu_file_lock);
> @@ -2410,7 +2410,7 @@ static int postcopy_start(MigrationState *ms, Error **errp)
> }
>
> trace_postcopy_start();
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> trace_postcopy_start_set_run();
>
> migration_downtime_start(ms);
> @@ -2519,7 +2519,7 @@ static int postcopy_start(MigrationState *ms, Error **errp)
>
> migration_downtime_end(ms);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> if (migrate_postcopy_ram()) {
> /*
> @@ -2560,7 +2560,7 @@ fail:
> error_report_err(local_err);
> }
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return -1;
> }
>
> @@ -2594,14 +2594,14 @@ static int migration_maybe_pause(MigrationState *s,
> * wait for the 'pause_sem' semaphore.
> */
> if (s->state != MIGRATION_STATUS_CANCELLING) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> migrate_set_state(&s->state, *current_active_state,
> MIGRATION_STATUS_PRE_SWITCHOVER);
> qemu_sem_wait(&s->pause_sem);
> migrate_set_state(&s->state, MIGRATION_STATUS_PRE_SWITCHOVER,
> new_state);
> *current_active_state = new_state;
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> return s->state == new_state ? 0 : -EINVAL;
> @@ -2612,7 +2612,7 @@ static int migration_completion_precopy(MigrationState *s,
> {
> int ret;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> migration_downtime_start(s);
> qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
>
> @@ -2640,7 +2640,7 @@ static int migration_completion_precopy(MigrationState *s,
> ret = qemu_savevm_state_complete_precopy(s->to_dst_file, false,
> s->block_inactive);
> out_unlock:
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return ret;
> }
>
> @@ -2648,9 +2648,9 @@ static void migration_completion_postcopy(MigrationState *s)
> {
> trace_migration_completion_postcopy_end();
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_savevm_state_complete_postcopy(s->to_dst_file);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> /*
> * Shutdown the postcopy fast path thread. This is only needed when dest
> @@ -2674,14 +2674,14 @@ static void migration_completion_failed(MigrationState *s,
> */
> Error *local_err = NULL;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> bdrv_activate_all(&local_err);
> if (local_err) {
> error_report_err(local_err);
> } else {
> s->block_inactive = false;
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> migrate_set_state(&s->state, current_active_state,
> @@ -3121,7 +3121,7 @@ static void migration_iteration_finish(MigrationState *s)
> /* If we enabled cpu throttling for auto-converge, turn it off. */
> cpu_throttle_stop();
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> switch (s->state) {
> case MIGRATION_STATUS_COMPLETED:
> migration_calculate_complete(s);
> @@ -3152,7 +3152,7 @@ static void migration_iteration_finish(MigrationState *s)
> break;
> }
> migrate_fd_cleanup_schedule(s);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> static void bg_migration_iteration_finish(MigrationState *s)
> @@ -3164,7 +3164,7 @@ static void bg_migration_iteration_finish(MigrationState *s)
> */
> ram_write_tracking_stop();
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> switch (s->state) {
> case MIGRATION_STATUS_COMPLETED:
> migration_calculate_complete(s);
> @@ -3183,7 +3183,7 @@ static void bg_migration_iteration_finish(MigrationState *s)
> }
>
> migrate_fd_cleanup_schedule(s);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> /*
> @@ -3305,9 +3305,9 @@ static void *migration_thread(void *opaque)
> object_ref(OBJECT(s));
> update_iteration_initial_status(s);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_savevm_state_header(s->to_dst_file);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> /*
> * If we opened the return path, we need to make sure dst has it
> @@ -3335,9 +3335,9 @@ static void *migration_thread(void *opaque)
> qemu_savevm_send_colo_enable(s->to_dst_file);
> }
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_savevm_state_setup(s->to_dst_file);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> qemu_savevm_wait_unplug(s, MIGRATION_STATUS_SETUP,
> MIGRATION_STATUS_ACTIVE);
> @@ -3448,10 +3448,10 @@ static void *bg_migration_thread(void *opaque)
> ram_write_tracking_prepare();
> #endif
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_savevm_state_header(s->to_dst_file);
> qemu_savevm_state_setup(s->to_dst_file);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> qemu_savevm_wait_unplug(s, MIGRATION_STATUS_SETUP,
> MIGRATION_STATUS_ACTIVE);
> @@ -3461,7 +3461,7 @@ static void *bg_migration_thread(void *opaque)
> trace_migration_thread_setup_complete();
> migration_downtime_start(s);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> /*
> * If VM is currently in suspended state, then, to make a valid runstate
> @@ -3504,7 +3504,7 @@ static void *bg_migration_thread(void *opaque)
> s->vm_start_bh = qemu_bh_new(bg_migration_vm_start_bh, s);
> qemu_bh_schedule(s->vm_start_bh);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> while (migration_is_active(s)) {
> MigIterateState iter_state = bg_migration_iteration_run(s);
> @@ -3533,7 +3533,7 @@ fail:
> if (early_fail) {
> migrate_set_state(&s->state, MIGRATION_STATUS_ACTIVE,
> MIGRATION_STATUS_FAILED);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> bg_migration_iteration_finish(s);
> diff --git a/migration/ram.c b/migration/ram.c
> index 8c7886ab79..f274bcf655 100644
> --- a/migration/ram.c
> +++ b/migration/ram.c
> @@ -2984,9 +2984,9 @@ static int ram_save_setup(QEMUFile *f, void *opaque)
> migration_ops = g_malloc0(sizeof(MigrationOps));
> migration_ops->ram_save_target_page = ram_save_target_page_legacy;
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> ret = multifd_send_sync_main(f);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> if (ret < 0) {
> return ret;
> }
> @@ -3221,11 +3221,11 @@ static void ram_state_pending_exact(void *opaque, uint64_t *must_precopy,
> uint64_t remaining_size = rs->migration_dirty_pages * TARGET_PAGE_SIZE;
>
> if (!migration_in_postcopy() && remaining_size < s->threshold_size) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> WITH_RCU_READ_LOCK_GUARD() {
> migration_bitmap_sync_precopy(rs, false);
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> remaining_size = rs->migration_dirty_pages * TARGET_PAGE_SIZE;
> }
>
> @@ -3453,7 +3453,7 @@ void colo_incoming_start_dirty_log(void)
> {
> RAMBlock *block = NULL;
> /* For memory_global_dirty_log_start below. */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_mutex_lock_ramlist();
>
> memory_global_dirty_log_sync(false);
> @@ -3467,7 +3467,7 @@ void colo_incoming_start_dirty_log(void)
> }
> ram_state->migration_dirty_pages = 0;
> qemu_mutex_unlock_ramlist();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> /* It is need to hold the global lock to call this helper */
> diff --git a/replay/replay-internal.c b/replay/replay-internal.c
> index 77d0c82327..04c9c6374b 100644
> --- a/replay/replay-internal.c
> +++ b/replay/replay-internal.c
> @@ -216,7 +216,7 @@ void replay_mutex_lock(void)
> {
> if (replay_mode != REPLAY_MODE_NONE) {
> unsigned long id;
> - g_assert(!qemu_mutex_iothread_locked());
> + g_assert(!qemu_bql_locked());
> g_assert(!replay_mutex_locked());
> qemu_mutex_lock(&lock);
> id = mutex_tail++;
> diff --git a/semihosting/console.c b/semihosting/console.c
> index 5d61e8207e..666285541d 100644
> --- a/semihosting/console.c
> +++ b/semihosting/console.c
> @@ -43,7 +43,7 @@ static SemihostingConsole console;
> static int console_can_read(void *opaque)
> {
> SemihostingConsole *c = opaque;
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
> return (int)fifo8_num_free(&c->fifo);
> }
>
> @@ -58,7 +58,7 @@ static void console_wake_up(gpointer data, gpointer user_data)
> static void console_read(void *opaque, const uint8_t *buf, int size)
> {
> SemihostingConsole *c = opaque;
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
> while (size-- && !fifo8_is_full(&c->fifo)) {
> fifo8_push(&c->fifo, *buf++);
> }
> @@ -70,7 +70,7 @@ bool qemu_semihosting_console_ready(void)
> {
> SemihostingConsole *c = &console;
>
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
> return !fifo8_is_empty(&c->fifo);
> }
>
> @@ -78,7 +78,7 @@ void qemu_semihosting_console_block_until_ready(CPUState *cs)
> {
> SemihostingConsole *c = &console;
>
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
>
> /* Block if the fifo is completely empty. */
> if (fifo8_is_empty(&c->fifo)) {
> diff --git a/stubs/iothread-lock.c b/stubs/iothread-lock.c
> index 5b45b7fc8b..1f24c3203a 100644
> --- a/stubs/iothread-lock.c
> +++ b/stubs/iothread-lock.c
> @@ -1,15 +1,15 @@
> #include "qemu/osdep.h"
> #include "qemu/main-loop.h"
>
> -bool qemu_mutex_iothread_locked(void)
> +bool qemu_bql_locked(void)
> {
> return false;
> }
>
> -void qemu_mutex_lock_iothread_impl(const char *file, int line)
> +void qemu_bql_lock_impl(const char *file, int line)
> {
> }
>
> -void qemu_mutex_unlock_iothread(void)
> +void qemu_bql_unlock(void)
> {
> }
> diff --git a/system/cpu-throttle.c b/system/cpu-throttle.c
> index d9bb30a223..e98836311b 100644
> --- a/system/cpu-throttle.c
> +++ b/system/cpu-throttle.c
> @@ -57,9 +57,9 @@ static void cpu_throttle_thread(CPUState *cpu, run_on_cpu_data opaque)
> qemu_cond_timedwait_iothread(cpu->halt_cond,
> sleeptime_ns / SCALE_MS);
> } else {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> g_usleep(sleeptime_ns / SCALE_US);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
> sleeptime_ns = endtime_ns - qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
> }
> diff --git a/system/cpus.c b/system/cpus.c
> index a444a747f0..d5b98c11f5 100644
> --- a/system/cpus.c
> +++ b/system/cpus.c
> @@ -481,35 +481,35 @@ bool qemu_in_vcpu_thread(void)
> return current_cpu && qemu_cpu_is_self(current_cpu);
> }
>
> -QEMU_DEFINE_STATIC_CO_TLS(bool, iothread_locked)
> +QEMU_DEFINE_STATIC_CO_TLS(bool, bql_locked)
>
> -bool qemu_mutex_iothread_locked(void)
> +bool qemu_bql_locked(void)
> {
> - return get_iothread_locked();
> + return get_bql_locked();
> }
>
> bool qemu_in_main_thread(void)
> {
> - return qemu_mutex_iothread_locked();
> + return qemu_bql_locked();
> }
>
> /*
> * The BQL is taken from so many places that it is worth profiling the
> * callers directly, instead of funneling them all through a single function.
> */
> -void qemu_mutex_lock_iothread_impl(const char *file, int line)
> +void qemu_bql_lock_impl(const char *file, int line)
> {
> QemuMutexLockFunc bql_lock = qatomic_read(&qemu_bql_mutex_lock_func);
>
> - g_assert(!qemu_mutex_iothread_locked());
> + g_assert(!qemu_bql_locked());
> bql_lock(&qemu_global_mutex, file, line);
> - set_iothread_locked(true);
> + set_bql_locked(true);
> }
>
> -void qemu_mutex_unlock_iothread(void)
> +void qemu_bql_unlock(void)
> {
> - g_assert(qemu_mutex_iothread_locked());
> - set_iothread_locked(false);
> + g_assert(qemu_bql_locked());
> + set_bql_locked(false);
> qemu_mutex_unlock(&qemu_global_mutex);
> }
>
> @@ -577,9 +577,9 @@ void pause_all_vcpus(void)
> }
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> replay_mutex_lock();
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> void cpu_resume(CPUState *cpu)
> @@ -608,9 +608,9 @@ void cpu_remove_sync(CPUState *cpu)
> cpu->stop = true;
> cpu->unplug = true;
> qemu_cpu_kick(cpu);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> qemu_thread_join(cpu->thread);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> void cpus_register_accel(const AccelOpsClass *ops)
> diff --git a/system/dirtylimit.c b/system/dirtylimit.c
> index 495c7a7082..f89bf6b61f 100644
> --- a/system/dirtylimit.c
> +++ b/system/dirtylimit.c
> @@ -148,9 +148,9 @@ void vcpu_dirty_rate_stat_stop(void)
> {
> qatomic_set(&vcpu_dirty_rate_stat->running, 0);
> dirtylimit_state_unlock();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> qemu_thread_join(&vcpu_dirty_rate_stat->thread);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> dirtylimit_state_lock();
> }
>
> diff --git a/system/memory.c b/system/memory.c
> index 4d9cb0a7ff..8d78334cb2 100644
> --- a/system/memory.c
> +++ b/system/memory.c
> @@ -1119,7 +1119,7 @@ void memory_region_transaction_commit(void)
> AddressSpace *as;
>
> assert(memory_region_transaction_depth);
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
>
> --memory_region_transaction_depth;
> if (!memory_region_transaction_depth) {
> diff --git a/system/physmem.c b/system/physmem.c
> index a63853a7bc..c136675876 100644
> --- a/system/physmem.c
> +++ b/system/physmem.c
> @@ -2639,8 +2639,8 @@ bool prepare_mmio_access(MemoryRegion *mr)
> {
> bool release_lock = false;
>
> - if (!qemu_mutex_iothread_locked()) {
> - qemu_mutex_lock_iothread();
> + if (!qemu_bql_locked()) {
> + qemu_bql_lock();
> release_lock = true;
> }
> if (mr->flush_coalesced_mmio) {
> @@ -2721,7 +2721,7 @@ static MemTxResult flatview_write_continue(FlatView *fv, hwaddr addr,
> }
>
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> release_lock = false;
> }
>
> @@ -2799,7 +2799,7 @@ MemTxResult flatview_read_continue(FlatView *fv, hwaddr addr,
> }
>
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> release_lock = false;
> }
>
> diff --git a/system/runstate.c b/system/runstate.c
> index ea9d6c2a32..5718e6827c 100644
> --- a/system/runstate.c
> +++ b/system/runstate.c
> @@ -810,7 +810,7 @@ void qemu_init_subsystems(void)
>
> qemu_init_cpu_list();
> qemu_init_cpu_loop();
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> atexit(qemu_run_exit_notifiers);
>
> diff --git a/system/watchpoint.c b/system/watchpoint.c
> index ba5ad13352..d9cc71dd33 100644
> --- a/system/watchpoint.c
> +++ b/system/watchpoint.c
> @@ -155,9 +155,9 @@ void cpu_check_watchpoint(CPUState *cpu, vaddr addr, vaddr len,
> * Now raise the debug interrupt so that it will
> * trigger after the current instruction.
> */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_interrupt(cpu, CPU_INTERRUPT_DEBUG);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return;
> }
>
> diff --git a/target/arm/arm-powerctl.c b/target/arm/arm-powerctl.c
> index c078849403..aec104834d 100644
> --- a/target/arm/arm-powerctl.c
> +++ b/target/arm/arm-powerctl.c
> @@ -88,7 +88,7 @@ static void arm_set_cpu_on_async_work(CPUState *target_cpu_state,
> g_free(info);
>
> /* Finally set the power status */
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
> target_cpu->power_state = PSCI_ON;
> }
>
> @@ -99,7 +99,7 @@ int arm_set_cpu_on(uint64_t cpuid, uint64_t entry, uint64_t context_id,
> ARMCPU *target_cpu;
> struct CpuOnInfo *info;
>
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
>
> DPRINTF("cpu %" PRId64 " (EL %d, %s) @ 0x%" PRIx64 " with R0 = 0x%" PRIx64
> "\n", cpuid, target_el, target_aa64 ? "aarch64" : "aarch32", entry,
> @@ -196,7 +196,7 @@ static void arm_set_cpu_on_and_reset_async_work(CPUState *target_cpu_state,
> target_cpu_state->halted = 0;
>
> /* Finally set the power status */
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
> target_cpu->power_state = PSCI_ON;
> }
>
> @@ -205,7 +205,7 @@ int arm_set_cpu_on_and_reset(uint64_t cpuid)
> CPUState *target_cpu_state;
> ARMCPU *target_cpu;
>
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
>
> /* Retrieve the cpu we are powering up */
> target_cpu_state = arm_get_cpu_by_id(cpuid);
> @@ -247,7 +247,7 @@ static void arm_set_cpu_off_async_work(CPUState *target_cpu_state,
> {
> ARMCPU *target_cpu = ARM_CPU(target_cpu_state);
>
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
> target_cpu->power_state = PSCI_OFF;
> target_cpu_state->halted = 1;
> target_cpu_state->exception_index = EXCP_HLT;
> @@ -258,7 +258,7 @@ int arm_set_cpu_off(uint64_t cpuid)
> CPUState *target_cpu_state;
> ARMCPU *target_cpu;
>
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
>
> DPRINTF("cpu %" PRId64 "\n", cpuid);
>
> @@ -294,7 +294,7 @@ int arm_reset_cpu(uint64_t cpuid)
> CPUState *target_cpu_state;
> ARMCPU *target_cpu;
>
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
>
> DPRINTF("cpu %" PRId64 "\n", cpuid);
>
> diff --git a/target/arm/helper.c b/target/arm/helper.c
> index 2746d3fdac..f472043986 100644
> --- a/target/arm/helper.c
> +++ b/target/arm/helper.c
> @@ -5831,7 +5831,7 @@ static void do_hcr_write(CPUARMState *env, uint64_t value, uint64_t valid_mask)
> * VFIQ are masked unless running at EL0 or EL1, and HCR
> * can only be written at EL2.
> */
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
> arm_cpu_update_virq(cpu);
> arm_cpu_update_vfiq(cpu);
> arm_cpu_update_vserr(cpu);
> @@ -11344,7 +11344,7 @@ void arm_cpu_do_interrupt(CPUState *cs)
> * BQL needs to be held for any modification of
> * cs->interrupt_request.
> */
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
>
> arm_call_pre_el_change_hook(cpu);
>
> diff --git a/target/arm/hvf/hvf.c b/target/arm/hvf/hvf.c
> index 757e13b0f9..017fd13c5d 100644
> --- a/target/arm/hvf/hvf.c
> +++ b/target/arm/hvf/hvf.c
> @@ -1718,9 +1718,9 @@ static void hvf_wait_for_ipi(CPUState *cpu, struct timespec *ts)
> * sleeping.
> */
> qatomic_set_mb(&cpu->thread_kicked, false);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> pselect(0, 0, 0, 0, ts, &cpu->accel->unblock_ipi_mask);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> static void hvf_wfi(CPUState *cpu)
> @@ -1821,7 +1821,7 @@ int hvf_vcpu_exec(CPUState *cpu)
>
> flush_cpu_state(cpu);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> assert_hvf_ok(hv_vcpu_run(cpu->accel->fd));
>
> /* handle VMEXIT */
> @@ -1830,7 +1830,7 @@ int hvf_vcpu_exec(CPUState *cpu)
> uint32_t ec = syn_get_ec(syndrome);
>
> ret = 0;
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> switch (exit_reason) {
> case HV_EXIT_REASON_EXCEPTION:
> /* This is the main one, handle below. */
> diff --git a/target/arm/kvm.c b/target/arm/kvm.c
> index 7903e2ddde..431b82e509 100644
> --- a/target/arm/kvm.c
> +++ b/target/arm/kvm.c
> @@ -833,7 +833,7 @@ MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run)
> if (run->s.regs.device_irq_level != cpu->device_irq_level) {
> switched_level = cpu->device_irq_level ^ run->s.regs.device_irq_level;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> if (switched_level & KVM_ARM_DEV_EL1_VTIMER) {
> qemu_set_irq(cpu->gt_timer_outputs[GTIMER_VIRT],
> @@ -862,7 +862,7 @@ MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run)
>
> /* We also mark unknown levels as processed to not waste cycles */
> cpu->device_irq_level = run->s.regs.device_irq_level;
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> return MEMTXATTRS_UNSPECIFIED;
> diff --git a/target/arm/kvm64.c b/target/arm/kvm64.c
> index 3c175c93a7..282dc5920e 100644
> --- a/target/arm/kvm64.c
> +++ b/target/arm/kvm64.c
> @@ -1233,9 +1233,9 @@ bool kvm_arm_handle_debug(CPUState *cs, struct kvm_debug_exit_arch *debug_exit)
> env->exception.syndrome = debug_exit->hsr;
> env->exception.vaddress = debug_exit->far;
> env->exception.target_el = 1;
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> arm_cpu_do_interrupt(cs);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> return false;
> }
> diff --git a/target/arm/ptw.c b/target/arm/ptw.c
> index 1762b058ae..e3cc0a7ab8 100644
> --- a/target/arm/ptw.c
> +++ b/target/arm/ptw.c
> @@ -772,9 +772,9 @@ static uint64_t arm_casq_ptw(CPUARMState *env, uint64_t old_val,
> #if !TCG_OVERSIZED_GUEST
> # error "Unexpected configuration"
> #endif
> - bool locked = qemu_mutex_iothread_locked();
> + bool locked = qemu_bql_locked();
> if (!locked) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
> if (ptw->out_be) {
> cur_val = ldq_be_p(host);
> @@ -788,7 +788,7 @@ static uint64_t arm_casq_ptw(CPUARMState *env, uint64_t old_val,
> }
> }
> if (!locked) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> #endif
>
> diff --git a/target/arm/tcg/helper-a64.c b/target/arm/tcg/helper-a64.c
> index 8ad84623d3..22d453e6e0 100644
> --- a/target/arm/tcg/helper-a64.c
> +++ b/target/arm/tcg/helper-a64.c
> @@ -809,9 +809,9 @@ void HELPER(exception_return)(CPUARMState *env, uint64_t new_pc)
> goto illegal_return;
> }
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> arm_call_pre_el_change_hook(env_archcpu(env));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> if (!return_to_aa64) {
> env->aarch64 = false;
> @@ -876,9 +876,9 @@ void HELPER(exception_return)(CPUARMState *env, uint64_t new_pc)
> */
> aarch64_sve_change_el(env, cur_el, new_el, return_to_aa64);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> arm_call_el_change_hook(env_archcpu(env));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> return;
>
> diff --git a/target/arm/tcg/m_helper.c b/target/arm/tcg/m_helper.c
> index a26adb75aa..5f38b9a4a1 100644
> --- a/target/arm/tcg/m_helper.c
> +++ b/target/arm/tcg/m_helper.c
> @@ -374,7 +374,7 @@ void HELPER(v7m_preserve_fp_state)(CPUARMState *env)
> bool take_exception;
>
> /* Take the iothread lock as we are going to touch the NVIC */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> /* Check the background context had access to the FPU */
> if (!v7m_cpacr_pass(env, is_secure, is_priv)) {
> @@ -428,7 +428,7 @@ void HELPER(v7m_preserve_fp_state)(CPUARMState *env)
> take_exception = !stacked_ok &&
> armv7m_nvic_can_take_pending_exception(env->nvic);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> if (take_exception) {
> raise_exception_ra(env, EXCP_LAZYFP, 0, 1, GETPC());
> diff --git a/target/arm/tcg/op_helper.c b/target/arm/tcg/op_helper.c
> index ea08936a85..46a14aac52 100644
> --- a/target/arm/tcg/op_helper.c
> +++ b/target/arm/tcg/op_helper.c
> @@ -427,9 +427,9 @@ void HELPER(cpsr_write_eret)(CPUARMState *env, uint32_t val)
> {
> uint32_t mask;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> arm_call_pre_el_change_hook(env_archcpu(env));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> mask = aarch32_cpsr_valid_mask(env->features, &env_archcpu(env)->isar);
> cpsr_write(env, val, mask, CPSRWriteExceptionReturn);
> @@ -442,9 +442,9 @@ void HELPER(cpsr_write_eret)(CPUARMState *env, uint32_t val)
> env->regs[15] &= (env->thumb ? ~1 : ~3);
> arm_rebuild_hflags(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> arm_call_el_change_hook(env_archcpu(env));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> /* Access to user mode registers from privileged modes. */
> @@ -803,9 +803,9 @@ void HELPER(set_cp_reg)(CPUARMState *env, const void *rip, uint32_t value)
> const ARMCPRegInfo *ri = rip;
>
> if (ri->type & ARM_CP_IO) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ri->writefn(env, ri, value);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> } else {
> ri->writefn(env, ri, value);
> }
> @@ -817,9 +817,9 @@ uint32_t HELPER(get_cp_reg)(CPUARMState *env, const void *rip)
> uint32_t res;
>
> if (ri->type & ARM_CP_IO) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> res = ri->readfn(env, ri);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> } else {
> res = ri->readfn(env, ri);
> }
> @@ -832,9 +832,9 @@ void HELPER(set_cp_reg64)(CPUARMState *env, const void *rip, uint64_t value)
> const ARMCPRegInfo *ri = rip;
>
> if (ri->type & ARM_CP_IO) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ri->writefn(env, ri, value);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> } else {
> ri->writefn(env, ri, value);
> }
> @@ -846,9 +846,9 @@ uint64_t HELPER(get_cp_reg64)(CPUARMState *env, const void *rip)
> uint64_t res;
>
> if (ri->type & ARM_CP_IO) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> res = ri->readfn(env, ri);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> } else {
> res = ri->readfn(env, ri);
> }
> diff --git a/target/arm/tcg/psci.c b/target/arm/tcg/psci.c
> index 6c1239bb96..51af10db99 100644
> --- a/target/arm/tcg/psci.c
> +++ b/target/arm/tcg/psci.c
> @@ -107,7 +107,7 @@ void arm_handle_psci_call(ARMCPU *cpu)
> }
> target_cpu = ARM_CPU(target_cpu_state);
>
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
> ret = target_cpu->power_state;
> break;
> default:
> diff --git a/target/hppa/int_helper.c b/target/hppa/int_helper.c
> index 98e9d688f6..9ef8cf7ff4 100644
> --- a/target/hppa/int_helper.c
> +++ b/target/hppa/int_helper.c
> @@ -84,17 +84,17 @@ void hppa_cpu_alarm_timer(void *opaque)
> void HELPER(write_eirr)(CPUHPPAState *env, target_ulong val)
> {
> env->cr[CR_EIRR] &= ~val;
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> eval_interrupt(env_archcpu(env));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(write_eiem)(CPUHPPAState *env, target_ulong val)
> {
> env->cr[CR_EIEM] = val;
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> eval_interrupt(env_archcpu(env));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void hppa_cpu_do_interrupt(CPUState *cs)
> diff --git a/target/i386/hvf/hvf.c b/target/i386/hvf/hvf.c
> index 20b9ca3ef5..2cc8b115f7 100644
> --- a/target/i386/hvf/hvf.c
> +++ b/target/i386/hvf/hvf.c
> @@ -429,9 +429,9 @@ int hvf_vcpu_exec(CPUState *cpu)
> }
> vmx_update_tpr(cpu);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> if (!cpu_is_bsp(X86_CPU(cpu)) && cpu->halted) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> return EXCP_HLT;
> }
>
> @@ -450,7 +450,7 @@ int hvf_vcpu_exec(CPUState *cpu)
> rip = rreg(cpu->accel->fd, HV_X86_RIP);
> env->eflags = rreg(cpu->accel->fd, HV_X86_RFLAGS);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> update_apic_tpr(cpu);
> current_cpu = cpu;
> diff --git a/target/i386/kvm/hyperv.c b/target/i386/kvm/hyperv.c
> index e3ac978648..dcad09f6c9 100644
> --- a/target/i386/kvm/hyperv.c
> +++ b/target/i386/kvm/hyperv.c
> @@ -45,9 +45,9 @@ void hyperv_x86_synic_update(X86CPU *cpu)
>
> static void async_synic_update(CPUState *cs, run_on_cpu_data data)
> {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> hyperv_x86_synic_update(X86_CPU(cs));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> int kvm_hv_handle_exit(X86CPU *cpu, struct kvm_hyperv_exit *exit)
> diff --git a/target/i386/kvm/kvm.c b/target/i386/kvm/kvm.c
> index 11b8177eff..084f5e6b8b 100644
> --- a/target/i386/kvm/kvm.c
> +++ b/target/i386/kvm/kvm.c
> @@ -4705,9 +4705,9 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)
> /* Inject NMI */
> if (cpu->interrupt_request & (CPU_INTERRUPT_NMI | CPU_INTERRUPT_SMI)) {
> if (cpu->interrupt_request & CPU_INTERRUPT_NMI) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu->interrupt_request &= ~CPU_INTERRUPT_NMI;
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> DPRINTF("injected NMI\n");
> ret = kvm_vcpu_ioctl(cpu, KVM_NMI);
> if (ret < 0) {
> @@ -4716,9 +4716,9 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)
> }
> }
> if (cpu->interrupt_request & CPU_INTERRUPT_SMI) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu->interrupt_request &= ~CPU_INTERRUPT_SMI;
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> DPRINTF("injected SMI\n");
> ret = kvm_vcpu_ioctl(cpu, KVM_SMI);
> if (ret < 0) {
> @@ -4729,7 +4729,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)
> }
>
> if (!kvm_pic_in_kernel()) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> /* Force the VCPU out of its inner loop to process any INIT requests
> @@ -4782,7 +4782,7 @@ void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run)
> DPRINTF("setting tpr\n");
> run->cr8 = cpu_get_apic_tpr(x86_cpu->apic_state);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> }
>
> @@ -4830,12 +4830,12 @@ MemTxAttrs kvm_arch_post_run(CPUState *cpu, struct kvm_run *run)
> /* We need to protect the apic state against concurrent accesses from
> * different threads in case the userspace irqchip is used. */
> if (!kvm_irqchip_in_kernel()) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
> cpu_set_apic_tpr(x86_cpu->apic_state, run->cr8);
> cpu_set_apic_base(x86_cpu->apic_state, run->apic_base);
> if (!kvm_irqchip_in_kernel()) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> return cpu_get_mem_attrs(env);
> }
> @@ -5269,17 +5269,17 @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
> switch (run->exit_reason) {
> case KVM_EXIT_HLT:
> DPRINTF("handle_hlt\n");
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ret = kvm_handle_halt(cpu);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> break;
> case KVM_EXIT_SET_TPR:
> ret = 0;
> break;
> case KVM_EXIT_TPR_ACCESS:
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ret = kvm_handle_tpr_access(cpu);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> break;
> case KVM_EXIT_FAIL_ENTRY:
> code = run->fail_entry.hardware_entry_failure_reason;
> @@ -5305,9 +5305,9 @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
> break;
> case KVM_EXIT_DEBUG:
> DPRINTF("kvm_exit_debug\n");
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ret = kvm_handle_debug(cpu, &run->debug.arch);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> break;
> case KVM_EXIT_HYPERV:
> ret = kvm_hv_handle_exit(cpu, &run->hyperv);
> diff --git a/target/i386/kvm/xen-emu.c b/target/i386/kvm/xen-emu.c
> index c0631f9cf4..f79f5d270f 100644
> --- a/target/i386/kvm/xen-emu.c
> +++ b/target/i386/kvm/xen-emu.c
> @@ -403,7 +403,7 @@ void kvm_xen_maybe_deassert_callback(CPUState *cs)
>
> /* If the evtchn_upcall_pending flag is cleared, turn the GSI off. */
> if (!vi->evtchn_upcall_pending) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> /*
> * Check again now we have the lock, because it may have been
> * asserted in the interim. And we don't want to take the lock
> @@ -413,7 +413,7 @@ void kvm_xen_maybe_deassert_callback(CPUState *cs)
> X86_CPU(cs)->env.xen_callback_asserted = false;
> xen_evtchn_set_callback_level(0);
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> }
>
> @@ -773,9 +773,9 @@ static bool handle_set_param(struct kvm_xen_exit *exit, X86CPU *cpu,
>
> switch (hp.index) {
> case HVM_PARAM_CALLBACK_IRQ:
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> err = xen_evtchn_set_callback_param(hp.value);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> xen_set_long_mode(exit->u.hcall.longmode);
> break;
> default:
> @@ -1408,7 +1408,7 @@ int kvm_xen_soft_reset(void)
> CPUState *cpu;
> int err;
>
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
>
> trace_kvm_xen_soft_reset();
>
> @@ -1481,9 +1481,9 @@ static int schedop_shutdown(CPUState *cs, uint64_t arg)
> break;
>
> case SHUTDOWN_soft_reset:
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ret = kvm_xen_soft_reset();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> break;
>
> default:
> diff --git a/target/i386/nvmm/nvmm-accel-ops.c b/target/i386/nvmm/nvmm-accel-ops.c
> index 6c46101ac1..387ccfcce5 100644
> --- a/target/i386/nvmm/nvmm-accel-ops.c
> +++ b/target/i386/nvmm/nvmm-accel-ops.c
> @@ -25,7 +25,7 @@ static void *qemu_nvmm_cpu_thread_fn(void *arg)
>
> rcu_register_thread();
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_thread_get_self(cpu->thread);
> cpu->thread_id = qemu_get_thread_id();
> current_cpu = cpu;
> @@ -55,7 +55,7 @@ static void *qemu_nvmm_cpu_thread_fn(void *arg)
>
> nvmm_destroy_vcpu(cpu);
> cpu_thread_signal_destroyed(cpu);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> rcu_unregister_thread();
> return NULL;
> }
> diff --git a/target/i386/nvmm/nvmm-all.c b/target/i386/nvmm/nvmm-all.c
> index 7d752bc5e0..9fa5b2e34a 100644
> --- a/target/i386/nvmm/nvmm-all.c
> +++ b/target/i386/nvmm/nvmm-all.c
> @@ -399,7 +399,7 @@ nvmm_vcpu_pre_run(CPUState *cpu)
> uint8_t tpr;
> int ret;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> tpr = cpu_get_apic_tpr(x86_cpu->apic_state);
> if (tpr != qcpu->tpr) {
> @@ -462,7 +462,7 @@ nvmm_vcpu_pre_run(CPUState *cpu)
> }
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> /*
> @@ -485,9 +485,9 @@ nvmm_vcpu_post_run(CPUState *cpu, struct nvmm_vcpu_exit *exit)
> tpr = exit->exitstate.cr8;
> if (qcpu->tpr != tpr) {
> qcpu->tpr = tpr;
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_set_apic_tpr(x86_cpu->apic_state, qcpu->tpr);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> }
>
> @@ -648,7 +648,7 @@ nvmm_handle_halted(struct nvmm_machine *mach, CPUState *cpu,
> CPUX86State *env = cpu_env(cpu);
> int ret = 0;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> if (!((cpu->interrupt_request & CPU_INTERRUPT_HARD) &&
> (env->eflags & IF_MASK)) &&
> @@ -658,7 +658,7 @@ nvmm_handle_halted(struct nvmm_machine *mach, CPUState *cpu,
> ret = 1;
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> return ret;
> }
> @@ -721,7 +721,7 @@ nvmm_vcpu_loop(CPUState *cpu)
> return 0;
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> cpu_exec_start(cpu);
>
> /*
> @@ -806,16 +806,16 @@ nvmm_vcpu_loop(CPUState *cpu)
> error_report("NVMM: Unexpected VM exit code 0x%lx [hw=0x%lx]",
> exit->reason, exit->u.inv.hwcode);
> nvmm_get_registers(cpu);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_system_guest_panicked(cpu_get_crash_info(cpu));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> ret = -1;
> break;
> }
> } while (ret == 0);
>
> cpu_exec_end(cpu);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> qatomic_set(&cpu->exit_request, false);
>
> diff --git a/target/i386/tcg/sysemu/fpu_helper.c b/target/i386/tcg/sysemu/fpu_helper.c
> index 93506cdd94..4960e97ebc 100644
> --- a/target/i386/tcg/sysemu/fpu_helper.c
> +++ b/target/i386/tcg/sysemu/fpu_helper.c
> @@ -32,9 +32,9 @@ void x86_register_ferr_irq(qemu_irq irq)
> void fpu_check_raise_ferr_irq(CPUX86State *env)
> {
> if (ferr_irq && !(env->hflags2 & HF2_IGNNE_MASK)) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_irq_raise(ferr_irq);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return;
> }
> }
> @@ -49,7 +49,7 @@ void cpu_set_ignne(void)
> {
> CPUX86State *env = &X86_CPU(first_cpu)->env;
>
> - assert(qemu_mutex_iothread_locked());
> + assert(qemu_bql_locked());
>
> env->hflags2 |= HF2_IGNNE_MASK;
> /*
> diff --git a/target/i386/tcg/sysemu/misc_helper.c b/target/i386/tcg/sysemu/misc_helper.c
> index e1528b7f80..e859879f4f 100644
> --- a/target/i386/tcg/sysemu/misc_helper.c
> +++ b/target/i386/tcg/sysemu/misc_helper.c
> @@ -118,9 +118,9 @@ void helper_write_crN(CPUX86State *env, int reg, target_ulong t0)
> break;
> case 8:
> if (!(env->hflags2 & HF2_VINTR_MASK)) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_set_apic_tpr(env_archcpu(env)->apic_state, t0);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> env->int_ctl = (env->int_ctl & ~V_TPR_MASK) | (t0 & V_TPR_MASK);
>
> diff --git a/target/i386/whpx/whpx-accel-ops.c b/target/i386/whpx/whpx-accel-ops.c
> index 67cad86720..1f29346a88 100644
> --- a/target/i386/whpx/whpx-accel-ops.c
> +++ b/target/i386/whpx/whpx-accel-ops.c
> @@ -25,7 +25,7 @@ static void *whpx_cpu_thread_fn(void *arg)
>
> rcu_register_thread();
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_thread_get_self(cpu->thread);
> cpu->thread_id = qemu_get_thread_id();
> current_cpu = cpu;
> @@ -55,7 +55,7 @@ static void *whpx_cpu_thread_fn(void *arg)
>
> whpx_destroy_vcpu(cpu);
> cpu_thread_signal_destroyed(cpu);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> rcu_unregister_thread();
> return NULL;
> }
> diff --git a/target/i386/whpx/whpx-all.c b/target/i386/whpx/whpx-all.c
> index d29ba916a0..50057b22ee 100644
> --- a/target/i386/whpx/whpx-all.c
> +++ b/target/i386/whpx/whpx-all.c
> @@ -1324,7 +1324,7 @@ static int whpx_first_vcpu_starting(CPUState *cpu)
> struct whpx_state *whpx = &whpx_global;
> HRESULT hr;
>
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
>
> if (!QTAILQ_EMPTY(&cpu->breakpoints) ||
> (whpx->breakpoints.breakpoints &&
> @@ -1442,7 +1442,7 @@ static int whpx_handle_halt(CPUState *cpu)
> CPUX86State *env = cpu_env(cpu);
> int ret = 0;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> if (!((cpu->interrupt_request & CPU_INTERRUPT_HARD) &&
> (env->eflags & IF_MASK)) &&
> !(cpu->interrupt_request & CPU_INTERRUPT_NMI)) {
> @@ -1450,7 +1450,7 @@ static int whpx_handle_halt(CPUState *cpu)
> cpu->halted = true;
> ret = 1;
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> return ret;
> }
> @@ -1472,7 +1472,7 @@ static void whpx_vcpu_pre_run(CPUState *cpu)
> memset(&new_int, 0, sizeof(new_int));
> memset(reg_values, 0, sizeof(reg_values));
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> /* Inject NMI */
> if (!vcpu->interruption_pending &&
> @@ -1563,7 +1563,7 @@ static void whpx_vcpu_pre_run(CPUState *cpu)
> reg_count += 1;
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> vcpu->ready_for_pic_interrupt = false;
>
> if (reg_count) {
> @@ -1590,9 +1590,9 @@ static void whpx_vcpu_post_run(CPUState *cpu)
> uint64_t tpr = vcpu->exit_ctx.VpContext.Cr8;
> if (vcpu->tpr != tpr) {
> vcpu->tpr = tpr;
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_set_apic_tpr(x86_cpu->apic_state, whpx_cr8_to_apic_tpr(vcpu->tpr));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> vcpu->interruption_pending =
> @@ -1652,7 +1652,7 @@ static int whpx_vcpu_run(CPUState *cpu)
> WhpxStepMode exclusive_step_mode = WHPX_STEP_NONE;
> int ret;
>
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
>
> if (whpx->running_cpus++ == 0) {
> /* Insert breakpoints into memory, update exception exit bitmap. */
> @@ -1690,7 +1690,7 @@ static int whpx_vcpu_run(CPUState *cpu)
> }
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> if (exclusive_step_mode != WHPX_STEP_NONE) {
> start_exclusive();
> @@ -2028,9 +2028,9 @@ static int whpx_vcpu_run(CPUState *cpu)
> error_report("WHPX: Unexpected VP exit code %d",
> vcpu->exit_ctx.ExitReason);
> whpx_get_registers(cpu);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> qemu_system_guest_panicked(cpu_get_crash_info(cpu));
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> break;
> }
>
> @@ -2055,7 +2055,7 @@ static int whpx_vcpu_run(CPUState *cpu)
> cpu_exec_end(cpu);
> }
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> current_cpu = cpu;
>
> if (--whpx->running_cpus == 0) {
> diff --git a/target/loongarch/csr_helper.c b/target/loongarch/csr_helper.c
> index 55341551a5..fa3f08335e 100644
> --- a/target/loongarch/csr_helper.c
> +++ b/target/loongarch/csr_helper.c
> @@ -89,9 +89,9 @@ target_ulong helper_csrwr_ticlr(CPULoongArchState *env, target_ulong val)
> int64_t old_v = 0;
>
> if (val & 0x1) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> loongarch_cpu_set_irq(cpu, IRQ_TIMER, 0);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> return old_v;
> }
> diff --git a/target/mips/kvm.c b/target/mips/kvm.c
> index e22e24ed97..7e2bac9a84 100644
> --- a/target/mips/kvm.c
> +++ b/target/mips/kvm.c
> @@ -138,7 +138,7 @@ void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run)
> int r;
> struct kvm_mips_interrupt intr;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> if ((cs->interrupt_request & CPU_INTERRUPT_HARD) &&
> cpu_mips_io_interrupts_pending(cpu)) {
> @@ -151,7 +151,7 @@ void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run)
> }
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> MemTxAttrs kvm_arch_post_run(CPUState *cs, struct kvm_run *run)
> diff --git a/target/mips/tcg/sysemu/cp0_helper.c b/target/mips/tcg/sysemu/cp0_helper.c
> index d349548743..fe87b72a2c 100644
> --- a/target/mips/tcg/sysemu/cp0_helper.c
> +++ b/target/mips/tcg/sysemu/cp0_helper.c
> @@ -59,9 +59,9 @@ static inline void mips_vpe_wake(MIPSCPU *c)
> * because there might be other conditions that state that c should
> * be sleeping.
> */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_interrupt(CPU(c), CPU_INTERRUPT_WAKE);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> static inline void mips_vpe_sleep(MIPSCPU *cpu)
> diff --git a/target/openrisc/sys_helper.c b/target/openrisc/sys_helper.c
> index 782a5751b7..1e9a55cec1 100644
> --- a/target/openrisc/sys_helper.c
> +++ b/target/openrisc/sys_helper.c
> @@ -160,20 +160,20 @@ void HELPER(mtspr)(CPUOpenRISCState *env, target_ulong spr, target_ulong rb)
> break;
> case TO_SPR(9, 0): /* PICMR */
> env->picmr = rb;
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> if (env->picsr & env->picmr) {
> cpu_interrupt(cs, CPU_INTERRUPT_HARD);
> } else {
> cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD);
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> break;
> case TO_SPR(9, 2): /* PICSR */
> env->picsr &= ~rb;
> break;
> case TO_SPR(10, 0): /* TTMR */
> {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> if ((env->ttmr & TTMR_M) ^ (rb & TTMR_M)) {
> switch (rb & TTMR_M) {
> case TIMER_NONE:
> @@ -198,15 +198,15 @@ void HELPER(mtspr)(CPUOpenRISCState *env, target_ulong spr, target_ulong rb)
> cs->interrupt_request &= ~CPU_INTERRUPT_TIMER;
> }
> cpu_openrisc_timer_update(cpu);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> break;
>
> case TO_SPR(10, 1): /* TTCR */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_openrisc_count_set(cpu, rb);
> cpu_openrisc_timer_update(cpu);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> break;
> }
> #endif
> @@ -347,9 +347,9 @@ target_ulong HELPER(mfspr)(CPUOpenRISCState *env, target_ulong rd,
> return env->ttmr;
>
> case TO_SPR(10, 1): /* TTCR */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_openrisc_count_update(cpu);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return cpu_openrisc_count_get(cpu);
> }
> #endif
> diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
> index a42743a3e0..0a1c942831 100644
> --- a/target/ppc/excp_helper.c
> +++ b/target/ppc/excp_helper.c
> @@ -3056,7 +3056,7 @@ void helper_msgsnd(target_ulong rb)
> return;
> }
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> CPU_FOREACH(cs) {
> PowerPCCPU *cpu = POWERPC_CPU(cs);
> CPUPPCState *cenv = &cpu->env;
> @@ -3065,7 +3065,7 @@ void helper_msgsnd(target_ulong rb)
> ppc_set_irq(cpu, irq, 1);
> }
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> /* Server Processor Control */
> @@ -3093,7 +3093,7 @@ static void book3s_msgsnd_common(int pir, int irq)
> {
> CPUState *cs;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> CPU_FOREACH(cs) {
> PowerPCCPU *cpu = POWERPC_CPU(cs);
> CPUPPCState *cenv = &cpu->env;
> @@ -3103,7 +3103,7 @@ static void book3s_msgsnd_common(int pir, int irq)
> ppc_set_irq(cpu, irq, 1);
> }
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void helper_book3s_msgsnd(target_ulong rb)
> @@ -3157,14 +3157,14 @@ void helper_book3s_msgsndp(CPUPPCState *env, target_ulong rb)
> }
>
> /* Does iothread need to be locked for walking CPU list? */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> THREAD_SIBLING_FOREACH(cs, ccs) {
> PowerPCCPU *ccpu = POWERPC_CPU(ccs);
> uint32_t thread_id = ppc_cpu_tir(ccpu);
>
> if (ttir == thread_id) {
> ppc_set_irq(ccpu, PPC_INTERRUPT_DOORBELL, 1);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return;
> }
> }
> diff --git a/target/ppc/kvm.c b/target/ppc/kvm.c
> index 9b1abe2fc4..132834505c 100644
> --- a/target/ppc/kvm.c
> +++ b/target/ppc/kvm.c
> @@ -1656,7 +1656,7 @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
> CPUPPCState *env = &cpu->env;
> int ret;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> switch (run->exit_reason) {
> case KVM_EXIT_DCR:
> @@ -1715,7 +1715,7 @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
> break;
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return ret;
> }
>
> diff --git a/target/ppc/misc_helper.c b/target/ppc/misc_helper.c
> index a05bdf78c9..41ef14bf24 100644
> --- a/target/ppc/misc_helper.c
> +++ b/target/ppc/misc_helper.c
> @@ -238,7 +238,7 @@ target_ulong helper_load_dpdes(CPUPPCState *env)
> return dpdes;
> }
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> THREAD_SIBLING_FOREACH(cs, ccs) {
> PowerPCCPU *ccpu = POWERPC_CPU(ccs);
> CPUPPCState *cenv = &ccpu->env;
> @@ -248,7 +248,7 @@ target_ulong helper_load_dpdes(CPUPPCState *env)
> dpdes |= (0x1 << thread_id);
> }
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> return dpdes;
> }
> @@ -278,14 +278,14 @@ void helper_store_dpdes(CPUPPCState *env, target_ulong val)
> }
>
> /* Does iothread need to be locked for walking CPU list? */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> THREAD_SIBLING_FOREACH(cs, ccs) {
> PowerPCCPU *ccpu = POWERPC_CPU(ccs);
> uint32_t thread_id = ppc_cpu_tir(ccpu);
>
> ppc_set_irq(cpu, PPC_INTERRUPT_DOORBELL, val & (0x1 << thread_id));
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> #endif /* defined(TARGET_PPC64) */
>
> diff --git a/target/ppc/timebase_helper.c b/target/ppc/timebase_helper.c
> index 08a6b47ee0..4cc0572fad 100644
> --- a/target/ppc/timebase_helper.c
> +++ b/target/ppc/timebase_helper.c
> @@ -173,9 +173,9 @@ target_ulong helper_load_dcr(CPUPPCState *env, target_ulong dcrn)
> } else {
> int ret;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ret = ppc_dcr_read(env->dcr_env, (uint32_t)dcrn, &val);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> if (unlikely(ret != 0)) {
> qemu_log_mask(LOG_GUEST_ERROR, "DCR read error %d %03x\n",
> (uint32_t)dcrn, (uint32_t)dcrn);
> @@ -196,9 +196,9 @@ void helper_store_dcr(CPUPPCState *env, target_ulong dcrn, target_ulong val)
> POWERPC_EXCP_INVAL_INVAL, GETPC());
> } else {
> int ret;
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ret = ppc_dcr_write(env->dcr_env, (uint32_t)dcrn, (uint32_t)val);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> if (unlikely(ret != 0)) {
> qemu_log_mask(LOG_GUEST_ERROR, "DCR write error %d %03x\n",
> (uint32_t)dcrn, (uint32_t)dcrn);
> diff --git a/target/s390x/kvm/kvm.c b/target/s390x/kvm/kvm.c
> index 33ab3551f4..27533d0401 100644
> --- a/target/s390x/kvm/kvm.c
> +++ b/target/s390x/kvm/kvm.c
> @@ -1923,7 +1923,7 @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
> S390CPU *cpu = S390_CPU(cs);
> int ret = 0;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> kvm_cpu_synchronize_state(cs);
>
> @@ -1947,7 +1947,7 @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
> fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason);
> break;
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> if (ret == 0) {
> ret = EXCP_INTERRUPT;
> diff --git a/target/s390x/tcg/misc_helper.c b/target/s390x/tcg/misc_helper.c
> index 6aa7907438..4be69c5ae8 100644
> --- a/target/s390x/tcg/misc_helper.c
> +++ b/target/s390x/tcg/misc_helper.c
> @@ -101,9 +101,9 @@ uint64_t HELPER(stck)(CPUS390XState *env)
> /* SCLP service call */
> uint32_t HELPER(servc)(CPUS390XState *env, uint64_t r1, uint64_t r2)
> {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> int r = sclp_service_call(env_archcpu(env), r1, r2);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> if (r < 0) {
> tcg_s390_program_interrupt(env, -r, GETPC());
> }
> @@ -117,9 +117,9 @@ void HELPER(diag)(CPUS390XState *env, uint32_t r1, uint32_t r3, uint32_t num)
> switch (num) {
> case 0x500:
> /* KVM hypercall */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> r = s390_virtio_hypercall(env);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> break;
> case 0x44:
> /* yield */
> @@ -127,9 +127,9 @@ void HELPER(diag)(CPUS390XState *env, uint32_t r1, uint32_t r3, uint32_t num)
> break;
> case 0x308:
> /* ipl */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> handle_diag_308(env, r1, r3, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> r = 0;
> break;
> case 0x288:
> @@ -185,7 +185,7 @@ static void update_ckc_timer(CPUS390XState *env)
>
> /* stop the timer and remove pending CKC IRQs */
> timer_del(env->tod_timer);
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
> env->pending_int &= ~INTERRUPT_EXT_CLOCK_COMPARATOR;
>
> /* the tod has to exceed the ckc, this can never happen if ckc is all 1's */
> @@ -207,9 +207,9 @@ void HELPER(sckc)(CPUS390XState *env, uint64_t ckc)
> {
> env->ckc = ckc;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> update_ckc_timer(env);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void tcg_s390_tod_updated(CPUState *cs, run_on_cpu_data opaque)
> @@ -229,9 +229,9 @@ uint32_t HELPER(sck)(CPUS390XState *env, uint64_t tod_low)
> .low = tod_low,
> };
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> tdc->set(td, &tod, &error_abort);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return 0;
> }
>
> @@ -421,9 +421,9 @@ uint32_t HELPER(sigp)(CPUS390XState *env, uint64_t order_code, uint32_t r1,
> int cc;
>
> /* TODO: needed to inject interrupts - push further down */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cc = handle_sigp(env, order_code & SIGP_ORDER_MASK, r1, r3);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> return cc;
> }
> @@ -433,92 +433,92 @@ uint32_t HELPER(sigp)(CPUS390XState *env, uint64_t order_code, uint32_t r1,
> void HELPER(xsch)(CPUS390XState *env, uint64_t r1)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_xsch(cpu, r1, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(csch)(CPUS390XState *env, uint64_t r1)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_csch(cpu, r1, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(hsch)(CPUS390XState *env, uint64_t r1)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_hsch(cpu, r1, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(msch)(CPUS390XState *env, uint64_t r1, uint64_t inst)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_msch(cpu, r1, inst >> 16, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(rchp)(CPUS390XState *env, uint64_t r1)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_rchp(cpu, r1, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(rsch)(CPUS390XState *env, uint64_t r1)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_rsch(cpu, r1, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(sal)(CPUS390XState *env, uint64_t r1)
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_sal(cpu, r1, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(schm)(CPUS390XState *env, uint64_t r1, uint64_t r2, uint64_t inst)
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_schm(cpu, r1, r2, inst >> 16, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(ssch)(CPUS390XState *env, uint64_t r1, uint64_t inst)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_ssch(cpu, r1, inst >> 16, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(stcrw)(CPUS390XState *env, uint64_t inst)
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_stcrw(cpu, inst >> 16, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(stsch)(CPUS390XState *env, uint64_t r1, uint64_t inst)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_stsch(cpu, r1, inst >> 16, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr)
> @@ -533,10 +533,10 @@ uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr)
> tcg_s390_program_interrupt(env, PGM_SPECIFICATION, ra);
> }
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> io = qemu_s390_flic_dequeue_io(flic, env->cregs[6]);
> if (!io) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return 0;
> }
>
> @@ -554,7 +554,7 @@ uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr)
> if (s390_cpu_virt_mem_write(cpu, addr, 0, &intc, sizeof(intc))) {
> /* writing failed, reinject and properly clean up */
> s390_io_interrupt(io->id, io->nr, io->parm, io->word);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> g_free(io);
> s390_cpu_virt_mem_handle_exc(cpu, ra);
> return 0;
> @@ -570,24 +570,24 @@ uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr)
> }
>
> g_free(io);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return 1;
> }
>
> void HELPER(tsch)(CPUS390XState *env, uint64_t r1, uint64_t inst)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_tsch(cpu, r1, inst >> 16, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(chsc)(CPUS390XState *env, uint64_t inst)
> {
> S390CPU *cpu = env_archcpu(env);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> ioinst_handle_chsc(cpu, inst >> 16, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> #endif
>
> @@ -726,27 +726,27 @@ void HELPER(clp)(CPUS390XState *env, uint32_t r2)
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> clp_service_call(cpu, r2, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(pcilg)(CPUS390XState *env, uint32_t r1, uint32_t r2)
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> pcilg_service_call(cpu, r1, r2, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(pcistg)(CPUS390XState *env, uint32_t r1, uint32_t r2)
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> pcistg_service_call(cpu, r1, r2, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(stpcifc)(CPUS390XState *env, uint32_t r1, uint64_t fiba,
> @@ -754,9 +754,9 @@ void HELPER(stpcifc)(CPUS390XState *env, uint32_t r1, uint64_t fiba,
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> stpcifc_service_call(cpu, r1, fiba, ar, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(sic)(CPUS390XState *env, uint64_t r1, uint64_t r3)
> @@ -764,9 +764,9 @@ void HELPER(sic)(CPUS390XState *env, uint64_t r1, uint64_t r3)
> S390CPU *cpu = env_archcpu(env);
> int r;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> r = css_do_sic(cpu, (r3 >> 27) & 0x7, r1 & 0xffff);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> /* css_do_sic() may actually return a PGM_xxx value to inject */
> if (r) {
> tcg_s390_program_interrupt(env, -r, GETPC());
> @@ -777,9 +777,9 @@ void HELPER(rpcit)(CPUS390XState *env, uint32_t r1, uint32_t r2)
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> rpcit_service_call(cpu, r1, r2, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(pcistb)(CPUS390XState *env, uint32_t r1, uint32_t r3,
> @@ -787,9 +787,9 @@ void HELPER(pcistb)(CPUS390XState *env, uint32_t r1, uint32_t r3,
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> pcistb_service_call(cpu, r1, r3, gaddr, ar, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(mpcifc)(CPUS390XState *env, uint32_t r1, uint64_t fiba,
> @@ -797,8 +797,8 @@ void HELPER(mpcifc)(CPUS390XState *env, uint32_t r1, uint64_t fiba,
> {
> S390CPU *cpu = env_archcpu(env);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> mpcifc_service_call(cpu, r1, fiba, ar, GETPC());
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> #endif
> diff --git a/target/sparc/int32_helper.c b/target/sparc/int32_helper.c
> index 1563613582..3fd28a04e7 100644
> --- a/target/sparc/int32_helper.c
> +++ b/target/sparc/int32_helper.c
> @@ -70,7 +70,7 @@ void cpu_check_irqs(CPUSPARCState *env)
> CPUState *cs;
>
> /* We should be holding the BQL before we mess with IRQs */
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
>
> if (env->pil_in && (env->interrupt_index == 0 ||
> (env->interrupt_index & ~15) == TT_EXTINT)) {
> diff --git a/target/sparc/int64_helper.c b/target/sparc/int64_helper.c
> index 1b4155f5f3..dacbbf6b5b 100644
> --- a/target/sparc/int64_helper.c
> +++ b/target/sparc/int64_helper.c
> @@ -69,7 +69,7 @@ void cpu_check_irqs(CPUSPARCState *env)
> (env->softint & ~(SOFTINT_TIMER | SOFTINT_STIMER));
>
> /* We should be holding the BQL before we mess with IRQs */
> - g_assert(qemu_mutex_iothread_locked());
> + g_assert(qemu_bql_locked());
>
> /* TT_IVEC has a higher priority (16) than TT_EXTINT (31..17) */
> if (env->ivec_status & 0x20) {
> @@ -267,9 +267,9 @@ static bool do_modify_softint(CPUSPARCState *env, uint32_t value)
> env->softint = value;
> #if !defined(CONFIG_USER_ONLY)
> if (cpu_interrupts_enabled(env)) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_check_irqs(env);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> #endif
> return true;
> diff --git a/target/sparc/win_helper.c b/target/sparc/win_helper.c
> index 16d1c70fe7..ba666ec50e 100644
> --- a/target/sparc/win_helper.c
> +++ b/target/sparc/win_helper.c
> @@ -179,9 +179,9 @@ void helper_wrpsr(CPUSPARCState *env, target_ulong new_psr)
> cpu_raise_exception_ra(env, TT_ILL_INSN, GETPC());
> } else {
> /* cpu_put_psr may trigger interrupts, hence BQL */
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_put_psr(env, new_psr);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> }
>
> @@ -407,9 +407,9 @@ void helper_wrpstate(CPUSPARCState *env, target_ulong new_state)
>
> #if !defined(CONFIG_USER_ONLY)
> if (cpu_interrupts_enabled(env)) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_check_irqs(env);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> #endif
> }
> @@ -422,9 +422,9 @@ void helper_wrpil(CPUSPARCState *env, target_ulong new_pil)
> env->psrpil = new_pil;
>
> if (cpu_interrupts_enabled(env)) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_check_irqs(env);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> #endif
> }
> @@ -451,9 +451,9 @@ void helper_done(CPUSPARCState *env)
>
> #if !defined(CONFIG_USER_ONLY)
> if (cpu_interrupts_enabled(env)) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_check_irqs(env);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> #endif
> }
> @@ -480,9 +480,9 @@ void helper_retry(CPUSPARCState *env)
>
> #if !defined(CONFIG_USER_ONLY)
> if (cpu_interrupts_enabled(env)) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> cpu_check_irqs(env);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> #endif
> }
> diff --git a/target/xtensa/exc_helper.c b/target/xtensa/exc_helper.c
> index 91354884f7..405387decb 100644
> --- a/target/xtensa/exc_helper.c
> +++ b/target/xtensa/exc_helper.c
> @@ -105,9 +105,9 @@ void HELPER(waiti)(CPUXtensaState *env, uint32_t pc, uint32_t intlevel)
> env->sregs[PS] = (env->sregs[PS] & ~PS_INTLEVEL) |
> (intlevel << PS_INTLEVEL_SHIFT);
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> check_interrupts(env);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> if (env->pending_irq_level) {
> cpu_loop_exit(cpu);
> @@ -120,9 +120,9 @@ void HELPER(waiti)(CPUXtensaState *env, uint32_t pc, uint32_t intlevel)
>
> void HELPER(check_interrupts)(CPUXtensaState *env)
> {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> check_interrupts(env);
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> void HELPER(intset)(CPUXtensaState *env, uint32_t v)
> diff --git a/ui/spice-core.c b/ui/spice-core.c
> index db21db2c94..1d895d2fe8 100644
> --- a/ui/spice-core.c
> +++ b/ui/spice-core.c
> @@ -222,7 +222,7 @@ static void channel_event(int event, SpiceChannelEventInfo *info)
> */
> bool need_lock = !qemu_thread_is_self(&me);
> if (need_lock) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> if (info->flags & SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT) {
> @@ -260,7 +260,7 @@ static void channel_event(int event, SpiceChannelEventInfo *info)
> }
>
> if (need_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
> qapi_free_SpiceServerInfo(server);
> diff --git a/util/async.c b/util/async.c
> index 8f90ddc304..49d07b3c73 100644
> --- a/util/async.c
> +++ b/util/async.c
> @@ -741,7 +741,7 @@ AioContext *qemu_get_current_aio_context(void)
> if (ctx) {
> return ctx;
> }
> - if (qemu_mutex_iothread_locked()) {
> + if (qemu_bql_locked()) {
> /* Possibly in a vCPU thread. */
> return qemu_get_aio_context();
> }
> diff --git a/util/main-loop.c b/util/main-loop.c
> index 797b640c41..921fab3f32 100644
> --- a/util/main-loop.c
> +++ b/util/main-loop.c
> @@ -302,13 +302,13 @@ static int os_host_main_loop_wait(int64_t timeout)
>
> glib_pollfds_fill(&timeout);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> replay_mutex_unlock();
>
> ret = qemu_poll_ns((GPollFD *)gpollfds->data, gpollfds->len, timeout);
>
> replay_mutex_lock();
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> glib_pollfds_poll();
>
> @@ -517,7 +517,7 @@ static int os_host_main_loop_wait(int64_t timeout)
>
> poll_timeout_ns = qemu_soonest_timeout(poll_timeout_ns, timeout);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
>
> replay_mutex_unlock();
>
> @@ -525,7 +525,7 @@ static int os_host_main_loop_wait(int64_t timeout)
>
> replay_mutex_lock();
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> if (g_poll_ret > 0) {
> for (i = 0; i < w->num; i++) {
> w->revents[i] = poll_fds[n_poll_fds + i].revents;
> diff --git a/util/rcu.c b/util/rcu.c
> index e587bcc483..8331f24288 100644
> --- a/util/rcu.c
> +++ b/util/rcu.c
> @@ -283,24 +283,24 @@ static void *call_rcu_thread(void *opaque)
>
> qatomic_sub(&rcu_call_count, n);
> synchronize_rcu();
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> while (n > 0) {
> node = try_dequeue();
> while (!node) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> qemu_event_reset(&rcu_call_ready_event);
> node = try_dequeue();
> if (!node) {
> qemu_event_wait(&rcu_call_ready_event);
> node = try_dequeue();
> }
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> n--;
> node->func(node);
> }
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> abort();
> }
> @@ -337,13 +337,13 @@ static void drain_rcu_callback(struct rcu_head *node)
> void drain_call_rcu(void)
> {
> struct rcu_drain rcu_drain;
> - bool locked = qemu_mutex_iothread_locked();
> + bool locked = qemu_bql_locked();
>
> memset(&rcu_drain, 0, sizeof(struct rcu_drain));
> qemu_event_init(&rcu_drain.drain_complete_event, false);
>
> if (locked) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
>
>
> @@ -365,7 +365,7 @@ void drain_call_rcu(void)
> qatomic_dec(&in_drain_call_rcu);
>
> if (locked) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> }
> diff --git a/audio/coreaudio.m b/audio/coreaudio.m
> index 8cd129a27d..866d7a9436 100644
> --- a/audio/coreaudio.m
> +++ b/audio/coreaudio.m
> @@ -547,7 +547,7 @@ static OSStatus handle_voice_change(
> {
> coreaudioVoiceOut *core = in_client_data;
>
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
>
> if (core->outputDeviceID) {
> fini_out_device(core);
> @@ -557,7 +557,7 @@ static OSStatus handle_voice_change(
> update_device_playback_state(core);
> }
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> return 0;
> }
>
> diff --git a/memory_ldst.c.inc b/memory_ldst.c.inc
> index 84b868f294..cd8a629816 100644
> --- a/memory_ldst.c.inc
> +++ b/memory_ldst.c.inc
> @@ -61,7 +61,7 @@ static inline uint32_t glue(address_space_ldl_internal, SUFFIX)(ARG1_DECL,
> *result = r;
> }
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> RCU_READ_UNLOCK();
> return val;
> @@ -130,7 +130,7 @@ static inline uint64_t glue(address_space_ldq_internal, SUFFIX)(ARG1_DECL,
> *result = r;
> }
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> RCU_READ_UNLOCK();
> return val;
> @@ -186,7 +186,7 @@ uint8_t glue(address_space_ldub, SUFFIX)(ARG1_DECL,
> *result = r;
> }
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> RCU_READ_UNLOCK();
> return val;
> @@ -234,7 +234,7 @@ static inline uint16_t glue(address_space_lduw_internal, SUFFIX)(ARG1_DECL,
> *result = r;
> }
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> RCU_READ_UNLOCK();
> return val;
> @@ -295,7 +295,7 @@ void glue(address_space_stl_notdirty, SUFFIX)(ARG1_DECL,
> *result = r;
> }
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> RCU_READ_UNLOCK();
> }
> @@ -339,7 +339,7 @@ static inline void glue(address_space_stl_internal, SUFFIX)(ARG1_DECL,
> *result = r;
> }
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> RCU_READ_UNLOCK();
> }
> @@ -391,7 +391,7 @@ void glue(address_space_stb, SUFFIX)(ARG1_DECL,
> *result = r;
> }
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> RCU_READ_UNLOCK();
> }
> @@ -435,7 +435,7 @@ static inline void glue(address_space_stw_internal, SUFFIX)(ARG1_DECL,
> *result = r;
> }
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> RCU_READ_UNLOCK();
> }
> @@ -499,7 +499,7 @@ static void glue(address_space_stq_internal, SUFFIX)(ARG1_DECL,
> *result = r;
> }
> if (release_lock) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> RCU_READ_UNLOCK();
> }
> diff --git a/target/i386/hvf/README.md b/target/i386/hvf/README.md
> index 2d33477aca..679b93b630 100644
> --- a/target/i386/hvf/README.md
> +++ b/target/i386/hvf/README.md
> @@ -4,4 +4,4 @@ These sources (and ../hvf-all.c) are adapted from Veertu Inc's vdhh (Veertu Desk
>
> 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.
> 2. Removal of `apic_page` and hyperv-related functionality.
> -3. More relaxed use of `qemu_mutex_lock_iothread`.
> +3. More relaxed use of `qemu_bql_lock`.
> diff --git a/ui/cocoa.m b/ui/cocoa.m
> index cd069da696..8a7d0a6f0c 100644
> --- a/ui/cocoa.m
> +++ b/ui/cocoa.m
> @@ -117,29 +117,29 @@ static void cocoa_switch(DisplayChangeListener *dcl,
> typedef void (^CodeBlock)(void);
> typedef bool (^BoolCodeBlock)(void);
>
> -static void with_iothread_lock(CodeBlock block)
> +static void with_bql(CodeBlock block)
> {
> - bool locked = qemu_mutex_iothread_locked();
> + bool locked = qemu_bql_locked();
> if (!locked) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
> block();
> if (!locked) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> }
>
> -static bool bool_with_iothread_lock(BoolCodeBlock block)
> +static bool bool_with_bql(BoolCodeBlock block)
> {
> - bool locked = qemu_mutex_iothread_locked();
> + bool locked = qemu_bql_locked();
> bool val;
>
> if (!locked) {
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
> val = block();
> if (!locked) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> }
> return val;
> }
> @@ -605,7 +605,7 @@ - (void) updateUIInfo
> return;
> }
>
> - with_iothread_lock(^{
> + with_bql(^{
> [self updateUIInfoLocked];
> });
> }
> @@ -790,7 +790,7 @@ - (void) handleMonitorInput:(NSEvent *)event
>
> - (bool) handleEvent:(NSEvent *)event
> {
> - return bool_with_iothread_lock(^{
> + return bool_with_bql(^{
> return [self handleEventLocked:event];
> });
> }
> @@ -1182,7 +1182,7 @@ - (QEMUScreen) gscreen {return screen;}
> */
> - (void) raiseAllKeys
> {
> - with_iothread_lock(^{
> + with_bql(^{
> qkbd_state_lift_all_keys(kbd);
> });
> }
> @@ -1282,7 +1282,7 @@ - (void)applicationWillTerminate:(NSNotification *)aNotification
> {
> COCOA_DEBUG("QemuCocoaAppController: applicationWillTerminate\n");
>
> - with_iothread_lock(^{
> + with_bql(^{
> shutdown_action = SHUTDOWN_ACTION_POWEROFF;
> qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_UI);
> });
> @@ -1420,7 +1420,7 @@ - (void)displayConsole:(id)sender
> /* Pause the guest */
> - (void)pauseQEMU:(id)sender
> {
> - with_iothread_lock(^{
> + with_bql(^{
> qmp_stop(NULL);
> });
> [sender setEnabled: NO];
> @@ -1431,7 +1431,7 @@ - (void)pauseQEMU:(id)sender
> /* Resume running the guest operating system */
> - (void)resumeQEMU:(id) sender
> {
> - with_iothread_lock(^{
> + with_bql(^{
> qmp_cont(NULL);
> });
> [sender setEnabled: NO];
> @@ -1461,7 +1461,7 @@ - (void)removePause
> /* Restarts QEMU */
> - (void)restartQEMU:(id)sender
> {
> - with_iothread_lock(^{
> + with_bql(^{
> qmp_system_reset(NULL);
> });
> }
> @@ -1469,7 +1469,7 @@ - (void)restartQEMU:(id)sender
> /* Powers down QEMU */
> - (void)powerDownQEMU:(id)sender
> {
> - with_iothread_lock(^{
> + with_bql(^{
> qmp_system_powerdown(NULL);
> });
> }
> @@ -1488,7 +1488,7 @@ - (void)ejectDeviceMedia:(id)sender
> }
>
> __block Error *err = NULL;
> - with_iothread_lock(^{
> + with_bql(^{
> qmp_eject([drive cStringUsingEncoding: NSASCIIStringEncoding],
> NULL, false, false, &err);
> });
> @@ -1523,7 +1523,7 @@ - (void)changeDeviceMedia:(id)sender
> }
>
> __block Error *err = NULL;
> - with_iothread_lock(^{
> + with_bql(^{
> qmp_blockdev_change_medium([drive cStringUsingEncoding:
> NSASCIIStringEncoding],
> NULL,
> @@ -1605,7 +1605,7 @@ - (void)adjustSpeed:(id)sender
> // get the throttle percentage
> throttle_pct = [sender tag];
>
> - with_iothread_lock(^{
> + with_bql(^{
> cpu_throttle_set(throttle_pct);
> });
> COCOA_DEBUG("cpu throttling at %d%c\n", cpu_throttle_get_percentage(), '%');
> @@ -1819,7 +1819,7 @@ - (void)pasteboard:(NSPasteboard *)sender provideDataForType:(NSPasteboardType)t
> return;
> }
>
> - with_iothread_lock(^{
> + with_bql(^{
> QemuClipboardInfo *info = qemu_clipboard_info_ref(cbinfo);
> qemu_event_reset(&cbevent);
> qemu_clipboard_request(info, QEMU_CLIPBOARD_TYPE_TEXT);
> @@ -1827,9 +1827,9 @@ - (void)pasteboard:(NSPasteboard *)sender provideDataForType:(NSPasteboardType)t
> while (info == cbinfo &&
> info->types[QEMU_CLIPBOARD_TYPE_TEXT].available &&
> info->types[QEMU_CLIPBOARD_TYPE_TEXT].data == NULL) {
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> qemu_event_wait(&cbevent);
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> }
>
> if (info == cbinfo) {
> @@ -1927,9 +1927,9 @@ static void cocoa_clipboard_request(QemuClipboardInfo *info,
> int status;
>
> COCOA_DEBUG("Second thread: calling qemu_default_main()\n");
> - qemu_mutex_lock_iothread();
> + qemu_bql_lock();
> status = qemu_default_main();
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> COCOA_DEBUG("Second thread: qemu_default_main() returned, exiting\n");
> [cbowner release];
> exit(status);
> @@ -1941,7 +1941,7 @@ static int cocoa_main(void)
>
> COCOA_DEBUG("Entered %s()\n", __func__);
>
> - qemu_mutex_unlock_iothread();
> + qemu_bql_unlock();
> qemu_thread_create(&thread, "qemu_main", call_qemu_main,
> NULL, QEMU_THREAD_DETACHED);
>
next prev parent reply other threads:[~2023-12-01 9:40 UTC|newest]
Thread overview: 34+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-11-29 21:26 [PATCH 0/6] Make Big QEMU Lock naming consistent Stefan Hajnoczi
2023-11-29 21:26 ` [PATCH 1/6] system/cpus: rename qemu_mutex_lock_iothread() to qemu_bql_lock() Stefan Hajnoczi
2023-11-30 9:02 ` Paul Durrant
2023-11-30 12:20 ` Fabiano Rosas
2023-11-30 12:25 ` David Woodhouse
2023-11-30 12:57 ` Cédric Le Goater
2023-11-30 20:08 ` Peter Xu
2023-11-30 20:43 ` Stefan Hajnoczi
2023-11-30 20:56 ` Peter Xu
2023-11-30 21:41 ` BALATON Zoltan
2023-11-30 21:48 ` Eric Farman
2023-12-01 5:12 ` Harsh Prateek Bora [this message]
2023-12-07 11:44 ` Stefan Hajnoczi
2023-11-29 21:26 ` [PATCH 2/6] qemu/main-loop: rename QEMU_IOTHREAD_LOCK_GUARD to QEMU_BQL_LOCK_GUARD Stefan Hajnoczi
2023-11-30 9:03 ` Paul Durrant
2023-11-30 9:14 ` Ilya Leoshkevich
2023-11-30 20:27 ` Stefan Hajnoczi
2023-12-01 7:10 ` Harsh Prateek Bora
2023-11-30 12:26 ` David Woodhouse
2023-11-30 12:58 ` Cédric Le Goater
2023-11-29 21:26 ` [PATCH 3/6] qemu/main-loop: rename qemu_cond_wait_iothread() to qemu_cond_wait_bql() Stefan Hajnoczi
2023-11-30 13:19 ` Cédric Le Goater
2023-11-30 13:36 ` Philippe Mathieu-Daudé
2023-11-29 21:26 ` [PATCH 4/6] system/cpus: rename qemu_global_mutex to qemu_bql Stefan Hajnoczi
2023-11-30 13:20 ` Cédric Le Goater
2023-11-30 13:44 ` Philippe Mathieu-Daudé
2023-11-30 20:31 ` Stefan Hajnoczi
2023-11-29 21:26 ` [PATCH 5/6] Replace "iothread lock" with "BQL" in comments Stefan Hajnoczi
2023-11-30 13:47 ` Philippe Mathieu-Daudé
2023-11-30 20:36 ` Stefan Hajnoczi
2023-11-29 21:26 ` [PATCH 6/6] Rename "QEMU global mutex" to "BQL" in comments and docs Stefan Hajnoczi
2023-11-30 7:17 ` Markus Armbruster
2023-11-30 13:49 ` Philippe Mathieu-Daudé
2023-11-30 20:37 ` Stefan Hajnoczi
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=8f89fbbf-454b-c5e5-5e8f-46ea42ec20ed@linux.ibm.com \
--to=harshpb@linux.ibm.com \
--cc=agraf@csgraf.de \
--cc=akihiko.odaki@daynix.com \
--cc=aleksandar.rikalo@syrmia.com \
--cc=alex.bennee@linaro.org \
--cc=alistair.francis@wdc.com \
--cc=andrew.smirnov@gmail.com \
--cc=anthony.perard@citrix.com \
--cc=armbru@redhat.com \
--cc=atar4qemu@gmail.com \
--cc=aurelien@aurel32.net \
--cc=balaton@eik.bme.hu \
--cc=berrange@redhat.com \
--cc=bin.meng@windriver.com \
--cc=borntraeger@linux.ibm.com \
--cc=chenhuacai@kernel.org \
--cc=clg@kaod.org \
--cc=danielhb413@gmail.com \
--cc=david@gibson.dropbear.id.au \
--cc=david@redhat.com \
--cc=dirty@apple.com \
--cc=dwmw2@infradead.org \
--cc=eblake@redhat.com \
--cc=eduardo@habkost.net \
--cc=elena.ufimtseva@oracle.com \
--cc=fam@euphon.net \
--cc=farman@linux.ibm.com \
--cc=farosas@suse.de \
--cc=gaosong@loongson.cn \
--cc=hreitz@redhat.com \
--cc=iii@linux.ibm.com \
--cc=jag.raman@oracle.com \
--cc=jasowang@redhat.com \
--cc=jcd@tribudubois.net \
--cc=jcmvbkbc@gmail.com \
--cc=jiaxun.yang@flygoat.com \
--cc=jslaby@suse.cz \
--cc=jsnow@redhat.com \
--cc=kraxel@redhat.com \
--cc=kvm@vger.kernel.org \
--cc=kwolf@redhat.com \
--cc=leobras@redhat.com \
--cc=liwei1518@gmail.com \
--cc=marcandre.lureau@redhat.com \
--cc=marcel.apfelbaum@gmail.com \
--cc=mark.cave-ayland@ilande.co.uk \
--cc=michael.roth@amd.com \
--cc=mst@redhat.com \
--cc=mtosatti@redhat.com \
--cc=npiggin@gmail.com \
--cc=palmer@dabbelt.com \
--cc=pasic@linux.ibm.com \
--cc=paul@xen.org \
--cc=pavel.dovgaluk@ispras.ru \
--cc=pbonzini@redhat.com \
--cc=peter.maydell@linaro.org \
--cc=peterx@redhat.com \
--cc=philmd@linaro.org \
--cc=qemu-arm@nongnu.org \
--cc=qemu-block@nongnu.org \
--cc=qemu-devel@nongnu.org \
--cc=qemu-ppc@nongnu.org \
--cc=qemu-riscv@nongnu.org \
--cc=qemu-s390x@nongnu.org \
--cc=quintela@redhat.com \
--cc=rbolshakov@ddn.com \
--cc=reinoud@netbsd.org \
--cc=richard.henderson@linaro.org \
--cc=shorne@gmail.com \
--cc=sstabellini@kernel.org \
--cc=stefanha@redhat.com \
--cc=sunilmut@microsoft.com \
--cc=thuth@redhat.com \
--cc=vsementsov@yandex-team.ru \
--cc=xen-devel@lists.xenproject.org \
--cc=yong.huang@smartx.com \
--cc=zhanghailiang@xfusion.com \
--cc=zhiwei_liu@linux.alibaba.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.