[mirror_qemu.git] / util / qemu-thread-posix.c

/*
 * Wrappers around mutex/cond/thread functions
 *
 * Copyright Red Hat, Inc. 2009
 *
 * Author:
 *  Marcelo Tosatti <mtosatti@redhat.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 *
 */
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include <signal.h>
#include <stdint.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#include <sys/time.h>
#ifdef __linux__
#include <sys/syscall.h>
#include <linux/futex.h>
#endif
#include "qemu/thread.h"
#include "qemu/atomic.h"
#include "qemu/notify.h"

static bool name_threads;

void qemu_thread_naming(bool enable)
{
    name_threads = enable;

#ifndef CONFIG_THREAD_SETNAME_BYTHREAD
    /* This is a debugging option, not fatal */
    if (enable) {
        fprintf(stderr, "qemu: thread naming not supported on this host\n");
    }
#endif
}

static void error_exit(int err, const char *msg)
{
    fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
    abort();
}

void qemu_mutex_init(QemuMutex *mutex)
{
    int err;

    err = pthread_mutex_init(&mutex->lock, NULL);
    if (err)
        error_exit(err, __func__);
}

void qemu_mutex_destroy(QemuMutex *mutex)
{
    int err;

    err = pthread_mutex_destroy(&mutex->lock);
    if (err)
        error_exit(err, __func__);
}

void qemu_mutex_lock(QemuMutex *mutex)
{
    int err;

    err = pthread_mutex_lock(&mutex->lock);
    if (err)
        error_exit(err, __func__);
}

int qemu_mutex_trylock(QemuMutex *mutex)
{
    return pthread_mutex_trylock(&mutex->lock);
}

void qemu_mutex_unlock(QemuMutex *mutex)
{
    int err;

    err = pthread_mutex_unlock(&mutex->lock);
    if (err)
        error_exit(err, __func__);
}

void qemu_cond_init(QemuCond *cond)
{
    int err;

    err = pthread_cond_init(&cond->cond, NULL);
    if (err)
        error_exit(err, __func__);
}

void qemu_cond_destroy(QemuCond *cond)
{
    int err;

    err = pthread_cond_destroy(&cond->cond);
    if (err)
        error_exit(err, __func__);
}

void qemu_cond_signal(QemuCond *cond)
{
    int err;

    err = pthread_cond_signal(&cond->cond);
    if (err)
        error_exit(err, __func__);
}

void qemu_cond_broadcast(QemuCond *cond)
{
    int err;

    err = pthread_cond_broadcast(&cond->cond);
    if (err)
        error_exit(err, __func__);
}

void qemu_cond_wait(QemuCond *cond, QemuMutex *mutex)
{
    int err;

    err = pthread_cond_wait(&cond->cond, &mutex->lock);
    if (err)
        error_exit(err, __func__);
}

void qemu_sem_init(QemuSemaphore *sem, int init)
{
    int rc;

#if defined(__APPLE__) || defined(__NetBSD__)
    rc = pthread_mutex_init(&sem->lock, NULL);
    if (rc != 0) {
        error_exit(rc, __func__);
    }
    rc = pthread_cond_init(&sem->cond, NULL);
    if (rc != 0) {
        error_exit(rc, __func__);
    }
    if (init < 0) {
        error_exit(EINVAL, __func__);
    }
    sem->count = init;
#else
    rc = sem_init(&sem->sem, 0, init);
    if (rc < 0) {
        error_exit(errno, __func__);
    }
#endif
}

void qemu_sem_destroy(QemuSemaphore *sem)
{
    int rc;

#if defined(__APPLE__) || defined(__NetBSD__)
    rc = pthread_cond_destroy(&sem->cond);
    if (rc < 0) {
        error_exit(rc, __func__);
    }
    rc = pthread_mutex_destroy(&sem->lock);
    if (rc < 0) {
        error_exit(rc, __func__);
    }
#else
    rc = sem_destroy(&sem->sem);
    if (rc < 0) {
        error_exit(errno, __func__);
    }
#endif
}

