passenger 3.0.21 → 3.9.1.beta

data/ext/oxt/{thread.cpp → initialize.hpp}

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2010 Phusion
+ * Copyright (c) 2012 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
@@ -22,11 +22,18 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-
-#include "thread.hpp"
+#ifndef _OXT_INITIALIZE_HPP_
+#define _OXT_INITIALIZE_HPP_
 
 namespace oxt {
-	boost::mutex _next_thread_number_mutex;
-	unsigned int _next_thread_number = 0;
-}
 
+/**
+ * OXT must be initialized for a lot of things to work properly.
+ * This does not enable system call interruption. Call setup_syscall_interruption_support()
+ * for that.
+ */
+void initialize();
+
+} // namespace oxt
+
+#endif /* _OXT_INITIALIZE_HPP_ */

data/ext/oxt/macros.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2010 Phusion
+ * Copyright (c) 2010, 2011, 2012 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
@@ -32,6 +32,10 @@
  * so often by application programmers.
  */
 
+#define OXT_GCC_VERSION (__GNUC__ * 10000 \
+                           + __GNUC_MINOR__ * 100 \
+                           + __GNUC_PATCHLEVEL__)
+
 #if (defined(__GNUC__) && (__GNUC__ > 2) && !defined(OXT_DEBUG)) || defined(IN_DOXYGEN)
 	/**
 	 * Indicate that the given expression is likely to be true.
@@ -55,4 +59,31 @@
 	#define OXT_UNLIKELY(expr) expr
 #endif
 
+/*
+ * 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).
+ *
+ * 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...
+ *
+ * On MacOS X, neither gcc nor llvm-gcc support the __thread keyword, but Clang
+ * does. It works on at least clang >= 3.0.
+ */
+#if defined(__APPLE__)
+	#if defined(__clang__) && __clang_major__ >= 3
+		#define OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+	#endif
+#elif defined(__GNUC__) && OXT_GCC_VERSION >= 40102
+	#if !defined(__SOLARIS__) && !defined(__OpenBSD__)
+		#define OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+	#endif
+#endif
+
 #endif /* _OXT_MACROS_HPP_ */

data/ext/oxt/spin_lock.hpp

@@ -25,21 +25,16 @@
 #ifndef _OXT_SPIN_LOCK_HPP_
 #define _OXT_SPIN_LOCK_HPP_
 
-// At the time of writing (July 22, 2008), these operating systems don't
-// support pthread spin locks:
-// - OpenBSD 4.3
-// - Solaris 9
-// - MacOS X
+#include "macros.hpp"
+
+// These operating systems don't support pthread spin locks:
+// - OpenBSD 4.3 (last checked: July 22, 2008)
+// - Solaris 9 (last checked: July 22, 2008)
+// - MacOS X (last checked: July 22, 2012)
 #if defined(__OpenBSD__) || defined(__SOLARIS9__) || defined(__APPLE__)
 	#define OXT_NO_PTHREAD_SPINLOCKS
 #endif
 
-#ifndef OXT_GCC_VERSION
-	#define OXT_GCC_VERSION (__GNUC__ * 10000 \
-	                     + __GNUC_MINOR__ * 100 \
-	                     + __GNUC_PATCH_LEVEL__)
-#endif
-
 #if defined(__APPLE__)
 	#include "detail/spin_lock_darwin.hpp"
 #elif (OXT_GCC_VERSION > 40100 && (defined(__i386__) || defined(__x86_64__))) || defined(IN_DOXYGEN)

data/ext/oxt/system_calls.cpp

@@ -23,6 +23,7 @@
  * THE SOFTWARE.
  */
 #include "system_calls.hpp"
+#include "detail/context.hpp"
 #include <boost/thread.hpp>
 #include <cerrno>
 
@@ -34,6 +35,9 @@ using namespace oxt;
  * oxt
  *************************************/
 
+static const ErrorChance *errorChances = NULL;
+static unsigned int nErrorChances = 0;
+
 static void
 interruption_signal_handler(int sig) {
 	// Do nothing.
@@ -66,19 +70,66 @@ oxt::setup_syscall_interruption_support() {
 	} while (ret == -1 && errno == EINTR);
 }
 
