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 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, write to the
20 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
25 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
26 * file for a list of people on the GLib Team. See the ChangeLog
27 * files for a list of changes. These files are distributed with
28 * GLib at ftp://ftp.gtk.org/pub/gtk/.
31 /* The GMutex and GCond implementations in this file are some of the
32 * lowest-level code in GLib. All other parts of GLib (messages,
33 * memory, slices, etc) assume that they can freely use these facilities
34 * without risking recursion.
36 * As such, these functions are NOT permitted to call any other part of
39 * The thread manipulation functions (create, exit, join, etc.) have
40 * more freedom -- they can do as they please.
46 #include "glib-init.h"
48 #include "gthreadprivate.h"
58 g_thread_abort (gint status,
59 const gchar *function)
61 fprintf (stderr, "GLib (gthread-win32.c): Unexpected error from C library during '%s': %s. Aborting.\n",
62 strerror (status), function);
66 /* Starting with Vista and Windows 2008, we have access to the
67 * CONDITION_VARIABLE and SRWLock primatives on Windows, which are
68 * pretty reasonable approximations of the primatives specified in
69 * POSIX 2001 (pthread_cond_t and pthread_mutex_t respectively).
71 * Both of these types are structs containing a single pointer. That
72 * pointer is used as an atomic bitfield to support user-space mutexes
73 * that only get the kernel involved in cases of contention (similar
74 * to how futex()-based mutexes work on Linux). The biggest advantage
75 * of these new types is that they can be statically initialised to
76 * zero. That means that they are completely ABI compatible with our
77 * GMutex and GCond APIs.
79 * Unfortunately, Windows XP lacks these facilities and GLib still
80 * needs to support Windows XP. Our approach here is as follows:
82 * - avoid depending on structure declarations at compile-time by
83 * declaring our own GMutex and GCond strutures to be
84 * ABI-compatible with SRWLock and CONDITION_VARIABLE and using
87 * - avoid a hard dependency on the symbols used to manipulate these
88 * structures by doing a dynamic lookup of those symbols at
91 * - if the symbols are not available, emulate them using other
94 * Using this approach also allows us to easily build a GLib that lacks
95 * support for Windows XP or to remove this code entirely when XP is no
96 * longer supported (end of line is currently April 8, 2014).
100 void (__stdcall * CallThisOnThreadExit) (void); /* fake */
102 void (__stdcall * InitializeSRWLock) (gpointer lock);
103 void (__stdcall * DeleteSRWLock) (gpointer lock); /* fake */
104 void (__stdcall * AcquireSRWLockExclusive) (gpointer lock);
105 BOOLEAN (__stdcall * TryAcquireSRWLockExclusive) (gpointer lock);
106 void (__stdcall * ReleaseSRWLockExclusive) (gpointer lock);
107 void (__stdcall * AcquireSRWLockShared) (gpointer lock);
108 BOOLEAN (__stdcall * TryAcquireSRWLockShared) (gpointer lock);
109 void (__stdcall * ReleaseSRWLockShared) (gpointer lock);
111 void (__stdcall * InitializeConditionVariable) (gpointer cond);
112 void (__stdcall * DeleteConditionVariable) (gpointer cond); /* fake */
113 BOOL (__stdcall * SleepConditionVariableSRW) (gpointer cond,
117 void (__stdcall * WakeAllConditionVariable) (gpointer cond);
118 void (__stdcall * WakeConditionVariable) (gpointer cond);
121 static GThreadImplVtable g_thread_impl_vtable;
125 g_mutex_init (GMutex *mutex)
127 g_thread_impl_vtable.InitializeSRWLock (mutex);
131 g_mutex_clear (GMutex *mutex)
133 if (g_thread_impl_vtable.DeleteSRWLock != NULL)
134 g_thread_impl_vtable.DeleteSRWLock (mutex);
138 g_mutex_lock (GMutex *mutex)
140 g_thread_impl_vtable.AcquireSRWLockExclusive (mutex);
144 g_mutex_trylock (GMutex *mutex)
146 return g_thread_impl_vtable.TryAcquireSRWLockExclusive (mutex);
150 g_mutex_unlock (GMutex *mutex)
152 g_thread_impl_vtable.ReleaseSRWLockExclusive (mutex);
157 static CRITICAL_SECTION *
158 g_rec_mutex_impl_new (void)
160 CRITICAL_SECTION *cs;
162 cs = g_slice_new (CRITICAL_SECTION);
163 InitializeCriticalSection (cs);
169 g_rec_mutex_impl_free (CRITICAL_SECTION *cs)
171 DeleteCriticalSection (cs);
172 g_slice_free (CRITICAL_SECTION, cs);
175 static CRITICAL_SECTION *
176 g_rec_mutex_get_impl (GRecMutex *mutex)
178 CRITICAL_SECTION *impl = mutex->p;
180 if G_UNLIKELY (mutex->p == NULL)
182 impl = g_rec_mutex_impl_new ();
183 if (InterlockedCompareExchangePointer (&mutex->p, impl, NULL) != NULL)
184 g_rec_mutex_impl_free (impl);
192 g_rec_mutex_init (GRecMutex *mutex)
194 mutex->p = g_rec_mutex_impl_new ();
198 g_rec_mutex_clear (GRecMutex *mutex)
200 g_rec_mutex_impl_free (mutex->p);
204 g_rec_mutex_lock (GRecMutex *mutex)
206 EnterCriticalSection (g_rec_mutex_get_impl (mutex));
210 g_rec_mutex_unlock (GRecMutex *mutex)
212 LeaveCriticalSection (mutex->p);
216 g_rec_mutex_trylock (GRecMutex *mutex)
218 return TryEnterCriticalSection (g_rec_mutex_get_impl (mutex));
224 g_rw_lock_init (GRWLock *lock)
226 g_thread_impl_vtable.InitializeSRWLock (lock);
230 g_rw_lock_clear (GRWLock *lock)
232 if (g_thread_impl_vtable.DeleteSRWLock != NULL)
233 g_thread_impl_vtable.DeleteSRWLock (lock);
237 g_rw_lock_writer_lock (GRWLock *lock)
239 g_thread_impl_vtable.AcquireSRWLockExclusive (lock);
243 g_rw_lock_writer_trylock (GRWLock *lock)
245 return g_thread_impl_vtable.TryAcquireSRWLockExclusive (lock);
249 g_rw_lock_writer_unlock (GRWLock *lock)
251 g_thread_impl_vtable.ReleaseSRWLockExclusive (lock);
255 g_rw_lock_reader_lock (GRWLock *lock)
257 g_thread_impl_vtable.AcquireSRWLockShared (lock);
261 g_rw_lock_reader_trylock (GRWLock *lock)
263 return g_thread_impl_vtable.TryAcquireSRWLockShared (lock);
267 g_rw_lock_reader_unlock (GRWLock *lock)
269 g_thread_impl_vtable.ReleaseSRWLockShared (lock);
274 g_cond_init (GCond *cond)
276 g_thread_impl_vtable.InitializeConditionVariable (cond);
280 g_cond_clear (GCond *cond)
282 if (g_thread_impl_vtable.DeleteConditionVariable)
283 g_thread_impl_vtable.DeleteConditionVariable (cond);
287 g_cond_signal (GCond *cond)
289 g_thread_impl_vtable.WakeConditionVariable (cond);
293 g_cond_broadcast (GCond *cond)
295 g_thread_impl_vtable.WakeAllConditionVariable (cond);
299 g_cond_wait (GCond *cond,
300 GMutex *entered_mutex)
302 g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, INFINITE, 0);
306 g_cond_wait_until (GCond *cond,
307 GMutex *entered_mutex,
312 span = end_time - g_get_monotonic_time ();
314 if G_UNLIKELY (span < 0)
317 if G_UNLIKELY (span > G_GINT64_CONSTANT (1000) * G_MAXINT32)
320 return g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, span / 1000, 0);
325 typedef struct _GPrivateDestructor GPrivateDestructor;
327 struct _GPrivateDestructor
330 GDestroyNotify notify;
331 GPrivateDestructor *next;
334 static GPrivateDestructor * volatile g_private_destructors;
335 static CRITICAL_SECTION g_private_lock;
338 g_private_get_impl (GPrivate *key)
340 DWORD impl = (DWORD) key->p;
342 if G_UNLIKELY (impl == 0)
344 EnterCriticalSection (&g_private_lock);
345 impl = (DWORD) key->p;
348 GPrivateDestructor *destructor;
352 if (impl == TLS_OUT_OF_INDEXES)
353 g_thread_abort (0, "TlsAlloc");
355 if (key->notify != NULL)
357 destructor = malloc (sizeof (GPrivateDestructor));
358 if G_UNLIKELY (destructor == NULL)
359 g_thread_abort (errno, "malloc");
360 destructor->index = impl;
361 destructor->notify = key->notify;
362 destructor->next = g_private_destructors;
364 /* We need to do an atomic store due to the unlocked
365 * access to the destructor list from the thread exit
368 * It can double as a sanity check...
370 if (InterlockedCompareExchangePointer (&g_private_destructors, destructor,
371 destructor->next) != destructor->next)
372 g_thread_abort (0, "g_private_get_impl(1)");
375 /* Ditto, due to the unlocked access on the fast path */
376 if (InterlockedCompareExchangePointer (&key->p, impl, NULL) != NULL)
377 g_thread_abort (0, "g_private_get_impl(2)");
379 LeaveCriticalSection (&g_private_lock);
386 g_private_get (GPrivate *key)
388 return TlsGetValue (g_private_get_impl (key));
392 g_private_set (GPrivate *key,
395 TlsSetValue (g_private_get_impl (key), value);
399 g_private_replace (GPrivate *key,
402 DWORD impl = g_private_get_impl (key);
405 old = TlsGetValue (impl);
406 if (old && key->notify)
408 TlsSetValue (impl, value);
413 #define win32_check_for_error(what) G_STMT_START{ \
415 g_error ("file %s: line %d (%s): error %s during %s", \
416 __FILE__, __LINE__, G_STRFUNC, \
417 g_win32_error_message (GetLastError ()), #what); \
420 #define G_MUTEX_SIZE (sizeof (gpointer))
422 typedef BOOL (__stdcall *GTryEnterCriticalSectionFunc) (CRITICAL_SECTION *);
433 g_system_thread_free (GRealThread *thread)
435 GThreadWin32 *wt = (GThreadWin32 *) thread;
437 win32_check_for_error (CloseHandle (wt->handle));
438 g_slice_free (GThreadWin32, wt);
442 g_system_thread_exit (void)
447 static guint __stdcall
448 g_thread_win32_proxy (gpointer data)
450 GThreadWin32 *self = data;
454 g_system_thread_exit ();
456 g_assert_not_reached ();
462 g_system_thread_new (GThreadFunc func,
466 GThreadWin32 *thread;
469 thread = g_slice_new0 (GThreadWin32);
470 thread->proxy = func;
472 thread->handle = (HANDLE) _beginthreadex (NULL, stack_size, g_thread_win32_proxy, thread, 0, &ignore);
474 if (thread->handle == NULL)
476 gchar *win_error = g_win32_error_message (GetLastError ());
477 g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN,
478 "Error creating thread: %s", win_error);
480 g_slice_free (GThreadWin32, thread);
484 return (GRealThread *) thread;
488 g_thread_yield (void)
494 g_system_thread_wait (GRealThread *thread)
496 GThreadWin32 *wt = (GThreadWin32 *) thread;
498 win32_check_for_error (WAIT_FAILED != WaitForSingleObject (wt->handle, INFINITE));
502 g_system_thread_set_name (const gchar *name)
504 /* FIXME: implement */
507 /* {{{1 SRWLock and CONDITION_VARIABLE emulation (for Windows XP) */
509 static CRITICAL_SECTION g_thread_xp_lock;
510 static DWORD g_thread_xp_waiter_tls;
512 /* {{{2 GThreadWaiter utility class for CONDITION_VARIABLE emulation */
513 typedef struct _GThreadXpWaiter GThreadXpWaiter;
514 struct _GThreadXpWaiter
517 volatile GThreadXpWaiter *next;
518 volatile GThreadXpWaiter **my_owner;
521 static GThreadXpWaiter *
522 g_thread_xp_waiter_get (void)
524 GThreadXpWaiter *waiter;
526 waiter = TlsGetValue (g_thread_xp_waiter_tls);
528 if G_UNLIKELY (waiter == NULL)
530 waiter = malloc (sizeof (GThreadXpWaiter));
532 g_thread_abort (GetLastError (), "malloc");
533 waiter->event = CreateEvent (0, FALSE, FALSE, NULL);
534 if (waiter->event == NULL)
535 g_thread_abort (GetLastError (), "CreateEvent");
536 waiter->my_owner = NULL;
538 TlsSetValue (g_thread_xp_waiter_tls, waiter);
544 static void __stdcall
545 g_thread_xp_CallThisOnThreadExit (void)
547 GThreadXpWaiter *waiter;
549 waiter = TlsGetValue (g_thread_xp_waiter_tls);
553 TlsSetValue (g_thread_xp_waiter_tls, NULL);
554 CloseHandle (waiter->event);
559 /* {{{2 SRWLock emulation */
562 CRITICAL_SECTION writer_lock;
563 gboolean ever_shared; /* protected by writer_lock */
564 gboolean writer_locked; /* protected by writer_lock */
566 /* below is only ever touched if ever_shared becomes true */
567 CRITICAL_SECTION atomicity;
568 GThreadXpWaiter *queued_writer; /* protected by atomicity lock */
569 gint num_readers; /* protected by atomicity lock */
572 static void __stdcall
573 g_thread_xp_InitializeSRWLock (gpointer mutex)
575 *(GThreadSRWLock * volatile *) mutex = NULL;
578 static void __stdcall
579 g_thread_xp_DeleteSRWLock (gpointer mutex)
581 GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
585 if (lock->ever_shared)
586 DeleteCriticalSection (&lock->atomicity);
588 DeleteCriticalSection (&lock->writer_lock);
593 static GThreadSRWLock * __stdcall
594 g_thread_xp_get_srwlock (GThreadSRWLock * volatile *lock)
596 GThreadSRWLock *result;
598 /* It looks like we're missing some barriers here, but this code only
599 * ever runs on Windows XP, which in turn only ever runs on hardware
600 * with a relatively rigid memory model. The 'volatile' will take
601 * care of the compiler.
605 if G_UNLIKELY (result == NULL)
607 EnterCriticalSection (&g_thread_xp_lock);
613 result = malloc (sizeof (GThreadSRWLock));
616 g_thread_abort (errno, "malloc");
618 InitializeCriticalSection (&result->writer_lock);
619 result->writer_locked = FALSE;
620 result->ever_shared = FALSE;
624 LeaveCriticalSection (&g_thread_xp_lock);
630 static void __stdcall
631 g_thread_xp_AcquireSRWLockExclusive (gpointer mutex)
633 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
635 EnterCriticalSection (&lock->writer_lock);
637 /* CRITICAL_SECTION is reentrant, but SRWLock is not.
638 * Detect the deadlock that would occur on later Windows version.
640 g_assert (!lock->writer_locked);
641 lock->writer_locked = TRUE;
643 if (lock->ever_shared)
645 GThreadXpWaiter *waiter = NULL;
647 EnterCriticalSection (&lock->atomicity);
648 if (lock->num_readers > 0)
649 lock->queued_writer = waiter = g_thread_xp_waiter_get ();
650 LeaveCriticalSection (&lock->atomicity);
653 WaitForSingleObject (waiter->event, INFINITE);
655 lock->queued_writer = NULL;
659 static BOOLEAN __stdcall
660 g_thread_xp_TryAcquireSRWLockExclusive (gpointer mutex)
662 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
664 if (!TryEnterCriticalSection (&lock->writer_lock))
667 /* CRITICAL_SECTION is reentrant, but SRWLock is not.
668 * Ensure that this properly returns FALSE (as SRWLock would).
670 if G_UNLIKELY (lock->writer_locked)
672 LeaveCriticalSection (&lock->writer_lock);
676 lock->writer_locked = TRUE;
678 if (lock->ever_shared)
682 EnterCriticalSection (&lock->atomicity);
683 available = lock->num_readers == 0;
684 LeaveCriticalSection (&lock->atomicity);
688 LeaveCriticalSection (&lock->writer_lock);
696 static void __stdcall
697 g_thread_xp_ReleaseSRWLockExclusive (gpointer mutex)
699 GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
701 lock->writer_locked = FALSE;
703 /* We need this until we fix some weird parts of GLib that try to
704 * unlock freshly-allocated mutexes.
707 LeaveCriticalSection (&lock->writer_lock);
711 g_thread_xp_srwlock_become_reader (GThreadSRWLock *lock)
713 if G_UNLIKELY (!lock->ever_shared)
715 InitializeCriticalSection (&lock->atomicity);
716 lock->queued_writer = NULL;
717 lock->num_readers = 0;
719 lock->ever_shared = TRUE;
722 EnterCriticalSection (&lock->atomicity);
724 LeaveCriticalSection (&lock->atomicity);
727 static void __stdcall
728 g_thread_xp_AcquireSRWLockShared (gpointer mutex)
730 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
732 EnterCriticalSection (&lock->writer_lock);
734 /* See g_thread_xp_AcquireSRWLockExclusive */
735 g_assert (!lock->writer_locked);
737 g_thread_xp_srwlock_become_reader (lock);
739 LeaveCriticalSection (&lock->writer_lock);
742 static BOOLEAN __stdcall
743 g_thread_xp_TryAcquireSRWLockShared (gpointer mutex)
745 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
747 if (!TryEnterCriticalSection (&lock->writer_lock))
750 /* See g_thread_xp_AcquireSRWLockExclusive */
751 if G_UNLIKELY (lock->writer_locked)
753 LeaveCriticalSection (&lock->writer_lock);
757 g_thread_xp_srwlock_become_reader (lock);
759 LeaveCriticalSection (&lock->writer_lock);
764 static void __stdcall
765 g_thread_xp_ReleaseSRWLockShared (gpointer mutex)
767 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
769 EnterCriticalSection (&lock->atomicity);
773 if (lock->num_readers == 0 && lock->queued_writer)
774 SetEvent (lock->queued_writer->event);
776 LeaveCriticalSection (&lock->atomicity);
779 /* {{{2 CONDITION_VARIABLE emulation */
782 volatile GThreadXpWaiter *first;
783 volatile GThreadXpWaiter **last_ptr;
784 } GThreadXpCONDITION_VARIABLE;
786 static void __stdcall
787 g_thread_xp_InitializeConditionVariable (gpointer cond)
789 *(GThreadXpCONDITION_VARIABLE * volatile *) cond = NULL;
792 static void __stdcall
793 g_thread_xp_DeleteConditionVariable (gpointer cond)
795 GThreadXpCONDITION_VARIABLE *cv = *(GThreadXpCONDITION_VARIABLE * volatile *) cond;
801 static GThreadXpCONDITION_VARIABLE * __stdcall
802 g_thread_xp_get_condition_variable (GThreadXpCONDITION_VARIABLE * volatile *cond)
804 GThreadXpCONDITION_VARIABLE *result;
806 /* It looks like we're missing some barriers here, but this code only
807 * ever runs on Windows XP, which in turn only ever runs on hardware
808 * with a relatively rigid memory model. The 'volatile' will take
809 * care of the compiler.
813 if G_UNLIKELY (result == NULL)
815 result = malloc (sizeof (GThreadXpCONDITION_VARIABLE));
818 g_thread_abort (errno, "malloc");
820 result->first = NULL;
821 result->last_ptr = &result->first;
823 if (InterlockedCompareExchangePointer (cond, result, NULL) != NULL)
833 static BOOL __stdcall
834 g_thread_xp_SleepConditionVariableSRW (gpointer cond,
839 GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
840 GThreadXpWaiter *waiter = g_thread_xp_waiter_get ();
845 EnterCriticalSection (&g_thread_xp_lock);
846 waiter->my_owner = cv->last_ptr;
847 *cv->last_ptr = waiter;
848 cv->last_ptr = &waiter->next;
849 LeaveCriticalSection (&g_thread_xp_lock);
851 g_mutex_unlock (mutex);
852 status = WaitForSingleObject (waiter->event, timeout);
854 if (status != WAIT_TIMEOUT && status != WAIT_OBJECT_0)
855 g_thread_abort (GetLastError (), "WaitForSingleObject");
856 g_mutex_lock (mutex);
858 if (status == WAIT_TIMEOUT)
860 EnterCriticalSection (&g_thread_xp_lock);
861 if (waiter->my_owner)
864 waiter->next->my_owner = waiter->my_owner;
866 cv->last_ptr = waiter->my_owner;
867 *waiter->my_owner = waiter->next;
868 waiter->my_owner = NULL;
870 LeaveCriticalSection (&g_thread_xp_lock);
873 return status == WAIT_OBJECT_0;
876 static void __stdcall
877 g_thread_xp_WakeConditionVariable (gpointer cond)
879 GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
880 volatile GThreadXpWaiter *waiter;
882 EnterCriticalSection (&g_thread_xp_lock);
887 waiter->my_owner = NULL;
888 cv->first = waiter->next;
889 if (cv->first != NULL)
890 cv->first->my_owner = &cv->first;
892 cv->last_ptr = &cv->first;
896 SetEvent (waiter->event);
898 LeaveCriticalSection (&g_thread_xp_lock);
901 static void __stdcall
902 g_thread_xp_WakeAllConditionVariable (gpointer cond)
904 GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
905 volatile GThreadXpWaiter *waiter;
907 EnterCriticalSection (&g_thread_xp_lock);
911 cv->last_ptr = &cv->first;
913 while (waiter != NULL)
915 volatile GThreadXpWaiter *next;
918 SetEvent (waiter->event);
919 waiter->my_owner = NULL;
923 LeaveCriticalSection (&g_thread_xp_lock);
928 g_thread_xp_init (void)
930 static const GThreadImplVtable g_thread_xp_impl_vtable = {
931 g_thread_xp_CallThisOnThreadExit,
932 g_thread_xp_InitializeSRWLock,
933 g_thread_xp_DeleteSRWLock,
934 g_thread_xp_AcquireSRWLockExclusive,
935 g_thread_xp_TryAcquireSRWLockExclusive,
936 g_thread_xp_ReleaseSRWLockExclusive,
937 g_thread_xp_AcquireSRWLockShared,
938 g_thread_xp_TryAcquireSRWLockShared,
939 g_thread_xp_ReleaseSRWLockShared,
940 g_thread_xp_InitializeConditionVariable,
941 g_thread_xp_DeleteConditionVariable,
942 g_thread_xp_SleepConditionVariableSRW,
943 g_thread_xp_WakeAllConditionVariable,
944 g_thread_xp_WakeConditionVariable
947 InitializeCriticalSection (&g_thread_xp_lock);
948 g_thread_xp_waiter_tls = TlsAlloc ();
950 g_thread_impl_vtable = g_thread_xp_impl_vtable;
956 g_thread_lookup_native_funcs (void)
958 GThreadImplVtable native_vtable = { 0, };
961 kernel32 = GetModuleHandle ("KERNEL32.DLL");
963 if (kernel32 == NULL)
966 #define GET_FUNC(name) if ((native_vtable.name = (void *) GetProcAddress (kernel32, #name)) == NULL) return FALSE
967 GET_FUNC(InitializeSRWLock);
968 GET_FUNC(AcquireSRWLockExclusive);
969 GET_FUNC(TryAcquireSRWLockExclusive);
970 GET_FUNC(ReleaseSRWLockExclusive);
971 GET_FUNC(AcquireSRWLockShared);
972 GET_FUNC(TryAcquireSRWLockShared);
973 GET_FUNC(ReleaseSRWLockShared);
975 GET_FUNC(InitializeConditionVariable);
976 GET_FUNC(SleepConditionVariableSRW);
977 GET_FUNC(WakeAllConditionVariable);
978 GET_FUNC(WakeConditionVariable);
981 g_thread_impl_vtable = native_vtable;
987 g_thread_win32_init (void)
989 if (!g_thread_lookup_native_funcs ())
992 InitializeCriticalSection (&g_private_lock);
996 g_thread_win32_thread_detach (void)
998 gboolean dtors_called;
1002 GPrivateDestructor *dtor;
1004 /* We go by the POSIX book on this one.
1006 * If we call a destructor then there is a chance that some new
1007 * TLS variables got set by code called in that destructor.
1009 * Loop until nothing is left.
1011 dtors_called = FALSE;
1013 for (dtor = g_private_destructors; dtor; dtor = dtor->next)
1017 value = TlsGetValue (dtor->index);
1018 if (value != NULL && dtor->notify != NULL)
1020 /* POSIX says to clear this before the call */
1021 TlsSetValue (dtor->index, NULL);
1022 dtor->notify (value);
1023 dtors_called = TRUE;
1027 while (dtors_called);
1029 if (g_thread_impl_vtable.CallThisOnThreadExit)
1030 g_thread_impl_vtable.CallThisOnThreadExit ();
1033 /* vim:set foldmethod=marker: */