void qemu_sem_post(QemuSemaphore *sem)
{
    int rc;

#if defined(__APPLE__) || defined(__NetBSD__)
    pthread_mutex_lock(&sem->lock);
    if (sem->count == UINT_MAX) {
        rc = EINVAL;
    } else {
        sem->count++;
        rc = pthread_cond_signal(&sem->cond);
    }
    pthread_mutex_unlock(&sem->lock);
    if (rc != 0) {
        error_exit(rc, __func__);
    }
#else
    rc = sem_post(&sem->sem);
    if (rc < 0) {
        error_exit(errno, __func__);
    }
#endif
}

static void compute_abs_deadline(struct timespec *ts, int ms)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    ts->tv_nsec = tv.tv_usec * 1000 + (ms % 1000) * 1000000;
    ts->tv_sec = tv.tv_sec + ms / 1000;
    if (ts->tv_nsec >= 1000000000) {
        ts->tv_sec++;
        ts->tv_nsec -= 1000000000;
    }
}

int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
{
    int rc;
    struct timespec ts;

#if defined(__APPLE__) || defined(__NetBSD__)
    rc = 0;
    compute_abs_deadline(&ts, ms);
    pthread_mutex_lock(&sem->lock);
    while (sem->count == 0) {
        rc = pthread_cond_timedwait(&sem->cond, &sem->lock, &ts);
        if (rc == ETIMEDOUT) {
            break;
        }
        if (rc != 0) {
            error_exit(rc, __func__);
        }
    }
    if (rc != ETIMEDOUT) {
        --sem->count;
    }
    pthread_mutex_unlock(&sem->lock);
    return (rc == ETIMEDOUT ? -1 : 0);
#else
    if (ms <= 0) {
        /* This is cheaper than sem_timedwait.  */
        do {
            rc = sem_trywait(&sem->sem);
        } while (rc == -1 && errno == EINTR);
        if (rc == -1 && errno == EAGAIN) {
            return -1;
        }
    } else {
        compute_abs_deadline(&ts, ms);
        do {
            rc = sem_timedwait(&sem->sem, &ts);
        } while (rc == -1 && errno == EINTR);
        if (rc == -1 && errno == ETIMEDOUT) {
            return -1;
        }
    }
    if (rc < 0) {
        error_exit(errno, __func__);
    }
    return 0;
#endif
}

void qemu_sem_wait(QemuSemaphore *sem)
{
    int rc;

#if defined(__APPLE__) || defined(__NetBSD__)
    pthread_mutex_lock(&sem->lock);
    while (sem->count == 0) {
        rc = pthread_cond_wait(&sem->cond, &sem->lock);
        if (rc != 0) {
            error_exit(rc, __func__);
        }
    }
    --sem->count;
    pthread_mutex_unlock(&sem->lock);
#else
    do {
        rc = sem_wait(&sem->sem);
    } while (rc == -1 && errno == EINTR);
    if (rc < 0) {
        error_exit(errno, __func__);
    }
#endif
}

#ifdef __linux__
#define futex(...)              syscall(__NR_futex, __VA_ARGS__)

static inline void futex_wake(QemuEvent *ev, int n)
{
    futex(ev, FUTEX_WAKE, n, NULL, NULL, 0);
}

static inline void futex_wait(QemuEvent *ev, unsigned val)
{
    futex(ev, FUTEX_WAIT, (int) val, NULL, NULL, 0);
}
#else
static inline void futex_wake(QemuEvent *ev, int n)
{
    pthread_mutex_lock(&ev->lock);
    if (n == 1) {
        pthread_cond_signal(&ev->cond);
    } else {
        pthread_cond_broadcast(&ev->cond);
    }
    pthread_mutex_unlock(&ev->lock);
}

static inline void futex_wait(QemuEvent *ev, unsigned val)
{
    pthread_mutex_lock(&ev->lock);
    if (ev->value == val) {
        pthread_cond_wait(&ev->cond, &ev->lock);
    }
    pthread_mutex_unlock(&ev->lock);
}
#endif

