passenger-jmazzi 2.2.9

data/ext/oxt/detail/spin_lock_gcc_x86.hpp

@@ -0,0 +1,82 @@
+/*
+ * 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 <boost/noncopyable.hpp>
+
+namespace oxt {
+
+/**
+ * A spin lock. It's more efficient than a mutex for locking very small
+ * critical sections with few contentions, but less efficient otherwise.
+ *
+ * The interface is similar to that of boost::mutex.
+ */
+class spin_lock {
+private:
+	int exclusion;
+
+public:
+	/**
+	 * Instantiate this class to lock a spin lock within a scope.
+	 */
+	class scoped_lock: boost::noncopyable {
+	private:
+		spin_lock &l;
+		
+	public:
+		scoped_lock(spin_lock &lock): l(lock) {
+			l.lock();
+		}
+		
+		~scoped_lock() {
+			l.unlock();
+		}
+	};
+
+	spin_lock(): exclusion(0) { }
+	
+	/**
+	 * Lock this spin lock.
+	 * @throws boost::thread_resource_error Something went wrong.
+	 */
+	void lock() {
+		while (__sync_lock_test_and_set(&exclusion, 1)) {
+			// Do nothing. This GCC builtin instruction
+			// ensures memory barrier.
+		}
+	}
+
+	/**
+	 * Unlock this spin lock.
+	 * @throws boost::thread_resource_error Something went wrong.
+	 */
+	void unlock() {
+		__sync_synchronize(); // Memory barrier.
+		exclusion = 0;
+	}
+};
+
+} // namespace oxt
+

data/ext/oxt/detail/spin_lock_portable.hpp

@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+/*
+ * Portable implementation of a spin lock.
+ * This is actually just a mutex...
+ *
+ * See spin_lock_gcc_x86.hpp for API documentation.
+ */
+
+#include <boost/thread/mutex.hpp>
+
+namespace oxt {
+	typedef boost::mutex spin_lock;
+}
+

data/ext/oxt/detail/spin_lock_pthreads.hpp

@@ -0,0 +1,97 @@
+/*
+ * 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 <boost/noncopyable.hpp>
+#include <pthread.h>
+#include <errno.h>
+#include "../macros.hpp"
+
+/*
+ * Implementation of a spin lock using POSIX pthread spin locks.
+ *
+ * See spin_lock_gcc_x86.hpp for API documentation.
+ */
+
+namespace oxt {
+
+class spin_lock {
+private:
+	pthread_spinlock_t spin;
+
+public:
+	class scoped_lock: boost::noncopyable {
+	private:
+		spin_lock &l;
+		
+	public:
+		scoped_lock(spin_lock &lock): l(lock) {
+			l.lock();
+		}
+		
+		~scoped_lock() {
+			l.unlock();
+		}
+	};
+
+	spin_lock() {
+		int ret;
+		do {
+			ret = pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE);
+		} while (ret == EINTR);
+		if (ret != 0) {
+			throw boost::thread_resource_error("Cannot initialize a spin lock", ret);
+		}
+	}
+	
+	~spin_lock() {
+		int ret;
+		do {
+			ret = pthread_spin_destroy(&spin);
+		} while (ret == EINTR);
+	}
+	
+	void lock() {
+		int ret;
+		do {
+			ret = pthread_spin_lock(&spin);
+		} while (OXT_UNLIKELY(ret == EINTR));
+		if (OXT_UNLIKELY(ret != 0)) {
+			throw boost::thread_resource_error("Cannot lock spin lock", ret);
+		}
+	}
+
+	void unlock() {
+		int ret;
+		do {
+			ret = pthread_spin_unlock(&spin);
+		} while (OXT_UNLIKELY(ret == EINTR));
+		if (OXT_UNLIKELY(ret != 0)) {
+			throw boost::thread_resource_error("Cannot unlock spin lock", ret);
+		}
+	}
+};
+
+} // namespace oxt
+

data/ext/oxt/detail/tracable_exception_disabled.hpp

