[Qemu-devel] [PATCH 2/3] glib: add g_thread_new() compat function

[Qemu-devel] [PATCH 2/3] glib: add g_thread_new() compat function

[Michael Tokarev]

Stefan Hajnoczi:
> Implement 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.

ACK.  With one small nit:

[]
> +#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

[Daniel P. Berrange]

On Fri, May 02, 2014 at 02:52:23PM +0400, Michael Tokarev wrote:
> Stefan Hajnoczi:
> > Implement 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.
> 
> ACK.  With one small nit:
> 
> []
> > +#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?

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
-- 
|: 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

[Peter Maydell]

On 2 May 2014 12:01, Daniel P. Berrange <berrange@redhat.com> wrote:
> On Fri, May 02, 2014 at 02:52:23PM +0400, Michael Tokarev wrote:
>> Stefan Hajnoczi:
>> > +#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?
>
> 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.

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

[Michael Tokarev]

02.05.2014 15:08, Peter Maydell wrote:

>>> Stefan Hajnoczi:
>>>> +#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 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

[Michael Tokarev]

02.05.2014 15:08, Peter Maydell wrote:
> On 2 May 2014 12:01, Daniel P. Berrange <berrange@redhat.com> wrote:
>> On Fri, May 02, 2014 at 02:52:23PM +0400, Michael Tokarev wrote:
>>> Stefan Hajnoczi:
>>>> +#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?
>>
>> 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.
> 
> 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

[Qemu-devel] [PATCH 0/3] glib: move compat functions into glib-compat.h

[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: 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(-)

-- 
1.8.5.3

[Qemu-devel] [PATCH 2/3] glib: add g_thread_new() compat function

[Stefan Hajnoczi]

Implement 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.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 coroutine-gthread.c   | 13 +++----------
 include/glib-compat.h | 13 +++++++++++++
 trace/simple.c        |  5 +----
 3 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/coroutine-gthread.c b/coroutine-gthread.c
index d3e5b99..695c113 100644
--- a/coroutine-gthread.c
+++ b/coroutine-gthread.c
@@ -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()) {
diff --git a/include/glib-compat.h b/include/glib-compat.h
index 8d25900..ea965df 100644
--- a/include/glib-compat.h
+++ b/include/glib-compat.h
@@ -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
diff --git a/trace/simple.c b/trace/simple.c
index 57572c4..8e83e59 100644
--- a/trace/simple.c
+++ b/trace/simple.c
@@ -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 _WIN32
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-- 
1.8.5.3