The following changes since commit 9af638cc1f665712522608c5d6b8c03d8fa67666:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200504' into staging (2020-05-04 13:37:17 +0100)

https://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 08b689aa6b521964b8275dd7a2564aefa5d68129:

lockable: Replace locks with lock guard macros (2020-05-04 16:07:43 +0100)

v2:

* Fixed stray slirp submodule change [Peter]

Fixes for the lock guard macros, code conversions to the lock guard macros, and

support for selecting fuzzer targets with argv[0].

Alexander Bulekov (1):

fuzz: select fuzz target using executable name

Daniel Brodsky (2):

lockable: fix __COUNTER__ macro to be referenced properly

lockable: replaced locks with lock guard macros where appropriate

Simran Singhal (1):

lockable: Replace locks with lock guard macros

include/qemu/lockable.h | 7 +++---

include/qemu/rcu.h | 2 +-

block/iscsi.c | 7 ++----

block/nfs.c | 51 +++++++++++++++++++----------------------

cpus-common.c | 14 ++++-------

hw/display/qxl.c | 43 ++++++++++++++++------------------

hw/hyperv/hyperv.c | 15 ++++++------

hw/rdma/rdma_backend.c | 50 ++++++++++++++++++++--------------------

hw/rdma/rdma_rm.c | 3 +--

hw/vfio/platform.c | 5 ++--

migration/migration.c | 3 +--

migration/multifd.c | 8 +++----

migration/ram.c | 3 +--

monitor/misc.c | 4 +---

tests/qtest/fuzz/fuzz.c | 19 ++++++++-------

ui/spice-display.c | 14 +++++------

util/log.c | 4 ++--

util/qemu-timer.c | 17 +++++++-------

util/rcu.c | 8 +++----

util/thread-pool.c | 3 +--

util/vfio-helpers.c | 5 ++--

21 files changed, 132 insertions(+), 153 deletions(-)

2.25.3

From: Alexander Bulekov <alxndr@bu.edu>

The fuzzers are built into a binary (e.g. qemu-fuzz-i386). To select the

device to fuzz/fuzz target, we usually use the --fuzz-target= argument.

This commit allows the fuzz-target to be specified using the name of the

executable. If the executable name ends with -target-FUZZ_TARGET, then

we select the fuzz target based on this name, rather than the

--fuzz-target argument. This is useful for systems such as oss-fuzz

where we don't have control of the arguments passed to the fuzzer.

[Fixed incorrect indentation.

--Stefan]

Signed-off-by: Alexander Bulekov <alxndr@bu.edu>

Reviewed-by: Darren Kenny <darren.kenny@oracle.com>

Message-id: 20200421182230.6313-1-alxndr@bu.edu

tests/qtest/fuzz/fuzz.c | 19 +++++++++++--------

1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/tests/qtest/fuzz/fuzz.c b/tests/qtest/fuzz/fuzz.c

--- a/tests/qtest/fuzz/fuzz.c

+++ b/tests/qtest/fuzz/fuzz.c

@@ -XXX,XX +XXX,XX @@ static void usage(char *path)

printf(" * %s : %s\n", tmp->target->name,

tmp->target->description);

}

+ printf("Alternatively, add -target-FUZZ_TARGET to the executable name\n");

exit(0);

@@ -XXX,XX +XXX,XX @@ int LLVMFuzzerInitialize(int *argc, char ***argv, char ***envp)

module_call_init(MODULE_INIT_QOM);

module_call_init(MODULE_INIT_LIBQOS);

