passenger 2.0.6 → 2.1.2

data/ext/apache2/ApplicationPoolServerExecutable.cpp

@@ -36,13 +36,20 @@
 #include <boost/bind.hpp>
 #include <boost/thread/thread.hpp>
 
+#include <oxt/system_calls.hpp>
+#include <oxt/thread.hpp>
+#include <oxt/backtrace.hpp>
+
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <unistd.h>
 #include <signal.h>
+#include <errno.h>
+#include <pwd.h>
 #include <string>
+#include <sstream>
 #include <vector>
 #include <set>
 #include <map>
@@ -51,12 +58,12 @@
 #include "StandardApplicationPool.h"
 #include "Application.h"
 #include "Logging.h"
-#include "System.h"
 #include "Exceptions.h"
 
 
 using namespace boost;
 using namespace std;
+using namespace oxt;
 using namespace Passenger;
 
 class Server;
@@ -65,6 +72,15 @@ typedef shared_ptr<Client> ClientPtr;
 
 #define SERVER_SOCKET_FD 3
 
+// The following variables contain pre-calculated data which are used by
+// Server::fatalSignalHandler(). It's not safe to allocate memory inside
+// a signal handler.
+
+/** The filename of the ApplicationPoolServerExecutable binary. */
+static string exeFile;
+static string gdbBacktraceGenerationCommand;
+static const char *gdbBacktraceGenerationCommandStr;
+
 
 /*****************************************
  * Server
@@ -77,16 +93,19 @@ private:
 	int serverSocket;
 	StandardApplicationPool pool;
 	set<ClientPtr> clients;
-	mutex lock;
+	boost::mutex lock;
 	string statusReportFIFO;
-	shared_ptr<Thread> statusReportThread;
+	shared_ptr<oxt::thread> statusReportThread;
+	string user;
 	
 	void statusReportThreadMain() {
+		TRACE_POINT();
 		try {
 			while (!this_thread::interruption_requested()) {
 				struct stat buf;
 				int ret;
 				
+				UPDATE_TRACE_POINT();
 				do {
 					ret = stat(statusReportFIFO.c_str(), &buf);
 				} while (ret == -1 && errno == EINTR);
@@ -96,17 +115,32 @@ private:
 					break;
 				}
 				
-				FILE *f = InterruptableCalls::fopen(statusReportFIFO.c_str(), "w");
+				UPDATE_TRACE_POINT();
+				FILE *f = syscalls::fopen(statusReportFIFO.c_str(), "w");
 				if (f == NULL) {
+					int e = errno;
+					P_ERROR("Cannot open status report FIFO " <<
+						statusReportFIFO << ": " <<
+						strerror(e) << " (" << e << ")");
 					break;
 				}
 				
-				string report(pool.toString());
-				fwrite(report.c_str(), 1, report.size(), f);
-				InterruptableCalls::fclose(f);
+				UPDATE_TRACE_POINT();
+				MessageChannel channel(fileno(f));
+				string report;
+				report.append("----------- Backtraces -----------\n");
+				report.append(oxt::thread::all_backtraces());
+				report.append("\n\n");
+				report.append(pool.toString());
 				
-				// Prevent sending too much data at once.
-				sleep(1);
+				UPDATE_TRACE_POINT();
+				try {
+					channel.writeScalar(report);
+					channel.writeScalar(pool.toXml());
+				} catch (...) {
+					// Ignore write errors.
+				}
+				syscalls::fclose(f);
 			}
 		} catch (const boost::thread_interrupted &) {
 			P_TRACE(2, "Status report thread interrupted.");
@@ -114,6 +148,7 @@ private:
 	}
 	
 	void deleteStatusReportFIFO() {
+		TRACE_POINT();
 		if (!statusReportFIFO.empty()) {
 			int ret;
 			do {
@@ -121,6 +156,134 @@ private:
 			} while (ret == -1 && errno == EINTR);
 		}
 	}
+	
+	/**
+	 * Lowers this process's privilege to that of <em>username</em>,
+	 * and sets stricter permissions for the Phusion Passenger temp
+	 * directory.
+	 */
+	void lowerPrivilege(const string &username) {
+		struct passwd *entry;
+		int ret, e;
+		
+		entry = getpwnam(username.c_str());
+		if (entry != NULL) {
+			do {
+				ret = chown(getPassengerTempDir().c_str(),
+					entry->pw_uid, entry->pw_gid);
+			} while (ret == -1 && errno == EINTR);
+			if (ret == -1) {
+				e = errno;
+				P_WARN("WARNING: Unable to change owner for directory '" <<
+					getPassengerTempDir() << "' to '" << username <<
+					"': " << strerror(e) << " (" << e << ")");
+			} else {
+				do {
+					ret = chmod(getPassengerTempDir().c_str(),
+						S_IRUSR | S_IWUSR | S_IXUSR);
+				} while (ret == -1 && errno == EINTR);
+				if (ret == -1) {
+					e = errno;
+					P_WARN("WARNING: Unable to change "
+						"permissions for directory " <<
+						getPassengerTempDir() << ": " <<
+						strerror(e) <<
+						" (" << e << ")");
+				}
+			}
+			
+			if (initgroups(username.c_str(), entry->pw_gid) != 0) {
+				int e = errno;
+				P_WARN("WARNING: Unable to lower ApplicationPoolServerExecutable's "
+					"privilege to that of user '" << username <<
+					"': cannot set supplementary groups for this "
+					"user: " << strerror(e) << " (" << e << ")");
+			}
+			if (setgid(entry->pw_gid) != 0) {
+				int e = errno;
+				P_WARN("WARNING: Unable to lower ApplicationPoolServerExecutable's "
+					"privilege to that of user '" << username <<
+					"': cannot set group ID: " << strerror(e) <<
+					" (" << e << ")");
+			}
+			if (setuid(entry->pw_uid) != 0) {
+				int e = errno;
+				P_WARN("WARNING: Unable to lower ApplicationPoolServerExecutable's "
+					"privilege to that of user '" << username <<
+					"': cannot set user ID: " << strerror(e) <<
+					" (" << e << ")");
+			}
+		} else {
+			P_WARN("WARNING: Unable to lower ApplicationPoolServerExecutable's "
+				"privilege to that of user '" << username <<
+				"': user does not exist.");
+		}
+	}
+	
+	static void fatalSignalHandler(int signum) {
+		static void (* const defaultHandler)(int) = SIG_DFL;
+		static bool calledBefore = false;
+		
+		if (calledBefore) {
+			// If we're here then it means that this signal
+			// handler crashed, and we weren't even able to
+			// call write() or system()! Abort immediately:
+			defaultHandler(signum);
+		} else {
+			calledBefore = true;
+			write(STDERR_FILENO,
+				"*** ERROR: ApplicationPoolServerExecutable received a "
+				"fatal signal. Running gdb to obtain the backtrace:\n\n",
+				sizeof("*** ERROR: ApplicationPoolServerExecutable caught "
+				       "fatal signal. Running gdb to obtain the backtrace:\n\n") - 1
+			);
+			write(STDERR_FILENO, "----------------- Begin gdb output -----------------\n",
+				sizeof("----------------- Begin gdb output -----------------\n") - 1);
+			system(gdbBacktraceGenerationCommandStr);
+			write(STDERR_FILENO, "----------------- End gdb output -----------------\n",
+				sizeof("----------------- End gdb output -----------------\n") - 1);
+			defaultHandler(signum);
+		}
+	}
+	
+	void setupSignalHandlers() {
+		// Ignore SIGPIPE and SIGHUP.
+		struct sigaction action;
+		action.sa_handler = SIG_IGN;
+		action.sa_flags   = 0;
+		sigemptyset(&action.sa_mask);
+		sigaction(SIGPIPE, &action, NULL);
+		sigaction(SIGHUP, &action, NULL);
+		
+		// Setup handlers for other signals.
+		FILE *f;
+		string gdbCommandFile;
+		
+		gdbCommandFile = getPassengerTempDir() + "/gdb_backtrace_command.txt";
+		f = fopen(gdbCommandFile.c_str(), "w");
+		if (f != NULL) {
+			// Write a file which contains commands for gdb to obtain
+			// the backtrace of this process.
+			fprintf(f, "attach %lu\n", (unsigned long) getpid());
+			fprintf(f, "thread apply all bt full\n");
+			fclose(f);
+			chmod(gdbCommandFile.c_str(), S_IRUSR | S_IRGRP | S_IROTH);
+			
+			gdbBacktraceGenerationCommand = "gdb -n -batch -x \"";
+			gdbBacktraceGenerationCommand.append(gdbCommandFile);
+			gdbBacktraceGenerationCommand.append("\" < /dev/null");
+			gdbBacktraceGenerationCommandStr = gdbBacktraceGenerationCommand.c_str();
+			
+			// Install the signal handlers.
+			action.sa_handler = fatalSignalHandler;
+			action.sa_flags   = 0;
+			sigemptyset(&action.sa_mask);
+			sigaction(SIGSEGV, &action, NULL);
+			sigaction(SIGABRT, &action, NULL);
+			sigaction(SIGILL, &action, NULL);
+			sigaction(SIGFPE, &action, NULL);
+		}
+	}
 
 public:
 	Server(int serverSocket,
@@ -135,21 +298,25 @@ public:
 		Passenger::setLogLevel(logLevel);
 		this->serverSocket = serverSocket;
 		this->statusReportFIFO = statusReportFIFO;
+		this->user = user;
 	}
 	
 	~Server() {
+		TRACE_POINT();
 		this_thread::disable_syscall_interruption dsi;
 		this_thread::disable_interruption di;
 		
 		P_TRACE(2, "Shutting down server.");
 		
-		InterruptableCalls::close(serverSocket);
+		syscalls::close(serverSocket);
 		
 		if (statusReportThread != NULL) {
-			statusReportThread->interruptAndJoin();
+			UPDATE_TRACE_POINT();
+			statusReportThread->interrupt_and_join();
 		}
 		
 		// Wait for all clients to disconnect.
+		UPDATE_TRACE_POINT();
 		set<ClientPtr> clientsCopy;
 		{
 			/* If we clear _clients_ directly, then it may result in a deadlock.
@@ -157,7 +324,7 @@ public:
 			 * the reference counts, and then we release all references outside the critical
 			 * section.
 			 */
-			mutex::scoped_lock l(lock);
+			boost::mutex::scoped_lock l(lock);
 			clientsCopy = clients;
 			clients.clear();
 		}
@@ -194,7 +361,7 @@ private:
 	MessageChannel channel;
 	
 	/** The thread which handles the client connection. */
-	Thread *thr;
+	oxt::thread *thr;
 	
 	/**
 	 * Maps session ID to sessions created by ApplicationPool::get(). Session IDs
@@ -207,15 +374,17 @@ private:
 	int lastSessionID;
 	
 	void processGet(const vector<string> &args) {
+		TRACE_POINT();
 		Application::SessionPtr session;
 		bool failed = false;
 		
 		try {
-			session = server.pool.get(args[1], args[2] == "true", args[3],
-				args[4], args[5], args[6]);
+			PoolOptions options(args, 1);
+			session = server.pool.get(options);
 			sessions[lastSessionID] = session;
 			lastSessionID++;
 		} catch (const SpawnException &e) {
+			UPDATE_TRACE_POINT();
 			this_thread::disable_syscall_interruption dsi;
 			
 			if (e.hasErrorPage()) {
@@ -230,22 +399,27 @@ private:
 			}
 			failed = true;
 		} catch (const BusyException &e) {
+			UPDATE_TRACE_POINT();
 			this_thread::disable_syscall_interruption dsi;
 			channel.write("BusyException", e.what(), NULL);
 			failed = true;
 		} catch (const IOException &e) {
+			UPDATE_TRACE_POINT();
 			this_thread::disable_syscall_interruption dsi;
 			channel.write("IOException", e.what(), NULL);
 			failed = true;
 		}
+		UPDATE_TRACE_POINT();
 		if (!failed) {
 			this_thread::disable_syscall_interruption dsi;
 			try {
+				UPDATE_TRACE_POINT();
 				channel.write("ok", toString(session->getPid()).c_str(),
 					toString(lastSessionID - 1).c_str(), NULL);
 				channel.writeFileDescriptor(session->getStream());
 				session->closeStream();
 			} catch (const exception &) {
+				UPDATE_TRACE_POINT();
 				P_TRACE(3, "Client " << this << ": something went wrong "
 					"while sending 'ok' back to the client.");
 				sessions.erase(lastSessionID - 1);
@@ -255,42 +429,47 @@ private:
 	}
 	
 	void processClose(const vector<string> &args) {
+		TRACE_POINT();
 		sessions.erase(atoi(args[1]));
 	}
 	
 	void processClear(const vector<string> &args) {
+		TRACE_POINT();
 		server.pool.clear();
 	}
 	
 	void processSetMaxIdleTime(const vector<string> &args) {
+		TRACE_POINT();
 		server.pool.setMaxIdleTime(atoi(args[1]));
 	}
 	
 	void processSetMax(const vector<string> &args) {
+		TRACE_POINT();
 		server.pool.setMax(atoi(args[1]));
 	}
 	
 	void processGetActive(const vector<string> &args) {
+		TRACE_POINT();
 		channel.write(toString(server.pool.getActive()).c_str(), NULL);
 	}
 	
 	void processGetCount(const vector<string> &args) {
+		TRACE_POINT();
 		channel.write(toString(server.pool.getCount()).c_str(), NULL);
 	}
 	
 	void processSetMaxPerApp(unsigned int maxPerApp) {
+		TRACE_POINT();
 		server.pool.setMaxPerApp(maxPerApp);
 	}
 	
-	void processSetUseGlobalQueue(bool value) {
-		server.pool.setUseGlobalQueue(value);
-	}
-	
 	void processGetSpawnServerPid(const vector<string> &args) {
+		TRACE_POINT();
 		channel.write(toString(server.pool.getSpawnServerPid()).c_str(), NULL);
 	}
 	
 	void processUnknownMessage(const vector<string> &args) {
+		TRACE_POINT();
 		string name;
 		if (args.empty()) {
 			name = "(null)";
@@ -305,9 +484,11 @@ private:
 	 * The entry point of the thread that handles the client connection.
 	 */
 	void threadMain(const weak_ptr<Client> self) {
+		TRACE_POINT();
 		vector<string> args;
 		try {
 			while (!this_thread::interruption_requested()) {
+				UPDATE_TRACE_POINT();
 				try {
 					if (!channel.read(args)) {
 						// Client closed connection.
@@ -322,7 +503,8 @@ private:
 				P_TRACE(4, "Client " << this << ": received message: " <<
 					toString(args));
 				
-				if (args[0] == "get" && args.size() == 7) {
+				UPDATE_TRACE_POINT();
+				if (args[0] == "get") {
 					processGet(args);
 				} else if (args[0] == "close" && args.size() == 2) {
 					processClose(args);
@@ -338,8 +520,6 @@ private:
 					processGetCount(args);
 				} else if (args[0] == "setMaxPerApp" && args.size() == 2) {
 					processSetMaxPerApp(atoi(args[1]));
-				} else if (args[0] == "setUseGlobalQueue" && args.size() == 2) {
-					processSetUseGlobalQueue(args[1] == "true");
 				} else if (args[0] == "getSpawnServerPid" && args.size() == 1) {
 					processGetSpawnServerPid(args);
 				} else {
@@ -350,13 +530,23 @@ private:
 			}
 		} catch (const boost::thread_interrupted &) {
 			P_TRACE(2, "Client thread " << this << " interrupted.");
+		} catch (const tracable_exception &e) {
+			P_TRACE(2, "Uncaught exception in ApplicationPoolServer client thread:\n"
+				<< "   message: " << toString(args) << "\n"
+				<< "   exception: " << e.what() << "\n"
+				<< "   backtrace:\n" << e.backtrace());
 		} catch (const exception &e) {
 			P_TRACE(2, "Uncaught exception in ApplicationPoolServer client thread:\n"
 				<< "   message: " << toString(args) << "\n"
-				<< "   exception: " << e.what());
+				<< "   exception: " << e.what() << "\n"
+				<< "   backtrace: not available");
+		} catch (...) {
+			P_TRACE(2, "Uncaught unknown exception in ApplicationPool client thread.");
+			throw;
 		}
 		
-		mutex::scoped_lock l(server.lock);
+		UPDATE_TRACE_POINT();
+		boost::mutex::scoped_lock l(server.lock);
 		ClientPtr myself(self.lock());
 		if (myself != NULL) {
 			server.clients.erase(myself);
@@ -390,55 +580,59 @@ public:
 	 *        connection.
 	 */
 	void start(const weak_ptr<Client> self) {
-		thr = new Thread(
+		stringstream name;
+		name << "Client " << fd;
+		thr = new oxt::thread(
 			bind(&Client::threadMain, this, self),
-			CLIENT_THREAD_STACK_SIZE
+			name.str(), CLIENT_THREAD_STACK_SIZE
 		);
 	}
 	
 	~Client() {
+		TRACE_POINT();
 		this_thread::disable_syscall_interruption dsi;
 		this_thread::disable_interruption di;
 		
 		if (thr != NULL) {
 			if (thr->get_id() != this_thread::get_id()) {
-				thr->interruptAndJoin();
+				thr->interrupt_and_join();
 			}
 			delete thr;
 		}
-		InterruptableCalls::close(fd);
+		syscalls::close(fd);
 	}
 };
 
-
 int
 Server::start() {
-	setupSyscallInterruptionSupport();
-	
-	// Ignore SIGPIPE.
-	struct sigaction action;
-	action.sa_handler = SIG_IGN;
-	action.sa_flags   = 0;
-	sigemptyset(&action.sa_mask);
-	sigaction(SIGPIPE, &action, NULL);
+	TRACE_POINT();
+	setup_syscall_interruption_support();
 	
 	try {
 		if (!statusReportFIFO.empty()) {
 			statusReportThread = ptr(
-				new Thread(
+				new oxt::thread(
 					bind(&Server::statusReportThreadMain, this),
+					"Status report thread",
 					1024 * 128
 				)
 			);
 		}
 		
+		if (!user.empty()) {
+			lowerPrivilege(user);
+		}
+		
+		setupSignalHandlers();
+		
 		while (!this_thread::interruption_requested()) {
 			int fds[2], ret;
 			char x;
 			
 			// The received data only serves to wake up the server socket,
 			// and is not important.
-			ret = InterruptableCalls::read(serverSocket, &x, 1);
+			UPDATE_TRACE_POINT();
+			ret = syscalls::read(serverSocket, &x, 1);
 			if (ret == 0) {
 				// All web server processes disconnected from this server.
 				// So we can safely quit.
@@ -450,22 +644,28 @@ Server::start() {
 			
 			// We have an incoming connect request from an
 			// ApplicationPool client.
+			UPDATE_TRACE_POINT();
 			do {
 				ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
 			} while (ret == -1 && errno == EINTR);
 			if (ret == -1) {
+				UPDATE_TRACE_POINT();
 				throw SystemException("Cannot create an anonymous Unix socket", errno);
 			}
 			
+			UPDATE_TRACE_POINT();
 			MessageChannel(serverSocket).writeFileDescriptor(fds[1]);
-			InterruptableCalls::close(fds[1]);
+			syscalls::close(fds[1]);
 			
+			UPDATE_TRACE_POINT();
 			ClientPtr client(new Client(*this, fds[0]));
 			pair<set<ClientPtr>::iterator, bool> p;
 			{
-				mutex::scoped_lock l(lock);
+				UPDATE_TRACE_POINT();
+				boost::mutex::scoped_lock l(lock);
 				clients.insert(client);
 			}
+			UPDATE_TRACE_POINT();
 			client->start(client);
 		}
 	} catch (const boost::thread_interrupted &) {
@@ -477,12 +677,19 @@ Server::start() {
 int
 main(int argc, char *argv[]) {
 	try {
+		exeFile = argv[0];
 		Server server(SERVER_SOCKET_FD, atoi(argv[1]),
 			argv[2], argv[3], argv[4], argv[5], argv[6]);
 		return server.start();
+	} catch (const tracable_exception &e) {
+		P_ERROR("*** Fatal error: " << e.what() << "\n" << e.backtrace());
+		return 1;
 	} catch (const exception &e) {
-		P_ERROR(e.what());
+		P_ERROR("*** Fatal error: " << e.what());
 		return 1;
+	} catch (...) {
+		P_ERROR("*** Fatal error: Unknown exception thrown in main thread.");
+		throw;
 	}
 }