diff mbox

coroutine-gthread.c: Avoid threading APIs deprecated in GLib 2.31

Message ID 1330786376-9248-1-git-send-email-peter.maydell@linaro.org
State Accepted
Commit d1b719e98ce8b506d122a845d405f941a7a497c1
Headers show

Commit Message

Peter Maydell March 3, 2012, 2:52 p.m. UTC
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(-)

Comments

Peter Maydell March 14, 2012, 2:50 p.m. UTC | #1
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
Stefan Hajnoczi March 15, 2012, 11:21 a.m. UTC | #2
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
Andreas Färber March 15, 2012, 12:33 p.m. UTC | #3
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
Peter Maydell March 15, 2012, 9:55 p.m. UTC | #4
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
Stefan Hajnoczi March 19, 2012, 8:14 a.m. UTC | #5
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
Peter Maydell April 3, 2012, 11:54 a.m. UTC | #6
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
Peter Maydell April 12, 2012, 11:13 a.m. UTC | #7
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
Stefan Hajnoczi April 12, 2012, 1:21 p.m. UTC | #8
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
Blue Swirl April 14, 2012, 12:17 p.m. UTC | #9
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 mbox

Patch

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;
 }