thread.c 5.56 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7
 */

8
#include "thread.h"
9
#include "runtime.h"
10

11 12
#define CLEAN_THREAD_EXIT 0x6F012842

13 14 15 16 17 18 19 20
typedef void (WINAPI *win32_srwlock_fn)(GIT_SRWLOCK *);

static win32_srwlock_fn win32_srwlock_initialize;
static win32_srwlock_fn win32_srwlock_acquire_shared;
static win32_srwlock_fn win32_srwlock_release_shared;
static win32_srwlock_fn win32_srwlock_acquire_exclusive;
static win32_srwlock_fn win32_srwlock_release_exclusive;

21 22
static DWORD fls_index;

23 24 25 26 27 28
/* The thread procedure stub used to invoke the caller's procedure
 * and capture the return value for later collection. Windows will
 * only hold a DWORD, but we need to be able to store an entire
 * void pointer. This requires the indirection. */
static DWORD WINAPI git_win32__threadproc(LPVOID lpParameter)
{
29
	git_thread *thread = lpParameter;
30

31
	/* Set the current thread for `git_thread_exit` */
32
	FlsSetValue(fls_index, thread);
33

Philip Kelley committed
34
	thread->result = thread->proc(thread->param);
35 36 37 38

	return CLEAN_THREAD_EXIT;
}

39 40 41 42 43
static void git_threads_global_shutdown(void)
{
	FlsFree(fls_index);
}

44
int git_threads_global_init(void)
45 46 47 48
{
	HMODULE hModule = GetModuleHandleW(L"kernel32");

	if (hModule) {
49
		win32_srwlock_initialize = (win32_srwlock_fn)(void *)
50
			GetProcAddress(hModule, "InitializeSRWLock");
51
		win32_srwlock_acquire_shared = (win32_srwlock_fn)(void *)
52
			GetProcAddress(hModule, "AcquireSRWLockShared");
53
		win32_srwlock_release_shared = (win32_srwlock_fn)(void *)
54
			GetProcAddress(hModule, "ReleaseSRWLockShared");
55
		win32_srwlock_acquire_exclusive = (win32_srwlock_fn)(void *)
56
			GetProcAddress(hModule, "AcquireSRWLockExclusive");
57
		win32_srwlock_release_exclusive = (win32_srwlock_fn)(void *)
58 59 60
			GetProcAddress(hModule, "ReleaseSRWLockExclusive");
	}

61 62 63
	if ((fls_index = FlsAlloc(NULL)) == FLS_OUT_OF_INDEXES)
		return -1;

64
	return git_runtime_shutdown_register(git_threads_global_shutdown);
65 66
}

67 68
int git_thread_create(
	git_thread *GIT_RESTRICT thread,
69 70
	void *(*start_routine)(void*),
	void *GIT_RESTRICT arg)
71
{
Philip Kelley committed
72 73
	thread->result = NULL;
	thread->param = arg;
74 75 76 77 78
	thread->proc = start_routine;
	thread->thread = CreateThread(
		NULL, 0, git_win32__threadproc, thread, 0, NULL);

	return thread->thread ? 0 : -1;
79 80
}

81 82
int git_thread_join(
	git_thread *thread,
83
	void **value_ptr)
84
{
85 86 87 88 89 90 91 92 93
	DWORD exit;

	if (WaitForSingleObject(thread->thread, INFINITE) != WAIT_OBJECT_0)
		return -1;

	if (!GetExitCodeThread(thread->thread, &exit)) {
		CloseHandle(thread->thread);
		return -1;
	}
94

95 96
	/* Check for the thread having exited uncleanly. If exit was unclean,
	 * then we don't have a return value to give back to the caller. */
Edward Thomson committed
97
	GIT_ASSERT(exit == CLEAN_THREAD_EXIT);
98

99
	if (value_ptr)
Philip Kelley committed
100
		*value_ptr = thread->result;
101 102 103

	CloseHandle(thread->thread);
	return 0;
104 105
}

106 107
void git_thread_exit(void *value)
{
108 109 110 111 112
	git_thread *thread = FlsGetValue(fls_index);

	if (thread)
		thread->result = value;

113 114 115 116 117 118 119 120
	ExitThread(CLEAN_THREAD_EXIT);
}

size_t git_thread_currentid(void)
{
	return GetCurrentThreadId();
}

