Series comparison

-[PULL for-7.0 0/2] Block patches
+[PULL v2 0/4] Block patches
-The following changes since commit 15ef89d2a1a7b93845a6b09c2ee8e1979f6eb30b:
+The following changes since commit 9af638cc1f665712522608c5d6b8c03d8fa67666:
-  Update version for v7.0.0-rc1 release (2022-03-22 22:58:44 +0000)
+  Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200504' into staging (2020-05-04 13:37:17 +0100)
 are available in the Git repository at:
-  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
+  https://github.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 2539eade4f689eda7e9fe45486f18334bfbafaf0:
+for you to fetch changes up to 08b689aa6b521964b8275dd7a2564aefa5d68129:
-  hw: Fix misleading hexadecimal format (2022-03-24 10:38:42 +0000)
+  lockable: Replace locks with lock guard macros (2020-05-04 16:07:43 +0100)
 ----------------------------------------------------------------
 Pull request
-Philippe found cases where the 0x%d format string was used, leading to
+v2:
-misleading output. The patches look harmless and could save people time, so I
+ * Fixed stray slirp submodule change [Peter]
-think it's worth including them in 7.0.
 Fixes for the lock guard macros, code conversions to the lock guard macros, and
 support for selecting fuzzer targets with argv[0].
 ----------------------------------------------------------------
-Philippe Mathieu-Daudé (2):
+Alexander Bulekov (1):
-  block: Fix misleading hexadecimal format
+  fuzz: select fuzz target using executable name
   hw: Fix misleading hexadecimal format
- block/parallels-ext.c | 2 +-
+Daniel Brodsky (2):
- hw/i386/sgx.c         | 2 +-
+  lockable: fix __COUNTER__ macro to be referenced properly
- hw/i386/trace-events  | 6 +++---
+  lockable: replaced locks with lock guard macros where appropriate
- hw/misc/trace-events  | 4 ++--
- hw/scsi/trace-events  | 4 ++--
+Simran Singhal (1):
-files changed, 9 insertions(+), 9 deletions(-)
+  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 ++--
 files changed, 132 insertions(+), 153 deletions(-)
 --
-.35.1
+.25.3

-New patch
+[PULL v2 1/4] fuzz: select fuzz target using executable name
+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
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ tests/qtest/fuzz/fuzz.c | 19 +++++++++++--------
+file changed, 11 insertions(+), 8 deletions(-)
+diff --git a/tests/qtest/fuzz/fuzz.c b/tests/qtest/fuzz/fuzz.c
+index XXXXXXX..XXXXXXX 100644
+--- 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);
+--
+.25.3

-New patch
+[PULL v2 2/4] lockable: fix __COUNTER__ macro to be referenced properly
+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
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ include/qemu/lockable.h | 7 ++++---
+ include/qemu/rcu.h      | 2 +-
+files changed, 5 insertions(+), 4 deletions(-)
+diff --git a/include/qemu/lockable.h b/include/qemu/lockable.h
+index XXXXXXX..XXXXXXX 100644
+--- 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
+index XXXXXXX..XXXXXXX 100644
+--- 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(); \
+--
+.25.3

-[PULL for-7.0 1/2] block: Fix misleading hexadecimal format
+[PULL v2 3/4] lockable: replaced locks with lock guard macros where appropriate
-From: Philippe Mathieu-Daudé <f4bug@amsat.org>
+From: Daniel Brodsky <dnbrdsky@gmail.com>
-"0x%u" format is very misleading, replace by "0x%x".
+- 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
-Found running:
+Signed-off-by: Daniel Brodsky <dnbrdsky@gmail.com>
+Reviewed-by: Juan Quintela <quintela@redhat.com>
-  $ git grep -E '0x%[0-9]*([lL]*|" ?PRI)[dDuU]' block/
+Message-id: 20200404042108.389635-3-dnbrdsky@gmail.com
 Inspired-by: Richard Henderson <richard.henderson@linaro.org>
 Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Reviewed-by: Hanna Reitz <hreitz@redhat.com>
 Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
 Reviewed-by: Denis V. Lunev <den@openvz.org>
 Message-id: 20220323114718.58714-2-philippe.mathieu.daude@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/parallels-ext.c | 2 +-
+ block/iscsi.c         |  7 ++----
-file changed, 1 insertion(+), 1 deletion(-)
+ 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 ++---
 files changed, 83 insertions(+), 106 deletions(-)
-diff --git a/block/parallels-ext.c b/block/parallels-ext.c
+diff --git a/block/iscsi.c b/block/iscsi.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/parallels-ext.c
+--- a/block/iscsi.c
-+++ b/block/parallels-ext.c
++++ b/block/iscsi.c
-@@ -XXX,XX +XXX,XX @@ static int parallels_parse_format_extension(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ static void iscsi_nop_timed_event(void *opaque)
-             break;
+ {
+     IscsiLun *iscsilun = opaque;
-         default:
--            error_setg(errp, "Unknown feature: 0x%" PRIu64, fh.magic);
+-    qemu_mutex_lock(&iscsilun->mutex);
-+            error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
++    QEMU_LOCK_GUARD(&iscsilun->mutex);
-             goto fail;
+     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
@@ -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);
      }
  }