@@ -0,0 +1,46 @@
+/*
+ * 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 <exception>
+#include <string>
+
+// Dummy implementation for tracable_exception.hpp.
+// See detail/tracable_exception_enabled.hpp for API documentation.
+
+namespace oxt {
+
+class tracable_exception: public std::exception {
+public:
+	virtual std::string backtrace() const throw() {
+		return "     (backtrace support disabled during compile time)\n";
+	}
+	
+	virtual const char *what() const throw() {
+		return "oxt::tracable_exception";
+	}
+};
+
+} // namespace oxt
+

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 OXT_GCC_VERSION
+	#define OXT_GCC_VERSION (__GNUC__ * 10000 \
+	                     + __GNUC_MINOR__ * 100 \
+	                     + __GNUC_PATCH_LEVEL__)
+#endif
+
+#if (OXT_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/oxt/system_calls.cpp

@@ -0,0 +1,351 @@
+/*
+ * 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 "system_calls.hpp"
+#include <boost/thread.hpp>
+#include <cerrno>
+
+using namespace boost;
+using namespace oxt;
+
+
+/*************************************
+ * oxt
+ *************************************/
+
+static void
+interruption_signal_handler(int sig) {
+	// Do nothing.
+}
+
+void
+oxt::setup_syscall_interruption_support() {
+	struct sigaction action;
+	sigset_t signal_set;
+	int ret;
+	
+	/* Very important! The signal mask is inherited across fork()
+	 * and exec() and we don't know what the parent process did to
+	 * us. At least on OS X, having a signal mask blocking important
+	 * signals can lead to stuff like waitpid() malfunction.
+	 */
+	sigemptyset(&signal_set);
+	do {
+		ret = sigprocmask(SIG_SETMASK, &signal_set, NULL);
+	} while (ret == -1 && errno == EINTR);
+	
+	action.sa_handler = interruption_signal_handler;
+	action.sa_flags   = 0;
+	sigemptyset(&action.sa_mask);
+	do {
+		ret = sigaction(INTERRUPTION_SIGNAL, &action, NULL);
+	} while (ret == -1 && errno == EINTR);
+	do {
+		ret = siginterrupt(INTERRUPTION_SIGNAL, 1);
+	} while (ret == -1 && errno == EINTR);
+}
+
+
+/*************************************
+ * Passenger::syscalls
+ *************************************/
+
+#define CHECK_INTERRUPTION(error_expression, code) \
+	do { \
+		int _my_errno; \
+		do { \
+			code; \
+			_my_errno = errno; \
+		} while ((error_expression) && _my_errno == EINTR \
+			&& !this_thread::syscalls_interruptable()); \
+		if ((error_expression) && _my_errno == EINTR && this_thread::syscalls_interruptable()) { \
+			throw thread_interrupted(); \
+		} \
+		errno = _my_errno; \
+	} while (false)
+
+ssize_t
+syscalls::read(int fd, void *buf, size_t count) {
+	ssize_t ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::read(fd, buf, count)
+	);
+	return ret;
+}
+
+ssize_t
+syscalls::write(int fd, const void *buf, size_t count) {
+	ssize_t ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::write(fd, buf, count)
+	);
+	return ret;
+}
+
+int
+syscalls::close(int fd) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::close(fd)
+	);
+	return ret;
+}
+
+int
+syscalls::accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::accept(sockfd, addr, addrlen)
+	);
+	return ret;
+}
+
+int
+syscalls::bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::bind(sockfd, addr, addrlen)
+	);
+	return ret;
+}
+
+int
+syscalls::connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen) {
+	int ret;
+	// FIXME: I don't think this is entirely correct.
+	// http://www.madore.org/~david/computers/connect-intr.html
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::connect(sockfd, serv_addr, addrlen);
+	);
+	return ret;
+}
+
+int
+syscalls::listen(int sockfd, int backlog) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::listen(sockfd, backlog)
+	);
+	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,
+		ret = ::socketpair(d, type, protocol, sv)
+	);
+	return ret;
+}
+
+ssize_t
+syscalls::recvmsg(int s, struct msghdr *msg, int flags) {
+	ssize_t ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		#ifdef _AIX53
+			ret = ::nrecvmsg(s, msg, flags)
+		#else
+			ret = ::recvmsg(s, msg, flags)
+		#endif
+	);
+	return ret;
+}
+
+ssize_t
+syscalls::sendmsg(int s, const struct msghdr *msg, int flags) {
+	ssize_t ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		#ifdef _AIX53
+			ret = ::nsendmsg(s, msg, flags)
+		#else
+			ret = ::sendmsg(s, msg, flags)
+		#endif
+	);
+	return ret;
+}
+
+int
+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,
+		ret = ::shutdown(s, how)
+	);
+	return ret;
+}
+
+FILE *
+syscalls::fopen(const char *path, const char *mode) {
+	FILE *ret;
+	CHECK_INTERRUPTION(
+		ret == NULL,
+		ret = ::fopen(path, mode)
+	);
+	return ret;
+}
+
+int
+syscalls::fclose(FILE *fp) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == EOF,
+		ret = ::fclose(fp)
+	);
+	return ret;
+}
+
+int
+syscalls::unlink(const char *pathname) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::unlink(pathname)
+	);
+	return ret;
+}
+
+int
+syscalls::stat(const char *path, struct stat *buf) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::stat(path, buf)
+	);
+	return ret;
+}
+
+time_t
+syscalls::time(time_t *t) {
+	time_t ret;
+	CHECK_INTERRUPTION(
+		ret == (time_t) -1,
+		ret = ::time(t)
+	);
+	return ret;
+}
+
+int
+syscalls::usleep(useconds_t usec) {
+	// We use syscalls::nanosleep() here to reuse the code that sleeps
+	// for the remaining amount of time, if a signal was received but
+	// system call interruption is disabled.
+	struct timespec spec;
+	spec.tv_sec = usec / 1000000;
+	spec.tv_nsec = usec % 1000000 * 1000;
+	return syscalls::nanosleep(&spec, NULL);
+}
+
+int
+syscalls::nanosleep(const struct timespec *req, struct timespec *rem) {
+	struct timespec req2 = *req;
+	struct timespec rem2;
+	int ret, e;
+	do {
+		ret = ::nanosleep(&req2, &rem2);
+		e = errno;
+		req2 = rem2;
+	} while (ret == -1 && e == EINTR && !this_thread::syscalls_interruptable());
+	if (ret == -1 && e == EINTR && this_thread::syscalls_interruptable()) {
+		throw thread_interrupted();
+	}
+	errno = e;
+	if (ret == 0 && rem) {
+		*rem = rem2;
+	}
+	return ret;
+}
+
+pid_t
+syscalls::fork() {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::fork()
+	);
+	return ret;
+}
+
+int
+syscalls::kill(pid_t pid, int sig) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::kill(pid, sig)
+	);
+	return ret;
+}
+
+pid_t
+syscalls::waitpid(pid_t pid, int *status, int options) {
+	pid_t ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::waitpid(pid, status, 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;
+}
+