From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:34659) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1WAJdD-00018N-KW for qemu-devel@nongnu.org; Mon, 03 Feb 2014 08:32:17 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1WAJd7-0004Xv-FU for qemu-devel@nongnu.org; Mon, 03 Feb 2014 08:32:11 -0500 Received: from mx1.redhat.com ([209.132.183.28]:31192) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1WAJd7-0004Xr-7f for qemu-devel@nongnu.org; Mon, 03 Feb 2014 08:32:05 -0500 From: Stefan Hajnoczi Date: Mon, 3 Feb 2014 14:31:50 +0100 Message-Id: <1391434310-9990-4-git-send-email-stefanha@redhat.com> In-Reply-To: <1391434310-9990-1-git-send-email-stefanha@redhat.com> References: <1391434310-9990-1-git-send-email-stefanha@redhat.com> Subject: [Qemu-devel] [PATCH 3/3] glib: add compat wrapper for GStaticMutex List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: Peter Maydell , Anthony Liguori Avoid duplicating ifdefs for the deprecated GStaticMutex API by introducing compat_g_static_mutex_*() in glib-compat.h. GStaticMutex users should use the compat API to avoid dealing with deprecation. Signed-off-by: Stefan Hajnoczi --- coroutine-gthread.c | 13 +++++++------ include/glib-compat.h | 19 +++++++++++++++++++ trace/simple.c | 26 +++++++++----------------- 3 files changed, 35 insertions(+), 23 deletions(-) diff --git a/coroutine-gthread.c b/coroutine-gthread.c index 695c113..28272f8 100644 --- a/coroutine-gthread.c +++ b/coroutine-gthread.c @@ -30,7 +30,7 @@ typedef struct { CoroutineAction action; } CoroutineGThread; -static GStaticMutex coroutine_lock = G_STATIC_MUTEX_INIT; +DEFINE_COMPAT_G_STATIC_MUTEX(coroutine_lock); /* GLib 2.31 and beyond deprecated various parts of the thread API, * but the new interfaces are not available in older GLib versions @@ -123,15 +123,16 @@ static void __attribute__((constructor)) coroutine_init(void) static void coroutine_wait_runnable_locked(CoroutineGThread *co) { while (!co->runnable) { - g_cond_wait(coroutine_cond, g_static_mutex_get_mutex(&coroutine_lock)); + g_cond_wait(coroutine_cond, + compat_g_static_mutex_get_mutex(&coroutine_lock)); } } static void coroutine_wait_runnable(CoroutineGThread *co) { - g_static_mutex_lock(&coroutine_lock); + compat_g_static_mutex_lock(&coroutine_lock); coroutine_wait_runnable_locked(co); - g_static_mutex_unlock(&coroutine_lock); + compat_g_static_mutex_unlock(&coroutine_lock); } static gpointer coroutine_thread(gpointer opaque) @@ -173,7 +174,7 @@ CoroutineAction qemu_coroutine_switch(Coroutine *from_, CoroutineGThread *from = DO_UPCAST(CoroutineGThread, base, from_); CoroutineGThread *to = DO_UPCAST(CoroutineGThread, base, to_); - g_static_mutex_lock(&coroutine_lock); + compat_g_static_mutex_lock(&coroutine_lock); from->runnable = false; from->action = action; to->runnable = true; @@ -183,7 +184,7 @@ CoroutineAction qemu_coroutine_switch(Coroutine *from_, if (action != COROUTINE_TERMINATE) { coroutine_wait_runnable_locked(from); } - g_static_mutex_unlock(&coroutine_lock); + compat_g_static_mutex_unlock(&coroutine_lock); return from->action; } diff --git a/include/glib-compat.h b/include/glib-compat.h index ea965df..48fa95c 100644 --- a/include/glib-compat.h +++ b/include/glib-compat.h @@ -49,4 +49,23 @@ static inline GThread *g_thread_new(const gchar *unused, } #endif +/* GStaticMutex was deprecated in 2.32.0. Use the compat_g_static_mutex_*() + * wrappers to hide the GStaticMutex/GMutex distinction. + */ +#if GLIB_CHECK_VERSION(2, 32, 0) +#define DEFINE_COMPAT_G_STATIC_MUTEX(name) \ +static GMutex name + +#define compat_g_static_mutex_lock(m) g_mutex_lock(m) +#define compat_g_static_mutex_unlock(m) g_mutex_unlock(m) +#define compat_g_static_mutex_get_mutex(m) (m) +#else +#define DEFINE_COMPAT_G_STATIC_MUTEX(name) \ +static GStaticMutex name = G_STATIC_MUTEX_INIT + +#define compat_g_static_mutex_lock(m) g_static_mutex_lock(m) +#define compat_g_static_mutex_unlock(m) g_static_mutex_unlock(m) +#define compat_g_static_mutex_get_mutex(m) g_static_mutex_get_mutex(m) +#endif + #endif diff --git a/trace/simple.c b/trace/simple.c index 8e83e59..dc58afe 100644 --- a/trace/simple.c +++ b/trace/simple.c @@ -41,17 +41,7 @@ * Trace records are written out by a dedicated thread. The thread waits for * records to become available, writes them out, and then waits again. */ -#if GLIB_CHECK_VERSION(2, 32, 0) -static GMutex trace_lock; -#define lock_trace_lock() g_mutex_lock(&trace_lock) -#define unlock_trace_lock() g_mutex_unlock(&trace_lock) -#define get_trace_lock_mutex() (&trace_lock) -#else -static GStaticMutex trace_lock = G_STATIC_MUTEX_INIT; -#define lock_trace_lock() g_static_mutex_lock(&trace_lock) -#define unlock_trace_lock() g_static_mutex_unlock(&trace_lock) -#define get_trace_lock_mutex() g_static_mutex_get_mutex(&trace_lock) -#endif +DEFINE_COMPAT_G_STATIC_MUTEX(trace_lock); /* g_cond_new() was deprecated in glib 2.31 but we still need to support it */ #if GLIB_CHECK_VERSION(2, 31, 0) @@ -151,26 +141,28 @@ static bool get_trace_record(unsigned int idx, TraceRecord **recordptr) */ static void flush_trace_file(bool wait) { - lock_trace_lock(); + compat_g_static_mutex_lock(&trace_lock); trace_available = true; g_cond_signal(trace_available_cond); if (wait) { - g_cond_wait(trace_empty_cond, get_trace_lock_mutex()); + g_cond_wait(trace_empty_cond, + compat_g_static_mutex_get_mutex(&trace_lock)); } - unlock_trace_lock(); + compat_g_static_mutex_unlock(&trace_lock); } static void wait_for_trace_records_available(void) { - lock_trace_lock(); + compat_g_static_mutex_lock(&trace_lock); while (!(trace_available && trace_writeout_enabled)) { g_cond_signal(trace_empty_cond); - g_cond_wait(trace_available_cond, get_trace_lock_mutex()); + g_cond_wait(trace_available_cond, + compat_g_static_mutex_get_mutex(&trace_lock)); } trace_available = false; - unlock_trace_lock(); + compat_g_static_mutex_unlock(&trace_lock); } static gpointer writeout_thread(gpointer opaque) -- 1.8.5.3