mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-12-25 15:06:14 +01:00
00bfb3ab44
This was mostly machine generated with the following command: ``` codespell \ --builtin clear,rare,usage \ --skip './po/*' --skip './.git/*' --skip './NEWS*' \ --write-changes . ``` using the latest git version of `codespell` as per [these instructions](https://github.com/codespell-project/codespell#user-content-updating). Then I manually checked each change using `git add -p`, made a few manual fixups and dropped a load of incorrect changes. There are still some outdated or loaded terms used in GLib, mostly to do with git branch terminology. They will need to be changed later as part of a wider migration of git terminology. If I’ve missed anything, please file an issue! Signed-off-by: Philip Withnall <withnall@endlessm.com>
668 lines
15 KiB
C
668 lines
15 KiB
C
/* GLIB - Library of useful routines for C programming
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
*
|
|
* gthread.c: solaris thread system implementation
|
|
* Copyright 1998-2001 Sebastian Wilhelmi; University of Karlsruhe
|
|
* Copyright 2001 Hans Breuer
|
|
*
|
|
* 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.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
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
* Modified by the GLib Team and others 1997-2000. See the AUTHORS
|
|
* file for a list of people on the GLib Team. See the ChangeLog
|
|
* files for a list of changes. These files are distributed with
|
|
* GLib at ftp://ftp.gtk.org/pub/gtk/.
|
|
*/
|
|
|
|
/* The GMutex and GCond implementations in this file are some of the
|
|
* lowest-level code in GLib. All other parts of GLib (messages,
|
|
* memory, slices, etc) assume that they can freely use these facilities
|
|
* without risking recursion.
|
|
*
|
|
* As such, these functions are NOT permitted to call any other part of
|
|
* GLib.
|
|
*
|
|
* The thread manipulation functions (create, exit, join, etc.) have
|
|
* more freedom -- they can do as they please.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "glib.h"
|
|
#include "glib-init.h"
|
|
#include "gthread.h"
|
|
#include "gthreadprivate.h"
|
|
#include "gslice.h"
|
|
|
|
#include <windows.h>
|
|
|
|
#include <process.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
static void
|
|
g_thread_abort (gint status,
|
|
const gchar *function)
|
|
{
|
|
fprintf (stderr, "GLib (gthread-win32.c): Unexpected error from C library during '%s': %s. Aborting.\n",
|
|
strerror (status), function);
|
|
g_abort ();
|
|
}
|
|
|
|
/* Starting with Vista and Windows 2008, we have access to the
|
|
* 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
|
|
* pointer is used as an atomic bitfield to support user-space mutexes
|
|
* that only get the kernel involved in cases of contention (similar
|
|
* to how futex()-based mutexes work on Linux). The biggest advantage
|
|
* 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.
|
|
*/
|
|
|
|
/* {{{1 GMutex */
|
|
void
|
|
g_mutex_init (GMutex *mutex)
|
|
{
|
|
InitializeSRWLock ((gpointer) mutex);
|
|
}
|
|
|
|
void
|
|
g_mutex_clear (GMutex *mutex)
|
|
{
|
|
}
|
|
|
|
void
|
|
g_mutex_lock (GMutex *mutex)
|
|
{
|
|
AcquireSRWLockExclusive ((gpointer) mutex);
|
|
}
|
|
|
|
gboolean
|
|
g_mutex_trylock (GMutex *mutex)
|
|
{
|
|
return TryAcquireSRWLockExclusive ((gpointer) mutex);
|
|
}
|
|
|
|
void
|
|
g_mutex_unlock (GMutex *mutex)
|
|
{
|
|
ReleaseSRWLockExclusive ((gpointer) mutex);
|
|
}
|
|
|
|
/* {{{1 GRecMutex */
|
|
|
|
static CRITICAL_SECTION *
|
|
g_rec_mutex_impl_new (void)
|
|
{
|
|
CRITICAL_SECTION *cs;
|
|
|
|
cs = g_slice_new (CRITICAL_SECTION);
|
|
InitializeCriticalSection (cs);
|
|
|
|
return cs;
|
|
}
|
|
|
|
static void
|
|
g_rec_mutex_impl_free (CRITICAL_SECTION *cs)
|
|
{
|
|
DeleteCriticalSection (cs);
|
|
g_slice_free (CRITICAL_SECTION, cs);
|
|
}
|
|
|
|
static CRITICAL_SECTION *
|
|
g_rec_mutex_get_impl (GRecMutex *mutex)
|
|
{
|
|
CRITICAL_SECTION *impl = mutex->p;
|
|
|
|
if G_UNLIKELY (mutex->p == NULL)
|
|
{
|
|
impl = g_rec_mutex_impl_new ();
|
|
if (InterlockedCompareExchangePointer (&mutex->p, impl, NULL) != NULL)
|
|
g_rec_mutex_impl_free (impl);
|
|
impl = mutex->p;
|
|
}
|
|
|
|
return impl;
|
|
}
|
|
|
|
void
|
|
g_rec_mutex_init (GRecMutex *mutex)
|
|
{
|
|
mutex->p = g_rec_mutex_impl_new ();
|
|
}
|
|
|
|
void
|
|
g_rec_mutex_clear (GRecMutex *mutex)
|
|
{
|
|
g_rec_mutex_impl_free (mutex->p);
|
|
}
|
|
|
|
void
|
|
g_rec_mutex_lock (GRecMutex *mutex)
|
|
{
|
|
EnterCriticalSection (g_rec_mutex_get_impl (mutex));
|
|
}
|
|
|
|
void
|
|
g_rec_mutex_unlock (GRecMutex *mutex)
|
|
{
|
|
LeaveCriticalSection (mutex->p);
|
|
}
|
|
|
|
gboolean
|
|
g_rec_mutex_trylock (GRecMutex *mutex)
|
|
{
|
|
return TryEnterCriticalSection (g_rec_mutex_get_impl (mutex));
|
|
}
|
|
|
|
/* {{{1 GRWLock */
|
|
|
|
void
|
|
g_rw_lock_init (GRWLock *lock)
|
|
{
|
|
InitializeSRWLock ((gpointer) lock);
|
|
}
|
|
|
|
void
|
|
g_rw_lock_clear (GRWLock *lock)
|
|
{
|
|
}
|
|
|
|
void
|
|
g_rw_lock_writer_lock (GRWLock *lock)
|
|
{
|
|
AcquireSRWLockExclusive ((gpointer) lock);
|
|
}
|
|
|
|
gboolean
|
|
g_rw_lock_writer_trylock (GRWLock *lock)
|
|
{
|
|
return TryAcquireSRWLockExclusive ((gpointer) lock);
|
|
}
|
|
|
|
void
|
|
g_rw_lock_writer_unlock (GRWLock *lock)
|
|
{
|
|
ReleaseSRWLockExclusive ((gpointer) lock);
|
|
}
|
|
|
|
void
|
|
g_rw_lock_reader_lock (GRWLock *lock)
|
|
{
|
|
AcquireSRWLockShared ((gpointer) lock);
|
|
}
|
|
|
|
gboolean
|
|
g_rw_lock_reader_trylock (GRWLock *lock)
|
|
{
|
|
return TryAcquireSRWLockShared ((gpointer) lock);
|
|
}
|
|
|
|
void
|
|
g_rw_lock_reader_unlock (GRWLock *lock)
|
|
{
|
|
ReleaseSRWLockShared ((gpointer) lock);
|
|
}
|
|
|
|
/* {{{1 GCond */
|
|
void
|
|
g_cond_init (GCond *cond)
|
|
{
|
|
InitializeConditionVariable ((gpointer) cond);
|
|
}
|
|
|
|
void
|
|
g_cond_clear (GCond *cond)
|
|
{
|
|
}
|
|
|
|
void
|
|
g_cond_signal (GCond *cond)
|
|
{
|
|
WakeConditionVariable ((gpointer) cond);
|
|
}
|
|
|
|
void
|
|
g_cond_broadcast (GCond *cond)
|
|
{
|
|
WakeAllConditionVariable ((gpointer) cond);
|
|
}
|
|
|
|
void
|
|
g_cond_wait (GCond *cond,
|
|
GMutex *entered_mutex)
|
|
{
|
|
SleepConditionVariableSRW ((gpointer) cond, (gpointer) entered_mutex, INFINITE, 0);
|
|
}
|
|
|
|
gboolean
|
|
g_cond_wait_until (GCond *cond,
|
|
GMutex *entered_mutex,
|
|
gint64 end_time)
|
|
{
|
|
gint64 span, start_time;
|
|
DWORD span_millis;
|
|
gboolean signalled;
|
|
|
|
start_time = g_get_monotonic_time ();
|
|
do
|
|
{
|
|
span = end_time - start_time;
|
|
|
|
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;
|
|
|
|
/* 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 signalled;
|
|
}
|
|
|
|
/* {{{1 GPrivate */
|
|
|
|
typedef struct _GPrivateDestructor GPrivateDestructor;
|
|
|
|
struct _GPrivateDestructor
|
|
{
|
|
DWORD index;
|
|
GDestroyNotify notify;
|
|
GPrivateDestructor *next;
|
|
};
|
|
|
|
static GPrivateDestructor * volatile g_private_destructors;
|
|
static CRITICAL_SECTION g_private_lock;
|
|
|
|
static DWORD
|
|
g_private_get_impl (GPrivate *key)
|
|
{
|
|
DWORD impl = (DWORD) key->p;
|
|
|
|
if G_UNLIKELY (impl == 0)
|
|
{
|
|
EnterCriticalSection (&g_private_lock);
|
|
impl = (DWORD) key->p;
|
|
if (impl == 0)
|
|
{
|
|
GPrivateDestructor *destructor;
|
|
|
|
impl = TlsAlloc ();
|
|
|
|
if (impl == TLS_OUT_OF_INDEXES)
|
|
g_thread_abort (0, "TlsAlloc");
|
|
|
|
if (key->notify != NULL)
|
|
{
|
|
destructor = malloc (sizeof (GPrivateDestructor));
|
|
if G_UNLIKELY (destructor == NULL)
|
|
g_thread_abort (errno, "malloc");
|
|
destructor->index = impl;
|
|
destructor->notify = key->notify;
|
|
destructor->next = g_private_destructors;
|
|
|
|
/* We need to do an atomic store due to the unlocked
|
|
* access to the destructor list from the thread exit
|
|
* function.
|
|
*
|
|
* It can double as a sanity check...
|
|
*/
|
|
if (InterlockedCompareExchangePointer (&g_private_destructors, destructor,
|
|
destructor->next) != destructor->next)
|
|
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)
|
|
g_thread_abort (0, "g_private_get_impl(2)");
|
|
}
|
|
LeaveCriticalSection (&g_private_lock);
|
|
}
|
|
|
|
return impl;
|
|
}
|
|
|
|
gpointer
|
|
g_private_get (GPrivate *key)
|
|
{
|
|
return TlsGetValue (g_private_get_impl (key));
|
|
}
|
|
|
|
void
|
|
g_private_set (GPrivate *key,
|
|
gpointer value)
|
|
{
|
|
TlsSetValue (g_private_get_impl (key), value);
|
|
}
|
|
|
|
void
|
|
g_private_replace (GPrivate *key,
|
|
gpointer value)
|
|
{
|
|
DWORD impl = g_private_get_impl (key);
|
|
gpointer old;
|
|
|
|
old = TlsGetValue (impl);
|
|
if (old && key->notify)
|
|
key->notify (old);
|
|
TlsSetValue (impl, value);
|
|
}
|
|
|
|
/* {{{1 GThread */
|
|
|
|
#define win32_check_for_error(what) G_STMT_START{ \
|
|
if (!(what)) \
|
|
g_error ("file %s: line %d (%s): error %s during %s", \
|
|
__FILE__, __LINE__, G_STRFUNC, \
|
|
g_win32_error_message (GetLastError ()), #what); \
|
|
}G_STMT_END
|
|
|
|
#define G_MUTEX_SIZE (sizeof (gpointer))
|
|
|
|
typedef BOOL (__stdcall *GTryEnterCriticalSectionFunc) (CRITICAL_SECTION *);
|
|
|
|
typedef struct
|
|
{
|
|
GRealThread thread;
|
|
|
|
GThreadFunc proxy;
|
|
HANDLE handle;
|
|
} GThreadWin32;
|
|
|
|
void
|
|
g_system_thread_free (GRealThread *thread)
|
|
{
|
|
GThreadWin32 *wt = (GThreadWin32 *) thread;
|
|
|
|
win32_check_for_error (CloseHandle (wt->handle));
|
|
g_slice_free (GThreadWin32, wt);
|
|
}
|
|
|
|
void
|
|
g_system_thread_exit (void)
|
|
{
|
|
_endthreadex (0);
|
|
}
|
|
|
|
static guint __stdcall
|
|
g_thread_win32_proxy (gpointer data)
|
|
{
|
|
GThreadWin32 *self = data;
|
|
|
|
self->proxy (self);
|
|
|
|
g_system_thread_exit ();
|
|
|
|
g_assert_not_reached ();
|
|
|
|
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 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 = 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)
|
|
{
|
|
message = "Error creating thread";
|
|
goto error;
|
|
}
|
|
|
|
/* 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.
|
|
*/
|
|
|
|
if (scheduler_settings)
|
|
{
|
|
thread_prio = scheduler_settings->thread_prio;
|
|
}
|
|
else
|
|
{
|
|
HANDLE current_thread = GetCurrentThread ();
|
|
thread_prio = GetThreadPriority (current_thread);
|
|
}
|
|
|
|
if (thread_prio == THREAD_PRIORITY_ERROR_RETURN)
|
|
{
|
|
message = "Error getting current thread priority";
|
|
goto error;
|
|
}
|
|
|
|
if (SetThreadPriority (thread->handle, thread_prio) == 0)
|
|
{
|
|
message = "Error setting new thread priority";
|
|
goto error;
|
|
}
|
|
|
|
if (ResumeThread (thread->handle) == -1)
|
|
{
|
|
message = "Error resuming new thread";
|
|
goto error;
|
|
}
|
|
|
|
return (GRealThread *) thread;
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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));
|
|
}
|
|
|
|
#define EXCEPTION_SET_THREAD_NAME ((DWORD) 0x406D1388)
|
|
|
|
#ifndef _MSC_VER
|
|
static void *SetThreadName_VEH_handle = NULL;
|
|
|
|
static LONG __stdcall
|
|
SetThreadName_VEH (PEXCEPTION_POINTERS ExceptionInfo)
|
|
{
|
|
if (ExceptionInfo->ExceptionRecord != NULL &&
|
|
ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SET_THREAD_NAME)
|
|
return EXCEPTION_CONTINUE_EXECUTION;
|
|
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
}
|
|
#endif
|
|
|
|
typedef struct _THREADNAME_INFO
|
|
{
|
|
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;
|
|
|
|
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, (DWORD *) &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, (DWORD *) &info);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
g_system_thread_set_name (const gchar *name)
|
|
{
|
|
SetThreadName ((DWORD) -1, name);
|
|
}
|
|
|
|
/* {{{1 Epilogue */
|
|
|
|
void
|
|
g_thread_win32_init (void)
|
|
{
|
|
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
|
|
}
|
|
|
|
void
|
|
g_thread_win32_thread_detach (void)
|
|
{
|
|
gboolean dtors_called;
|
|
|
|
do
|
|
{
|
|
GPrivateDestructor *dtor;
|
|
|
|
/* We go by the POSIX book on this one.
|
|
*
|
|
* If we call a destructor then there is a chance that some new
|
|
* TLS variables got set by code called in that destructor.
|
|
*
|
|
* Loop until nothing is left.
|
|
*/
|
|
dtors_called = FALSE;
|
|
|
|
for (dtor = g_private_destructors; dtor; dtor = dtor->next)
|
|
{
|
|
gpointer value;
|
|
|
|
value = TlsGetValue (dtor->index);
|
|
if (value != NULL && dtor->notify != NULL)
|
|
{
|
|
/* POSIX says to clear this before the call */
|
|
TlsSetValue (dtor->index, NULL);
|
|
dtor->notify (value);
|
|
dtors_called = TRUE;
|
|
}
|
|
}
|
|
}
|
|
while (dtors_called);
|
|
}
|
|
|
|
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: */
|