passenger 3.0.21 → 3.9.1.beta

data/ext/nginx/ContentHandler.h

@@ -33,7 +33,7 @@
 
 
 typedef enum {
-    AP_RAILS,
+    AP_CLASSIC_RAILS,
     AP_RACK,
     AP_WSGI,
     AP_NONE

data/ext/nginx/config

@@ -1,12 +1,14 @@
-if ! test -f "$ngx_addon_dir/../common/libpassenger_common.a" || \
-   ! test -f "$ngx_addon_dir/../common/libboost_oxt.a"; then
+PATH="$ngx_addon_dir/../../bin:$PATH"
+export PATH
+
+if test "x$PASSENGER_LIBS" = "x" && ! passenger-config --compiled; then
     echo "*** The Phusion Passenger support files are not yet compiled. Compiling them for you... ***"
-    echo "*** Running 'rake nginx RELEASE=yes' in $ngx_addon_dir... ***"
+    echo "*** Running 'rake nginx CACHING=false' in $ngx_addon_dir... ***"
     old_dir=`pwd`
     if ! cd $ngx_addon_dir; then
         exit 1
     fi
-    if ! rake nginx RELEASE=yes; then
+    if ! rake nginx CACHING=false; then
         exit 1
     fi
     cd "$old_dir"
@@ -25,11 +27,13 @@ NGX_ADDON_DEPS="$NGX_ADDON_DEPS \
     ${ngx_addon_dir}/ContentHandler.h \
     ${ngx_addon_dir}/StaticContentHandler.h \
     ${ngx_addon_dir}/ngx_http_passenger_module.h \
-    ${ngx_addon_dir}/../common/Constants.h"
-CORE_LIBS="$CORE_LIBS  \
-    ${ngx_addon_dir}/../common/libpassenger_common.a \
-    ${ngx_addon_dir}/../common/libboost_oxt.a \
-    -lstdc++ -lpthread"
+    `passenger-config --root`/ext/common/Constants.h"
+if test "x$PASSENGER_LIBS" = "x"; then
+    CORE_LIBS="$CORE_LIBS `passenger-config --nginx-libs`"
+else
+    CORE_LIBS="$CORE_LIBS $PASSENGER_LIBS"
+fi
+CORE_LIBS="$CORE_LIBS -lstdc++ -lpthread"
 
 ngx_feature="Math library"
 ngx_feature_name=

data/ext/nginx/ngx_http_passenger_module.c

@@ -86,8 +86,7 @@ register_content_handler(ngx_conf_t *cf)
 */
 
 static void
-ignore_sigpipe()
-{
+ignore_sigpipe() {
     struct sigaction action;
     
     action.sa_handler = SIG_IGN;
@@ -96,7 +95,7 @@ ignore_sigpipe()
     sigaction(SIGPIPE, &action, NULL);
 }
 
-char *
+static char *
 ngx_str_null_terminate(ngx_str_t *str) {
     char *result = malloc(str->len + 1);
     memcpy(result, str->data, str->len);
@@ -232,7 +231,6 @@ start_helper_server(ngx_cycle_t *cycle) {
     char   *default_user = NULL;
     char   *default_group = NULL;
     char   *passenger_root = NULL;
-    char   *ruby = NULL;
     char   *analytics_log_dir;
     char   *analytics_log_user;
     char   *analytics_log_group;
@@ -251,7 +249,6 @@ start_helper_server(ngx_cycle_t *cycle) {
     default_user   = ngx_str_null_terminate(&passenger_main_conf.default_user);
     default_group  = ngx_str_null_terminate(&passenger_main_conf.default_group);
     passenger_root = ngx_str_null_terminate(&passenger_main_conf.root_dir);
-    ruby           = ngx_str_null_terminate(&passenger_main_conf.ruby);
     analytics_log_dir = ngx_str_null_terminate(&passenger_main_conf.analytics_log_dir);
     analytics_log_user = ngx_str_null_terminate(&passenger_main_conf.analytics_log_user);
     analytics_log_group = ngx_str_null_terminate(&passenger_main_conf.analytics_log_group);
@@ -279,7 +276,7 @@ start_helper_server(ngx_cycle_t *cycle) {
         "", passenger_main_conf.user_switching,
         default_user, default_group,
         core_conf->user, core_conf->group,
-        passenger_root, ruby, passenger_main_conf.max_pool_size,
+        passenger_root, "ruby", passenger_main_conf.max_pool_size,
         passenger_main_conf.max_instances_per_app,
         passenger_main_conf.pool_idle_time,
         "",
@@ -354,7 +351,6 @@ cleanup:
     free(default_user);
     free(default_group);
     free(passenger_root);
-    free(ruby);
     free(analytics_log_dir);
     free(analytics_log_user);
     free(analytics_log_group);

data/ext/oxt/detail/backtrace_enabled.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2010 Phusion
+ * Copyright (c) 2010, 2011, 2012 Phusion
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -27,32 +27,10 @@
 
 #define OXT_BACKTRACE_IS_ENABLED
 
-#include <boost/thread/mutex.hpp>
 #include <boost/current_function.hpp>
-#include <exception>
-#include <string>
-#include <list>
-#include <vector>
-#include "../spin_lock.hpp"
-#include "../macros.hpp"
 
 namespace oxt {
 
-using namespace std;
-using namespace boost;
-struct trace_point;
-class tracable_exception;
-struct thread_registration;
-
-extern boost::mutex _thread_registration_mutex;
-extern list<thread_registration *> _registered_threads;
-
-void   _init_backtrace_tls();
-void   _finalize_backtrace_tls();
-bool   _get_backtrace_list_and_its_lock(vector<trace_point *> **backtrace_list, spin_lock **lock);
-string _format_backtrace(const list<trace_point *> *backtrace_list);
-string _format_backtrace(const vector<trace_point *> *backtrace_list);
-
 /**
  * A single point in a backtrace. Creating this object will cause it
  * to push itself to the thread's backtrace list. This backtrace list
@@ -61,9 +39,6 @@ string _format_backtrace(const vector<trace_point *> *backtrace_list);
  * backtrace list.
  *
  * Except if you set the 'detached' argument to true.
- *
- * Implementation detail - do not use directly!
- * @internal
  */
 struct trace_point {
 	const char *function;
@@ -71,86 +46,14 @@ struct trace_point {
 	unsigned int line;
 	bool m_detached;
 	
-	trace_point(const char *function, const char *source, unsigned int line) {
-		this->function = function;
-		this->source = source;
-		this->line = line;
-		m_detached = false;
-		
-		vector<trace_point *> *backtrace_list;
-		spin_lock *lock;
-		if (OXT_LIKELY(_get_backtrace_list_and_its_lock(&backtrace_list, &lock))) {
-			spin_lock::scoped_lock l(*lock);
-			backtrace_list->push_back(this);
-		}
-	}
-	
-	trace_point(const char *function, const char *source, unsigned int line, bool detached) {
-		this->function = function;
-		this->source = source;
-		this->line = line;
-		m_detached = true;
-	}
-
-	~trace_point() {
-		if (OXT_LIKELY(!m_detached)) {
-			vector<trace_point *> *backtrace_list;
-			spin_lock *lock;
-			if (OXT_LIKELY(_get_backtrace_list_and_its_lock(&backtrace_list, &lock))) {
-				spin_lock::scoped_lock l(*lock);
-				backtrace_list->pop_back();
-			}
-		}
-	}
-
-	void update(const char *source, unsigned int line) {
-		this->source = source;
-		this->line = line;
-	}
+	trace_point(const char *function, const char *source, unsigned int line);
+	trace_point(const char *function, const char *source, unsigned int line, bool detached);
+	~trace_point();
+	void update(const char *source, unsigned int line);
 };
 
 #define TRACE_POINT() oxt::trace_point __p(BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)
 #define TRACE_POINT_WITH_NAME(name) oxt::trace_point __p(name, __FILE__, __LINE__)
 #define UPDATE_TRACE_POINT() __p.update(__FILE__, __LINE__)
 
-/**
- * @internal
- */
-struct thread_registration {
-	string name;
-	spin_lock *backtrace_lock;
-	vector<trace_point *> *backtrace;
-};
-
-/**
- * @internal
- */
-struct initialize_backtrace_support_for_this_thread {
-	thread_registration *registration;
-	list<thread_registration *>::iterator it;
-	
-	initialize_backtrace_support_for_this_thread(const string &name) {
-		_init_backtrace_tls();
-		registration = new thread_registration();
-		registration->name = name;
-		_get_backtrace_list_and_its_lock(&registration->backtrace,
-			&registration->backtrace_lock);
-		
-		boost::mutex::scoped_lock l(_thread_registration_mutex);
-		_registered_threads.push_back(registration);
-		it = _registered_threads.end();
-		it--;
-	}
-	
-	~initialize_backtrace_support_for_this_thread() {
-		{
-			boost::mutex::scoped_lock l(_thread_registration_mutex);
-			_registered_threads.erase(it);
-			delete registration;
-		}
-		_finalize_backtrace_tls();
-	}
-};
-
 } // namespace oxt
-

data/ext/oxt/detail/context.hpp

@@ -0,0 +1,90 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2012 Phusion
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef _OXT_DETAIL_CONTEXT_HPP_
+#define _OXT_DETAIL_CONTEXT_HPP_
+
+#include <boost/thread/mutex.hpp>
+#include <boost/shared_ptr.hpp>
+#include <list>
+#include <vector>
+#include <string>
+#include <pthread.h>
+#ifdef __linux__
+	#include <sys/types.h>
+#endif
+#include "../spin_lock.hpp"
+
+namespace oxt {
+
+
+struct thread_local_context;
+
+typedef boost::shared_ptr<thread_local_context> thread_local_context_ptr;
+
+struct global_context_t {
+	boost::mutex next_thread_number_mutex;
+	/** Thread numbering begins at 2. The main thread has number 1.
+	 * A thread number of 0 is invalid. */
+	unsigned int next_thread_number;
+
+	boost::mutex thread_registration_mutex;
+	std::list<thread_local_context_ptr> registered_threads;
+
+	global_context_t();
+};
+
+struct thread_local_context {
+	std::list<thread_local_context_ptr>::iterator iterator;
+
+	pthread_t thread;
+	#ifdef __linux__
+		pid_t tid;
+	#endif
+	unsigned int thread_number;
+	std::string thread_name;
+
+	/** This lock is normally locked, but only unlocked during an oxt::sycall function,
+	 * and is relocked when that function returns. One can use try_lock to find out
+	 * whether the code is inside an oxt::syscall function.
+	 */
+	spin_lock syscall_interruption_lock;
+
+	#ifdef OXT_BACKTRACE_IS_ENABLED
+		std::vector<trace_point *> backtrace_list;
+		spin_lock backtrace_lock;
+	#endif
+	
+	static thread_local_context_ptr make_shared_ptr();
+
+	thread_local_context();
+};
+
+
+thread_local_context *get_thread_local_context();
+
+
+} // namespace oxt
+
+#endif /* _OXT_DETAIL_CONTEXT_HPP_ */

data/ext/oxt/detail/spin_lock_darwin.hpp

@@ -64,6 +64,10 @@ public:
 	void unlock() {
 		OSSpinLockUnlock(&spin);
 	}
+
+	bool try_lock() {
+		return OSSpinLockTry(&spin);
+	}
 };
 
 } // namespace oxt

data/ext/oxt/detail/spin_lock_gcc_x86.hpp

@@ -75,6 +75,10 @@ public:
 	void unlock() {
 		__sync_lock_release(&exclusion);
 	}
+
+	bool try_lock() {
+		return !__sync_lock_test_and_set(&exclusion, 1);
+	}
 };
 
 } // namespace oxt

data/ext/oxt/detail/spin_lock_pthreads.hpp

@@ -91,6 +91,20 @@ public:
 			throw boost::thread_resource_error("Cannot unlock spin lock", ret);
 		}
 	}
+
+	void try_lock() {
+		int ret;
+		do {
+			ret = pthread_spin_trylock(&spin);
+		} while (OXT_UNLIKELY(ret == EINTR));
+		if (ret == 0) {
+			return true;
+		} else if (ret == EBUSY) {
+			return false;
+		} else {
+			throw boost::thread_resource_error("Cannot lock spin lock", ret);
+		}
+	}
 };
 
 } // namespace oxt

