passenger 2.2.15 → 3.0.0.pre1

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) 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/spin_lock.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
@@ -40,7 +40,9 @@
 	                     + __GNUC_PATCH_LEVEL__)
 #endif
 
-#if (OXT_GCC_VERSION > 40100 && defined(__i386__)) || defined(IN_DOXYGEN)
+#if defined(__APPLE__)
+	#include "detail/spin_lock_darwin.hpp"
+#elif (OXT_GCC_VERSION > 40100 && (defined(__i386__) || defined(__x86_64__))) || defined(IN_DOXYGEN)
 	// GCC 4.0 doesn't support __sync instructions while GCC 4.2
 	// does. I'm not sure whether support for it started in 4.1 or
 	// 4.2, so the above version check may have to be changed later.

data/ext/oxt/system_calls.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
@@ -85,6 +85,26 @@ oxt::setup_syscall_interruption_support() {
 		errno = _my_errno; \
 	} while (false)
 
+int
+syscalls::open(const char *path, int oflag) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::open(path, oflag)
+	);
+	return ret;
+}
+
+int
+syscalls::open(const char *path, int oflag, mode_t mode) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::open(path, oflag, mode)
+	);
+	return ret;
+}
+
 ssize_t
 syscalls::read(int fd, void *buf, size_t count) {
 	ssize_t ret;
@@ -105,6 +125,16 @@ syscalls::write(int fd, const void *buf, size_t count) {
 	return ret;
 }
 
+ssize_t
+syscalls::writev(int fd, const struct iovec *iov, int iovcnt) {
+	ssize_t ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::writev(fd, iov, iovcnt)
+	);
+	return ret;
+}
+
 int
 syscalls::close(int fd) {
 	int ret;
@@ -115,6 +145,26 @@ syscalls::close(int fd) {
 	return ret;
 }
 
+int
+syscalls::pipe(int filedes[2]) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::pipe(filedes)
+	);
+	return ret;
+}
+
+int
+syscalls::dup2(int filedes, int filedes2) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::dup2(filedes, filedes2)
+	);
+	return ret;
+}
+
 int
 syscalls::accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
 	int ret;
