passenger 5.0.4 → 5.0.5

data/ext/common/ApplicationPool2/Socket.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-2014 Phusion
+ *  Copyright (c) 2011-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -47,13 +47,13 @@ using namespace boost;
 
 struct Connection {
 	int fd;
-	bool persistent: 1;
+	bool wantKeepAlive: 1;
 	bool fail: 1;
 	bool blocking: 1;
 
 	Connection()
 		: fd(-1),
-		  persistent(false),
+		  wantKeepAlive(false),
 		  fail(false),
 		  blocking(true)
 		{ }
@@ -62,8 +62,9 @@ struct Connection {
 		if (fd != -1) {
 			int fd2 = fd;
 			fd = -1;
-			persistent = false;
+			wantKeepAlive = false;
 			safelyClose(fd2);
+			P_LOG_FILE_DESCRIPTOR_CLOSE(fd2);
 		}
 	}
 };
@@ -85,10 +86,11 @@ private:
 	Connection connect() const {
 		Connection connection;
 		P_TRACE(3, "Connecting to " << address);
-		connection.fd = connectToServer(address);
+		connection.fd = connectToServer(address, __FILE__, __LINE__);
 		connection.fail = true;
-		connection.persistent = false;
+		connection.wantKeepAlive = false;
 		connection.blocking = true;
+		P_LOG_FILE_DESCRIPTOR_PURPOSE(connection.fd, "App " << pid << " connection");
 		return connection;
 	}
 
@@ -97,24 +99,30 @@ public:
 	StaticString name;
 	StaticString address;
 	StaticString protocol;
+	pid_t pid;
 	int concurrency;
 
 	// Private. In public section as alignment optimization.
-	int totalActiveConnections;
+	int totalConnections;
+	int totalIdleConnections;
 
 	/** Invariant: sessions >= 0 */
 	int sessions;
 
 	Socket()
-		: concurrency(0)
+		: pid(-1),
+		  concurrency(0)
 		{ }
 
-	Socket(const StaticString &_name, const StaticString &_address, const StaticString &_protocol, int _concurrency)
+	Socket(pid_t _pid, const StaticString &_name, const StaticString &_address,
+		const StaticString &_protocol, int _concurrency)
 		: name(_name),
 		  address(_address),
 		  protocol(_protocol),
+		  pid(_pid),
 		  concurrency(_concurrency),
-		  totalActiveConnections(0),
+		  totalConnections(0),
+		  totalIdleConnections(0),
 		  sessions(0)
 		{ }
 
@@ -123,17 +131,21 @@ public:
 		  name(other.name),
 		  address(other.address),
 		  protocol(other.protocol),
+		  pid(other.pid),
 		  concurrency(other.concurrency),
-		  totalActiveConnections(other.totalActiveConnections),
+		  totalConnections(other.totalConnections),
+		  totalIdleConnections(other.totalIdleConnections),
 		  sessions(other.sessions)
 		{ }
 
 	Socket &operator=(const Socket &other) {
-		totalActiveConnections = other.totalActiveConnections;
+		totalConnections = other.totalConnections;
+		totalIdleConnections = other.totalIdleConnections;
 		idleConnections = other.idleConnections;
 		name = other.name;
 		address = other.address;
 		protocol = other.protocol;
+		pid = other.pid;
 		concurrency = other.concurrency;
 		sessions = other.sessions;
 		return *this;
@@ -151,41 +163,59 @@ public:
 		if (!idleConnections.empty()) {
 			P_TRACE(3, "Socket " << address << ": checking out connection from connection pool (" <<
 				idleConnections.size() << " -> " << (idleConnections.size() - 1) <<
-				" items). Current active connections: " << totalActiveConnections);
+				" items). Current total number of connections: " << totalConnections);
 			Connection connection = idleConnections.back();
 			idleConnections.pop_back();
+			totalIdleConnections--;
 			return connection;
-		} else if (totalActiveConnections < connectionPoolLimit()) {
+		} else {
 			Connection connection = connect();
-			totalActiveConnections++;
+			totalConnections++;
 			P_TRACE(3, "Socket " << address << ": there are now " <<
-				totalActiveConnections << " active connections");
+				totalConnections << " total connections");
 			l.unlock();
 			return connection;
