migration: force QEMUFile to blocking mode for outgoing migration
[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 /* 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 #ifdef _WIN32
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 !GLIB_CHECK_VERSION(2, 31, 0)
52 /* before glib-2.31, GMutex and GCond was dynamic-only (there was a separate
53 * GStaticMutex, but it didn't work with condition variables).
54 *
55 * Our implementation uses GOnce to fake a static implementation that does
56 * not require separate initialization.
57 * We need to rename the types to avoid passing our CompatGMutex/CompatGCond
58 * by mistake to a function that expects GMutex/GCond. However, for ease
59 * of use we keep the GLib function names. GLib uses macros for the
60 * implementation, we use inline functions instead and undefine the macros.
61 */
62
63 typedef struct CompatGMutex {
64 GOnce once;
65 } CompatGMutex;
66
67 typedef struct CompatGCond {
68 GOnce once;
69 } CompatGCond;
70
71 static inline gpointer do_g_mutex_new(gpointer unused)
72 {
73 return (gpointer) g_mutex_new();
74 }
75
76 static inline void g_mutex_init(CompatGMutex *mutex)
77 {
78 mutex->once = (GOnce) G_ONCE_INIT;
79 }
80
81 static inline void g_mutex_clear(CompatGMutex *mutex)
82 {
83 g_assert(mutex->once.status != G_ONCE_STATUS_PROGRESS);
84 if (mutex->once.retval) {
85 g_mutex_free((GMutex *) mutex->once.retval);
86 }
87 mutex->once = (GOnce) G_ONCE_INIT;
88 }
89
90 static inline void (g_mutex_lock)(CompatGMutex *mutex)
91 {
92 g_once(&mutex->once, do_g_mutex_new, NULL);
93 g_mutex_lock((GMutex *) mutex->once.retval);
94 }
95 #undef g_mutex_lock
96
97 static inline gboolean (g_mutex_trylock)(CompatGMutex *mutex)
98 {
99 g_once(&mutex->once, do_g_mutex_new, NULL);
100 return g_mutex_trylock((GMutex *) mutex->once.retval);
101 }
102 #undef g_mutex_trylock
103
104
105 static inline void (g_mutex_unlock)(CompatGMutex *mutex)
106 {
107 g_mutex_unlock((GMutex *) mutex->once.retval);
108 }
109 #undef g_mutex_unlock
110
111 static inline gpointer do_g_cond_new(gpointer unused)
112 {
113 return (gpointer) g_cond_new();
114 }
115
116 static inline void g_cond_init(CompatGCond *cond)
117 {
118 cond->once = (GOnce) G_ONCE_INIT;
119 }
120
121 static inline void g_cond_clear(CompatGCond *cond)
122 {
123 g_assert(cond->once.status != G_ONCE_STATUS_PROGRESS);
124 if (cond->once.retval) {
125 g_cond_free((GCond *) cond->once.retval);
126 }
127 cond->once = (GOnce) G_ONCE_INIT;
128 }
129
130 static inline void (g_cond_wait)(CompatGCond *cond, CompatGMutex *mutex)
131 {
132 g_assert(mutex->once.status != G_ONCE_STATUS_PROGRESS);
133 g_once(&cond->once, do_g_cond_new, NULL);
134 g_cond_wait((GCond *) cond->once.retval, (GMutex *) mutex->once.retval);
135 }
136 #undef g_cond_wait
137
138 static inline void (g_cond_broadcast)(CompatGCond *cond)
139 {
140 g_once(&cond->once, do_g_cond_new, NULL);
141 g_cond_broadcast((GCond *) cond->once.retval);
142 }
143 #undef g_cond_broadcast
144
145 static inline void (g_cond_signal)(CompatGCond *cond)
146 {
147 g_once(&cond->once, do_g_cond_new, NULL);
148 g_cond_signal((GCond *) cond->once.retval);
149 }
150 #undef g_cond_signal
151
152
153 /* before 2.31 there was no g_thread_new() */
154 static inline GThread *g_thread_new(const char *name,
155 GThreadFunc func, gpointer data)
156 {
157 GThread *thread = g_thread_create(func, data, TRUE, NULL);
158 if (!thread) {
159 g_error("creating thread");
160 }
161 return thread;
162 }
163 #else
164 #define CompatGMutex GMutex
165 #define CompatGCond GCond
166 #endif /* glib 2.31 */
167
168 #if !GLIB_CHECK_VERSION(2, 32, 0)
169 /* Beware, function returns gboolean since 2.39.2, see GLib commit 9101915 */
170 static inline void g_hash_table_add(GHashTable *hash_table, gpointer key)
171 {
172 g_hash_table_replace(hash_table, key, key);
173 }
174 #endif
175
176 #ifndef g_assert_true
177 #define g_assert_true(expr) \
178 do { \
179 if (G_LIKELY(expr)) { \
180 } else { \
181 g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
182 "'" #expr "' should be TRUE"); \
183 } \
184 } while (0)
185 #endif
186
187 #ifndef g_assert_false
188 #define g_assert_false(expr) \
189 do { \
190 if (G_LIKELY(!(expr))) { \
191 } else { \
192 g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
193 "'" #expr "' should be FALSE"); \
194 } \
195 } while (0)
196 #endif
197
198 #ifndef g_assert_null
199 #define g_assert_null(expr) \
200 do { \
201 if (G_LIKELY((expr) == NULL)) { \
202 } else { \
203 g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
204 "'" #expr "' should be NULL"); \
205 } \
206 } while (0)
207 #endif
208
209 #ifndef g_assert_nonnull
210 #define g_assert_nonnull(expr) \
211 do { \
212 if (G_LIKELY((expr) != NULL)) { \
213 } else { \
214 g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
215 "'" #expr "' should not be NULL"); \
216 } \
217 } while (0)
218 #endif
219
220 #ifndef g_assert_cmpmem
221 #define g_assert_cmpmem(m1, l1, m2, l2) \
222 do { \
223 gconstpointer __m1 = m1, __m2 = m2; \
224 int __l1 = l1, __l2 = l2; \
225 if (__l1 != __l2) { \
226 g_assertion_message_cmpnum( \
227 G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
228 #l1 " (len(" #m1 ")) == " #l2 " (len(" #m2 "))", __l1, "==", \
229 __l2, 'i'); \
230 } else if (memcmp(__m1, __m2, __l1) != 0) { \
231 g_assertion_message(G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
232 "assertion failed (" #m1 " == " #m2 ")"); \
233 } \
234 } while (0)
235 #endif
236
237 #endif