passenger-jmazzi 2.2.9

data/ext/nginx/ngx_http_passenger_module.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) 2007 Manlio Perillo (manlio.perillo@gmail.com)
+ * Copyright (C) 2008 Phusion
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _PASSENGER_NGINX_MODULE_H_
+#define _PASSENGER_NGINX_MODULE_H_
+
+#include <ngx_core.h>
+#include "../common/CachedFileStat.h"
+
+/**
+ * The Nginx version number as an integer.
+ * For example, on nginx 1.7.30 this value is 1007030.
+ */
+#define NGINX_VERSION_NUM \
+    (1000000 * PASSENGER_NGINX_MAJOR_VERSION + \
+     1000   * PASSENGER_NGINX_MINOR_VERSION + \
+     PASSENGER_NGINX_MICRO_VERSION)
+
+extern ngx_module_t ngx_http_passenger_module;
+
+/**
+ * The folder in which Passenger temp files are to be stored. This folder
+ * is created during Nginx initialization and removed during Nginx shutdown.
+ */
+extern const char   passenger_temp_dir[NGX_MAX_PATH];
+
+/**
+ * A static schema string to be assigned to Nginx 'upstream' strctures.
+ */
+extern ngx_str_t    passenger_schema_string;
+
+/**
+ * An autogenerated password, used for authenticating with the helper server.
+ */
+extern ngx_str_t    passenger_helper_server_password;
+
+/**
+ * The filename of the Unix socket on which the helper server is listening.
+ */
+extern const char   passenger_helper_server_socket[NGX_MAX_PATH];
+
+/**
+ * A CachedFileStat object used for caching stat() calls.
+ */
+extern CachedFileStat *passenger_stat_cache;
+
+#endif /* _PASSENGER_NGINX_MODULE_H_ */
+

data/ext/oxt/backtrace.cpp

@@ -0,0 +1,177 @@
+/*
+ * 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 <cstring>
+#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, but versions earlier
+ * than 4.1.2 have bugs (http://gcc.gnu.org/ml/gcc-bugs/2006-09/msg02275.html).
+ */
+
+#ifndef OXT_GCC_VERSION
+	#define OXT_GCC_VERSION (__GNUC__ * 10000 \
+                               + __GNUC_MINOR__ * 100 \
+                               + __GNUC_PATCHLEVEL__)
+#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 OXT_GCC_VERSION >= 40102 && !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) {
+				const char *source = strrchr(p->source, '/');
+				if (source != NULL) {
+					source++;
+				} else {
+					source = p->source;
+				}
+				result << " (" << 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_ */

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
+