@@ -180,28 +230,34 @@ syscalls::socketpair(int d, int type, int protocol, int sv[2]) {
 ssize_t
 syscalls::recvmsg(int s, struct msghdr *msg, int flags) {
 	ssize_t ret;
-	CHECK_INTERRUPTION(
-		ret == -1,
-		#ifdef _AIX53
+	#ifdef _AIX53
+		CHECK_INTERRUPTION(
+			ret == -1,
 			ret = ::nrecvmsg(s, msg, flags)
-		#else
+		);
+	#else
+		CHECK_INTERRUPTION(
+			ret == -1,
 			ret = ::recvmsg(s, msg, flags)
-		#endif
-	);
+		);
+	#endif
 	return ret;
 }
 
 ssize_t
 syscalls::sendmsg(int s, const struct msghdr *msg, int flags) {
 	ssize_t ret;
-	CHECK_INTERRUPTION(
-		ret == -1,
-		#ifdef _AIX53
+	#ifdef _AIX53
+		CHECK_INTERRUPTION(
+			ret == -1,
 			ret = ::nsendmsg(s, msg, flags)
-		#else
+		);
+	#else
+		CHECK_INTERRUPTION(
+			ret == -1,
 			ret = ::sendmsg(s, msg, flags)
-		#endif
-	);
+		);
+	#endif
 	return ret;
 }
 
@@ -225,6 +281,16 @@ syscalls::shutdown(int s, int how) {
 	return ret;
 }
 
+int
+syscalls::select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::select(nfds, readfds, writefds, errorfds, timeout)
+	);
+	return ret;
+}
+
 FILE *
 syscalls::fopen(const char *path, const char *mode) {
 	FILE *ret;
@@ -235,6 +301,16 @@ syscalls::fopen(const char *path, const char *mode) {
 	return ret;
 }
 
+size_t
+syscalls::fread(void *ptr, size_t size, size_t nitems, FILE *stream) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == 0 && ferror(stream),
+		ret = ::fread(ptr, size, nitems, stream)
+	);
+	return ret;
+}
+
 int
 syscalls::fclose(FILE *fp) {
 	int ret;
@@ -275,6 +351,36 @@ syscalls::time(time_t *t) {
 	return ret;
 }
 
+unsigned int
+syscalls::sleep(unsigned int seconds) {
+	// We use syscalls::nanosleep() here not only to reuse interruption
+	// handling code, but also to avoid potentional infinite loops
+	// in combination with oxt::thread::interrupt_and_join().
+	// Upon interruption sleep() returns the number of seconds unslept
+	// but interrupt_and_join() keeps interrupting the thread every 10
+	// msec. Depending on the implementation of sleep(), it might return
+	// the same value as its original argument. A naive implementation
+	// of syscalls::sleep() that sleeps again with the return value
+	// could easily cause an infinite loop. nanosleep() has a large
+	// enough resolution so it won't trigger the problem.
+	struct timespec spec, rem;
+	int ret;
+	
+	spec.tv_sec = seconds;
+	spec.tv_nsec = 0;
+	ret = syscalls::nanosleep(&spec, &rem);
+	if (ret == 0) {
+		return 0;
+	} else if (errno == EINTR) {
+		return rem.tv_sec;
+	} else {
+		// No sure what to do here. There's an error
+		// but we can't return -1. Let's just hope
+		// this never happens.
+		return 0;
+	}
+}
+
 int
 syscalls::usleep(useconds_t usec) {
 	// We use syscalls::nanosleep() here to reuse the code that sleeps
@@ -326,6 +432,16 @@ syscalls::kill(pid_t pid, int sig) {
 	return ret;
 }
 
+int
+syscalls::killpg(pid_t pgrp, int sig) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::killpg(pgrp, sig)
+	);
+	return ret;
+}
+
 pid_t
 syscalls::waitpid(pid_t pid, int *status, int options) {
 	pid_t ret;

data/ext/oxt/system_calls.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
@@ -30,8 +30,11 @@
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/socket.h>
+#include <sys/select.h>
+#include <sys/uio.h>
 #include <pthread.h>
 #include <unistd.h>
+#include <fcntl.h>
 #include <signal.h>
 #include <cstdio>
 #include <ctime>
@@ -96,7 +99,7 @@
 // This is one of the things that Java is good at and C++ sucks at. Sigh...
 
 namespace oxt {
-	static const int INTERRUPTION_SIGNAL = SIGUSR2;
+	static const int INTERRUPTION_SIGNAL = SIGUSR1; // SIGUSR2 is reserved by Valgrind...
 	
 	/**
 	 * Setup system call interruption support.
@@ -121,9 +124,14 @@ namespace oxt {
 	 * by oxt::thread::interrupt() or oxt::thread::interrupt_and_join().
 	 */
 	namespace syscalls {
+		int open(const char *path, int oflag);
+		int open(const char *path, int oflag, mode_t mode);
 		ssize_t read(int fd, void *buf, size_t count);
 		ssize_t write(int fd, const void *buf, size_t count);
+		ssize_t writev(int fd, const struct iovec *iov, int iovcnt);
 		int close(int fd);
+		int pipe(int filedes[2]);
+		int dup2(int filedes, int filedes2);
 		
 		int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
 		int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
@@ -137,17 +145,23 @@ namespace oxt {
 			socklen_t optlen);
 		int shutdown(int s, int how);
 		
+		int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds,
+		           struct timeval *timeout);
+		
 		FILE *fopen(const char *path, const char *mode);
+		size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
 		int fclose(FILE *fp);
 		int unlink(const char *pathname);
 		int stat(const char *path, struct stat *buf);
 		
 		time_t time(time_t *t);
+		unsigned int sleep(unsigned int seconds);
 		int usleep(useconds_t usec);
 		int nanosleep(const struct timespec *req, struct timespec *rem);
 		
 		pid_t fork();
 		int kill(pid_t pid, int sig);
+		int killpg(pid_t pgrp, int sig);
 		pid_t waitpid(pid_t pid, int *status, int options);
 	}
 

data/ext/oxt/thread.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

data/ext/oxt/thread.hpp

@@ -2,7 +2,7 @@
  * OXT - OS eXtensions for boosT
  * Provides important functionality necessary for writing robust server software.
  *
- * Copyright (c) 2008, 2009 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
@@ -230,8 +230,9 @@ public:
 	
 	/**
 	 * Interrupt the thread. This method behaves just like
-	 * boost::thread::interrupt(), but will also respect the interruption
-	 * points defined in oxt::syscalls.
+	 * boost::thread::interrupt(), but if <em>interruptSyscalls</em> is true
+	 * then it will also respect the interruption points defined in
+	 * oxt::syscalls.
 	 *
 	 * Note that an interruption request may get lost, depending on the
 	 * current execution point of the thread. Thus, one should call this
@@ -239,26 +240,30 @@ public:
 	 * interrupt_and_join() is a convenience method that implements this
 	 * pattern.
 	 */
-	void interrupt() {
+	void interrupt(bool interruptSyscalls = true) {
 		int ret;
 		
 		boost::thread::interrupt();
-		do {
-			ret = pthread_kill(native_handle(),
-				INTERRUPTION_SIGNAL);
-		} while (ret == EINTR);
+		if (interruptSyscalls) {
+			do {
+				ret = pthread_kill(native_handle(),
+					INTERRUPTION_SIGNAL);
+			} while (ret == EINTR);
+		}
 	}
 	
 	/**
 	 * Keep interrupting the thread until it's done, then join it.
 	 *
+	 * @param interruptSyscalls Whether oxt::syscalls calls should also
+	 *    be eligable for interruption.
 	 * @throws boost::thread_interrupted The calling thread has been
 	 *    interrupted before we could join this thread.
 	 */
-	void interrupt_and_join() {
+	void interrupt_and_join(bool interruptSyscalls = true) {
 		bool done = false;
 		while (!done) {
-			interrupt();
+			interrupt(interruptSyscalls);
 			done = timed_join(boost::posix_time::millisec(10));
 		}
 	}
@@ -269,18 +274,20 @@ public:
 	 *
 	 * @param timeout The maximum number of milliseconds that this method
 	 *                should keep trying.
+	 * @param interruptSyscalls Whether oxt::syscalls calls should also
+	 *    be eligable for interruption.
 	 * @return True if the thread was successfully joined, false if the
 	 *         timeout has been reached.
 	 * @throws boost::thread_interrupted The calling thread has been
 	 *    interrupted before we could join this thread.
 	 */
-	bool interrupt_and_join(unsigned int timeout) {
+	bool interrupt_and_join(unsigned int timeout, bool interruptSyscalls = true) {
 		bool joined = false, timed_out = false;
 		boost::posix_time::ptime deadline =
 			boost::posix_time::microsec_clock::local_time() +
 			boost::posix_time::millisec(timeout);
 		while (!joined && !timed_out) {
-			interrupt();
+			interrupt(interruptSyscalls);
 			joined = timed_join(boost::posix_time::millisec(10));
 			timed_out = !joined && boost::posix_time::microsec_clock::local_time() > deadline;
 		}
@@ -295,11 +302,15 @@ public:
 	 *
 	 * @param threads An array of threads to join.
 	 * @param size The number of elements in <em>threads</em>.
+	 * @param interruptSyscalls Whether oxt::syscalls calls should also
+	 *    be eligable for interruption.
 	 * @throws boost::thread_interrupted The calling thread has been
 	 *    interrupted before all threads have been joined. Some threads
 	 *    may have been successfully joined while others haven't.
 	 */
-	static void interrupt_and_join_multiple(oxt::thread **threads, unsigned int size) {
+	static void interrupt_and_join_multiple(oxt::thread **threads, unsigned int size,
+		bool interruptSyscalls = true)
+	{
 		std::list<oxt::thread *> remaining_threads;
 		std::list<oxt::thread *>::iterator it, current;
 		oxt::thread *thread;
@@ -312,7 +323,7 @@ public:
 		while (!remaining_threads.empty()) {
 			for (it = remaining_threads.begin(); it != remaining_threads.end(); it++) {
 				thread = *it;
-				thread->interrupt();
+				thread->interrupt(interruptSyscalls);
 			}
 			for (it = remaining_threads.begin(); it != remaining_threads.end(); it++) {
 				thread = *it;
@@ -329,6 +340,30 @@ public:
 	}
 };
 
+/**
+ * Like boost::lock_guard, but is interruptable.
+ */
+template<typename TimedLockable>
+class interruptable_lock_guard {
+private:
+	TimedLockable &mutex;
+public:
+	interruptable_lock_guard(TimedLockable &m): mutex(m) {
+		bool locked = false;
+		
+		while (!locked) {
+			locked = m.timed_lock(boost::posix_time::milliseconds(20));
+			if (!locked) {
+				boost::this_thread::interruption_point();
+			}
+		}
+	}
+	
+	~interruptable_lock_guard() {
+		mutex.unlock();
+	}
+};
+
 } // namespace oxt
 
 #endif /* _OXT_THREAD_HPP_ */