thodg/libgit2/src/win32/thread.c

• Show log

  Commit

• Hash : 0c7f49dd
  Author :
  Date : 2017-06-30T13:39:01
  

  Make sure to always include "common.h" first Next to including several files, our "common.h" header also declares various macros which are then used throughout the project. As such, we have to make sure to always include this file first in all implementation files. Otherwise, we might encounter problems or even silent behavioural differences due to macros or defines not being defined as they should be. So in fact, our header and implementation files should make sure to always include "common.h" first. This commit does so by establishing a common include pattern. Header files inside of "src" will now always include "common.h" as its first other file, separated by a newline from all the other includes to make it stand out as special. There are two cases for the implementation files. If they do have a matching header file, they will always include this one first, leading to "common.h" being transitively included as first file. If they do not have a matching header file, they instead include "common.h" as first file themselves. This fixes the outlined problems and will become our standard practice for header and source files inside of the "src/" from now on.

Download

• src/win32/thread.c

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

Download