passenger 2.2.15 → 3.0.0.pre1

data/ext/nginx/ngx_http_passenger_module.h

@@ -1,7 +1,7 @@
 /*
  * Copyright (C) Igor Sysoev
  * Copyright (C) 2007 Manlio Perillo (manlio.perillo@gmail.com)
- * Copyright (C) 2008 Phusion
+ * Copyright (C) 2010 Phusion
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -29,7 +29,8 @@
 #define _PASSENGER_NGINX_MODULE_H_
 
 #include <ngx_core.h>
-#include "../common/CachedFileStat.h"
+#include "../common/AgentsStarter.h"
+#include "../common/Utils/CachedFileStat.h"
 
 /**
  * The Nginx version number as an integer.
@@ -42,31 +43,21 @@
 
 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];
+extern ngx_str_t    passenger_placeholder_upstream_address;
 
 /**
  * A CachedFileStat object used for caching stat() calls.
  */
 extern CachedFileStat *passenger_stat_cache;
 
+extern AgentsStarter  *passenger_agents_starter;
+
+extern ngx_cycle_t    *passenger_current_cycle;
+
 #endif /* _PASSENGER_NGINX_MODULE_H_ */
 

data/ext/oxt/backtrace.cpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008 Phusion
+ * Copyright (c) 2010 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
@@ -38,6 +38,19 @@ list<thread_registration *> _registered_threads;
 // Register main thread.
 static initialize_backtrace_support_for_this_thread main_thread_initialization("Main thread");
 
+
+namespace {
+	struct backtrace_data {
+		vector<trace_point *> list;
+		spin_lock lock;
+		
+		backtrace_data() {
+			list.reserve(50);
+		}
+	};
+}
+
+
 /*
  * boost::thread_specific_storage is pretty expensive. So we use the __thread
  * keyword whenever possible - that's almost free.
@@ -66,65 +79,60 @@ static initialize_backtrace_support_for_this_thread main_thread_initialization("
  */
 #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;
+	static __thread backtrace_data *thread_specific_backtrace_data;
 	
 	void
 	_init_backtrace_tls() {
-		backtrace_lock = new spin_lock();
-		current_backtrace = new vector<trace_point *>();
-		current_backtrace->reserve(50);
+		thread_specific_backtrace_data = new backtrace_data();
 	}
 	
 	void
 	_finalize_backtrace_tls() {
-		delete backtrace_lock;
-		delete current_backtrace;
-	}
-	
-	spin_lock *
-	_get_backtrace_lock() {
-		return backtrace_lock;
+		delete thread_specific_backtrace_data;
 	}
 	
-	vector<trace_point *> *
-	_get_current_backtrace() {
-		return current_backtrace;
+	bool
+	_get_backtrace_list_and_its_lock(vector<trace_point *> **backtrace_list, spin_lock **lock) {
+		if (OXT_LIKELY(thread_specific_backtrace_data != NULL)) {
+			*backtrace_list = &thread_specific_backtrace_data->list;
+			*lock = &thread_specific_backtrace_data->lock;
+			return true;
+		} else {
+			return false;
+		}
 	}
 #else
-	static thread_specific_ptr<spin_lock> backtrace_lock;
-	static thread_specific_ptr< vector<trace_point *> > current_backtrace;
+	static thread_specific_ptr<backtrace_data> thread_specific_backtrace_data;
 	
 	void _init_backtrace_tls() {
-		// Not implemented.
+		/* Not implemented on purpose.
+		 *
+		 * It is not safe to use thread_specific_backtrace_data here
+		 * because this function may be called by
+		 * initialize_backtrace_support_for_this_thread's constructor,
+		 * which in turn may be called by the global static variable
+		 * main_thread_initialization. C++ does not guarantee initialization
+		 * order so thread_specific_backtrace_data may not be usable at
+		 * this time.
+		 */
 	}
 	
 	void _finalize_backtrace_tls() {
-		// Not implemented.
+		// Not implemented either.
 	}
-
-	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);
+	bool
+	_get_backtrace_list_and_its_lock(vector<trace_point *> **backtrace_list, spin_lock **lock) {
+		backtrace_data *data;
+		
+		data = thread_specific_backtrace_data.get();
+		if (OXT_UNLIKELY(data == NULL)) {
+			data = new backtrace_data();
+			thread_specific_backtrace_data.reset(data);
 		}
-		return result;
+		*backtrace_list = &data->list;
+		*lock = &data->lock;
+		return true;
 	}
 #endif
 