- if (*argc <= 1) {

+ target_name = strstr(**argv, "-target-");

+ if (target_name) { /* The binary name specifies the target */

+ target_name += strlen("-target-");

+ } else if (*argc > 1) { /* The target is specified as an argument */

+ target_name = (*argv)[1];

+ if (!strstr(target_name, "--fuzz-target=")) {

+ usage(**argv);

+ }

+ target_name += strlen("--fuzz-target=");

+ } else {

usage(**argv);

/* Identify the fuzz target */

- target_name = (*argv)[1];

- if (!strstr(target_name, "--fuzz-target=")) {

- usage(**argv);

- target_name += strlen("--fuzz-target=");

fuzz_target = fuzz_get_target(target_name);

if (!fuzz_target) {

usage(**argv);

2.25.3

From: Daniel Brodsky <dnbrdsky@gmail.com>

- ran regexp "qemu_mutex_lock\(.*\).*\n.*if" to find targets

- replaced result with QEMU_LOCK_GUARD if all unlocks at function end

- replaced result with WITH_QEMU_LOCK_GUARD if unlock not at end

Signed-off-by: Daniel Brodsky <dnbrdsky@gmail.com>

Reviewed-by: Juan Quintela <quintela@redhat.com>

Message-id: 20200404042108.389635-3-dnbrdsky@gmail.com

block/iscsi.c | 7 ++----

block/nfs.c | 51 ++++++++++++++++++++-----------------------

cpus-common.c | 14 +++++-------

hw/display/qxl.c | 43 +++++++++++++++++-------------------

hw/vfio/platform.c | 5 ++---

migration/migration.c | 3 +--

migration/multifd.c | 8 +++----

migration/ram.c | 3 +--

monitor/misc.c | 4 +---

ui/spice-display.c | 14 ++++++------

util/log.c | 4 ++--

util/qemu-timer.c | 17 +++++++--------

util/rcu.c | 8 +++----

util/thread-pool.c | 3 +--

util/vfio-helpers.c | 5 ++---

15 files changed, 83 insertions(+), 106 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c

index XXXXXXX..XXXXXXX 100644

--- a/block/iscsi.c

+++ b/block/iscsi.c

@@ -XXX,XX +XXX,XX @@ static void iscsi_nop_timed_event(void *opaque)

{

IscsiLun *iscsilun = opaque;

- qemu_mutex_lock(&iscsilun->mutex);

+ QEMU_LOCK_GUARD(&iscsilun->mutex);

if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) {

error_report("iSCSI: NOP timeout. Reconnecting...");

iscsilun->request_timed_out = true;

} else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) {

error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");

- goto out;

+ return;

}

timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);

iscsi_set_events(iscsilun);

-

-out:

- qemu_mutex_unlock(&iscsilun->mutex);

}

static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)

diff --git a/block/nfs.c b/block/nfs.c

index XXXXXXX..XXXXXXX 100644

--- a/block/nfs.c

