passenger 2.0.6 → 2.1.2

data/ext/boost/cstdint.hpp

@@ -122,8 +122,10 @@ namespace boost
 
 } // namespace boost
 
-#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__)
-// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
+#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || \
+      defined(__SOLARIS9__)
+// FreeBSD, Tru64 and Solaris 9 have an <inttypes.h> that contains much of 
+// what we need.
 # include <inttypes.h>
 
 namespace boost {

data/ext/boost/current_function.hpp

@@ -0,0 +1,67 @@
+#ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
+#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/current_function.hpp - BOOST_CURRENT_FUNCTION
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+//  http://www.boost.org/libs/utility/current_function.html
+//
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline void current_function_helper()
+{
+
+#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600))
+
+# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+
+#elif defined(__DMC__) && (__DMC__ >= 0x810)
+
+# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+
+#elif defined(__FUNCSIG__)
+
+# define BOOST_CURRENT_FUNCTION __FUNCSIG__
+
+#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
+
+# define BOOST_CURRENT_FUNCTION __FUNCTION__
+
+#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
+
+# define BOOST_CURRENT_FUNCTION __FUNC__
+
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
+
+# define BOOST_CURRENT_FUNCTION __func__
+
+#else
+
+# define BOOST_CURRENT_FUNCTION "(unknown)"
+
+#endif
+
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED

data/ext/boost/detail/sp_counted_base.hpp

@@ -51,14 +51,14 @@
 
 # include <boost/detail/sp_counted_base_gcc_ppc.hpp>
 
-#elif defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
-
-# include <boost/detail/sp_counted_base_sync.hpp>
-
 #elif defined(__GNUC__) && ( defined( __sparcv8 ) || defined( __sparcv9 ) )
 
 # include <boost/detail/sp_counted_base_gcc_sparc.hpp>
 
+#elif defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
+
+# include <boost/detail/sp_counted_base_sync.hpp>
+
 #elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
 
 # include <boost/detail/sp_counted_base_w32.hpp>

data/ext/boost/thread/exceptions.hpp

@@ -9,6 +9,7 @@
 #define BOOST_THREAD_EXCEPTIONS_PDM070801_H
 
 #include <boost/thread/detail/config.hpp>
+#include <oxt/tracable_exception.hpp>
 
 //  pdm: Sorry, but this class is used all over the place & I end up
 //       with recursive headers if I don't separate it
@@ -21,7 +22,7 @@
 
 namespace boost {
 
-class BOOST_THREAD_DECL thread_exception : public std::exception
+class BOOST_THREAD_DECL thread_exception : public oxt::tracable_exception
 {
 protected:
     std::string message;

data/ext/boost/thread/pthread/thread.hpp

@@ -134,15 +134,22 @@ namespace boost
         mutable boost::mutex thread_info_mutex;
         detail::thread_data_ptr thread_info;
 
-        void start_thread(unsigned int stack_size = 0);
-        
         explicit thread(detail::thread_data_ptr data);
 
         detail::thread_data_ptr get_thread_info() const;
         
+    protected:
+        template <class F>
+        void set_thread_main_function(F f)
+        {
+            thread_info = detail::thread_data_ptr(new thread_data<F>(f));
+        }
+        
+        void start_thread(unsigned int stack_size);
+        
     public:
         thread();
-        ~thread();
+        virtual ~thread();
 
         template <class F>
         explicit thread(F f, unsigned int stack_size = 0):
@@ -150,6 +157,7 @@ namespace boost
         {
             start_thread(stack_size);
         }
+        
         template <class F>
         thread(detail::thread_move_t<F> f, unsigned int stack_size = 0):
             thread_info(new thread_data<F>(f))

data/ext/boost/thread/pthread/thread_data.hpp

@@ -10,12 +10,13 @@
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/optional.hpp>
+#include <oxt/tracable_exception.hpp>
 #include <pthread.h>
 #include "condition_variable_fwd.hpp"
 
 namespace boost
 {
-    class thread_interrupted
+    class thread_interrupted: public oxt::tracable_exception
     {};
 
     namespace detail

data/ext/oxt/backtrace.cpp

@@ -0,0 +1,172 @@
+/*
+ * 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.
+ */
+#if !(defined(NDEBUG) || defined(OXT_DISABLE_BACKTRACES))
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/tss.hpp>
+#include <sstream>
+#include "backtrace.hpp"
+
+namespace oxt {
+
+boost::mutex _thread_registration_mutex;
+list<thread_registration *> _registered_threads;
+
+// Register main thread.
+static initialize_backtrace_support_for_this_thread main_thread_initialization("Main thread");
+
+/*
+ * boost::thread_specific_storage is pretty expensive. So we use the __thread
+ * keyword whenever possible - that's almost free.
+ * GCC supports the __thread keyword on x86 since version 3.3. Not sure
+ * about other architectures.
+ */
+
+#if defined(__GNUC__) && (                       \
+   __GNUC__ > 3 || (                             \
+       __GNUC__ == 3 && __GNUC_MINOR__ >= 3      \
+   )                                             \
+)
+	#define GCC_IS_3_3_OR_HIGHER
+#endif
+
+/*
+ * FreeBSD 5 supports the __thread keyword, and everything works fine in
+ * micro-tests, but in mod_passenger the thread-local variables are initialized
+ * to unaligned addresses for some weird reason, thereby causing bus errors.
+ *
+ * GCC on OpenBSD supports __thread, but any access to such a variable
+ * results in a segfault.
+ *
+ * Solaris does support __thread, but often it's not compiled into default GCC 
+ * packages (not to mention it's not available for Sparc). Playing it safe...
+ *
+ * MacOS X doesn't support __thread at all.
+ */
+#if defined(GCC_IS_3_3_OR_HIGHER) && !defined(__FreeBSD__) && \
+   !defined(__SOLARIS__) && !defined(__OpenBSD__) && !defined(__APPLE__)
+	static __thread spin_lock *backtrace_lock = NULL;
+	static __thread vector<trace_point *> *current_backtrace = NULL;
+	
+	void
+	_init_backtrace_tls() {
+		backtrace_lock = new spin_lock();
+		current_backtrace = new vector<trace_point *>();
+		current_backtrace->reserve(50);
+	}
+	
+	void
+	_finalize_backtrace_tls() {
+		delete backtrace_lock;
+		delete current_backtrace;
+	}
+	
+	spin_lock *
+	_get_backtrace_lock() {
+		return backtrace_lock;
+	}
+	
+	vector<trace_point *> *
+	_get_current_backtrace() {
+		return current_backtrace;
+	}
+#else
+	static thread_specific_ptr<spin_lock> backtrace_lock;
+	static thread_specific_ptr< vector<trace_point *> > current_backtrace;
+	
+	void _init_backtrace_tls() {
+		// Not implemented.
+	}
+	
+	void _finalize_backtrace_tls() {
+		// Not implemented.
+	}
+
+	spin_lock *
+	_get_backtrace_lock() {
+		spin_lock *result;
+	
+		result = backtrace_lock.get();
+		if (OXT_UNLIKELY(result == NULL)) {
+			result = new spin_lock();
+			backtrace_lock.reset(result);
+		}
+		return result;
+	}
+
+	vector<trace_point *> *
+	_get_current_backtrace() {
+		vector<trace_point *> *result;
+	
+		result = current_backtrace.get();
+		if (OXT_UNLIKELY(result == NULL)) {
+			result = new vector<trace_point *>();
+			current_backtrace.reset(result);
+		}
+		return result;
+	}
+#endif
+
+template<typename Iterable, typename ReverseIterator> static string
+format_backtrace(Iterable backtrace_list) {
+	if (backtrace_list->empty()) {
+		return "     (empty)";
+	} else {
+		stringstream result;
+		ReverseIterator it;
+		
+		for (it = backtrace_list->rbegin(); it != backtrace_list->rend(); it++) {
+			trace_point *p = *it;
+			
+			result << "     in '" << p->function << "'";
+			if (p->source != NULL) {
+				result << " (" << p->source << ":" << p->line << ")";
+			}
+			result << endl;
+		}
+		return result.str();
+	}
+}
+
+string
+_format_backtrace(const list<trace_point *> *backtrace_list) {
+	return format_backtrace<
+		const list<trace_point *> *,
+		list<trace_point *>::const_reverse_iterator
+	>(backtrace_list);
+}
+
+string
+_format_backtrace(const vector<trace_point *> *backtrace_list) {
+	return format_backtrace<
+		const vector<trace_point *> *,
+		vector<trace_point *>::const_reverse_iterator
+	>(backtrace_list);
+}
+
+} // namespace oxt
+
+#endif
+

data/ext/oxt/backtrace.hpp

@@ -0,0 +1,135 @@
+/*
+ * 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.
+ */
+#ifndef _OXT_BACKTRACE_HPP_
+#define _OXT_BACKTRACE_HPP_
+
+/**
+ * Portable C++ backtrace support.
+ *
+ * C++ doesn't provide a builtin, automatic, portable way of obtaining
+ * backtraces. Obtaining a backtrace via a debugger (e.g. gdb) is very
+ * expensive. Furthermore, not all machines have a debugger installed.
+ * This makes it very hard to debug problems on production servers.
+ *
+ * This file provides a portable way of specifying and obtaining
+ * backtraces. Via oxt::thread::all_backtraces(), it is even possible
+ * to obtain the backtraces of all running threads.
+ *
+ * <h2>Initialization</h2>
+ * Every thread that is to contain backtrace information <b>must</b> be
+ * initialized. Initialization is done by instantiating an
+ * initialize_backtrace_support_for_this_thread object. This includes the main
+ * thread as well.
+ *
+ * If you use oxt::thread, then initialization will be automatically done for
+ * you for that partciular thread.
+ *
+ * <h2>Basic usage</h2>
+ * Backtrace points must be specified manually in the code using TRACE_POINT().
+ * The TracableException class allows one to obtain the backtrace at the moment
+ * the exception object was created.
+ *
+ * For example:
+ * @code
+ * void foo() {
+ *     TRACE_POINT();
+ *     do_something();
+ *     bar();
+ *     do_something_else();
+ * }
+ *
+ * void bar() {
+ *     TRACE_POINT();
+ *     throw TracableException();
+ * }
+ * @encode
+ *
+ * One can obtain the backtrace string, as follows:
+ * @code
+ * try {
+ *     foo();
+ * } catch (const TracableException &e) {
+ *     cout << "Something bad happened:\n" << e.backtrace();
+ * }
+ * @endcode
+ *
+ * This will print something like:
+ * @code
+ * Something bad happened:
+ *     in 'bar' (example.cpp:123)
+ *     in 'foo' (example.cpp:117)
+ *     in 'example_function' (example.cpp:456)
+ * @encode
+ *
+ * <h2>Making sure the line number is correct</h2>
+ * A TRACE_POINT() call will add a backtrace point for the source line on
+ * which it is written. However, this causes an undesirable effect in long
+ * functions:
+ * @code
+ * 100   void some_long_function() {
+ * 101       TRACE_POINT();
+ * 102       do_something();
+ * 103       for (...) {
+ * 104           do_something();
+ * 105       }
+ * 106       do_something_else();
+ * 107
+ * 108       if (!write_file()) {
+ * 109           throw TracableException();
+ * 110       }
+ * 111   }
+ * @endcode
+ * You will want the thrown exception to show a backtrace line number that's
+ * near line 109. But as things are now, the backtrace will show line 101.
+ *
+ * This can be solved by calling UPDATE_TRACE_POINT() from time to time:
+ * @code
+ * 100   void some_long_function() {
+ * 101       TRACE_POINT();
+ * 102       do_something();
+ * 103       for (...) {
+ * 104           do_something();
+ * 105       }
+ * 106       do_something_else();
+ * 107
+ * 108       if (!write_file()) {
+ * 109           UPDATE_TRACE_POINT();   // Added!
+ * 110           throw TracableException();
+ * 111       }
+ * 112   }
+ * @endcode
+ *
+ * <h2>Compilation options</h2>
+ * Define OXT_DISABLE_BACKTRACES to disable backtrace support. The backtrace
+ * functions as provided by this header will become empty stubs.
+ */
+
+#if defined(NDEBUG) || defined(OXT_DISABLE_BACKTRACES)
+	#include "detail/backtrace_disabled.hpp"
+#else
+	#include "detail/backtrace_enabled.hpp"
+#endif
+
+#endif /* _OXT_BACKTRACE_HPP_ */