src/global.c - third_party/libgit2 - Git at Google

 /*
  * 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 "common.h"
 #include "global.h"
 #include "hash.h"
 #include "sysdir.h"
 #include "git2/global.h"
 #include "git2/sys/openssl.h"
 #include "thread-utils.h"


 git_mutex git__mwindow_mutex;

 #define MAX_SHUTDOWN_CB 8

 #ifdef GIT_OPENSSL
 # include <openssl/ssl.h>
 SSL_CTX *git__ssl_ctx;
 # ifdef GIT_THREADS
 static git_mutex *openssl_locks;
 # endif
 #endif

 static git_global_shutdown_fn git__shutdown_callbacks[MAX_SHUTDOWN_CB];
 static git_atomic git__n_shutdown_callbacks;
 static git_atomic git__n_inits;

 void git__on_shutdown(git_global_shutdown_fn callback)
 {
 	int count = git_atomic_inc(&git__n_shutdown_callbacks);
 	assert(count <= MAX_SHUTDOWN_CB && count > 0);
 	git__shutdown_callbacks[count - 1] = callback;
 }

 static void git__global_state_cleanup(git_global_st *st)
 {
 	if (!st)
 		return;

 	git__free(st->error_t.message);
 	st->error_t.message = NULL;
 }

 static void git__shutdown(void)
 {
 	int pos;

 	/* Shutdown subsystems that have registered */
 	for (pos = git_atomic_get(&git__n_shutdown_callbacks); pos > 0; pos = git_atomic_dec(&git__n_shutdown_callbacks)) {
 		git_global_shutdown_fn cb = git__swap(git__shutdown_callbacks[pos - 1], NULL);
 		if (cb != NULL)
 			cb();
 	}
 }

 #if defined(GIT_THREADS) && defined(GIT_OPENSSL)
 void openssl_locking_function(int mode, int n, const char *file, int line)
 {
 	int lock;

 	GIT_UNUSED(file);
 	GIT_UNUSED(line);

 	lock = mode & CRYPTO_LOCK;

 	if (lock) {
 		git_mutex_lock(&openssl_locks[n]);
 	} else {
 		git_mutex_unlock(&openssl_locks[n]);
 	}
 }

 static void shutdown_ssl_locking(void)
 {
 	int num_locks, i;

 	num_locks = CRYPTO_num_locks();
 	CRYPTO_set_locking_callback(NULL);

 	for (i = 0; i < num_locks; ++i)
 		git_mutex_free(openssl_locks);
 	git__free(openssl_locks);
 }
 #endif

 static void init_ssl(void)
 {
 #ifdef GIT_OPENSSL
 	long ssl_opts = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3;

 	/* Older OpenSSL and MacOS OpenSSL doesn't have this */
 #ifdef SSL_OP_NO_COMPRESSION
 	ssl_opts |= SSL_OP_NO_COMPRESSION;
 #endif

 	SSL_load_error_strings();
 	OpenSSL_add_ssl_algorithms();
 	/*
 	 * Load SSLv{2,3} and TLSv1 so that we can talk with servers
 	 * which use the SSL hellos, which are often used for
 	 * compatibility. We then disable SSL so we only allow OpenSSL
 	 * to speak TLSv1 to perform the encryption itself.
 	 */
 	git__ssl_ctx = SSL_CTX_new(SSLv23_method());
 	SSL_CTX_set_options(git__ssl_ctx, ssl_opts);
 	SSL_CTX_set_mode(git__ssl_ctx, SSL_MODE_AUTO_RETRY);
 	SSL_CTX_set_verify(git__ssl_ctx, SSL_VERIFY_NONE, NULL);
 	if (!SSL_CTX_set_default_verify_paths(git__ssl_ctx)) {
 		SSL_CTX_free(git__ssl_ctx);
 		git__ssl_ctx = NULL;
 	}
 #endif
 }

 int git_openssl_set_locking(void)
 {
 #ifdef GIT_OPENSSL
 # ifdef GIT_THREADS
 	int num_locks, i;

 	num_locks = CRYPTO_num_locks();
 	openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
 	GITERR_CHECK_ALLOC(openssl_locks);

 	for (i = 0; i < num_locks; i++) {
 		if (git_mutex_init(&openssl_locks[i]) != 0) {
 			giterr_set(GITERR_SSL, "failed to initialize openssl locks");
 			return -1;
 		}
 	}

 	CRYPTO_set_locking_callback(openssl_locking_function);
 	git__on_shutdown(shutdown_ssl_locking);
 	return 0;
 # else
 	giterr_set(GITERR_THREAD, "libgit2 as not built with threads");
 	return -1;
 # endif
 #else
 	giterr_set(GITERR_SSL, "libgit2 was not built with OpenSSL support");
 	return -1;
 #endif
 }

 /**
  * Handle the global state with TLS
  *
  * If libgit2 is built with GIT_THREADS enabled,
  * the `git_libgit2_init()` function must be called
  * before calling any other function of the library.
  *
  * This function allocates a TLS index (using pthreads
  * or the native Win32 API) to store the global state
  * on a per-thread basis.
  *
  * Any internal method that requires global state will
  * then call `git__global_state()` which returns a pointer
  * to the global state structure; this pointer is lazily
  * allocated on each thread.
  *
  * Before shutting down the library, the
  * `git_libgit2_shutdown` method must be called to free
  * the previously reserved TLS index.
  *
  * If libgit2 is built without threading support, the
  * `git__global_statestate()` call returns a pointer to a single,
  * statically allocated global state. The `git_thread_`
  * functions are not available in that case.
  */

 /*
  * `git_libgit2_init()` allows subsystems to perform global setup,
  * which may take place in the global scope.  An explicit memory
  * fence exists at the exit of `git_libgit2_init()`.  Without this,
  * CPU cores are free to reorder cache invalidation of `_tls_init`
  * before cache invalidation of the subsystems' newly written global
  * state.
  */
 #if defined(GIT_THREADS) && defined(GIT_WIN32)

 static DWORD _tls_index;
 static volatile LONG _mutex = 0;

 static int synchronized_threads_init(void)
 {
 	int error;

 	_tls_index = TlsAlloc();
 	if (git_mutex_init(&git__mwindow_mutex))
 		return -1;

 	/* Initialize any other subsystems that have global state */
 	if ((error = git_hash_global_init()) >= 0)
 		error = git_sysdir_global_init();

 	win32_pthread_initialize();

 	return error;
 }

 int git_libgit2_init(void)
 {
 	int ret;

 	/* Enter the lock */
 	while (InterlockedCompareExchange(&_mutex, 1, 0)) { Sleep(0); }

 	/* Only do work on a 0 -> 1 transition of the refcount */
 	if ((ret = git_atomic_inc(&git__n_inits)) == 1) {
 		if (synchronized_threads_init() < 0)
 			ret = -1;
 	}

 	/* Exit the lock */
 	InterlockedExchange(&_mutex, 0);

 	return ret;
 }

 static void synchronized_threads_shutdown(void)
 {
 	/* Shut down any subsystems that have global state */
 	git__shutdown();

 	git__free_tls_data();

 	TlsFree(_tls_index);
 	git_mutex_free(&git__mwindow_mutex);
 }

 int git_libgit2_shutdown(void)
 {
 	int ret;

 	/* Enter the lock */
 	while (InterlockedCompareExchange(&_mutex, 1, 0)) { Sleep(0); }

 	/* Only do work on a 1 -> 0 transition of the refcount */
 	if ((ret = git_atomic_dec(&git__n_inits)) == 0)
 		synchronized_threads_shutdown();

 	/* Exit the lock */
 	InterlockedExchange(&_mutex, 0);

 	return ret;
 }

 git_global_st *git__global_state(void)
 {
 	void *ptr;

 	assert(git_atomic_get(&git__n_inits) > 0);

 	if ((ptr = TlsGetValue(_tls_index)) != NULL)
 		return ptr;

 	ptr = git__malloc(sizeof(git_global_st));
 	if (!ptr)
 		return NULL;

 	memset(ptr, 0x0, sizeof(git_global_st));
 	TlsSetValue(_tls_index, ptr);
 	return ptr;
 }

 /**
  * Free the TLS data associated with this thread.
  * This should only be used by the thread as it
  * is exiting.
  */
 void git__free_tls_data(void)
 {
 	void *ptr = TlsGetValue(_tls_index);
 	if (!ptr)
 		return;

 	git__global_state_cleanup(ptr);
 	git__free(ptr);
 	TlsSetValue(_tls_index, NULL);
 }

 #elif defined(GIT_THREADS) && defined(_POSIX_THREADS)

 static pthread_key_t _tls_key;
 static pthread_once_t _once_init = PTHREAD_ONCE_INIT;
 int init_error = 0;

 static void cb__free_status(void *st)
 {
 	git__global_state_cleanup(st);
 	git__free(st);
 }

 static void init_once(void)
 {
 	if ((init_error = git_mutex_init(&git__mwindow_mutex)) != 0)
 		return;
 	pthread_key_create(&_tls_key, &cb__free_status);


 	/* Initialize any other subsystems that have global state */
 	if ((init_error = git_hash_global_init()) >= 0)
 		init_error = git_sysdir_global_init();

 	/* OpenSSL needs to be initialized from the main thread */
 	init_ssl();

 	GIT_MEMORY_BARRIER;
 }

 int git_libgit2_init(void)
 {
 	int ret;

 	pthread_once(&_once_init, init_once);
 	ret = git_atomic_inc(&git__n_inits);

 	return init_error ? init_error : ret;
 }

 int git_libgit2_shutdown(void)
 {
 	void *ptr = NULL;
 	pthread_once_t new_once = PTHREAD_ONCE_INIT;
 	int ret;

 	if ((ret = git_atomic_dec(&git__n_inits)) != 0)
 		return ret;

 	/* Shut down any subsystems that have global state */
 	git__shutdown();

 	ptr = pthread_getspecific(_tls_key);
 	pthread_setspecific(_tls_key, NULL);

 	git__global_state_cleanup(ptr);
 	git__free(ptr);

 	pthread_key_delete(_tls_key);
 	git_mutex_free(&git__mwindow_mutex);
 	_once_init = new_once;

 	return 0;
 }

 git_global_st *git__global_state(void)
 {
 	void *ptr;

 	assert(git_atomic_get(&git__n_inits) > 0);

 	if ((ptr = pthread_getspecific(_tls_key)) != NULL)
 		return ptr;

 	ptr = git__malloc(sizeof(git_global_st));
 	if (!ptr)
 		return NULL;

 	memset(ptr, 0x0, sizeof(git_global_st));
 	pthread_setspecific(_tls_key, ptr);
 	return ptr;
 }

 #else

 static git_global_st __state;

 int git_libgit2_init(void)
 {
 	static int ssl_inited = 0;

 	if (!ssl_inited) {
 		init_ssl();
 		ssl_inited = 1;
 	}

 	return git_atomic_inc(&git__n_inits);
 }

 int git_libgit2_shutdown(void)
 {
 	int ret;

 	/* Shut down any subsystems that have global state */
 	if ((ret = git_atomic_dec(&git__n_inits)) != 0)
 		return ret;

 	git__shutdown();
 	git__global_state_cleanup(&__state);

 	return 0;
 }

 git_global_st *git__global_state(void)
 {
 	return &__state;
 }

 #endif /* GIT_THREADS */
	/*
	* 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 "common.h"
	#include "global.h"
	#include "hash.h"
	#include "sysdir.h"
	#include "git2/global.h"
	#include "git2/sys/openssl.h"
	#include "thread-utils.h"


	git_mutex git__mwindow_mutex;

	#define MAX_SHUTDOWN_CB 8

	#ifdef GIT_OPENSSL
	# include <openssl/ssl.h>
	SSL_CTX *git__ssl_ctx;
	# ifdef GIT_THREADS
	static git_mutex *openssl_locks;
	# endif
	#endif

	static git_global_shutdown_fn git__shutdown_callbacks[MAX_SHUTDOWN_CB];
	static git_atomic git__n_shutdown_callbacks;
	static git_atomic git__n_inits;

	void git__on_shutdown(git_global_shutdown_fn callback)
	{
	int count = git_atomic_inc(&git__n_shutdown_callbacks);
	assert(count <= MAX_SHUTDOWN_CB && count > 0);
	git__shutdown_callbacks[count - 1] = callback;
	}

	static void git__global_state_cleanup(git_global_st *st)
	{
	if (!st)
	return;

	git__free(st->error_t.message);
	st->error_t.message = NULL;
	}

	static void git__shutdown(void)
	{
	int pos;

	/* Shutdown subsystems that have registered */
	for (pos = git_atomic_get(&git__n_shutdown_callbacks); pos > 0; pos = git_atomic_dec(&git__n_shutdown_callbacks)) {
	git_global_shutdown_fn cb = git__swap(git__shutdown_callbacks[pos - 1], NULL);
	if (cb != NULL)
	cb();
	}
	}

	#if defined(GIT_THREADS) && defined(GIT_OPENSSL)
	void openssl_locking_function(int mode, int n, const char *file, int line)
	{
	int lock;

	GIT_UNUSED(file);
	GIT_UNUSED(line);

	lock = mode & CRYPTO_LOCK;

	if (lock) {
	git_mutex_lock(&openssl_locks[n]);
	} else {
	git_mutex_unlock(&openssl_locks[n]);
	}
	}

	static void shutdown_ssl_locking(void)
	{
	int num_locks, i;

	num_locks = CRYPTO_num_locks();
	CRYPTO_set_locking_callback(NULL);

	for (i = 0; i < num_locks; ++i)
	git_mutex_free(openssl_locks);
	git__free(openssl_locks);
	}
	#endif

	static void init_ssl(void)
	{
	#ifdef GIT_OPENSSL
	long ssl_opts = SSL_OP_NO_SSLv2 \| SSL_OP_NO_SSLv3;

	/* Older OpenSSL and MacOS OpenSSL doesn't have this */
	#ifdef SSL_OP_NO_COMPRESSION
	ssl_opts \|= SSL_OP_NO_COMPRESSION;
	#endif

	SSL_load_error_strings();
	OpenSSL_add_ssl_algorithms();
	/*
	* Load SSLv{2,3} and TLSv1 so that we can talk with servers
	* which use the SSL hellos, which are often used for
	* compatibility. We then disable SSL so we only allow OpenSSL
	* to speak TLSv1 to perform the encryption itself.
	*/
	git__ssl_ctx = SSL_CTX_new(SSLv23_method());
	SSL_CTX_set_options(git__ssl_ctx, ssl_opts);
	SSL_CTX_set_mode(git__ssl_ctx, SSL_MODE_AUTO_RETRY);
	SSL_CTX_set_verify(git__ssl_ctx, SSL_VERIFY_NONE, NULL);
	if (!SSL_CTX_set_default_verify_paths(git__ssl_ctx)) {
	SSL_CTX_free(git__ssl_ctx);
	git__ssl_ctx = NULL;
	}
	#endif
	}

	int git_openssl_set_locking(void)
	{
	#ifdef GIT_OPENSSL
	# ifdef GIT_THREADS
	int num_locks, i;

	num_locks = CRYPTO_num_locks();
	openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
	GITERR_CHECK_ALLOC(openssl_locks);

	for (i = 0; i < num_locks; i++) {
	if (git_mutex_init(&openssl_locks[i]) != 0) {
	giterr_set(GITERR_SSL, "failed to initialize openssl locks");
	return -1;
	}
	}

	CRYPTO_set_locking_callback(openssl_locking_function);
	git__on_shutdown(shutdown_ssl_locking);
	return 0;
	# else
	giterr_set(GITERR_THREAD, "libgit2 as not built with threads");
	return -1;
	# endif
	#else
	giterr_set(GITERR_SSL, "libgit2 was not built with OpenSSL support");
	return -1;
	#endif
	}

	/**
	* Handle the global state with TLS
	*
	* If libgit2 is built with GIT_THREADS enabled,
	* the `git_libgit2_init()` function must be called
	* before calling any other function of the library.
	*
	* This function allocates a TLS index (using pthreads
	* or the native Win32 API) to store the global state
	* on a per-thread basis.
	*
	* Any internal method that requires global state will
	* then call `git__global_state()` which returns a pointer
	* to the global state structure; this pointer is lazily
	* allocated on each thread.
	*
	* Before shutting down the library, the
	* `git_libgit2_shutdown` method must be called to free
	* the previously reserved TLS index.
	*
	* If libgit2 is built without threading support, the
	* `git__global_statestate()` call returns a pointer to a single,
	* statically allocated global state. The `git_thread_`
	* functions are not available in that case.
	*/

	/*
	* `git_libgit2_init()` allows subsystems to perform global setup,
	* which may take place in the global scope. An explicit memory
	* fence exists at the exit of `git_libgit2_init()`. Without this,
	* CPU cores are free to reorder cache invalidation of `_tls_init`
	* before cache invalidation of the subsystems' newly written global
	* state.
	*/
	#if defined(GIT_THREADS) && defined(GIT_WIN32)

	static DWORD _tls_index;
	static volatile LONG _mutex = 0;

	static int synchronized_threads_init(void)
	{
	int error;

	_tls_index = TlsAlloc();
	if (git_mutex_init(&git__mwindow_mutex))
	return -1;

	/* Initialize any other subsystems that have global state */
	if ((error = git_hash_global_init()) >= 0)
	error = git_sysdir_global_init();

	win32_pthread_initialize();

	return error;
	}

	int git_libgit2_init(void)
	{
	int ret;

	/* Enter the lock */
	while (InterlockedCompareExchange(&_mutex, 1, 0)) { Sleep(0); }

	/* Only do work on a 0 -> 1 transition of the refcount */
	if ((ret = git_atomic_inc(&git__n_inits)) == 1) {
	if (synchronized_threads_init() < 0)
	ret = -1;
	}

	/* Exit the lock */
	InterlockedExchange(&_mutex, 0);

	return ret;
	}

	static void synchronized_threads_shutdown(void)
	{
	/* Shut down any subsystems that have global state */
	git__shutdown();

	git__free_tls_data();

	TlsFree(_tls_index);
	git_mutex_free(&git__mwindow_mutex);
	}

	int git_libgit2_shutdown(void)
	{
	int ret;

	/* Enter the lock */
	while (InterlockedCompareExchange(&_mutex, 1, 0)) { Sleep(0); }

	/* Only do work on a 1 -> 0 transition of the refcount */
	if ((ret = git_atomic_dec(&git__n_inits)) == 0)
	synchronized_threads_shutdown();

	/* Exit the lock */
	InterlockedExchange(&_mutex, 0);

	return ret;
	}

	git_global_st *git__global_state(void)
	{
	void *ptr;

	assert(git_atomic_get(&git__n_inits) > 0);

	if ((ptr = TlsGetValue(_tls_index)) != NULL)
	return ptr;

	ptr = git__malloc(sizeof(git_global_st));
	if (!ptr)
	return NULL;

	memset(ptr, 0x0, sizeof(git_global_st));
	TlsSetValue(_tls_index, ptr);
	return ptr;
	}

	/**
	* Free the TLS data associated with this thread.
	* This should only be used by the thread as it
	* is exiting.
	*/
	void git__free_tls_data(void)
	{
	void *ptr = TlsGetValue(_tls_index);
	if (!ptr)
	return;

	git__global_state_cleanup(ptr);
	git__free(ptr);
	TlsSetValue(_tls_index, NULL);
	}

	#elif defined(GIT_THREADS) && defined(_POSIX_THREADS)

	static pthread_key_t _tls_key;
	static pthread_once_t _once_init = PTHREAD_ONCE_INIT;
	int init_error = 0;

	static void cb__free_status(void *st)
	{
	git__global_state_cleanup(st);
	git__free(st);
	}

	static void init_once(void)
	{
	if ((init_error = git_mutex_init(&git__mwindow_mutex)) != 0)
	return;
	pthread_key_create(&_tls_key, &cb__free_status);


	/* Initialize any other subsystems that have global state */
	if ((init_error = git_hash_global_init()) >= 0)
	init_error = git_sysdir_global_init();

	/* OpenSSL needs to be initialized from the main thread */
	init_ssl();

	GIT_MEMORY_BARRIER;
	}

	int git_libgit2_init(void)
	{
	int ret;

	pthread_once(&_once_init, init_once);
	ret = git_atomic_inc(&git__n_inits);

	return init_error ? init_error : ret;
	}

	int git_libgit2_shutdown(void)
	{
	void *ptr = NULL;
	pthread_once_t new_once = PTHREAD_ONCE_INIT;
	int ret;

	if ((ret = git_atomic_dec(&git__n_inits)) != 0)
	return ret;

	/* Shut down any subsystems that have global state */
	git__shutdown();

	ptr = pthread_getspecific(_tls_key);
	pthread_setspecific(_tls_key, NULL);

	git__global_state_cleanup(ptr);
	git__free(ptr);

	pthread_key_delete(_tls_key);
	git_mutex_free(&git__mwindow_mutex);
	_once_init = new_once;

	return 0;
	}

	git_global_st *git__global_state(void)
	{
	void *ptr;

	assert(git_atomic_get(&git__n_inits) > 0);

	if ((ptr = pthread_getspecific(_tls_key)) != NULL)
	return ptr;

	ptr = git__malloc(sizeof(git_global_st));
	if (!ptr)
	return NULL;

	memset(ptr, 0x0, sizeof(git_global_st));
	pthread_setspecific(_tls_key, ptr);
	return ptr;
	}

	#else

	static git_global_st __state;

	int git_libgit2_init(void)
	{
	static int ssl_inited = 0;

	if (!ssl_inited) {
	init_ssl();
	ssl_inited = 1;
	}

	return git_atomic_inc(&git__n_inits);
	}

	int git_libgit2_shutdown(void)
	{
	int ret;

	/* Shut down any subsystems that have global state */
	if ((ret = git_atomic_dec(&git__n_inits)) != 0)
	return ret;

	git__shutdown();
	git__global_state_cleanup(&__state);

	return 0;
	}

	git_global_st *git__global_state(void)
	{
	return &__state;
	}

	#endif /* GIT_THREADS */