xref: /openbmc/qemu/util/qemu-thread-posix.c (revision d9570434) 
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 <limits.h>
21 #include <unistd.h>
22 #include <sys/time.h>
23 #include "qemu/thread.h"
24 
25 static void error_exit(int err, const char *msg)
26 {
27     fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
28     abort();
29 }
30 
31 void qemu_mutex_init(QemuMutex *mutex)
32 {
33     int err;
34     pthread_mutexattr_t mutexattr;
35 
36     pthread_mutexattr_init(&mutexattr);
37     pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ERRORCHECK);
38     err = pthread_mutex_init(&mutex->lock, &mutexattr);
39     pthread_mutexattr_destroy(&mutexattr);
40     if (err)
41         error_exit(err, __func__);
42 }
43 
44 void qemu_mutex_destroy(QemuMutex *mutex)
45 {
46     int err;
47 
48     err = pthread_mutex_destroy(&mutex->lock);
49     if (err)
50         error_exit(err, __func__);
51 }
52 
53 void qemu_mutex_lock(QemuMutex *mutex)
54 {
55     int err;
56 
57     err = pthread_mutex_lock(&mutex->lock);
58     if (err)
59         error_exit(err, __func__);
60 }
61 
62 int qemu_mutex_trylock(QemuMutex *mutex)
63 {
64     return pthread_mutex_trylock(&mutex->lock);
65 }
66 
67 void qemu_mutex_unlock(QemuMutex *mutex)
68 {
69     int err;
70 
71     err = pthread_mutex_unlock(&mutex->lock);
72     if (err)
73         error_exit(err, __func__);
74 }
75 
76 void qemu_cond_init(QemuCond *cond)
77 {
78     int err;
79 
80     err = pthread_cond_init(&cond->cond, NULL);
81     if (err)
82         error_exit(err, __func__);
83 }
84 
85 void qemu_cond_destroy(QemuCond *cond)
86 {
87     int err;
88 
89     err = pthread_cond_destroy(&cond->cond);
90     if (err)
91         error_exit(err, __func__);
92 }
93 
94 void qemu_cond_signal(QemuCond *cond)
95 {
96     int err;
97 
98     err = pthread_cond_signal(&cond->cond);
99     if (err)
100         error_exit(err, __func__);
101 }
102 
103 void qemu_cond_broadcast(QemuCond *cond)
104 {
105     int err;
106 
107     err = pthread_cond_broadcast(&cond->cond);
108     if (err)
109         error_exit(err, __func__);
110 }
111 
112 void qemu_cond_wait(QemuCond *cond, QemuMutex *mutex)
113 {
114     int err;
115 
116     err = pthread_cond_wait(&cond->cond, &mutex->lock);
117     if (err)
118         error_exit(err, __func__);
119 }
120 
121 void qemu_sem_init(QemuSemaphore *sem, int init)
122 {
123     int rc;
124 
125 #if defined(__APPLE__) || defined(__NetBSD__)
126     rc = pthread_mutex_init(&sem->lock, NULL);
127     if (rc != 0) {
128         error_exit(rc, __func__);
129     }
130     rc = pthread_cond_init(&sem->cond, NULL);
131     if (rc != 0) {
132         error_exit(rc, __func__);
133     }
134     if (init < 0) {
135         error_exit(EINVAL, __func__);
136     }
137     sem->count = init;
138 #else
139     rc = sem_init(&sem->sem, 0, init);
140     if (rc < 0) {
141         error_exit(errno, __func__);
142     }
143 #endif
144 }
145 
146 void qemu_sem_destroy(QemuSemaphore *sem)
147 {
148     int rc;
149 
150 #if defined(__APPLE__) || defined(__NetBSD__)
151     rc = pthread_cond_destroy(&sem->cond);
152     if (rc < 0) {
153         error_exit(rc, __func__);
154     }
155     rc = pthread_mutex_destroy(&sem->lock);
156     if (rc < 0) {
157         error_exit(rc, __func__);
158     }
159 #else
160     rc = sem_destroy(&sem->sem);
161     if (rc < 0) {
162         error_exit(errno, __func__);
163     }
164 #endif
165 }
166 
167 void qemu_sem_post(QemuSemaphore *sem)
168 {
169     int rc;
170 
171 #if defined(__APPLE__) || defined(__NetBSD__)
172     pthread_mutex_lock(&sem->lock);
173     if (sem->count == UINT_MAX) {
174         rc = EINVAL;
175     } else {
176         sem->count++;
177         rc = pthread_cond_signal(&sem->cond);
178     }
179     pthread_mutex_unlock(&sem->lock);
180     if (rc != 0) {
181         error_exit(rc, __func__);
182     }
183 #else
184     rc = sem_post(&sem->sem);
185     if (rc < 0) {
186         error_exit(errno, __func__);
187     }
188 #endif
189 }
190 
191 static void compute_abs_deadline(struct timespec *ts, int ms)
192 {
193     struct timeval tv;
194     gettimeofday(&tv, NULL);
195     ts->tv_nsec = tv.tv_usec * 1000 + (ms % 1000) * 1000000;
196     ts->tv_sec = tv.tv_sec + ms / 1000;
197     if (ts->tv_nsec >= 1000000000) {
198         ts->tv_sec++;
199         ts->tv_nsec -= 1000000000;
200     }
201 }
202 
203 int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
204 {
205     int rc;
206     struct timespec ts;
207 
208 #if defined(__APPLE__) || defined(__NetBSD__)
209     rc = 0;
210     compute_abs_deadline(&ts, ms);
211     pthread_mutex_lock(&sem->lock);
212     while (sem->count == 0) {
213         rc = pthread_cond_timedwait(&sem->cond, &sem->lock, &ts);
214         if (rc == ETIMEDOUT) {
215             break;
216         }
217         if (rc != 0) {
218             error_exit(rc, __func__);
219         }
220     }
221     if (rc != ETIMEDOUT) {
222         --sem->count;
223     }
224     pthread_mutex_unlock(&sem->lock);
225     return (rc == ETIMEDOUT ? -1 : 0);
226 #else
227     if (ms <= 0) {
228         /* This is cheaper than sem_timedwait.  */
229         do {
230             rc = sem_trywait(&sem->sem);
231         } while (rc == -1 && errno == EINTR);
232         if (rc == -1 && errno == EAGAIN) {
233             return -1;
234         }
235     } else {
236         compute_abs_deadline(&ts, ms);
237         do {
238             rc = sem_timedwait(&sem->sem, &ts);
239         } while (rc == -1 && errno == EINTR);
240         if (rc == -1 && errno == ETIMEDOUT) {
241             return -1;
242         }
243     }
244     if (rc < 0) {
245         error_exit(errno, __func__);
246     }
247     return 0;
248 #endif
249 }
250 
251 void qemu_sem_wait(QemuSemaphore *sem)
252 {
253     int rc;
254 
255 #if defined(__APPLE__) || defined(__NetBSD__)
256     pthread_mutex_lock(&sem->lock);
257     while (sem->count == 0) {
258         rc = pthread_cond_wait(&sem->cond, &sem->lock);
259         if (rc != 0) {
260             error_exit(rc, __func__);
261         }
262     }
263     --sem->count;
264     pthread_mutex_unlock(&sem->lock);
265 #else
266     do {
267         rc = sem_wait(&sem->sem);
268     } while (rc == -1 && errno == EINTR);
269     if (rc < 0) {
270         error_exit(errno, __func__);
271     }
272 #endif
273 }
274 
275 void qemu_thread_create(QemuThread *thread,
276                        void *(*start_routine)(void*),
277                        void *arg, int mode)
278 {
279     sigset_t set, oldset;
280     int err;
281     pthread_attr_t attr;
282 
283     err = pthread_attr_init(&attr);
284     if (err) {
285         error_exit(err, __func__);
286     }
287     if (mode == QEMU_THREAD_DETACHED) {
288         err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
289         if (err) {
290             error_exit(err, __func__);
291         }
292     }
293 
294     /* Leave signal handling to the iothread.  */
295     sigfillset(&set);
296     pthread_sigmask(SIG_SETMASK, &set, &oldset);
297     err = pthread_create(&thread->thread, &attr, start_routine, arg);
298     if (err)
299         error_exit(err, __func__);
300 
301     pthread_sigmask(SIG_SETMASK, &oldset, NULL);
302 
303     pthread_attr_destroy(&attr);
304 }
305 
306 void qemu_thread_get_self(QemuThread *thread)
307 {
308     thread->thread = pthread_self();
309 }
310 
311 bool qemu_thread_is_self(QemuThread *thread)
312 {
313    return pthread_equal(pthread_self(), thread->thread);
314 }
315 
316 void qemu_thread_exit(void *retval)
317 {
318     pthread_exit(retval);
319 }
320 
321 void *qemu_thread_join(QemuThread *thread)
322 {
323     int err;
324     void *ret;
325 
326     err = pthread_join(thread->thread, &ret);
327     if (err) {
328         error_exit(err, __func__);
329     }
330     return ret;
331 }
332