passenger 2.0.6 → 2.1.2

data/ext/apache2/Application.h

@@ -22,11 +22,15 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/function.hpp>
+#include <oxt/system_calls.hpp>
+#include <oxt/backtrace.hpp>
 #include <string>
+#include <vector>
 
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <netdb.h>
 #include <unistd.h>
 #include <errno.h>
 #include <ctime>
@@ -35,6 +39,7 @@
 #include "MessageChannel.h"
 #include "Exceptions.h"
 #include "Logging.h"
+#include "Utils.h"
 
 namespace Passenger {
 
@@ -105,6 +110,7 @@ public:
 		 * @throws boost::thread_interrupted
 		 */
 		virtual void sendHeaders(const char *headers, unsigned int size) {
+			TRACE_POINT();
 			int stream = getStream();
 			if (stream == -1) {
 				throw IOException("Cannot write headers to the request handler "
@@ -112,9 +118,10 @@ public:
 			}
 			try {
 				MessageChannel(stream).writeScalar(headers, size);
-			} catch (const SystemException &e) {
-				throw SystemException("An error occured while writing headers "
-					"to the request handler", e.code());
+			} catch (SystemException &e) {
+				e.setBriefMessage("An error occured while writing headers "
+					"to the request handler");
+				throw;
 			}
 		}
 		
@@ -144,6 +151,7 @@ public:
 		 * @throws boost::thread_interrupted
 		 */
 		virtual void sendBodyBlock(const char *block, unsigned int size) {
+			TRACE_POINT();
 			int stream = getStream();
 			if (stream == -1) {
 				throw IOException("Cannot write request body block to the "
@@ -152,9 +160,10 @@ public:
 			}
 			try {
 				MessageChannel(stream).writeRaw(block, size);
-			} catch (const SystemException &e) {
-				throw SystemException("An error occured while sending the "
-					"request body to the request handler", e.code());
+			} catch (SystemException &e) {
+				e.setBriefMessage("An error occured while sending the "
+					"request body to the request handler");
+				throw;
 			}
 		}
 		
@@ -167,6 +176,28 @@ public:
 		 */
 		virtual int getStream() const = 0;
 		
+		/**
+		 * Set the timeout value for reading data from the I/O stream.
+		 * If no data can be read within the timeout period, then the
+		 * read call will fail with error EAGAIN or EWOULDBLOCK.
+		 *
+		 * @param msec The timeout, in milliseconds. If 0 is given,
+		 *             there will be no timeout.
+		 * @throws SystemException Cannot set the timeout.
+		 */
+		virtual void setReaderTimeout(unsigned int msec) = 0;
+		
+		/**
+		 * Set the timeout value for writing data from the I/O stream.
+		 * If no data can be written within the timeout period, then the
+		 * write call will fail with error EAGAIN or EWOULDBLOCK.
+		 *
+		 * @param msec The timeout, in milliseconds. If 0 is given,
+		 *             there will be no timeout.
+		 * @throws SystemException Cannot set the timeout.
+		 */
+		virtual void setWriterTimeout(unsigned int msec) = 0;
+		
 		/**
 		 * Indicate that we don't want to read data anymore from the I/O stream.
 		 * Calling this method after closeStream() is called will have no effect.
@@ -225,6 +256,7 @@ private:
 		}
 	
 		virtual ~StandardSession() {
+			TRACE_POINT();
 			closeStream();
 			closeCallback();
 		}
@@ -233,9 +265,18 @@ private:
 			return fd;
 		}
 		
+		virtual void setReaderTimeout(unsigned int msec) {
+			MessageChannel(fd).setReadTimeout(msec);
+		}
+		
+		virtual void setWriterTimeout(unsigned int msec) {
+			MessageChannel(fd).setWriteTimeout(msec);
+		}
+		
 		virtual void shutdownReader() {
+			TRACE_POINT();
 			if (fd != -1) {
-				int ret = InterruptableCalls::shutdown(fd, SHUT_RD);
+				int ret = syscalls::shutdown(fd, SHUT_RD);
 				if (ret == -1) {
 					throw SystemException("Cannot shutdown the writer stream",
 						errno);
@@ -244,8 +285,9 @@ private:
 		}
 		
 		virtual void shutdownWriter() {
+			TRACE_POINT();
 			if (fd != -1) {
-				int ret = InterruptableCalls::shutdown(fd, SHUT_WR);
+				int ret = syscalls::shutdown(fd, SHUT_WR);
 				if (ret == -1) {
 					throw SystemException("Cannot shutdown the writer stream",
 						errno);
@@ -254,8 +296,9 @@ private:
 		}
 		
 		virtual void closeStream() {
+			TRACE_POINT();
 			if (fd != -1) {
-				int ret = InterruptableCalls::close(fd);
+				int ret = syscalls::close(fd);
 				if (ret == -1) {
 					throw SystemException("Cannot close the session stream",
 						errno);
@@ -276,8 +319,88 @@ private:
 	string appRoot;
 	pid_t pid;
 	string listenSocketName;
-	bool usingAbstractNamespace;
+	string listenSocketType;
 	int ownerPipe;
+	
+	SessionPtr connectToUnixServer(const function<void()> &closeCallback) const {
+		TRACE_POINT();
+		int fd, ret;
+		
+		do {
+			fd = socket(PF_UNIX, SOCK_STREAM, 0);
+		} while (fd == -1 && errno == EINTR);
+		if (fd == -1) {
+			throw SystemException("Cannot create a new unconnected Unix socket", errno);
+		}
+		
+		struct sockaddr_un addr;
+		addr.sun_family = AF_UNIX;
+		strncpy(addr.sun_path, listenSocketName.c_str(), sizeof(addr.sun_path));
+		addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
+		do {
+			ret = ::connect(fd, (const sockaddr *) &addr, sizeof(addr));
+		} while (ret == -1 && errno == EINTR);
+		if (ret == -1) {
+			int e = errno;
+			string message("Cannot connect to Unix socket '");
+			message.append(listenSocketName);
+			message.append("'");
+			do {
+				ret = close(fd);
+			} while (ret == -1 && errno == EINTR);
+			throw SystemException(message, e);
+		}
+		
+		return ptr(new StandardSession(pid, closeCallback, fd));
+	}
+	
+	SessionPtr connectToTcpServer(const function<void()> &closeCallback) const {
+		TRACE_POINT();
+		int fd, ret;
+		vector<string> args;
+		
+		split(listenSocketName, ':', args);
+		if (args.size() != 2 || atoi(args[1]) == 0) {
+			throw IOException("Invalid TCP/IP address '" + listenSocketName + "'");
+		}
+		
+		struct addrinfo hints, *res;
+		
+		memset(&hints, 0, sizeof(hints));
+		hints.ai_family = PF_INET;
+		hints.ai_socktype = SOCK_STREAM;
+		ret = getaddrinfo(args[0].c_str(), args[1].c_str(), &hints, &res);
+		if (ret != 0) {
+			int e = errno;
+			throw IOException("Cannot resolve address '" + listenSocketName +
+				"': " + gai_strerror(e));
+		}
+		
+		do {
+			fd = socket(PF_INET, SOCK_STREAM, 0);
+		} while (fd == -1 && errno == EINTR);
+		if (fd == -1) {
+			freeaddrinfo(res);
+			throw SystemException("Cannot create a new unconnected TCP socket", errno);
+		}
+		
+		do {
+			ret = ::connect(fd, res->ai_addr, res->ai_addrlen);
+		} while (ret == -1 && errno == EINTR);
+		freeaddrinfo(res);
+		if (ret == -1) {
+			int e = errno;
+			string message("Cannot connect to TCP server '");
+			message.append(listenSocketName);
+			message.append("'");
+			do {
+				ret = close(fd);
+			} while (ret == -1 && errno == EINTR);
+			throw SystemException(message, e);
+		}
+		
+		return ptr(new StandardSession(pid, closeCallback, fd));
+	}
 
 public:
 	/**
@@ -288,23 +411,23 @@ public:
 	 *             This must be a valid directory, but the path does not have to be absolute.
 	 * @param pid The process ID of this application instance.
 	 * @param listenSocketName The name of the listener socket of this application instance.
-	 * @param usingAbstractNamespace Whether <tt>listenSocketName</tt> refers to a Unix
-	 *        socket on the abstract namespace. Note that listenSocketName must not
-	 *        contain the leading null byte, even if it's an abstract namespace socket.
+	 * @param listenSocketType The type of the listener socket, e.g. "unix" for Unix
+	 *                         domain sockets.
 	 * @param ownerPipe The owner pipe of this application instance.
 	 * @post getAppRoot() == theAppRoot && getPid() == pid
 	 */
 	Application(const string &theAppRoot, pid_t pid, const string &listenSocketName,
-	            bool usingAbstractNamespace, int ownerPipe) {
+	            const string &listenSocketType, int ownerPipe) {
 		appRoot = theAppRoot;
 		this->pid = pid;
 		this->listenSocketName = listenSocketName;
-		this->usingAbstractNamespace = usingAbstractNamespace;
+		this->listenSocketType = listenSocketType;
 		this->ownerPipe = ownerPipe;
 		P_TRACE(3, "Application " << this << ": created.");
 	}
 	
 	virtual ~Application() {
+		TRACE_POINT();
 		int ret;
 		
 		if (ownerPipe != -1) {
@@ -312,7 +435,7 @@ public:
 				ret = close(ownerPipe);
 			} while (ret == -1 && errno == EINTR);
 		}
-		if (!usingAbstractNamespace) {
+		if (listenSocketType == "unix") {
 			do {
 				ret = unlink(listenSocketName.c_str());
 			} while (ret == -1 && errno == EINTR);
@@ -384,36 +507,14 @@ public:
 	 * @throws IOException Something went wrong during the connection process.
 	 */
 	SessionPtr connect(const function<void()> &closeCallback) const {
-		int fd, ret;
-		
-		do {
-			fd = socket(PF_UNIX, SOCK_STREAM, 0);
-		} while (fd == -1 && errno == EINTR);
-		if (fd == -1) {
-			throw SystemException("Cannot create a new unconnected Unix socket", errno);
-		}
-		
-		struct sockaddr_un addr;
-		addr.sun_family = AF_UNIX;
-		if (usingAbstractNamespace) {
-			strncpy(addr.sun_path + 1, listenSocketName.c_str(), sizeof(addr.sun_path) - 1);
-			addr.sun_path[0] = '\0';
+		TRACE_POINT();
+		if (listenSocketType == "unix") {
+			return connectToUnixServer(closeCallback);
+		} else if (listenSocketType == "tcp") {
+			return connectToTcpServer(closeCallback);
 		} else {
-			strncpy(addr.sun_path, listenSocketName.c_str(), sizeof(addr.sun_path));
-		}
-		addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
-		do {
-			ret = ::connect(fd, (const sockaddr *) &addr, sizeof(addr));
-		} while (ret == -1 && errno == EINTR);
-		if (ret == -1) {
-			int e = errno;
-			string message("Cannot connect to Unix socket '");
-			message.append(listenSocketName);
-			message.append("' on the abstract namespace");
-			throw SystemException(message, e);
+			throw IOException("Unsupported socket type '" + listenSocketType + "'");
 		}
-		
-		return ptr(new StandardSession(pid, closeCallback, fd));
 	}
 };
 

data/ext/apache2/ApplicationPool.h

@@ -24,6 +24,7 @@
 #include <sys/types.h>
 
 #include "Application.h"
+#include "PoolOptions.h"
 
 namespace Passenger {
 
@@ -91,26 +92,30 @@ public:
 	virtual ~ApplicationPool() {};
 	
 	/**
-	 * Open a new session with the application specified by <tt>appRoot</tt>.
+	 * Checks whether this ApplicationPool object is still connected to the
+	 * ApplicationPool server.
+	 *
+	 * If that's not the case, then one should reconnect to the ApplicationPool server.
+	 *
+	 * This method is only meaningful for instances of type ApplicationPoolServer::Client.
+	 * The default implementation always returns true.
+	 */
+	virtual bool connected() const {
+		return true;
+	}
+	
+	/**
+	 * Open a new session with the application specified by <tt>PoolOptions.appRoot</tt>.
 	 * See the class description for ApplicationPool, as well as Application::connect(),
 	 * on how to use the returned session object.
 	 *
 	 * Internally, this method may either spawn a new application instance, or use
 	 * an existing one.
 	 *
-	 * If <tt>lowerPrivilege</tt> is true, then any newly spawned application
-	 * instances will have lower privileges. See SpawnManager::SpawnManager()'s
-	 * description of <tt>lowerPrivilege</tt> and <tt>lowestUser</tt> for details.
-	 *
-	 * @param appRoot The application root of a RoR application, i.e. the folder that
-	 *             contains 'app/', 'public/', 'config/', etc. This must be a valid
-	 *             directory, but does not have to be an absolute path.
-	 * @param lowerPrivilege Whether to lower the application's privileges.
-	 * @param lowestUser The user to fallback to if lowering privilege fails.
-	 * @param environment The RAILS_ENV/RACK_ENV environment that should be used. May not be empty.
-	 * @param spawnMethod The spawn method to use. Either "smart" or "conservative".
- 	 *                    See the Ruby class SpawnManager for details.
- 	 * @param appType The application type. Either "rails" or "rack".
+	 * @param options An object containing information on which application to open
+	 *             a session with, as well as spawning details. Spawning details will be used
+	 *             if the pool decides that spawning a new application instance is necessary.
+	 *             See SpawnManager and PoolOptions for details.
 	 * @return A session object.
 	 * @throw SpawnException An attempt was made to spawn a new application instance, but that attempt failed.
 	 * @throw BusyException The application pool is too busy right now, and cannot
@@ -123,9 +128,14 @@ public:
 	 *       <tt>get("/home/../home/foo")</tt>, then ApplicationPool will think
 	 *       they're 2 different applications, and thus will spawn 2 application instances.
 	 */
-	virtual Application::SessionPtr get(const string &appRoot, bool lowerPrivilege = true,
-		const string &lowestUser = "nobody", const string &environment = "production",
-		const string &spawnMethod = "smart", const string &appType = "rails") = 0;
+	virtual Application::SessionPtr get(const PoolOptions &options) = 0;
+	
+	/**
+	 * Convenience shortcut for calling get() with default spawn options.
+	 */
+	virtual Application::SessionPtr get(const string &appRoot) {
+		return get(PoolOptions(appRoot));
+	}
 	
 	/**
 	 * Clear all application instances that are currently in the pool.
@@ -173,18 +183,6 @@ public:
 	 */
 	virtual void setMaxPerApp(unsigned int max) = 0;
 	
-	/**
-	 * Sets whether to use a global queue instead of a per-backend process
-	 * queue. If enabled, when all backend processes are active, get() will
-	 * wait until there's at least one backend process that's idle, instead
-	 * of queuing the request into a random process's private queue.
-	 * This is especially useful if a website has one or more long-running
-	 * requests.
-	 *
-	 * Defaults to false.
-	 */
-	virtual void setUseGlobalQueue(bool value) = 0;
-	
 	/**
 	 * Get the process ID of the spawn server that is used.
 	 *

data/ext/apache2/ApplicationPoolServer.h

@@ -22,6 +22,8 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/thread/mutex.hpp>
+#include <oxt/system_calls.hpp>
+#include <oxt/backtrace.hpp>
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -40,12 +42,12 @@
 #include "Application.h"
 #include "Exceptions.h"
 #include "Logging.h"
-#include "System.h"
 
 namespace Passenger {
 
 using namespace std;
 using namespace boost;
+using namespace oxt;
 
 
 /**
@@ -140,16 +142,31 @@ private:
 		/**
 		 * The socket connection to the ApplicationPool server, as was
 		 * established by ApplicationPoolServer::connect().
+		 *
+		 * The value may be -1, which indicates that the connection has
+		 * been closed.
 		 */
 		int server;
 		
-		mutex lock;
+		mutable boost::mutex lock;
 		
 		~SharedData() {
+			TRACE_POINT();
+			if (server != -1) {
+				disconnect();
+			}
+		}
+		
+		/**
+		 * Disconnect from the ApplicationPool server.
+		 */
+		void disconnect() {
+			TRACE_POINT();
 			int ret;
 			do {
 				ret = close(server);
 			} while (ret == -1 && errno == EINTR);
+			server = -1;
 		}
 	};
 	
@@ -174,7 +191,7 @@ private:
 		
 		virtual ~RemoteSession() {
 			closeStream();
-			mutex::scoped_lock(data->lock);
+			boost::mutex::scoped_lock(data->lock);
 			MessageChannel(data->server).write("close", toString(id).c_str(), NULL);
 		}
 		
@@ -182,9 +199,17 @@ private:
 			return fd;
 		}
 		
+		virtual void setReaderTimeout(unsigned int msec) {
+			MessageChannel(fd).setReadTimeout(msec);
+		}
+		
+		virtual void setWriterTimeout(unsigned int msec) {
+			MessageChannel(fd).setWriteTimeout(msec);
+		}
+		
 		virtual void shutdownReader() {
 			if (fd != -1) {
-				int ret = InterruptableCalls::shutdown(fd, SHUT_RD);
+				int ret = syscalls::shutdown(fd, SHUT_RD);
 				if (ret == -1) {
 					throw SystemException("Cannot shutdown the writer stream",
 						errno);
@@ -194,7 +219,7 @@ private:
 		
 		virtual void shutdownWriter() {
 			if (fd != -1) {
-				int ret = InterruptableCalls::shutdown(fd, SHUT_WR);
+				int ret = syscalls::shutdown(fd, SHUT_WR);
 				if (ret == -1) {
 					throw SystemException("Cannot shutdown the writer stream",
 						errno);
@@ -204,7 +229,7 @@ private:
 		
 		virtual void closeStream() {
 			if (fd != -1) {
-				int ret = InterruptableCalls::close(fd);
+				int ret = syscalls::close(fd);
 				if (ret == -1) {
 					throw SystemException("Cannot close the session stream",
 						errno);
@@ -246,112 +271,167 @@ private:
 			data->server = sock;
 		}
 		
+		virtual bool connected() const {
+			boost::mutex::scoped_lock(data->lock);
+			return data->server != -1;
+		}
+		
 		virtual void clear() {
 			MessageChannel channel(data->server);
-			mutex::scoped_lock l(data->lock);
-			channel.write("clear", NULL);
+			boost::mutex::scoped_lock l(data->lock);
+			try {
+				channel.write("clear", NULL);
+			} catch (...) {
+				data->disconnect();
+				throw;
+			}
 		}
 		
 		virtual void setMaxIdleTime(unsigned int seconds) {
 			MessageChannel channel(data->server);
-			mutex::scoped_lock l(data->lock);
-			channel.write("setMaxIdleTime", toString(seconds).c_str(), NULL);
+			boost::mutex::scoped_lock l(data->lock);
+			try {
+				channel.write("setMaxIdleTime", toString(seconds).c_str(), NULL);
+			} catch (...) {
+				data->disconnect();
+				throw;
+			}
 		}
 		
 		virtual void setMax(unsigned int max) {
 			MessageChannel channel(data->server);
-			mutex::scoped_lock l(data->lock);
-			channel.write("setMax", toString(max).c_str(), NULL);
+			boost::mutex::scoped_lock l(data->lock);
+			try {
+				channel.write("setMax", toString(max).c_str(), NULL);
+			} catch (...) {
+				data->disconnect();
+				throw;
+			}
 		}
 		
 		virtual unsigned int getActive() const {
 			MessageChannel channel(data->server);
-			mutex::scoped_lock l(data->lock);
+			boost::mutex::scoped_lock l(data->lock);
 			vector<string> args;
 			
-			channel.write("getActive", NULL);
-			channel.read(args);
-			return atoi(args[0].c_str());
+			try {
+				channel.write("getActive", NULL);
+				channel.read(args);
+				return atoi(args[0].c_str());
+			} catch (...) {
+				data->disconnect();
+				throw;
+			}
 		}
 		
 		virtual unsigned int getCount() const {
 			MessageChannel channel(data->server);
-			mutex::scoped_lock l(data->lock);
+			boost::mutex::scoped_lock l(data->lock);
 			vector<string> args;
 			
-			channel.write("getCount", NULL);
-			channel.read(args);
-			return atoi(args[0].c_str());
+			try {
+				channel.write("getCount", NULL);
+				channel.read(args);
+				return atoi(args[0].c_str());
+			} catch (...) {
+				data->disconnect();
+				throw;
+			}
 		}
 		
 		virtual void setMaxPerApp(unsigned int max) {
-			MessageChannel channel(data->server);
-			mutex::scoped_lock l(data->lock);
-			channel.write("setMaxPerApp", toString(max).c_str(), NULL);
-		}
-		
-		virtual void setUseGlobalQueue(bool value) {
 			MessageChannel channel(data->server);
 			boost::mutex::scoped_lock l(data->lock);
-			channel.write("setUseGlobalQueue", value ? "true" : "false", NULL);
+			try {
+				channel.write("setMaxPerApp", toString(max).c_str(), NULL);
+			} catch (...) {
+				data->disconnect();
+				throw;
+			}
 		}
 		
 		virtual pid_t getSpawnServerPid() const {
 			this_thread::disable_syscall_interruption dsi;
 			MessageChannel channel(data->server);
-			mutex::scoped_lock l(data->lock);
+			boost::mutex::scoped_lock l(data->lock);
 			vector<string> args;
 			
-			channel.write("getSpawnServerPid", NULL);
-			channel.read(args);
-			return atoi(args[0].c_str());
-		}
-		
-		virtual Application::SessionPtr get(
-			const string &appRoot,
-			bool lowerPrivilege = true,
-			const string &lowestUser = "nobody",
-			const string &environment = "production",
-			const string &spawnMethod = "smart",
-			const string &appType = "rails"
-		) {
+			try {
+				channel.write("getSpawnServerPid", NULL);
+				channel.read(args);
+				return atoi(args[0].c_str());
+			} catch (...) {
+				data->disconnect();
+				throw;
+			}
+		}
+		
+		virtual Application::SessionPtr get(const PoolOptions &options) {
 			this_thread::disable_syscall_interruption dsi;
+			TRACE_POINT();
+			
 			MessageChannel channel(data->server);
-			mutex::scoped_lock l(data->lock);
+			boost::mutex::scoped_lock l(data->lock);
 			vector<string> args;
 			int stream;
 			bool result;
 			
 			try {
-				channel.write("get", appRoot.c_str(),
-					(lowerPrivilege) ? "true" : "false",
-					lowestUser.c_str(),
-					environment.c_str(),
-					spawnMethod.c_str(),
-					appType.c_str(),
-					NULL);
-			} catch (const SystemException &) {
-				throw IOException("The ApplicationPool server exited unexpectedly.");
+				vector<string> args;
+				
+				args.push_back("get");
+				options.toVector(args);
+				channel.write(args);
+			} catch (const SystemException &e) {
+				UPDATE_TRACE_POINT();
+				data->disconnect();
+				
+				string message("Could not send data to the ApplicationPool server: ");
+				message.append(e.brief());
+				throw SystemException(message, e.code());
 			}
 			try {
+				UPDATE_TRACE_POINT();
 				result = channel.read(args);
 			} catch (const SystemException &e) {
+				UPDATE_TRACE_POINT();
+				data->disconnect();
 				throw SystemException("Could not read a message from "
 					"the ApplicationPool server", e.code());
 			}
 			if (!result) {
+				UPDATE_TRACE_POINT();
+				data->disconnect();
 				throw IOException("The ApplicationPool server unexpectedly "
 					"closed the connection.");
 			}
 			if (args[0] == "ok") {
-				stream = channel.readFileDescriptor();
+				UPDATE_TRACE_POINT();
+				pid_t pid = (pid_t) atol(args[1]);
+				int sessionID = atoi(args[2]);
+				
+				try {
+					stream = channel.readFileDescriptor();
+				} catch (...) {
+					UPDATE_TRACE_POINT();
+					data->disconnect();
+					throw;
+				}
+				
 				return ptr(new RemoteSession(dataSmartPointer,
-					atoi(args[1]), atoi(args[2]), stream));
+					pid, sessionID, stream));
 			} else if (args[0] == "SpawnException") {
+				UPDATE_TRACE_POINT();
 				if (args[2] == "true") {
 					string errorPage;
 					
-					if (!channel.readScalar(errorPage)) {
+					try {
+						result = channel.readScalar(errorPage);
+					} catch (...) {
+						data->disconnect();
+						throw;
+					}
+					if (!result) {
 						throw IOException("The ApplicationPool server "
 							"unexpectedly closed the connection.");
 					}
@@ -360,10 +440,15 @@ private:
 					throw SpawnException(args[1]);
 				}
 			} else if (args[0] == "BusyException") {
+				UPDATE_TRACE_POINT();
 				throw BusyException(args[1]);
 			} else if (args[0] == "IOException") {
+				UPDATE_TRACE_POINT();
+				data->disconnect();
 				throw IOException(args[1]);
 			} else {
+				UPDATE_TRACE_POINT();
+				data->disconnect();
 				throw IOException("The ApplicationPool server returned "
 					"an unknown message: " + toString(args));
 			}
@@ -408,12 +493,13 @@ private:
 	 * @post serverSocket == -1 && serverPid == 0
 	 */
 	void shutdownServer() {
+		TRACE_POINT();
 		this_thread::disable_syscall_interruption dsi;
 		int ret;
 		time_t begin;
 		bool done = false;
 		
-		InterruptableCalls::close(serverSocket);
+		syscalls::close(serverSocket);
 		if (!statusReportFIFO.empty()) {
 			do {
 				ret = unlink(statusReportFIFO.c_str());
@@ -422,28 +508,28 @@ private:
 		
 		P_TRACE(2, "Waiting for existing ApplicationPoolServerExecutable (PID " <<
 			serverPid << ") to exit...");
-		begin = InterruptableCalls::time(NULL);
-		while (!done && InterruptableCalls::time(NULL) < begin + 5) {
+		begin = syscalls::time(NULL);
+		while (!done && syscalls::time(NULL) < begin + 5) {
 			/*
 			 * Some Apache modules fork(), but don't close file descriptors.
 			 * mod_wsgi is one such example. Because of that, closing serverSocket
 			 * won't always cause the ApplicationPool server to exit. So we send it a
 			 * signal.
 			 */
-			InterruptableCalls::kill(serverPid, SIGINT);
+			syscalls::kill(serverPid, SIGINT);
 			
-			ret = InterruptableCalls::waitpid(serverPid, NULL, WNOHANG);
+			ret = syscalls::waitpid(serverPid, NULL, WNOHANG);
 			done = ret > 0 || ret == -1;
 			if (!done) {
-				InterruptableCalls::usleep(100000);
+				syscalls::usleep(100000);
 			}
 		}
 		if (done) {
 			P_TRACE(2, "ApplicationPoolServerExecutable exited.");
 		} else {
 			P_DEBUG("ApplicationPoolServerExecutable not exited in time. Killing it...");
-			InterruptableCalls::kill(serverPid, SIGTERM);
-			InterruptableCalls::waitpid(serverPid, NULL, 0);
+			syscalls::kill(serverPid, SIGTERM);
+			syscalls::waitpid(serverPid, NULL, 0);
 		}
 		
 		serverSocket = -1;
@@ -459,6 +545,7 @@ private:
 	 * @throw SystemException Something went wrong.
 	 */
 	void restartServer() {
+		TRACE_POINT();
 		int fds[2];
 		pid_t pid;
 		
@@ -466,14 +553,15 @@ private:
 			shutdownServer();
 		}
 		
-		if (InterruptableCalls::socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1) {
+		if (syscalls::socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1) {
 			throw SystemException("Cannot create a Unix socket pair", errno);
 		}
 		
 		createStatusReportFIFO();
 		
-		pid = InterruptableCalls::fork();
+		pid = syscalls::fork();
 		if (pid == 0) { // Child process.
+			dup2(STDERR_FILENO, STDOUT_FILENO);  // Redirect stdout to the same channel as stderr.
 			dup2(fds[0], SERVER_SOCKET_FD);
 			
 			// Close all unnecessary file descriptors
@@ -495,18 +583,20 @@ private:
 				m_rubyCommand.c_str(),
 				m_user.c_str(),
 				statusReportFIFO.c_str(),
-				NULL);
+				(char *) 0);
 			int e = errno;
-			fprintf(stderr, "*** Passenger ERROR: Cannot execute %s: %s (%d)\n",
+			fprintf(stderr, "*** Passenger ERROR (%s:%d):\n"
+				"Cannot execute %s: %s (%d)\n",
+				__FILE__, __LINE__,
 				m_serverExecutable.c_str(), strerror(e), e);
 			fflush(stderr);
 			_exit(1);
 		} else if (pid == -1) { // Error.
-			InterruptableCalls::close(fds[0]);
-			InterruptableCalls::close(fds[1]);
+			syscalls::close(fds[0]);
+			syscalls::close(fds[1]);
 			throw SystemException("Cannot create a new process", errno);
 		} else { // Parent process.
-			InterruptableCalls::close(fds[0]);
+			syscalls::close(fds[0]);
 			serverSocket = fds[1];
 			
 			int flags = fcntl(serverSocket, F_GETFD);
@@ -519,14 +609,24 @@ private:
 	}
 	
 	void createStatusReportFIFO() {
+		TRACE_POINT();
 		char filename[PATH_MAX];
 		int ret;
+		mode_t permissions;
+		
+		createPassengerTempDir();
 		
-		snprintf(filename, sizeof(filename), "/tmp/passenger_status.%d.fifo",
-			getpid());
+		if (m_user.empty()) {
+			permissions = S_IRUSR | S_IWUSR;
+		} else {
+			permissions = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+		}
+		
+		snprintf(filename, sizeof(filename), "%s/status.fifo",
+				getPassengerTempDir().c_str());
 		filename[PATH_MAX - 1] = '\0';
 		do {
-			ret = mkfifo(filename, S_IRUSR | S_IWUSR);
+			ret = mkfifo(filename, permissions);
 		} while (ret == -1 && errno == EINTR);
 		if (ret == -1 && errno != EEXIST) {
 			int e = errno;
@@ -536,6 +636,12 @@ private:
 			statusReportFIFO = "";
 		} else {
 			statusReportFIFO = filename;
+			
+			// It seems that the permissions passed to mkfifo()
+			// aren't respected, so here we chmod the file.
+			do {
+				ret = chmod(filename, permissions);
+			} while (ret == -1 && errno == EINTR);
 		}
 	}
 
@@ -572,6 +678,7 @@ public:
 	  m_logFile(logFile),
 	  m_rubyCommand(rubyCommand),
 	  m_user(user) {
+		TRACE_POINT();
 		serverSocket = -1;
 		serverPid = 0;
 		this_thread::disable_syscall_interruption dsi;
@@ -579,7 +686,9 @@ public:
 	}
 	
 	~ApplicationPoolServer() {
+		TRACE_POINT();
 		if (serverSocket != -1) {
+			UPDATE_TRACE_POINT();
 			this_thread::disable_syscall_interruption dsi;
 			shutdownServer();
 		}
@@ -618,6 +727,7 @@ public:
 	 * @throws IOException Something went wrong.
 	 */
 	ApplicationPoolPtr connect() {
+		TRACE_POINT();
 		try {
 			this_thread::disable_syscall_interruption dsi;
 			MessageChannel channel(serverSocket);
@@ -652,6 +762,7 @@ public:
 	 * before calling detach().
 	 */
 	void detach() {
+		TRACE_POINT();
 		int ret;
 		do {
 			ret = close(serverSocket);