+++ b/block/nfs.c

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn nfs_co_preadv(BlockDriverState *bs, uint64_t offset,

nfs_co_init_task(bs, &task);

task.iov = iov;

- qemu_mutex_lock(&client->mutex);

- if (nfs_pread_async(client->context, client->fh,

- offset, bytes, nfs_co_generic_cb, &task) != 0) {

- qemu_mutex_unlock(&client->mutex);

- return -ENOMEM;

- }

+ WITH_QEMU_LOCK_GUARD(&client->mutex) {

+ if (nfs_pread_async(client->context, client->fh,

+ offset, bytes, nfs_co_generic_cb, &task) != 0) {

+ return -ENOMEM;

+ }

- nfs_set_events(client);

- qemu_mutex_unlock(&client->mutex);

+ nfs_set_events(client);

+ }

while (!task.complete) {

qemu_coroutine_yield();

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn nfs_co_pwritev(BlockDriverState *bs, uint64_t offset,

buf = iov->iov[0].iov_base;

}

- qemu_mutex_lock(&client->mutex);

- if (nfs_pwrite_async(client->context, client->fh,

- offset, bytes, buf,

- nfs_co_generic_cb, &task) != 0) {

- qemu_mutex_unlock(&client->mutex);

- if (my_buffer) {

- g_free(buf);

+ WITH_QEMU_LOCK_GUARD(&client->mutex) {

+ if (nfs_pwrite_async(client->context, client->fh,

+ offset, bytes, buf,

+ nfs_co_generic_cb, &task) != 0) {

+ if (my_buffer) {

+ g_free(buf);

+ }

+ return -ENOMEM;

}

- return -ENOMEM;

- }

- nfs_set_events(client);

- qemu_mutex_unlock(&client->mutex);

+ nfs_set_events(client);

+ }

while (!task.complete) {

qemu_coroutine_yield();

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn nfs_co_flush(BlockDriverState *bs)

nfs_co_init_task(bs, &task);

- qemu_mutex_lock(&client->mutex);

- if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb,

- &task) != 0) {

- qemu_mutex_unlock(&client->mutex);

- return -ENOMEM;

- }

+ WITH_QEMU_LOCK_GUARD(&client->mutex) {

+ if (nfs_fsync_async(client->context, client->fh, nfs_co_generic_cb,

+ &task) != 0) {

+ return -ENOMEM;

+ }

- nfs_set_events(client);

- qemu_mutex_unlock(&client->mutex);

+ nfs_set_events(client);

+ }

while (!task.complete) {

qemu_coroutine_yield();

}

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

index XXXXXXX..XXXXXXX 100644

--- a/cpus-common.c

+++ b/cpus-common.c

#include "exec/cpu-common.h"

#include "hw/core/cpu.h"

#include "sysemu/cpus.h"

+#include "qemu/lockable.h"

static QemuMutex qemu_cpu_list_lock;

static QemuCond exclusive_cond;

@@ -XXX,XX +XXX,XX @@ static int cpu_get_free_index(void)

void cpu_list_add(CPUState *cpu)

{

- qemu_mutex_lock(&qemu_cpu_list_lock);

+ QEMU_LOCK_GUARD(&qemu_cpu_list_lock);

if (cpu->cpu_index == UNASSIGNED_CPU_INDEX) {

cpu->cpu_index = cpu_get_free_index();

assert(cpu->cpu_index != UNASSIGNED_CPU_INDEX);

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

assert(!cpu_index_auto_assigned);

}

QTAILQ_INSERT_TAIL_RCU(&cpus, cpu, node);

- qemu_mutex_unlock(&qemu_cpu_list_lock);

}

void cpu_list_remove(CPUState *cpu)

{

- qemu_mutex_lock(&qemu_cpu_list_lock);

+ QEMU_LOCK_GUARD(&qemu_cpu_list_lock);

if (!QTAILQ_IN_USE(cpu, node)) {

/* there is nothing to undo since cpu_exec_init() hasn't been called */

- qemu_mutex_unlock(&qemu_cpu_list_lock);

return;

}

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

QTAILQ_REMOVE_RCU(&cpus, cpu, node);

cpu->cpu_index = UNASSIGNED_CPU_INDEX;

- qemu_mutex_unlock(&qemu_cpu_list_lock);

}

struct qemu_work_item {

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

* see cpu->running == true, and it will kick the CPU.

if (unlikely(atomic_read(&pending_cpus))) {

- qemu_mutex_lock(&qemu_cpu_list_lock);

+ QEMU_LOCK_GUARD(&qemu_cpu_list_lock);

if (!cpu->has_waiter) {

/* Not counted in pending_cpus, let the exclusive item

* run. Since we have the lock, just set cpu->running to true

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

* waiter at cpu_exec_end.

*/

}

- qemu_mutex_unlock(&qemu_cpu_list_lock);

}

}

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

* next cpu_exec_start.

*/

if (unlikely(atomic_read(&pending_cpus))) {

- qemu_mutex_lock(&qemu_cpu_list_lock);

+ QEMU_LOCK_GUARD(&qemu_cpu_list_lock);

if (cpu->has_waiter) {

cpu->has_waiter = false;

atomic_set(&pending_cpus, pending_cpus - 1);

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

qemu_cond_signal(&exclusive_cond);

}

}

- qemu_mutex_unlock(&qemu_cpu_list_lock);

}

}

diff --git a/hw/display/qxl.c b/hw/display/qxl.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/display/qxl.c

+++ b/hw/display/qxl.c

@@ -XXX,XX +XXX,XX @@ static int qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext)

cmd->u.surface_create.stride);

return 1;

}

- qemu_mutex_lock(&qxl->track_lock);

- if (cmd->type == QXL_SURFACE_CMD_CREATE) {

- qxl->guest_surfaces.cmds[id] = ext->cmd.data;

- qxl->guest_surfaces.count++;

- if (qxl->guest_surfaces.max < qxl->guest_surfaces.count)

- qxl->guest_surfaces.max = qxl->guest_surfaces.count;

+ WITH_QEMU_LOCK_GUARD(&qxl->track_lock) {

+ if (cmd->type == QXL_SURFACE_CMD_CREATE) {

+ qxl->guest_surfaces.cmds[id] = ext->cmd.data;

+ qxl->guest_surfaces.count++;

+ if (qxl->guest_surfaces.max < qxl->guest_surfaces.count) {

+ qxl->guest_surfaces.max = qxl->guest_surfaces.count;

+ }

+ }

+ if (cmd->type == QXL_SURFACE_CMD_DESTROY) {

+ qxl->guest_surfaces.cmds[id] = 0;

+ qxl->guest_surfaces.count--;

+ }

}

- if (cmd->type == QXL_SURFACE_CMD_DESTROY) {

- qxl->guest_surfaces.cmds[id] = 0;

- qxl->guest_surfaces.count--;

- }

- qemu_mutex_unlock(&qxl->track_lock);

break;

}

