include/glib-compat.h

   1 /*
   2  * GLIB Compatibility Functions
   3  *
   4  * Copyright IBM, Corp. 2013
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *  Michael Tokarev   <mjt@tls.msk.ru>
   9  *  Paolo Bonzini     <pbonzini@redhat.com>
  10  *
  11  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  12  * See the COPYING file in the top-level directory.
  13  *
  14  */
  15
  16 #ifndef QEMU_GLIB_COMPAT_H
  17 #define QEMU_GLIB_COMPAT_H
  18
  19 #include <glib.h>
  20
  21 /* GLIB version compatibility flags */
  22 #if !GLIB_CHECK_VERSION(2, 26, 0)
  23 #define G_TIME_SPAN_SECOND              (G_GINT64_CONSTANT(1000000))
  24 #endif
  25
  26 #if !GLIB_CHECK_VERSION(2, 14, 0)
  27 static inline guint g_timeout_add_seconds(guint interval, GSourceFunc function,
  28                                           gpointer data)
  29 {
  30     return g_timeout_add(interval * 1000, function, data);
  31 }
  32 #endif
  33
  34 #if !GLIB_CHECK_VERSION(2, 28, 0)
  35 static inline gint64 qemu_g_get_monotonic_time(void)
  36 {
  37     /* g_get_monotonic_time() is best-effort so we can use the wall clock as a
  38      * fallback.
  39      */
  40
  41     GTimeVal time;
  42     g_get_current_time(&time);
  43
  44     return time.tv_sec * G_TIME_SPAN_SECOND + time.tv_usec;
  45 }
  46 /* work around distro backports of this interface */
  47 #define g_get_monotonic_time() qemu_g_get_monotonic_time()
  48 #endif
  49
  50 #if !GLIB_CHECK_VERSION(2, 16, 0)
  51 static inline int g_strcmp0(const char *str1, const char *str2)
  52 {
  53     int result;
  54
  55     if (!str1) {
  56         result = -(str1 != str2);
  57     } else if (!str2) {
  58         result = (str1 != str2);
  59     } else {
  60         result = strcmp(str1, str2);
  61     }
  62
  63     return result;
  64 }
  65 #endif
  66
  67 #ifdef _WIN32
  68 /*
  69  * g_poll has a problem on Windows when using
  70  * timeouts < 10ms, so use wrapper.
  71  */
  72 #define g_poll(fds, nfds, timeout) g_poll_fixed(fds, nfds, timeout)
  73 gint g_poll_fixed(GPollFD *fds, guint nfds, gint timeout);
  74 #elif !GLIB_CHECK_VERSION(2, 20, 0)
  75 /*
  76  * Glib before 2.20.0 doesn't implement g_poll, so wrap it to compile properly
  77  * on older systems.
  78  */
  79 static inline gint g_poll(GPollFD *fds, guint nfds, gint timeout)
  80 {
  81     GMainContext *ctx = g_main_context_default();
  82     return g_main_context_get_poll_func(ctx)(fds, nfds, timeout);
  83 }
  84 #endif
  85
  86 #if !GLIB_CHECK_VERSION(2, 31, 0)
  87 /* before glib-2.31, GMutex and GCond was dynamic-only (there was a separate
  88  * GStaticMutex, but it didn't work with condition variables).
  89  *
  90  * Our implementation uses GOnce to fake a static implementation that does
  91  * not require separate initialization.
  92  * We need to rename the types to avoid passing our CompatGMutex/CompatGCond
  93  * by mistake to a function that expects GMutex/GCond.  However, for ease
  94  * of use we keep the GLib function names.  GLib uses macros for the
  95  * implementation, we use inline functions instead and undefine the macros.
  96  */
  97
  98 typedef struct CompatGMutex {
  99     GOnce once;
 100 } CompatGMutex;
 101
 102 typedef struct CompatGCond {
 103     GOnce once;
 104 } CompatGCond;
 105
 106 static inline gpointer do_g_mutex_new(gpointer unused)
 107 {
 108     return (gpointer) g_mutex_new();
 109 }
 110
 111 static inline void g_mutex_init(CompatGMutex *mutex)
 112 {
 113     mutex->once = (GOnce) G_ONCE_INIT;
 114 }
 115
 116 static inline void g_mutex_clear(CompatGMutex *mutex)
 117 {
 118     g_assert(mutex->once.status != G_ONCE_STATUS_PROGRESS);
 119     if (mutex->once.retval) {
 120         g_mutex_free((GMutex *) mutex->once.retval);
 121     }
 122     mutex->once = (GOnce) G_ONCE_INIT;
 123 }
 124
 125 static inline void (g_mutex_lock)(CompatGMutex *mutex)
 126 {
 127     g_once(&mutex->once, do_g_mutex_new, NULL);
 128     g_mutex_lock((GMutex *) mutex->once.retval);
 129 }
 130 #undef g_mutex_lock
 131
 132 static inline gboolean (g_mutex_trylock)(CompatGMutex *mutex)
 133 {
 134     g_once(&mutex->once, do_g_mutex_new, NULL);
 135     return g_mutex_trylock((GMutex *) mutex->once.retval);
 136 }
 137 #undef g_mutex_trylock
 138
 139
 140 static inline void (g_mutex_unlock)(CompatGMutex *mutex)
 141 {
 142     g_mutex_unlock((GMutex *) mutex->once.retval);
 143 }
 144 #undef g_mutex_unlock
 145
 146 static inline gpointer do_g_cond_new(gpointer unused)
 147 {
 148     return (gpointer) g_cond_new();
 149 }
 150
 151 static inline void g_cond_init(CompatGCond *cond)
 152 {
 153     cond->once = (GOnce) G_ONCE_INIT;
 154 }
 155
 156 static inline void g_cond_clear(CompatGCond *cond)
 157 {
 158     g_assert(cond->once.status != G_ONCE_STATUS_PROGRESS);
 159     if (cond->once.retval) {
 160         g_cond_free((GCond *) cond->once.retval);
 161     }
 162     cond->once = (GOnce) G_ONCE_INIT;
 163 }
 164
 165 static inline void (g_cond_wait)(CompatGCond *cond, CompatGMutex *mutex)
 166 {
 167     g_assert(mutex->once.status != G_ONCE_STATUS_PROGRESS);
 168     g_once(&cond->once, do_g_cond_new, NULL);
 169     g_cond_wait((GCond *) cond->once.retval, (GMutex *) mutex->once.retval);
 170 }
 171 #undef g_cond_wait
 172
 173 static inline void (g_cond_broadcast)(CompatGCond *cond)
 174 {
 175     g_once(&cond->once, do_g_cond_new, NULL);
 176     g_cond_broadcast((GCond *) cond->once.retval);
 177 }
 178 #undef g_cond_broadcast
 179
 180 static inline void (g_cond_signal)(CompatGCond *cond)
 181 {
 182     g_once(&cond->once, do_g_cond_new, NULL);
 183     g_cond_signal((GCond *) cond->once.retval);
 184 }
 185 #undef g_cond_signal
 186
 187
 188 /* before 2.31 there was no g_thread_new() */
 189 static inline GThread *g_thread_new(const char *name,
 190                                     GThreadFunc func, gpointer data)
 191 {
 192     GThread *thread = g_thread_create(func, data, TRUE, NULL);
 193     if (!thread) {
 194         g_error("creating thread");
 195     }
 196     return thread;
 197 }
 198 #else
 199 #define CompatGMutex GMutex
 200 #define CompatGCond GCond
 201 #endif /* glib 2.31 */
 202
 203 #endif