121
int git_mutex_init(git_mutex *GIT_RESTRICT mutex)
122
{
Vicent Marti committed
123 124
	InitializeCriticalSection(mutex);
	return 0;
125 126
}

127
int git_mutex_free(git_mutex *mutex)
128
{
Vicent Marti committed
129 130
	DeleteCriticalSection(mutex);
	return 0;
131 132
}

133
int git_mutex_lock(git_mutex *mutex)
134
{
Vicent Marti committed
135 136
	EnterCriticalSection(mutex);
	return 0;
137 138
}

139
int git_mutex_unlock(git_mutex *mutex)
140
{
Vicent Marti committed
141 142
	LeaveCriticalSection(mutex);
	return 0;
143 144
}

145
int git_cond_init(git_cond *cond)
146 147 148
{
	/* This is an auto-reset event. */
	*cond = CreateEventW(NULL, FALSE, FALSE, NULL);
Edward Thomson committed
149
	GIT_ASSERT(*cond);
150 151 152 153 154 155

	/* If we can't create the event, claim that the reason was out-of-memory.
	 * The actual reason can be fetched with GetLastError(). */
	return *cond ? 0 : ENOMEM;
}

156
int git_cond_free(git_cond *cond)
157 158 159 160 161 162 163
{
	BOOL closed;

	if (!cond)
		return EINVAL;

	closed = CloseHandle(*cond);
Edward Thomson committed
164
	GIT_ASSERT(closed);
165
	GIT_UNUSED(closed);
166 167 168 169 170

	*cond = NULL;
	return 0;
}

171
int git_cond_wait(git_cond *cond, git_mutex *mutex)
172 173 174 175 176 177 178 179
{
	int error;
	DWORD wait_result;

	if (!cond || !mutex)
		return EINVAL;

	/* The caller must be holding the mutex. */
180
	error = git_mutex_unlock(mutex);
181 182 183 184 185

	if (error)
		return error;

	wait_result = WaitForSingleObject(*cond, INFINITE);
Edward Thomson committed
186
	GIT_ASSERT(WAIT_OBJECT_0 == wait_result);
187
	GIT_UNUSED(wait_result);
188

189
	return git_mutex_lock(mutex);
190 191
}

192
int git_cond_signal(git_cond *cond)
193 194 195 196 197 198 199
{
	BOOL signaled;

	if (!cond)
		return EINVAL;

	signaled = SetEvent(*cond);
Edward Thomson committed
200
	GIT_ASSERT(signaled);
201
	GIT_UNUSED(signaled);
202 203 204 205

	return 0;
}

206
int git_rwlock_init(git_rwlock *GIT_RESTRICT lock)
207
{
208 209 210 211 212
	if (win32_srwlock_initialize)
		win32_srwlock_initialize(&lock->native.srwl);
	else
		InitializeCriticalSection(&lock->native.csec);

213 214 215
	return 0;
}

216
int git_rwlock_rdlock(git_rwlock *lock)
217
{
218 219 220 221 222
	if (win32_srwlock_acquire_shared)
		win32_srwlock_acquire_shared(&lock->native.srwl);
	else
		EnterCriticalSection(&lock->native.csec);

223 224 225
	return 0;
}

226
int git_rwlock_rdunlock(git_rwlock *lock)
227
{
228 229 230 231 232
	if (win32_srwlock_release_shared)
		win32_srwlock_release_shared(&lock->native.srwl);
	else
		LeaveCriticalSection(&lock->native.csec);

233 234 235
	return 0;
}

236
int git_rwlock_wrlock(git_rwlock *lock)
237
{
238 239 240 241 242
	if (win32_srwlock_acquire_exclusive)
		win32_srwlock_acquire_exclusive(&lock->native.srwl);
	else
		EnterCriticalSection(&lock->native.csec);

243 244 245
	return 0;
}

246
int git_rwlock_wrunlock(git_rwlock *lock)
247
{
248 249 250 251 252
	if (win32_srwlock_release_exclusive)
		win32_srwlock_release_exclusive(&lock->native.srwl);
	else
		LeaveCriticalSection(&lock->native.csec);

253 254 255
	return 0;
}

256
int git_rwlock_free(git_rwlock *lock)
257
{
258 259 260 261 262
	if (!win32_srwlock_initialize)
		DeleteCriticalSection(&lock->native.csec);
	git__memzero(lock, sizeof(*lock));
	return 0;
}