File:  [Qemu by Fabrice Bellard] / qemu / qemu-thread-posix.c
Revision 1.1.1.2 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:17:19 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu1001, HEAD
qemu 1.0.1

    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: 
   22: static void error_exit(int err, const char *msg)
   23: {
   24:     fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
   25:     abort();
   26: }
   27: 
   28: void 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: 
   41: void 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: 
   50: void 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: 
   59: int qemu_mutex_trylock(QemuMutex *mutex)
   60: {
   61:     return pthread_mutex_trylock(&mutex->lock);
   62: }
   63: 
   64: void 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: 
   73: void 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: 
   82: void 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: 
   91: void 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: 
  100: void 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: 
  109: void 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: 
  118: void qemu_thread_create(QemuThread *thread,
  119:                        void *(*start_routine)(void*),
  120:                        void *arg)
  121: {
  122:     int err;
  123: 
  124:     /* Leave signal handling to the iothread.  */
  125:     sigset_t set, oldset;
  126: 
  127:     sigfillset(&set);
  128:     pthread_sigmask(SIG_SETMASK, &set, &oldset);
  129:     err = pthread_create(&thread->thread, NULL, start_routine, arg);
  130:     if (err)
  131:         error_exit(err, __func__);
  132: 
  133:     pthread_sigmask(SIG_SETMASK, &oldset, NULL);
  134: }
  135: 
  136: void qemu_thread_get_self(QemuThread *thread)
  137: {
  138:     thread->thread = pthread_self();
  139: }
  140: 
  141: int qemu_thread_is_self(QemuThread *thread)
  142: {
  143:    return pthread_equal(pthread_self(), thread->thread);
  144: }
  145: 
  146: void qemu_thread_exit(void *retval)
  147: {
  148:     pthread_exit(retval);
  149: }

unix.superglobalmegacorp.com