/* Valid transitions:
 * - free->set, when setting the event
 * - busy->set, when setting the event, followed by futex_wake
 * - set->free, when resetting the event
 * - free->busy, when waiting
 *
 * set->busy does not happen (it can be observed from the outside but
 * it really is set->free->busy).
 *
 * busy->free provably cannot happen; to enforce it, the set->free transition
 * is done with an OR, which becomes a no-op if the event has concurrently
 * transitioned to free or busy.
 */

#define EV_SET         0
#define EV_FREE        1
#define EV_BUSY       -1

void qemu_event_init(QemuEvent *ev, bool init)
{
#ifndef __linux__
    pthread_mutex_init(&ev->lock, NULL);
    pthread_cond_init(&ev->cond, NULL);
#endif

    ev->value = (init ? EV_SET : EV_FREE);
}

void qemu_event_destroy(QemuEvent *ev)
{
#ifndef __linux__
    pthread_mutex_destroy(&ev->lock);
    pthread_cond_destroy(&ev->cond);
#endif
}

void qemu_event_set(QemuEvent *ev)
{
    if (atomic_mb_read(&ev->value) != EV_SET) {
        if (atomic_xchg(&ev->value, EV_SET) == EV_BUSY) {
            /* There were waiters, wake them up.  */
            futex_wake(ev, INT_MAX);
        }
    }
}

void qemu_event_reset(QemuEvent *ev)
{
    if (atomic_mb_read(&ev->value) == EV_SET) {
        /*
         * If there was a concurrent reset (or even reset+wait),
         * do nothing.  Otherwise change EV_SET->EV_FREE.
         */
        atomic_or(&ev->value, EV_FREE);
    }
}

void qemu_event_wait(QemuEvent *ev)
{
    unsigned value;

    value = atomic_mb_read(&ev->value);
    if (value != EV_SET) {
        if (value == EV_FREE) {
            /*
             * Leave the event reset and tell qemu_event_set that there
             * are waiters.  No need to retry, because there cannot be
             * a concurent busy->free transition.  After the CAS, the
             * event will be either set or busy.
             */
            if (atomic_cmpxchg(&ev->value, EV_FREE, EV_BUSY) == EV_SET) {
                return;
            }
        }
        futex_wait(ev, EV_BUSY);
    }
}

static pthread_key_t exit_key;

union NotifierThreadData {
    void *ptr;
    NotifierList list;
};
QEMU_BUILD_BUG_ON(sizeof(union NotifierThreadData) != sizeof(void *));

void qemu_thread_atexit_add(Notifier *notifier)
{
    union NotifierThreadData ntd;
    ntd.ptr = pthread_getspecific(exit_key);
    notifier_list_add(&ntd.list, notifier);
    pthread_setspecific(exit_key, ntd.ptr);
}

void qemu_thread_atexit_remove(Notifier *notifier)
{
    union NotifierThreadData ntd;
    ntd.ptr = pthread_getspecific(exit_key);
    notifier_remove(notifier);
    pthread_setspecific(exit_key, ntd.ptr);
}

static void qemu_thread_atexit_run(void *arg)
{
    union NotifierThreadData ntd = { .ptr = arg };
    notifier_list_notify(&ntd.list, NULL);
}

static void __attribute__((constructor)) qemu_thread_atexit_init(void)
{
    pthread_key_create(&exit_key, qemu_thread_atexit_run);
}


/* Attempt to set the threads name; note that this is for debug, so
 * we're not going to fail if we can't set it.
 */
static void qemu_thread_set_name(QemuThread *thread, const char *name)
{
#ifdef CONFIG_PTHREAD_SETNAME_NP
    pthread_setname_np(thread->thread, name);
#endif
}

void qemu_thread_create(QemuThread *thread, const char *name,
                       void *(*start_routine)(void*),
                       void *arg, int mode)
{
    sigset_t set, oldset;
    int err;
    pthread_attr_t attr;

    err = pthread_attr_init(&attr);
    if (err) {
        error_exit(err, __func__);
    }
    if (mode == QEMU_THREAD_DETACHED) {
        err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
        if (err) {
            error_exit(err, __func__);
        }
    }

    /* Leave signal handling to the iothread.  */
    sigfillset(&set);
    pthread_sigmask(SIG_SETMASK, &set, &oldset);
    err = pthread_create(&thread->thread, &attr, start_routine, arg);
    if (err)
        error_exit(err, __func__);

    if (name_threads) {
        qemu_thread_set_name(thread, name);
    }

    pthread_sigmask(SIG_SETMASK, &oldset, NULL);

    pthread_attr_destroy(&attr);
}