+void
+oxt::setup_random_failure_simulation(const ErrorChance *_errorChances, unsigned int n) {
+	ErrorChance *storage = new ErrorChance[n];
+	for (unsigned int i = 0; i < n; i++) {
+		storage[i] = _errorChances[i];
+	}
+	errorChances = storage;
+	nErrorChances = n;
+}
+
+static bool
+shouldSimulateFailure() {
+	if (nErrorChances > 0) {
+		double number = random() / (double) RAND_MAX;
+		const ErrorChance *candidates[nErrorChances];
+		unsigned int i, n = 0;
+
+		for (i = 0; i < nErrorChances; i++) {
+			if (number <= errorChances[i].chance) {
+				candidates[n] = &errorChances[i];
+				n++;
+			}
+		}
+
+		if (n > 0) {
+			int choice = random() % n;
+			errno = candidates[choice]->errorCode;
+			return true;
+		} else {
+			return false;
+		}
+	} else {
+		return false;
+	}
+}
+
 
 /*************************************
  * Passenger::syscalls
  *************************************/
 
-#define CHECK_INTERRUPTION(error_expression, code) \
+#define CHECK_INTERRUPTION(error_expression, allowSimulatingFailure, error_assignment, code) \
 	do { \
+		if (allowSimulatingFailure && shouldSimulateFailure()) { \
+			error_assignment; \
+			break; \
+		} \
+		thread_local_context *ctx = get_thread_local_context(); \
+		if (OXT_UNLIKELY(ctx != NULL)) { \
+			ctx->syscall_interruption_lock.unlock(); \
+		} \
 		int _my_errno; \
 		do { \
 			code; \
 			_my_errno = errno; \
 		} while ((error_expression) && _my_errno == EINTR \
 			&& !this_thread::syscalls_interruptable()); \
+		if (OXT_UNLIKELY(ctx != NULL)) { \
+			ctx->syscall_interruption_lock.lock(); \
+		} \
 		if ((error_expression) && _my_errno == EINTR && this_thread::syscalls_interruptable()) { \
 			throw thread_interrupted(); \
 		} \
@@ -90,6 +141,8 @@ syscalls::open(const char *path, int oflag) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::open(path, oflag)
 	);
 	return ret;
@@ -100,6 +153,8 @@ syscalls::open(const char *path, int oflag, mode_t mode) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::open(path, oflag, mode)
 	);
 	return ret;
@@ -110,6 +165,8 @@ syscalls::read(int fd, void *buf, size_t count) {
 	ssize_t ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::read(fd, buf, count)
 	);
 	return ret;
@@ -120,6 +177,8 @@ syscalls::write(int fd, const void *buf, size_t count) {
 	ssize_t ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::write(fd, buf, count)
 	);
 	return ret;
@@ -130,6 +189,8 @@ syscalls::writev(int fd, const struct iovec *iov, int iovcnt) {
 	ssize_t ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::writev(fd, iov, iovcnt)
 	);
 	return ret;
@@ -158,10 +219,21 @@ syscalls::close(int fd) {
 		int ret;
 		CHECK_INTERRUPTION(
 			ret == -1,
+			true,
+			ret = -1,
 			ret = ::close(fd)
 		);
 		return ret;
 	#else
+		if (shouldSimulateFailure()) {
+			return -1;
+		}
+		
+		thread_local_context *ctx = get_thread_local_context();
+		if (OXT_UNLIKELY(ctx != NULL)) {
+			ctx->syscall_interruption_lock.unlock();
+		}
+
 		/* TODO: If it's not known whether the OS releases the file
 		 * descriptor on EINTR-on-close(), we should print some kind of
 		 * warning here. This would actually explain why some people get
@@ -170,6 +242,11 @@ syscalls::close(int fd) {
 		 * behaviors.
 		 */
 		int ret = ::close(fd);
+		if (OXT_UNLIKELY(ctx != NULL)) {
+			int e = errno;
+			ctx->syscall_interruption_lock.lock();
+			errno = e;
+		}
 		if (ret == -1 && errno == EINTR && this_thread::syscalls_interruptable()) {
 			throw thread_interrupted();
 		} else {
@@ -183,6 +260,8 @@ syscalls::pipe(int filedes[2]) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::pipe(filedes)
 	);
 	return ret;
@@ -193,16 +272,44 @@ syscalls::dup2(int filedes, int filedes2) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::dup2(filedes, filedes2)
 	);
 	return ret;
 }
 
