numa: add -numa node,memdev= option
[qemu.git] / 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 #if !GLIB_CHECK_VERSION(2, 14, 0)
22 static inline guint g_timeout_add_seconds(guint interval, GSourceFunc function,
23 gpointer data)
24 {
25 return g_timeout_add(interval * 1000, function, data);
26 }
27 #endif
28
29 #ifdef _WIN32
30 /*
31 * g_poll has a problem on Windows when using
32 * timeouts < 10ms, so use wrapper.
33 */
34 #define g_poll(fds, nfds, timeout) g_poll_fixed(fds, nfds, timeout)
35 gint g_poll_fixed(GPollFD *fds, guint nfds, gint timeout);
36 #elif !GLIB_CHECK_VERSION(2, 20, 0)
37 /*
38 * Glib before 2.20.0 doesn't implement g_poll, so wrap it to compile properly
39 * on older systems.
40 */
41 static inline gint g_poll(GPollFD *fds, guint nfds, gint timeout)
42 {
43 GMainContext *ctx = g_main_context_default();
44 return g_main_context_get_poll_func(ctx)(fds, nfds, timeout);
45 }
46 #endif
47
48 #if !GLIB_CHECK_VERSION(2, 31, 0)
49 /* before glib-2.31, GMutex and GCond was dynamic-only (there was a separate
50 * GStaticMutex, but it didn't work with condition variables).
51 *
52 * Our implementation uses GOnce to fake a static implementation that does
53 * not require separate initialization.
54 * We need to rename the types to avoid passing our CompatGMutex/CompatGCond
55 * by mistake to a function that expects GMutex/GCond. However, for ease
56 * of use we keep the GLib function names. GLib uses macros for the
57 * implementation, we use inline functions instead and undefine the macros.
58 */
59
60 typedef struct CompatGMutex {
61 GOnce once;
62 } CompatGMutex;
63
64 typedef struct CompatGCond {
65 GOnce once;
66 } CompatGCond;
67
68 static inline gpointer do_g_mutex_new(gpointer unused)
69 {
70 return (gpointer) g_mutex_new();
71 }
72
73 static inline void g_mutex_init(CompatGMutex *mutex)
74 {
75 mutex->once = (GOnce) G_ONCE_INIT;
76 }
77
78 static inline void g_mutex_clear(CompatGMutex *mutex)
79 {
80 assert(mutex->once.status != G_ONCE_STATUS_PROGRESS);
81 if (mutex->once.retval) {
82 g_mutex_free((GMutex *) mutex->once.retval);
83 }
84 mutex->once = (GOnce) G_ONCE_INIT;
85 }
86
87 static inline void (g_mutex_lock)(CompatGMutex *mutex)
88 {
89 g_once(&mutex->once, do_g_mutex_new, NULL);
90 g_mutex_lock((GMutex *) mutex->once.retval);
91 }
92 #undef g_mutex_lock
93
94 static inline gboolean (g_mutex_trylock)(CompatGMutex *mutex)
95 {
96 g_once(&mutex->once, do_g_mutex_new, NULL);
97 return g_mutex_trylock((GMutex *) mutex->once.retval);
98 }
99 #undef g_mutex_trylock
100
101
102 static inline void (g_mutex_unlock)(CompatGMutex *mutex)
103 {
104 g_mutex_unlock((GMutex *) mutex->once.retval);
105 }
106 #undef g_mutex_unlock
107
108 static inline gpointer do_g_cond_new(gpointer unused)
109 {
110 return (gpointer) g_cond_new();
111 }
112
113 static inline void g_cond_init(CompatGCond *cond)
114 {
115 cond->once = (GOnce) G_ONCE_INIT;
116 }
117
118 static inline void g_cond_clear(CompatGCond *cond)
119 {
120 assert(cond->once.status != G_ONCE_STATUS_PROGRESS);
121 if (cond->once.retval) {
122 g_cond_free((GCond *) cond->once.retval);
123 }
124 cond->once = (GOnce) G_ONCE_INIT;
125 }
126
127 static inline void (g_cond_wait)(CompatGCond *cond, CompatGMutex *mutex)
128 {
129 assert(mutex->once.status != G_ONCE_STATUS_PROGRESS);
130 g_once(&cond->once, do_g_cond_new, NULL);
131 g_cond_wait((GCond *) cond->once.retval, (GMutex *) mutex->once.retval);
132 }
133 #undef g_cond_wait
134
135 static inline void (g_cond_broadcast)(CompatGCond *cond)
136 {
137 g_once(&cond->once, do_g_cond_new, NULL);
138 g_cond_broadcast((GCond *) cond->once.retval);
139 }
140 #undef g_cond_broadcast
141
142 static inline void (g_cond_signal)(CompatGCond *cond)
143 {
144 g_once(&cond->once, do_g_cond_new, NULL);
145 g_cond_signal((GCond *) cond->once.retval);
146 }
147 #undef g_cond_signal
148
149
150 /* before 2.31 there was no g_thread_new() */
151 static inline GThread *g_thread_new(const char *name,
152 GThreadFunc func, gpointer data)
153 {
154 GThread *thread = g_thread_create(func, data, TRUE, NULL);
155 if (!thread) {
156 g_error("creating thread");
157 }
158 return thread;
159 }
160 #else
161 #define CompatGMutex GMutex
162 #define CompatGCond GCond
163 #endif /* glib 2.31 */
164
165 #endif