case QXL_CMD_CURSOR:

@@ -XXX,XX +XXX,XX @@ static void interface_update_area_complete(QXLInstance *sin,

int i;

int qxl_i;

- qemu_mutex_lock(&qxl->ssd.lock);

+ QEMU_LOCK_GUARD(&qxl->ssd.lock);

if (surface_id != 0 || !num_updated_rects ||

!qxl->render_update_cookie_num) {

- qemu_mutex_unlock(&qxl->ssd.lock);

return;

}

trace_qxl_interface_update_area_complete(qxl->id, surface_id, dirty->left,

@@ -XXX,XX +XXX,XX @@ static void interface_update_area_complete(QXLInstance *sin,

* Don't bother copying or scheduling the bh since we will flip

* the whole area anyway on completion of the update_area async call

*/

- qemu_mutex_unlock(&qxl->ssd.lock);

return;

}

qxl_i = qxl->num_dirty_rects;

@@ -XXX,XX +XXX,XX @@ static void interface_update_area_complete(QXLInstance *sin,

trace_qxl_interface_update_area_complete_schedule_bh(qxl->id,

qxl->num_dirty_rects);

qemu_bh_schedule(qxl->update_area_bh);

- qemu_mutex_unlock(&qxl->ssd.lock);

}

/* called from spice server thread context only */

@@ -XXX,XX +XXX,XX @@ static void ioport_write(void *opaque, hwaddr addr,

case QXL_IO_MONITORS_CONFIG_ASYNC:

async_common:

async = QXL_ASYNC;

- qemu_mutex_lock(&d->async_lock);

- if (d->current_async != QXL_UNDEFINED_IO) {

- qxl_set_guest_bug(d, "%d async started before last (%d) complete",

- io_port, d->current_async);

- qemu_mutex_unlock(&d->async_lock);

- return;

+ WITH_QEMU_LOCK_GUARD(&d->async_lock) {

+ if (d->current_async != QXL_UNDEFINED_IO) {

+ qxl_set_guest_bug(d, "%d async started before last (%d) complete",

+ io_port, d->current_async);

+ return;

+ }

+ d->current_async = orig_io_port;

}

- d->current_async = orig_io_port;

- qemu_mutex_unlock(&d->async_lock);

break;

default:

break;

diff --git a/hw/vfio/platform.c b/hw/vfio/platform.c

index XXXXXXX..XXXXXXX 100644

--- a/hw/vfio/platform.c

+++ b/hw/vfio/platform.c

#include "hw/vfio/vfio-platform.h"

#include "migration/vmstate.h"

#include "qemu/error-report.h"

+#include "qemu/lockable.h"

#include "qemu/main-loop.h"

#include "qemu/module.h"

#include "qemu/range.h"

@@ -XXX,XX +XXX,XX @@ static void vfio_intp_interrupt(VFIOINTp *intp)

VFIOPlatformDevice *vdev = intp->vdev;

bool delay_handling = false;

- qemu_mutex_lock(&vdev->intp_mutex);

+ QEMU_LOCK_GUARD(&vdev->intp_mutex);

if (intp->state == VFIO_IRQ_INACTIVE) {

QLIST_FOREACH(tmp, &vdev->intp_list, next) {

if (tmp->state == VFIO_IRQ_ACTIVE ||

@@ -XXX,XX +XXX,XX @@ static void vfio_intp_interrupt(VFIOINTp *intp)

QSIMPLEQ_INSERT_TAIL(&vdev->pending_intp_queue,

intp, pqnext);

ret = event_notifier_test_and_clear(intp->interrupt);

- qemu_mutex_unlock(&vdev->intp_mutex);

return;

}

@@ -XXX,XX +XXX,XX @@ static void vfio_intp_interrupt(VFIOINTp *intp)

qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +

vdev->mmap_timeout);

}

- qemu_mutex_unlock(&vdev->intp_mutex);

}

/**

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

index XXXXXXX..XXXXXXX 100644

--- a/migration/migration.c

+++ b/migration/migration.c

@@ -XXX,XX +XXX,XX @@ static void migrate_fd_cleanup_bh(void *opaque)

void migrate_set_error(MigrationState *s, const Error *error)

{

- qemu_mutex_lock(&s->error_mutex);

+ QEMU_LOCK_GUARD(&s->error_mutex);

if (!s->error) {

s->error = error_copy(error);

}

- qemu_mutex_unlock(&s->error_mutex);

}

void migrate_fd_error(MigrationState *s, const Error *error)

diff --git a/migration/multifd.c b/migration/multifd.c

index XXXXXXX..XXXXXXX 100644

--- a/migration/multifd.c

+++ b/migration/multifd.c

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

for (i = 0; i < migrate_multifd_channels(); i++) {

MultiFDRecvParams *p = &multifd_recv_state->params[i];

- qemu_mutex_lock(&p->mutex);

- if (multifd_recv_state->packet_num < p->packet_num) {

- multifd_recv_state->packet_num = p->packet_num;

+ WITH_QEMU_LOCK_GUARD(&p->mutex) {

+ if (multifd_recv_state->packet_num < p->packet_num) {

+ multifd_recv_state->packet_num = p->packet_num;

+ }

}

- qemu_mutex_unlock(&p->mutex);

trace_multifd_recv_sync_main_signal(p->id);

qemu_sem_post(&p->sem_sync);

}

diff --git a/migration/ram.c b/migration/ram.c

index XXXXXXX..XXXXXXX 100644

--- a/migration/ram.c

+++ b/migration/ram.c

@@ -XXX,XX +XXX,XX @@ static RAMBlock *unqueue_page(RAMState *rs, ram_addr_t *offset)

return NULL;

}

- qemu_mutex_lock(&rs->src_page_req_mutex);

+ QEMU_LOCK_GUARD(&rs->src_page_req_mutex);

if (!QSIMPLEQ_EMPTY(&rs->src_page_requests)) {

struct RAMSrcPageRequest *entry =

QSIMPLEQ_FIRST(&rs->src_page_requests);

@@ -XXX,XX +XXX,XX @@ static RAMBlock *unqueue_page(RAMState *rs, ram_addr_t *offset)

migration_consume_urgent_request();

}

}

- qemu_mutex_unlock(&rs->src_page_req_mutex);

return block;

}

diff --git a/monitor/misc.c b/monitor/misc.c

index XXXXXXX..XXXXXXX 100644

--- a/monitor/misc.c

+++ b/monitor/misc.c

@@ -XXX,XX +XXX,XX @@ AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,

MonFdsetFd *mon_fdset_fd;

AddfdInfo *fdinfo;

- qemu_mutex_lock(&mon_fdsets_lock);

+ QEMU_LOCK_GUARD(&mon_fdsets_lock);

if (has_fdset_id) {

QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {

/* Break if match found or match impossible due to ordering by ID */

@@ -XXX,XX +XXX,XX @@ AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,

if (fdset_id < 0) {

error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",

"a non-negative value");

- qemu_mutex_unlock(&mon_fdsets_lock);

return NULL;

}

/* Use specified fdset ID */

@@ -XXX,XX +XXX,XX @@ AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,

fdinfo->fdset_id = mon_fdset->id;

fdinfo->fd = mon_fdset_fd->fd;

- qemu_mutex_unlock(&mon_fdsets_lock);

return fdinfo;

}

diff --git a/ui/spice-display.c b/ui/spice-display.c

index XXXXXXX..XXXXXXX 100644

--- a/ui/spice-display.c

+++ b/ui/spice-display.c

#include "ui/qemu-spice.h"

#include "qemu/timer.h"

+#include "qemu/lockable.h"

#include "qemu/main-loop.h"

#include "qemu/option.h"

#include "qemu/queue.h"

@@ -XXX,XX +XXX,XX @@ void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)

