1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * gthread.c: solaris thread system implementation
5 * Copyright 1998-2001 Sebastian Wilhelmi; University of Karlsruhe
6 * Copyright 2001 Hans Breuer
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
23 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
24 * file for a list of people on the GLib Team. See the ChangeLog
25 * files for a list of changes. These files are distributed with
26 * GLib at ftp://ftp.gtk.org/pub/gtk/.
29 /* The GMutex and GCond implementations in this file are some of the
30 * lowest-level code in GLib. All other parts of GLib (messages,
31 * memory, slices, etc) assume that they can freely use these facilities
32 * without risking recursion.
34 * As such, these functions are NOT permitted to call any other part of
37 * The thread manipulation functions (create, exit, join, etc.) have
38 * more freedom -- they can do as they please.
44 #include "glib-init.h"
46 #include "gthreadprivate.h"
56 g_thread_abort (gint status,
57 const gchar *function)
59 fprintf (stderr, "GLib (gthread-win32.c): Unexpected error from C library during '%s': %s. Aborting.\n",
60 strerror (status), function);
64 /* Starting with Vista and Windows 2008, we have access to the
65 * CONDITION_VARIABLE and SRWLock primitives on Windows, which are
66 * pretty reasonable approximations of the primitives specified in
67 * POSIX 2001 (pthread_cond_t and pthread_mutex_t respectively).
69 * Both of these types are structs containing a single pointer. That
70 * pointer is used as an atomic bitfield to support user-space mutexes
71 * that only get the kernel involved in cases of contention (similar
72 * to how futex()-based mutexes work on Linux). The biggest advantage
73 * of these new types is that they can be statically initialised to
74 * zero. That means that they are completely ABI compatible with our
75 * GMutex and GCond APIs.
80 g_mutex_init (GMutex *mutex)
82 InitializeSRWLock ((gpointer) mutex);
86 g_mutex_clear (GMutex *mutex)
91 g_mutex_lock (GMutex *mutex)
93 AcquireSRWLockExclusive ((gpointer) mutex);
97 g_mutex_trylock (GMutex *mutex)
99 return TryAcquireSRWLockExclusive ((gpointer) mutex);
103 g_mutex_unlock (GMutex *mutex)
105 ReleaseSRWLockExclusive ((gpointer) mutex);
110 static CRITICAL_SECTION *
111 g_rec_mutex_impl_new (void)
113 CRITICAL_SECTION *cs;
115 cs = g_slice_new (CRITICAL_SECTION);
116 InitializeCriticalSection (cs);
122 g_rec_mutex_impl_free (CRITICAL_SECTION *cs)
124 DeleteCriticalSection (cs);
125 g_slice_free (CRITICAL_SECTION, cs);
128 static CRITICAL_SECTION *
129 g_rec_mutex_get_impl (GRecMutex *mutex)
131 CRITICAL_SECTION *impl = mutex->p;
133 if G_UNLIKELY (mutex->p == NULL)
135 impl = g_rec_mutex_impl_new ();
136 if (InterlockedCompareExchangePointer (&mutex->p, impl, NULL) != NULL)
137 g_rec_mutex_impl_free (impl);
145 g_rec_mutex_init (GRecMutex *mutex)
147 mutex->p = g_rec_mutex_impl_new ();
151 g_rec_mutex_clear (GRecMutex *mutex)
153 g_rec_mutex_impl_free (mutex->p);
157 g_rec_mutex_lock (GRecMutex *mutex)
159 EnterCriticalSection (g_rec_mutex_get_impl (mutex));
163 g_rec_mutex_unlock (GRecMutex *mutex)
165 LeaveCriticalSection (mutex->p);
169 g_rec_mutex_trylock (GRecMutex *mutex)
171 return TryEnterCriticalSection (g_rec_mutex_get_impl (mutex));
177 g_rw_lock_init (GRWLock *lock)
179 InitializeSRWLock ((gpointer) lock);
183 g_rw_lock_clear (GRWLock *lock)
188 g_rw_lock_writer_lock (GRWLock *lock)
190 AcquireSRWLockExclusive ((gpointer) lock);
194 g_rw_lock_writer_trylock (GRWLock *lock)
196 return TryAcquireSRWLockExclusive ((gpointer) lock);
200 g_rw_lock_writer_unlock (GRWLock *lock)
202 ReleaseSRWLockExclusive ((gpointer) lock);
206 g_rw_lock_reader_lock (GRWLock *lock)
208 AcquireSRWLockShared ((gpointer) lock);
212 g_rw_lock_reader_trylock (GRWLock *lock)
214 return TryAcquireSRWLockShared ((gpointer) lock);
218 g_rw_lock_reader_unlock (GRWLock *lock)
220 ReleaseSRWLockShared ((gpointer) lock);
225 g_cond_init (GCond *cond)
227 InitializeConditionVariable ((gpointer) cond);
231 g_cond_clear (GCond *cond)
236 g_cond_signal (GCond *cond)
238 WakeConditionVariable ((gpointer) cond);
242 g_cond_broadcast (GCond *cond)
244 WakeAllConditionVariable ((gpointer) cond);
248 g_cond_wait (GCond *cond,
249 GMutex *entered_mutex)
251 SleepConditionVariableSRW ((gpointer) cond, (gpointer) entered_mutex, INFINITE, 0);
255 g_cond_wait_until (GCond *cond,
256 GMutex *entered_mutex,
259 gint64 span, start_time;
263 start_time = g_get_monotonic_time ();
266 span = end_time - start_time;
268 if G_UNLIKELY (span < 0)
270 else if G_UNLIKELY (span > G_GINT64_CONSTANT (1000) * (DWORD) INFINITE)
271 span_millis = INFINITE;
273 /* Round up so we don't time out too early */
274 span_millis = (span + 1000 - 1) / 1000;
276 /* We never want to wait infinitely */
277 if (span_millis >= INFINITE)
278 span_millis = INFINITE - 1;
280 signalled = SleepConditionVariableSRW ((gpointer) cond, (gpointer) entered_mutex, span_millis, 0);
284 /* In case we didn't wait long enough after a timeout, wait again for the
286 start_time = g_get_monotonic_time ();
288 while (start_time < end_time);
295 typedef struct _GPrivateDestructor GPrivateDestructor;
297 struct _GPrivateDestructor
300 GDestroyNotify notify;
301 GPrivateDestructor *next;
304 static GPrivateDestructor *g_private_destructors; /* (atomic) prepend-only */
305 static CRITICAL_SECTION g_private_lock;
308 g_private_get_impl (GPrivate *key)
310 DWORD impl = (DWORD) key->p;
312 if G_UNLIKELY (impl == 0)
314 EnterCriticalSection (&g_private_lock);
315 impl = (DWORD) key->p;
318 GPrivateDestructor *destructor;
322 if (impl == TLS_OUT_OF_INDEXES)
323 g_thread_abort (0, "TlsAlloc");
325 if (key->notify != NULL)
327 destructor = malloc (sizeof (GPrivateDestructor));
328 if G_UNLIKELY (destructor == NULL)
329 g_thread_abort (errno, "malloc");
330 destructor->index = impl;
331 destructor->notify = key->notify;
332 destructor->next = g_atomic_pointer_get (&g_private_destructors);
334 /* We need to do an atomic store due to the unlocked
335 * access to the destructor list from the thread exit
338 * It can double as a sanity check...
340 if (!g_atomic_pointer_compare_and_exchange (&g_private_destructors,
343 g_thread_abort (0, "g_private_get_impl(1)");
346 /* Ditto, due to the unlocked access on the fast path */
347 if (!g_atomic_pointer_compare_and_exchange (&key->p, NULL, impl))
348 g_thread_abort (0, "g_private_get_impl(2)");
350 LeaveCriticalSection (&g_private_lock);
357 g_private_get (GPrivate *key)
359 return TlsGetValue (g_private_get_impl (key));
363 g_private_set (GPrivate *key,
366 TlsSetValue (g_private_get_impl (key), value);
370 g_private_replace (GPrivate *key,
373 DWORD impl = g_private_get_impl (key);
376 old = TlsGetValue (impl);
377 TlsSetValue (impl, value);
378 if (old && key->notify)
384 #define win32_check_for_error(what) G_STMT_START{ \
386 g_error ("file %s: line %d (%s): error %s during %s", \
387 __FILE__, __LINE__, G_STRFUNC, \
388 g_win32_error_message (GetLastError ()), #what); \
391 #define G_MUTEX_SIZE (sizeof (gpointer))
393 typedef BOOL (__stdcall *GTryEnterCriticalSectionFunc) (CRITICAL_SECTION *);
404 g_system_thread_free (GRealThread *thread)
406 GThreadWin32 *wt = (GThreadWin32 *) thread;
408 win32_check_for_error (CloseHandle (wt->handle));
409 g_slice_free (GThreadWin32, wt);
413 g_system_thread_exit (void)
418 static guint __stdcall
419 g_thread_win32_proxy (gpointer data)
421 GThreadWin32 *self = data;
425 g_system_thread_exit ();
427 g_assert_not_reached ();
433 g_system_thread_get_scheduler_settings (GThreadSchedulerSettings *scheduler_settings)
435 HANDLE current_thread = GetCurrentThread ();
436 scheduler_settings->thread_prio = GetThreadPriority (current_thread);
442 g_system_thread_new (GThreadFunc proxy,
444 const GThreadSchedulerSettings *scheduler_settings,
450 GThreadWin32 *thread;
451 GRealThread *base_thread;
453 const gchar *message = NULL;
456 thread = g_slice_new0 (GThreadWin32);
457 thread->proxy = proxy;
458 thread->handle = (HANDLE) NULL;
459 base_thread = (GRealThread*)thread;
460 base_thread->ref_count = 2;
461 base_thread->ours = TRUE;
462 base_thread->thread.joinable = TRUE;
463 base_thread->thread.func = func;
464 base_thread->thread.data = data;
465 base_thread->name = g_strdup (name);
467 thread->handle = (HANDLE) _beginthreadex (NULL, stack_size, g_thread_win32_proxy, thread,
468 CREATE_SUSPENDED, &ignore);
470 if (thread->handle == NULL)
472 message = "Error creating thread";
476 /* For thread priority inheritance we need to manually set the thread
477 * priority of the new thread to the priority of the current thread. We
478 * also have to start the thread suspended and resume it after actually
479 * setting the priority here.
481 * On Windows, by default all new threads are created with NORMAL thread
485 if (scheduler_settings)
487 thread_prio = scheduler_settings->thread_prio;
491 HANDLE current_thread = GetCurrentThread ();
492 thread_prio = GetThreadPriority (current_thread);
495 if (thread_prio == THREAD_PRIORITY_ERROR_RETURN)
497 message = "Error getting current thread priority";
501 if (SetThreadPriority (thread->handle, thread_prio) == 0)
503 message = "Error setting new thread priority";
507 if (ResumeThread (thread->handle) == -1)
509 message = "Error resuming new thread";
513 return (GRealThread *) thread;
517 gchar *win_error = g_win32_error_message (GetLastError ());
518 g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN,
519 "%s: %s", message, win_error);
522 CloseHandle (thread->handle);
523 g_slice_free (GThreadWin32, thread);
529 g_thread_yield (void)
535 g_system_thread_wait (GRealThread *thread)
537 GThreadWin32 *wt = (GThreadWin32 *) thread;
539 win32_check_for_error (WAIT_FAILED != WaitForSingleObject (wt->handle, INFINITE));
542 #define EXCEPTION_SET_THREAD_NAME ((DWORD) 0x406D1388)
545 static void *SetThreadName_VEH_handle = NULL;
547 static LONG __stdcall
548 SetThreadName_VEH (PEXCEPTION_POINTERS ExceptionInfo)
550 if (ExceptionInfo->ExceptionRecord != NULL &&
551 ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SET_THREAD_NAME)
552 return EXCEPTION_CONTINUE_EXECUTION;
554 return EXCEPTION_CONTINUE_SEARCH;
558 typedef struct _THREADNAME_INFO
560 DWORD dwType; /* must be 0x1000 */
561 LPCSTR szName; /* pointer to name (in user addr space) */
562 DWORD dwThreadID; /* thread ID (-1=caller thread) */
563 DWORD dwFlags; /* reserved for future use, must be zero */
567 SetThreadName (DWORD dwThreadID,
570 THREADNAME_INFO info;
573 info.dwType = 0x1000;
574 info.szName = szThreadName;
575 info.dwThreadID = dwThreadID;
578 infosize = sizeof (info) / sizeof (DWORD);
583 RaiseException (EXCEPTION_SET_THREAD_NAME, 0, infosize,
584 (const ULONG_PTR *) &info);
586 __except (EXCEPTION_EXECUTE_HANDLER)
590 /* Without a debugger we *must* have an exception handler,
591 * otherwise raising an exception will crash the process.
593 if ((!IsDebuggerPresent ()) && (SetThreadName_VEH_handle == NULL))
596 RaiseException (EXCEPTION_SET_THREAD_NAME, 0, infosize, (DWORD *) &info);
600 typedef HRESULT (WINAPI *pSetThreadDescription) (HANDLE hThread,
601 PCWSTR lpThreadDescription);
602 static pSetThreadDescription SetThreadDescriptionFunc = NULL;
603 HMODULE kernel32_module = NULL;
606 g_thread_win32_load_library (void)
608 /* FIXME: Add support for UWP app */
609 #if !defined(G_WINAPI_ONLY_APP)
610 static volatile gsize _init_once = 0;
611 if (g_once_init_enter (&_init_once))
613 kernel32_module = LoadLibraryW (L"kernel32.dll");
616 SetThreadDescriptionFunc =
617 (pSetThreadDescription) GetProcAddress (kernel32_module,
618 "SetThreadDescription");
619 if (!SetThreadDescriptionFunc)
620 FreeLibrary (kernel32_module);
622 g_once_init_leave (&_init_once, 1);
626 return !!SetThreadDescriptionFunc;
630 g_thread_win32_set_thread_desc (const gchar *name)
635 if (!g_thread_win32_load_library () || !name)
638 namew = g_utf8_to_utf16 (name, -1, NULL, NULL, NULL);
642 hr = SetThreadDescriptionFunc (GetCurrentThread (), namew);
645 return SUCCEEDED (hr);
649 g_system_thread_set_name (const gchar *name)
651 /* Prefer SetThreadDescription over exception based way if available,
652 * since thread description set by SetThreadDescription will be preserved
654 if (!g_thread_win32_set_thread_desc (name))
655 SetThreadName ((DWORD) -1, name);
661 g_thread_win32_init (void)
663 InitializeCriticalSection (&g_private_lock);
666 SetThreadName_VEH_handle = AddVectoredExceptionHandler (1, &SetThreadName_VEH);
667 if (SetThreadName_VEH_handle == NULL)
669 /* This is bad, but what can we do? */
675 g_thread_win32_thread_detach (void)
677 gboolean dtors_called;
681 GPrivateDestructor *dtor;
683 /* We go by the POSIX book on this one.
685 * If we call a destructor then there is a chance that some new
686 * TLS variables got set by code called in that destructor.
688 * Loop until nothing is left.
690 dtors_called = FALSE;
692 for (dtor = g_atomic_pointer_get (&g_private_destructors); dtor; dtor = dtor->next)
696 value = TlsGetValue (dtor->index);
697 if (value != NULL && dtor->notify != NULL)
699 /* POSIX says to clear this before the call */
700 TlsSetValue (dtor->index, NULL);
701 dtor->notify (value);
706 while (dtors_called);
710 g_thread_win32_process_detach (void)
713 if (SetThreadName_VEH_handle != NULL)
715 RemoveVectoredExceptionHandler (SetThreadName_VEH_handle);
716 SetThreadName_VEH_handle = NULL;
721 /* vim:set foldmethod=marker: */