LXR qemu/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 "qemu-thread.h"
  21
  22static void error_exit(int err, const char *msg)
  23{
  24    fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
  25    abort();
  26}
  27
  28void qemu_mutex_init(QemuMutex *mutex)
  29{
  30    int err;
  31    pthread_mutexattr_t mutexattr;
  32
  33    pthread_mutexattr_init(&mutexattr);
  34    pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ERRORCHECK);
  35    err = pthread_mutex_init(&mutex->lock, &mutexattr);
  36    pthread_mutexattr_destroy(&mutexattr);
  37    if (err)
  38        error_exit(err, __func__);
  39}
  40
  41void qemu_mutex_destroy(QemuMutex *mutex)
  42{
  43    int err;
  44
  45    err = pthread_mutex_destroy(&mutex->lock);
  46    if (err)
  47        error_exit(err, __func__);
  48}
  49
  50void qemu_mutex_lock(QemuMutex *mutex)
  51{
  52    int err;
  53
  54    err = pthread_mutex_lock(&mutex->lock);
  55    if (err)
  56        error_exit(err, __func__);
  57}
  58
  59int qemu_mutex_trylock(QemuMutex *mutex)
  60{
  61    return pthread_mutex_trylock(&mutex->lock);
  62}
  63
  64void qemu_mutex_unlock(QemuMutex *mutex)
  65{
  66    int err;
  67
  68    err = pthread_mutex_unlock(&mutex->lock);
  69    if (err)
  70        error_exit(err, __func__);
  71}
  72
  73void qemu_cond_init(QemuCond *cond)
  74{
  75    int err;
  76
  77    err = pthread_cond_init(&cond->cond, NULL);
  78    if (err)
  79        error_exit(err, __func__);
  80}
  81
  82void qemu_cond_destroy(QemuCond *cond)
  83{
  84    int err;
  85
  86    err = pthread_cond_destroy(&cond->cond);
  87    if (err)
  88        error_exit(err, __func__);
  89}
  90
  91void qemu_cond_signal(QemuCond *cond)
  92{
  93    int err;
  94
  95    err = pthread_cond_signal(&cond->cond);
  96    if (err)
  97        error_exit(err, __func__);
  98}
  99
 100void qemu_cond_broadcast(QemuCond *cond)
 101{
 102    int err;
 103
 104    err = pthread_cond_broadcast(&cond->cond);
 105    if (err)
 106        error_exit(err, __func__);
 107}
 108
 109void qemu_cond_wait(QemuCond *cond, QemuMutex *mutex)
 110{
 111    int err;
 112
 113    err = pthread_cond_wait(&cond->cond, &mutex->lock);
 114    if (err)
 115        error_exit(err, __func__);
 116}
 117
 118void qemu_thread_create(QemuThread *thread,
 119                       void *(*start_routine)(void*),
 120                       void *arg, int mode)
 121{
 122    sigset_t set, oldset;
 123    int err;
 124    pthread_attr_t attr;
 125
 126    err = pthread_attr_init(&attr);
 127    if (err) {
 128        error_exit(err, __func__);
 129    }
 130    if (mode == QEMU_THREAD_DETACHED) {
 131        err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 132        if (err) {
 133            error_exit(err, __func__);
 134        }
 135    }
 136
 137    /* Leave signal handling to the iothread.  */
 138    sigfillset(&set);
 139    pthread_sigmask(SIG_SETMASK, &set, &oldset);
 140    err = pthread_create(&thread->thread, &attr, start_routine, arg);
 141    if (err)
 142        error_exit(err, __func__);
 143
 144    pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 145
 146    pthread_attr_destroy(&attr);
 147}
 148
 149void qemu_thread_get_self(QemuThread *thread)
 150{
 151    thread->thread = pthread_self();
 152}
 153
 154bool qemu_thread_is_self(QemuThread *thread)
 155{
 156   return pthread_equal(pthread_self(), thread->thread);
 157}
 158
 159void qemu_thread_exit(void *retval)
 160{
 161    pthread_exit(retval);
 162}
 163
 164void *qemu_thread_join(QemuThread *thread)
 165{
 166    int err;
 167    void *ret;
 168
 169    err = pthread_join(thread->thread, &ret);
 170    if (err) {
 171        error_exit(err, __func__);
 172    }
 173    return ret;
 174}
 175