Added license information
[kvmfornfv.git] / qemu / util / qemu-thread-posix.c
1 /*
2  * Wrappers around mutex/cond/thread functions
3  *
4  * Copyright Red Hat, Inc. 2009
5  *
6  * Author:
7  *  Marcelo Tosatti <mtosatti@redhat.com>
8  *
9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
10  * See the COPYING file in the top-level directory.
11  *
12  */
13 #include <stdlib.h>
14 #include <stdio.h>
15 #include <errno.h>
16 #include <time.h>
17 #include <signal.h>
18 #include <stdint.h>
19 #include <string.h>
20 #include <limits.h>
21 #include <unistd.h>
22 #include <sys/time.h>
23 #ifdef __linux__
24 #include <sys/syscall.h>
25 #include <linux/futex.h>
26 #endif
27 #include "qemu/thread.h"
28 #include "qemu/atomic.h"
29 #include "qemu/notify.h"
30
31 static bool name_threads;
32
33 void qemu_thread_naming(bool enable)
34 {
35     name_threads = enable;
36
37 #ifndef CONFIG_THREAD_SETNAME_BYTHREAD
38     /* This is a debugging option, not fatal */
39     if (enable) {
40         fprintf(stderr, "qemu: thread naming not supported on this host\n");
41     }
42 #endif
43 }
44
45 static void error_exit(int err, const char *msg)
46 {
47     fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
48     abort();
49 }
50
51 void qemu_mutex_init(QemuMutex *mutex)
52 {
53     int err;
54
55     err = pthread_mutex_init(&mutex->lock, NULL);
56     if (err)
57         error_exit(err, __func__);
58 }
59
60 void qemu_mutex_destroy(QemuMutex *mutex)
61 {
62     int err;
63
64     err = pthread_mutex_destroy(&mutex->lock);
65     if (err)
66         error_exit(err, __func__);
67 }
68
69 void qemu_mutex_lock(QemuMutex *mutex)
70 {
71     int err;
72
73     err = pthread_mutex_lock(&mutex->lock);
74     if (err)
75         error_exit(err, __func__);
76 }
77
78 int qemu_mutex_trylock(QemuMutex *mutex)
79 {
80     return pthread_mutex_trylock(&mutex->lock);
81 }
82
83 void qemu_mutex_unlock(QemuMutex *mutex)
84 {
85     int err;
86
87     err = pthread_mutex_unlock(&mutex->lock);
88     if (err)
89         error_exit(err, __func__);
90 }
91
92 void qemu_cond_init(QemuCond *cond)
93 {
94     int err;
95
96     err = pthread_cond_init(&cond->cond, NULL);
97     if (err)
98         error_exit(err, __func__);
99 }
100
101 void qemu_cond_destroy(QemuCond *cond)
102 {
103     int err;
104
105     err = pthread_cond_destroy(&cond->cond);
106     if (err)
107         error_exit(err, __func__);
108 }
109
110 void qemu_cond_signal(QemuCond *cond)
111 {
112     int err;
113
114     err = pthread_cond_signal(&cond->cond);
115     if (err)
116         error_exit(err, __func__);
117 }
118
119 void qemu_cond_broadcast(QemuCond *cond)
120 {
121     int err;
122
123     err = pthread_cond_broadcast(&cond->cond);
124     if (err)
125         error_exit(err, __func__);
126 }
127
128 void qemu_cond_wait(QemuCond *cond, QemuMutex *mutex)
129 {
130     int err;
131
132     err = pthread_cond_wait(&cond->cond, &mutex->lock);
133     if (err)
134         error_exit(err, __func__);
135 }
136
137 void qemu_sem_init(QemuSemaphore *sem, int init)
138 {
139     int rc;
140
141 #if defined(__APPLE__) || defined(__NetBSD__)
142     rc = pthread_mutex_init(&sem->lock, NULL);
143     if (rc != 0) {
144         error_exit(rc, __func__);
145     }
146     rc = pthread_cond_init(&sem->cond, NULL);
147     if (rc != 0) {
148         error_exit(rc, __func__);
149     }
150     if (init < 0) {
151         error_exit(EINVAL, __func__);
152     }
153     sem->count = init;
154 #else
155     rc = sem_init(&sem->sem, 0, init);
156     if (rc < 0) {
157         error_exit(errno, __func__);
158     }
159 #endif
160 }
161
162 void qemu_sem_destroy(QemuSemaphore *sem)
163 {
164     int rc;
165
166 #if defined(__APPLE__) || defined(__NetBSD__)
167     rc = pthread_cond_destroy(&sem->cond);
168     if (rc < 0) {
169         error_exit(rc, __func__);
170     }
171     rc = pthread_mutex_destroy(&sem->lock);
172     if (rc < 0) {
173         error_exit(rc, __func__);
174     }
175 #else
176     rc = sem_destroy(&sem->sem);
177     if (rc < 0) {
178         error_exit(errno, __func__);
179     }
180 #endif
181 }
182
183 void qemu_sem_post(QemuSemaphore *sem)
184 {
185     int rc;
186
187 #if defined(__APPLE__) || defined(__NetBSD__)
188     pthread_mutex_lock(&sem->lock);
189     if (sem->count == UINT_MAX) {
190         rc = EINVAL;
191     } else {
192         sem->count++;
193         rc = pthread_cond_signal(&sem->cond);
194     }
195     pthread_mutex_unlock(&sem->lock);
196     if (rc != 0) {
197         error_exit(rc, __func__);
198     }
199 #else
200     rc = sem_post(&sem->sem);
201     if (rc < 0) {
202         error_exit(errno, __func__);
203     }
204 #endif
205 }
206
207 static void compute_abs_deadline(struct timespec *ts, int ms)
208 {
209     struct timeval tv;
210     gettimeofday(&tv, NULL);
211     ts->tv_nsec = tv.tv_usec * 1000 + (ms % 1000) * 1000000;
212     ts->tv_sec = tv.tv_sec + ms / 1000;
213     if (ts->tv_nsec >= 1000000000) {
214         ts->tv_sec++;
215         ts->tv_nsec -= 1000000000;
216     }
217 }
218
219 int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
220 {
221     int rc;
222     struct timespec ts;
223
224 #if defined(__APPLE__) || defined(__NetBSD__)
225     rc = 0;
226     compute_abs_deadline(&ts, ms);
227     pthread_mutex_lock(&sem->lock);
228     while (sem->count == 0) {
229         rc = pthread_cond_timedwait(&sem->cond, &sem->lock, &ts);
230         if (rc == ETIMEDOUT) {
231             break;
232         }
233         if (rc != 0) {
234             error_exit(rc, __func__);
235         }
236     }
237     if (rc != ETIMEDOUT) {
238         --sem->count;
239     }
240     pthread_mutex_unlock(&sem->lock);
241     return (rc == ETIMEDOUT ? -1 : 0);
242 #else
243     if (ms <= 0) {
244         /* This is cheaper than sem_timedwait.  */
245         do {
246             rc = sem_trywait(&sem->sem);
247         } while (rc == -1 && errno == EINTR);
248         if (rc == -1 && errno == EAGAIN) {
249             return -1;
250         }
251     } else {
252         compute_abs_deadline(&ts, ms);
253         do {
254             rc = sem_timedwait(&sem->sem, &ts);
255         } while (rc == -1 && errno == EINTR);
256         if (rc == -1 && errno == ETIMEDOUT) {
257             return -1;
258         }
259     }
260     if (rc < 0) {
261         error_exit(errno, __func__);
262     }
263     return 0;
264 #endif
265 }
266
267 void qemu_sem_wait(QemuSemaphore *sem)
268 {
269     int rc;
270
271 #if defined(__APPLE__) || defined(__NetBSD__)
272     pthread_mutex_lock(&sem->lock);
273     while (sem->count == 0) {
274         rc = pthread_cond_wait(&sem->cond, &sem->lock);
275         if (rc != 0) {
276             error_exit(rc, __func__);
277         }
278     }
279     --sem->count;
280     pthread_mutex_unlock(&sem->lock);
281 #else
282     do {
283         rc = sem_wait(&sem->sem);
284     } while (rc == -1 && errno == EINTR);
285     if (rc < 0) {
286         error_exit(errno, __func__);
287     }
288 #endif
289 }
290
291 #ifdef __linux__
292 #define futex(...)              syscall(__NR_futex, __VA_ARGS__)
293
294 static inline void futex_wake(QemuEvent *ev, int n)
295 {
296     futex(ev, FUTEX_WAKE, n, NULL, NULL, 0);
297 }
298
299 static inline void futex_wait(QemuEvent *ev, unsigned val)
300 {
301     futex(ev, FUTEX_WAIT, (int) val, NULL, NULL, 0);
302 }
303 #else
304 static inline void futex_wake(QemuEvent *ev, int n)
305 {
306     pthread_mutex_lock(&ev->lock);
307     if (n == 1) {
308         pthread_cond_signal(&ev->cond);
309     } else {
310         pthread_cond_broadcast(&ev->cond);
311     }
312     pthread_mutex_unlock(&ev->lock);
313 }
314
315 static inline void futex_wait(QemuEvent *ev, unsigned val)
316 {
317     pthread_mutex_lock(&ev->lock);
318     if (ev->value == val) {
319         pthread_cond_wait(&ev->cond, &ev->lock);
320     }
321     pthread_mutex_unlock(&ev->lock);
322 }
323 #endif
324
325 /* Valid transitions:
326  * - free->set, when setting the event
327  * - busy->set, when setting the event, followed by futex_wake
328  * - set->free, when resetting the event
329  * - free->busy, when waiting
330  *
331  * set->busy does not happen (it can be observed from the outside but
332  * it really is set->free->busy).
333  *
334  * busy->free provably cannot happen; to enforce it, the set->free transition
335  * is done with an OR, which becomes a no-op if the event has concurrently
336  * transitioned to free or busy.
337  */
338
339 #define EV_SET         0
340 #define EV_FREE        1
341 #define EV_BUSY       -1
342
343 void qemu_event_init(QemuEvent *ev, bool init)
344 {
345 #ifndef __linux__
346     pthread_mutex_init(&ev->lock, NULL);
347     pthread_cond_init(&ev->cond, NULL);
348 #endif
349
350     ev->value = (init ? EV_SET : EV_FREE);
351 }
352
353 void qemu_event_destroy(QemuEvent *ev)
354 {
355 #ifndef __linux__
356     pthread_mutex_destroy(&ev->lock);
357     pthread_cond_destroy(&ev->cond);
358 #endif
359 }
360
361 void qemu_event_set(QemuEvent *ev)
362 {
363     if (atomic_mb_read(&ev->value) != EV_SET) {
364         if (atomic_xchg(&ev->value, EV_SET) == EV_BUSY) {
365             /* There were waiters, wake them up.  */
366             futex_wake(ev, INT_MAX);
367         }
368     }
369 }
370
371 void qemu_event_reset(QemuEvent *ev)
372 {
373     if (atomic_mb_read(&ev->value) == EV_SET) {
374         /*
375          * If there was a concurrent reset (or even reset+wait),
376          * do nothing.  Otherwise change EV_SET->EV_FREE.
377          */
378         atomic_or(&ev->value, EV_FREE);
379     }
380 }
381
382 void qemu_event_wait(QemuEvent *ev)
383 {
384     unsigned value;
385
386     value = atomic_mb_read(&ev->value);
387     if (value != EV_SET) {
388         if (value == EV_FREE) {
389             /*
390              * Leave the event reset and tell qemu_event_set that there
391              * are waiters.  No need to retry, because there cannot be
392              * a concurent busy->free transition.  After the CAS, the
393              * event will be either set or busy.
394              */
395             if (atomic_cmpxchg(&ev->value, EV_FREE, EV_BUSY) == EV_SET) {
396                 return;
397             }
398         }
399         futex_wait(ev, EV_BUSY);
400     }
401 }
402
403 static pthread_key_t exit_key;
404
405 union NotifierThreadData {
406     void *ptr;
407     NotifierList list;
408 };
409 QEMU_BUILD_BUG_ON(sizeof(union NotifierThreadData) != sizeof(void *));
410
411 void qemu_thread_atexit_add(Notifier *notifier)
412 {
413     union NotifierThreadData ntd;
414     ntd.ptr = pthread_getspecific(exit_key);
415     notifier_list_add(&ntd.list, notifier);
416     pthread_setspecific(exit_key, ntd.ptr);
417 }
418
419 void qemu_thread_atexit_remove(Notifier *notifier)
420 {
421     union NotifierThreadData ntd;
422     ntd.ptr = pthread_getspecific(exit_key);
423     notifier_remove(notifier);
424     pthread_setspecific(exit_key, ntd.ptr);
425 }
426
427 static void qemu_thread_atexit_run(void *arg)
428 {
429     union NotifierThreadData ntd = { .ptr = arg };
430     notifier_list_notify(&ntd.list, NULL);
431 }
432
433 static void __attribute__((constructor)) qemu_thread_atexit_init(void)
434 {
435     pthread_key_create(&exit_key, qemu_thread_atexit_run);
436 }
437
438
439 /* Attempt to set the threads name; note that this is for debug, so
440  * we're not going to fail if we can't set it.
441  */
442 static void qemu_thread_set_name(QemuThread *thread, const char *name)
443 {
444 #ifdef CONFIG_PTHREAD_SETNAME_NP
445     pthread_setname_np(thread->thread, name);
446 #endif
447 }
448
449 void qemu_thread_create(QemuThread *thread, const char *name,
450                        void *(*start_routine)(void*),
451                        void *arg, int mode)
452 {
453     sigset_t set, oldset;
454     int err;
455     pthread_attr_t attr;
456
457     err = pthread_attr_init(&attr);
458     if (err) {
459         error_exit(err, __func__);
460     }
461     if (mode == QEMU_THREAD_DETACHED) {
462         err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
463         if (err) {
464             error_exit(err, __func__);
465         }
466     }
467
468     /* Leave signal handling to the iothread.  */
469     sigfillset(&set);
470     pthread_sigmask(SIG_SETMASK, &set, &oldset);
471     err = pthread_create(&thread->thread, &attr, start_routine, arg);
472     if (err)
473         error_exit(err, __func__);
474
475     if (name_threads) {
476         qemu_thread_set_name(thread, name);
477     }
478
479     pthread_sigmask(SIG_SETMASK, &oldset, NULL);
480
481     pthread_attr_destroy(&attr);
482 }
483
484 void qemu_thread_get_self(QemuThread *thread)
485 {
486     thread->thread = pthread_self();
487 }
488
489 bool qemu_thread_is_self(QemuThread *thread)
490 {
491    return pthread_equal(pthread_self(), thread->thread);
492 }
493
494 void qemu_thread_exit(void *retval)
495 {
496     pthread_exit(retval);
497 }
498
499 void *qemu_thread_join(QemuThread *thread)
500 {
501     int err;
502     void *ret;
503
504     err = pthread_join(thread->thread, &ret);
505     if (err) {
506         error_exit(err, __func__);
507     }
508     return ret;
509 }