* Copyright 1998-2001 Sebastian Wilhelmi; University of Karlsruhe
* Copyright 2001 Hans Breuer
*
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
/*
#include "config.h"
#include "glib.h"
+#include "glib-init.h"
#include "gthread.h"
#include "gthreadprivate.h"
#include "gslice.h"
{
fprintf (stderr, "GLib (gthread-win32.c): Unexpected error from C library during '%s': %s. Aborting.\n",
strerror (status), function);
- abort ();
+ g_abort ();
}
/* Starting with Vista and Windows 2008, we have access to the
- * CONDITION_VARIABLE and SRWLock primatives on Windows, which are
- * pretty reasonable approximations of the primatives specified in
+ * CONDITION_VARIABLE and SRWLock primitives on Windows, which are
+ * pretty reasonable approximations of the primitives specified in
* POSIX 2001 (pthread_cond_t and pthread_mutex_t respectively).
*
* Both of these types are structs containing a single pointer. That
* of these new types is that they can be statically initialised to
* zero. That means that they are completely ABI compatible with our
* GMutex and GCond APIs.
- *
- * Unfortunately, Windows XP lacks these facilities and GLib still
- * needs to support Windows XP. Our approach here is as follows:
- *
- * - avoid depending on structure declarations at compile-time by
- * declaring our own GMutex and GCond strutures to be
- * ABI-compatible with SRWLock and CONDITION_VARIABLE and using
- * those instead
- *
- * - avoid a hard dependency on the symbols used to manipulate these
- * structures by doing a dynamic lookup of those symbols at
- * runtime
- *
- * - if the symbols are not available, emulate them using other
- * primatives
- *
- * Using this approach also allows us to easily build a GLib that lacks
- * support for Windows XP or to remove this code entirely when XP is no
- * longer supported (end of line is currently April 8, 2014).
*/
-typedef struct
-{
- void (__stdcall * CallThisOnThreadExit) (void); /* fake */
-
- void (__stdcall * InitializeSRWLock) (gpointer lock);
- void (__stdcall * DeleteSRWLock) (gpointer lock); /* fake */
- void (__stdcall * AcquireSRWLockExclusive) (gpointer lock);
- BOOLEAN (__stdcall * TryAcquireSRWLockExclusive) (gpointer lock);
- void (__stdcall * ReleaseSRWLockExclusive) (gpointer lock);
- void (__stdcall * AcquireSRWLockShared) (gpointer lock);
- BOOLEAN (__stdcall * TryAcquireSRWLockShared) (gpointer lock);
- void (__stdcall * ReleaseSRWLockShared) (gpointer lock);
-
- void (__stdcall * InitializeConditionVariable) (gpointer cond);
- void (__stdcall * DeleteConditionVariable) (gpointer cond); /* fake */
- BOOL (__stdcall * SleepConditionVariableSRW) (gpointer cond,
- gpointer lock,
- DWORD timeout,
- ULONG flags);
- void (__stdcall * WakeAllConditionVariable) (gpointer cond);
- void (__stdcall * WakeConditionVariable) (gpointer cond);
-} GThreadImplVtable;
-
-static GThreadImplVtable g_thread_impl_vtable;
/* {{{1 GMutex */
void
g_mutex_init (GMutex *mutex)
{
- g_thread_impl_vtable.InitializeSRWLock (mutex);
+ InitializeSRWLock ((gpointer) mutex);
}
void
g_mutex_clear (GMutex *mutex)
{
- if (g_thread_impl_vtable.DeleteSRWLock != NULL)
- g_thread_impl_vtable.DeleteSRWLock (mutex);
}
void
g_mutex_lock (GMutex *mutex)
{
- g_thread_impl_vtable.AcquireSRWLockExclusive (mutex);
+ AcquireSRWLockExclusive ((gpointer) mutex);
}
gboolean
g_mutex_trylock (GMutex *mutex)
{
- return g_thread_impl_vtable.TryAcquireSRWLockExclusive (mutex);
+ return TryAcquireSRWLockExclusive ((gpointer) mutex);
}
void
g_mutex_unlock (GMutex *mutex)
{
- g_thread_impl_vtable.ReleaseSRWLockExclusive (mutex);
+ ReleaseSRWLockExclusive ((gpointer) mutex);
}
/* {{{1 GRecMutex */
void
g_rw_lock_init (GRWLock *lock)
{
- g_thread_impl_vtable.InitializeSRWLock (lock);
+ InitializeSRWLock ((gpointer) lock);
}
void
g_rw_lock_clear (GRWLock *lock)
{
- if (g_thread_impl_vtable.DeleteSRWLock != NULL)
- g_thread_impl_vtable.DeleteSRWLock (lock);
}
void
g_rw_lock_writer_lock (GRWLock *lock)
{
- g_thread_impl_vtable.AcquireSRWLockExclusive (lock);
+ AcquireSRWLockExclusive ((gpointer) lock);
}
gboolean
g_rw_lock_writer_trylock (GRWLock *lock)
{
- return g_thread_impl_vtable.TryAcquireSRWLockExclusive (lock);
+ return TryAcquireSRWLockExclusive ((gpointer) lock);
}
void
g_rw_lock_writer_unlock (GRWLock *lock)
{
- g_thread_impl_vtable.ReleaseSRWLockExclusive (lock);
+ ReleaseSRWLockExclusive ((gpointer) lock);
}
void
g_rw_lock_reader_lock (GRWLock *lock)
{
- g_thread_impl_vtable.AcquireSRWLockShared (lock);
+ AcquireSRWLockShared ((gpointer) lock);
}
gboolean
g_rw_lock_reader_trylock (GRWLock *lock)
{
- return g_thread_impl_vtable.TryAcquireSRWLockShared (lock);
+ return TryAcquireSRWLockShared ((gpointer) lock);
}
void
g_rw_lock_reader_unlock (GRWLock *lock)
{
- g_thread_impl_vtable.ReleaseSRWLockShared (lock);
+ ReleaseSRWLockShared ((gpointer) lock);
}
/* {{{1 GCond */
void
g_cond_init (GCond *cond)
{
- g_thread_impl_vtable.InitializeConditionVariable (cond);
+ InitializeConditionVariable ((gpointer) cond);
}
void
g_cond_clear (GCond *cond)
{
- if (g_thread_impl_vtable.DeleteConditionVariable)
- g_thread_impl_vtable.DeleteConditionVariable (cond);
}
void
g_cond_signal (GCond *cond)
{
- g_thread_impl_vtable.WakeConditionVariable (cond);
+ WakeConditionVariable ((gpointer) cond);
}
void
g_cond_broadcast (GCond *cond)
{
- g_thread_impl_vtable.WakeAllConditionVariable (cond);
+ WakeAllConditionVariable ((gpointer) cond);
}
void
g_cond_wait (GCond *cond,
GMutex *entered_mutex)
{
- g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, INFINITE, 0);
+ SleepConditionVariableSRW ((gpointer) cond, (gpointer) entered_mutex, INFINITE, 0);
}
gboolean
GMutex *entered_mutex,
gint64 end_time)
{
- gint64 span;
+ gint64 span, start_time;
+ DWORD span_millis;
+ gboolean signalled;
- span = end_time - g_get_monotonic_time ();
+ start_time = g_get_monotonic_time ();
+ do
+ {
+ span = end_time - start_time;
- if G_UNLIKELY (span < 0)
- span = 0;
+ if G_UNLIKELY (span < 0)
+ span_millis = 0;
+ else if G_UNLIKELY (span > G_GINT64_CONSTANT (1000) * (DWORD) INFINITE)
+ span_millis = INFINITE;
+ else
+ /* Round up so we don't time out too early */
+ span_millis = (span + 1000 - 1) / 1000;
- if G_UNLIKELY (span > G_GINT64_CONSTANT (1000) * G_MAXINT32)
- span = INFINITE;
+ /* We never want to wait infinitely */
+ if (span_millis >= INFINITE)
+ span_millis = INFINITE - 1;
+
+ signalled = SleepConditionVariableSRW ((gpointer) cond, (gpointer) entered_mutex, span_millis, 0);
+ if (signalled)
+ break;
+
+ /* In case we didn't wait long enough after a timeout, wait again for the
+ * remaining time */
+ start_time = g_get_monotonic_time ();
+ }
+ while (start_time < end_time);
- return g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, span / 1000, 0);
+ return signalled;
}
/* {{{1 GPrivate */
GPrivateDestructor *next;
};
-static GPrivateDestructor * volatile g_private_destructors;
+static GPrivateDestructor *g_private_destructors; /* (atomic) prepend-only */
static CRITICAL_SECTION g_private_lock;
static DWORD
g_private_get_impl (GPrivate *key)
{
- DWORD impl = (DWORD) key->p;
+ DWORD impl = (DWORD) GPOINTER_TO_UINT(key->p);
if G_UNLIKELY (impl == 0)
{
EnterCriticalSection (&g_private_lock);
- impl = (DWORD) key->p;
+ impl = (UINT_PTR) key->p;
if (impl == 0)
{
GPrivateDestructor *destructor;
impl = TlsAlloc ();
- if (impl == TLS_OUT_OF_INDEXES)
+ if G_UNLIKELY (impl == 0)
+ {
+ /* Ignore TLS index 0 temporarily (as 0 is the indicator that we
+ * haven't allocated TLS yet) and alloc again;
+ * See https://gitlab.gnome.org/GNOME/glib/-/issues/2058 */
+ DWORD impl2 = TlsAlloc ();
+ TlsFree (impl);
+ impl = impl2;
+ }
+
+ if (impl == TLS_OUT_OF_INDEXES || impl == 0)
g_thread_abort (0, "TlsAlloc");
if (key->notify != NULL)
g_thread_abort (errno, "malloc");
destructor->index = impl;
destructor->notify = key->notify;
- destructor->next = g_private_destructors;
+ destructor->next = g_atomic_pointer_get (&g_private_destructors);
/* We need to do an atomic store due to the unlocked
* access to the destructor list from the thread exit
*
* It can double as a sanity check...
*/
- if (InterlockedCompareExchangePointer (&g_private_destructors, destructor,
- destructor->next) != destructor->next)
+ if (!g_atomic_pointer_compare_and_exchange (&g_private_destructors,
+ destructor->next,
+ destructor))
g_thread_abort (0, "g_private_get_impl(1)");
}
/* Ditto, due to the unlocked access on the fast path */
- if (InterlockedCompareExchangePointer (&key->p, impl, NULL) != NULL)
+ if (!g_atomic_pointer_compare_and_exchange (&key->p, NULL, impl))
g_thread_abort (0, "g_private_get_impl(2)");
}
LeaveCriticalSection (&g_private_lock);
gpointer old;
old = TlsGetValue (impl);
+ TlsSetValue (impl, value);
if (old && key->notify)
key->notify (old);
- TlsSetValue (impl, value);
}
/* {{{1 GThread */
void
g_system_thread_exit (void)
{
+ /* In static compilation, DllMain doesn't exist and so DLL_THREAD_DETACH
+ * case is never called and thread destroy notifications are not triggered.
+ * To ensure that notifications are correctly triggered in static
+ * compilation mode, we call directly the "detach" function here right
+ * before terminating the thread.
+ * As all win32 threads initialized through the glib API are run through
+ * the same proxy function g_thread_win32_proxy() which calls systematically
+ * g_system_thread_exit() when finishing, we obtain the same behavior as
+ * with dynamic compilation.
+ *
+ * WARNING: unfortunately this mechanism cannot work with threads created
+ * directly from the Windows API using CreateThread() or _beginthread/ex().
+ * It only works with threads created by using the glib API with
+ * g_system_thread_new(). If users need absolutely to use a thread NOT
+ * created with glib API under Windows and in static compilation mode, they
+ * should not use glib functions within their thread or they may encounter
+ * memory leaks when the thread finishes.
+ */
+#ifdef GLIB_STATIC_COMPILATION
+ g_thread_win32_thread_detach ();
+#endif
+
_endthreadex (0);
}
return 0;
}
+gboolean
+g_system_thread_get_scheduler_settings (GThreadSchedulerSettings *scheduler_settings)
+{
+ HANDLE current_thread = GetCurrentThread ();
+ scheduler_settings->thread_prio = GetThreadPriority (current_thread);
+
+ return TRUE;
+}
+
GRealThread *
-g_system_thread_new (GThreadFunc func,
- gulong stack_size,
- GError **error)
+g_system_thread_new (GThreadFunc proxy,
+ gulong stack_size,
+ const GThreadSchedulerSettings *scheduler_settings,
+ const char *name,
+ GThreadFunc func,
+ gpointer data,
+ GError **error)
{
GThreadWin32 *thread;
+ GRealThread *base_thread;
guint ignore;
+ const gchar *message = NULL;
+ int thread_prio;
thread = g_slice_new0 (GThreadWin32);
- thread->proxy = func;
-
- thread->handle = (HANDLE) _beginthreadex (NULL, stack_size, g_thread_win32_proxy, thread, 0, &ignore);
+ thread->proxy = proxy;
+ thread->handle = (HANDLE) NULL;
+ base_thread = (GRealThread*)thread;
+ base_thread->ref_count = 2;
+ base_thread->ours = TRUE;
+ base_thread->thread.joinable = TRUE;
+ base_thread->thread.func = func;
+ base_thread->thread.data = data;
+ base_thread->name = g_strdup (name);
+
+ thread->handle = (HANDLE) _beginthreadex (NULL, stack_size, g_thread_win32_proxy, thread,
+ CREATE_SUSPENDED, &ignore);
if (thread->handle == NULL)
{
- gchar *win_error = g_win32_error_message (GetLastError ());
- g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN,
- "Error creating thread: %s", win_error);
- g_free (win_error);
- g_slice_free (GThreadWin32, thread);
- return NULL;
+ message = "Error creating thread";
+ goto error;
}
- return (GRealThread *) thread;
-}
-
-void
-g_thread_yield (void)
-{
- Sleep(0);
-}
-
-void
-g_system_thread_wait (GRealThread *thread)
-{
- GThreadWin32 *wt = (GThreadWin32 *) thread;
-
- win32_check_for_error (WAIT_FAILED != WaitForSingleObject (wt->handle, INFINITE));
-}
-
-void
-g_system_thread_set_name (const gchar *name)
-{
- /* FIXME: implement */
-}
-
-/* {{{1 SRWLock and CONDITION_VARIABLE emulation (for Windows XP) */
-
-static CRITICAL_SECTION g_thread_xp_lock;
-static DWORD g_thread_xp_waiter_tls;
-
-/* {{{2 GThreadWaiter utility class for CONDITION_VARIABLE emulation */
-typedef struct _GThreadXpWaiter GThreadXpWaiter;
-struct _GThreadXpWaiter
-{
- HANDLE event;
- volatile GThreadXpWaiter *next;
- volatile GThreadXpWaiter **my_owner;
-};
-
-static GThreadXpWaiter *
-g_thread_xp_waiter_get (void)
-{
- GThreadXpWaiter *waiter;
-
- waiter = TlsGetValue (g_thread_xp_waiter_tls);
-
- if G_UNLIKELY (waiter == NULL)
- {
- waiter = malloc (sizeof (GThreadXpWaiter));
- if (waiter == NULL)
- g_thread_abort (GetLastError (), "malloc");
- waiter->event = CreateEvent (0, FALSE, FALSE, NULL);
- if (waiter->event == NULL)
- g_thread_abort (GetLastError (), "CreateEvent");
- waiter->my_owner = NULL;
-
- TlsSetValue (g_thread_xp_waiter_tls, waiter);
- }
-
- return waiter;
-}
-
-static void __stdcall
-g_thread_xp_CallThisOnThreadExit (void)
-{
- GThreadXpWaiter *waiter;
-
- waiter = TlsGetValue (g_thread_xp_waiter_tls);
-
- if (waiter != NULL)
- {
- TlsSetValue (g_thread_xp_waiter_tls, NULL);
- CloseHandle (waiter->event);
- free (waiter);
- }
-}
-
-/* {{{2 SRWLock emulation */
-typedef struct
-{
- CRITICAL_SECTION writer_lock;
- gboolean ever_shared; /* protected by writer_lock */
- gboolean writer_locked; /* protected by writer_lock */
-
- /* below is only ever touched if ever_shared becomes true */
- CRITICAL_SECTION atomicity;
- GThreadXpWaiter *queued_writer; /* protected by atomicity lock */
- gint num_readers; /* protected by atomicity lock */
-} GThreadSRWLock;
-
-static void __stdcall
-g_thread_xp_InitializeSRWLock (gpointer mutex)
-{
- *(GThreadSRWLock * volatile *) mutex = NULL;
-}
-
-static void __stdcall
-g_thread_xp_DeleteSRWLock (gpointer mutex)
-{
- GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
-
- if (lock)
- {
- if (lock->ever_shared)
- DeleteCriticalSection (&lock->atomicity);
-
- DeleteCriticalSection (&lock->writer_lock);
- free (lock);
- }
-}
-
-static GThreadSRWLock * __stdcall
-g_thread_xp_get_srwlock (GThreadSRWLock * volatile *lock)
-{
- GThreadSRWLock *result;
-
- /* It looks like we're missing some barriers here, but this code only
- * ever runs on Windows XP, which in turn only ever runs on hardware
- * with a relatively rigid memory model. The 'volatile' will take
- * care of the compiler.
+ /* For thread priority inheritance we need to manually set the thread
+ * priority of the new thread to the priority of the current thread. We
+ * also have to start the thread suspended and resume it after actually
+ * setting the priority here.
+ *
+ * On Windows, by default all new threads are created with NORMAL thread
+ * priority.
*/
- result = *lock;
- if G_UNLIKELY (result == NULL)
+ if (scheduler_settings)
{
- EnterCriticalSection (&g_thread_xp_lock);
-
- /* Check again */
- result = *lock;
- if (result == NULL)
- {
- result = malloc (sizeof (GThreadSRWLock));
-
- if (result == NULL)
- g_thread_abort (errno, "malloc");
-
- InitializeCriticalSection (&result->writer_lock);
- result->writer_locked = FALSE;
- result->ever_shared = FALSE;
- *lock = result;
- }
-
- LeaveCriticalSection (&g_thread_xp_lock);
+ thread_prio = scheduler_settings->thread_prio;
}
-
- return result;
-}
-
-static void __stdcall
-g_thread_xp_AcquireSRWLockExclusive (gpointer mutex)
-{
- GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
-
- EnterCriticalSection (&lock->writer_lock);
-
- /* CRITICAL_SECTION is reentrant, but SRWLock is not.
- * Detect the deadlock that would occur on later Windows version.
- */
- g_assert (!lock->writer_locked);
- lock->writer_locked = TRUE;
-
- if (lock->ever_shared)
+ else
{
- GThreadXpWaiter *waiter = NULL;
-
- EnterCriticalSection (&lock->atomicity);
- if (lock->num_readers > 0)
- lock->queued_writer = waiter = g_thread_xp_waiter_get ();
- LeaveCriticalSection (&lock->atomicity);
-
- if (waiter != NULL)
- WaitForSingleObject (waiter->event, INFINITE);
-
- lock->queued_writer = NULL;
+ HANDLE current_thread = GetCurrentThread ();
+ thread_prio = GetThreadPriority (current_thread);
}
-}
-
-static BOOLEAN __stdcall
-g_thread_xp_TryAcquireSRWLockExclusive (gpointer mutex)
-{
- GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
- if (!TryEnterCriticalSection (&lock->writer_lock))
- return FALSE;
-
- /* CRITICAL_SECTION is reentrant, but SRWLock is not.
- * Ensure that this properly returns FALSE (as SRWLock would).
- */
- if G_UNLIKELY (lock->writer_locked)
+ if (thread_prio == THREAD_PRIORITY_ERROR_RETURN)
{
- LeaveCriticalSection (&lock->writer_lock);
- return FALSE;
+ message = "Error getting current thread priority";
+ goto error;
}
- lock->writer_locked = TRUE;
-
- if (lock->ever_shared)
+ if (SetThreadPriority (thread->handle, thread_prio) == 0)
{
- gboolean available;
-
- EnterCriticalSection (&lock->atomicity);
- available = lock->num_readers == 0;
- LeaveCriticalSection (&lock->atomicity);
-
- if (!available)
- {
- LeaveCriticalSection (&lock->writer_lock);
- return FALSE;
- }
+ message = "Error setting new thread priority";
+ goto error;
}
- return TRUE;
-}
-
-static void __stdcall
-g_thread_xp_ReleaseSRWLockExclusive (gpointer mutex)
-{
- GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
-
- lock->writer_locked = FALSE;
-
- /* We need this until we fix some weird parts of GLib that try to
- * unlock freshly-allocated mutexes.
- */
- if (lock != NULL)
- LeaveCriticalSection (&lock->writer_lock);
-}
-
-static void
-g_thread_xp_srwlock_become_reader (GThreadSRWLock *lock)
-{
- if G_UNLIKELY (!lock->ever_shared)
+ if (ResumeThread (thread->handle) == (DWORD) -1)
{
- InitializeCriticalSection (&lock->atomicity);
- lock->queued_writer = NULL;
- lock->num_readers = 0;
-
- lock->ever_shared = TRUE;
+ message = "Error resuming new thread";
+ goto error;
}
- EnterCriticalSection (&lock->atomicity);
- lock->num_readers++;
- LeaveCriticalSection (&lock->atomicity);
-}
-
-static void __stdcall
-g_thread_xp_AcquireSRWLockShared (gpointer mutex)
-{
- GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
-
- EnterCriticalSection (&lock->writer_lock);
-
- /* See g_thread_xp_AcquireSRWLockExclusive */
- g_assert (!lock->writer_locked);
-
- g_thread_xp_srwlock_become_reader (lock);
+ return (GRealThread *) thread;
- LeaveCriticalSection (&lock->writer_lock);
+error:
+ {
+ gchar *win_error = g_win32_error_message (GetLastError ());
+ g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN,
+ "%s: %s", message, win_error);
+ g_free (win_error);
+ if (thread->handle)
+ CloseHandle (thread->handle);
+ g_slice_free (GThreadWin32, thread);
+ return NULL;
+ }
}
-static BOOLEAN __stdcall
-g_thread_xp_TryAcquireSRWLockShared (gpointer mutex)
+void
+g_thread_yield (void)
{
- GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
-
- if (!TryEnterCriticalSection (&lock->writer_lock))
- return FALSE;
-
- /* See g_thread_xp_AcquireSRWLockExclusive */
- if G_UNLIKELY (lock->writer_locked)
- {
- LeaveCriticalSection (&lock->writer_lock);
- return FALSE;
- }
-
- g_thread_xp_srwlock_become_reader (lock);
-
- LeaveCriticalSection (&lock->writer_lock);
-
- return TRUE;
+ Sleep(0);
}
-static void __stdcall
-g_thread_xp_ReleaseSRWLockShared (gpointer mutex)
+void
+g_system_thread_wait (GRealThread *thread)
{
- GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
-
- EnterCriticalSection (&lock->atomicity);
-
- lock->num_readers--;
-
- if (lock->num_readers == 0 && lock->queued_writer)
- SetEvent (lock->queued_writer->event);
+ GThreadWin32 *wt = (GThreadWin32 *) thread;
- LeaveCriticalSection (&lock->atomicity);
+ win32_check_for_error (WAIT_FAILED != WaitForSingleObject (wt->handle, INFINITE));
}
-/* {{{2 CONDITION_VARIABLE emulation */
-typedef struct
-{
- volatile GThreadXpWaiter *first;
- volatile GThreadXpWaiter **last_ptr;
-} GThreadXpCONDITION_VARIABLE;
+#define EXCEPTION_SET_THREAD_NAME ((DWORD) 0x406D1388)
-static void __stdcall
-g_thread_xp_InitializeConditionVariable (gpointer cond)
-{
- *(GThreadXpCONDITION_VARIABLE * volatile *) cond = NULL;
-}
+#ifndef _MSC_VER
+static void *SetThreadName_VEH_handle = NULL;
-static void __stdcall
-g_thread_xp_DeleteConditionVariable (gpointer cond)
+static LONG __stdcall
+SetThreadName_VEH (PEXCEPTION_POINTERS ExceptionInfo)
{
- GThreadXpCONDITION_VARIABLE *cv = *(GThreadXpCONDITION_VARIABLE * volatile *) cond;
+ if (ExceptionInfo->ExceptionRecord != NULL &&
+ ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SET_THREAD_NAME)
+ return EXCEPTION_CONTINUE_EXECUTION;
- if (cv)
- free (cv);
+ return EXCEPTION_CONTINUE_SEARCH;
}
+#endif
-static GThreadXpCONDITION_VARIABLE * __stdcall
-g_thread_xp_get_condition_variable (GThreadXpCONDITION_VARIABLE * volatile *cond)
+typedef struct _THREADNAME_INFO
{
- GThreadXpCONDITION_VARIABLE *result;
+ DWORD dwType; /* must be 0x1000 */
+ LPCSTR szName; /* pointer to name (in user addr space) */
+ DWORD dwThreadID; /* thread ID (-1=caller thread) */
+ DWORD dwFlags; /* reserved for future use, must be zero */
+} THREADNAME_INFO;
- /* It looks like we're missing some barriers here, but this code only
- * ever runs on Windows XP, which in turn only ever runs on hardware
- * with a relatively rigid memory model. The 'volatile' will take
- * care of the compiler.
- */
- result = *cond;
-
- if G_UNLIKELY (result == NULL)
- {
- result = malloc (sizeof (GThreadXpCONDITION_VARIABLE));
-
- if (result == NULL)
- g_thread_abort (errno, "malloc");
-
- result->first = NULL;
- result->last_ptr = &result->first;
-
- if (InterlockedCompareExchangePointer (cond, result, NULL) != NULL)
- {
- free (result);
- result = *cond;
- }
- }
-
- return result;
-}
+static void
+SetThreadName (DWORD dwThreadID,
+ LPCSTR szThreadName)
+{
+ THREADNAME_INFO info;
+ DWORD infosize;
+
+ info.dwType = 0x1000;
+ info.szName = szThreadName;
+ info.dwThreadID = dwThreadID;
+ info.dwFlags = 0;
+
+ infosize = sizeof (info) / sizeof (DWORD);
+
+#ifdef _MSC_VER
+ __try
+ {
+ RaiseException (EXCEPTION_SET_THREAD_NAME, 0, infosize,
+ (const ULONG_PTR *) &info);
+ }
+ __except (EXCEPTION_EXECUTE_HANDLER)
+ {
+ }
+#else
+ /* Without a debugger we *must* have an exception handler,
+ * otherwise raising an exception will crash the process.
+ */
+ if ((!IsDebuggerPresent ()) && (SetThreadName_VEH_handle == NULL))
+ return;
+
+ RaiseException (EXCEPTION_SET_THREAD_NAME, 0, infosize, (const ULONG_PTR *) &info);
+#endif
+}
+
+typedef HRESULT (WINAPI *pSetThreadDescription) (HANDLE hThread,
+ PCWSTR lpThreadDescription);
+static pSetThreadDescription SetThreadDescriptionFunc = NULL;
+static HMODULE kernel32_module = NULL;
-static BOOL __stdcall
-g_thread_xp_SleepConditionVariableSRW (gpointer cond,
- gpointer mutex,
- DWORD timeout,
- ULONG flags)
+static gboolean
+g_thread_win32_load_library (void)
{
- GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
- GThreadXpWaiter *waiter = g_thread_xp_waiter_get ();
- DWORD status;
-
- waiter->next = NULL;
-
- EnterCriticalSection (&g_thread_xp_lock);
- waiter->my_owner = cv->last_ptr;
- *cv->last_ptr = waiter;
- cv->last_ptr = &waiter->next;
- LeaveCriticalSection (&g_thread_xp_lock);
-
- g_mutex_unlock (mutex);
- status = WaitForSingleObject (waiter->event, timeout);
-
- if (status != WAIT_TIMEOUT && status != WAIT_OBJECT_0)
- g_thread_abort (GetLastError (), "WaitForSingleObject");
- g_mutex_lock (mutex);
-
- if (status == WAIT_TIMEOUT)
+ /* FIXME: Add support for UWP app */
+#if !defined(G_WINAPI_ONLY_APP)
+ static gsize _init_once = 0;
+ if (g_once_init_enter (&_init_once))
{
- EnterCriticalSection (&g_thread_xp_lock);
- if (waiter->my_owner)
+ kernel32_module = LoadLibraryW (L"kernel32.dll");
+ if (kernel32_module)
{
- if (waiter->next)
- waiter->next->my_owner = waiter->my_owner;
- else
- cv->last_ptr = waiter->my_owner;
- *waiter->my_owner = waiter->next;
- waiter->my_owner = NULL;
+ SetThreadDescriptionFunc =
+ (pSetThreadDescription) GetProcAddress (kernel32_module,
+ "SetThreadDescription");
+ if (!SetThreadDescriptionFunc)
+ FreeLibrary (kernel32_module);
}
- LeaveCriticalSection (&g_thread_xp_lock);
+ g_once_init_leave (&_init_once, 1);
}
+#endif
- return status == WAIT_OBJECT_0;
+ return !!SetThreadDescriptionFunc;
}
-static void __stdcall
-g_thread_xp_WakeConditionVariable (gpointer cond)
-{
- GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
- volatile GThreadXpWaiter *waiter;
-
- EnterCriticalSection (&g_thread_xp_lock);
-
- waiter = cv->first;
- if (waiter != NULL)
- {
- waiter->my_owner = NULL;
- cv->first = waiter->next;
- if (cv->first != NULL)
- cv->first->my_owner = &cv->first;
- else
- cv->last_ptr = &cv->first;
- }
-
- if (waiter != NULL)
- SetEvent (waiter->event);
-
- LeaveCriticalSection (&g_thread_xp_lock);
-}
-
-static void __stdcall
-g_thread_xp_WakeAllConditionVariable (gpointer cond)
+static gboolean
+g_thread_win32_set_thread_desc (const gchar *name)
{
- GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
- volatile GThreadXpWaiter *waiter;
-
- EnterCriticalSection (&g_thread_xp_lock);
+ HRESULT hr;
+ wchar_t *namew;
- waiter = cv->first;
- cv->first = NULL;
- cv->last_ptr = &cv->first;
+ if (!g_thread_win32_load_library () || !name)
+ return FALSE;
- while (waiter != NULL)
- {
- volatile GThreadXpWaiter *next;
+ namew = g_utf8_to_utf16 (name, -1, NULL, NULL, NULL);
+ if (!namew)
+ return FALSE;
- next = waiter->next;
- SetEvent (waiter->event);
- waiter->my_owner = NULL;
- waiter = next;
- }
+ hr = SetThreadDescriptionFunc (GetCurrentThread (), namew);
- LeaveCriticalSection (&g_thread_xp_lock);
+ g_free (namew);
+ return SUCCEEDED (hr);
}
-/* {{{2 XP Setup */
-static void
-g_thread_xp_init (void)
+void
+g_system_thread_set_name (const gchar *name)
{
- static const GThreadImplVtable g_thread_xp_impl_vtable = {
- g_thread_xp_CallThisOnThreadExit,
- g_thread_xp_InitializeSRWLock,
- g_thread_xp_DeleteSRWLock,
- g_thread_xp_AcquireSRWLockExclusive,
- g_thread_xp_TryAcquireSRWLockExclusive,
- g_thread_xp_ReleaseSRWLockExclusive,
- g_thread_xp_AcquireSRWLockShared,
- g_thread_xp_TryAcquireSRWLockShared,
- g_thread_xp_ReleaseSRWLockShared,
- g_thread_xp_InitializeConditionVariable,
- g_thread_xp_DeleteConditionVariable,
- g_thread_xp_SleepConditionVariableSRW,
- g_thread_xp_WakeAllConditionVariable,
- g_thread_xp_WakeConditionVariable
- };
-
- InitializeCriticalSection (&g_thread_xp_lock);
- g_thread_xp_waiter_tls = TlsAlloc ();
-
- g_thread_impl_vtable = g_thread_xp_impl_vtable;
+ /* Prefer SetThreadDescription over exception based way if available,
+ * since thread description set by SetThreadDescription will be preserved
+ * in dump file */
+ if (!g_thread_win32_set_thread_desc (name))
+ SetThreadName ((DWORD) -1, name);
}
/* {{{1 Epilogue */
-static gboolean
-g_thread_lookup_native_funcs (void)
-{
- GThreadImplVtable native_vtable = { 0, };
- HMODULE kernel32;
-
- kernel32 = GetModuleHandle ("KERNEL32.DLL");
-
- if (kernel32 == NULL)
- return FALSE;
-
-#define GET_FUNC(name) if ((native_vtable.name = (void *) GetProcAddress (kernel32, #name)) == NULL) return FALSE
- GET_FUNC(InitializeSRWLock);
- GET_FUNC(AcquireSRWLockExclusive);
- GET_FUNC(TryAcquireSRWLockExclusive);
- GET_FUNC(ReleaseSRWLockExclusive);
- GET_FUNC(AcquireSRWLockShared);
- GET_FUNC(TryAcquireSRWLockShared);
- GET_FUNC(ReleaseSRWLockShared);
-
- GET_FUNC(InitializeConditionVariable);
- GET_FUNC(SleepConditionVariableSRW);
- GET_FUNC(WakeAllConditionVariable);
- GET_FUNC(WakeConditionVariable);
-#undef GET_FUNC
-
- g_thread_impl_vtable = native_vtable;
-
- return TRUE;
-}
-
-G_GNUC_INTERNAL void
+void
g_thread_win32_init (void)
{
- if (!g_thread_lookup_native_funcs ())
- g_thread_xp_init ();
-
InitializeCriticalSection (&g_private_lock);
+
+#ifndef _MSC_VER
+ SetThreadName_VEH_handle = AddVectoredExceptionHandler (1, &SetThreadName_VEH);
+ if (SetThreadName_VEH_handle == NULL)
+ {
+ /* This is bad, but what can we do? */
+ }
+#endif
}
-G_GNUC_INTERNAL void
+void
g_thread_win32_thread_detach (void)
{
gboolean dtors_called;
*/
dtors_called = FALSE;
- for (dtor = g_private_destructors; dtor; dtor = dtor->next)
+ for (dtor = g_atomic_pointer_get (&g_private_destructors); dtor; dtor = dtor->next)
{
gpointer value;
}
}
while (dtors_called);
+}
- if (g_thread_impl_vtable.CallThisOnThreadExit)
- g_thread_impl_vtable.CallThisOnThreadExit ();
+void
+g_thread_win32_process_detach (void)
+{
+#ifndef _MSC_VER
+ if (SetThreadName_VEH_handle != NULL)
+ {
+ RemoveVectoredExceptionHandler (SetThreadName_VEH_handle);
+ SetThreadName_VEH_handle = NULL;
+ }
+#endif
}
/* vim:set foldmethod=marker: */