glib: move compat functions into glib-compat.h
cover glib: move compat functions into glib-compat.h
glib has deprecated APIs like GStaticMutex, g_thread_create(), and others. In QEMU support both old and new APIs since using deprecated APIs would flood us with warnings but legacy distros must continue to build the QEMU source code.
This patch series reduces ifdefs by moving glib compat functions into glib-compat.h, where they can be reused.
There are two strategies for compat functions:
1. Implement the new API using the deprecated API. This compat function is used when building on a legacy host. Sometimes the API semantics are so different that this option is not feasible.
2. Add a new wrapper API that maps to the deprecated API. The wrapper is not marked deprecated so it works as a drop-in replacement but is implemented using the new API where possible.
Stefan Hajnoczi (3):
glib: move g_poll() replacement into glib-compat.h
glib: add g_thread_new() compat function
glib: add compat wrapper for GStaticMutex
coroutine-gthread.c | 26 ++++++++++---------------- include/glib-compat.h | 44 ++++++++++++++++++++++++++++++++++++++++++++ include/qemu-common.h | 12 ------------ trace/simple.c | 31 ++++++++++--------------------- 4 files changed, 64 insertions(+), 49 deletions(-)
Signature · 1 line
1.8.5.3
PATCH 1/3 glib: move g_poll() replacement into glib-compat.h
We have a dedicated header file for wrappers to smooth over glib version differences. Move the g_poll() definition into glib-compat.h for consistency.
--- include/glib-compat.h | 12 ++++++++++++ include/qemu-common.h | 12 ------------ 2 files changed, 12 insertions(+), 12 deletions(-)
include/glib-compat.h +12 -0
@@ -24,4 +24,16 @@ static inline guint g_timeout_add_seconds(guint interval, GSourceFunc function, }#endif +#if !GLIB_CHECK_VERSION (2 ,20 ,0 ) +/* +* Glib before 2.20.0 doesn't implement g_poll, so wrap it to compile properly +* on older systems. +*/ +static inline gint g_poll (GPollFD *fds,guint nfds,gint timeout) +{ +GMainContext *ctx =g_main_context_default (); +return g_main_context_get_poll_func (ctx)(fds, nfds, timeout); +} +#endif +#endif
include/qemu-common.h +0 -12
@@ -124,18 +124,6 @@ int qemu_main(int argc, char **argv, char **envp);void qemu_get_timedate (struct tm *tm,int offset);int qemu_timedate_diff (struct tm *tm); -#if !GLIB_CHECK_VERSION (2 ,20 ,0 ) -/* -* Glib before 2.20.0 doesn't implement g_poll, so wrap it to compile properly -* on older systems. -*/ -static inline gint g_poll (GPollFD *fds,guint nfds,gint timeout) -{ -GMainContext *ctx =g_main_context_default (); -return g_main_context_get_poll_func (ctx)(fds, nfds, timeout); -} -#endif -/** * is_help_option: * @s: string to test
Signature · 1 line
1.8.5.3
PATCH 1/3 glib: move g_poll() replacement into glib-compat.h
Stefan Hajnoczi:
Quoted 3 lines
We have a dedicated header file for wrappers to smooth over glib version differences. Move the
g_poll()definition intoglib-compat.hfor consistency.
Ack.
I wanted to include exactly this in my series too, but forgot.
/mjt
Re: [Qemu-devel] [PATCH 1/3] glib: move g_poll() replacement into glib-compat.h
Quoted 10 lines · Michael Tokarev
Stefan Hajnoczi:
Quoted 3 lines
We have a dedicated header file for wrappers to smooth over glib version differences. Move the
g_poll()definition intoglib-compat.hfor consistency.Ack.
Reviewed-by Michael Tokarev <[email protected]>I wanted to include exactly this in my series too, but forgot.
Forgot to mention: this can go to -trivial just fine.
Together with, I think, https://lists.gnu.org/archive/html/qemu-devel/2014-04/msg04546.html .
Thanks,
/mjt
PATCH 2/3 glib: add g_thread_new() compat function
In reply to Stefan HajnocziImplement g_thread_new() in terms of the deprecated g_thread_create(). The API was changed in glib 2.31.0.
The compat function allows us to write modern code and avoid ifdefs.
--- coroutine-gthread.c | 13 +++---------- include/glib-compat.h | 13 +++++++++++++ trace/simple.c | 5 +---- 3 files changed, 17 insertions(+), 14 deletions(-)
coroutine-gthread.c +3 -10
@@ -76,11 +76,6 @@ static inline void set_coroutine_key(CoroutineGThread *co, g_private_replace(&coroutine_key, co); } -static inline GThread *create_thread (GThreadFunc func,gpointer data) -{ -return g_thread_new ("coroutine" , func, data); -} -#else /* Handle older GLib versions */
@@ -104,15 +99,13 @@ static inline void set_coroutine_key(CoroutineGThread *co, free_on_thread_exit ? (GDestroyNotify)g_free : NULL); } +#endif +static inline GThread *create_thread (GThreadFunc func,gpointer data) { -return g_thread_create_full (func, data,0 , TRUE, TRUE, -G_THREAD_PRIORITY_NORMAL ,NULL ); +return g_thread_new ("coroutine" , func, data); } -#endif - -static void __attribute__((constructor))coroutine_init (void ) {if (!g_thread_supported ()) {
include/glib-compat.h +13 -0
@@ -36,4 +36,17 @@ static inline gint g_poll(GPollFD *fds, guint nfds, gint timeout) }#endif +#if !GLIB_CHECK_VERSION (2 ,31 ,0 ) +static inline GThread *g_thread_new (const gchar *unused, +GThreadFunc func, +gpointer data) +{ +GThread *thread =g_thread_create (func, data, TRUE,NULL ); +if (!thread) { +g_error ("g_thread_create failed" ); + } +return thread; +} +#endif +#endif
trace/simple.c +1 -4
@@ -17,6 +17,7 @@#include <pthread.h> #endif #include "qemu/timer.h" +#include "glib-compat.h" #include "trace.h" #include "trace/control.h" #include "trace/simple.h"
@@ -397,11 +398,7 @@ static GThread *trace_thread_create(GThreadFunc fn)pthread_sigmask (SIG_SETMASK , &set, &oldset);#endif -#if GLIB_CHECK_VERSION (2 ,31 ,0 ) thread =g_thread_new ("trace-thread" , fn,NULL ); -#else - thread =g_thread_create (fn,NULL , FALSE,NULL ); -#endif #ifndef _WIN32pthread_sigmask (SIG_SETMASK , &oldset,NULL );
Signature · 1 line
1.8.5.3
PATCH 2/3 glib: add g_thread_new() compat function
Stefan Hajnoczi:
Quoted 4 lines
Implement
g_thread_new()in terms of the deprecatedg_thread_create(). The API was changed in glib 2.31.0.The compat function allows us to write modern code and avoid ifdefs.
ACK. With one small nit:
[]
include/glib-compat.h static inline gint g_poll(GPollFD *fds, guint nfds, gint timeout) · line 50
Quoted 12 lines
include/glib-compat.h +12
-0+#if !GLIB_CHECK_VERSION (2 ,31 ,0 ) +static inline GThread *g_thread_new (const gchar *unused, +GThreadFunc func, +gpointer data) +{ +GThread *thread =g_thread_create (func, data, TRUE,NULL ); +if (!thread) { +g_error ("g_thread_create failed" ); + } +return thread; +} +#endif
About g_error():
"This function will result in a core dump; don't use it for errors you expect.
Using this function indicates a bug in your program, i.e. an assertion failure."
I'm not sure if this is like an assertion failure, probably yes. But we should not, I think, dump core in this situation. Is there a glib function that does (fatal) error reporting but does NOT dump core?
In my attempt to do this, I completely ignored errors:
https://lists.gnu.org/archive/html/qemu-devel/2014-04/msg04551.html
(search for g_thread_new() in glib-compat.h). This is, obviously, not right, but that's really because I was too lazy to actually find the right function to do so. Maybe just using some fprintf(stderr) + abort() - from classic C library instead of glib - will do.
Thanks,
/mjt
Re: [Qemu-devel] [PATCH 2/3] glib: add g_thread_new() compat function
Quoted 24 lines · Michael Tokarev
Stefan Hajnoczi:
Quoted 4 lines
Implement
g_thread_new()in terms of the deprecatedg_thread_create(). The API was changed in glib 2.31.0.The compat function allows us to write modern code and avoid ifdefs.
ACK. With one small nit:
[]
include/glib-compat.h static inline gint g_poll(GPollFD *fds, guint nfds, gint timeout) · line 50
Quoted 12 lines
include/glib-compat.h +12
-0+#if !GLIB_CHECK_VERSION (2 ,31 ,0 ) +static inline GThread *g_thread_new (const gchar *unused, +GThreadFunc func, +gpointer data) +{ +GThread *thread =g_thread_create (func, data, TRUE,NULL ); +if (!thread) { +g_error ("g_thread_create failed" ); + } +return thread; +} +#endif About
g_error():
Quoted 6 lines
"This function will result in a core dump; don't use it for errors you expect.
Using this function indicates a bug in your program, i.e. an assertion failure."I'm not sure if this is like an assertion failure, probably yes. But we should not, I think, dump core in this situation. Is there a glib function that does (fatal) error reporting but does NOT dump core?
I think that's what g_critical is intended for. It is more severe than g_warning, but won't exit or abort the process.
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
Re: [Qemu-devel] [PATCH 2/3] glib: add g_thread_new() compat function
Quoted 20 lines · Daniel P. Berrange
Quoted 19 lines · Michael Tokarev
Stefan Hajnoczi:
include/glib-compat.h static inline gint g_poll(GPollFD *fds, guint nfds, gint timeout) · line 50
Quoted 12 lines
include/glib-compat.h +12
-0+#if !GLIB_CHECK_VERSION (2 ,31 ,0 ) +static inline GThread *g_thread_new (const gchar *unused, +GThreadFunc func, +gpointer data) +{ +GThread *thread =g_thread_create (func, data, TRUE,NULL ); +if (!thread) { +g_error ("g_thread_create failed" ); + } +return thread; +} +#endif About
g_error():"This function will result in a core dump; don't use it for errors you expect.
Using this function indicates a bug in your program, i.e. an assertion failure."
Quoted 6 lines
Quoted 3 lines
I'm not sure if this is like an assertion failure, probably yes. But we should not, I think, dump core in this situation. Is there a glib function that does (fatal) error reporting but does NOT dump core?
I think that's what
g_criticalis intended for. It is more severe thang_warning, but won't exit or abort the process.
I'm not convinced we should be emitting any kind of warning message here anyway -- surely it's up to the caller to handle thread creation failure? The glib warning/error functions presumably print to stderr, which has all the usual issues with possibly messing up guest output.
thanks
-- PMM
Re: [Qemu-devel] [PATCH 2/3] glib: add g_thread_new() compat function
Quoted 19 lines · Peter Maydell
Quoted 16 lines
Quoted 16 lines
Stefan Hajnoczi:
include/glib-compat.h static inline gint g_poll(GPollFD *fds, guint nfds, gint timeout) · line 50
Quoted 12 lines
include/glib-compat.h +12
-0+#if !GLIB_CHECK_VERSION (2 ,31 ,0 ) +static inline GThread *g_thread_new (const gchar *unused, +GThreadFunc func, +gpointer data) +{ +GThread *thread =g_thread_create (func, data, TRUE,NULL ); +if (!thread) { +g_error ("g_thread_create failed" ); + } +return thread; +} +#endif About
g_error():Quoted 2 lines
Quoted 2 lines
"This function will result in a core dump; don't use it for errors you expect.
Using this function indicates a bug in your program, i.e. an assertion failure."
Quoted 6 lines
I'm not convinced we should be emitting any kind of warning message here anyway -- surely it's up to the caller to handle thread creation failure? The glib warning/error functions presumably print to stderr, which has all the usual issues with possibly messing up guest output.
Note that QemuThread &Co has exactly the same issue.
void qemu_mutex_init(QemuMutex *mutex)
{
...
if (err)
error_exit(err, __func__);
}and so on in all util/qemu-thread-{posix,win32).c
But yes, you're right, at least coroutine-gthread.c appears to try to handle errors by its own.
So this is what's missing from my patchset for libcacard - since this one replaces qemu thread primitives (which aborts on error) with glib thread primitives (which return error condition instead).
Thanks,
/mjt
Re: [Qemu-devel] [PATCH 2/3] glib: add g_thread_new() compat function
In reply to Peter MaydellQuoted 28 lines · Peter Maydell
Quoted 20 lines · Daniel P. Berrange
Quoted 19 lines · Michael Tokarev
Stefan Hajnoczi:
include/glib-compat.h static inline gint g_poll(GPollFD *fds, guint nfds, gint timeout) · line 50
Quoted 12 lines
include/glib-compat.h +12
-0+#if !GLIB_CHECK_VERSION (2 ,31 ,0 ) +static inline GThread *g_thread_new (const gchar *unused, +GThreadFunc func, +gpointer data) +{ +GThread *thread =g_thread_create (func, data, TRUE,NULL ); +if (!thread) { +g_error ("g_thread_create failed" ); + } +return thread; +} +#endif About
g_error():"This function will result in a core dump; don't use it for errors you expect.
Using this function indicates a bug in your program, i.e. an assertion failure."Quoted 6 lines
Quoted 3 lines
I'm not sure if this is like an assertion failure, probably yes. But we should not, I think, dump core in this situation. Is there a glib function that does (fatal) error reporting but does NOT dump core?
I think that's what
g_criticalis intended for. It is more severe thang_warning, but won't exit or abort the process.
Quoted 6 lines
I'm not convinced we should be emitting any kind of warning message here anyway -- surely it's up to the caller to handle thread creation failure? The glib warning/error functions presumably print to stderr, which has all the usual issues with possibly messing up guest output.
Actually the whole point is moot. Here's what g_thread_new() does (in 2.31+):
GThread *g_thread_new (const gchar *name,
GThreadFunc func,
gpointer data)
{
GError *error = NULL;
GThread *thread;
thread = g_thread_new_internal (name, g_thread_proxy, func, data, 0, &error);
if G_UNLIKELY (thread == NULL)
g_error ("creating thread '%s': %s", name ? name : "", error->message); return thread;
}
So that's what we should use in our g_thread_new() impl, and this is what Stefan used, in a slightly less complex way.
I'll add this to my wrapper too.
Thanks,
/mjt
PATCH 3/3 glib: add compat wrapper for GStaticMutex
In reply to Stefan HajnocziAvoid 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.
--- coroutine-gthread.c | 13 +++++++------ include/glib-compat.h | 19 +++++++++++++++++++ trace/simple.c | 26 +++++++++----------------- 3 files changed, 35 insertions(+), 23 deletions(-)
coroutine-gthread.c +7 -6
@@ -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; }
include/glib-compat.h +19 -0
@@ -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
trace/simple.c +9 -17
@@ -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)
Signature · 1 line
1.8.5.3
PATCH 3/3 glib: add compat wrapper for GStaticMutex
Stefan Hajnoczi:
Quoted 5 lines
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.
To my taste this is a wrong(ish) approach.
GStaticMutex is nothing more than a pointer to GMutex wrapped in an internal structure, and each function from g_static_mutex_* family first checks for this pointer, whenever it is initialized, and calls g_mutex_new() if not. So if there's a good place to actually init (allocate) a GMutex, it is better to use it directly instead of checking for the init in every place.
(Note also that this checking itself may need a protection using a mutex, to avoid 2 threads allocating the same GStaticMutex ;) -- this is done in g_static_mutex_get_mutex_impl() inside glib).
But that's cosmetics.
More to the point is that this is re-introduction of old API for new program. It'd be very nice if we were able to actually use the new API everywhere, instead of re-introducing old API.
And this introduces some (light) wrapper #ifdefery too.
So we not only will use the old API in the code, we also will use wrappers for almost everything. So it becomes rather clumsy.
It is, I think, better to try to switch to the new API as much as possible, or to use our own types and wrappers instead, without resoting to use foo_compat_deprecated_* (where "deprecated" part comes from staticmutex -- ie, instead of regular g_mutex_foo, we use g_compat_static_mutex_foo).
Other the bit of clumsiness, this should work.
include/glib-compat.h static inline GThread *g_thread_new(const gchar *unused, · line 55
Quoted 4 lines
include/glib-compat.h +4
-0+/* 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 )
It is actually deprecated in 2.31, even if the glib docs says 2.32. Probably not a big deal, as, I think, there's no 2.31 glib in the wild due to bugs in there, so they had to quickly release 2.32.
Thanks,
/mjt
Re: [Qemu-devel] [PATCH 3/3] glib: add compat wrapper for GStaticMutex
Quoted 9 lines · Michael Tokarev
Stefan Hajnoczi:
Quoted 5 lines
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.
To my taste this is a wrong(ish) approach.
The different approaches to hiding gthread API deprecation have their pros/cons but mostly a question of taste. If you want to merge your patch I'm fine with that.
Stefan
Quoted 22 lines · Stefan Hajnoczi
glib has deprecated APIs like GStaticMutex,
g_thread_create(), and others. In QEMU support both old and new APIs since using deprecated APIs would flood us with warnings but legacy distros must continue to build the QEMU source code.This patch series reduces ifdefs by moving glib compat functions into
glib-compat.h, where they can be reused.There are two strategies for compat functions:
1. Implement the new API using the deprecated API. This compat function is used when building on a legacy host. Sometimes the API semantics are so different that this option is not feasible.
2. Add a new wrapper API that maps to the deprecated API. The wrapper is not marked deprecated so it works as a drop-in replacement but is implemented using the new API where possible.
Stefan Hajnoczi (3):
glib: moveg_poll()replacement intoglib-compat.h
glib: addg_thread_new()compat function
glib: add compat wrapper for GStaticMutex
Quoted 5 lines
coroutine-gthread.c | 26 ++++++++++---------------- include/glib-compat.h | 44 ++++++++++++++++++++++++++++++++++++++++++++ include/qemu-common.h | 12 ------------ trace/simple.c | 31 ++++++++++--------------------- 4 files changed, 64 insertions(+), 49 deletions(-)
Ping?
Quoted 22 lines · Stefan Hajnoczi
glib has deprecated APIs like GStaticMutex,
g_thread_create(), and others. In QEMU support both old and new APIs since using deprecated APIs would flood us with warnings but legacy distros must continue to build the QEMU source code.This patch series reduces ifdefs by moving glib compat functions into
glib-compat.h, where they can be reused.There are two strategies for compat functions:
1. Implement the new API using the deprecated API. This compat function is used when building on a legacy host. Sometimes the API semantics are so different that this option is not feasible.
2. Add a new wrapper API that maps to the deprecated API. The wrapper is not marked deprecated so it works as a drop-in replacement but is implemented using the new API where possible.
Stefan Hajnoczi (3):
glib: moveg_poll()replacement intoglib-compat.h
glib: addg_thread_new()compat function
glib: add compat wrapper for GStaticMutex
Quoted 5 lines
coroutine-gthread.c | 26 ++++++++++---------------- include/glib-compat.h | 44 ++++++++++++++++++++++++++++++++++++++++++++ include/qemu-common.h | 12 ------------ trace/simple.c | 31 ++++++++++--------------------- 4 files changed, 64 insertions(+), 49 deletions(-)
Ping^2?
Also CCed mjt because he posted a related series.
Stefan