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 "qemu/osdep.h"
14#include "qemu/thread.h"
15#include "qemu/atomic.h"
16#include "qemu/notify.h"
17#include "qemu-thread-common.h"
18
19static bool name_threads;
20
21void qemu_thread_naming(bool enable)
22{
23 name_threads = enable;
24
25#ifndef CONFIG_THREAD_SETNAME_BYTHREAD
26 /* This is a debugging option, not fatal */
27 if (enable) {
28 fprintf(stderr, "qemu: thread naming not supported on this host\n");
29 }
30#endif
31}
32
33static void error_exit(int err, const char *msg)
34{
35 fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
36 abort();
37}
38
39void qemu_mutex_init(QemuMutex *mutex)
40{
41 int err;
42
43 err = pthread_mutex_init(&mutex->lock, NULL);
44 if (err)
45 error_exit(err, __func__);
46 qemu_mutex_post_init(mutex);
47}
48
49void qemu_mutex_destroy(QemuMutex *mutex)
50{
51 int err;
52
53 assert(mutex->initialized);
54 mutex->initialized = false;
55 err = pthread_mutex_destroy(&mutex->lock);
56 if (err)
57 error_exit(err, __func__);
58}
59
60void qemu_mutex_lock_impl(QemuMutex *mutex, const char *file, const int line)
61{
62 int err;
63
64 assert(mutex->initialized);
65 qemu_mutex_pre_lock(mutex, file, line);
66 err = pthread_mutex_lock(&mutex->lock);
67 if (err)
68 error_exit(err, __func__);
69 qemu_mutex_post_lock(mutex, file, line);
70}
71
72int qemu_mutex_trylock_impl(QemuMutex *mutex, const char *file, const int line)
73{
74 int err;
75
76 assert(mutex->initialized);
77 err = pthread_mutex_trylock(&mutex->lock);
78 if (err == 0) {
79 qemu_mutex_post_lock(mutex, file, line);
80 return 0;
81 }
82 if (err != EBUSY) {
83 error_exit(err, __func__);
84 }
85 return -EBUSY;
86}
87
88void qemu_mutex_unlock_impl(QemuMutex *mutex, const char *file, const int line)
89{
90 int err;
91
92 assert(mutex->initialized);
93 qemu_mutex_pre_unlock(mutex, file, line);
94 err = pthread_mutex_unlock(&mutex->lock);
95 if (err)
96 error_exit(err, __func__);
97}
98
99void qemu_rec_mutex_init(QemuRecMutex *mutex)
100{
101 int err;
102 pthread_mutexattr_t attr;
103
104 pthread_mutexattr_init(&attr);
105 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
106 err = pthread_mutex_init(&mutex->lock, &attr);
107 pthread_mutexattr_destroy(&attr);
108 if (err) {
109 error_exit(err, __func__);
110 }
111 mutex->initialized = true;
112}
113
114void qemu_cond_init(QemuCond *cond)
115{
116 int err;
117
118 err = pthread_cond_init(&cond->cond, NULL);
119 if (err)
120 error_exit(err, __func__);
121 cond->initialized = true;
122}
123
124void qemu_cond_destroy(QemuCond *cond)
125{
126 int err;
127
128 assert(cond->initialized);
129 cond->initialized = false;
130 err = pthread_cond_destroy(&cond->cond);
131 if (err)
132 error_exit(err, __func__);
133}
134
135void qemu_cond_signal(QemuCond *cond)
136{
137 int err;
138
139 assert(cond->initialized);
140 err = pthread_cond_signal(&cond->cond);
141 if (err)
142 error_exit(err, __func__);
143}
144
145void qemu_cond_broadcast(QemuCond *cond)
146{
147 int err;
148
149 assert(cond->initialized);
150 err = pthread_cond_broadcast(&cond->cond);
151 if (err)
152 error_exit(err, __func__);
153}
154
155void qemu_cond_wait_impl(QemuCond *cond, QemuMutex *mutex, const char *file, const int line)
156{
157 int err;
158
159 assert(cond->initialized);
160 qemu_mutex_pre_unlock(mutex, file, line);
161 err = pthread_cond_wait(&cond->cond, &mutex->lock);
162 qemu_mutex_post_lock(mutex, file, line);
163 if (err)
164 error_exit(err, __func__);
165}
166
167void qemu_sem_init(QemuSemaphore *sem, int init)
168{
169 int rc;
170
171#ifndef CONFIG_SEM_TIMEDWAIT
172 rc = pthread_mutex_init(&sem->lock, NULL);
173 if (rc != 0) {
174 error_exit(rc, __func__);
175 }
176 rc = pthread_cond_init(&sem->cond, NULL);
177 if (rc != 0) {
178 error_exit(rc, __func__);
179 }
180 if (init < 0) {
181 error_exit(EINVAL, __func__);
182 }
183 sem->count = init;
184#else
185 rc = sem_init(&sem->sem, 0, init);
186 if (rc < 0) {
187 error_exit(errno, __func__);
188 }
189#endif
190 sem->initialized = true;
191}
192
193void qemu_sem_destroy(QemuSemaphore *sem)
194{
195 int rc;
196
197 assert(sem->initialized);
198 sem->initialized = false;
199#ifndef CONFIG_SEM_TIMEDWAIT
200 rc = pthread_cond_destroy(&sem->cond);
201 if (rc < 0) {
202 error_exit(rc, __func__);
203 }
204 rc = pthread_mutex_destroy(&sem->lock);
205 if (rc < 0) {
206 error_exit(rc, __func__);
207 }
208#else
209 rc = sem_destroy(&sem->sem);
210 if (rc < 0) {
211 error_exit(errno, __func__);
212 }
213#endif
214}
215
216void qemu_sem_post(QemuSemaphore *sem)
217{
218 int rc;
219
220 assert(sem->initialized);
221#ifndef CONFIG_SEM_TIMEDWAIT
222 pthread_mutex_lock(&sem->lock);
223 if (sem->count == UINT_MAX) {
224 rc = EINVAL;
225 } else {
226 sem->count++;
227 rc = pthread_cond_signal(&sem->cond);
228 }
229 pthread_mutex_unlock(&sem->lock);
230 if (rc != 0) {
231 error_exit(rc, __func__);
232 }
233#else
234 rc = sem_post(&sem->sem);
235 if (rc < 0) {
236 error_exit(errno, __func__);
237 }
238#endif
239}
240
241static void compute_abs_deadline(struct timespec *ts, int ms)
242{
243 struct timeval tv;
244 gettimeofday(&tv, NULL);
245 ts->tv_nsec = tv.tv_usec * 1000 + (ms % 1000) * 1000000;
246 ts->tv_sec = tv.tv_sec + ms / 1000;
247 if (ts->tv_nsec >= 1000000000) {
248 ts->tv_sec++;
249 ts->tv_nsec -= 1000000000;
250 }
251}
252
253int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
254{
255 int rc;
256 struct timespec ts;
257
258 assert(sem->initialized);
259#ifndef CONFIG_SEM_TIMEDWAIT
260 rc = 0;
261 compute_abs_deadline(&ts, ms);
262 pthread_mutex_lock(&sem->lock);
263 while (sem->count == 0) {
264 rc = pthread_cond_timedwait(&sem->cond, &sem->lock, &ts);
265 if (rc == ETIMEDOUT) {
266 break;
267 }
268 if (rc != 0) {
269 error_exit(rc, __func__);
270 }
271 }
272 if (rc != ETIMEDOUT) {
273 --sem->count;
274 }
275 pthread_mutex_unlock(&sem->lock);
276 return (rc == ETIMEDOUT ? -1 : 0);
277#else
278 if (ms <= 0) {
279 /* This is cheaper than sem_timedwait. */
280 do {
281 rc = sem_trywait(&sem->sem);
282 } while (rc == -1 && errno == EINTR);
283 if (rc == -1 && errno == EAGAIN) {
284 return -1;
285 }
286 } else {
287 compute_abs_deadline(&ts, ms);
288 do {
289 rc = sem_timedwait(&sem->sem, &ts);
290 } while (rc == -1 && errno == EINTR);
291 if (rc == -1 && errno == ETIMEDOUT) {
292 return -1;
293 }
294 }
295 if (rc < 0) {
296 error_exit(errno, __func__);
297 }
298 return 0;
299#endif
300}
301
302void qemu_sem_wait(QemuSemaphore *sem)
303{
304 int rc;
305
306 assert(sem->initialized);
307#ifndef CONFIG_SEM_TIMEDWAIT
308 pthread_mutex_lock(&sem->lock);
309 while (sem->count == 0) {
310 rc = pthread_cond_wait(&sem->cond, &sem->lock);
311 if (rc != 0) {
312 error_exit(rc, __func__);
313 }
314 }
315 --sem->count;
316 pthread_mutex_unlock(&sem->lock);
317#else
318 do {
319 rc = sem_wait(&sem->sem);
320 } while (rc == -1 && errno == EINTR);
321 if (rc < 0) {
322 error_exit(errno, __func__);
323 }
324#endif
325}
326
327#ifdef __linux__
328#include "qemu/futex.h"
329#else
330static inline void qemu_futex_wake(QemuEvent *ev, int n)
331{
332 assert(ev->initialized);
333 pthread_mutex_lock(&ev->lock);
334 if (n == 1) {
335 pthread_cond_signal(&ev->cond);
336 } else {
337 pthread_cond_broadcast(&ev->cond);
338 }
339 pthread_mutex_unlock(&ev->lock);
340}
341
342static inline void qemu_futex_wait(QemuEvent *ev, unsigned val)
343{
344 assert(ev->initialized);
345 pthread_mutex_lock(&ev->lock);
346 if (ev->value == val) {
347 pthread_cond_wait(&ev->cond, &ev->lock);
348 }
349 pthread_mutex_unlock(&ev->lock);
350}
351#endif
352
353/* Valid transitions:
354 * - free->set, when setting the event
355 * - busy->set, when setting the event, followed by qemu_futex_wake
356 * - set->free, when resetting the event
357 * - free->busy, when waiting
358 *
359 * set->busy does not happen (it can be observed from the outside but
360 * it really is set->free->busy).
361 *
362 * busy->free provably cannot happen; to enforce it, the set->free transition
363 * is done with an OR, which becomes a no-op if the event has concurrently
364 * transitioned to free or busy.
365 */
366
367#define EV_SET 0
368#define EV_FREE 1
369#define EV_BUSY -1
370
371void qemu_event_init(QemuEvent *ev, bool init)
372{
373#ifndef __linux__
374 pthread_mutex_init(&ev->lock, NULL);
375 pthread_cond_init(&ev->cond, NULL);
376#endif
377
378 ev->value = (init ? EV_SET : EV_FREE);
379 ev->initialized = true;
380}
381
382void qemu_event_destroy(QemuEvent *ev)
383{
384 assert(ev->initialized);
385 ev->initialized = false;
386#ifndef __linux__
387 pthread_mutex_destroy(&ev->lock);
388 pthread_cond_destroy(&ev->cond);
389#endif
390}
391
392void qemu_event_set(QemuEvent *ev)
393{
394 /* qemu_event_set has release semantics, but because it *loads*
395 * ev->value we need a full memory barrier here.
396 */
397 assert(ev->initialized);
398 smp_mb();
399 if (atomic_read(&ev->value) != EV_SET) {
400 if (atomic_xchg(&ev->value, EV_SET) == EV_BUSY) {
401 /* There were waiters, wake them up. */
402 qemu_futex_wake(ev, INT_MAX);
403 }
404 }
405}
406
407void qemu_event_reset(QemuEvent *ev)
408{
409 unsigned value;
410
411 assert(ev->initialized);
412 value = atomic_read(&ev->value);
413 smp_mb_acquire();
414 if (value == EV_SET) {
415 /*
416 * If there was a concurrent reset (or even reset+wait),
417 * do nothing. Otherwise change EV_SET->EV_FREE.
418 */
419 atomic_or(&ev->value, EV_FREE);
420 }
421}
422
423void qemu_event_wait(QemuEvent *ev)
424{
425 unsigned value;
426
427 assert(ev->initialized);
428 value = atomic_read(&ev->value);
429 smp_mb_acquire();
430 if (value != EV_SET) {
431 if (value == EV_FREE) {
432 /*
433 * Leave the event reset and tell qemu_event_set that there
434 * are waiters. No need to retry, because there cannot be
435 * a concurrent busy->free transition. After the CAS, the
436 * event will be either set or busy.
437 */
438 if (atomic_cmpxchg(&ev->value, EV_FREE, EV_BUSY) == EV_SET) {
439 return;
440 }
441 }
442 qemu_futex_wait(ev, EV_BUSY);
443 }
444}
445
446static __thread NotifierList thread_exit;
447
448/*
449 * Note that in this implementation you can register a thread-exit
450 * notifier for the main thread, but it will never be called.
451 * This is OK because main thread exit can only happen when the
452 * entire process is exiting, and the API allows notifiers to not
453 * be called on process exit.
454 */
455void qemu_thread_atexit_add(Notifier *notifier)
456{
457 notifier_list_add(&thread_exit, notifier);
458}
459
460void qemu_thread_atexit_remove(Notifier *notifier)
461{
462 notifier_remove(notifier);
463}
464
465static void qemu_thread_atexit_notify(void *arg)
466{
467 /*
468 * Called when non-main thread exits (via qemu_thread_exit()
469 * or by returning from its start routine.)
470 */
471 notifier_list_notify(&thread_exit, NULL);
472}
473
474typedef struct {
475 void *(*start_routine)(void *);
476 void *arg;
477 char *name;
478} QemuThreadArgs;
479
480static void *qemu_thread_start(void *args)
481{
482 QemuThreadArgs *qemu_thread_args = args;
483 void *(*start_routine)(void *) = qemu_thread_args->start_routine;
484 void *arg = qemu_thread_args->arg;
485 void *r;
486
487#ifdef CONFIG_THREAD_SETNAME_BYTHREAD
488 /* Attempt to set the threads name; note that this is for debug, so
489 * we're not going to fail if we can't set it.
490 */
491 if (name_threads && qemu_thread_args->name) {
492# if defined(CONFIG_PTHREAD_SETNAME_NP_W_TID)
493 pthread_setname_np(pthread_self(), qemu_thread_args->name);
494# elif defined(CONFIG_PTHREAD_SETNAME_NP_WO_TID)
495 pthread_setname_np(qemu_thread_args->name);
496# endif
497 }
498#endif
499 g_free(qemu_thread_args->name);
500 g_free(qemu_thread_args);
501 pthread_cleanup_push(qemu_thread_atexit_notify, NULL);
502 r = start_routine(arg);
503 pthread_cleanup_pop(1);
504 return r;
505}
506
507void qemu_thread_create(QemuThread *thread, const char *name,
508 void *(*start_routine)(void*),
509 void *arg, int mode)
510{
511 sigset_t set, oldset;
512 int err;
513 pthread_attr_t attr;
514 QemuThreadArgs *qemu_thread_args;
515
516 err = pthread_attr_init(&attr);
517 if (err) {
518 error_exit(err, __func__);
519 }
520
521 if (mode == QEMU_THREAD_DETACHED) {
522 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
523 }
524
525 /* Leave signal handling to the iothread. */
526 sigfillset(&set);
527 /* Blocking the signals can result in undefined behaviour. */
528 sigdelset(&set, SIGSEGV);
529 sigdelset(&set, SIGFPE);
530 sigdelset(&set, SIGILL);
531 /* TODO avoid SIGBUS loss on macOS */
532 pthread_sigmask(SIG_SETMASK, &set, &oldset);
533
534 qemu_thread_args = g_new0(QemuThreadArgs, 1);
535 qemu_thread_args->name = g_strdup(name);
536 qemu_thread_args->start_routine = start_routine;
537 qemu_thread_args->arg = arg;
538
539 err = pthread_create(&thread->thread, &attr,
540 qemu_thread_start, qemu_thread_args);
541
542 if (err)
543 error_exit(err, __func__);
544
545 pthread_sigmask(SIG_SETMASK, &oldset, NULL);
546
547 pthread_attr_destroy(&attr);
548}
549
550void qemu_thread_get_self(QemuThread *thread)
551{
552 thread->thread = pthread_self();
553}
554
555bool qemu_thread_is_self(QemuThread *thread)
556{
557 return pthread_equal(pthread_self(), thread->thread);
558}
559
560void qemu_thread_exit(void *retval)
561{
562 pthread_exit(retval);
563}
564
565void *qemu_thread_join(QemuThread *thread)
566{
567 int err;
568 void *ret;
569
570 err = pthread_join(thread->thread, &ret);
571 if (err) {
572 error_exit(err, __func__);
573 }
574 return ret;
575}
576