thread: add lock guard macros
v2 cover thread: add lock guard macros
Lock guards automatically call qemu_(rec_)mutex_unlock() when returning from a function or leaving leaving a lexical scope. This simplifies code and eliminates leaks (especially in error code paths).
This series adds lock guards for QemuMutex and QemuRecMutex. It does not convert the entire tree but includes example conversions.
Stefan Hajnoczi (2):
lockable: add lock guards
lockable: add QemuRecMutex support
include/qemu/lockable.h | 67 +++++++++++++++++++++++++++++++++++++++++ plugins/core.c | 7 ++--- plugins/loader.c | 16 +++++----- util/qemu-timer.c | 23 +++++++------- 4 files changed, 89 insertions(+), 24 deletions(-)
Signature · 1 line
2.24.1
PATCH v2 1/2 lockable: add lock guards
This patch introduces two lock guard macros that automatically unlock a lock object (QemuMutex and others):
void f(void) {
QEMU_LOCK_GUARD(&mutex);
if (!may_fail()) {
return; /* automatically unlocks mutex */
}
...
}and:
WITH_QEMU_LOCK_GUARD(&mutex) {
if (!may_fail()) {
return; /* automatically unlocks mutex */
}
}
/* automatically unlocks mutex here */
...Convert qemu-timer.c functions that benefit from these macros as an example. Manual qemu_mutex_lock/unlock() callers are left unmodified in cases where clarity would not improve by switching to the macros.
Many other QemuMutex users remain in the codebase that might benefit from lock guards. Over time they can be converted, if that is desirable.
--- include/qemu/lockable.h | 65 +++++++++++++++++++++++++++++++++++++++++ util/qemu-timer.c | 23 +++++++-------- 2 files changed, 76 insertions(+), 12 deletions(-)
include/qemu/lockable.h +65 -0
@@ -93,4 +93,69 @@ static inline void qemu_lockable_unlock(QemuLockable *x) x->unlock (x->object); } +static inline QemuLockable *qemu_lockable_auto_lock (QemuLockable *x) +{ +qemu_lockable_lock (x); +return x; +} + +static inline void qemu_lockable_auto_unlock (QemuLockable *x) +{ +if (x) { +qemu_lockable_unlock (x); + } +} + +G_DEFINE_AUTOPTR_CLEANUP_FUNC(QemuLockable, qemu_lockable_auto_unlock) + +#define WITH_QEMU_LOCK_GUARD_ (x, var) \ + for (g_autoptr(QemuLockable) var = \ + qemu_lockable_auto_lock(QEMU_MAKE_LOCKABLE((x))); \ + var; \ + qemu_lockable_auto_unlock(var), var = NULL) + +/** +* WITH_QEMU_LOCK_GUARD - Lock a lock object for scope +* +* @x: a lock object (currently one of QemuMutex, CoMutex, QemuSpin). +* +* This macro defines a lock scope such that entering the scope takes the lock +* and leaving the scope releases the lock. Return statements are allowed +* within the scope and release the lock. Break and continue statements leave +* the scope early and release the lock. +* +* WITH_QEMU_LOCK_GUARD(&mutex) { +* ... +* if (error) { +* return; <-- mutex is automatically unlocked +* } +* +* if (early_exit) { +* break; <-- leave this scope early +* } +* ... +* } +*/ +#define WITH_QEMU_LOCK_GUARD (x) \ + WITH_QEMU_LOCK_GUARD_((x), qemu_lockable_auto##__COUNTER__) + +/** +* QEMU_LOCK_GUARD - Lock an object until the end of the scope +* +* @x: a lock object (currently one of QemuMutex, CoMutex, QemuSpin). +* +* This macro takes a lock until the end of the scope. Return statements +* release the lock. +* +* ... <-- mutex not locked +* QEMU_LOCK_GUARD(&mutex); <-- mutex locked from here onwards +* ... +* if (error) { +* return; <-- mutex is automatically unlocked +* } +*/ +#define QEMU_LOCK_GUARD (x) \ + g_autoptr(QemuLockable) qemu_lockable_auto##__COUNTER__ = \ + qemu_lockable_auto_lock(QEMU_MAKE_LOCKABLE((x))) +#endif
util/qemu-timer.c +11 -12
@@ -25,6 +25,7 @@#include "qemu/osdep.h" #include "qemu/main-loop.h" #include "qemu/timer.h" +#include "qemu/lockable.h" #include "sysemu/replay.h" #include "sysemu/cpus.h"
@@ -186,13 +187,12 @@ bool timerlist_expired(QEMUTimerList *timer_list)return false; } -qemu_mutex_lock (&timer_list->active_timers_lock); -if (!timer_list->active_timers) { -qemu_mutex_unlock (&timer_list->active_timers_lock); -return false; + WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) { +if (!timer_list->active_timers) { +return false; + } + expire_time = timer_list->active_timers->expire_time; } - expire_time = timer_list->active_timers->expire_time; -qemu_mutex_unlock (&timer_list->active_timers_lock);return expire_time <=qemu_clock_get_ns (timer_list->clock->type); }
@@ -225,13 +225,12 @@ int64_t timerlist_deadline_ns(QEMUTimerList *timer_list)* value but ->notify_cb() is called when the deadline changes. Therefore * the caller should notice the change and there is no race condition. */ -qemu_mutex_lock (&timer_list->active_timers_lock); -if (!timer_list->active_timers) { -qemu_mutex_unlock (&timer_list->active_timers_lock); -return -1 ; + WITH_QEMU_LOCK_GUARD(&timer_list->active_timers_lock) { +if (!timer_list->active_timers) { +return -1 ; + } + expire_time = timer_list->active_timers->expire_time; } - expire_time = timer_list->active_timers->expire_time; -qemu_mutex_unlock (&timer_list->active_timers_lock); delta = expire_time -qemu_clock_get_ns (timer_list->clock->type);
Signature · 1 line
2.24.1
Paolo Bonzini
AppliedQuoted 11 lines · Stefan Hajnoczi
Lock guards automatically call qemu_(rec_)mutex_unlock() when returning from a function or leaving leaving a lexical scope. This simplifies code and eliminates leaks (especially in error code paths).
This series adds lock guards for QemuMutex and QemuRecMutex. It does not convert the entire tree but includes example conversions.
Stefan Hajnoczi (2):
lockable: add lock guards
lockable: add QemuRecMutex support
Quoted 6 lines
include/qemu/lockable.h | 67 +++++++++++++++++++++++++++++++++++++++++ plugins/core.c | 7 ++--- plugins/loader.c | 16 +++++----- util/qemu-timer.c | 23 +++++++------- 4 files changed, 89 insertions(+), 24 deletions(-)
Queued, thanks.
Paolo
PATCH v2 2/2 lockable: add QemuRecMutex support
In reply to Stefan HajnocziThe polymorphic locking macros don't support QemuRecMutex yet. Add it so that lock guards can be used with QemuRecMutex.
Convert TCG plugins functions that benefit from these macros. Manual qemu_rec_mutex_lock/unlock() callers are left unmodified in cases where clarity would not improve by switching to the macros.
--- include/qemu/lockable.h | 2 ++ plugins/core.c | 7 +++---- plugins/loader.c | 16 ++++++++-------- 3 files changed, 13 insertions(+), 12 deletions(-)
include/qemu/lockable.h +2 -0
@@ -50,6 +50,7 @@ qemu_make_lockable(void *x, QemuLockable *lockable)#define QEMU_LOCK_FUNC (x) ((QemuLockUnlockFunc *) \ QEMU_GENERIC(x, \ (QemuMutex *, qemu_mutex_lock), \ + (QemuRecMutex *, qemu_rec_mutex_lock), \ (CoMutex *, qemu_co_mutex_lock), \ (QemuSpin *, qemu_spin_lock), \ unknown_lock_type))
@@ -57,6 +58,7 @@ qemu_make_lockable(void *x, QemuLockable *lockable)#define QEMU_UNLOCK_FUNC (x) ((QemuLockUnlockFunc *) \ QEMU_GENERIC(x, \ (QemuMutex *, qemu_mutex_unlock), \ + (QemuRecMutex *, qemu_rec_mutex_unlock), \ (CoMutex *, qemu_co_mutex_unlock), \ (QemuSpin *, qemu_spin_unlock), \ unknown_lock_type))
plugins/core.c +3 -4
@@ -15,6 +15,7 @@#include "qemu/error-report.h" #include "qemu/config-file.h" #include "qapi/error.h" +#include "qemu/lockable.h" #include "qemu/option.h" #include "qemu/rcu_queue.h" #include "qemu/xxhash.h"
@@ -150,11 +151,11 @@ do_plugin_register_cb(qemu_plugin_id_t id, enum qemu_plugin_event ev, {struct qemu_plugin_ctx *ctx; -qemu_rec_mutex_lock (&plugin.lock); +QEMU_LOCK_GUARD (&plugin.lock); ctx =plugin_id_to_ctx_locked (id);/* if the plugin is on its way out, ignore this request */ if (unlikely (ctx->uninstalling)) { - goto out_unlock; +return ; }if (func) {struct qemu_plugin_cb *cb = ctx->callbacks[ev];
@@ -178,8 +179,6 @@ do_plugin_register_cb(qemu_plugin_id_t id, enum qemu_plugin_event ev, }else {plugin_unregister_cb__locked (ctx, ev); } - out_unlock: -qemu_rec_mutex_unlock (&plugin.lock); } void plugin_register_cb(qemu_plugin_id_t id, enum qemu_plugin_event ev,
plugins/loader.c +8 -8
@@ -19,6 +19,7 @@#include "qemu/error-report.h" #include "qemu/config-file.h" #include "qapi/error.h" +#include "qemu/lockable.h" #include "qemu/option.h" #include "qemu/rcu_queue.h" #include "qemu/qht.h"
@@ -367,15 +368,14 @@ void plugin_reset_uninstall(qemu_plugin_id_t id,struct qemu_plugin_reset_data *data;struct qemu_plugin_ctx *ctx; -qemu_rec_mutex_lock (&plugin.lock); - ctx =plugin_id_to_ctx_locked (id); -if (ctx->uninstalling || (reset && ctx->resetting)) { -qemu_rec_mutex_unlock (&plugin.lock); -return ; + WITH_QEMU_LOCK_GUARD(&plugin.lock) { + ctx =plugin_id_to_ctx_locked (id); +if (ctx->uninstalling || (reset && ctx->resetting)) { +return ; + } + ctx->resetting = reset; + ctx->uninstalling = !reset; } - ctx->resetting = reset; - ctx->uninstalling = !reset; -qemu_rec_mutex_unlock (&plugin.lock); data = g_new(struct qemu_plugin_reset_data, 1); data->ctx = ctx;
Signature · 1 line
2.24.1