nbd: force read-only export for read-only devices
[qemu/opensuse.git] / qemu-thread-posix.c
blob4ef9c7b3f83469c87d09b66751ceb2e67e7877e1
1 /*
2 * Wrappers around mutex/cond/thread functions
4 * Copyright Red Hat, Inc. 2009
6 * Author:
7 * Marcelo Tosatti <mtosatti@redhat.com>
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.
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"
25 static void error_exit(int err, const char *msg)
27 fprintf(stderr, "qemu: %s: %s\n", msg, strerror(err));
28 abort();
31 void qemu_mutex_init(QemuMutex *mutex)
33 int err;
34 pthread_mutexattr_t mutexattr;
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__);
44 void qemu_mutex_destroy(QemuMutex *mutex)
46 int err;
48 err = pthread_mutex_destroy(&mutex->lock);
49 if (err)
50 error_exit(err, __func__);
53 void qemu_mutex_lock(QemuMutex *mutex)
55 int err;
57 err = pthread_mutex_lock(&mutex->lock);
58 if (err)
59 error_exit(err, __func__);
62 int qemu_mutex_trylock(QemuMutex *mutex)
64 return pthread_mutex_trylock(&mutex->lock);
67 void qemu_mutex_unlock(QemuMutex *mutex)
69 int err;
71 err = pthread_mutex_unlock(&mutex->lock);
72 if (err)
73 error_exit(err, __func__);
76 void qemu_cond_init(QemuCond *cond)
78 int err;
80 err = pthread_cond_init(&cond->cond, NULL);
81 if (err)
82 error_exit(err, __func__);
85 void qemu_cond_destroy(QemuCond *cond)
87 int err;
89 err = pthread_cond_destroy(&cond->cond);
90 if (err)
91 error_exit(err, __func__);
94 void qemu_cond_signal(QemuCond *cond)
96 int err;
98 err = pthread_cond_signal(&cond->cond);
99 if (err)
100 error_exit(err, __func__);
103 void qemu_cond_broadcast(QemuCond *cond)
105 int err;
107 err = pthread_cond_broadcast(&cond->cond);
108 if (err)
109 error_exit(err, __func__);
112 void qemu_cond_wait(QemuCond *cond, QemuMutex *mutex)
114 int err;
116 err = pthread_cond_wait(&cond->cond, &mutex->lock);
117 if (err)
118 error_exit(err, __func__);
121 void qemu_sem_init(QemuSemaphore *sem, int init)
123 int rc;
125 #if defined(__OpenBSD__) || defined(__APPLE__) || defined(__NetBSD__)
126 rc = pthread_mutex_init(&sem->lock, NULL);
127 if (rc != 0) {
128 error_exit(rc, __func__);
130 rc = pthread_cond_init(&sem->cond, NULL);
131 if (rc != 0) {
132 error_exit(rc, __func__);
134 if (init < 0) {
135 error_exit(EINVAL, __func__);
137 sem->count = init;
138 #else
139 rc = sem_init(&sem->sem, 0, init);
140 if (rc < 0) {
141 error_exit(errno, __func__);
143 #endif
146 void qemu_sem_destroy(QemuSemaphore *sem)
148 int rc;
150 #if defined(__OpenBSD__) || defined(__APPLE__) || defined(__NetBSD__)
151 rc = pthread_cond_destroy(&sem->cond);
152 if (rc < 0) {
153 error_exit(rc, __func__);
155 rc = pthread_mutex_destroy(&sem->lock);
156 if (rc < 0) {
157 error_exit(rc, __func__);
159 #else
160 rc = sem_destroy(&sem->sem);
161 if (rc < 0) {
162 error_exit(errno, __func__);
164 #endif
167 void qemu_sem_post(QemuSemaphore *sem)
169 int rc;
171 #if defined(__OpenBSD__) || defined(__APPLE__) || defined(__NetBSD__)
172 pthread_mutex_lock(&sem->lock);
173 if (sem->count == INT_MAX) {
174 rc = EINVAL;
175 } else if (sem->count++ < 0) {
176 rc = pthread_cond_signal(&sem->cond);
177 } else {
178 rc = 0;
180 pthread_mutex_unlock(&sem->lock);
181 if (rc != 0) {
182 error_exit(rc, __func__);
184 #else
185 rc = sem_post(&sem->sem);
186 if (rc < 0) {
187 error_exit(errno, __func__);
189 #endif
192 static void compute_abs_deadline(struct timespec *ts, int ms)
194 struct timeval tv;
195 gettimeofday(&tv, NULL);
196 ts->tv_nsec = tv.tv_usec * 1000 + (ms % 1000) * 1000000;
197 ts->tv_sec = tv.tv_sec + ms / 1000;
198 if (ts->tv_nsec >= 1000000000) {
199 ts->tv_sec++;
200 ts->tv_nsec -= 1000000000;
204 int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
206 int rc;
207 struct timespec ts;
209 #if defined(__OpenBSD__) || defined(__APPLE__) || defined(__NetBSD__)
210 compute_abs_deadline(&ts, ms);
211 pthread_mutex_lock(&sem->lock);
212 --sem->count;
213 while (sem->count < 0) {
214 rc = pthread_cond_timedwait(&sem->cond, &sem->lock, &ts);
215 if (rc == ETIMEDOUT) {
216 break;
218 if (rc != 0) {
219 error_exit(rc, __func__);
222 pthread_mutex_unlock(&sem->lock);
223 return (rc == ETIMEDOUT ? -1 : 0);
224 #else
225 if (ms <= 0) {
226 /* This is cheaper than sem_timedwait. */
227 do {
228 rc = sem_trywait(&sem->sem);
229 } while (rc == -1 && errno == EINTR);
230 if (rc == -1 && errno == EAGAIN) {
231 return -1;
233 } else {
234 compute_abs_deadline(&ts, ms);
235 do {
236 rc = sem_timedwait(&sem->sem, &ts);
237 } while (rc == -1 && errno == EINTR);
238 if (rc == -1 && errno == ETIMEDOUT) {
239 return -1;
242 if (rc < 0) {
243 error_exit(errno, __func__);
245 return 0;
246 #endif
249 void qemu_sem_wait(QemuSemaphore *sem)
251 #if defined(__OpenBSD__) || defined(__APPLE__) || defined(__NetBSD__)
252 pthread_mutex_lock(&sem->lock);
253 --sem->count;
254 while (sem->count < 0) {
255 pthread_cond_wait(&sem->cond, &sem->lock);
257 pthread_mutex_unlock(&sem->lock);
258 #else
259 int rc;
261 do {
262 rc = sem_wait(&sem->sem);
263 } while (rc == -1 && errno == EINTR);
264 if (rc < 0) {
265 error_exit(errno, __func__);
267 #endif
270 void qemu_thread_create(QemuThread *thread,
271 void *(*start_routine)(void*),
272 void *arg, int mode)
274 sigset_t set, oldset;
275 int err;
276 pthread_attr_t attr;
278 err = pthread_attr_init(&attr);
279 if (err) {
280 error_exit(err, __func__);
282 if (mode == QEMU_THREAD_DETACHED) {
283 err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
284 if (err) {
285 error_exit(err, __func__);
289 /* Leave signal handling to the iothread. */
290 sigfillset(&set);
291 pthread_sigmask(SIG_SETMASK, &set, &oldset);
292 err = pthread_create(&thread->thread, &attr, start_routine, arg);
293 if (err)
294 error_exit(err, __func__);
296 pthread_sigmask(SIG_SETMASK, &oldset, NULL);
298 pthread_attr_destroy(&attr);
301 void qemu_thread_get_self(QemuThread *thread)
303 thread->thread = pthread_self();
306 bool qemu_thread_is_self(QemuThread *thread)
308 return pthread_equal(pthread_self(), thread->thread);
311 void qemu_thread_exit(void *retval)
313 pthread_exit(retval);
316 void *qemu_thread_join(QemuThread *thread)
318 int err;
319 void *ret;
321 err = pthread_join(thread->thread, &ret);
322 if (err) {
323 error_exit(err, __func__);
325 return ret;