+int
+syscalls::mkdir(const char *pathname, mode_t mode) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		true,
+		ret = -1,
+		ret = ::mkdir(pathname, mode)
+	);
+	return ret;
+}
+
+int
+syscalls::chown(const char *path, uid_t owner, gid_t group) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		true,
+		ret = -1,
+		ret = ::chown(path, owner, group)
+	);
+	return ret;
+}
+
 int
 syscalls::accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::accept(sockfd, addr, addrlen)
 	);
 	return ret;
@@ -213,6 +320,8 @@ syscalls::bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::bind(sockfd, addr, addrlen)
 	);
 	return ret;
@@ -225,6 +334,8 @@ syscalls::connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrle
 	// http://www.madore.org/~david/computers/connect-intr.html
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::connect(sockfd, serv_addr, addrlen);
 	);
 	return ret;
@@ -235,6 +346,8 @@ syscalls::listen(int sockfd, int backlog) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::listen(sockfd, backlog)
 	);
 	return ret;
@@ -245,6 +358,8 @@ syscalls::socket(int domain, int type, int protocol) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::socket(domain, type, protocol)
 	);
 	return ret;
@@ -255,6 +370,8 @@ syscalls::socketpair(int d, int type, int protocol, int sv[2]) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::socketpair(d, type, protocol, sv)
 	);
 	return ret;
@@ -266,11 +383,15 @@ syscalls::recvmsg(int s, struct msghdr *msg, int flags) {
 	#ifdef _AIX53
 		CHECK_INTERRUPTION(
 			ret == -1,
+			true,
+			ret = -1,
 			ret = ::nrecvmsg(s, msg, flags)
 		);
 	#else
 		CHECK_INTERRUPTION(
 			ret == -1,
+			true,
+			ret = -1,
 			ret = ::recvmsg(s, msg, flags)
 		);
 	#endif
@@ -283,11 +404,15 @@ syscalls::sendmsg(int s, const struct msghdr *msg, int flags) {
 	#ifdef _AIX53
 		CHECK_INTERRUPTION(
 			ret == -1,
+			true,
+			ret = -1,
 			ret = ::nsendmsg(s, msg, flags)
 		);
 	#else
 		CHECK_INTERRUPTION(
 			ret == -1,
+			true,
+			ret = -1,
 			ret = ::sendmsg(s, msg, flags)
 		);
 	#endif
@@ -299,6 +424,8 @@ syscalls::setsockopt(int s, int level, int optname, const void *optval, socklen_
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::setsockopt(s, level, optname, optval, optlen)
 	);
 	return ret;
@@ -309,6 +436,8 @@ syscalls::shutdown(int s, int how) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::shutdown(s, how)
 	);
 	return ret;
@@ -319,6 +448,8 @@ syscalls::select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds,
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::select(nfds, readfds, writefds, errorfds, timeout)
 	);
 	return ret;
@@ -329,6 +460,8 @@ syscalls::poll(struct pollfd fds[], nfds_t nfds, int timeout) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::poll(fds, nfds, timeout)
 	);
 	return ret;
@@ -339,6 +472,8 @@ syscalls::fopen(const char *path, const char *mode) {
 	FILE *ret;
 	CHECK_INTERRUPTION(
 		ret == NULL,
+		true,
+		ret = NULL,
 		ret = ::fopen(path, mode)
 	);
 	return ret;
@@ -349,6 +484,8 @@ syscalls::fread(void *ptr, size_t size, size_t nitems, FILE *stream) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == 0 && ferror(stream),
+		true,
+		ret = 0,
 		ret = ::fread(ptr, size, nitems, stream)
 	);
 	return ret;