data/ext/oxt/backtrace.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008 Phusion
+ * Copyright (c) 2010 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

data/ext/oxt/detail/backtrace_disabled.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008 Phusion
+ * Copyright (c) 2010 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

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) 2008 Phusion
+ * Copyright (c) 2010 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
@@ -47,12 +47,11 @@ 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);
+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
@@ -78,10 +77,11 @@ struct trace_point {
 		this->line = line;
 		m_detached = false;
 		
-		spin_lock *lock = _get_backtrace_lock();
-		if (OXT_LIKELY(lock != NULL)) {
+		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);
-			_get_current_backtrace()->push_back(this);
+			backtrace_list->push_back(this);
 		}
 	}
 	
@@ -94,10 +94,11 @@ struct trace_point {
 
 	~trace_point() {
 		if (OXT_LIKELY(!m_detached)) {
-			spin_lock *lock = _get_backtrace_lock();
-			if (OXT_LIKELY(lock != NULL)) {
+			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);
-				_get_current_backtrace()->pop_back();
+				backtrace_list->pop_back();
 			}
 		}
 	}
@@ -132,8 +133,8 @@ struct initialize_backtrace_support_for_this_thread {
 		_init_backtrace_tls();
 		registration = new thread_registration();
 		registration->name = name;
-		registration->backtrace_lock = _get_backtrace_lock();
-		registration->backtrace = _get_current_backtrace();
+		_get_backtrace_list_and_its_lock(&registration->backtrace,
+			&registration->backtrace_lock);
 		
 		boost::mutex::scoped_lock l(_thread_registration_mutex);
 		_registered_threads.push_back(registration);

data/ext/oxt/detail/spin_lock_darwin.hpp

@@ -0,0 +1,69 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2010 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 <libkern/OSAtomic.h>
+#include <boost/noncopyable.hpp>
+
+/*
+ * Implementation of a spin lock using Darwin spin locks.
+ *
+ * See spin_lock_gcc_x86.hpp for API documentation.
+ */
+
+namespace oxt {
+
+class spin_lock {
+private:
+	OSSpinLock 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() {
+		spin = 0;
+	}
+	
+	void lock() {
+		OSSpinLockLock(&spin);
+	}
+	
+	void unlock() {
+		OSSpinLockUnlock(&spin);
+	}
+};
+
+} // namespace oxt

data/ext/oxt/detail/spin_lock_gcc_x86.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008 Phusion
+ * Copyright (c) 2010 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
@@ -35,7 +35,7 @@ namespace oxt {
  */
 class spin_lock {
 private:
-	int exclusion;
+	volatile int exclusion;
 
 public:
 	/**
@@ -73,8 +73,7 @@ public:
 	 * @throws boost::thread_resource_error Something went wrong.
 	 */
 	void unlock() {
-		__sync_synchronize(); // Memory barrier.
-		exclusion = 0;
+		__sync_lock_release(&exclusion);
 	}
 };
 

data/ext/oxt/detail/spin_lock_portable.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008 Phusion
+ * Copyright (c) 2010 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

data/ext/oxt/detail/spin_lock_pthreads.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008 Phusion
+ * Copyright (c) 2010 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

data/ext/oxt/detail/tracable_exception_disabled.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008 Phusion
+ * Copyright (c) 2010 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

data/ext/oxt/detail/tracable_exception_enabled.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008 Phusion
+ * Copyright (c) 2010 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

data/ext/oxt/dynamic_thread_group.hpp

@@ -0,0 +1,195 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2010 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_DYNAMIC_THREAD_GROUP_HPP_
+#define _OXT_DYNAMIC_THREAD_GROUP_HPP_
+
+#include <list>
+#include <memory>
+
+#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+#include <oxt/thread.hpp>
+#include <oxt/system_calls.hpp>
+
+namespace oxt {
+
+using namespace std;
+using namespace boost;
+
+/**
+ * A thread group is a collection of threads. One can run aggregate
+ * operations on it, such as interrupting and joining all threads
+ * in the thread group.
+ *
+ * Unlike boost::thread_group, an oxt::dynamic_thread_group
+ * supports oxt::thread, and automatically removes terminated threads
+ * from its collection, hence 'dynamic' in the name.
+ *
+ * Threads in the group are guaranteed to have a shorter life time
+ * than the group itself: upon destruction, all threads in the group
+ * will be interrupted and joined by calling interrupt_and_join_all().
+ */
+class dynamic_thread_group {
+private:
+	struct thread_handle;
+	typedef shared_ptr<thread_handle> thread_handle_ptr;
+	
+	/** A container which aggregates a thread object
+	 * as well as the its own iterator in the 'thread_handles'
+	 * member. The latter is used for removing itself from
+	 * 'thread_handles'.
+	 */
+	struct thread_handle {
+		list<thread_handle_ptr>::iterator iterator;
+		thread *thr;
+		bool removed_from_list;
+		
+		thread_handle() {
+			thr = NULL;
+			removed_from_list = false;
+		}
+		
+		~thread_handle() {
+			delete thr;
+		}
+	};
+	
+	/** A mutex which protects thread_handles and nthreads. */
+	mutable boost::mutex lock;
+	/** The internal list of threads. */
+	list<thread_handle_ptr> thread_handles;
+	/** The number of threads in this thread group. */
+	unsigned int nthreads;
+	
+	struct thread_cleanup {
+		dynamic_thread_group *thread_group;
+		thread_handle *handle;
+		
+		thread_cleanup(dynamic_thread_group *g, thread_handle *h) {
+			thread_group = g;
+			handle = h;
+		}
+		
+		~thread_cleanup() {
+			this_thread::disable_interruption di;
+			this_thread::disable_syscall_interruption dsi;
+			boost::lock_guard<boost::mutex> l(thread_group->lock);
+			if (!handle->removed_from_list) {
+				thread_group->thread_handles.erase(handle->iterator);
+				thread_group->nthreads--;
+			}
+		}
+	};
+	
+	void thread_main(boost::function<void ()> &func, thread_handle *handle) {
+		thread_cleanup c(this, handle);
+		func();
+	}
+	
+public:
+	dynamic_thread_group() {
+		nthreads = 0;
+	}
+	
+	~dynamic_thread_group() {
+		interrupt_and_join_all();
+	}
+	
+	/**
+	 * Create a new thread that belongs to this thread group.
+	 *
+	 * @param func The thread main function.
+	 * @param name A name for this thread. If the empty string is passed,
+	 *             then an auto-generated name will be used.
+	 * @param stack_size The stack size for this thread. A value of 0 means
+	 *                   that the system's default stack size should be used.
+	 * @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) {
+		boost::lock_guard<boost::mutex> l(lock);
+		thread_handle_ptr handle(new thread_handle());
+		thread_handles.push_back(handle);
+		handle->iterator = thread_handles.end();
+		handle->iterator--;
+		try {
+			handle->thr = new thread(
+				boost::bind(&dynamic_thread_group::thread_main, this, func, handle.get()),
+				name,
+				stack_size
+			);
+			nthreads++;
+		} catch (...) {
+			thread_handles.erase(handle->iterator);
+			throw;
+		}
+	}
+	
+	/**
+	 * Interrupt and join all threads in this group.
+	 *
+	 * @post num_threads() == 0
+	 */
+	void interrupt_and_join_all() {
+		/* While interrupting and joining the threads, each thread
+		 * will try to lock the mutex and remove itself from
+		 * 'thread_handles'. We want to avoid deadlocks so we
+		 * empty 'thread_handles' in the critical section and
+		 * join the threads outside the critical section.
+		 */
+		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();
+		thread::interrupt_and_join_multiple(threads, nthreads_copy);
+	}
+	
+	/**
+	 * Returns the number of threads currently in this thread group.
+	 */
+	unsigned int num_threads() const {
+		boost::lock_guard<boost::mutex> l(lock);
+		return nthreads;
+	}
+};
+
+} // namespace oxt
+
+#endif /* _OXT_DYNAMIC_THREAD_GROUP_HPP_ */