/*

 * Copyright (C) the libgit2 contributors. All rights reserved.

 *

 * This file is part of libgit2, distributed under the GNU GPL v2 with

 * a Linking Exception. For full terms see the included COPYING file.

 */

#include "thread.h"

#include "../global.h"

#define CLEAN_THREAD_EXIT 0x6F012842

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;

/* 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)

{

	git_thread *thread = lpParameter;

	/* Set the current thread for `git_thread_exit` */

	GIT_GLOBAL->current_thread = thread;

	thread->result = thread->proc(thread->param);

	git__free_tls_data();

	return CLEAN_THREAD_EXIT;

}

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;

}

int git_thread_create(

	git_thread *GIT_RESTRICT thread,

	void *(*start_routine)(void*),

	void *GIT_RESTRICT arg)

{

	thread->result = NULL;

	thread->param = arg;

	thread->proc = start_routine;

	thread->thread = CreateThread(

		NULL, 0, git_win32__threadproc, thread, 0, NULL);

	return thread->thread ? 0 : -1;

}

int git_thread_join(

	git_thread *thread,

	void **value_ptr)

{

	DWORD exit;

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

		return -1;

	if (!GetExitCodeThread(thread->thread, &exit)) {

		CloseHandle(thread->thread);

		return -1;

	}

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

		thread->result = NULL;

	}

	if (value_ptr)

		*value_ptr = thread->result;

	CloseHandle(thread->thread);

	return 0;

}

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();

}

int git_mutex_init(git_mutex *GIT_RESTRICT mutex)

{

	InitializeCriticalSection(mutex);

	return 0;

}

int git_mutex_free(git_mutex *mutex)

{

	DeleteCriticalSection(mutex);

	return 0;

}

int git_mutex_lock(git_mutex *mutex)

{

	EnterCriticalSection(mutex);

	return 0;

}

int git_mutex_unlock(git_mutex *mutex)

{

	LeaveCriticalSection(mutex);

	return 0;

}

int git_cond_init(git_cond *cond)

{

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

}

int git_cond_free(git_cond *cond)

{

	BOOL closed;

	if (!cond)

		return EINVAL;

	closed = CloseHandle(*cond);

	assert(closed);

	GIT_UNUSED(closed);

	*cond = NULL;

	return 0;

}

int git_cond_wait(git_cond *cond, git_mutex *mutex)

{

	int error;

	DWORD wait_result;

	if (!cond || !mutex)

		return EINVAL;

	/* The caller must be holding the mutex. */

	error = git_mutex_unlock(mutex);

	if (error)

		return error;

	wait_result = WaitForSingleObject(*cond, INFINITE);

	assert(WAIT_OBJECT_0 == wait_result);

	GIT_UNUSED(wait_result);

	return git_mutex_lock(mutex);

}

int git_cond_signal(git_cond *cond)

{

	BOOL signaled;

	if (!cond)

		return EINVAL;

	signaled = SetEvent(*cond);

	assert(signaled);

	GIT_UNUSED(signaled);

	return 0;

}

int git_rwlock_init(git_rwlock *GIT_RESTRICT lock)

{

	if (win32_srwlock_initialize)

		win32_srwlock_initialize(&lock->native.srwl);

	else

		InitializeCriticalSection(&lock->native.csec);

	return 0;

}

int git_rwlock_rdlock(git_rwlock *lock)

{

	if (win32_srwlock_acquire_shared)

		win32_srwlock_acquire_shared(&lock->native.srwl);

	else

		EnterCriticalSection(&lock->native.csec);

	return 0;

}

int git_rwlock_rdunlock(git_rwlock *lock)

{

	if (win32_srwlock_release_shared)

		win32_srwlock_release_shared(&lock->native.srwl);

	else

		LeaveCriticalSection(&lock->native.csec);

	return 0;

}

int git_rwlock_wrlock(git_rwlock *lock)

{

	if (win32_srwlock_acquire_exclusive)

		win32_srwlock_acquire_exclusive(&lock->native.srwl);

	else

		EnterCriticalSection(&lock->native.csec);

	return 0;

}

int git_rwlock_wrunlock(git_rwlock *lock)

{

	if (win32_srwlock_release_exclusive)

		win32_srwlock_release_exclusive(&lock->native.srwl);

	else

		LeaveCriticalSection(&lock->native.csec);

	return 0;

}

int git_rwlock_free(git_rwlock *lock)

{

	if (!win32_srwlock_initialize)

		DeleteCriticalSection(&lock->native.csec);

	git__memzero(lock, sizeof(*lock));

	return 0;

}