@@ -359,6 +496,8 @@ syscalls::fclose(FILE *fp) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == EOF,
+		true,
+		ret = EOF,
 		ret = ::fclose(fp)
 	);
 	return ret;
@@ -369,6 +508,8 @@ syscalls::unlink(const char *pathname) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::unlink(pathname)
 	);
 	return ret;
@@ -379,16 +520,32 @@ syscalls::stat(const char *path, struct stat *buf) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::stat(path, buf)
 	);
 	return ret;
 }
 
+int
+syscalls::lstat(const char *path, struct stat *buf) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		true,
+		ret = -1,
+		ret = ::lstat(path, buf)
+	);
+	return ret;
+}
+
 time_t
 syscalls::time(time_t *t) {
 	time_t ret;
 	CHECK_INTERRUPTION(
 		ret == (time_t) -1,
+		false,
+		(void) 0,
 		ret = ::time(t)
 	);
 	return ret;
@@ -440,20 +597,36 @@ syscalls::nanosleep(const struct timespec *req, struct timespec *rem) {
 	struct timespec req2 = *req;
 	struct timespec rem2;
 	int ret, e;
+
+	/* We never simulate failure in this function. */
+
+	thread_local_context *ctx = get_thread_local_context();
+	if (OXT_UNLIKELY(ctx != NULL)) {
+		ctx->syscall_interruption_lock.unlock();
+	}
+	
 	do {
 		ret = ::nanosleep(&req2, &rem2);
 		e = errno;
-		// nanosleep() on some systems is sometimes buggy. rem2
-		// could end up containing a tv_sec with a value near 2^32-1,
-		// probably because of integer wrapping bugs in the kernel.
-		// So we check for those.
-		if (rem2.tv_sec < req->tv_sec) {
-			req2 = rem2;
-		} else {
-			req2.tv_sec = 0;
-			req2.tv_nsec = 0;
+		if (ret == -1) {
+			/* nanosleep() on some systems is sometimes buggy. rem2
+			 * could end up containing a tv_sec with a value near 2^32-1,
+			 * probably because of integer wrapping bugs in the kernel.
+			 * So we check for those.
+			 */
+			if (rem2.tv_sec < req->tv_sec) {
+				req2 = rem2;
+			} else {
+				req2.tv_sec = 0;
+				req2.tv_nsec = 0;
+			}
 		}
 	} while (ret == -1 && e == EINTR && !this_thread::syscalls_interruptable());
+	
+	if (OXT_UNLIKELY(ctx != NULL)) {
+		ctx->syscall_interruption_lock.lock();
+	}
+	
 	if (ret == -1 && e == EINTR && this_thread::syscalls_interruptable()) {
 		throw thread_interrupted();
 	}
@@ -469,6 +642,8 @@ syscalls::fork() {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::fork()
 	);
 	return ret;
@@ -479,6 +654,8 @@ syscalls::kill(pid_t pid, int sig) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::kill(pid, sig)
 	);
 	return ret;
@@ -489,6 +666,8 @@ syscalls::killpg(pid_t pgrp, int sig) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::killpg(pgrp, sig)
 	);
 	return ret;
@@ -499,6 +678,8 @@ syscalls::waitpid(pid_t pid, int *status, int options) {
 	pid_t ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
+		true,
+		ret = -1,
 		ret = ::waitpid(pid, status, options)
 	);
 	return ret;
@@ -509,11 +690,18 @@ syscalls::waitpid(pid_t pid, int *status, int options) {
  * boost::this_thread
  *************************************/
 
-thread_specific_ptr<bool> this_thread::_syscalls_interruptable;
-
+#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+	__thread bool this_thread::_syscalls_interruptable = true;
 
-bool
-this_thread::syscalls_interruptable() {
-	return _syscalls_interruptable.get() == NULL || *_syscalls_interruptable;
-}
+	bool
+	this_thread::syscalls_interruptable() {
+		return _syscalls_interruptable;
+	}
+#else
+	thread_specific_ptr<bool> this_thread::_syscalls_interruptable;
 
+	bool
+	this_thread::syscalls_interruptable() {
+		return _syscalls_interruptable.get() == NULL || *_syscalls_interruptable;
+	}
+#endif