@@ -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
@@ -XXX,XX +XXX,XX @@
  #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
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #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
@@ -XXX,XX +XXX,XX @@
  #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/main-loop.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);
  }
 diff --git a/util/thread-pool.c b/util/thread-pool.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/thread-pool.c
 +++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ static void thread_pool_cancel(BlockAIOCB *acb)
      trace_thread_pool_cancel(elem, elem->common.opaque);
 -    qemu_mutex_lock(&pool->lock);
 +    QEMU_LOCK_GUARD(&pool->lock);
      if (elem->state == THREAD_QUEUED &&
          /* No thread has yet started working on elem. we can try to "steal"
           * the item from the worker if we can get a signal from the
@@ -XXX,XX +XXX,XX @@ static void thread_pool_cancel(BlockAIOCB *acb)
          elem->ret = -ECANCELED;
      }
 -    qemu_mutex_unlock(&pool->lock);
  }
  static AioContext *thread_pool_get_aio_context(BlockAIOCB *acb)
 diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/vfio-helpers.c
 +++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@
  #include "standard-headers/linux/pci_regs.h"
  #include "qemu/event_notifier.h"
  #include "qemu/vfio-helpers.h"
 +#include "qemu/lockable.h"
  #include "trace.h"
  #define QEMU_VFIO_DEBUG 0
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_reset_temporary(QEMUVFIOState *s)
          .size = QEMU_VFIO_IOVA_MAX - s->high_water_mark,
      };
      trace_qemu_vfio_dma_reset_temporary(s);
 -    qemu_mutex_lock(&s->lock);
 +    QEMU_LOCK_GUARD(&s->lock);
      if (ioctl(s->container, VFIO_IOMMU_UNMAP_DMA, &unmap)) {
          error_report("VFIO_UNMAP_DMA failed: %s", strerror(errno));
 -        qemu_mutex_unlock(&s->lock);
          return -errno;
      }
      s->high_water_mark = QEMU_VFIO_IOVA_MAX;
 -    qemu_mutex_unlock(&s->lock);
      return 0;
  }
 --
-.35.1
+.25.3

-[PULL for-7.0 2/2] hw: Fix misleading hexadecimal format
+[PULL v2 4/4] lockable: Replace locks with lock guard macros
-From: Philippe Mathieu-Daudé <f4bug@amsat.org>
+From: Simran Singhal <singhalsimran0@gmail.com>
-"0x%u" format is very misleading, replace by "0x%x".
+Replace manual lock()/unlock() calls with lock guard macros
 (QEMU_LOCK_GUARD/WITH_QEMU_LOCK_GUARD).
-Found running:
+Signed-off-by: Simran Singhal <singhalsimran0@gmail.com>
+Reviewed-by: Yuval Shaia <yuval.shaia.ml@gmail.com>
-  $ git grep -E '0x%[0-9]*([lL]*|" ?PRI)[dDuU]' hw/
+Reviewed-by: Marcel Apfelbaum<marcel.apfelbaum@gmail.com>
+Tested-by: Yuval Shaia <yuval.shaia.ml@gmail.com>
-Inspired-by: Richard Henderson <richard.henderson@linaro.org>
+Message-id: 20200402065035.GA15477@simran-Inspiron-5558
 Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
 Message-id: 20220323114718.58714-3-philippe.mathieu.daude@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- hw/i386/sgx.c        | 2 +-
+ hw/hyperv/hyperv.c     | 15 ++++++-------
- hw/i386/trace-events | 6 +++---
+ hw/rdma/rdma_backend.c | 50 +++++++++++++++++++++---------------------
- hw/misc/trace-events | 4 ++--
+ hw/rdma/rdma_rm.c      |  3 +--
- hw/scsi/trace-events | 4 ++--
+files changed, 33 insertions(+), 35 deletions(-)
 files changed, 8 insertions(+), 8 deletions(-)
-diff --git a/hw/i386/sgx.c b/hw/i386/sgx.c
+diff --git a/hw/hyperv/hyperv.c b/hw/hyperv/hyperv.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/i386/sgx.c
+--- a/hw/hyperv/hyperv.c
-+++ b/hw/i386/sgx.c
++++ b/hw/hyperv/hyperv.c
-@@ -XXX,XX +XXX,XX @@ void pc_machine_init_sgx_epc(PCMachineState *pcms)
+@@ -XXX,XX +XXX,XX @@
  #include "sysemu/kvm.h"
  #include "qemu/bitops.h"
  #include "qemu/error-report.h"
 +#include "qemu/lockable.h"
  #include "qemu/queue.h"
  #include "qemu/rcu.h"
  #include "qemu/rcu_queue.h"
@@ -XXX,XX +XXX,XX @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data)
      int ret;
      MsgHandler *mh;
 -    qemu_mutex_lock(&handlers_mutex);
 +    QEMU_LOCK_GUARD(&handlers_mutex);
      QLIST_FOREACH(mh, &msg_handlers, link) {
          if (mh->conn_id == conn_id) {
              if (handler) {
@@ -XXX,XX +XXX,XX @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data)
                  g_free_rcu(mh, rcu);
                  ret = 0;
              }
 -            goto unlock;
 +            return ret;
          }
      }
-     if ((sgx_epc->base + sgx_epc->size) < sgx_epc->base) {
+@@ -XXX,XX +XXX,XX @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data)
--        error_report("Size of all 'sgx-epc' =0x%"PRIu64" causes EPC to wrap",
+     } else {
-+        error_report("Size of all 'sgx-epc' =0x%"PRIx64" causes EPC to wrap",
+         ret = -ENOENT;
                       sgx_epc->size);
          exit(EXIT_FAILURE);
      }
-diff --git a/hw/i386/trace-events b/hw/i386/trace-events
+-unlock:
 -    qemu_mutex_unlock(&handlers_mutex);
 +
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier)
      int ret;
      EventFlagHandler *handler;
 -    qemu_mutex_lock(&handlers_mutex);
 +    QEMU_LOCK_GUARD(&handlers_mutex);
      QLIST_FOREACH(handler, &event_flag_handlers, link) {
          if (handler->conn_id == conn_id) {
              if (notifier) {
@@ -XXX,XX +XXX,XX @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier)
                  g_free_rcu(handler, rcu);
                  ret = 0;
              }
 -            goto unlock;
 +            return ret;
          }
      }
@@ -XXX,XX +XXX,XX @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier)
      } else {
          ret = -ENOENT;
      }
 -unlock:
 -    qemu_mutex_unlock(&handlers_mutex);
 +
      return ret;
  }
 diff --git a/hw/rdma/rdma_backend.c b/hw/rdma/rdma_backend.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/i386/trace-events
+--- a/hw/rdma/rdma_backend.c
-+++ b/hw/i386/trace-events
++++ b/hw/rdma/rdma_backend.c
-@@ -XXX,XX +XXX,XX @@ vtd_fault_disabled(void) "Fault processing disabled for context entry"
+@@ -XXX,XX +XXX,XX @@ static int rdma_poll_cq(RdmaDeviceResources *rdma_dev_res, struct ibv_cq *ibcq)
- vtd_replay_ce_valid(const char *mode, uint8_t bus, uint8_t dev, uint8_t fn, uint16_t domain, uint64_t hi, uint64_t lo) "%s: replay valid context device %02"PRIx8":%02"PRIx8".%02"PRIx8" domain 0x%"PRIx16" hi 0x%"PRIx64" lo 0x%"PRIx64
+     struct ibv_wc wc[2];
- vtd_replay_ce_invalid(uint8_t bus, uint8_t dev, uint8_t fn) "replay invalid context device %02"PRIx8":%02"PRIx8".%02"PRIx8
+     RdmaProtectedGSList *cqe_ctx_list;
- vtd_page_walk_level(uint64_t addr, uint32_t level, uint64_t start, uint64_t end) "walk (base=0x%"PRIx64", level=%"PRIu32") iova range 0x%"PRIx64" - 0x%"PRIx64
--vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm) "domain 0x%"PRIu16" iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64" perm %d"
+-    qemu_mutex_lock(&rdma_dev_res->lock);
-+vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm) "domain 0x%"PRIx16" iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64" perm %d"
+-    do {
- vtd_page_walk_one_skip_map(uint64_t iova, uint64_t mask, uint64_t translated) "iova 0x%"PRIx64" mask 0x%"PRIx64" translated 0x%"PRIx64
+-        ne = ibv_poll_cq(ibcq, ARRAY_SIZE(wc), wc);
- vtd_page_walk_one_skip_unmap(uint64_t iova, uint64_t mask) "iova 0x%"PRIx64" mask 0x%"PRIx64
++    WITH_QEMU_LOCK_GUARD(&rdma_dev_res->lock) {
- vtd_page_walk_skip_read(uint64_t iova, uint64_t next) "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to unable to read"
++        do {
- vtd_page_walk_skip_reserve(uint64_t iova, uint64_t next) "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to rsrv set"
++            ne = ibv_poll_cq(ibcq, ARRAY_SIZE(wc), wc);
- vtd_switch_address_space(uint8_t bus, uint8_t slot, uint8_t fn, bool on) "Device %02x:%02x.%x switching address space (iommu enabled=%d)"
- vtd_as_unmap_whole(uint8_t bus, uint8_t slot, uint8_t fn, uint64_t iova, uint64_t size) "Device %02x:%02x.%x start 0x%"PRIx64" size 0x%"PRIx64
+-        trace_rdma_poll_cq(ne, ibcq);
--vtd_translate_pt(uint16_t sid, uint64_t addr) "source id 0x%"PRIu16", iova 0x%"PRIx64
++            trace_rdma_poll_cq(ne, ibcq);
--vtd_pt_enable_fast_path(uint16_t sid, bool success) "sid 0x%"PRIu16" %d"
-+vtd_translate_pt(uint16_t sid, uint64_t addr) "source id 0x%"PRIx16", iova 0x%"PRIx64
+-        for (i = 0; i < ne; i++) {
-+vtd_pt_enable_fast_path(uint16_t sid, bool success) "sid 0x%"PRIx16" %d"
+-            bctx = rdma_rm_get_cqe_ctx(rdma_dev_res, wc[i].wr_id);
- vtd_irq_generate(uint64_t addr, uint64_t data) "addr 0x%"PRIx64" data 0x%"PRIx64
+-            if (unlikely(!bctx)) {
- vtd_reg_read(uint64_t addr, uint64_t size) "addr 0x%"PRIx64" size 0x%"PRIx64
+-                rdma_error_report("No matching ctx for req %"PRId64,
- vtd_reg_write(uint64_t addr, uint64_t size, uint64_t val) "addr 0x%"PRIx64" size 0x%"PRIx64" value 0x%"PRIx64
+-                                  wc[i].wr_id);
-diff --git a/hw/misc/trace-events b/hw/misc/trace-events
+-                continue;
 -            }
 +            for (i = 0; i < ne; i++) {
 +                bctx = rdma_rm_get_cqe_ctx(rdma_dev_res, wc[i].wr_id);
 +                if (unlikely(!bctx)) {
 +                    rdma_error_report("No matching ctx for req %"PRId64,
 +                                      wc[i].wr_id);
 +                    continue;
 +                }
 -            comp_handler(bctx->up_ctx, &wc[i]);
 +                comp_handler(bctx->up_ctx, &wc[i]);
 -            if (bctx->backend_qp) {
 -                cqe_ctx_list = &bctx->backend_qp->cqe_ctx_list;
 -            } else {
 -                cqe_ctx_list = &bctx->backend_srq->cqe_ctx_list;
 -            }
 +                if (bctx->backend_qp) {
 +                    cqe_ctx_list = &bctx->backend_qp->cqe_ctx_list;
 +                } else {
 +                    cqe_ctx_list = &bctx->backend_srq->cqe_ctx_list;
 +                }
 -            rdma_protected_gslist_remove_int32(cqe_ctx_list, wc[i].wr_id);
 -            rdma_rm_dealloc_cqe_ctx(rdma_dev_res, wc[i].wr_id);
 -            g_free(bctx);
 -        }
 -        total_ne += ne;
 -    } while (ne > 0);
 -    atomic_sub(&rdma_dev_res->stats.missing_cqe, total_ne);
 -    qemu_mutex_unlock(&rdma_dev_res->lock);
 +                rdma_protected_gslist_remove_int32(cqe_ctx_list, wc[i].wr_id);
 +                rdma_rm_dealloc_cqe_ctx(rdma_dev_res, wc[i].wr_id);
 +                g_free(bctx);
 +            }
 +            total_ne += ne;
 +        } while (ne > 0);
 +        atomic_sub(&rdma_dev_res->stats.missing_cqe, total_ne);
 +    }
      if (ne < 0) {
          rdma_error_report("ibv_poll_cq fail, rc=%d, errno=%d", ne, errno);
 diff --git a/hw/rdma/rdma_rm.c b/hw/rdma/rdma_rm.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/misc/trace-events
+--- a/hw/rdma/rdma_rm.c
-+++ b/hw/misc/trace-events
++++ b/hw/rdma/rdma_rm.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static inline void rdma_res_tbl_dealloc(RdmaRmResTbl *tbl, uint32_t handle)
- # See docs/devel/tracing.rst for syntax documentation.
+ {
+     trace_rdma_res_tbl_dealloc(tbl->name, handle);
- # allwinner-cpucfg.c
--allwinner_cpucfg_cpu_reset(uint8_t cpu_id, uint32_t reset_addr) "id %u, reset_addr 0x%" PRIu32
+-    qemu_mutex_lock(&tbl->lock);
-+allwinner_cpucfg_cpu_reset(uint8_t cpu_id, uint32_t reset_addr) "id %u, reset_addr 0x%" PRIx32
++    QEMU_LOCK_GUARD(&tbl->lock);
- allwinner_cpucfg_read(uint64_t offset, uint64_t data, unsigned size) "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32
- allwinner_cpucfg_write(uint64_t offset, uint64_t data, unsigned size) "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32
+     if (handle < tbl->tbl_sz) {
+         clear_bit(handle, tbl->bitmap);
-@@ -XXX,XX +XXX,XX @@ imx7_gpr_write(uint64_t offset, uint64_t value) "addr 0x%08" PRIx64 "value 0x%08
+         tbl->used--;
+     }
- # mos6522.c
- mos6522_set_counter(int index, unsigned int val) "T%d.counter=%d"
+-    qemu_mutex_unlock(&tbl->lock);
--mos6522_get_next_irq_time(uint16_t latch, int64_t d, int64_t delta) "latch=%d counter=0x%"PRId64 " delta_next=0x%"PRId64
+ }
-+mos6522_get_next_irq_time(uint16_t latch, int64_t d, int64_t delta) "latch=%d counter=0x%"PRIx64 " delta_next=0x%"PRIx64
- mos6522_set_sr_int(void) "set sr_int"
+ int rdma_rm_alloc_pd(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev,
  mos6522_write(uint64_t addr, const char *name, uint64_t val) "reg=0x%"PRIx64 " [%s] val=0x%"PRIx64
  mos6522_read(uint64_t addr, const char *name, unsigned val) "reg=0x%"PRIx64 " [%s] val=0x%x"
 diff --git a/hw/scsi/trace-events b/hw/scsi/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/scsi/trace-events
 +++ b/hw/scsi/trace-events
@@ -XXX,XX +XXX,XX @@ lsi_bad_phase_interrupt(void) "Phase mismatch interrupt"
  lsi_bad_selection(uint32_t id) "Selected absent target %"PRIu32
  lsi_do_dma_unavailable(void) "DMA no data available"
  lsi_do_dma(uint64_t addr, int len) "DMA addr=0x%"PRIx64" len=%d"
 -lsi_queue_command(uint32_t tag) "Queueing tag=0x%"PRId32
 +lsi_queue_command(uint32_t tag) "Queueing tag=0x%"PRIx32
  lsi_add_msg_byte_error(void) "MSG IN data too long"
  lsi_add_msg_byte(uint8_t data) "MSG IN 0x%02x"
  lsi_reselect(int id) "Reselected target %d"
@@ -XXX,XX +XXX,XX @@ lsi_do_msgout_noop(void) "MSG: No Operation"
  lsi_do_msgout_extended(uint8_t msg, uint8_t len) "Extended message 0x%x (len %d)"
  lsi_do_msgout_ignored(const char *msg) "%s (ignored)"
  lsi_do_msgout_simplequeue(uint8_t select_tag) "SIMPLE queue tag=0x%x"
 -lsi_do_msgout_abort(uint32_t tag) "MSG: ABORT TAG tag=0x%"PRId32
 +lsi_do_msgout_abort(uint32_t tag) "MSG: ABORT TAG tag=0x%"PRIx32
  lsi_do_msgout_clearqueue(uint32_t tag) "MSG: CLEAR QUEUE tag=0x%"PRIx32
  lsi_do_msgout_busdevicereset(uint32_t tag) "MSG: BUS DEVICE RESET tag=0x%"PRIx32
  lsi_do_msgout_select(int id) "Select LUN %d"
 --
-.35.1
+.25.3

The following changes since commit 15ef89d2a1a7b93845a6b09c2ee8e1979f6eb30b:

Update version for v7.0.0-rc1 release (2022-03-22 22:58:44 +0000)

are available in the Git repository at:

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

for you to fetch changes up to 2539eade4f689eda7e9fe45486f18334bfbafaf0:

hw: Fix misleading hexadecimal format (2022-03-24 10:38:42 +0000)

----------------------------------------------------------------
Pull request

Philippe found cases where the 0x%d format string was used, leading to
misleading output. The patches look harmless and could save people time, so I
think it's worth including them in 7.0.

----------------------------------------------------------------

Philippe Mathieu-Daudé (2):
  block: Fix misleading hexadecimal format
  hw: Fix misleading hexadecimal format

-- 
2.35.1

From: Philippe Mathieu-Daudé <f4bug@amsat.org>

"0x%u" format is very misleading, replace by "0x%x".

Found running:

$ git grep -E '0x%[0-9]*([lL]*|" ?PRI)[dDuU]' block/

Inspired-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Denis V. Lunev <den@openvz.org>
Message-id: 20220323114718.58714-2-philippe.mathieu.daude@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/parallels-ext.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/block/parallels-ext.c b/block/parallels-ext.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels-ext.c
+++ b/block/parallels-ext.c
@@ -XXX,XX +XXX,XX @@ static int parallels_parse_format_extension(BlockDriverState *bs,
             break;
 
         default:
-            error_setg(errp, "Unknown feature: 0x%" PRIu64, fh.magic);
+            error_setg(errp, "Unknown feature: 0x%" PRIx64, fh.magic);
             goto fail;
         }
 
-- 
2.35.1

From: Philippe Mathieu-Daudé <f4bug@amsat.org>

"0x%u" format is very misleading, replace by "0x%x".

Found running:

$ git grep -E '0x%[0-9]*([lL]*|" ?PRI)[dDuU]' hw/

Inspired-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Message-id: 20220323114718.58714-3-philippe.mathieu.daude@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/i386/sgx.c        | 2 +-
 hw/i386/trace-events | 6 +++---
 hw/misc/trace-events | 4 ++--
 hw/scsi/trace-events | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/hw/i386/sgx.c b/hw/i386/sgx.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/i386/sgx.c
+++ b/hw/i386/sgx.c
@@ -XXX,XX +XXX,XX @@ void pc_machine_init_sgx_epc(PCMachineState *pcms)
     }
 
     if ((sgx_epc->base + sgx_epc->size) < sgx_epc->base) {
-        error_report("Size of all 'sgx-epc' =0x%"PRIu64" causes EPC to wrap",
+        error_report("Size of all 'sgx-epc' =0x%"PRIx64" causes EPC to wrap",
                      sgx_epc->size);
         exit(EXIT_FAILURE);
     }
diff --git a/hw/i386/trace-events b/hw/i386/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/i386/trace-events
+++ b/hw/i386/trace-events
@@ -XXX,XX +XXX,XX @@ vtd_fault_disabled(void) "Fault processing disabled for context entry"
 vtd_replay_ce_valid(const char *mode, uint8_t bus, uint8_t dev, uint8_t fn, uint16_t domain, uint64_t hi, uint64_t lo) "%s: replay valid context device %02"PRIx8":%02"PRIx8".%02"PRIx8" domain 0x%"PRIx16" hi 0x%"PRIx64" lo 0x%"PRIx64
 vtd_replay_ce_invalid(uint8_t bus, uint8_t dev, uint8_t fn) "replay invalid context device %02"PRIx8":%02"PRIx8".%02"PRIx8
 vtd_page_walk_level(uint64_t addr, uint32_t level, uint64_t start, uint64_t end) "walk (base=0x%"PRIx64", level=%"PRIu32") iova range 0x%"PRIx64" - 0x%"PRIx64
-vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm) "domain 0x%"PRIu16" iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64" perm %d"
+vtd_page_walk_one(uint16_t domain, uint64_t iova, uint64_t gpa, uint64_t mask, int perm) "domain 0x%"PRIx16" iova 0x%"PRIx64" -> gpa 0x%"PRIx64" mask 0x%"PRIx64" perm %d"
 vtd_page_walk_one_skip_map(uint64_t iova, uint64_t mask, uint64_t translated) "iova 0x%"PRIx64" mask 0x%"PRIx64" translated 0x%"PRIx64
 vtd_page_walk_one_skip_unmap(uint64_t iova, uint64_t mask) "iova 0x%"PRIx64" mask 0x%"PRIx64
 vtd_page_walk_skip_read(uint64_t iova, uint64_t next) "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to unable to read"
 vtd_page_walk_skip_reserve(uint64_t iova, uint64_t next) "Page walk skip iova 0x%"PRIx64" - 0x%"PRIx64" due to rsrv set"
 vtd_switch_address_space(uint8_t bus, uint8_t slot, uint8_t fn, bool on) "Device %02x:%02x.%x switching address space (iommu enabled=%d)"
 vtd_as_unmap_whole(uint8_t bus, uint8_t slot, uint8_t fn, uint64_t iova, uint64_t size) "Device %02x:%02x.%x start 0x%"PRIx64" size 0x%"PRIx64
-vtd_translate_pt(uint16_t sid, uint64_t addr) "source id 0x%"PRIu16", iova 0x%"PRIx64
-vtd_pt_enable_fast_path(uint16_t sid, bool success) "sid 0x%"PRIu16" %d"
+vtd_translate_pt(uint16_t sid, uint64_t addr) "source id 0x%"PRIx16", iova 0x%"PRIx64
+vtd_pt_enable_fast_path(uint16_t sid, bool success) "sid 0x%"PRIx16" %d"
 vtd_irq_generate(uint64_t addr, uint64_t data) "addr 0x%"PRIx64" data 0x%"PRIx64
 vtd_reg_read(uint64_t addr, uint64_t size) "addr 0x%"PRIx64" size 0x%"PRIx64
 vtd_reg_write(uint64_t addr, uint64_t size, uint64_t val) "addr 0x%"PRIx64" size 0x%"PRIx64" value 0x%"PRIx64
diff --git a/hw/misc/trace-events b/hw/misc/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/misc/trace-events
+++ b/hw/misc/trace-events
@@ -XXX,XX +XXX,XX @@
 # See docs/devel/tracing.rst for syntax documentation.
 
 # allwinner-cpucfg.c
-allwinner_cpucfg_cpu_reset(uint8_t cpu_id, uint32_t reset_addr) "id %u, reset_addr 0x%" PRIu32
+allwinner_cpucfg_cpu_reset(uint8_t cpu_id, uint32_t reset_addr) "id %u, reset_addr 0x%" PRIx32
 allwinner_cpucfg_read(uint64_t offset, uint64_t data, unsigned size) "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32
 allwinner_cpucfg_write(uint64_t offset, uint64_t data, unsigned size) "offset 0x%" PRIx64 " data 0x%" PRIx64 " size %" PRIu32
 
@@ -XXX,XX +XXX,XX @@ imx7_gpr_write(uint64_t offset, uint64_t value) "addr 0x%08" PRIx64 "value 0x%08
 
 # mos6522.c
 mos6522_set_counter(int index, unsigned int val) "T%d.counter=%d"
-mos6522_get_next_irq_time(uint16_t latch, int64_t d, int64_t delta) "latch=%d counter=0x%"PRId64 " delta_next=0x%"PRId64
+mos6522_get_next_irq_time(uint16_t latch, int64_t d, int64_t delta) "latch=%d counter=0x%"PRIx64 " delta_next=0x%"PRIx64
 mos6522_set_sr_int(void) "set sr_int"
 mos6522_write(uint64_t addr, const char *name, uint64_t val) "reg=0x%"PRIx64 " [%s] val=0x%"PRIx64
 mos6522_read(uint64_t addr, const char *name, unsigned val) "reg=0x%"PRIx64 " [%s] val=0x%x"
diff --git a/hw/scsi/trace-events b/hw/scsi/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/trace-events
+++ b/hw/scsi/trace-events
@@ -XXX,XX +XXX,XX @@ lsi_bad_phase_interrupt(void) "Phase mismatch interrupt"
 lsi_bad_selection(uint32_t id) "Selected absent target %"PRIu32
 lsi_do_dma_unavailable(void) "DMA no data available"
 lsi_do_dma(uint64_t addr, int len) "DMA addr=0x%"PRIx64" len=%d"
-lsi_queue_command(uint32_t tag) "Queueing tag=0x%"PRId32
+lsi_queue_command(uint32_t tag) "Queueing tag=0x%"PRIx32
 lsi_add_msg_byte_error(void) "MSG IN data too long"
 lsi_add_msg_byte(uint8_t data) "MSG IN 0x%02x"
 lsi_reselect(int id) "Reselected target %d"
@@ -XXX,XX +XXX,XX @@ lsi_do_msgout_noop(void) "MSG: No Operation"
 lsi_do_msgout_extended(uint8_t msg, uint8_t len) "Extended message 0x%x (len %d)"
 lsi_do_msgout_ignored(const char *msg) "%s (ignored)"
 lsi_do_msgout_simplequeue(uint8_t select_tag) "SIMPLE queue tag=0x%x"
-lsi_do_msgout_abort(uint32_t tag) "MSG: ABORT TAG tag=0x%"PRId32
+lsi_do_msgout_abort(uint32_t tag) "MSG: ABORT TAG tag=0x%"PRIx32
 lsi_do_msgout_clearqueue(uint32_t tag) "MSG: CLEAR QUEUE tag=0x%"PRIx32
 lsi_do_msgout_busdevicereset(uint32_t tag) "MSG: BUS DEVICE RESET tag=0x%"PRIx32
 lsi_do_msgout_select(int id) "Select LUN %d"
-- 
2.35.1

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)

are available in the Git repository at:

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)

----------------------------------------------------------------
Pull request

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

-- 
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
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 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
index XXXXXXX..XXXXXXX 100644
--- 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>

- __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
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.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
index XXXXXXX..XXXXXXX 100644
--- 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
index XXXXXXX..XXXXXXX 100644
--- 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
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.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
@@ -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);
     }
 }
 
@@ -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
@@ -XXX,XX +XXX,XX @@
 #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
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #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
@@ -XXX,XX +XXX,XX @@
 #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/main-loop.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);
 }
 
 
diff --git a/util/thread-pool.c b/util/thread-pool.c
index XXXXXXX..XXXXXXX 100644
--- a/util/thread-pool.c
+++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ static void thread_pool_cancel(BlockAIOCB *acb)
 
     trace_thread_pool_cancel(elem, elem->common.opaque);
 
-    qemu_mutex_lock(&pool->lock);
+    QEMU_LOCK_GUARD(&pool->lock);
     if (elem->state == THREAD_QUEUED &&
         /* No thread has yet started working on elem. we can try to "steal"
          * the item from the worker if we can get a signal from the
@@ -XXX,XX +XXX,XX @@ static void thread_pool_cancel(BlockAIOCB *acb)
         elem->ret = -ECANCELED;
     }
 
-    qemu_mutex_unlock(&pool->lock);
 }
 
 static AioContext *thread_pool_get_aio_context(BlockAIOCB *acb)
diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@
 #include "standard-headers/linux/pci_regs.h"
 #include "qemu/event_notifier.h"
 #include "qemu/vfio-helpers.h"
+#include "qemu/lockable.h"
 #include "trace.h"
 
 #define QEMU_VFIO_DEBUG 0
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_reset_temporary(QEMUVFIOState *s)
         .size = QEMU_VFIO_IOVA_MAX - s->high_water_mark,
     };
     trace_qemu_vfio_dma_reset_temporary(s);
-    qemu_mutex_lock(&s->lock);
+    QEMU_LOCK_GUARD(&s->lock);
     if (ioctl(s->container, VFIO_IOMMU_UNMAP_DMA, &unmap)) {
         error_report("VFIO_UNMAP_DMA failed: %s", strerror(errno));
-        qemu_mutex_unlock(&s->lock);
         return -errno;
     }
     s->high_water_mark = QEMU_VFIO_IOVA_MAX;
-    qemu_mutex_unlock(&s->lock);
     return 0;
 }
 
-- 
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
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 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
index XXXXXXX..XXXXXXX 100644
--- a/hw/hyperv/hyperv.c
+++ b/hw/hyperv/hyperv.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/kvm.h"
 #include "qemu/bitops.h"
 #include "qemu/error-report.h"
+#include "qemu/lockable.h"
 #include "qemu/queue.h"
 #include "qemu/rcu.h"
 #include "qemu/rcu_queue.h"
@@ -XXX,XX +XXX,XX @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data)
     int ret;
     MsgHandler *mh;
 
-    qemu_mutex_lock(&handlers_mutex);
+    QEMU_LOCK_GUARD(&handlers_mutex);
     QLIST_FOREACH(mh, &msg_handlers, link) {
         if (mh->conn_id == conn_id) {
             if (handler) {
@@ -XXX,XX +XXX,XX @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data)
                 g_free_rcu(mh, rcu);
                 ret = 0;
             }
-            goto unlock;
+            return ret;
         }
     }
 
@@ -XXX,XX +XXX,XX @@ int hyperv_set_msg_handler(uint32_t conn_id, HvMsgHandler handler, void *data)
     } else {
         ret = -ENOENT;
     }
-unlock:
-    qemu_mutex_unlock(&handlers_mutex);
+
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier)
     int ret;
     EventFlagHandler *handler;
 
-    qemu_mutex_lock(&handlers_mutex);
+    QEMU_LOCK_GUARD(&handlers_mutex);
     QLIST_FOREACH(handler, &event_flag_handlers, link) {
         if (handler->conn_id == conn_id) {
             if (notifier) {
@@ -XXX,XX +XXX,XX @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier)
                 g_free_rcu(handler, rcu);
                 ret = 0;
             }
-            goto unlock;
+            return ret;
         }
     }
 
@@ -XXX,XX +XXX,XX @@ static int set_event_flag_handler(uint32_t conn_id, EventNotifier *notifier)
     } else {
         ret = -ENOENT;
     }
-unlock:
-    qemu_mutex_unlock(&handlers_mutex);
+
     return ret;
 }
 
diff --git a/hw/rdma/rdma_backend.c b/hw/rdma/rdma_backend.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/rdma/rdma_backend.c
+++ b/hw/rdma/rdma_backend.c
@@ -XXX,XX +XXX,XX @@ static int rdma_poll_cq(RdmaDeviceResources *rdma_dev_res, struct ibv_cq *ibcq)
     struct ibv_wc wc[2];
     RdmaProtectedGSList *cqe_ctx_list;
 
-    qemu_mutex_lock(&rdma_dev_res->lock);
-    do {
-        ne = ibv_poll_cq(ibcq, ARRAY_SIZE(wc), wc);
+    WITH_QEMU_LOCK_GUARD(&rdma_dev_res->lock) {
+        do {
+            ne = ibv_poll_cq(ibcq, ARRAY_SIZE(wc), wc);
 
-        trace_rdma_poll_cq(ne, ibcq);
+            trace_rdma_poll_cq(ne, ibcq);
 
-        for (i = 0; i < ne; i++) {
-            bctx = rdma_rm_get_cqe_ctx(rdma_dev_res, wc[i].wr_id);
-            if (unlikely(!bctx)) {
-                rdma_error_report("No matching ctx for req %"PRId64,
-                                  wc[i].wr_id);
-                continue;
-            }
+            for (i = 0; i < ne; i++) {
+                bctx = rdma_rm_get_cqe_ctx(rdma_dev_res, wc[i].wr_id);
+                if (unlikely(!bctx)) {
+                    rdma_error_report("No matching ctx for req %"PRId64,
+                                      wc[i].wr_id);
+                    continue;
+                }
 
-            comp_handler(bctx->up_ctx, &wc[i]);
+                comp_handler(bctx->up_ctx, &wc[i]);
 
-            if (bctx->backend_qp) {
-                cqe_ctx_list = &bctx->backend_qp->cqe_ctx_list;
-            } else {
-                cqe_ctx_list = &bctx->backend_srq->cqe_ctx_list;
-            }
+                if (bctx->backend_qp) {
+                    cqe_ctx_list = &bctx->backend_qp->cqe_ctx_list;
+                } else {
+                    cqe_ctx_list = &bctx->backend_srq->cqe_ctx_list;
+                }
 
-            rdma_protected_gslist_remove_int32(cqe_ctx_list, wc[i].wr_id);
-            rdma_rm_dealloc_cqe_ctx(rdma_dev_res, wc[i].wr_id);
-            g_free(bctx);
-        }
-        total_ne += ne;
-    } while (ne > 0);
-    atomic_sub(&rdma_dev_res->stats.missing_cqe, total_ne);
-    qemu_mutex_unlock(&rdma_dev_res->lock);
+                rdma_protected_gslist_remove_int32(cqe_ctx_list, wc[i].wr_id);
+                rdma_rm_dealloc_cqe_ctx(rdma_dev_res, wc[i].wr_id);
+                g_free(bctx);
+            }
+            total_ne += ne;
+        } while (ne > 0);
+        atomic_sub(&rdma_dev_res->stats.missing_cqe, total_ne);
+    }
 
     if (ne < 0) {
         rdma_error_report("ibv_poll_cq fail, rc=%d, errno=%d", ne, errno);
diff --git a/hw/rdma/rdma_rm.c b/hw/rdma/rdma_rm.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/rdma/rdma_rm.c
+++ b/hw/rdma/rdma_rm.c
@@ -XXX,XX +XXX,XX @@ static inline void rdma_res_tbl_dealloc(RdmaRmResTbl *tbl, uint32_t handle)
 {
     trace_rdma_res_tbl_dealloc(tbl->name, handle);
 
-    qemu_mutex_lock(&tbl->lock);
+    QEMU_LOCK_GUARD(&tbl->lock);
 
     if (handle < tbl->tbl_sz) {
         clear_bit(handle, tbl->bitmap);
         tbl->used--;
     }
 
-    qemu_mutex_unlock(&tbl->lock);
 }
 
 int rdma_rm_alloc_pd(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev,
-- 
2.25.3