The following changes since commit 27c94566379069fb8930bb1433dcffbf7df3203d:

Merge remote-tracking branch 'remotes/edgar/tags/edgar/xilinx-next-2020-04-30.for-upstream' into staging (2020-04-30 16:47:23 +0100)

for you to fetch changes up to cc1adc4488059ac16d4d2772a7aa7cd1323deeca:

lockable: Replace locks with lock guard macros (2020-05-01 09:19:25 +0100)

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 ++--

slirp | 2 +-

22 files changed, 133 insertions(+), 154 deletions(-)

--

2.25.3

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]

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

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

slirp | 2 +-

2 files changed, 12 insertions(+), 9 deletions(-)

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);

diff --git a/slirp b/slirp

index XXXXXXX..XXXXXXX 160000

--- a/slirp

+++ b/slirp

@@ -1 +1 @@

-Subproject commit 2faae0f778f818fadc873308f983289df697eb93

+Subproject commit 55ab21c9a36852915b81f1b41ebaf3b6509dd8ba

2.25.3

From: Daniel Brodsky <dnbrdsky@gmail.com>

- __COUNTER__ doesn't work with ## concat

- replaced ## with glue() macro so __COUNTER__ is evaluated

Fixes: 3284c3ddc4

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

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

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

include/qemu/rcu.h | 2 +-

2 files changed, 5 insertions(+), 4 deletions(-)

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

--- a/include/qemu/lockable.h

+++ b/include/qemu/lockable.h

@@ -XXX,XX +XXX,XX @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(QemuLockable, qemu_lockable_auto_unlock)

* }

#define WITH_QEMU_LOCK_GUARD(x) \

- WITH_QEMU_LOCK_GUARD_((x), qemu_lockable_auto##__COUNTER__)

+ WITH_QEMU_LOCK_GUARD_((x), glue(qemu_lockable_auto, __COUNTER__))

* QEMU_LOCK_GUARD - Lock an object until the end of the scope

@@ -XXX,XX +XXX,XX @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC(QemuLockable, qemu_lockable_auto_unlock)

* return; <-- mutex is automatically unlocked

* }

*/

-#define QEMU_LOCK_GUARD(x) \

- g_autoptr(QemuLockable) qemu_lockable_auto##__COUNTER__ = \

+#define QEMU_LOCK_GUARD(x) \

+ g_autoptr(QemuLockable) \

+ glue(qemu_lockable_auto, __COUNTER__) G_GNUC_UNUSED = \

qemu_lockable_auto_lock(QEMU_MAKE_LOCKABLE((x)))

#endif

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

--- a/include/qemu/rcu.h

+++ b/include/qemu/rcu.h

@@ -XXX,XX +XXX,XX @@ static inline void rcu_read_auto_unlock(RCUReadAuto *r)

G_DEFINE_AUTOPTR_CLEANUP_FUNC(RCUReadAuto, rcu_read_auto_unlock)

#define WITH_RCU_READ_LOCK_GUARD() \

- WITH_RCU_READ_LOCK_GUARD_(_rcu_read_auto##__COUNTER__)

+ WITH_RCU_READ_LOCK_GUARD_(glue(_rcu_read_auto, __COUNTER__))

#define WITH_RCU_READ_LOCK_GUARD_(var) \

for (g_autoptr(RCUReadAuto) var = rcu_read_auto_lock(); \

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

--- 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

--- 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

--- a/cpus-common.c

+++ b/cpus-common.c

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

#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);

2.25.3

From: Simran Singhal <singhalsimran0@gmail.com>

Replace manual lock()/unlock() calls with lock guard macros

(QEMU_LOCK_GUARD/WITH_QEMU_LOCK_GUARD).

Signed-off-by: Simran Singhal <singhalsimran0@gmail.com>

Reviewed-by: Yuval Shaia <yuval.shaia.ml@gmail.com>

Reviewed-by: Marcel Apfelbaum<marcel.apfelbaum@gmail.com>

Tested-by: Yuval Shaia <yuval.shaia.ml@gmail.com>

Message-id: 20200402065035.GA15477@simran-Inspiron-5558

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

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

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

3 files changed, 33 insertions(+), 35 deletions(-)

diff --git a/hw/hyperv/hyperv.c b/hw/hyperv/hyperv.c

--- a/hw/hyperv/hyperv.c

+++ b/hw/hyperv/hyperv.c

#include "sysemu/kvm.h"

#include "qemu/bitops.h"

#include "qemu/error-report.h"