passenger 2.0.6 → 2.1.2

data/ext/oxt/detail/backtrace_disabled.hpp

@@ -0,0 +1,39 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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 <exception>
+#include <string>
+
+// Dummy implementation for backtrace.hpp.
+// See detail/backtrace_enabled.hpp for API documentation.
+
+namespace oxt {
+
+#define TRACE_POINT() do { /* nothing */ } while (false)
+#define TRACE_POINT_WITH_NAME(name) do { /* nothing */ } while (false)
+#define UPDATE_TRACE_POINT() do { /* nothing */ } while (false)
+
+} // namespace oxt
+

data/ext/oxt/detail/backtrace_enabled.hpp

@@ -0,0 +1,155 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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.
+ */
+
+// Actual implementation for backtrace.hpp.
+
+#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;
+class trace_point;
+class tracable_exception;
+class thread_registration;
+
+extern boost::mutex _thread_registration_mutex;
+extern list<thread_registration *> _registered_threads;
+
+void                 _init_backtrace_tls();
+void                 _finalize_backtrace_tls();
+spin_lock           *_get_backtrace_lock();
+vector<trace_point *> *_get_current_backtrace();
+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
+ * is stored in a thread local storage, and so is unique for each
+ * thread. Upon destruction, the object will pop itself from the thread's
+ * backtrace list.
+ *
+ * Except if you set the 'detached' argument to true.
+ *
+ * Implementation detail - do not use directly!
+ * @internal
+ */
+struct trace_point {
+	const char *function;
+	const char *source;
+	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;
+		
+		spin_lock *lock = _get_backtrace_lock();
+		if (OXT_LIKELY(lock != NULL)) {
+			spin_lock::scoped_lock l(*lock);
+			_get_current_backtrace()->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)) {
+			spin_lock *lock = _get_backtrace_lock();
+			if (OXT_LIKELY(lock != NULL)) {
+				spin_lock::scoped_lock l(*lock);
+				_get_current_backtrace()->pop_back();
+			}
+		}
+	}
+
+	void update(const char *source, unsigned int line) {
+		this->source = source;
+		this->line = 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;
+		registration->backtrace_lock = _get_backtrace_lock();
+		registration->backtrace = _get_current_backtrace();
+		
+		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/spin_lock_gcc_x86.hpp

@@ -0,0 +1,82 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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/noncopyable.hpp>
+
+namespace oxt {
+
+/**
+ * A spin lock. It's more efficient than a mutex for locking very small
+ * critical sections with few contentions, but less efficient otherwise.
+ *
+ * The interface is similar to that of boost::mutex.
+ */
+class spin_lock {
+private:
+	int exclusion;
+
+public:
+	/**
+	 * Instantiate this class to lock a spin lock within a scope.
+	 */
+	class scoped_lock: boost::noncopyable {
+	private:
+		spin_lock &l;
+		
+	public:
+		scoped_lock(spin_lock &lock): l(lock) {
+			l.lock();
+		}
+		
+		~scoped_lock() {
+			l.unlock();
+		}
+	};
+
+	spin_lock(): exclusion(0) { }
+	
+	/**
+	 * Lock this spin lock.
+	 * @throws boost::thread_resource_error Something went wrong.
+	 */
+	void lock() {
+		while (__sync_lock_test_and_set(&exclusion, 1)) {
+			// Do nothing. This GCC builtin instruction
+			// ensures memory barrier.
+		}
+	}
+
+	/**
+	 * Unlock this spin lock.
+	 * @throws boost::thread_resource_error Something went wrong.
+	 */
+	void unlock() {
+		__sync_synchronize(); // Memory barrier.
+		exclusion = 0;
+	}
+};
+
+} // namespace oxt
+

data/ext/oxt/detail/spin_lock_portable.hpp

@@ -0,0 +1,38 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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.
+ */
+
+/*
+ * Portable implementation of a spin lock.
+ * This is actually just a mutex...
+ *
+ * See spin_lock_gcc_x86.hpp for API documentation.
+ */
+
+#include <boost/thread/mutex.hpp>
+
+namespace oxt {
+	typedef boost::mutex spin_lock;
+}
+

data/ext/oxt/detail/spin_lock_pthreads.hpp

@@ -0,0 +1,97 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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/noncopyable.hpp>
+#include <pthread.h>
+#include <errno.h>
+#include "../macros.hpp"
+
+/*
+ * Implementation of a spin lock using POSIX pthread spin locks.
+ *
+ * See spin_lock_gcc_x86.hpp for API documentation.
+ */
+
+namespace oxt {
+
+class spin_lock {
+private:
+	pthread_spinlock_t spin;
+
+public:
+	class scoped_lock: boost::noncopyable {
+	private:
+		spin_lock &l;
+		
+	public:
+		scoped_lock(spin_lock &lock): l(lock) {
+			l.lock();
+		}
+		
+		~scoped_lock() {
+			l.unlock();
+		}
+	};
+
+	spin_lock() {
+		int ret;
+		do {
+			ret = pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE);
+		} while (ret == EINTR);
+		if (ret != 0) {
+			throw boost::thread_resource_error("Cannot initialize a spin lock", ret);
+		}
+	}
+	
+	~spin_lock() {
+		int ret;
+		do {
+			ret = pthread_spin_destroy(&spin);
+		} while (ret == EINTR);
+	}
+	
+	void lock() {
+		int ret;
+		do {
+			ret = pthread_spin_lock(&spin);
+		} while (OXT_UNLIKELY(ret == EINTR));
+		if (OXT_UNLIKELY(ret != 0)) {
+			throw boost::thread_resource_error("Cannot lock spin lock", ret);
+		}
+	}
+
+	void unlock() {
+		int ret;
+		do {
+			ret = pthread_spin_unlock(&spin);
+		} while (OXT_UNLIKELY(ret == EINTR));
+		if (OXT_UNLIKELY(ret != 0)) {
+			throw boost::thread_resource_error("Cannot unlock spin lock", ret);
+		}
+	}
+};
+
+} // namespace oxt
+

data/ext/oxt/detail/tracable_exception_disabled.hpp

@@ -0,0 +1,46 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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 <exception>
+#include <string>
+
+// Dummy implementation for tracable_exception.hpp.
+// See detail/tracable_exception_enabled.hpp for API documentation.
+
+namespace oxt {
+
+class tracable_exception: public std::exception {
+public:
+	virtual std::string backtrace() const throw() {
+		return "     (backtrace support disabled during compile time)\n";
+	}
+	
+	virtual const char *what() const throw() {
+		return "oxt::tracable_exception";
+	}
+};
+
+} // namespace oxt
+