passenger 2.0.6 → 2.1.2

data/ext/oxt/detail/tracable_exception_enabled.hpp

@@ -0,0 +1,48 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <string>
+#include <exception>
+#include <list>
+
+namespace oxt {
+
+struct trace_point;
+
+/**
+ * Exception class with backtrace support. See backtrace.hpp for details.
+ */
+class tracable_exception: public std::exception {
+private:
+	std::list<trace_point *> backtrace_copy;
+public:
+	tracable_exception();
+	tracable_exception(const tracable_exception &other);
+	virtual ~tracable_exception() throw();
+	virtual std::string backtrace() const throw();
+	virtual const char *what() const throw();
+};
+
+} // namespace oxt
+

data/ext/oxt/macros.hpp

@@ -0,0 +1,58 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef _OXT_MACROS_HPP_
+#define _OXT_MACROS_HPP_
+
+/**
+ * Specialized macros.
+ *
+ * These macros provide more specialized features which are not needed
+ * so often by application programmers.
+ */
+
+#if (defined(__GNUC__) && (__GNUC__ > 2) && !defined(OXT_DEBUG)) || defined(IN_DOXYGEN)
+	/**
+	 * Indicate that the given expression is likely to be true.
+	 * This allows the CPU to better perform branch prediction.
+	 *
+	 * Defining OXT_DEBUG will cause this macro to become an
+	 * empty stub.
+	 */
+	#define OXT_LIKELY(expr) __builtin_expect((expr), 1)
+	
+	/**
+	 * Indicate that the given expression is likely to be false.
+	 * This allows the CPU to better perform branch prediction.
+	 *
+	 * Defining OXT_DEBUG will cause this macro to become an
+	 * empty stub.
+	 */
+	#define OXT_UNLIKELY(expr) __builtin_expect((expr), 0)
+#else
+	#define OXT_LIKELY(expr) expr
+	#define OXT_UNLIKELY(expr) expr
+#endif
+
+#endif /* _OXT_MACROS_HPP_ */

data/ext/oxt/spin_lock.hpp

@@ -0,0 +1,55 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#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
+#if defined(__OpenBSD__) || defined(__SOLARIS9__) || defined(__APPLE__)
+	#define OXT_NO_PTHREAD_SPINLOCKS
+#endif
+
+#ifndef GCC_VERSION
+	#define GCC_VERSION (__GNUC__ * 10000 \
+	                     + __GNUC_MINOR__ * 100 \
+	                     + __GNUC_PATCH_LEVEL__)
+#endif
+
+#if (GCC_VERSION > 40100 && defined(__i386__)) || 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.
+	#include "detail/spin_lock_gcc_x86.hpp"
+#elif !defined(WIN32) && !defined(OXT_NO_PTHREAD_SPINLOCKS)
+	#include "detail/spin_lock_pthreads.hpp"
+#else
+	#include "detail/spin_lock_portable.hpp"
+#endif
+
+#endif /* _OXT_SPIN_LOCK_HPP_ */
+

data/ext/{apache2/System.cpp → oxt/system_calls.cpp}

@@ -1,58 +1,50 @@
 /*
- *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (C) 2008  Phusion
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
  *
- *  Phusion Passenger is a trademark of Hongli Lai & Ninh Bui.
+ * Copyright (c) 2008 Phusion
  *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; version 2 of the License.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
  *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
  *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
  */
-#include "System.h"
-
-/*************************************
- * boost::this_thread
- *************************************/
+#include "system_calls.hpp"
+#include <boost/thread.hpp>
+#include <cerrno>
 
 using namespace boost;
-
-thread_specific_ptr<bool> this_thread::_syscalls_interruptable;
-
-
-bool
-this_thread::syscalls_interruptable() {
-	return _syscalls_interruptable.get() == NULL || *_syscalls_interruptable;
-}
+using namespace oxt;
 
 
 /*************************************
- * Passenger
+ * oxt
  *************************************/
 
-using namespace Passenger;
-
-static bool interrupted = false;
-
 static void
