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, 28, 0)
  27 static inline gint64 qemu_g_get_monotonic_time(void)
  28 {
  29     /* g_get_monotonic_time() is best-effort so we can use the wall clock as a
  30      * fallback.
  31      */
  32
  33     GTimeVal time;
  34     g_get_current_time(&time);
  35
  36     return time.tv_sec * G_TIME_SPAN_SECOND + time.tv_usec;
  37 }
  38 /* work around distro backports of this interface */
  39 #define g_get_monotonic_time() qemu_g_get_monotonic_time()
  40 #endif
  41
  42 #if defined(_WIN32) && !GLIB_CHECK_VERSION(2, 50, 0)
  43 /*
  44  * g_poll has a problem on Windows when using
  45  * timeouts < 10ms, so use wrapper.
  46  */
  47 #define g_poll(fds, nfds, timeout) g_poll_fixed(fds, nfds, timeout)
  48 gint g_poll_fixed(GPollFD *fds, guint nfds, gint timeout);
  49 #endif
  50
  51 #if !defined(_WIN32)
  52 #if !GLIB_CHECK_VERSION(2, 30, 0)
  53 /* Not a 100% compatible implementation, but good enough for most
  54  * cases. Placeholders are only supported at the end of the
  55  * template. */
  56 static inline gchar *qemu_g_dir_make_tmp(gchar const *tmpl, GError **error)
  57 {
  58     gchar *path = g_build_filename(g_get_tmp_dir(), tmpl ?: ".XXXXXX", NULL);
  59
  60     if (mkdtemp(path) != NULL) {
  61         return path;
  62     }
  63     /* Error occurred, clean up. */
  64     g_set_error(error, G_FILE_ERROR, g_file_error_from_errno(errno),
  65                 "mkdtemp() failed");
  66     g_free(path);
  67     return NULL;
  68 }
  69
  70 #define g_dir_make_tmp(tmpl, error) qemu_g_dir_make_tmp(tmpl, error)
  71 #endif /* glib 2.30 */
  72 #endif /* !_WIN32 */
  73
  74 #if !GLIB_CHECK_VERSION(2, 31, 0)
  75 /* before glib-2.31, GMutex and GCond was dynamic-only (there was a separate
  76  * GStaticMutex, but it didn't work with condition variables).
  77  *
  78  * Our implementation uses GOnce to fake a static implementation that does
  79  * not require separate initialization.
  80  * We need to rename the types to avoid passing our CompatGMutex/CompatGCond
  81  * by mistake to a function that expects GMutex/GCond.  However, for ease
  82  * of use we keep the GLib function names.  GLib uses macros for the
  83  * implementation, we use inline functions instead and undefine the macros.
  84  */
  85
  86 typedef struct CompatGMutex {
  87     GOnce once;
  88 } CompatGMutex;
  89
  90 typedef struct CompatGCond {
  91     GOnce once;
  92 } CompatGCond;
  93
  94 static inline gpointer do_g_mutex_new(gpointer unused)
  95 {
  96     return (gpointer) g_mutex_new();
  97 }
  98
  99 static inline void g_mutex_init(CompatGMutex *mutex)
 100 {
 101     mutex->once = (GOnce) G_ONCE_INIT;
 102 }
 103
 104 static inline void g_mutex_clear(CompatGMutex *mutex)
 105 {
 106     g_assert(mutex->once.status != G_ONCE_STATUS_PROGRESS);
 107     if (mutex->once.retval) {
 108         g_mutex_free((GMutex *) mutex->once.retval);
 109     }
 110     mutex->once = (GOnce) G_ONCE_INIT;
 111 }
 112
 113 static inline void (g_mutex_lock)(CompatGMutex *mutex)
 114 {
 115     g_once(&mutex->once, do_g_mutex_new, NULL);
 116     g_mutex_lock((GMutex *) mutex->once.retval);
 117 }
 118 #undef g_mutex_lock
 119
 120 static inline gboolean (g_mutex_trylock)(CompatGMutex *mutex)
 121 {
 122     g_once(&mutex->once, do_g_mutex_new, NULL);
 123     return g_mutex_trylock((GMutex *) mutex->once.retval);
 124 }
 125 #undef g_mutex_trylock
 126
 127
 128 static inline void (g_mutex_unlock)(CompatGMutex *mutex)
 129 {
 130     g_mutex_unlock((GMutex *) mutex->once.retval);
 131 }
 132 #undef g_mutex_unlock
 133
 134 static inline gpointer do_g_cond_new(gpointer unused)
 135 {
 136     return (gpointer) g_cond_new();
 137 }
 138
 139 static inline void g_cond_init(CompatGCond *cond)
 140 {
 141     cond->once = (GOnce) G_ONCE_INIT;
 142 }
 143
 144 static inline void g_cond_clear(CompatGCond *cond)
 145 {
 146     g_assert(cond->once.status != G_ONCE_STATUS_PROGRESS);
 147     if (cond->once.retval) {
 148         g_cond_free((GCond *) cond->once.retval);
 149     }
 150     cond->once = (GOnce) G_ONCE_INIT;
 151 }
 152
 153 static inline void (g_cond_wait)(CompatGCond *cond, CompatGMutex *mutex)
 154 {
 155     g_assert(mutex->once.status != G_ONCE_STATUS_PROGRESS);
 156     g_once(&cond->once, do_g_cond_new, NULL);
 157     g_cond_wait((GCond *) cond->once.retval, (GMutex *) mutex->once.retval);
 158 }
 159 #undef g_cond_wait
 160
 161 static inline void (g_cond_broadcast)(CompatGCond *cond)
 162 {
 163     g_once(&cond->once, do_g_cond_new, NULL);
 164     g_cond_broadcast((GCond *) cond->once.retval);
 165 }
 166 #undef g_cond_broadcast
 167
 168 static inline void (g_cond_signal)(CompatGCond *cond)
 169 {
 170     g_once(&cond->once, do_g_cond_new, NULL);
 171     g_cond_signal((GCond *) cond->once.retval);
 172 }
 173 #undef g_cond_signal
 174
 175 static inline gboolean (g_cond_timed_wait)(CompatGCond *cond,
 176                                            CompatGMutex *mutex,
 177                                            GTimeVal *time)
 178 {
 179     g_assert(mutex->once.status != G_ONCE_STATUS_PROGRESS);
 180     g_once(&cond->once, do_g_cond_new, NULL);
 181     return g_cond_timed_wait((GCond *) cond->once.retval,
 182                              (GMutex *) mutex->once.retval, time);
 183 }
 184 #undef g_cond_timed_wait
 185
 186 /* This is not a macro, because it didn't exist until 2.32.  */
 187 static inline gboolean g_cond_wait_until(CompatGCond *cond, CompatGMutex *mutex,
 188                                          gint64 end_time)
 189 {
 190     GTimeVal time;
 191
 192     /* Convert from monotonic to CLOCK_REALTIME.  */
 193     end_time -= g_get_monotonic_time();
 194     g_get_current_time(&time);
 195     end_time += time.tv_sec * G_TIME_SPAN_SECOND + time.tv_usec;
 196
 197     time.tv_sec = end_time / G_TIME_SPAN_SECOND;
 198     time.tv_usec = end_time % G_TIME_SPAN_SECOND;
 199     return g_cond_timed_wait(cond, mutex, &time);
 200 }
 201
 202 /* before 2.31 there was no g_thread_new() */
 203 static inline GThread *g_thread_new(const char *name,
 204                                     GThreadFunc func, gpointer data)
 205 {
 206     GThread *thread = g_thread_create(func, data, TRUE, NULL);
 207     if (!thread) {
 208         g_error("creating thread");
 209     }
 210     return thread;
 211 }
 212 #else
 213 #define CompatGMutex GMutex
 214 #define CompatGCond GCond
 215 #endif /* glib 2.31 */
 216
 217 #if !GLIB_CHECK_VERSION(2, 32, 0)
 218 /* Beware, function returns gboolean since 2.39.2, see GLib commit 9101915 */
 219 static inline void g_hash_table_add(GHashTable *hash_table, gpointer key)
 220 {
 221     g_hash_table_replace(hash_table, key, key);
 222 }
 223
 224 static inline gboolean g_hash_table_contains(GHashTable *hash_table,
 225                                              gpointer key)
 226 {
 227     return g_hash_table_lookup_extended(hash_table, key, NULL, NULL);
 228 }
 229 #endif
 230
 231 #ifndef g_assert_true
 232 #define g_assert_true(expr)                                                    \
 233     do {                                                                       \
 234         if (G_LIKELY(expr)) {                                                  \
 235         } else {                                                               \
 236             g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC,   \
 237                                 "'" #expr "' should be TRUE");                 \
 238         }                                                                      \
 239     } while (0)
 240 #endif
 241
 242 #ifndef g_assert_false
 243 #define g_assert_false(expr)                                                   \
 244     do {                                                                       \
 245         if (G_LIKELY(!(expr))) {                                               \
 246         } else {                                                               \
 247             g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC,   \
 248                                 "'" #expr "' should be FALSE");                \
 249         }                                                                      \
 250     } while (0)
 251 #endif
 252
 253 #ifndef g_assert_null
 254 #define g_assert_null(expr)                                                    \
 255     do {                                                                       \
 256         if (G_LIKELY((expr) == NULL)) {                                        \
 257         } else {                                                               \
 258             g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC,   \
 259                                 "'" #expr "' should be NULL");                 \
 260         }                                                                      \
 261     } while (0)
 262 #endif
 263
 264 #ifndef g_assert_nonnull
 265 #define g_assert_nonnull(expr)                                                 \
 266     do {                                                                       \
 267         if (G_LIKELY((expr) != NULL)) {                                        \
 268         } else {                                                               \
 269             g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC,   \
 270                                 "'" #expr "' should not be NULL");             \
 271         }                                                                      \
 272     } while (0)
 273 #endif
 274
 275 #ifndef g_assert_cmpmem
 276 #define g_assert_cmpmem(m1, l1, m2, l2)                                        \
 277     do {                                                                       \
 278         gconstpointer __m1 = m1, __m2 = m2;                                    \
 279         int __l1 = l1, __l2 = l2;                                              \
 280         if (__l1 != __l2) {                                                    \
 281             g_assertion_message_cmpnum(                                        \
 282                 G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC,                   \
 283                 #l1 " (len(" #m1 ")) == " #l2 " (len(" #m2 "))", __l1, "==",   \
 284                 __l2, 'i');                                                    \
 285         } else if (memcmp(__m1, __m2, __l1) != 0) {                            \
 286             g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC,   \
 287                                 "assertion failed (" #m1 " == " #m2 ")");      \
 288         }                                                                      \
 289     } while (0)
 290 #endif
 291
 292 #if !GLIB_CHECK_VERSION(2, 28, 0)
 293 static inline void g_list_free_full(GList *list, GDestroyNotify free_func)
 294 {
 295     GList *l;
 296
 297     for (l = list; l; l = l->next) {
 298         free_func(l->data);
 299     }
 300
 301     g_list_free(list);
 302 }
 303
 304 static inline void g_slist_free_full(GSList *list, GDestroyNotify free_func)
 305 {
 306     GSList *l;
 307
 308     for (l = list; l; l = l->next) {
 309         free_func(l->data);
 310     }
 311
 312     g_slist_free(list);
 313 }
 314 #endif
 315
 316 #if !GLIB_CHECK_VERSION(2, 26, 0)
 317 static inline void g_source_set_name(GSource *source, const char *name)
 318 {
 319     /* This is just a debugging aid, so leaving it a no-op */
 320 }
 321 static inline void g_source_set_name_by_id(guint tag, const char *name)
 322 {
 323     /* This is just a debugging aid, so leaving it a no-op */
 324 }
 325 #endif
 326
 327 #if !GLIB_CHECK_VERSION(2, 36, 0)
 328 /* Always fail.  This will not include error_report output in the test log,
 329  * sending it instead to stderr.
 330  */
 331 #define g_test_initialized() (0)
 332 #endif
 333 #if !GLIB_CHECK_VERSION(2, 38, 0)
 334 #ifdef CONFIG_HAS_GLIB_SUBPROCESS_TESTS
 335 #error schizophrenic detection of glib subprocess testing
 336 #endif
 337 #define g_test_subprocess() (0)
 338 #endif
 339
 340
 341 #if !GLIB_CHECK_VERSION(2, 34, 0)
 342 static inline void
 343 g_test_add_data_func_full(const char *path,
 344                           gpointer data,
 345                           gpointer fn,
 346                           gpointer data_free_func)
 347 {
 348 #if GLIB_CHECK_VERSION(2, 26, 0)
 349     /* back-compat casts, remove this once we can require new-enough glib */
 350     g_test_add_vtable(path, 0, data, NULL,
 351                       (GTestFixtureFunc)fn, (GTestFixtureFunc) data_free_func);
 352 #else
 353     /* back-compat casts, remove this once we can require new-enough glib */
 354     g_test_add_vtable(path, 0, data, NULL,
 355                       (void (*)(void)) fn, (void (*)(void)) data_free_func);
 356 #endif
 357 }
 358 #endif
 359
 360
 361 #endif