target-arm: Avoid calling arm_el_is_aa64() function for unimplemented EL
[qemu/ar7.git] / util / qemu-thread-win32.c
blob6cdd553e9ac61ce1358482419d9d35778485c2a6
1 /*
2 * Win32 implementation for mutex/cond/thread functions
4 * Copyright Red Hat, Inc. 2010
6 * Author:
7 * Paolo Bonzini <pbonzini@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 "qemu-common.h"
14 #include "qemu/thread.h"
15 #include "qemu/notify.h"
16 #include <process.h>
17 #include <assert.h>
18 #include <limits.h>
20 static bool name_threads;
22 void qemu_thread_naming(bool enable)
24 /* But note we don't actually name them on Windows yet */
25 name_threads = enable;
27 fprintf(stderr, "qemu: thread naming not supported on this host\n");
30 static void error_exit(int err, const char *msg)
32 char *pstr;
34 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
35 NULL, err, 0, (LPTSTR)&pstr, 2, NULL);
36 fprintf(stderr, "qemu: %s: %s\n", msg, pstr);
37 LocalFree(pstr);
38 abort();
41 void qemu_mutex_init(QemuMutex *mutex)
43 mutex->owner = 0;
44 InitializeCriticalSection(&mutex->lock);
47 void qemu_mutex_destroy(QemuMutex *mutex)
49 assert(mutex->owner == 0);
50 DeleteCriticalSection(&mutex->lock);
53 void qemu_mutex_lock(QemuMutex *mutex)
55 EnterCriticalSection(&mutex->lock);
57 /* Win32 CRITICAL_SECTIONs are recursive. Assert that we're not
58 * using them as such.
60 assert(mutex->owner == 0);
61 mutex->owner = GetCurrentThreadId();
64 int qemu_mutex_trylock(QemuMutex *mutex)
66 int owned;
68 owned = TryEnterCriticalSection(&mutex->lock);
69 if (owned) {
70 assert(mutex->owner == 0);
71 mutex->owner = GetCurrentThreadId();
73 return !owned;
76 void qemu_mutex_unlock(QemuMutex *mutex)
78 assert(mutex->owner == GetCurrentThreadId());
79 mutex->owner = 0;
80 LeaveCriticalSection(&mutex->lock);
83 void qemu_cond_init(QemuCond *cond)
85 memset(cond, 0, sizeof(*cond));
87 cond->sema = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
88 if (!cond->sema) {
89 error_exit(GetLastError(), __func__);
91 cond->continue_event = CreateEvent(NULL, /* security */
92 FALSE, /* auto-reset */
93 FALSE, /* not signaled */
94 NULL); /* name */
95 if (!cond->continue_event) {
96 error_exit(GetLastError(), __func__);
100 void qemu_cond_destroy(QemuCond *cond)
102 BOOL result;
103 result = CloseHandle(cond->continue_event);
104 if (!result) {
105 error_exit(GetLastError(), __func__);
107 cond->continue_event = 0;
108 result = CloseHandle(cond->sema);
109 if (!result) {
110 error_exit(GetLastError(), __func__);
112 cond->sema = 0;
115 void qemu_cond_signal(QemuCond *cond)
117 DWORD result;
120 * Signal only when there are waiters. cond->waiters is
121 * incremented by pthread_cond_wait under the external lock,
122 * so we are safe about that.
124 if (cond->waiters == 0) {
125 return;
129 * Waiting threads decrement it outside the external lock, but
130 * only if another thread is executing pthread_cond_broadcast and
131 * has the mutex. So, it also cannot be decremented concurrently
132 * with this particular access.
134 cond->target = cond->waiters - 1;
135 result = SignalObjectAndWait(cond->sema, cond->continue_event,
136 INFINITE, FALSE);
137 if (result == WAIT_ABANDONED || result == WAIT_FAILED) {
138 error_exit(GetLastError(), __func__);
142 void qemu_cond_broadcast(QemuCond *cond)
144 BOOLEAN result;
146 * As in pthread_cond_signal, access to cond->waiters and
147 * cond->target is locked via the external mutex.
149 if (cond->waiters == 0) {
150 return;
153 cond->target = 0;
154 result = ReleaseSemaphore(cond->sema, cond->waiters, NULL);
155 if (!result) {
156 error_exit(GetLastError(), __func__);
160 * At this point all waiters continue. Each one takes its
161 * slice of the semaphore. Now it's our turn to wait: Since
162 * the external mutex is held, no thread can leave cond_wait,
163 * yet. For this reason, we can be sure that no thread gets
164 * a chance to eat *more* than one slice. OTOH, it means
165 * that the last waiter must send us a wake-up.
167 WaitForSingleObject(cond->continue_event, INFINITE);
170 void qemu_cond_wait(QemuCond *cond, QemuMutex *mutex)
173 * This access is protected under the mutex.
175 cond->waiters++;
178 * Unlock external mutex and wait for signal.
179 * NOTE: we've held mutex locked long enough to increment
180 * waiters count above, so there's no problem with
181 * leaving mutex unlocked before we wait on semaphore.
183 qemu_mutex_unlock(mutex);
184 WaitForSingleObject(cond->sema, INFINITE);
186 /* Now waiters must rendez-vous with the signaling thread and
187 * let it continue. For cond_broadcast this has heavy contention
188 * and triggers thundering herd. So goes life.
190 * Decrease waiters count. The mutex is not taken, so we have
191 * to do this atomically.
193 * All waiters contend for the mutex at the end of this function
194 * until the signaling thread relinquishes it. To ensure
195 * each waiter consumes exactly one slice of the semaphore,
196 * the signaling thread stops until it is told by the last
197 * waiter that it can go on.
199 if (InterlockedDecrement(&cond->waiters) == cond->target) {
200 SetEvent(cond->continue_event);
203 qemu_mutex_lock(mutex);
206 void qemu_sem_init(QemuSemaphore *sem, int init)
208 /* Manual reset. */
209 sem->sema = CreateSemaphore(NULL, init, LONG_MAX, NULL);
212 void qemu_sem_destroy(QemuSemaphore *sem)
214 CloseHandle(sem->sema);
217 void qemu_sem_post(QemuSemaphore *sem)
219 ReleaseSemaphore(sem->sema, 1, NULL);
222 int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
224 int rc = WaitForSingleObject(sem->sema, ms);
225 if (rc == WAIT_OBJECT_0) {
226 return 0;
228 if (rc != WAIT_TIMEOUT) {
229 error_exit(GetLastError(), __func__);
231 return -1;
234 void qemu_sem_wait(QemuSemaphore *sem)
236 if (WaitForSingleObject(sem->sema, INFINITE) != WAIT_OBJECT_0) {
237 error_exit(GetLastError(), __func__);
241 /* Wrap a Win32 manual-reset event with a fast userspace path. The idea
242 * is to reset the Win32 event lazily, as part of a test-reset-test-wait
243 * sequence. Such a sequence is, indeed, how QemuEvents are used by
244 * RCU and other subsystems!
246 * Valid transitions:
247 * - free->set, when setting the event
248 * - busy->set, when setting the event, followed by futex_wake
249 * - set->free, when resetting the event
250 * - free->busy, when waiting
252 * set->busy does not happen (it can be observed from the outside but
253 * it really is set->free->busy).
255 * busy->free provably cannot happen; to enforce it, the set->free transition
256 * is done with an OR, which becomes a no-op if the event has concurrently
257 * transitioned to free or busy (and is faster than cmpxchg).
260 #define EV_SET 0
261 #define EV_FREE 1
262 #define EV_BUSY -1
264 void qemu_event_init(QemuEvent *ev, bool init)
266 /* Manual reset. */
267 ev->event = CreateEvent(NULL, TRUE, TRUE, NULL);
268 ev->value = (init ? EV_SET : EV_FREE);
271 void qemu_event_destroy(QemuEvent *ev)
273 CloseHandle(ev->event);
276 void qemu_event_set(QemuEvent *ev)
278 if (atomic_mb_read(&ev->value) != EV_SET) {
279 if (atomic_xchg(&ev->value, EV_SET) == EV_BUSY) {
280 /* There were waiters, wake them up. */
281 SetEvent(ev->event);
286 void qemu_event_reset(QemuEvent *ev)
288 if (atomic_mb_read(&ev->value) == EV_SET) {
289 /* If there was a concurrent reset (or even reset+wait),
290 * do nothing. Otherwise change EV_SET->EV_FREE.
292 atomic_or(&ev->value, EV_FREE);
296 void qemu_event_wait(QemuEvent *ev)
298 unsigned value;
300 value = atomic_mb_read(&ev->value);
301 if (value != EV_SET) {
302 if (value == EV_FREE) {
303 /* qemu_event_set is not yet going to call SetEvent, but we are
304 * going to do another check for EV_SET below when setting EV_BUSY.
305 * At that point it is safe to call WaitForSingleObject.
307 ResetEvent(ev->event);
309 /* Tell qemu_event_set that there are waiters. No need to retry
310 * because there cannot be a concurent busy->free transition.
311 * After the CAS, the event will be either set or busy.
313 if (atomic_cmpxchg(&ev->value, EV_FREE, EV_BUSY) == EV_SET) {
314 value = EV_SET;
315 } else {
316 value = EV_BUSY;
319 if (value == EV_BUSY) {
320 WaitForSingleObject(ev->event, INFINITE);
325 struct QemuThreadData {
326 /* Passed to win32_start_routine. */
327 void *(*start_routine)(void *);
328 void *arg;
329 short mode;
330 NotifierList exit;
332 /* Only used for joinable threads. */
333 bool exited;
334 void *ret;
335 CRITICAL_SECTION cs;
338 static bool atexit_registered;
339 static NotifierList main_thread_exit;
341 static __thread QemuThreadData *qemu_thread_data;
343 static void run_main_thread_exit(void)
345 notifier_list_notify(&main_thread_exit, NULL);
348 void qemu_thread_atexit_add(Notifier *notifier)
350 if (!qemu_thread_data) {
351 if (!atexit_registered) {
352 atexit_registered = true;
353 atexit(run_main_thread_exit);
355 notifier_list_add(&main_thread_exit, notifier);
356 } else {
357 notifier_list_add(&qemu_thread_data->exit, notifier);
361 void qemu_thread_atexit_remove(Notifier *notifier)
363 notifier_remove(notifier);
366 static unsigned __stdcall win32_start_routine(void *arg)
368 QemuThreadData *data = (QemuThreadData *) arg;
369 void *(*start_routine)(void *) = data->start_routine;
370 void *thread_arg = data->arg;
372 qemu_thread_data = data;
373 qemu_thread_exit(start_routine(thread_arg));
374 abort();
377 void qemu_thread_exit(void *arg)
379 QemuThreadData *data = qemu_thread_data;
381 notifier_list_notify(&data->exit, NULL);
382 if (data->mode == QEMU_THREAD_JOINABLE) {
383 data->ret = arg;
384 EnterCriticalSection(&data->cs);
385 data->exited = true;
386 LeaveCriticalSection(&data->cs);
387 } else {
388 g_free(data);
390 _endthreadex(0);
393 void *qemu_thread_join(QemuThread *thread)
395 QemuThreadData *data;
396 void *ret;
397 HANDLE handle;
399 data = thread->data;
400 if (data->mode == QEMU_THREAD_DETACHED) {
401 return NULL;
405 * Because multiple copies of the QemuThread can exist via
406 * qemu_thread_get_self, we need to store a value that cannot
407 * leak there. The simplest, non racy way is to store the TID,
408 * discard the handle that _beginthreadex gives back, and
409 * get another copy of the handle here.
411 handle = qemu_thread_get_handle(thread);
412 if (handle) {
413 WaitForSingleObject(handle, INFINITE);
414 CloseHandle(handle);
416 ret = data->ret;
417 DeleteCriticalSection(&data->cs);
418 g_free(data);
419 return ret;
422 void qemu_thread_create(QemuThread *thread, const char *name,
423 void *(*start_routine)(void *),
424 void *arg, int mode)
426 HANDLE hThread;
427 struct QemuThreadData *data;
429 data = g_malloc(sizeof *data);
430 data->start_routine = start_routine;
431 data->arg = arg;
432 data->mode = mode;
433 data->exited = false;
434 notifier_list_init(&data->exit);
436 if (data->mode != QEMU_THREAD_DETACHED) {
437 InitializeCriticalSection(&data->cs);
440 hThread = (HANDLE) _beginthreadex(NULL, 0, win32_start_routine,
441 data, 0, &thread->tid);
442 if (!hThread) {
443 error_exit(GetLastError(), __func__);
445 CloseHandle(hThread);
446 thread->data = data;
449 void qemu_thread_get_self(QemuThread *thread)
451 thread->data = qemu_thread_data;
452 thread->tid = GetCurrentThreadId();
455 HANDLE qemu_thread_get_handle(QemuThread *thread)
457 QemuThreadData *data;
458 HANDLE handle;
460 data = thread->data;
461 if (data->mode == QEMU_THREAD_DETACHED) {
462 return NULL;
465 EnterCriticalSection(&data->cs);
466 if (!data->exited) {
467 handle = OpenThread(SYNCHRONIZE | THREAD_SUSPEND_RESUME, FALSE,
468 thread->tid);
469 } else {
470 handle = NULL;
472 LeaveCriticalSection(&data->cs);
473 return handle;
476 bool qemu_thread_is_self(QemuThread *thread)
478 return GetCurrentThreadId() == thread->tid;