{

graphic_hw_update(ssd->dcl.con);

- qemu_mutex_lock(&ssd->lock);

- if (QTAILQ_EMPTY(&ssd->updates) && ssd->ds) {

- qemu_spice_create_update(ssd);

- ssd->notify++;

+ WITH_QEMU_LOCK_GUARD(&ssd->lock) {

+ if (QTAILQ_EMPTY(&ssd->updates) && ssd->ds) {

+ qemu_spice_create_update(ssd);

+ ssd->notify++;

+ }

}

- qemu_mutex_unlock(&ssd->lock);

trace_qemu_spice_display_refresh(ssd->qxl.id, ssd->notify);

if (ssd->notify) {

@@ -XXX,XX +XXX,XX @@ static int interface_get_cursor_command(QXLInstance *sin, QXLCommandExt *ext)

SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);

int ret;

- qemu_mutex_lock(&ssd->lock);

+ QEMU_LOCK_GUARD(&ssd->lock);

if (ssd->ptr_define) {

*ext = ssd->ptr_define->ext;

ssd->ptr_define = NULL;

@@ -XXX,XX +XXX,XX @@ static int interface_get_cursor_command(QXLInstance *sin, QXLCommandExt *ext)

} else {

ret = false;

}

- qemu_mutex_unlock(&ssd->lock);

return ret;

}

diff --git a/util/log.c b/util/log.c

index XXXXXXX..XXXXXXX 100644

--- a/util/log.c

+++ b/util/log.c

#include "qemu/cutils.h"

#include "trace/control.h"

#include "qemu/thread.h"

+#include "qemu/lockable.h"

static char *logfilename;

static QemuMutex qemu_logfile_mutex;

@@ -XXX,XX +XXX,XX @@ void qemu_set_log(int log_flags)

if (qemu_loglevel && (!is_daemonized() || logfilename)) {

need_to_open_file = true;

}

- qemu_mutex_lock(&qemu_logfile_mutex);

+ QEMU_LOCK_GUARD(&qemu_logfile_mutex);

if (qemu_logfile && !need_to_open_file) {

logfile = qemu_logfile;

atomic_rcu_set(&qemu_logfile, NULL);

@@ -XXX,XX +XXX,XX @@ void qemu_set_log(int log_flags)

}

atomic_rcu_set(&qemu_logfile, logfile);

}