data/ext/oxt/detail/tracable_exception_enabled.hpp

@@ -24,7 +24,7 @@
  */
 #include <string>
 #include <exception>
-#include <list>
+#include <vector>
 
 namespace oxt {
 
@@ -35,7 +35,7 @@ struct trace_point;
  */
 class tracable_exception: public std::exception {
 private:
-	std::list<trace_point *> backtrace_copy;
+	std::vector<trace_point *> backtrace_copy;
 public:
 	tracable_exception();
 	tracable_exception(const tracable_exception &other);

data/ext/oxt/dynamic_thread_group.hpp

@@ -128,7 +128,7 @@ public:
 	 * @throws thread_resource_error Cannot create a thread.
 	 * @post this->num_threads() == old->num_threads() + 1
 	 */
-	void create_thread(boost::function<void ()> &func, const string &name = "", unsigned int stack_size = 0) {
+	void create_thread(const boost::function<void ()> &func, const string &name = "", unsigned int stack_size = 0) {
 		boost::lock_guard<boost::mutex> l(lock);
 		thread_handle_ptr handle(new thread_handle());
 		thread_handles.push_back(handle);
@@ -181,6 +181,32 @@ public:
 		thread::interrupt_and_join_multiple(threads, nthreads_copy);
 	}
 	
+	void join_all() {
+		// See comments from interrupt_and_join_all().
+		boost::unique_lock<boost::mutex> l(lock);
+		list<thread_handle_ptr> thread_handles_copy;
+		list<thread_handle_ptr>::iterator it;
+		thread_handle_ptr handle;
+		unsigned int nthreads_copy = nthreads;
+		thread *threads[nthreads];
+		unsigned int i = 0;
+		
+		// We make a copy so that the handles aren't destroyed prematurely.
+		thread_handles_copy = thread_handles;
+		for (it = thread_handles.begin(); it != thread_handles.end(); it++, i++) {
+			handle = *it;
+			handle->removed_from_list = true;
+			threads[i] = handle->thr;
+		}
+		thread_handles.clear();
+		nthreads = 0;
+		
+		l.unlock();
+		for (i = 0; i < nthreads_copy; i++) {
+			threads[i]->join();
+		}
+	}
+	
 	/**
 	 * Returns the number of threads currently in this thread group.
 	 */

data/ext/oxt/implementation.cpp

@@ -0,0 +1,415 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008-2012 Phusion
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <boost/thread/mutex.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/make_shared.hpp>
+#include "tracable_exception.hpp"
+#include "backtrace.hpp"
+#include "macros.hpp"
+#include "thread.hpp"
+#include "spin_lock.hpp"
+#include "detail/context.hpp"
+#ifdef __linux__
+	#include <sys/syscall.h>
+#endif
+
+#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+	#include <cassert>
+	#include <sstream>
+	#include <cstring>
+#endif
+
+
+namespace oxt {
+
+using namespace std;
+using namespace boost;
+
+
+static global_context_t *global_context = NULL;
+
+
+/*
+ * boost::thread_specific_storage is pretty expensive. So we use the __thread
+ * keyword whenever possible - that's almost free.
+ */
+#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+	static __thread thread_local_context_ptr *local_context = NULL;
+
+	static void
+	init_thread_local_context_support() {
+		/* Do nothing. */
+	}
+	
+	static void
+	set_thread_local_context(const thread_local_context_ptr &ctx) {
+		local_context = new thread_local_context_ptr(ctx);
+	}
+
+	static void
+	free_thread_local_context() {
+		delete local_context;
+		local_context = NULL;
+	}
+
+	thread_local_context *
+	get_thread_local_context() {
+		if (OXT_LIKELY(local_context != NULL)) {
+			return local_context->get();
+		} else {
+			return NULL;
+		}
+	}
+#else
+	/*
+	 * This is a *pointer* to a thread_specific_ptr because, once
+	 * we've created a thread_specific_ptr, we never want to destroy it
+	 * in order to avoid C++'s global variable destruction. All kinds
+	 * of cleanup code may depend on local_context and because global
+	 * variable destruction order is undefined, we just want to keep
+	 * this object alive until the OS cleans it up.
+	 */
+	static thread_specific_ptr<thread_local_context_ptr> *local_context = NULL;
+	
+	static void
+	init_thread_local_context_support() {
+		local_context = new thread_specific_ptr<thread_local_context_ptr>();
+	}
+
+	static void
+	set_thread_local_context(const thread_local_context_ptr &ctx) {
+		if (local_context != NULL) {
+			local_context->reset(new thread_local_context_ptr(ctx));
+		}
+	}
+
+	static void
+	free_thread_local_context() {
+		if (local_context != NULL) {
+			local_context->reset();
+		}
+	}
+
+	thread_local_context *
+	get_thread_local_context() {
+		if (OXT_LIKELY(local_context != NULL)) {
+			thread_local_context_ptr *pointer = local_context->get();
+			if (OXT_LIKELY(pointer != NULL)) {
+				return pointer->get();
+			} else {
+				return NULL;
+			}
+		} else {
+			return NULL;
+		}
+	}
+#endif
+
+
+#ifdef OXT_BACKTRACE_IS_ENABLED
+
+trace_point::trace_point(const char *_function, const char *_source, unsigned int _line)
+	: function(_function),
+	  source(_source),
+	  line(_line),
+	  m_detached(false)
+{
+	thread_local_context *ctx = get_thread_local_context();
+	if (OXT_LIKELY(ctx != NULL)) {
+		spin_lock::scoped_lock l(ctx->backtrace_lock);
+		ctx->backtrace_list.push_back(this);
+	} else {
+		m_detached = true;
+	}
+}
+
+trace_point::trace_point(const char *_function, const char *_source, unsigned int _line, bool detached)
+	: function(_function),
+	  source(_source),
+	  line(_line),
+	  m_detached(true)
+{ }
+
+trace_point::~trace_point() {
+	if (OXT_LIKELY(!m_detached)) {
+		thread_local_context *ctx = get_thread_local_context();
+		if (OXT_LIKELY(ctx != NULL)) {
+			spin_lock::scoped_lock l(ctx->backtrace_lock);
+			assert(!ctx->backtrace_list.empty());
+			ctx->backtrace_list.pop_back();
+		}
+	}
+}
+
+void
+trace_point::update(const char *source, unsigned int line) {
+	this->source = source;
+	this->line = line;
+}
+
+
+tracable_exception::tracable_exception() {
+	thread_local_context *ctx = get_thread_local_context();
+	if (OXT_LIKELY(ctx != NULL)) {
+		spin_lock::scoped_lock l(ctx->backtrace_lock);
+		vector<trace_point *>::const_iterator it, end = ctx->backtrace_list.end();
+		
+		backtrace_copy.reserve(ctx->backtrace_list.size());
+		for (it = ctx->backtrace_list.begin(); it != end; it++) {
+			trace_point *p = new trace_point(
+				(*it)->function,
+				(*it)->source,
+				(*it)->line,
+				true);
+			backtrace_copy.push_back(p);
+		}
+	}
+}
+
+tracable_exception::tracable_exception(const tracable_exception &other)
+	: std::exception()
+{
+	vector<trace_point *>::const_iterator it, end = other.backtrace_copy.end();
+	backtrace_copy.reserve(other.backtrace_copy.size());
+	for (it = other.backtrace_copy.begin(); it != end; it++) {
+		trace_point *p = new trace_point(
+			(*it)->function,
+			(*it)->source,
+			(*it)->line,
+			true);
+		backtrace_copy.push_back(p);
+	}
+}
+
+tracable_exception::~tracable_exception() throw() {
+	vector<trace_point *>::iterator it, end = backtrace_copy.end();
+	for (it = backtrace_copy.begin(); it != end; it++) {
+		delete *it;
+	}
+}
+
+template<typename Collection>
+static string
+format_backtrace(const Collection &backtrace_list) {
+	if (backtrace_list.empty()) {
+		return "     (empty)";
+	} else {
+		backtrace_list.rbegin();
+		stringstream result;
+		typename Collection::const_reverse_iterator it;
+		
+		for (it = backtrace_list.rbegin(); it != backtrace_list.rend(); it++) {
+			const trace_point *p = *it;
+			
+			result << "     in '" << p->function << "'";
+			if (p->source != NULL) {
+				const char *source = strrchr(p->source, '/');
+				if (source != NULL) {
+					source++;
+				} else {
+					source = p->source;
+				}
+				result << " (" << source << ":" << p->line << ")";
+			}
+			result << endl;
+		}
+		return result.str();
+	}
+}
+
+string
+tracable_exception::backtrace() const throw() {
+	return format_backtrace< vector<trace_point *> >(backtrace_copy);
+}
+
+const char *
+tracable_exception::what() const throw() {
+	return "oxt::tracable_exception";
+}
+
+#endif /* OXT_BACKTRACE_IS_ENABLED */
+
+
+void initialize() {
+	global_context = new global_context_t();
+	init_thread_local_context_support();
+	// For some reason make_shared() crashes here when compiled with clang 3.2 on OS X.
+	// Clang bug? We use 'new' to work around it.
+	thread_local_context_ptr ctx = thread_local_context::make_shared_ptr();
+	ctx->thread_number = 1;
+	ctx->thread_name = "Main thread";
+	set_thread_local_context(ctx);
+}
+
+
+global_context_t::global_context_t()
+	: next_thread_number(2)
+{ }
+
+
+thread_local_context_ptr
+thread_local_context::make_shared_ptr() {
+	// For some reason make_shared() crashes here when compiled with clang 3.2 on OS X.
+	// Clang bug? We use 'new' to work around it.
+	return thread_local_context_ptr(new thread_local_context());
+}
+
+thread_local_context::thread_local_context()
+	: thread_number(0)
+{
+	thread = pthread_self();
+	#ifdef __linux__
+		tid = syscall(SYS_gettid);
+	#endif
+	syscall_interruption_lock.lock();
+	#ifdef OXT_BACKTRACE_IS_ENABLED
+		backtrace_list.reserve(50);
+	#endif
+}
+
+
+string
+thread::make_thread_name(const string &given_name) {
+	if (given_name.empty()) {
+		if (OXT_LIKELY(global_context != NULL)) {
+			stringstream str;
+			str << "Thread #";
+			{
+				lock_guard<boost::mutex> l(global_context->thread_registration_mutex);
+				str << global_context->next_thread_number;
+			}
+			return str.str();
+		} else {
+			return "(unknown)";
+		}
+	} else {
+		return given_name;
+	}
+}
+
+void
+thread::thread_main(const boost::function<void ()> func, thread_local_context_ptr ctx) {
+	set_thread_local_context(ctx);
+
+	if (OXT_LIKELY(global_context != NULL)) {
+		lock_guard<boost::mutex> l(global_context->thread_registration_mutex);
+
+		ctx->thread = pthread_self();
+		global_context->next_thread_number++;
+		global_context->registered_threads.push_back(ctx);
+		ctx->iterator = global_context->registered_threads.end();
+		ctx->iterator--;
+		// Set this after setting 'iterator' to indicate
+		// that push_back() has succeeded.
+		ctx->thread_number = global_context->next_thread_number;
+	}
+
+	try {
+		func();
+	} catch (const thread_interrupted &) {
+		// Do nothing.
+	}
+	// We don't care about other exceptions because they'll crash the process anyway.
+
+	if (OXT_LIKELY(global_context != NULL)) {
+		lock_guard<boost::mutex> l(global_context->thread_registration_mutex);
+		thread_local_context *ctx = get_thread_local_context();
+		if (ctx != 0 && ctx->thread_number != 0) {
+			global_context->registered_threads.erase(ctx->iterator);
+			ctx->thread_number = 0;
+		}
+	}
+	free_thread_local_context();
+}
+
+std::string
+thread::name() const throw() {
+	return context->thread_name;
+}
+
+std::string
+thread::backtrace() const throw() {
+	#ifdef OXT_BACKTRACE_IS_ENABLED
+		spin_lock::scoped_lock l(context->backtrace_lock);
+		return format_backtrace(context->backtrace_list);
+	#else
+		return "    (backtrace support disabled during compile time)";
+	#endif
+}
+
+string
+thread::all_backtraces() throw() {
+	#ifdef OXT_BACKTRACE_IS_ENABLED
+		if (OXT_LIKELY(global_context != NULL)) {
+			lock_guard<boost::mutex> l(global_context->thread_registration_mutex);
+			list<thread_local_context_ptr>::const_iterator it;
+			std::stringstream result;
+			
+			for (it = global_context->registered_threads.begin();
+			     it != global_context->registered_threads.end();
+			     it++)
+			{
+				thread_local_context_ptr ctx = *it;
+				result << "Thread '" << ctx->thread_name <<
+					"' (" << hex << showbase << ctx->thread << dec;
+				#ifdef __linux__
+					result << ", LWP " << ctx->tid;
+				#endif
+				result << "):" << endl;
+				
+				spin_lock::scoped_lock l(ctx->backtrace_lock);
+				std::string bt = format_backtrace(ctx->backtrace_list);
+				result << bt;
+				if (bt.empty() || bt[bt.size() - 1] != '\n') {
+					result << endl;
+				}
+				result << endl;
+			}
+			return result.str();
+		} else {
+			return "(OXT not initialized)";
+		}
+	#else
+		return "(backtrace support disabled during compile time)";
+	#endif
+}
+
+void
+thread::interrupt(bool interruptSyscalls) {
+	int ret;
+	
+	boost::thread::interrupt();
+	if (interruptSyscalls && context->syscall_interruption_lock.try_lock()) {
+		do {
+			ret = pthread_kill(native_handle(),
+				INTERRUPTION_SIGNAL);
+		} while (ret == EINTR);
+		context->syscall_interruption_lock.unlock();
+	}
+}
+
+
+} // namespace oxt