passenger_dudemeister 3.0.1

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) 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
+ * 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,57 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * 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
+ * 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 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.
+	#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,477 @@
+/*
+ * OXT - OS eXtensions for boosT
+ * Provides important functionality necessary for writing robust server software.
+ *
+ * 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
+ * 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)
+
+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;
+	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;
+}
+
+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;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::close(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;
+	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;
+	#ifdef _AIX53
+		CHECK_INTERRUPTION(
+			ret == -1,
+			ret = ::nrecvmsg(s, msg, flags)
+		);
+	#else
+		CHECK_INTERRUPTION(
+			ret == -1,
+			ret = ::recvmsg(s, msg, flags)
+		);
+	#endif
+	return ret;
+}
+
+ssize_t
+syscalls::sendmsg(int s, const struct msghdr *msg, int flags) {
+	ssize_t ret;
+	#ifdef _AIX53
+		CHECK_INTERRUPTION(
+			ret == -1,
+			ret = ::nsendmsg(s, msg, flags)
+		);
+	#else
+		CHECK_INTERRUPTION(
+			ret == -1,
+			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;
+}
+
+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;
+}
+
+int
+syscalls::poll(struct pollfd fds[], nfds_t nfds, int timeout) {
+	int ret;
+	CHECK_INTERRUPTION(
+		ret == -1,
+		ret = ::poll(fds, nfds, timeout)
+	);
+	return ret;
+}
+
+FILE *
+syscalls::fopen(const char *path, const char *mode) {
+	FILE *ret;
+	CHECK_INTERRUPTION(
+		ret == NULL,
+		ret = ::fopen(path, 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;
+	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;
+}
+
+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
+	// 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;
+}
+
+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;
+	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;
+}
+