- qemu_mutex_unlock(&qemu_logfile_mutex);

}

void qemu_log_needs_buffers(void)

diff --git a/util/qemu-timer.c b/util/qemu-timer.c

index XXXXXXX..XXXXXXX 100644

--- a/util/qemu-timer.c

+++ b/util/qemu-timer.c

@@ -XXX,XX +XXX,XX @@ void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time)

QEMUTimerList *timer_list = ts->timer_list;

bool rearm;

- qemu_mutex_lock(&timer_list->active_timers_lock);

- if (ts->expire_time == -1 || ts->expire_time > expire_time) {

- if (ts->expire_time != -1) {

- timer_del_locked(timer_list, ts);

+ WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) {

+ if (ts->expire_time == -1 || ts->expire_time > expire_time) {

+ if (ts->expire_time != -1) {

+ timer_del_locked(timer_list, ts);

+ }

+ rearm = timer_mod_ns_locked(timer_list, ts, expire_time);

+ } else {

+ rearm = false;

}

- rearm = timer_mod_ns_locked(timer_list, ts, expire_time);

- } else {

- rearm = false;

}

- qemu_mutex_unlock(&timer_list->active_timers_lock);

-

if (rearm) {

timerlist_rearm(timer_list);

}

diff --git a/util/rcu.c b/util/rcu.c

index XXXXXXX..XXXXXXX 100644

--- a/util/rcu.c

+++ b/util/rcu.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/atomic.h"

#include "qemu/thread.h"

+#include "qemu/lockable.h"

#if defined(CONFIG_MALLOC_TRIM)

#include <malloc.h>

#endif

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

void synchronize_rcu(void)

- qemu_mutex_lock(&rcu_sync_lock);

+ QEMU_LOCK_GUARD(&rcu_sync_lock);

/* Write RCU-protected pointers before reading p_rcu_reader->ctr.

* Pairs with smp_mb_placeholder() in rcu_read_lock().

*/

smp_mb_global();

- qemu_mutex_lock(&rcu_registry_lock);

+ QEMU_LOCK_GUARD(&rcu_registry_lock);

if (!QLIST_EMPTY(&registry)) {

/* In either case, the atomic_mb_set below blocks stores that free

* old RCU-protected pointers.

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

wait_for_readers();

}

-

- qemu_mutex_unlock(&rcu_registry_lock);

- qemu_mutex_unlock(&rcu_sync_lock);

}

@@ -XXX,XX +XXX,XX @@ static void thread_pool_cancel(BlockAIOCB *acb)

trace_thread_pool_cancel(elem, elem->common.opaque);