void qemu_thread_get_self(QemuThread *thread)
{
    thread->thread = pthread_self();
}

bool qemu_thread_is_self(QemuThread *thread)
{
   return pthread_equal(pthread_self(), thread->thread);
}

void qemu_thread_exit(void *retval)
{
    pthread_exit(retval);
}

void *qemu_thread_join(QemuThread *thread)
{
    int err;
    void *ret;

    err = pthread_join(thread->thread, &ret);
    if (err) {
        error_exit(err, __func__);
    }
    return ret;
}
Commit	Line	Data
e5d355d1 AL	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>
38b14db3 PB	20	#include <limits.h>
	21	#include <unistd.h>
	22	#include <sys/time.h>
c7c4d063 PB	23	#ifdef __linux__
	24	#include <sys/syscall.h>
	25	#include <linux/futex.h>
	26	#endif
1de7afc9	27	#include "qemu/thread.h"
c7c4d063	28	#include "qemu/atomic.h"
ef57137f	29	#include "qemu/notify.h"
e5d355d1	30
8f480de0 DDAG	31	static bool name_threads;
	32
	33	void qemu_thread_naming(bool enable)
	34	{
	35	name_threads = enable;
5c312079 DDAG	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
8f480de0 DDAG	43	}
8f480de0 DDAG	44
e5d355d1 AL	45	static void error_exit(int err, const char *msg)
	46	{
	47	fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
53380ac3	48	abort();
e5d355d1 AL	49	}
	50
	51	void qemu_mutex_init(QemuMutex *mutex)
	52	{
	53	int err;
	54
24fa9049	55	err = pthread_mutex_init(&mutex->lock, NULL);
e5d355d1 AL	56	if (err)
	57	error_exit(err, __func__);
	58	}
	59
