[thirdparty/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"

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;
    pthread_mutexattr_t mutexattr;

    pthread_mutexattr_init(&mutexattr);
    pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ERRORCHECK);
    err = pthread_mutex_init(&mutex->lock, &mutexattr);
    pthread_mutexattr_destroy(&mutexattr);
    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);
    }
}

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