| Message ID | 1330786376-9248-1-git-send-email-peter.maydell@linaro.org |
|---|---|
| State | Accepted |
| Commit | d1b719e98ce8b506d122a845d405f941a7a497c1 |
| Headers | show |
Ping? On 3 March 2012 14:52, Peter Maydell <peter.maydell@linaro.org> wrote: > The GLib threading APIs were revamped in GLib 2.31 and a number > of the old interfaces were deprecated, which means they provoke > compilation warnings (errors if -Werror) now. Add support for the > new interfaces while retaining the old ones so we can still compile > on older versions of GLib too. > > Signed-off-by: Peter Maydell <peter.maydell@linaro.org> > --- > In particular, this fixes compilation failure on ARM hosts running > Ubuntu Precise. Seems kinda ugly to me, suggestions for improvement > welcomed. > > coroutine-gthread.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++----- > 1 files changed, 87 insertions(+), 9 deletions(-) > > diff --git a/coroutine-gthread.c b/coroutine-gthread.c > index 662801b..30c24c9 100644 > --- a/coroutine-gthread.c > +++ b/coroutine-gthread.c > @@ -26,13 +26,93 @@ typedef struct { > Coroutine base; > GThread *thread; > bool runnable; > + bool free_on_thread_exit; > CoroutineAction action; > } CoroutineGThread; > > -static GCond *coroutine_cond; > static GStaticMutex coroutine_lock = G_STATIC_MUTEX_INIT; > + > +/* GLib 2.31 and beyond deprecated various parts of the thread API, > + * but the new interfaces are not available in older GLib versions > + * so we have to cope with both. > + */ > +#if GLIB_CHECK_VERSION(2, 31, 0) > +/* Default zero-initialisation is sufficient for 2.31+ GCond */ > +static GCond the_coroutine_cond; > +static GCond *coroutine_cond = &the_coroutine_cond; > +static inline void init_coroutine_cond(void) > +{ > +} > + > +/* Awkwardly, the GPrivate API doesn't provide a way to update the > + * GDestroyNotify handler for the coroutine key dynamically. So instead > + * we track whether or not the CoroutineGThread should be freed on > + * thread exit / coroutine key update using the free_on_thread_exit > + * field. > + */ > +static void coroutine_destroy_notify(gpointer data) > +{ > + CoroutineGThread *co = data; > + if (co && co->free_on_thread_exit) { > + g_free(co); > + } > +} > + > +static GPrivate coroutine_key = G_PRIVATE_INIT(coroutine_destroy_notify); > + > +static inline CoroutineGThread *get_coroutine_key(void) > +{ > + return g_private_get(&coroutine_key); > +} > + > +static inline void set_coroutine_key(CoroutineGThread *co, > + bool free_on_thread_exit) > +{ > + /* Unlike g_static_private_set() this does not call the GDestroyNotify > + * if the previous value of the key was NULL. Fortunately we only need > + * the GDestroyNotify in the non-NULL key case. > + */ > + co->free_on_thread_exit = free_on_thread_exit; > + 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 */ > +static GCond *coroutine_cond; > +static inline void init_coroutine_cond(void) > +{ > + coroutine_cond = g_cond_new(); > +} > + > static GStaticPrivate coroutine_key = G_STATIC_PRIVATE_INIT; > > +static inline CoroutineGThread *get_coroutine_key(void) > +{ > + return g_static_private_get(&coroutine_key); > +} > + > +static inline void set_coroutine_key(CoroutineGThread *co, > + bool free_on_thread_exit) > +{ > + g_static_private_set(&coroutine_key, co, > + free_on_thread_exit ? (GDestroyNotify)g_free : NULL); > +} > + > +static inline GThread *create_thread(GThreadFunc func, gpointer data) > +{ > + return g_thread_create_full(func, data, 0, TRUE, TRUE, > + G_THREAD_PRIORITY_NORMAL, NULL); > +} > + > +#endif > + > + > static void __attribute__((constructor)) coroutine_init(void) > { > if (!g_thread_supported()) { > @@ -44,7 +124,7 @@ static void __attribute__((constructor)) coroutine_init(void) > #endif > } > > - coroutine_cond = g_cond_new(); > + init_coroutine_cond(); > } > > static void coroutine_wait_runnable_locked(CoroutineGThread *co) > @@ -65,7 +145,7 @@ static gpointer coroutine_thread(gpointer opaque) > { > CoroutineGThread *co = opaque; > > - g_static_private_set(&coroutine_key, co, NULL); > + set_coroutine_key(co, false); > coroutine_wait_runnable(co); > co->base.entry(co->base.entry_arg); > qemu_coroutine_switch(&co->base, co->base.caller, COROUTINE_TERMINATE); > @@ -77,8 +157,7 @@ Coroutine *qemu_coroutine_new(void) > CoroutineGThread *co; > > co = g_malloc0(sizeof(*co)); > - co->thread = g_thread_create_full(coroutine_thread, co, 0, TRUE, TRUE, > - G_THREAD_PRIORITY_NORMAL, NULL); > + co->thread = create_thread(coroutine_thread, co); > if (!co->thread) { > g_free(co); > return NULL; > @@ -117,12 +196,11 @@ CoroutineAction qemu_coroutine_switch(Coroutine *from_, > > Coroutine *qemu_coroutine_self(void) > { > - CoroutineGThread *co = g_static_private_get(&coroutine_key); > - > + CoroutineGThread *co = get_coroutine_key(); > if (!co) { > co = g_malloc0(sizeof(*co)); > co->runnable = true; > - g_static_private_set(&coroutine_key, co, (GDestroyNotify)g_free); > + set_coroutine_key(co, true); > } > > return &co->base; > @@ -130,7 +208,7 @@ Coroutine *qemu_coroutine_self(void) > > bool qemu_in_coroutine(void) > { > - CoroutineGThread *co = g_static_private_get(&coroutine_key); > + CoroutineGThread *co = get_coroutine_key(); > > return co && co->base.caller; > } > -- > 1.7.5.4
On Sat, Mar 3, 2012 at 2:52 PM, Peter Maydell <peter.maydell@linaro.org> wrote: > The GLib threading APIs were revamped in GLib 2.31 and a number > of the old interfaces were deprecated, which means they provoke > compilation warnings (errors if -Werror) now. Add support for the > new interfaces while retaining the old ones so we can still compile > on older versions of GLib too. > > Signed-off-by: Peter Maydell <peter.maydell@linaro.org> > --- > In particular, this fixes compilation failure on ARM hosts running > Ubuntu Precise. Seems kinda ugly to me, suggestions for improvement > welcomed. It's ugly but it won't cause larger scale problems, so we should probably pick this up. I was wondering if this is a legitimate case to override warnings - because the new library probably still supports the deprecated functions. But eventually we need to bite the bullet and convert the code. Stefan
Am 14.03.2012 15:50, schrieb Peter Maydell: > Ping? > > On 3 March 2012 14:52, Peter Maydell <peter.maydell@linaro.org> wrote: >> The GLib threading APIs were revamped in GLib 2.31 and a number >> of the old interfaces were deprecated, which means they provoke >> compilation warnings (errors if -Werror) now. Add support for the >> new interfaces while retaining the old ones so we can still compile >> on older versions of GLib too. >> >> Signed-off-by: Peter Maydell <peter.maydell@linaro.org> >> --- >> In particular, this fixes compilation failure on ARM hosts running >> Ubuntu Precise. Seems kinda ugly to me, suggestions for improvement >> welcomed. Appeared okay to me. /-F
On 15 March 2012 11:21, Stefan Hajnoczi <stefanha@gmail.com> wrote: > It's ugly but it won't cause larger scale problems, so we should > probably pick this up. > > I was wondering if this is a legitimate case to override warnings - > because the new library probably still supports the deprecated > functions. But eventually we need to bite the bullet and convert the > code. Mmm. Eventually presumably we'll end up requiring at least glib 2.31 and we can drop the old stuff. Incidentally, there's another couple of uses of g_cond_new in trace/simple.c which probably also need conversion, but none of my use cases involve trying to compile that file so I left it alone... -- PMM
On Thu, Mar 15, 2012 at 09:55:02PM +0000, Peter Maydell wrote: > On 15 March 2012 11:21, Stefan Hajnoczi <stefanha@gmail.com> wrote: > > It's ugly but it won't cause larger scale problems, so we should > > probably pick this up. > > > > I was wondering if this is a legitimate case to override warnings - > > because the new library probably still supports the deprecated > > functions. But eventually we need to bite the bullet and convert the > > code. > > Mmm. Eventually presumably we'll end up requiring at least glib > 2.31 and we can drop the old stuff. > > Incidentally, there's another couple of uses of g_cond_new in > trace/simple.c which probably also need conversion, but none of > my use cases involve trying to compile that file so I left it > alone... Thanks for pointing that out. I've added it to my todo list. Stefan
Ping^2 ? On 14 March 2012 14:50, Peter Maydell <peter.maydell@linaro.org> wrote: > Ping? > > On 3 March 2012 14:52, Peter Maydell <peter.maydell@linaro.org> wrote: >> The GLib threading APIs were revamped in GLib 2.31 and a number >> of the old interfaces were deprecated, which means they provoke >> compilation warnings (errors if -Werror) now. Add support for the >> new interfaces while retaining the old ones so we can still compile >> on older versions of GLib too. >> >> Signed-off-by: Peter Maydell <peter.maydell@linaro.org> >> --- >> In particular, this fixes compilation failure on ARM hosts running >> Ubuntu Precise. Seems kinda ugly to me, suggestions for improvement >> welcomed. >> >> coroutine-gthread.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++----- >> 1 files changed, 87 insertions(+), 9 deletions(-) >> >> diff --git a/coroutine-gthread.c b/coroutine-gthread.c >> index 662801b..30c24c9 100644 >> --- a/coroutine-gthread.c >> +++ b/coroutine-gthread.c >> @@ -26,13 +26,93 @@ typedef struct { >> Coroutine base; >> GThread *thread; >> bool runnable; >> + bool free_on_thread_exit; >> CoroutineAction action; >> } CoroutineGThread; >> >> -static GCond *coroutine_cond; >> static GStaticMutex coroutine_lock = G_STATIC_MUTEX_INIT; >> + >> +/* GLib 2.31 and beyond deprecated various parts of the thread API, >> + * but the new interfaces are not available in older GLib versions >> + * so we have to cope with both. >> + */ >> +#if GLIB_CHECK_VERSION(2, 31, 0) >> +/* Default zero-initialisation is sufficient for 2.31+ GCond */ >> +static GCond the_coroutine_cond; >> +static GCond *coroutine_cond = &the_coroutine_cond; >> +static inline void init_coroutine_cond(void) >> +{ >> +} >> + >> +/* Awkwardly, the GPrivate API doesn't provide a way to update the >> + * GDestroyNotify handler for the coroutine key dynamically. So instead >> + * we track whether or not the CoroutineGThread should be freed on >> + * thread exit / coroutine key update using the free_on_thread_exit >> + * field. >> + */ >> +static void coroutine_destroy_notify(gpointer data) >> +{ >> + CoroutineGThread *co = data; >> + if (co && co->free_on_thread_exit) { >> + g_free(co); >> + } >> +} >> + >> +static GPrivate coroutine_key = G_PRIVATE_INIT(coroutine_destroy_notify); >> + >> +static inline CoroutineGThread *get_coroutine_key(void) >> +{ >> + return g_private_get(&coroutine_key); >> +} >> + >> +static inline void set_coroutine_key(CoroutineGThread *co, >> + bool free_on_thread_exit) >> +{ >> + /* Unlike g_static_private_set() this does not call the GDestroyNotify >> + * if the previous value of the key was NULL. Fortunately we only need >> + * the GDestroyNotify in the non-NULL key case. >> + */ >> + co->free_on_thread_exit = free_on_thread_exit; >> + 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 */ >> +static GCond *coroutine_cond; >> +static inline void init_coroutine_cond(void) >> +{ >> + coroutine_cond = g_cond_new(); >> +} >> + >> static GStaticPrivate coroutine_key = G_STATIC_PRIVATE_INIT; >> >> +static inline CoroutineGThread *get_coroutine_key(void) >> +{ >> + return g_static_private_get(&coroutine_key); >> +} >> + >> +static inline void set_coroutine_key(CoroutineGThread *co, >> + bool free_on_thread_exit) >> +{ >> + g_static_private_set(&coroutine_key, co, >> + free_on_thread_exit ? (GDestroyNotify)g_free : NULL); >> +} >> + >> +static inline GThread *create_thread(GThreadFunc func, gpointer data) >> +{ >> + return g_thread_create_full(func, data, 0, TRUE, TRUE, >> + G_THREAD_PRIORITY_NORMAL, NULL); >> +} >> + >> +#endif >> + >> + >> static void __attribute__((constructor)) coroutine_init(void) >> { >> if (!g_thread_supported()) { >> @@ -44,7 +124,7 @@ static void __attribute__((constructor)) coroutine_init(void) >> #endif >> } >> >> - coroutine_cond = g_cond_new(); >> + init_coroutine_cond(); >> } >> >> static void coroutine_wait_runnable_locked(CoroutineGThread *co) >> @@ -65,7 +145,7 @@ static gpointer coroutine_thread(gpointer opaque) >> { >> CoroutineGThread *co = opaque; >> >> - g_static_private_set(&coroutine_key, co, NULL); >> + set_coroutine_key(co, false); >> coroutine_wait_runnable(co); >> co->base.entry(co->base.entry_arg); >> qemu_coroutine_switch(&co->base, co->base.caller, COROUTINE_TERMINATE); >> @@ -77,8 +157,7 @@ Coroutine *qemu_coroutine_new(void) >> CoroutineGThread *co; >> >> co = g_malloc0(sizeof(*co)); >> - co->thread = g_thread_create_full(coroutine_thread, co, 0, TRUE, TRUE, >> - G_THREAD_PRIORITY_NORMAL, NULL); >> + co->thread = create_thread(coroutine_thread, co); >> if (!co->thread) { >> g_free(co); >> return NULL; >> @@ -117,12 +196,11 @@ CoroutineAction qemu_coroutine_switch(Coroutine *from_, >> >> Coroutine *qemu_coroutine_self(void) >> { >> - CoroutineGThread *co = g_static_private_get(&coroutine_key); >> - >> + CoroutineGThread *co = get_coroutine_key(); >> if (!co) { >> co = g_malloc0(sizeof(*co)); >> co->runnable = true; >> - g_static_private_set(&coroutine_key, co, (GDestroyNotify)g_free); >> + set_coroutine_key(co, true); >> } >> >> return &co->base; >> @@ -130,7 +208,7 @@ Coroutine *qemu_coroutine_self(void) >> >> bool qemu_in_coroutine(void) >> { >> - CoroutineGThread *co = g_static_private_get(&coroutine_key); >> + CoroutineGThread *co = get_coroutine_key(); >> >> return co && co->base.caller; >> } >> -- >> 1.7.5.4
Ping^3 ? On 3 April 2012 12:54, Peter Maydell <peter.maydell@linaro.org> wrote: > Ping^2 ? > > On 14 March 2012 14:50, Peter Maydell <peter.maydell@linaro.org> wrote: >> Ping? >> >> On 3 March 2012 14:52, Peter Maydell <peter.maydell@linaro.org> wrote: >>> The GLib threading APIs were revamped in GLib 2.31 and a number >>> of the old interfaces were deprecated, which means they provoke >>> compilation warnings (errors if -Werror) now. Add support for the >>> new interfaces while retaining the old ones so we can still compile >>> on older versions of GLib too. >>> >>> Signed-off-by: Peter Maydell <peter.maydell@linaro.org> >>> --- >>> In particular, this fixes compilation failure on ARM hosts running >>> Ubuntu Precise. Seems kinda ugly to me, suggestions for improvement >>> welcomed. >>> >>> coroutine-gthread.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++----- >>> 1 files changed, 87 insertions(+), 9 deletions(-) >>> >>> diff --git a/coroutine-gthread.c b/coroutine-gthread.c >>> index 662801b..30c24c9 100644 >>> --- a/coroutine-gthread.c >>> +++ b/coroutine-gthread.c >>> @@ -26,13 +26,93 @@ typedef struct { >>> Coroutine base; >>> GThread *thread; >>> bool runnable; >>> + bool free_on_thread_exit; >>> CoroutineAction action; >>> } CoroutineGThread; >>> >>> -static GCond *coroutine_cond; >>> static GStaticMutex coroutine_lock = G_STATIC_MUTEX_INIT; >>> + >>> +/* GLib 2.31 and beyond deprecated various parts of the thread API, >>> + * but the new interfaces are not available in older GLib versions >>> + * so we have to cope with both. >>> + */ >>> +#if GLIB_CHECK_VERSION(2, 31, 0) >>> +/* Default zero-initialisation is sufficient for 2.31+ GCond */ >>> +static GCond the_coroutine_cond; >>> +static GCond *coroutine_cond = &the_coroutine_cond; >>> +static inline void init_coroutine_cond(void) >>> +{ >>> +} >>> + >>> +/* Awkwardly, the GPrivate API doesn't provide a way to update the >>> + * GDestroyNotify handler for the coroutine key dynamically. So instead >>> + * we track whether or not the CoroutineGThread should be freed on >>> + * thread exit / coroutine key update using the free_on_thread_exit >>> + * field. >>> + */ >>> +static void coroutine_destroy_notify(gpointer data) >>> +{ >>> + CoroutineGThread *co = data; >>> + if (co && co->free_on_thread_exit) { >>> + g_free(co); >>> + } >>> +} >>> + >>> +static GPrivate coroutine_key = G_PRIVATE_INIT(coroutine_destroy_notify); >>> + >>> +static inline CoroutineGThread *get_coroutine_key(void) >>> +{ >>> + return g_private_get(&coroutine_key); >>> +} >>> + >>> +static inline void set_coroutine_key(CoroutineGThread *co, >>> + bool free_on_thread_exit) >>> +{ >>> + /* Unlike g_static_private_set() this does not call the GDestroyNotify >>> + * if the previous value of the key was NULL. Fortunately we only need >>> + * the GDestroyNotify in the non-NULL key case. >>> + */ >>> + co->free_on_thread_exit = free_on_thread_exit; >>> + 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 */ >>> +static GCond *coroutine_cond; >>> +static inline void init_coroutine_cond(void) >>> +{ >>> + coroutine_cond = g_cond_new(); >>> +} >>> + >>> static GStaticPrivate coroutine_key = G_STATIC_PRIVATE_INIT; >>> >>> +static inline CoroutineGThread *get_coroutine_key(void) >>> +{ >>> + return g_static_private_get(&coroutine_key); >>> +} >>> + >>> +static inline void set_coroutine_key(CoroutineGThread *co, >>> + bool free_on_thread_exit) >>> +{ >>> + g_static_private_set(&coroutine_key, co, >>> + free_on_thread_exit ? (GDestroyNotify)g_free : NULL); >>> +} >>> + >>> +static inline GThread *create_thread(GThreadFunc func, gpointer data) >>> +{ >>> + return g_thread_create_full(func, data, 0, TRUE, TRUE, >>> + G_THREAD_PRIORITY_NORMAL, NULL); >>> +} >>> + >>> +#endif >>> + >>> + >>> static void __attribute__((constructor)) coroutine_init(void) >>> { >>> if (!g_thread_supported()) { >>> @@ -44,7 +124,7 @@ static void __attribute__((constructor)) coroutine_init(void) >>> #endif >>> } >>> >>> - coroutine_cond = g_cond_new(); >>> + init_coroutine_cond(); >>> } >>> >>> static void coroutine_wait_runnable_locked(CoroutineGThread *co) >>> @@ -65,7 +145,7 @@ static gpointer coroutine_thread(gpointer opaque) >>> { >>> CoroutineGThread *co = opaque; >>> >>> - g_static_private_set(&coroutine_key, co, NULL); >>> + set_coroutine_key(co, false); >>> coroutine_wait_runnable(co); >>> co->base.entry(co->base.entry_arg); >>> qemu_coroutine_switch(&co->base, co->base.caller, COROUTINE_TERMINATE); >>> @@ -77,8 +157,7 @@ Coroutine *qemu_coroutine_new(void) >>> CoroutineGThread *co; >>> >>> co = g_malloc0(sizeof(*co)); >>> - co->thread = g_thread_create_full(coroutine_thread, co, 0, TRUE, TRUE, >>> - G_THREAD_PRIORITY_NORMAL, NULL); >>> + co->thread = create_thread(coroutine_thread, co); >>> if (!co->thread) { >>> g_free(co); >>> return NULL; >>> @@ -117,12 +196,11 @@ CoroutineAction qemu_coroutine_switch(Coroutine *from_, >>> >>> Coroutine *qemu_coroutine_self(void) >>> { >>> - CoroutineGThread *co = g_static_private_get(&coroutine_key); >>> - >>> + CoroutineGThread *co = get_coroutine_key(); >>> if (!co) { >>> co = g_malloc0(sizeof(*co)); >>> co->runnable = true; >>> - g_static_private_set(&coroutine_key, co, (GDestroyNotify)g_free); >>> + set_coroutine_key(co, true); >>> } >>> >>> return &co->base; >>> @@ -130,7 +208,7 @@ Coroutine *qemu_coroutine_self(void) >>> >>> bool qemu_in_coroutine(void) >>> { >>> - CoroutineGThread *co = g_static_private_get(&coroutine_key); >>> + CoroutineGThread *co = get_coroutine_key(); >>> >>> return co && co->base.caller; >>> } >>> -- >>> 1.7.5.4
On Thu, Apr 12, 2012 at 12:13:12PM +0100, Peter Maydell wrote:
> Ping^3 ?
Waiting on a qemu.git committer, Andreas Faerber and I have reviewed this.
Stefan
On Thu, Apr 12, 2012 at 11:13, Peter Maydell <peter.maydell@linaro.org> wrote: > Ping^3 ? Thanks, applied. When pinging for not very recent patches, including for example the Patchwork ID would help locate the actual patch. Resending the patch would work too, or adding a link to message archives. I didn't find the patch so easily since it was already deleted by garbage collector so I had to search the archives. > > On 3 April 2012 12:54, Peter Maydell <peter.maydell@linaro.org> wrote: >> Ping^2 ? >> >> On 14 March 2012 14:50, Peter Maydell <peter.maydell@linaro.org> wrote: >>> Ping? >>> >>> On 3 March 2012 14:52, Peter Maydell <peter.maydell@linaro.org> wrote: >>>> The GLib threading APIs were revamped in GLib 2.31 and a number >>>> of the old interfaces were deprecated, which means they provoke >>>> compilation warnings (errors if -Werror) now. Add support for the >>>> new interfaces while retaining the old ones so we can still compile >>>> on older versions of GLib too. >>>> >>>> Signed-off-by: Peter Maydell <peter.maydell@linaro.org> >>>> --- >>>> In particular, this fixes compilation failure on ARM hosts running >>>> Ubuntu Precise. Seems kinda ugly to me, suggestions for improvement >>>> welcomed. >>>> >>>> coroutine-gthread.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++----- >>>> 1 files changed, 87 insertions(+), 9 deletions(-) >>>> >>>> diff --git a/coroutine-gthread.c b/coroutine-gthread.c >>>> index 662801b..30c24c9 100644 >>>> --- a/coroutine-gthread.c >>>> +++ b/coroutine-gthread.c >>>> @@ -26,13 +26,93 @@ typedef struct { >>>> Coroutine base; >>>> GThread *thread; >>>> bool runnable; >>>> + bool free_on_thread_exit; >>>> CoroutineAction action; >>>> } CoroutineGThread; >>>> >>>> -static GCond *coroutine_cond; >>>> static GStaticMutex coroutine_lock = G_STATIC_MUTEX_INIT; >>>> + >>>> +/* GLib 2.31 and beyond deprecated various parts of the thread API, >>>> + * but the new interfaces are not available in older GLib versions >>>> + * so we have to cope with both. >>>> + */ >>>> +#if GLIB_CHECK_VERSION(2, 31, 0) >>>> +/* Default zero-initialisation is sufficient for 2.31+ GCond */ >>>> +static GCond the_coroutine_cond; >>>> +static GCond *coroutine_cond = &the_coroutine_cond; >>>> +static inline void init_coroutine_cond(void) >>>> +{ >>>> +} >>>> + >>>> +/* Awkwardly, the GPrivate API doesn't provide a way to update the >>>> + * GDestroyNotify handler for the coroutine key dynamically. So instead >>>> + * we track whether or not the CoroutineGThread should be freed on >>>> + * thread exit / coroutine key update using the free_on_thread_exit >>>> + * field. >>>> + */ >>>> +static void coroutine_destroy_notify(gpointer data) >>>> +{ >>>> + CoroutineGThread *co = data; >>>> + if (co && co->free_on_thread_exit) { >>>> + g_free(co); >>>> + } >>>> +} >>>> + >>>> +static GPrivate coroutine_key = G_PRIVATE_INIT(coroutine_destroy_notify); >>>> + >>>> +static inline CoroutineGThread *get_coroutine_key(void) >>>> +{ >>>> + return g_private_get(&coroutine_key); >>>> +} >>>> + >>>> +static inline void set_coroutine_key(CoroutineGThread *co, >>>> + bool free_on_thread_exit) >>>> +{ >>>> + /* Unlike g_static_private_set() this does not call the GDestroyNotify >>>> + * if the previous value of the key was NULL. Fortunately we only need >>>> + * the GDestroyNotify in the non-NULL key case. >>>> + */ >>>> + co->free_on_thread_exit = free_on_thread_exit; >>>> + 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 */ >>>> +static GCond *coroutine_cond; >>>> +static inline void init_coroutine_cond(void) >>>> +{ >>>> + coroutine_cond = g_cond_new(); >>>> +} >>>> + >>>> static GStaticPrivate coroutine_key = G_STATIC_PRIVATE_INIT; >>>> >>>> +static inline CoroutineGThread *get_coroutine_key(void) >>>> +{ >>>> + return g_static_private_get(&coroutine_key); >>>> +} >>>> + >>>> +static inline void set_coroutine_key(CoroutineGThread *co, >>>> + bool free_on_thread_exit) >>>> +{ >>>> + g_static_private_set(&coroutine_key, co, >>>> + free_on_thread_exit ? (GDestroyNotify)g_free : NULL); >>>> +} >>>> + >>>> +static inline GThread *create_thread(GThreadFunc func, gpointer data) >>>> +{ >>>> + return g_thread_create_full(func, data, 0, TRUE, TRUE, >>>> + G_THREAD_PRIORITY_NORMAL, NULL); >>>> +} >>>> + >>>> +#endif >>>> + >>>> + >>>> static void __attribute__((constructor)) coroutine_init(void) >>>> { >>>> if (!g_thread_supported()) { >>>> @@ -44,7 +124,7 @@ static void __attribute__((constructor)) coroutine_init(void) >>>> #endif >>>> } >>>> >>>> - coroutine_cond = g_cond_new(); >>>> + init_coroutine_cond(); >>>> } >>>> >>>> static void coroutine_wait_runnable_locked(CoroutineGThread *co) >>>> @@ -65,7 +145,7 @@ static gpointer coroutine_thread(gpointer opaque) >>>> { >>>> CoroutineGThread *co = opaque; >>>> >>>> - g_static_private_set(&coroutine_key, co, NULL); >>>> + set_coroutine_key(co, false); >>>> coroutine_wait_runnable(co); >>>> co->base.entry(co->base.entry_arg); >>>> qemu_coroutine_switch(&co->base, co->base.caller, COROUTINE_TERMINATE); >>>> @@ -77,8 +157,7 @@ Coroutine *qemu_coroutine_new(void) >>>> CoroutineGThread *co; >>>> >>>> co = g_malloc0(sizeof(*co)); >>>> - co->thread = g_thread_create_full(coroutine_thread, co, 0, TRUE, TRUE, >>>> - G_THREAD_PRIORITY_NORMAL, NULL); >>>> + co->thread = create_thread(coroutine_thread, co); >>>> if (!co->thread) { >>>> g_free(co); >>>> return NULL; >>>> @@ -117,12 +196,11 @@ CoroutineAction qemu_coroutine_switch(Coroutine *from_, >>>> >>>> Coroutine *qemu_coroutine_self(void) >>>> { >>>> - CoroutineGThread *co = g_static_private_get(&coroutine_key); >>>> - >>>> + CoroutineGThread *co = get_coroutine_key(); >>>> if (!co) { >>>> co = g_malloc0(sizeof(*co)); >>>> co->runnable = true; >>>> - g_static_private_set(&coroutine_key, co, (GDestroyNotify)g_free); >>>> + set_coroutine_key(co, true); >>>> } >>>> >>>> return &co->base; >>>> @@ -130,7 +208,7 @@ Coroutine *qemu_coroutine_self(void) >>>> >>>> bool qemu_in_coroutine(void) >>>> { >>>> - CoroutineGThread *co = g_static_private_get(&coroutine_key); >>>> + CoroutineGThread *co = get_coroutine_key(); >>>> >>>> return co && co->base.caller; >>>> } >>>> -- >>>> 1.7.5.4 >
diff --git a/coroutine-gthread.c b/coroutine-gthread.c index 662801b..30c24c9 100644 --- a/coroutine-gthread.c +++ b/coroutine-gthread.c @@ -26,13 +26,93 @@ typedef struct { Coroutine base; GThread *thread; bool runnable; + bool free_on_thread_exit; CoroutineAction action; } CoroutineGThread; -static GCond *coroutine_cond; static GStaticMutex coroutine_lock = G_STATIC_MUTEX_INIT; + +/* GLib 2.31 and beyond deprecated various parts of the thread API, + * but the new interfaces are not available in older GLib versions + * so we have to cope with both. + */ +#if GLIB_CHECK_VERSION(2, 31, 0) +/* Default zero-initialisation is sufficient for 2.31+ GCond */ +static GCond the_coroutine_cond; +static GCond *coroutine_cond = &the_coroutine_cond; +static inline void init_coroutine_cond(void) +{ +} + +/* Awkwardly, the GPrivate API doesn't provide a way to update the + * GDestroyNotify handler for the coroutine key dynamically. So instead + * we track whether or not the CoroutineGThread should be freed on + * thread exit / coroutine key update using the free_on_thread_exit + * field. + */ +static void coroutine_destroy_notify(gpointer data) +{ + CoroutineGThread *co = data; + if (co && co->free_on_thread_exit) { + g_free(co); + } +} + +static GPrivate coroutine_key = G_PRIVATE_INIT(coroutine_destroy_notify); + +static inline CoroutineGThread *get_coroutine_key(void) +{ + return g_private_get(&coroutine_key); +} + +static inline void set_coroutine_key(CoroutineGThread *co, + bool free_on_thread_exit) +{ + /* Unlike g_static_private_set() this does not call the GDestroyNotify + * if the previous value of the key was NULL. Fortunately we only need + * the GDestroyNotify in the non-NULL key case. + */ + co->free_on_thread_exit = free_on_thread_exit; + 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 */ +static GCond *coroutine_cond; +static inline void init_coroutine_cond(void) +{ + coroutine_cond = g_cond_new(); +} + static GStaticPrivate coroutine_key = G_STATIC_PRIVATE_INIT; +static inline CoroutineGThread *get_coroutine_key(void) +{ + return g_static_private_get(&coroutine_key); +} + +static inline void set_coroutine_key(CoroutineGThread *co, + bool free_on_thread_exit) +{ + g_static_private_set(&coroutine_key, co, + free_on_thread_exit ? (GDestroyNotify)g_free : NULL); +} + +static inline GThread *create_thread(GThreadFunc func, gpointer data) +{ + return g_thread_create_full(func, data, 0, TRUE, TRUE, + G_THREAD_PRIORITY_NORMAL, NULL); +} + +#endif + + static void __attribute__((constructor)) coroutine_init(void) { if (!g_thread_supported()) { @@ -44,7 +124,7 @@ static void __attribute__((constructor)) coroutine_init(void) #endif } - coroutine_cond = g_cond_new(); + init_coroutine_cond(); } static void coroutine_wait_runnable_locked(CoroutineGThread *co) @@ -65,7 +145,7 @@ static gpointer coroutine_thread(gpointer opaque) { CoroutineGThread *co = opaque; - g_static_private_set(&coroutine_key, co, NULL); + set_coroutine_key(co, false); coroutine_wait_runnable(co); co->base.entry(co->base.entry_arg); qemu_coroutine_switch(&co->base, co->base.caller, COROUTINE_TERMINATE); @@ -77,8 +157,7 @@ Coroutine *qemu_coroutine_new(void) CoroutineGThread *co; co = g_malloc0(sizeof(*co)); - co->thread = g_thread_create_full(coroutine_thread, co, 0, TRUE, TRUE, - G_THREAD_PRIORITY_NORMAL, NULL); + co->thread = create_thread(coroutine_thread, co); if (!co->thread) { g_free(co); return NULL; @@ -117,12 +196,11 @@ CoroutineAction qemu_coroutine_switch(Coroutine *from_, Coroutine *qemu_coroutine_self(void) { - CoroutineGThread *co = g_static_private_get(&coroutine_key); - + CoroutineGThread *co = get_coroutine_key(); if (!co) { co = g_malloc0(sizeof(*co)); co->runnable = true; - g_static_private_set(&coroutine_key, co, (GDestroyNotify)g_free); + set_coroutine_key(co, true); } return &co->base; @@ -130,7 +208,7 @@ Coroutine *qemu_coroutine_self(void) bool qemu_in_coroutine(void) { - CoroutineGThread *co = g_static_private_get(&coroutine_key); + CoroutineGThread *co = get_coroutine_key(); return co && co->base.caller; }
The GLib threading APIs were revamped in GLib 2.31 and a number of the old interfaces were deprecated, which means they provoke compilation warnings (errors if -Werror) now. Add support for the new interfaces while retaining the old ones so we can still compile on older versions of GLib too. Signed-off-by: Peter Maydell <peter.maydell@linaro.org> --- In particular, this fixes compilation failure on ARM hosts running Ubuntu Precise. Seems kinda ugly to me, suggestions for improvement welcomed. coroutine-gthread.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++----- 1 files changed, 87 insertions(+), 9 deletions(-)