313b1d69 CC	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
e5d355d1 AL	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
e5d355d1 AL	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
313b1d69 CC	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
e5d355d1 AL	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
38b14db3 PB	137	void qemu_sem_init(QemuSemaphore *sem, int init)
	138	{
	139	int rc;
	140
927fa909	141	#if defined(__APPLE__) \|\| defined(__NetBSD__)
c166cb72 PB	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
38b14db3 PB	155	rc = sem_init(&sem->sem, 0, init);
	156	if (rc < 0) {
	157	error_exit(errno, __func__);
	158	}
c166cb72	159	#endif
38b14db3 PB	160	}
	161
	162	void qemu_sem_destroy(QemuSemaphore *sem)
	163	{
	164	int rc;
	165
927fa909	166	#if defined(__APPLE__) \|\| defined(__NetBSD__)
c166cb72 PB	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
38b14db3 PB	176	rc = sem_destroy(&sem->sem);
	177	if (rc < 0) {
	178	error_exit(errno, __func__);
	179	}
c166cb72	180	#endif
38b14db3 PB	181	}
	182
	183	void qemu_sem_post(QemuSemaphore *sem)
	184	{
	185	int rc;
	186
927fa909	187	#if defined(__APPLE__) \|\| defined(__NetBSD__)
c166cb72	188	pthread_mutex_lock(&sem->lock);
79761c66	189	if (sem->count == UINT_MAX) {
c166cb72	190	rc = EINVAL;
c166cb72	191	} else {
79761c66 IT	192	sem->count++;
79761c66 IT	193	rc = pthread_cond_signal(&sem->cond);
c166cb72 PB	194	}
	195	pthread_mutex_unlock(&sem->lock);
	196	if (rc != 0) {
	197	error_exit(rc, __func__);
	198	}
	199	#else
38b14db3 PB	200	rc = sem_post(&sem->sem);
	201	if (rc < 0) {
	202	error_exit(errno, __func__);
	203	}
c166cb72 PB	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	}
38b14db3 PB	217	}
	218
	219	int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
	220	{
	221	int rc;
c166cb72 PB	222	struct timespec ts;
c166cb72 PB	223
927fa909	224	#if defined(__APPLE__) \|\| defined(__NetBSD__)
79761c66	225	rc = 0;
c166cb72 PB	226	compute_abs_deadline(&ts, ms);
c166cb72 PB	227	pthread_mutex_lock(&sem->lock);
79761c66	228	while (sem->count == 0) {
c166cb72 PB	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	}
79761c66 IT	237	if (rc != ETIMEDOUT) {
	238	--sem->count;
	239	}
c166cb72 PB	240	pthread_mutex_unlock(&sem->lock);
	241	return (rc == ETIMEDOUT ? -1 : 0);
	242	#else
38b14db3 PB	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 {
c166cb72	252	compute_abs_deadline(&ts, ms);
38b14db3 PB	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;
c166cb72	264	#endif
38b14db3 PB	265	}
	266
	267	void qemu_sem_wait(QemuSemaphore *sem)
	268	{
79761c66 IT	269	int rc;
79761c66 IT	270
927fa909	271	#if defined(__APPLE__) \|\| defined(__NetBSD__)
c166cb72	272	pthread_mutex_lock(&sem->lock);
79761c66 IT	273	while (sem->count == 0) {
	274	rc = pthread_cond_wait(&sem->cond, &sem->lock);
	275	if (rc != 0) {
	276	error_exit(rc, __func__);
	277	}
c166cb72	278	}
79761c66	279	--sem->count;
c166cb72 PB	280	pthread_mutex_unlock(&sem->lock);
c166cb72 PB	281	#else
38b14db3 PB	282	do {
	283	rc = sem_wait(&sem->sem);
	284	} while (rc == -1 && errno == EINTR);
	285	if (rc < 0) {
	286	error_exit(errno, __func__);
	287	}
c166cb72	288	#endif
38b14db3 PB	289	}
38b14db3 PB	290
c7c4d063 PB	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	{
158ef8cb	306	pthread_mutex_lock(&ev->lock);
c7c4d063 PB	307	if (n == 1) {
	308	pthread_cond_signal(&ev->cond);
	309	} else {
	310	pthread_cond_broadcast(&ev->cond);
	311	}
158ef8cb	312	pthread_mutex_unlock(&ev->lock);
c7c4d063 PB	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
ef57137f PB	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
5c312079 DDAG	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
4900116e	449	void qemu_thread_create(QemuThread thread, const char name,
e5d355d1	450	void (start_routine)(void*),
cf218714	451	void *arg, int mode)
e5d355d1	452	{
cf218714	453	sigset_t set, oldset;
e5d355d1	454	int err;
8763046b	455	pthread_attr_t attr;
e5d355d1	456
8763046b JK	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	}
55541c8a	467
cf218714	468	/* Leave signal handling to the iothread. */
55541c8a PB	469	sigfillset(&set);
55541c8a PB	470	pthread_sigmask(SIG_SETMASK, &set, &oldset);
8763046b	471	err = pthread_create(&thread->thread, &attr, start_routine, arg);
e5d355d1 AL	472	if (err)
e5d355d1 AL	473	error_exit(err, __func__);
55541c8a	474
4900116e	475	if (name_threads) {
5c312079	476	qemu_thread_set_name(thread, name);
4900116e	477	}
4900116e	478
55541c8a	479	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
8763046b JK	480
8763046b JK	481	pthread_attr_destroy(&attr);
e5d355d1 AL	482	}
e5d355d1 AL	483
b7680cb6	484	void qemu_thread_get_self(QemuThread *thread)
e5d355d1 AL	485	{
	486	thread->thread = pthread_self();
	487	}
	488
2d797b65	489	bool qemu_thread_is_self(QemuThread *thread)
e5d355d1	490	{
b7680cb6	491	return pthread_equal(pthread_self(), thread->thread);
e5d355d1 AL	492	}
e5d355d1 AL	493
313b1d69 CC	494	void qemu_thread_exit(void *retval)
	495	{
	496	pthread_exit(retval);
	497	}
8763046b JK	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	}