thodg/libgit2/src/global.c

• Show log

  Commit

• Hash : b35c3098
  Author :
  Date : 2018-02-28T12:06:59
  

  curl: explicitly initialize and cleanup global curl state Our curl-based streams make use of the easy curl interface. This interface automatically initializes and de-initializes the global curl state by calling out to `curl_global_init` and `curl_global_cleanup`. Thus, all global state will be repeatedly re-initialized when creating multiple curl streams in succession. Despite being inefficient, this is not thread-safe due to `curl_global_init` being not thread-safe itself. Thus a multi-threaded programing handling multiple curl streams at the same time is inherently racy. Fix the issue by globally initializing and cleaning up curl's state.

Download

• src/global.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 "common.h"
  #include "global.h"
  #include "hash.h"
  #include "sysdir.h"
  #include "filter.h"
  #include "merge_driver.h"
  #include "curl_stream.h"
  #include "openssl_stream.h"
  #include "thread-utils.h"
  #include "git2/global.h"
  #include "transports/ssh.h"
  
  #if defined(GIT_MSVC_CRTDBG)
  #include "win32/w32_stack.h"
  #include "win32/w32_crtdbg_stacktrace.h"
  #endif
  
  git_mutex git__mwindow_mutex;
  
  #define MAX_SHUTDOWN_CB 10
  
  static git_global_shutdown_fn git__shutdown_callbacks[MAX_SHUTDOWN_CB];
  static git_atomic git__n_shutdown_callbacks;
  static git_atomic git__n_inits;
  char *git__user_agent;
  char *git__ssl_ciphers;
  
  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 int init_common(void)
  {
  	int ret;
  
  	/* Initialize the CRT debug allocator first, before our first malloc */
  #if defined(GIT_MSVC_CRTDBG)
  	git_win32__crtdbg_stacktrace_init();
  	git_win32__stack_init();
  #endif
  
  	/* Initialize any other subsystems that have global state */
  	if ((ret = git_hash_global_init()) == 0 &&
  		(ret = git_sysdir_global_init()) == 0 &&
  		(ret = git_filter_global_init()) == 0 &&
  		(ret = git_merge_driver_global_init()) == 0 &&
  		(ret = git_transport_ssh_global_init()) == 0 &&
  		(ret = git_openssl_stream_global_init()) == 0 &&
  		(ret = git_curl_stream_global_init()) == 0)
  		ret = git_mwindow_global_init();
  
  	GIT_MEMORY_BARRIER;
  
  	return ret;
  }
  
  static void shutdown_common(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();
  	}
  
  	git__free(git__user_agent);
  	git__free(git__ssl_ciphers);
  }
  
  /**
   * 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();
  
  	git_threads_init();
  
  	if (git_mutex_init(&git__mwindow_mutex))
  		return -1;
  
  	error = init_common();
  
  	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;
  }
  
  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) {
  		shutdown_common();
  
  		git__free_tls_data();
  
  		TlsFree(_tls_index);
  		git_mutex_free(&git__mwindow_mutex);
  
  #if defined(GIT_MSVC_CRTDBG)
  		git_win32__crtdbg_stacktrace_cleanup();
  		git_win32__stack_cleanup();
  #endif
  	}
  
  	/* Exit the lock */
  	InterlockedExchange(&_mutex, 0);
  
  	return ret;
  }
  
  git_global_st *git__global_state(void)
  {
  	git_global_st *ptr;
  
  	assert(git_atomic_get(&git__n_inits) > 0);
  
  	if ((ptr = TlsGetValue(_tls_index)) != NULL)
  		return ptr;
  
  	ptr = git__calloc(1, sizeof(git_global_st));
  	if (!ptr)
  		return NULL;
  
  	git_buf_init(&ptr->error_buf, 0);
  
  	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);
  }
  
  BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
  {
  	GIT_UNUSED(hInstDll);
  	GIT_UNUSED(lpvReserved);
  
  	/* This is how Windows lets us know our thread is being shut down */
  	if (fdwReason == DLL_THREAD_DETACH) {
  		git__free_tls_data();
  	}
  
  	/*
  	 * Windows pays attention to this during library loading. We don't do anything
  	 * so we trivially succeed.
  	 */
  	return TRUE;
  }
  
  #elif defined(GIT_THREADS) && defined(_POSIX_THREADS)
  
  static pthread_key_t _tls_key;
  static pthread_mutex_t _init_mutex = PTHREAD_MUTEX_INITIALIZER;
  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);
  
  	init_error = init_common();
  }
  
  int git_libgit2_init(void)
  {
  	int ret, err;
  
  	ret = git_atomic_inc(&git__n_inits);
  
  	if ((err = pthread_mutex_lock(&_init_mutex)) != 0)
  		return err;
  	err = pthread_once(&_once_init, init_once);
  	err |= pthread_mutex_unlock(&_init_mutex);
  
  	if (err || init_error)
  		return err | init_error;
  
  	return 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;
  
  	if ((ret = pthread_mutex_lock(&_init_mutex)) != 0)
  		return ret;
  
  	/* Shut down any subsystems that have global state */
  	shutdown_common();
  
  	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;
  
  	if ((ret = pthread_mutex_unlock(&_init_mutex)) != 0)
  		return ret;
  
  	return 0;
  }
  
  git_global_st *git__global_state(void)
  {
  	git_global_st *ptr;
  
  	assert(git_atomic_get(&git__n_inits) > 0);
  
  	if ((ptr = pthread_getspecific(_tls_key)) != NULL)
  		return ptr;
  
  	ptr = git__calloc(1, sizeof(git_global_st));
  	if (!ptr)
  		return NULL;
  
  	git_buf_init(&ptr->error_buf, 0);
  	pthread_setspecific(_tls_key, ptr);
  	return ptr;
  }
  
  #else
  
  static git_global_st __state;
  
  int git_libgit2_init(void)
  {
  	int ret;
  
  	/* Only init subsystems the first time */
  	if ((ret = git_atomic_inc(&git__n_inits)) != 1)
  		return ret;
  
  	if ((ret = init_common()) < 0)
  		return ret;
  
  	return 1;
  }
  
  int git_libgit2_shutdown(void)
  {
  	int ret;
  
  	/* Shut down any subsystems that have global state */
  	if ((ret = git_atomic_dec(&git__n_inits)) == 0) {
  		shutdown_common();
  		git__global_state_cleanup(&__state);
  		memset(&__state, 0, sizeof(__state));
  	}
  
  	return ret;
  }
  
  git_global_st *git__global_state(void)
  {
  	return &__state;
  }
  
  #endif /* GIT_THREADS */
  

Download