thread.c 5.37 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"
Russell Belfer committed
9
#include "../global.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 23 24 25 26
/* 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)
{
27
	git_thread *thread = lpParameter;
28

29 30 31
	/* Set the current thread for `git_thread_exit` */
	GIT_GLOBAL->current_thread = thread;

Philip Kelley committed
32
	thread->result = thread->proc(thread->param);
33

34
	git__free_tls_data();
35

36 37 38
	return CLEAN_THREAD_EXIT;
}

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
int git_threads_init(void)
{
	HMODULE hModule = GetModuleHandleW(L"kernel32");

	if (hModule) {
		win32_srwlock_initialize = (win32_srwlock_fn)
			GetProcAddress(hModule, "InitializeSRWLock");
		win32_srwlock_acquire_shared = (win32_srwlock_fn)
			GetProcAddress(hModule, "AcquireSRWLockShared");
		win32_srwlock_release_shared = (win32_srwlock_fn)
			GetProcAddress(hModule, "ReleaseSRWLockShared");
		win32_srwlock_acquire_exclusive = (win32_srwlock_fn)
			GetProcAddress(hModule, "AcquireSRWLockExclusive");
		win32_srwlock_release_exclusive = (win32_srwlock_fn)
			GetProcAddress(hModule, "ReleaseSRWLockExclusive");
	}

	return 0;
}

59 60
int git_thread_create(
	git_thread *GIT_RESTRICT thread,
61 62
	void *(*start_routine)(void*),
	void *GIT_RESTRICT arg)
63
{
Philip Kelley committed
64 65
	thread->result = NULL;
	thread->param = arg;
66 67 68 69 70
	thread->proc = start_routine;
	thread->thread = CreateThread(
		NULL, 0, git_win32__threadproc, thread, 0, NULL);

	return thread->thread ? 0 : -1;
71 72
}

73 74
int git_thread_join(
	git_thread *thread,
75
	void **value_ptr)
76
{
77 78 79 80 81 82 83 84 85
	DWORD exit;

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

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

87 88 89 90
	/* 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. */
	if (exit != CLEAN_THREAD_EXIT) {
		assert(false);
Philip Kelley committed
91
		thread->result = NULL;
92 93
	}

94
	if (value_ptr)
Philip Kelley committed
95
		*value_ptr = thread->result;
96 97 98

	CloseHandle(thread->thread);
	return 0;
99 100
}

101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
void git_thread_exit(void *value)
{
	assert(GIT_GLOBAL->current_thread);
	GIT_GLOBAL->current_thread->result = value;

	git__free_tls_data();

	ExitThread(CLEAN_THREAD_EXIT);
}

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

116
int git_mutex_init(git_mutex *GIT_RESTRICT mutex)
117
{
Vicent Marti committed
118 119
	InitializeCriticalSection(mutex);
	return 0;
120 121
}

122
int git_mutex_free(git_mutex *mutex)
123
{
Vicent Marti committed
124 125
	DeleteCriticalSection(mutex);
	return 0;
126 127
}

128
int git_mutex_lock(git_mutex *mutex)
129
{
Vicent Marti committed
130 131
	EnterCriticalSection(mutex);
	return 0;
132 133
}

134
int git_mutex_unlock(git_mutex *mutex)
135
{
Vicent Marti committed
136 137
	LeaveCriticalSection(mutex);
	return 0;
138 139
}

140
int git_cond_init(git_cond *cond)
141 142 143 144 145 146 147 148 149 150
{
	/* This is an auto-reset event. */
	*cond = CreateEventW(NULL, FALSE, FALSE, NULL);
	assert(*cond);

	/* 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;
}

151
int git_cond_free(git_cond *cond)
152 153 154 155 156 157 158 159
{
	BOOL closed;

	if (!cond)
		return EINVAL;

	closed = CloseHandle(*cond);
	assert(closed);
160
	GIT_UNUSED(closed);
161 162 163 164 165

	*cond = NULL;
	return 0;
}

166
int git_cond_wait(git_cond *cond, git_mutex *mutex)
167 168 169 170 171 172 173 174
{
	int error;
	DWORD wait_result;

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

	/* The caller must be holding the mutex. */
175
	error = git_mutex_unlock(mutex);
176 177 178 179 180 181

	if (error)
		return error;

	wait_result = WaitForSingleObject(*cond, INFINITE);
	assert(WAIT_OBJECT_0 == wait_result);
182
	GIT_UNUSED(wait_result);
183

184
	return git_mutex_lock(mutex);
185 186
}

187
int git_cond_signal(git_cond *cond)
188 189 190 191 192 193 194 195
{
	BOOL signaled;

	if (!cond)
		return EINVAL;

	signaled = SetEvent(*cond);
	assert(signaled);
196
	GIT_UNUSED(signaled);
197 198 199 200

	return 0;
}

201
int git_rwlock_init(git_rwlock *GIT_RESTRICT lock)
202
{
203 204 205 206 207
	if (win32_srwlock_initialize)
		win32_srwlock_initialize(&lock->native.srwl);
	else
		InitializeCriticalSection(&lock->native.csec);

208 209 210
	return 0;
}

211
int git_rwlock_rdlock(git_rwlock *lock)
212
{
213 214 215 216 217
	if (win32_srwlock_acquire_shared)
		win32_srwlock_acquire_shared(&lock->native.srwl);
	else
		EnterCriticalSection(&lock->native.csec);

218 219 220
	return 0;
}

221
int git_rwlock_rdunlock(git_rwlock *lock)
222
{
223 224 225 226 227
	if (win32_srwlock_release_shared)
		win32_srwlock_release_shared(&lock->native.srwl);
	else
		LeaveCriticalSection(&lock->native.csec);

228 229 230
	return 0;
}

231
int git_rwlock_wrlock(git_rwlock *lock)
232
{
233 234 235 236 237
	if (win32_srwlock_acquire_exclusive)
		win32_srwlock_acquire_exclusive(&lock->native.srwl);
	else
		EnterCriticalSection(&lock->native.csec);

238 239 240
	return 0;
}

241
int git_rwlock_wrunlock(git_rwlock *lock)
242
{
243 244 245 246 247
	if (win32_srwlock_release_exclusive)
		win32_srwlock_release_exclusive(&lock->native.srwl);
	else
		LeaveCriticalSection(&lock->native.csec);

248 249 250
	return 0;
}

251
int git_rwlock_free(git_rwlock *lock)
252
{
253 254 255 256 257
	if (!win32_srwlock_initialize)
		DeleteCriticalSection(&lock->native.csec);
	git__memzero(lock, sizeof(*lock));
	return 0;
}