mips: Ensure PC update with MTC0 single-stepping
[qemu.git] / util / qemu-thread-win32.c
1 /*
2 * Win32 implementation for mutex/cond/thread functions
3 *
4 * Copyright Red Hat, Inc. 2010
5 *
6 * Author:
7 * Paolo Bonzini <pbonzini@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 "qemu-common.h"
14 #include "qemu/thread.h"
15 #include <process.h>
16 #include <assert.h>
17 #include <limits.h>
18
19 static bool name_threads;
20
21 void qemu_thread_naming(bool enable)
22 {
23 /* But note we don't actually name them on Windows yet */
24 name_threads = enable;
25
26 fprintf(stderr, "qemu: thread naming not supported on this host\n");
27 }
28
29 static void error_exit(int err, const char *msg)
30 {
31 char *pstr;
32
33 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
34 NULL, err, 0, (LPTSTR)&pstr, 2, NULL);
35 fprintf(stderr, "qemu: %s: %s\n", msg, pstr);
36 LocalFree(pstr);
37 abort();
38 }
39
40 void qemu_mutex_init(QemuMutex *mutex)
41 {
42 mutex->owner = 0;
43 InitializeCriticalSection(&mutex->lock);
44 }
45
46 void qemu_mutex_destroy(QemuMutex *mutex)
47 {
48 assert(mutex->owner == 0);
49 DeleteCriticalSection(&mutex->lock);
50 }
51
52 void qemu_mutex_lock(QemuMutex *mutex)
53 {
54 EnterCriticalSection(&mutex->lock);
55
56 /* Win32 CRITICAL_SECTIONs are recursive. Assert that we're not
57 * using them as such.
58 */
59 assert(mutex->owner == 0);
60 mutex->owner = GetCurrentThreadId();
61 }
62
63 int qemu_mutex_trylock(QemuMutex *mutex)
64 {
65 int owned;
66
67 owned = TryEnterCriticalSection(&mutex->lock);
68 if (owned) {
69 assert(mutex->owner == 0);
70 mutex->owner = GetCurrentThreadId();
71 }
72 return !owned;
73 }
74
75 void qemu_mutex_unlock(QemuMutex *mutex)
76 {
77 assert(mutex->owner == GetCurrentThreadId());
78 mutex->owner = 0;
79 LeaveCriticalSection(&mutex->lock);
80 }
81
82 void qemu_cond_init(QemuCond *cond)
83 {
84 memset(cond, 0, sizeof(*cond));
85
86 cond->sema = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
87 if (!cond->sema) {
88 error_exit(GetLastError(), __func__);
89 }
90 cond->continue_event = CreateEvent(NULL, /* security */
91 FALSE, /* auto-reset */
92 FALSE, /* not signaled */
93 NULL); /* name */
94 if (!cond->continue_event) {
95 error_exit(GetLastError(), __func__);
96 }
97 }
98
99 void qemu_cond_destroy(QemuCond *cond)
100 {
101 BOOL result;
102 result = CloseHandle(cond->continue_event);
103 if (!result) {
104 error_exit(GetLastError(), __func__);
105 }
106 cond->continue_event = 0;
107 result = CloseHandle(cond->sema);
108 if (!result) {
109 error_exit(GetLastError(), __func__);
110 }
111 cond->sema = 0;
112 }
113
114 void qemu_cond_signal(QemuCond *cond)
115 {
116 DWORD result;
117
118 /*
119 * Signal only when there are waiters. cond->waiters is
120 * incremented by pthread_cond_wait under the external lock,
121 * so we are safe about that.
122 */
123 if (cond->waiters == 0) {
124 return;
125 }
126
127 /*
128 * Waiting threads decrement it outside the external lock, but
129 * only if another thread is executing pthread_cond_broadcast and
130 * has the mutex. So, it also cannot be decremented concurrently
131 * with this particular access.
132 */
133 cond->target = cond->waiters - 1;
134 result = SignalObjectAndWait(cond->sema, cond->continue_event,
135 INFINITE, FALSE);
136 if (result == WAIT_ABANDONED || result == WAIT_FAILED) {
137 error_exit(GetLastError(), __func__);
138 }
139 }
140
141 void qemu_cond_broadcast(QemuCond *cond)
142 {
143 BOOLEAN result;
144 /*
145 * As in pthread_cond_signal, access to cond->waiters and
146 * cond->target is locked via the external mutex.
147 */
148 if (cond->waiters == 0) {
149 return;
150 }
151
152 cond->target = 0;
153 result = ReleaseSemaphore(cond->sema, cond->waiters, NULL);
154 if (!result) {
155 error_exit(GetLastError(), __func__);
156 }
157
158 /*
159 * At this point all waiters continue. Each one takes its
160 * slice of the semaphore. Now it's our turn to wait: Since
161 * the external mutex is held, no thread can leave cond_wait,
162 * yet. For this reason, we can be sure that no thread gets
163 * a chance to eat *more* than one slice. OTOH, it means
164 * that the last waiter must send us a wake-up.
165 */
166 WaitForSingleObject(cond->continue_event, INFINITE);
167 }
168
169 void qemu_cond_wait(QemuCond *cond, QemuMutex *mutex)
170 {
171 /*
172 * This access is protected under the mutex.
173 */
174 cond->waiters++;
175
176 /*
177 * Unlock external mutex and wait for signal.
178 * NOTE: we've held mutex locked long enough to increment
179 * waiters count above, so there's no problem with
180 * leaving mutex unlocked before we wait on semaphore.
181 */
182 qemu_mutex_unlock(mutex);
183 WaitForSingleObject(cond->sema, INFINITE);
184
185 /* Now waiters must rendez-vous with the signaling thread and
186 * let it continue. For cond_broadcast this has heavy contention
187 * and triggers thundering herd. So goes life.
188 *
189 * Decrease waiters count. The mutex is not taken, so we have
190 * to do this atomically.
191 *
192 * All waiters contend for the mutex at the end of this function
193 * until the signaling thread relinquishes it. To ensure
194 * each waiter consumes exactly one slice of the semaphore,
195 * the signaling thread stops until it is told by the last
196 * waiter that it can go on.
197 */
198 if (InterlockedDecrement(&cond->waiters) == cond->target) {
199 SetEvent(cond->continue_event);
200 }
201
202 qemu_mutex_lock(mutex);
203 }
204
205 void qemu_sem_init(QemuSemaphore *sem, int init)
206 {
207 /* Manual reset. */
208 sem->sema = CreateSemaphore(NULL, init, LONG_MAX, NULL);
209 }
210
211 void qemu_sem_destroy(QemuSemaphore *sem)
212 {
213 CloseHandle(sem->sema);
214 }
215
216 void qemu_sem_post(QemuSemaphore *sem)
217 {
218 ReleaseSemaphore(sem->sema, 1, NULL);
219 }
220
221 int qemu_sem_timedwait(QemuSemaphore *sem, int ms)
222 {
223 int rc = WaitForSingleObject(sem->sema, ms);
224 if (rc == WAIT_OBJECT_0) {
225 return 0;
226 }
227 if (rc != WAIT_TIMEOUT) {
228 error_exit(GetLastError(), __func__);
229 }
230 return -1;
231 }
232
233 void qemu_sem_wait(QemuSemaphore *sem)
234 {
235 if (WaitForSingleObject(sem->sema, INFINITE) != WAIT_OBJECT_0) {
236 error_exit(GetLastError(), __func__);
237 }
238 }
239
240 void qemu_event_init(QemuEvent *ev, bool init)
241 {
242 /* Manual reset. */
243 ev->event = CreateEvent(NULL, TRUE, init, NULL);
244 }
245
246 void qemu_event_destroy(QemuEvent *ev)
247 {
248 CloseHandle(ev->event);
249 }
250
251 void qemu_event_set(QemuEvent *ev)
252 {
253 SetEvent(ev->event);
254 }
255
256 void qemu_event_reset(QemuEvent *ev)
257 {
258 ResetEvent(ev->event);
259 }
260
261 void qemu_event_wait(QemuEvent *ev)
262 {
263 WaitForSingleObject(ev->event, INFINITE);
264 }
265
266 struct QemuThreadData {
267 /* Passed to win32_start_routine. */
268 void *(*start_routine)(void *);
269 void *arg;
270 short mode;
271
272 /* Only used for joinable threads. */
273 bool exited;
274 void *ret;
275 CRITICAL_SECTION cs;
276 };
277
278 static __thread QemuThreadData *qemu_thread_data;
279
280 static unsigned __stdcall win32_start_routine(void *arg)
281 {
282 QemuThreadData *data = (QemuThreadData *) arg;
283 void *(*start_routine)(void *) = data->start_routine;
284 void *thread_arg = data->arg;
285
286 if (data->mode == QEMU_THREAD_DETACHED) {
287 g_free(data);
288 data = NULL;
289 }
290 qemu_thread_data = data;
291 qemu_thread_exit(start_routine(thread_arg));
292 abort();
293 }
294
295 void qemu_thread_exit(void *arg)
296 {
297 QemuThreadData *data = qemu_thread_data;
298
299 if (data) {
300 assert(data->mode != QEMU_THREAD_DETACHED);
301 data->ret = arg;
302 EnterCriticalSection(&data->cs);
303 data->exited = true;
304 LeaveCriticalSection(&data->cs);
305 }
306 _endthreadex(0);
307 }
308
309 void *qemu_thread_join(QemuThread *thread)
310 {
311 QemuThreadData *data;
312 void *ret;
313 HANDLE handle;
314
315 data = thread->data;
316 if (!data) {
317 return NULL;
318 }
319 /*
320 * Because multiple copies of the QemuThread can exist via
321 * qemu_thread_get_self, we need to store a value that cannot
322 * leak there. The simplest, non racy way is to store the TID,
323 * discard the handle that _beginthreadex gives back, and
324 * get another copy of the handle here.
325 */
326 handle = qemu_thread_get_handle(thread);
327 if (handle) {
328 WaitForSingleObject(handle, INFINITE);
329 CloseHandle(handle);
330 }
331 ret = data->ret;
332 assert(data->mode != QEMU_THREAD_DETACHED);
333 DeleteCriticalSection(&data->cs);
334 g_free(data);
335 return ret;
336 }
337
338 void qemu_thread_create(QemuThread *thread, const char *name,
339 void *(*start_routine)(void *),
340 void *arg, int mode)
341 {
342 HANDLE hThread;
343 struct QemuThreadData *data;
344
345 data = g_malloc(sizeof *data);
346 data->start_routine = start_routine;
347 data->arg = arg;
348 data->mode = mode;
349 data->exited = false;
350
351 if (data->mode != QEMU_THREAD_DETACHED) {
352 InitializeCriticalSection(&data->cs);
353 }
354
355 hThread = (HANDLE) _beginthreadex(NULL, 0, win32_start_routine,
356 data, 0, &thread->tid);
357 if (!hThread) {
358 error_exit(GetLastError(), __func__);
359 }
360 CloseHandle(hThread);
361 thread->data = (mode == QEMU_THREAD_DETACHED) ? NULL : data;
362 }
363
364 void qemu_thread_get_self(QemuThread *thread)
365 {
366 thread->data = qemu_thread_data;
367 thread->tid = GetCurrentThreadId();
368 }
369
370 HANDLE qemu_thread_get_handle(QemuThread *thread)
371 {
372 QemuThreadData *data;
373 HANDLE handle;
374
375 data = thread->data;
376 if (!data) {
377 return NULL;
378 }
379
380 assert(data->mode != QEMU_THREAD_DETACHED);
381 EnterCriticalSection(&data->cs);
382 if (!data->exited) {
383 handle = OpenThread(SYNCHRONIZE | THREAD_SUSPEND_RESUME, FALSE,
384 thread->tid);
385 } else {
386 handle = NULL;
387 }
388 LeaveCriticalSection(&data->cs);
389 return handle;
390 }
391
392 bool qemu_thread_is_self(QemuThread *thread)
393 {
394 return GetCurrentThreadId() == thread->tid;
395 }