Statistics
| Branch: | Revision:

root / qemu-thread-posix.c @ 44bc10d5

History | View | Annotate | Download (2.9 kB)

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
    exit(1);
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
}