-		} else {
-			l.unlock();
-			return connect();
 		}
 	}
 
 	void checkinConnection(Connection &connection) {
 		boost::unique_lock<boost::mutex> l(connectionPoolLock);
 
-		if (connection.fail || !connection.persistent) {
-			totalActiveConnections--;
+		if (connection.fail || !connection.wantKeepAlive || totalIdleConnections >= connectionPoolLimit()) {
+			totalConnections--;
+			assert(totalConnections >= 0);
 			P_TRACE(3, "Socket " << address << ": connection not checked back into "
-				"connection pool. There are now " << totalActiveConnections <<
-				" active connections");
+				"connection pool. There are now " << totalConnections <<
+				" connections in total");
 			l.unlock();
 			connection.close();
 		} else {
 			P_TRACE(3, "Socket " << address << ": checking in connection into connection pool (" <<
-				idleConnections.size() << " -> " << (idleConnections.size() + 1) <<
-				" items). Current active connections: " << totalActiveConnections);
+				totalIdleConnections << " -> " << (totalIdleConnections + 1) <<
+				" items). Current total number of connections: " << totalConnections);
+			totalIdleConnections++;
 			idleConnections.push_back(connection);
 		}
 	}
 
+	void closeAllConnections() {
+		boost::unique_lock<boost::mutex> l(connectionPoolLock);
+		assert(sessions == 0);
+		assert(totalConnections == totalIdleConnections);
+		vector<Connection>::iterator it, end = idleConnections.end();
+
+		for (it = idleConnections.begin(); it != end; it++) {
+			try {
+				it->close();
+			} catch (const SystemException &e) {
+				P_ERROR("Cannot close a connection with socket " << address << ": " << e.what());
+			}
+		}
+		idleConnections.clear();
+		totalConnections = 0;
+		totalIdleConnections = 0;
+	}
+
 
 	bool isIdle() const {
 		return sessions == 0;
@@ -226,8 +256,10 @@ public:
 
 class SocketList: public SmallVector<Socket, 1> {
 public:
-	void add(const StaticString &name, const StaticString &address, const StaticString &protocol, int concurrency) {
-		push_back(Socket(name, address, protocol, concurrency));
+	void add(pid_t pid, const StaticString &name, const StaticString &address,
+		const StaticString &protocol, int concurrency)
+	{
+		push_back(Socket(pid, name, address, protocol, concurrency));
 	}
 
 	const Socket *findSocketWithName(const StaticString &name) const {

data/ext/common/ApplicationPool2/Spawner.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-2014 Phusion
+ *  Copyright (c) 2011-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -496,7 +496,7 @@ private:
 						fixupSocketAddress(*details.options, args[1]));
 					StaticString protocol = psg_pstrdup(result.pool, args[2]);
 
-					sockets.add(name, address, protocol, atoi(args[3]));
+					sockets.add(details.pid, name, address, protocol, atoi(args[3]));
 				} else {
 					throwAppSpawnException("An error occurred while starting the "
 						"web application. It reported a wrongly formatted 'socket'"

data/ext/common/BackgroundEventLoop.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011, 2012 Phusion
+ *  Copyright (c) 2011-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -29,6 +29,7 @@
 #include <ev++.h>
 #include <eio.h>
 #include <BackgroundEventLoop.h>
+#include <Logging.h>
 #include <Exceptions.h>
 #include <SafeLibev.h>
 
@@ -107,10 +108,14 @@ BackgroundEventLoop::BackgroundEventLoop(bool scalable, bool useLibeio) {
 		throw RuntimeException("Cannot create an event loop");
 	}
 
+	P_LOG_FILE_DESCRIPTOR_OPEN2(ev_backend_fd(loop), "libev event loop: backend FD");
+
 	async = (ev_async *) malloc(sizeof(ev_async));
 	async->data = this;
 	ev_async_init(async, signalBackgroundEventLoopExit);
 	ev_async_start(loop, async);
+	P_LOG_FILE_DESCRIPTOR_OPEN2(ev_loop_get_pipe(loop, 0), "libev event loop: async pipe 0");
+	P_LOG_FILE_DESCRIPTOR_OPEN2(ev_loop_get_pipe(loop, 1), "libev event loop: async pipe 1");
 	safe = boost::make_shared<SafeLibev>(loop);
 	priv = new BackgroundEventLoopPrivate();
 	priv->thr = NULL;

data/ext/common/Constants.h

@@ -114,7 +114,7 @@
 
 	#define NGINX_DOC_URL "https://www.phusionpassenger.com/documentation/Users%20guide%20Nginx.html"
 
-	#define PASSENGER_VERSION "5.0.4"
+	#define PASSENGER_VERSION "5.0.5"
 
 	#define POOL_HELPER_THREAD_STACK_SIZE 262144
 

data/ext/common/EventedClient.h

@@ -689,7 +689,7 @@ public:
 			state = EC_DISCONNECTED;
 			watchReadEvents(false);
 			watchWriteEvents(false);
-			fd = -1;
+			fd.assign(-1, __FILE__, __LINE__);
 			emitEvent(onDetach);
 			return oldFd;
 		}

data/ext/common/EventedServer.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010 Phusion
+ *  Copyright (c) 2010-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -221,7 +221,7 @@ private:
 				}
 				done = true;
 			} else {
-				FileDescriptor clientfdGuard(clientfd);
+				FileDescriptor clientfdGuard(clientfd, __FILE__, __LINE__, "EventedClient");
 				int optval = 1;
 
 				setNonBlocking(clientfdGuard);

data/ext/common/FileDescriptor.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010, 2011, 2012 Phusion
+ *  Copyright (c) 2010-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -34,6 +34,7 @@
 #include <unistd.h>
 #include <cerrno>
 
+#include <Logging.h>
 #include <Exceptions.h>
 
 namespace Passenger {
@@ -79,6 +80,7 @@ private:
 			if (fd >= 0 && autoClose) {
 				this_thread::disable_syscall_interruption dsi;
 				syscalls::close(fd);
+				P_LOG_FILE_DESCRIPTOR_CLOSE(fd);
 			}
 		}
 
@@ -88,6 +90,7 @@ private:
 				int theFd = fd;
 				fd = -1;
 				safelyClose(theFd, !checkErrors);
+				P_LOG_FILE_DESCRIPTOR_CLOSE(theFd);
 			}
 		}
 
