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 "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 primatives on Windows, which are
66 * pretty reasonable approximations of the primatives 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. This allows us to use them directly and still support:
76 * GMutex mutex = G_MUTEX_INIT;
80 * GCond cond = G_COND_INIT;
82 * Unfortunately, Windows XP lacks these facilities and GLib still
83 * needs to support Windows XP. Our approach here is as follows:
85 * - avoid depending on structure declarations at compile-time by
86 * declaring our own GMutex and GCond strutures to be
87 * ABI-compatible with SRWLock and CONDITION_VARIABLE and using
90 * - avoid a hard dependency on the symbols used to manipulate these
91 * structures by doing a dynamic lookup of those symbols at
94 * - if the symbols are not available, emulate them using other
97 * Using this approach also allows us to easily build a GLib that lacks
98 * support for Windows XP or to remove this code entirely when XP is no
99 * longer supported (end of line is currently April 8, 2014).
103 void (__stdcall * CallThisOnThreadExit) (void); /* fake */
105 void (__stdcall * InitializeSRWLock) (gpointer lock);
106 void (__stdcall * DeleteSRWLock) (gpointer lock); /* fake */
107 void (__stdcall * AcquireSRWLockExclusive) (gpointer lock);
108 BOOLEAN (__stdcall * TryAcquireSRWLockExclusive) (gpointer lock);
109 void (__stdcall * ReleaseSRWLockExclusive) (gpointer lock);
110 void (__stdcall * AcquireSRWLockShared) (gpointer lock);
111 BOOLEAN (__stdcall * TryAcquireSRWLockShared) (gpointer lock);
112 void (__stdcall * ReleaseSRWLockShared) (gpointer lock);
114 void (__stdcall * InitializeConditionVariable) (gpointer cond);
115 void (__stdcall * DeleteConditionVariable) (gpointer cond); /* fake */
116 BOOL (__stdcall * SleepConditionVariableSRW) (gpointer cond,
120 void (__stdcall * WakeAllConditionVariable) (gpointer cond);
121 void (__stdcall * WakeConditionVariable) (gpointer cond);
124 static GThreadImplVtable g_thread_impl_vtable;
128 g_mutex_init (GMutex *mutex)
130 g_thread_impl_vtable.InitializeSRWLock (mutex);
134 g_mutex_clear (GMutex *mutex)
136 if (g_thread_impl_vtable.DeleteSRWLock != NULL)
137 g_thread_impl_vtable.DeleteSRWLock (mutex);
141 g_mutex_lock (GMutex *mutex)
143 g_thread_impl_vtable.AcquireSRWLockExclusive (mutex);
147 g_mutex_trylock (GMutex *mutex)
149 return g_thread_impl_vtable.TryAcquireSRWLockExclusive (mutex);
153 g_mutex_unlock (GMutex *mutex)
155 g_thread_impl_vtable.ReleaseSRWLockExclusive (mutex);
160 static CRITICAL_SECTION *
161 g_rec_mutex_impl_new (void)
163 CRITICAL_SECTION *cs;
165 cs = g_slice_new (CRITICAL_SECTION);
166 InitializeCriticalSection (cs);
172 g_rec_mutex_impl_free (CRITICAL_SECTION *cs)
174 DeleteCriticalSection (cs);
175 g_slice_free (CRITICAL_SECTION, cs);
178 static CRITICAL_SECTION *
179 g_rec_mutex_get_impl (GRecMutex *mutex)
181 CRITICAL_SECTION *impl = mutex->impl;
183 if G_UNLIKELY (mutex->impl == NULL)
185 impl = g_rec_mutex_impl_new ();
186 if (InterlockedCompareExchangePointer (&mutex->impl, impl, NULL) != NULL)
187 g_rec_mutex_impl_free (impl);
195 g_rec_mutex_init (GRecMutex *mutex)
197 mutex->impl = g_rec_mutex_impl_new ();
201 g_rec_mutex_clear (GRecMutex *mutex)
204 g_rec_mutex_impl_free (mutex->impl);
208 g_rec_mutex_lock (GRecMutex *mutex)
210 EnterCriticalSection (g_rec_mutex_get_impl (mutex));
214 g_rec_mutex_unlock (GRecMutex *mutex)
216 LeaveCriticalSection (mutex->impl);
220 g_rec_mutex_trylock (GRecMutex *mutex)
222 return TryEnterCriticalSection (g_rec_mutex_get_impl (mutex));
228 g_rw_lock_init (GRWLock *lock)
230 g_thread_impl_vtable.InitializeSRWLock (lock);
234 g_rw_lock_clear (GRWLock *lock)
236 if (g_thread_impl_vtable.DeleteSRWLock != NULL)
237 g_thread_impl_vtable.DeleteSRWLock (lock);
241 g_rw_lock_writer_lock (GRWLock *lock)
243 g_thread_impl_vtable.AcquireSRWLockExclusive (lock);
247 g_rw_lock_writer_trylock (GRWLock *lock)
249 return g_thread_impl_vtable.TryAcquireSRWLockExclusive (lock);
253 g_rw_lock_writer_unlock (GRWLock *lock)
255 g_thread_impl_vtable.ReleaseSRWLockExclusive (lock);
259 g_rw_lock_reader_lock (GRWLock *lock)
261 g_thread_impl_vtable.AcquireSRWLockShared (lock);
265 g_rw_lock_reader_trylock (GRWLock *lock)
267 return g_thread_impl_vtable.TryAcquireSRWLockShared (lock);
271 g_rw_lock_reader_unlock (GRWLock *lock)
273 g_thread_impl_vtable.ReleaseSRWLockShared (lock);
278 g_cond_init (GCond *cond)
280 g_thread_impl_vtable.InitializeConditionVariable (cond);
284 g_cond_clear (GCond *cond)
286 if (g_thread_impl_vtable.DeleteConditionVariable)
287 g_thread_impl_vtable.DeleteConditionVariable (cond);
291 g_cond_signal (GCond *cond)
293 g_thread_impl_vtable.WakeConditionVariable (cond);
297 g_cond_broadcast (GCond *cond)
299 g_thread_impl_vtable.WakeAllConditionVariable (cond);
303 g_cond_wait (GCond *cond,
304 GMutex *entered_mutex)
306 g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, INFINITE, 0);
310 g_cond_timedwait (GCond *cond,
311 GMutex *entered_mutex,
318 GetSystemTimeAsFileTime (&ft);
319 memmove (&now, &ft, sizeof (FILETIME));
321 now -= G_GINT64_CONSTANT (116444736000000000);
324 span = abs_time - now;
326 if G_UNLIKELY (span < 0)
329 if G_UNLIKELY (span > G_GINT64_CONSTANT (1000) * G_MAXINT32)
332 return g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, span / 1000, 0);
336 g_cond_timed_wait (GCond *cond,
337 GMutex *entered_mutex,
344 micros = abs_time->tv_sec;
346 micros += abs_time->tv_usec;
348 return g_cond_timedwait (cond, entered_mutex, micros);
352 g_cond_wait (cond, entered_mutex);
359 typedef struct _GPrivateDestructor GPrivateDestructor;
361 struct _GPrivateDestructor
364 GDestroyNotify notify;
365 GPrivateDestructor *next;
368 static GPrivateDestructor * volatile g_private_destructors;
371 g_private_init (GPrivate *key,
372 GDestroyNotify notify)
374 GPrivateDestructor *destructor;
376 key->index = TlsAlloc ();
378 destructor = malloc (sizeof (GPrivateDestructor));
379 if G_UNLIKELY (destructor == NULL)
380 g_thread_abort (errno, "malloc");
381 destructor->index = key->index;
382 destructor->notify = notify;
385 destructor->next = g_private_destructors;
386 while (InterlockedCompareExchangePointer (&g_private_destructors, destructor->next, destructor) != destructor->next);
392 g_private_get (GPrivate *key)
395 return key->single_value;
397 return TlsGetValue (key->index);
401 g_private_set (GPrivate *key,
406 key->single_value = value;
410 TlsSetValue (key->index, value);
416 #include "gthreadprivate.h"
418 #define win32_check_for_error(what) G_STMT_START{ \
420 g_error ("file %s: line %d (%s): error %s during %s", \
421 __FILE__, __LINE__, G_STRFUNC, \
422 g_win32_error_message (GetLastError ()), #what); \
425 #define G_MUTEX_SIZE (sizeof (gpointer))
427 static DWORD g_thread_self_tls;
428 static DWORD g_private_tls;
430 typedef BOOL (__stdcall *GTryEnterCriticalSectionFunc) (CRITICAL_SECTION *);
432 typedef struct _GThreadData GThreadData;
442 g_system_thread_self (gpointer thread)
444 GThreadData *self = TlsGetValue (g_thread_self_tls);
448 /* This should only happen for the main thread! */
449 HANDLE handle = GetCurrentThread ();
450 HANDLE process = GetCurrentProcess ();
451 self = g_new (GThreadData, 1);
452 win32_check_for_error (DuplicateHandle (process, handle, process,
453 &self->thread, 0, FALSE,
454 DUPLICATE_SAME_ACCESS));
455 win32_check_for_error (TlsSetValue (g_thread_self_tls, self));
458 self->joinable = FALSE;
461 *(GThreadData **)thread = self;
465 g_system_thread_exit (void)
467 GThreadData *self = TlsGetValue (g_thread_self_tls);
468 gboolean dtors_called;
472 GPrivateDestructor *dtor;
474 /* We go by the POSIX book on this one.
476 * If we call a destructor then there is a chance that some new
477 * TLS variables got set by code called in that destructor.
479 * Loop until nothing is left.
481 dtors_called = FALSE;
483 for (dtor = g_private_destructors; dtor; dtor = dtor->next)
487 value = TlsGetValue (dtor->index);
488 if (value != NULL && dtor->notify != NULL)
490 /* POSIX says to clear this before the call */
491 TlsSetValue (dtor->index, NULL);
492 dtor->notify (value);
497 while (dtors_called);
503 win32_check_for_error (CloseHandle (self->thread));
506 win32_check_for_error (TlsSetValue (g_thread_self_tls, NULL));
509 if (g_thread_impl_vtable.CallThisOnThreadExit)
510 g_thread_impl_vtable.CallThisOnThreadExit ();
515 static guint __stdcall
516 g_thread_proxy (gpointer data)
518 GThreadData *self = (GThreadData*) data;
520 win32_check_for_error (TlsSetValue (g_thread_self_tls, self));
522 self->func (self->data);
524 g_system_thread_exit ();
526 g_assert_not_reached ();
532 g_system_thread_create (GThreadFunc func,
542 g_return_if_fail (func);
544 retval = g_new(GThreadData, 1);
548 retval->joinable = joinable;
550 retval->thread = (HANDLE) _beginthreadex (NULL, stack_size, g_thread_proxy,
553 if (retval->thread == NULL)
555 gchar *win_error = g_win32_error_message (GetLastError ());
556 g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN,
557 "Error creating thread: %s", win_error);
563 *(GThreadData **)thread = retval;
567 g_thread_yield (void)
573 g_system_thread_join (gpointer thread)
575 GThreadData *target = *(GThreadData **)thread;
577 g_return_if_fail (target->joinable);
579 win32_check_for_error (WAIT_FAILED !=
580 WaitForSingleObject (target->thread, INFINITE));
582 win32_check_for_error (CloseHandle (target->thread));
587 g_system_thread_equal (gpointer thread1,
590 return ((GSystemThread*)thread1)->dummy_pointer == ((GSystemThread*)thread2)->dummy_pointer;
593 /* {{{1 SRWLock and CONDITION_VARIABLE emulation (for Windows XP) */
595 static CRITICAL_SECTION g_thread_xp_lock;
596 static DWORD g_thread_xp_waiter_tls;
598 /* {{{2 GThreadWaiter utility class for CONDITION_VARIABLE emulation */
599 typedef struct _GThreadXpWaiter GThreadXpWaiter;
600 struct _GThreadXpWaiter
603 volatile GThreadXpWaiter *next;
606 static GThreadXpWaiter *
607 g_thread_xp_waiter_get (void)
609 GThreadXpWaiter *waiter;
611 waiter = TlsGetValue (g_thread_xp_waiter_tls);
613 if G_UNLIKELY (waiter == NULL)
615 waiter = malloc (sizeof (GThreadXpWaiter));
617 g_thread_abort (GetLastError (), "malloc");
618 waiter->event = CreateEvent (0, FALSE, FALSE, NULL);
619 if (waiter->event == NULL)
620 g_thread_abort (GetLastError (), "CreateEvent");
622 TlsSetValue (g_thread_xp_waiter_tls, waiter);
628 static void __stdcall
629 g_thread_xp_CallThisOnThreadExit (void)
631 GThreadXpWaiter *waiter;
633 waiter = TlsGetValue (g_thread_xp_waiter_tls);
637 TlsSetValue (g_thread_xp_waiter_tls, NULL);
638 CloseHandle (waiter->event);
643 /* {{{2 SRWLock emulation */
646 CRITICAL_SECTION writer_lock;
647 gboolean ever_shared; /* protected by writer_lock */
648 gboolean writer_locked; /* protected by writer_lock */
650 /* below is only ever touched if ever_shared becomes true */
651 CRITICAL_SECTION atomicity;
652 GThreadXpWaiter *queued_writer; /* protected by atomicity lock */
653 gint num_readers; /* protected by atomicity lock */
656 static void __stdcall
657 g_thread_xp_InitializeSRWLock (gpointer mutex)
659 *(GThreadSRWLock * volatile *) mutex = NULL;
662 static void __stdcall
663 g_thread_xp_DeleteSRWLock (gpointer mutex)
665 GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
669 if (lock->ever_shared)
670 DeleteCriticalSection (&lock->atomicity);
672 DeleteCriticalSection (&lock->writer_lock);
677 static GThreadSRWLock * __stdcall
678 g_thread_xp_get_srwlock (GThreadSRWLock * volatile *lock)
680 GThreadSRWLock *result;
682 /* It looks like we're missing some barriers here, but this code only
683 * ever runs on Windows XP, which in turn only ever runs on hardware
684 * with a relatively rigid memory model. The 'volatile' will take
685 * care of the compiler.
689 if G_UNLIKELY (result == NULL)
691 EnterCriticalSection (&g_thread_xp_lock);
693 result = malloc (sizeof (GThreadSRWLock));
696 g_thread_abort (errno, "malloc");
698 InitializeCriticalSection (&result->writer_lock);
699 result->writer_locked = FALSE;
700 result->ever_shared = FALSE;
703 LeaveCriticalSection (&g_thread_xp_lock);
709 static void __stdcall
710 g_thread_xp_AcquireSRWLockExclusive (gpointer mutex)
712 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
714 EnterCriticalSection (&lock->writer_lock);
716 /* CRITICAL_SECTION is reentrant, but SRWLock is not.
717 * Detect the deadlock that would occur on later Windows version.
719 g_assert (!lock->writer_locked);
720 lock->writer_locked = TRUE;
722 if (lock->ever_shared)
724 GThreadXpWaiter *waiter = NULL;
726 EnterCriticalSection (&lock->atomicity);
727 if (lock->num_readers > 0)
728 lock->queued_writer = waiter = g_thread_xp_waiter_get ();
729 LeaveCriticalSection (&lock->atomicity);
732 WaitForSingleObject (waiter->event, INFINITE);
734 lock->queued_writer = NULL;
738 static BOOLEAN __stdcall
739 g_thread_xp_TryAcquireSRWLockExclusive (gpointer mutex)
741 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
743 if (!TryEnterCriticalSection (&lock->writer_lock))
746 /* CRITICAL_SECTION is reentrant, but SRWLock is not.
747 * Ensure that this properly returns FALSE (as SRWLock would).
749 if G_UNLIKELY (lock->writer_locked)
751 LeaveCriticalSection (&lock->writer_lock);
755 lock->writer_locked = TRUE;
757 if (lock->ever_shared)
761 EnterCriticalSection (&lock->atomicity);
762 available = lock->num_readers == 0;
763 LeaveCriticalSection (&lock->atomicity);
767 LeaveCriticalSection (&lock->writer_lock);
775 static void __stdcall
776 g_thread_xp_ReleaseSRWLockExclusive (gpointer mutex)
778 GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
780 lock->writer_locked = FALSE;
782 /* We need this until we fix some weird parts of GLib that try to
783 * unlock freshly-allocated mutexes.
786 LeaveCriticalSection (&lock->writer_lock);
790 g_thread_xp_srwlock_become_reader (GThreadSRWLock *lock)
792 if G_UNLIKELY (!lock->ever_shared)
794 InitializeCriticalSection (&lock->atomicity);
795 lock->queued_writer = NULL;
796 lock->num_readers = 0;
798 lock->ever_shared = TRUE;
801 EnterCriticalSection (&lock->atomicity);
803 LeaveCriticalSection (&lock->atomicity);
806 static void __stdcall
807 g_thread_xp_AcquireSRWLockShared (gpointer mutex)
809 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
811 EnterCriticalSection (&lock->writer_lock);
813 /* See g_thread_xp_AcquireSRWLockExclusive */
814 g_assert (!lock->writer_locked);
816 g_thread_xp_srwlock_become_reader (lock);
818 LeaveCriticalSection (&lock->writer_lock);
821 static BOOLEAN __stdcall
822 g_thread_xp_TryAcquireSRWLockShared (gpointer mutex)
824 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
826 if (!TryEnterCriticalSection (&lock->writer_lock))
829 /* See g_thread_xp_AcquireSRWLockExclusive */
830 if G_UNLIKELY (lock->writer_locked)
832 LeaveCriticalSection (&lock->writer_lock);
836 g_thread_xp_srwlock_become_reader (lock);
838 LeaveCriticalSection (&lock->writer_lock);
843 static void __stdcall
844 g_thread_xp_ReleaseSRWLockShared (gpointer mutex)
846 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
848 EnterCriticalSection (&lock->atomicity);
852 if (lock->num_readers == 0 && lock->queued_writer)
853 SetEvent (lock->queued_writer->event);
855 LeaveCriticalSection (&lock->atomicity);
858 /* {{{2 CONDITION_VARIABLE emulation */
861 volatile GThreadXpWaiter *first;
862 volatile GThreadXpWaiter **last_ptr;
863 } GThreadXpCONDITION_VARIABLE;
865 static void __stdcall
866 g_thread_xp_InitializeConditionVariable (gpointer cond)
868 *(GThreadXpCONDITION_VARIABLE * volatile *) cond = NULL;
871 static void __stdcall
872 g_thread_xp_DeleteConditionVariable (gpointer cond)
874 GThreadXpCONDITION_VARIABLE *cv = *(GThreadXpCONDITION_VARIABLE * volatile *) cond;
880 static GThreadXpCONDITION_VARIABLE * __stdcall
881 g_thread_xp_get_condition_variable (GThreadXpCONDITION_VARIABLE * volatile *cond)
883 GThreadXpCONDITION_VARIABLE *result;
885 /* It looks like we're missing some barriers here, but this code only
886 * ever runs on Windows XP, which in turn only ever runs on hardware
887 * with a relatively rigid memory model. The 'volatile' will take
888 * care of the compiler.
892 if G_UNLIKELY (result == NULL)
894 result = malloc (sizeof (GThreadXpCONDITION_VARIABLE));
897 g_thread_abort (errno, "malloc");
899 result->first = NULL;
900 result->last_ptr = &result->first;
902 if (InterlockedCompareExchangePointer (cond, result, NULL) != NULL)
912 static BOOL __stdcall
913 g_thread_xp_SleepConditionVariableSRW (gpointer cond,
918 GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
919 GThreadXpWaiter *waiter = g_thread_xp_waiter_get ();
924 EnterCriticalSection (&g_thread_xp_lock);
925 *cv->last_ptr = waiter;
926 cv->last_ptr = &waiter->next;
927 LeaveCriticalSection (&g_thread_xp_lock);
929 g_mutex_unlock (mutex);
930 status = WaitForSingleObject (waiter->event, timeout);
932 if (status != WAIT_TIMEOUT && status != WAIT_OBJECT_0)
933 g_thread_abort (GetLastError (), "WaitForSingleObject");
935 g_mutex_lock (mutex);
937 return status == WAIT_OBJECT_0;
940 static void __stdcall
941 g_thread_xp_WakeConditionVariable (gpointer cond)
943 GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
944 volatile GThreadXpWaiter *waiter;
946 EnterCriticalSection (&g_thread_xp_lock);
950 cv->first = waiter->next;
951 if (cv->first == NULL)
952 cv->last_ptr = &cv->first;
954 LeaveCriticalSection (&g_thread_xp_lock);
957 SetEvent (waiter->event);
960 static void __stdcall
961 g_thread_xp_WakeAllConditionVariable (gpointer cond)
963 GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
964 volatile GThreadXpWaiter *waiter;
966 EnterCriticalSection (&g_thread_xp_lock);
969 cv->last_ptr = &cv->first;
970 LeaveCriticalSection (&g_thread_xp_lock);
972 while (waiter != NULL)
974 volatile GThreadXpWaiter *next;
977 SetEvent (waiter->event);
984 g_thread_xp_init (void)
986 static const GThreadImplVtable g_thread_xp_impl_vtable = {
987 g_thread_xp_CallThisOnThreadExit,
988 g_thread_xp_InitializeSRWLock,
989 g_thread_xp_DeleteSRWLock,
990 g_thread_xp_AcquireSRWLockExclusive,
991 g_thread_xp_TryAcquireSRWLockExclusive,
992 g_thread_xp_ReleaseSRWLockExclusive,
993 g_thread_xp_AcquireSRWLockShared,
994 g_thread_xp_TryAcquireSRWLockShared,
995 g_thread_xp_ReleaseSRWLockShared,
996 g_thread_xp_InitializeConditionVariable,
997 g_thread_xp_DeleteConditionVariable,
998 g_thread_xp_SleepConditionVariableSRW,
999 g_thread_xp_WakeAllConditionVariable,
1000 g_thread_xp_WakeConditionVariable
1003 InitializeCriticalSection (&g_thread_xp_lock);
1004 g_thread_xp_waiter_tls = TlsAlloc ();
1006 g_thread_impl_vtable = g_thread_xp_impl_vtable;
1012 g_thread_lookup_native_funcs (void)
1014 GThreadImplVtable native_vtable = { 0, };
1017 kernel32 = GetModuleHandle ("KERNEL32.DLL");
1019 if (kernel32 == NULL)
1022 #define GET_FUNC(name) if ((native_vtable.name = (void *) GetProcAddress (kernel32, #name)) == NULL) return FALSE
1023 GET_FUNC(InitializeSRWLock);
1024 GET_FUNC(AcquireSRWLockExclusive);
1025 GET_FUNC(TryAcquireSRWLockExclusive);
1026 GET_FUNC(ReleaseSRWLockExclusive);
1027 GET_FUNC(AcquireSRWLockShared);
1028 GET_FUNC(TryAcquireSRWLockShared);
1029 GET_FUNC(ReleaseSRWLockShared);
1031 GET_FUNC(InitializeConditionVariable);
1032 GET_FUNC(SleepConditionVariableSRW);
1033 GET_FUNC(WakeAllConditionVariable);
1034 GET_FUNC(WakeConditionVariable);
1037 g_thread_impl_vtable = native_vtable;
1042 G_GNUC_INTERNAL void
1043 g_thread_DllMain (void)
1045 if (g_thread_lookup_native_funcs ())
1046 fprintf (stderr, "(debug) GThread using native mode\n");
1049 fprintf (stderr, "(debug) GThread using Windows XP mode\n");
1050 g_thread_xp_init ();
1053 win32_check_for_error (TLS_OUT_OF_INDEXES != (g_thread_self_tls = TlsAlloc ()));
1054 win32_check_for_error (TLS_OUT_OF_INDEXES != (g_private_tls = TlsAlloc ()));
1057 /* vim:set foldmethod=marker: */