-interruptionSignalHandler(int sig) {
-	interrupted = true;
+interruption_signal_handler(int sig) {
+	// Do nothing.
 }
 
 void
-Passenger::setupSyscallInterruptionSupport() {
+oxt::setup_syscall_interruption_support() {
 	struct sigaction action;
 	int ret;
 	
-	action.sa_handler = interruptionSignalHandler;
+	action.sa_handler = interruption_signal_handler;
 	action.sa_flags   = 0;
 	sigemptyset(&action.sa_mask);
 	do {
@@ -65,7 +57,7 @@ Passenger::setupSyscallInterruptionSupport() {
 
 
 /*************************************
- * Passenger::InterruptableCalls
+ * Passenger::syscalls
  *************************************/
 
 #define CHECK_INTERRUPTION(error_expression, code) \
@@ -83,7 +75,7 @@ Passenger::setupSyscallInterruptionSupport() {
 	} while (false)
 
 ssize_t
-InterruptableCalls::read(int fd, void *buf, size_t count) {
+syscalls::read(int fd, void *buf, size_t count) {
 	ssize_t ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -93,7 +85,7 @@ InterruptableCalls::read(int fd, void *buf, size_t count) {
 }
 
 ssize_t
-InterruptableCalls::write(int fd, const void *buf, size_t count) {
+syscalls::write(int fd, const void *buf, size_t count) {
 	ssize_t ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -103,7 +95,7 @@ InterruptableCalls::write(int fd, const void *buf, size_t count) {
 }
 
 int
-InterruptableCalls::close(int fd) {
+syscalls::close(int fd) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -113,7 +105,27 @@ InterruptableCalls::close(int fd) {
 }
 
 int
-InterruptableCalls::socketpair(int d, int type, int protocol, int sv[2]) {
+syscalls::connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::connect(sockfd, serv_addr, addrlen);
+	);
+	return ret;
+}
+
+int
+syscalls::socket(int domain, int type, int protocol) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::socket(domain, type, protocol)
+	);
+	return ret;
+}
+
+int
+syscalls::socketpair(int d, int type, int protocol, int sv[2]) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -123,7 +135,7 @@ InterruptableCalls::socketpair(int d, int type, int protocol, int sv[2]) {
 }
 
 ssize_t
-InterruptableCalls::recvmsg(int s, struct msghdr *msg, int flags) {
+syscalls::recvmsg(int s, struct msghdr *msg, int flags) {
 	ssize_t ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -133,7 +145,7 @@ InterruptableCalls::recvmsg(int s, struct msghdr *msg, int flags) {
 }
 
 ssize_t
-InterruptableCalls::sendmsg(int s, const struct msghdr *msg, int flags) {
+syscalls::sendmsg(int s, const struct msghdr *msg, int flags) {
 	ssize_t ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -143,7 +155,17 @@ InterruptableCalls::sendmsg(int s, const struct msghdr *msg, int flags) {
 }
 
 int
-InterruptableCalls::shutdown(int s, int how) {
+syscalls::setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::setsockopt(s, level, optname, optval, optlen)
+	);
+	return ret;
+}
+
+int
+syscalls::shutdown(int s, int how) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -153,7 +175,7 @@ InterruptableCalls::shutdown(int s, int how) {
 }
 
 FILE *
-InterruptableCalls::fopen(const char *path, const char *mode) {
+syscalls::fopen(const char *path, const char *mode) {
 	FILE *ret;
 	CHECK_INTERRUPTION(
 		ret == NULL,
@@ -163,7 +185,7 @@ InterruptableCalls::fopen(const char *path, const char *mode) {
 }
 
 int
-InterruptableCalls::fclose(FILE *fp) {
+syscalls::fclose(FILE *fp) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == EOF,
@@ -173,7 +195,7 @@ InterruptableCalls::fclose(FILE *fp) {
 }
 
 time_t
-InterruptableCalls::time(time_t *t) {
+syscalls::time(time_t *t) {
 	time_t ret;
 	CHECK_INTERRUPTION(
 		ret == (time_t) -1,
@@ -183,15 +205,15 @@ InterruptableCalls::time(time_t *t) {
 }
 
 int
-InterruptableCalls::usleep(useconds_t usec) {
+syscalls::usleep(useconds_t usec) {
 	struct timespec spec;
 	spec.tv_sec = usec / 1000000;
 	spec.tv_nsec = usec % 1000000;
-	return InterruptableCalls::nanosleep(&spec, NULL);
+	return syscalls::nanosleep(&spec, NULL);
 }
 
 int
-InterruptableCalls::nanosleep(const struct timespec *req, struct timespec *rem) {
+syscalls::nanosleep(const struct timespec *req, struct timespec *rem) {
 	struct timespec req2 = *req;
 	struct timespec rem2;
 	int ret, e;
@@ -211,7 +233,7 @@ InterruptableCalls::nanosleep(const struct timespec *req, struct timespec *rem)
 }
 
 pid_t
-InterruptableCalls::fork() {
+syscalls::fork() {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -221,7 +243,7 @@ InterruptableCalls::fork() {
 }
 
 int
-InterruptableCalls::kill(pid_t pid, int sig) {
+syscalls::kill(pid_t pid, int sig) {
 	int ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -231,7 +253,7 @@ InterruptableCalls::kill(pid_t pid, int sig) {
 }
 
 pid_t
-InterruptableCalls::waitpid(pid_t pid, int *status, int options) {
+syscalls::waitpid(pid_t pid, int *status, int options) {
 	pid_t ret;
 	CHECK_INTERRUPTION(
 		ret == -1,
@@ -240,3 +262,16 @@ InterruptableCalls::waitpid(pid_t pid, int *status, int options) {
 	return ret;
 }
 
+
+/*************************************
+ * boost::this_thread
+ *************************************/
+
+thread_specific_ptr<bool> this_thread::_syscalls_interruptable;
+
+
+bool
+this_thread::syscalls_interruptable() {
+	return _syscalls_interruptable.get() == NULL || *_syscalls_interruptable;
+}
+

data/ext/oxt/system_calls.hpp

@@ -0,0 +1,234 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * Copyright (c) 2008 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef _OXT_SYSTEM_CALLS_HPP_
+#define _OXT_SYSTEM_CALLS_HPP_
+
+#include <boost/thread/tss.hpp>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <signal.h>
+#include <cstdio>
+#include <ctime>
+#include <cassert>
+
+/**
+ * Support for interruption of blocking system calls and C library calls
+ *
+ * This file provides a framework for writing multithreading code that can
+ * be interrupted, even when blocked on system calls or C library calls.
+ *
+ * One must first call oxt::setup_syscall_interruption_support().
+ * Then one may use the functions in oxt::syscalls as drop-in replacements
+ * for system calls or C library functions. These functions throw
+ * boost::thread_interrupted upon interruption, instead of returning an EINTR
+ * error.
+ *
+ * System call interruption is disabled by default. As long as system call
+ * interruption is disabled, the replacement functions in oxt::syscalls will
+ * never throw boost::thread_interrupted, and they will ignore any EINTR errors.
+ * You can enable or disable system call interruption in the current scope
+ * by creating instances of boost::this_thread::enable_syscall_interruption
+ * and similar objects. This is similar to Boost thread interruption.
+ *
+ * <h2>How to interrupt</h2>
+ * Generally, oxt::thread::interrupt() and oxt::thread::interrupt_and_join()
+ * should be used for interrupting threads. These methods will interrupt
+ * the thread at all Boost interruption points, as well as system calls that
+ * are caled through the oxt::syscalls namespace. Do *not* use
+ * boost::thread::interrupt, because that will not honor system calls as
+ * interruption points.
+ *
+ * Under the hood, system calls are interrupted by sending a signal to the
+ * to a specific thread (note: sending a signal to a process will deliver the
+ * signal to the main thread).
+ *
+ * Any signal will do, but of course, one should only send a signal whose
+ * signal handler doesn't do undesirable things (such as aborting the entire
+ * program). That's why it's generally recommended that you only use
+ * oxt::INTERRUPTION_SIGNAL to interrupt system calls, because
+ * oxt::setup_syscall_interruption_support() installs an "nice" signal
+ * handler for that signal (though you should of course use
+ * oxt::thread::interrupt() instead of sending signals whenever
+ * possible).
+ *
+ * Note that sending a signal once may not interrupt the thread, because
+ * the thread may not be calling a system call at the time the signal was
+ * received. So one must keep sending signals periodically until the
+ * thread has quit.
+ *
+ * @warning
+ * After oxt::setup_syscall_interruption_support() is called, sending a signal
+ * will cause system calls to return with an EINTR error. The oxt::syscall
+ * functions will automatically take care of this, but if you're calling any
+ * system calls without using that namespace, then you should check for and
+ * take care of EINTR errors.
+ */
+
+// This is one of the things that Java is good at and C++ sucks at. Sigh...
+
+namespace oxt {
+	static const int INTERRUPTION_SIGNAL = SIGINT;
+	
+	/**
+	 * Setup system call interruption support.
+	 * This function may only be called once. It installs a signal handler
+	 * for INTERRUPTION_SIGNAL, so one should not install a different signal
+	 * handler for that signal after calling this function.
+	 *
+	 * @warning
+	 * After oxt::setup_syscall_interruption_support() is called, sending a signal
+	 * will cause system calls to return with an EINTR error. The oxt::syscall
+	 * functions will automatically take care of this, but if you're calling any
+	 * system calls without using that namespace, then you should check for and
+	 * take care of EINTR errors.
+	 */
+	void setup_syscall_interruption_support();
+	
+	/**
+	 * System call and C library call wrappers with interruption support.
+	 * These functions are interruption points, i.e. they throw
+	 * boost::thread_interrupted whenever the calling thread is interrupted
+	 * by oxt::thread::interrupt() or oxt::thread::interrupt_and_join().
+	 */
+	namespace syscalls {
+		ssize_t read(int fd, void *buf, size_t count);
+		ssize_t write(int fd, const void *buf, size_t count);
+		int close(int fd);
+		
+		int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen);
+		int socket(int domain, int type, int protocol);
+		int socketpair(int d, int type, int protocol, int sv[2]);
+		ssize_t recvmsg(int s, struct msghdr *msg, int flags);
+		ssize_t sendmsg(int s, const struct msghdr *msg, int flags);
+		int setsockopt(int s, int level, int optname, const void *optval,
+			socklen_t optlen);
+		int shutdown(int s, int how);
+		
+		FILE *fopen(const char *path, const char *mode);
+		int fclose(FILE *fp);
+		
+		time_t time(time_t *t);
+		int usleep(useconds_t usec);
+		int nanosleep(const struct timespec *req, struct timespec *rem);
+		
+		pid_t fork();
+		int kill(pid_t pid, int sig);
+		pid_t waitpid(pid_t pid, int *status, int options);
+	}
+
+} // namespace oxt
+
+namespace boost {
+namespace this_thread {
+
+	/**
+	 * @intern
+	 */
+	extern thread_specific_ptr<bool> _syscalls_interruptable;
+	
+	/**
+	 * Check whether system calls should be interruptable in
+	 * the calling thread.
+	 */
+	bool syscalls_interruptable();
+	
+	class restore_syscall_interruption;
+
+	/**
+	 * Create this struct on the stack to temporarily enable system
+	 * call interruption, until the object goes out of scope.
+	 */
+	class enable_syscall_interruption {
+	private:
+		bool last_value;
+	public:
+		enable_syscall_interruption() {
+			if (_syscalls_interruptable.get() == NULL) {
+				last_value = true;
+				_syscalls_interruptable.reset(new bool(true));
+			} else {
+				last_value = *_syscalls_interruptable;
+				*_syscalls_interruptable = true;
+			}
+		}
+		
+		~enable_syscall_interruption() {
+			*_syscalls_interruptable = last_value;
+		}
+	};
+	
+	/**
+	 * Create this struct on the stack to temporarily disable system
+	 * call interruption, until the object goes out of scope.
+	 * While system call interruption is disabled, the functions in
+	 * InterruptableCalls will try until the return code is not EINTR.
+	 */
+	class disable_syscall_interruption {
+	private:
+		friend class restore_syscall_interruption;
+		bool last_value;
+	public:
+		disable_syscall_interruption() {
+			if (_syscalls_interruptable.get() == NULL) {
+				last_value = true;
+				_syscalls_interruptable.reset(new bool(false));
+			} else {
+				last_value = *_syscalls_interruptable;
+				*_syscalls_interruptable = false;
+			}
+		}
+		
+		~disable_syscall_interruption() {
+			*_syscalls_interruptable = last_value;
+		}
+	};
+	
+	/**
+	 * Creating an object of this class on the stack will restore the
+	 * system call interruption state to what it was before.
+	 */
+	class restore_syscall_interruption {
+	private:
+		int last_value;
+	public:
+		restore_syscall_interruption(const disable_syscall_interruption &intr) {
+			assert(_syscalls_interruptable.get() != NULL);
+			last_value = *_syscalls_interruptable;
+			*_syscalls_interruptable = intr.last_value;
+		}
+		
+		~restore_syscall_interruption() {
+			*_syscalls_interruptable = last_value;
+		}
+	};
+
+} // namespace this_thread
+} // namespace boost
+
+#endif /* _OXT_SYSTEM_CALLS_HPP_ */
+