@@ -99,6 +102,15 @@ private:
 	/** Shared pointer for reference counting on this file descriptor */
 	boost::shared_ptr<SharedData> data;
 
+	/**
+	 * Calling FileDescriptor(otherFileDescriptorObject, __FILE__, __LINE__)
+	 * is always a mistake, so we declare the corresponding constructor as
+	 * private in order to enforce a compiler error.
+	 */
+	FileDescriptor(const FileDescriptor &other, const char *file, unsigned int line, bool autoClose = true) {
+		throw "never reached";
+	}
+
 public:
 	/**
 	 * Creates a new empty FileDescriptor instance that has no underlying
@@ -113,7 +125,7 @@ public:
 	 *
 	 * @post *this == fd
 	 */
-	explicit FileDescriptor(int fd, bool autoClose = true) {
+	explicit FileDescriptor(int fd, const char *file, unsigned int line, bool autoClose = true) {
 		if (fd >= 0) {
 			/* Make sure that the 'new' operator doesn't overwrite
 			 * errno so that we can write code like this:
@@ -126,6 +138,7 @@ public:
 			int e = errno;
 			data = boost::make_shared<SharedData>(fd, autoClose);
 			errno = e;
+			P_LOG_FILE_DESCRIPTOR_OPEN3(fd, file, line);
 		}
 	}
 
@@ -182,12 +195,12 @@ public:
 		}
 	}
 
-	FileDescriptor &operator=(int fd) {
+	void assign(int fd, const char *file, unsigned int line) {
 		/* Make sure that the 'new' and 'delete' operators don't
 		 * overwrite errno so that we can write code like this:
 		 *
 		 *    FileDescriptor fd;
-		 *    fd = open(...);
+		 *    fd.assign(open(...));
 		 *    if (fd == -1) {
 		 *       print_error(errno);
 		 *    }
@@ -195,11 +208,13 @@ public:
 		int e = errno;
 		if (fd >= 0) {
 			data = boost::make_shared<SharedData>(fd, true);
+			if (file != NULL) {
+				P_LOG_FILE_DESCRIPTOR_OPEN3(fd, file, line);
+			}
 		} else {
 			data.reset();
 		}
 		errno = e;
-		return *this;
 	}
 
 	FileDescriptor &operator=(const FileDescriptor &other) {
@@ -260,7 +275,7 @@ private:
 	int writer;
 
 public:
-	EventFd() {
+	EventFd(const char *file, unsigned int line, const char *purpose) {
 		int fds[2];
 
 		if (syscalls::pipe(fds) == -1) {
@@ -269,12 +284,16 @@ public:
 		}
 		reader = fds[0];
 		writer = fds[1];
+		P_LOG_FILE_DESCRIPTOR_OPEN4(fds[0], file, line, purpose);
+		P_LOG_FILE_DESCRIPTOR_OPEN4(fds[1], file, line, purpose);
 	}
 
 	~EventFd() {
 		this_thread::disable_syscall_interruption dsi;
 		syscalls::close(reader);
 		syscalls::close(writer);
+		P_LOG_FILE_DESCRIPTOR_CLOSE(reader);
+		P_LOG_FILE_DESCRIPTOR_CLOSE(writer);
 	}
 
 	void notify() {

data/ext/common/Logging.cpp

@@ -28,6 +28,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 
+#include <boost/thread.hpp>
 #include <boost/atomic.hpp>
 #include <Logging.h>
 #include <Constants.h>
@@ -40,114 +41,168 @@ namespace Passenger {
 volatile sig_atomic_t _logLevel = DEFAULT_LOG_LEVEL;
 AssertionFailureInfo lastAssertionFailure;
 static bool printAppOutputAsDebuggingMessages = false;
-static char *logFile = NULL;
+
+static boost::mutex logFileMutex;
+static string logFile;
+
+static int fileDescriptorLog = -1;
+static string fileDescriptorLogFile;
 
 #define TRUNCATE_LOGPATHS_TO_MAXCHARS 3 // set to 0 to disable truncation
 
+
 void
 setLogLevel(int value) {
 	_logLevel = value;
 	boost::atomic_signal_fence(boost::memory_order_seq_cst);
 }
 
+string getLogFile() {
+	boost::lock_guard<boost::mutex> l(logFileMutex);
+	return logFile;
+}
+
 bool
-setLogFile(const char *path) {
-	int fd = open(path, O_WRONLY | O_CREAT | O_APPEND, 0644);
+setLogFile(const string &path, int *errcode) {
+	int fd = open(path.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0644);
 	if (fd != -1) {
-		char *newLogFile = strdup(path);
-		if (newLogFile == NULL) {
-			P_CRITICAL("Cannot allocate memory");
-			abort();
-		}
-
+		boost::lock_guard<boost::mutex> l(logFileMutex);
 		dup2(fd, STDOUT_FILENO);
 		dup2(fd, STDERR_FILENO);
 		close(fd);
-
-		if (logFile != NULL) {
-			free(logFile);
-		}
-		logFile = newLogFile;
+		logFile = path;
 		return true;
 	} else {
+		if (errcode != NULL) {
+			*errcode = errno;
+		}
 		return false;
 	}
 }
 
-string getLogFile() {
-	if (logFile == NULL) {
-		return string();
+bool
+hasFileDescriptorLogFile() {
+	return fileDescriptorLog != -1;
+}
+
+string
+getFileDescriptorLogFile() {
+	return fileDescriptorLogFile;
+}
+
+int
+getFileDescriptorLogFileFd() {
+	return fileDescriptorLog;
+}
+
+bool
+setFileDescriptorLogFile(const string &path, int *errcode) {
+	int fd = open(path.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0644);
+	if (fd != -1) {
+		if (fileDescriptorLog == -1) {
+			fileDescriptorLog = fd;
+		} else {
+			dup2(fd, fileDescriptorLog);
+			close(fd);
+		}
+		if (fileDescriptorLogFile != path) {
+			// Do not mutate `fileDescriptorLogFile` if the path
+			// hasn't changed. This allows `setFileDescriptorLogFile()`
+			// to be thread-safe within the documented constraints.
+			fileDescriptorLogFile = path;
+		}
+		return true;
 	} else {
-		return string(logFile);
+		if (errcode != NULL) {
+			*errcode = errno;
+		}
+		return false;
 	}
 }
 
 void
-_prepareLogEntry(std::stringstream &sstream, const char *file, unsigned int line) {
-	time_t the_time;
+_prepareLogEntry(FastStringStream<> &sstream, const char *file, unsigned int line) {
 	struct tm the_tm;
-	char datetime_buf[60];
+	char datetime_buf[32];
+	int datetime_size;
 	struct timeval tv;
 
-	the_time = time(NULL);
-	localtime_r(&the_time, &the_tm);
-	strftime(datetime_buf, sizeof(datetime_buf) - 1, "%F %H:%M:%S", &the_tm);
 	gettimeofday(&tv, NULL);
+	localtime_r(&tv.tv_sec, &the_tm);
+	datetime_size = snprintf(datetime_buf, sizeof(datetime_buf),
+		"%d-%02d-%02d %02d:%02d:%02d.%04u",
+		the_tm.tm_year + 1900, the_tm.tm_mon + 1, the_tm.tm_mday,
+		the_tm.tm_hour, the_tm.tm_min, the_tm.tm_sec,
+		tv.tv_usec / 100);
 	sstream <<
-		"[ " << datetime_buf << "." << std::setfill('0') << std::setw(4) <<
-			(unsigned long) (tv.tv_usec / 100) <<
+		"[ " << StaticString(datetime_buf, datetime_size) <<
 		" " << std::dec << getpid() << "/" <<
 			std::hex << pthread_self() << std::dec <<
 		" ";
 
-	if (startsWith(file, "ext/")) { // special reduncancy filter because most code resides in these paths
+	if (startsWith(file, P_STATIC_STRING("ext/"))) { // special reduncancy filter because most code resides in these paths
 		file += sizeof("ext/") - 1;
-		if (startsWith(file, "common/")) {
+		if (startsWith(file, P_STATIC_STRING("common/"))) {
 			file += sizeof("common/") - 1;
 		}
 	}
 
 	if (TRUNCATE_LOGPATHS_TO_MAXCHARS > 0) {
-		truncateBeforeTokens(file, "/\\", TRUNCATE_LOGPATHS_TO_MAXCHARS, sstream);
+		truncateBeforeTokens(file, P_STATIC_STRING("/\\"), TRUNCATE_LOGPATHS_TO_MAXCHARS, sstream);
 	} else {
 		sstream << file;
 	}
 
-	sstream << ":" << line <<
-		" ]: ";
+	sstream << ":" << line << " ]: ";
 }
 
 static void
-_writeLogEntry(const StaticString &str) {
-	try {
-		writeExact(STDERR_FILENO, str.data(), str.size());
-	} catch (const SystemException &) {
-		/* The most likely reason why this fails is when the user has setup
-		 * Apache to log to a pipe (e.g. to a log rotation script). Upon
-		 * restarting the web server, the process that reads from the pipe
-		 * shuts down, so we can't write to it anymore. That's why we
-		 * just ignore write errors. It doesn't make sense to abort for
-		 * something like this.
-		 */
+writeExactWithoutOXT(int fd, const char *str, unsigned int size) {
+	/* We do not use writeExact() here because writeExact()
+	 * uses oxt::syscalls::write(), which is an interruption point and
+	 * which is slightly more expensive than a plain write().
+	 * Logging may block, but in most cases not indefinitely,
+	 * so we don't care if the write() here is not an interruption
+	 * point. If the write does block indefinitely then it's
+	 * probably a FIFO that is not opened on the other side.
+	 * In that case we can blame the user.
+	 */
+	ssize_t ret;
+	unsigned int written = 0;
+	while (written < size) {
+		do {
+			ret = write(fd, str + written, size - written);
+		} while (ret == -1 && errno == EINTR);
+		if (ret == -1) {
+			/* The most likely reason why this fails is when the user has setup
+			 * Apache to log to a pipe (e.g. to a log rotation script). Upon
+			 * restarting the web server, the process that reads from the pipe
+			 * shuts down, so we can't write to it anymore. That's why we
+			 * just ignore write errors. It doesn't make sense to abort for
+			 * something like this.
+			 */
+			break;
+		} else {
+			written += ret;
+		}
 	}
 }
 
 void
-_writeLogEntry(const std::string &str) {
-	_writeLogEntry(StaticString(str));
+_writeLogEntry(const char *str, unsigned int size) {
+	writeExactWithoutOXT(STDERR_FILENO, str, size);
 }
 
 void
-_writeLogEntry(const char *str, unsigned int size) {
-	_writeLogEntry(StaticString(str, size));
+_writeFileDescriptorLogEntry(const char *str, unsigned int size) {
+	writeExactWithoutOXT(fileDescriptorLog, str, size);
 }
 
 const char *
-_strdupStringStream(const std::stringstream &stream) {
-	string str = stream.str();
-	char *buf = (char *) malloc(str.size() + 1);
-	memcpy(buf, str.data(), str.size());
-	buf[str.size()] = '\0';
+_strdupFastStringStream(const FastStringStream<> &stream) {
+	char *buf = (char *) malloc(stream.size() + 1);
+	memcpy(buf, stream.data(), stream.size());
+	buf[stream.size()] = '\0';
 	return buf;
 }
 
@@ -167,7 +222,7 @@ realPrintAppOutput(char *buf, unsigned int bufSize,
 	pos = appendData(pos, end, ": ");
 	pos = appendData(pos, end, message, messageLen);
 	pos = appendData(pos, end, "\n");
-	_writeLogEntry(StaticString(buf, pos - buf));
+	_writeLogEntry(buf, pos - buf);
 }
 
 void