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"
55 g_thread_abort (gint status,
56 const gchar *function)
58 fprintf (stderr, "GLib (gthread-win32.c): Unexpected error from C library during '%s': %s. Aborting.\n",
59 strerror (status), function);
63 /* Starting with Vista and Windows 2008, we have access to the
64 * CONDITION_VARIABLE and SRWLock primatives on Windows, which are
65 * pretty reasonable approximations of the primatives specified in
66 * POSIX 2001 (pthread_cond_t and pthread_mutex_t respectively).
68 * Both of these types are structs containing a single pointer. That
69 * pointer is used as an atomic bitfield to support user-space mutexes
70 * that only get the kernel involved in cases of contention (similar
71 * to how futex()-based mutexes work on Linux). The biggest advantage
72 * of these new types is that they can be statically initialised to
73 * zero. This allows us to use them directly and still support:
75 * GMutex mutex = G_MUTEX_INIT;
79 * GCond cond = G_COND_INIT;
81 * Unfortunately, Windows XP lacks these facilities and GLib still
82 * needs to support Windows XP. Our approach here is as follows:
84 * - avoid depending on structure declarations at compile-time by
85 * declaring our own GMutex and GCond strutures to be
86 * ABI-compatible with SRWLock and CONDITION_VARIABLE and using
89 * - avoid a hard dependency on the symbols used to manipulate these
90 * structures by doing a dynamic lookup of those symbols at
93 * - if the symbols are not available, emulate them using other
96 * Using this approach also allows us to easily build a GLib that lacks
97 * support for Windows XP or to remove this code entirely when XP is no
98 * longer supported (end of line is currently April 8, 2014).
102 void (__stdcall * CallThisOnThreadExit) (void); /* fake */
104 void (__stdcall * InitializeSRWLock) (gpointer lock);
105 void (__stdcall * DeleteSRWLock) (gpointer lock); /* fake */
106 void (__stdcall * AcquireSRWLockExclusive) (gpointer lock);
107 BOOLEAN (__stdcall * TryAcquireSRWLockExclusive) (gpointer lock);
108 void (__stdcall * ReleaseSRWLockExclusive) (gpointer lock);
110 void (__stdcall * InitializeConditionVariable) (gpointer cond);
111 void (__stdcall * DeleteConditionVariable) (gpointer cond); /* fake */
112 BOOL (__stdcall * SleepConditionVariableSRW) (gpointer cond,
116 void (__stdcall * WakeAllConditionVariable) (gpointer cond);
117 void (__stdcall * WakeConditionVariable) (gpointer cond);
120 static GThreadImplVtable g_thread_impl_vtable;
124 g_mutex_init (GMutex *mutex)
126 g_thread_impl_vtable.InitializeSRWLock (mutex);
130 g_mutex_clear (GMutex *mutex)
132 if (g_thread_impl_vtable.DeleteSRWLock != NULL)
133 g_thread_impl_vtable.DeleteSRWLock (mutex);
137 g_mutex_lock (GMutex *mutex)
139 g_thread_impl_vtable.AcquireSRWLockExclusive (mutex);
143 g_mutex_trylock (GMutex *mutex)
145 return g_thread_impl_vtable.TryAcquireSRWLockExclusive (mutex);
149 g_mutex_unlock (GMutex *mutex)
151 g_thread_impl_vtable.ReleaseSRWLockExclusive (mutex);
156 g_cond_init (GCond *cond)
158 g_thread_impl_vtable.InitializeConditionVariable (cond);
162 g_cond_clear (GCond *cond)
164 if (g_thread_impl_vtable.DeleteConditionVariable)
165 g_thread_impl_vtable.DeleteConditionVariable (cond);
169 g_cond_signal (GCond *cond)
171 g_thread_impl_vtable.WakeConditionVariable (cond);
175 g_cond_broadcast (GCond *cond)
177 g_thread_impl_vtable.WakeAllConditionVariable (cond);
181 g_cond_wait (GCond *cond,
182 GMutex *entered_mutex)
184 g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, INFINITE, 0);
188 g_cond_timedwait (GCond *cond,
189 GMutex *entered_mutex,
196 GetSystemTimeAsFileTime (&ft);
197 memmove (&now, &ft, sizeof (FILETIME));
199 now -= G_GINT64_CONSTANT (116444736000000000);
202 span = abs_time - now;
204 if G_UNLIKELY (span < 0)
207 if G_UNLIKELY (span > G_GINT64_CONSTANT (1000) * G_MAXINT32)
210 return g_thread_impl_vtable.SleepConditionVariableSRW (cond, entered_mutex, span / 1000, 0);
214 g_cond_timed_wait (GCond *cond,
215 GMutex *entered_mutex,
222 micros = abs_time->tv_sec;
224 micros += abs_time->tv_usec;
226 return g_cond_timedwait (cond, entered_mutex, micros);
230 g_cond_wait (cond, entered_mutex);
237 typedef struct _GPrivateDestructor GPrivateDestructor;
239 struct _GPrivateDestructor
242 GDestroyNotify notify;
243 GPrivateDestructor *next;
246 static GPrivateDestructor * volatile g_private_destructors;
249 g_private_init (GPrivate *key,
250 GDestroyNotify notify)
252 GPrivateDestructor *destructor;
254 key->index = TlsAlloc ();
256 destructor = malloc (sizeof (GPrivateDestructor));
257 if G_UNLIKELY (destructor == NULL)
258 g_thread_abort (errno, "malloc");
259 destructor->index = key->index;
260 destructor->notify = notify;
263 destructor->next = g_private_destructors;
264 while (InterlockedCompareExchangePointer (&g_private_destructors, destructor->next, destructor) != destructor->next);
270 g_private_get (GPrivate *key)
273 return key->single_value;
275 return TlsGetValue (key->index);
279 g_private_set (GPrivate *key,
284 key->single_value = value;
288 TlsSetValue (key->index, value);
294 #include "gthreadprivate.h"
296 #define win32_check_for_error(what) G_STMT_START{ \
298 g_error ("file %s: line %d (%s): error %s during %s", \
299 __FILE__, __LINE__, G_STRFUNC, \
300 g_win32_error_message (GetLastError ()), #what); \
303 #define G_MUTEX_SIZE (sizeof (gpointer))
305 static DWORD g_thread_self_tls;
306 static DWORD g_private_tls;
308 typedef BOOL (__stdcall *GTryEnterCriticalSectionFunc) (CRITICAL_SECTION *);
310 typedef struct _GThreadData GThreadData;
321 g_thread_set_priority_win32_impl (gpointer thread, GThreadPriority priority)
323 GThreadData *target = *(GThreadData **)thread;
328 case G_THREAD_PRIORITY_LOW:
329 native_prio = THREAD_PRIORITY_BELOW_NORMAL;
332 case G_THREAD_PRIORITY_NORMAL:
333 native_prio = THREAD_PRIORITY_NORMAL;
336 case G_THREAD_PRIORITY_HIGH:
337 native_prio = THREAD_PRIORITY_ABOVE_NORMAL;
340 case G_THREAD_PRIORITY_URGENT:
341 native_prio = THREAD_PRIORITY_HIGHEST;
345 g_return_if_reached ();
348 win32_check_for_error (SetThreadPriority (target->thread, native_prio));
352 g_thread_self_win32_impl (gpointer thread)
354 GThreadData *self = TlsGetValue (g_thread_self_tls);
358 /* This should only happen for the main thread! */
359 HANDLE handle = GetCurrentThread ();
360 HANDLE process = GetCurrentProcess ();
361 self = g_new (GThreadData, 1);
362 win32_check_for_error (DuplicateHandle (process, handle, process,
363 &self->thread, 0, FALSE,
364 DUPLICATE_SAME_ACCESS));
365 win32_check_for_error (TlsSetValue (g_thread_self_tls, self));
368 self->joinable = FALSE;
371 *(GThreadData **)thread = self;
375 g_thread_exit_win32_impl (void)
377 GThreadData *self = TlsGetValue (g_thread_self_tls);
378 gboolean dtors_called;
382 GPrivateDestructor *dtor;
384 /* We go by the POSIX book on this one.
386 * If we call a destructor then there is a chance that some new
387 * TLS variables got set by code called in that destructor.
389 * Loop until nothing is left.
391 dtors_called = FALSE;
393 for (dtor = g_private_destructors; dtor; dtor = dtor->next)
397 value = TlsGetValue (dtor->index);
398 if (value != NULL && dtor->notify != NULL)
400 /* POSIX says to clear this before the call */
401 TlsSetValue (dtor->index, NULL);
402 dtor->notify (value);
407 while (dtors_called);
413 win32_check_for_error (CloseHandle (self->thread));
416 win32_check_for_error (TlsSetValue (g_thread_self_tls, NULL));
419 if (g_thread_impl_vtable.CallThisOnThreadExit)
420 g_thread_impl_vtable.CallThisOnThreadExit ();
425 static guint __stdcall
426 g_thread_proxy (gpointer data)
428 GThreadData *self = (GThreadData*) data;
430 win32_check_for_error (TlsSetValue (g_thread_self_tls, self));
432 self->func (self->data);
434 g_thread_exit_win32_impl ();
436 g_assert_not_reached ();
442 g_thread_create_win32_impl (GThreadFunc func,
447 GThreadPriority priority,
454 g_return_if_fail (func);
455 g_return_if_fail (priority >= G_THREAD_PRIORITY_LOW);
456 g_return_if_fail (priority <= G_THREAD_PRIORITY_URGENT);
458 retval = g_new(GThreadData, 1);
462 retval->joinable = joinable;
464 retval->thread = (HANDLE) _beginthreadex (NULL, stack_size, g_thread_proxy,
467 if (retval->thread == NULL)
469 gchar *win_error = g_win32_error_message (GetLastError ());
470 g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN,
471 "Error creating thread: %s", win_error);
477 *(GThreadData **)thread = retval;
479 g_thread_set_priority_win32_impl (thread, priority);
483 g_thread_yield (void)
489 g_thread_join_win32_impl (gpointer thread)
491 GThreadData *target = *(GThreadData **)thread;
493 g_return_if_fail (target->joinable);
495 win32_check_for_error (WAIT_FAILED !=
496 WaitForSingleObject (target->thread, INFINITE));
498 win32_check_for_error (CloseHandle (target->thread));
502 /* {{{1 SRWLock and CONDITION_VARIABLE emulation (for Windows XP) */
504 static CRITICAL_SECTION g_thread_xp_lock;
505 static DWORD g_thread_xp_waiter_tls;
507 /* {{{2 GThreadWaiter utility class for CONDITION_VARIABLE emulation */
508 typedef struct _GThreadXpWaiter GThreadXpWaiter;
509 struct _GThreadXpWaiter
512 volatile GThreadXpWaiter *next;
515 static GThreadXpWaiter *
516 g_thread_xp_waiter_get (void)
518 GThreadXpWaiter *waiter;
520 waiter = TlsGetValue (g_thread_xp_waiter_tls);
522 if G_UNLIKELY (waiter == NULL)
524 waiter = malloc (sizeof (GThreadXpWaiter));
526 g_thread_abort (GetLastError (), "malloc");
527 waiter->event = CreateEvent (0, FALSE, FALSE, NULL);
528 if (waiter->event == NULL)
529 g_thread_abort (GetLastError (), "CreateEvent");
531 TlsSetValue (g_thread_xp_waiter_tls, waiter);
537 static void __stdcall
538 g_thread_xp_CallThisOnThreadExit (void)
540 GThreadXpWaiter *waiter;
542 waiter = TlsGetValue (g_thread_xp_waiter_tls);
546 TlsSetValue (g_thread_xp_waiter_tls, NULL);
547 CloseHandle (waiter->event);
552 /* {{{2 SRWLock emulation */
555 CRITICAL_SECTION critical_section;
558 static void __stdcall
559 g_thread_xp_InitializeSRWLock (gpointer mutex)
561 *(GThreadSRWLock * volatile *) mutex = NULL;
564 static void __stdcall
565 g_thread_xp_DeleteSRWLock (gpointer mutex)
567 GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
571 DeleteCriticalSection (&lock->critical_section);
576 static GThreadSRWLock * __stdcall
577 g_thread_xp_get_srwlock (GThreadSRWLock * volatile *lock)
579 GThreadSRWLock *result;
581 /* It looks like we're missing some barriers here, but this code only
582 * ever runs on Windows XP, which in turn only ever runs on hardware
583 * with a relatively rigid memory model. The 'volatile' will take
584 * care of the compiler.
588 if G_UNLIKELY (result == NULL)
590 EnterCriticalSection (&g_thread_xp_lock);
592 result = malloc (sizeof (GThreadSRWLock));
595 g_thread_abort (errno, "malloc");
597 InitializeCriticalSection (&result->critical_section);
600 LeaveCriticalSection (&g_thread_xp_lock);
606 static void __stdcall
607 g_thread_xp_AcquireSRWLockExclusive (gpointer mutex)
609 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
611 EnterCriticalSection (&lock->critical_section);
614 static BOOLEAN __stdcall
615 g_thread_xp_TryAcquireSRWLockExclusive (gpointer mutex)
617 GThreadSRWLock *lock = g_thread_xp_get_srwlock (mutex);
619 return TryEnterCriticalSection (&lock->critical_section);
622 static void __stdcall
623 g_thread_xp_ReleaseSRWLockExclusive (gpointer mutex)
625 GThreadSRWLock *lock = *(GThreadSRWLock * volatile *) mutex;
627 /* We need this until we fix some weird parts of GLib that try to
628 * unlock freshly-allocated mutexes.
631 LeaveCriticalSection (&lock->critical_section);
634 /* {{{2 CONDITION_VARIABLE emulation */
637 volatile GThreadXpWaiter *first;
638 volatile GThreadXpWaiter **last_ptr;
639 } GThreadXpCONDITION_VARIABLE;
641 static void __stdcall
642 g_thread_xp_InitializeConditionVariable (gpointer cond)
644 *(GThreadXpCONDITION_VARIABLE * volatile *) cond = NULL;
647 static void __stdcall
648 g_thread_xp_DeleteConditionVariable (gpointer cond)
650 GThreadXpCONDITION_VARIABLE *cv = *(GThreadXpCONDITION_VARIABLE * volatile *) cond;
656 static GThreadXpCONDITION_VARIABLE * __stdcall
657 g_thread_xp_get_condition_variable (GThreadXpCONDITION_VARIABLE * volatile *cond)
659 GThreadXpCONDITION_VARIABLE *result;
661 /* It looks like we're missing some barriers here, but this code only
662 * ever runs on Windows XP, which in turn only ever runs on hardware
663 * with a relatively rigid memory model. The 'volatile' will take
664 * care of the compiler.
668 if G_UNLIKELY (result == NULL)
670 result = malloc (sizeof (GThreadXpCONDITION_VARIABLE));
673 g_thread_abort (errno, "malloc");
675 result->first = NULL;
676 result->last_ptr = &result->first;
678 if (InterlockedCompareExchangePointer (cond, result, NULL) != NULL)
688 static BOOL __stdcall
689 g_thread_xp_SleepConditionVariableSRW (gpointer cond,
694 GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
695 GThreadXpWaiter *waiter = g_thread_xp_waiter_get ();
700 EnterCriticalSection (&g_thread_xp_lock);
701 *cv->last_ptr = waiter;
702 cv->last_ptr = &waiter->next;
703 LeaveCriticalSection (&g_thread_xp_lock);
705 g_mutex_unlock (mutex);
706 status = WaitForSingleObject (waiter->event, timeout);
708 if (status != WAIT_TIMEOUT && status != WAIT_OBJECT_0)
709 g_thread_abort (GetLastError (), "WaitForSingleObject");
711 g_mutex_lock (mutex);
713 return status == WAIT_OBJECT_0;
716 static void __stdcall
717 g_thread_xp_WakeConditionVariable (gpointer cond)
719 GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
720 volatile GThreadXpWaiter *waiter;
722 EnterCriticalSection (&g_thread_xp_lock);
726 cv->first = waiter->next;
727 if (cv->first == NULL)
728 cv->last_ptr = &cv->first;
730 LeaveCriticalSection (&g_thread_xp_lock);
733 SetEvent (waiter->event);
736 static void __stdcall
737 g_thread_xp_WakeAllConditionVariable (gpointer cond)
739 GThreadXpCONDITION_VARIABLE *cv = g_thread_xp_get_condition_variable (cond);
740 volatile GThreadXpWaiter *waiter;
742 EnterCriticalSection (&g_thread_xp_lock);
745 cv->last_ptr = &cv->first;
746 LeaveCriticalSection (&g_thread_xp_lock);
748 while (waiter != NULL)
750 volatile GThreadXpWaiter *next;
753 SetEvent (waiter->event);
760 g_thread_xp_init (void)
762 static const GThreadImplVtable g_thread_xp_impl_vtable = {
763 g_thread_xp_CallThisOnThreadExit,
764 g_thread_xp_InitializeSRWLock,
765 g_thread_xp_DeleteSRWLock,
766 g_thread_xp_AcquireSRWLockExclusive,
767 g_thread_xp_TryAcquireSRWLockExclusive,
768 g_thread_xp_ReleaseSRWLockExclusive,
769 g_thread_xp_InitializeConditionVariable,
770 g_thread_xp_DeleteConditionVariable,
771 g_thread_xp_SleepConditionVariableSRW,
772 g_thread_xp_WakeAllConditionVariable,
773 g_thread_xp_WakeConditionVariable
776 InitializeCriticalSection (&g_thread_xp_lock);
777 g_thread_xp_waiter_tls = TlsAlloc ();
779 g_thread_impl_vtable = g_thread_xp_impl_vtable;
784 GThreadFunctions g_thread_functions_for_glib_use =
786 g_mutex_new, /* mutex */
791 g_cond_new, /* condition */
797 g_private_new, /* private thread data */
800 g_thread_create_win32_impl, /* thread */
802 g_thread_join_win32_impl,
803 g_thread_exit_win32_impl,
804 g_thread_set_priority_win32_impl,
805 g_thread_self_win32_impl,
806 NULL /* no equal function necessary */
810 _g_thread_impl_init (void)
812 static gboolean beenhere = FALSE;
819 printf ("thread init\n");
820 win32_check_for_error (TLS_OUT_OF_INDEXES !=
821 (g_thread_self_tls = TlsAlloc ()));
822 win32_check_for_error (TLS_OUT_OF_INDEXES !=
823 (g_private_tls = TlsAlloc ()));
827 g_thread_lookup_native_funcs (void)
829 GThreadImplVtable native_vtable = { 0, };
832 kernel32 = GetModuleHandle ("KERNEL32.DLL");
834 if (kernel32 == NULL)
837 #define GET_FUNC(name) if ((native_vtable.name = (void *) GetProcAddress (kernel32, #name)) == NULL) return FALSE
838 GET_FUNC(InitializeSRWLock);
839 GET_FUNC(AcquireSRWLockExclusive);
840 GET_FUNC(TryAcquireSRWLockExclusive);
841 GET_FUNC(ReleaseSRWLockExclusive);
843 GET_FUNC(InitializeConditionVariable);
844 GET_FUNC(SleepConditionVariableSRW);
845 GET_FUNC(WakeAllConditionVariable);
846 GET_FUNC(WakeConditionVariable);
849 g_thread_impl_vtable = native_vtable;
855 g_thread_DllMain (void)
857 if (g_thread_lookup_native_funcs ())
858 fprintf (stderr, "(debug) GThread using native mode\n");
861 fprintf (stderr, "(debug) GThread using Windows XP mode\n");
866 /* vim:set foldmethod=marker: */