passenger 3.0.21 → 3.9.1.beta

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) 2010 Phusion
+ * Copyright (c) 2010-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
@@ -40,20 +40,26 @@
 #include <cstdio>
 #include <ctime>
 #include <cassert>
+#include "macros.hpp"
 
 /**
- * Support for interruption of blocking system calls and C library calls
+ * System call and C library call wrappers with extra features
  *
- * This file provides a framework for writing multithreading code that can
- * be interrupted, even when blocked on system calls or C library calls.
+ * This file provides wrappers for many system calls and C library calls
+ * and adds the following features:
  *
- * One must first call oxt::setup_syscall_interruption_support().
+ * - Interruption of blocking system calls and blocking C library calls.
+ * - Simulation of random failures.
+ *
+ * ## About system call interruption
+ *
+ * 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.
  *
- * Once setup_syscall_interruption_support() has been called, system call
+ * Once `setup_syscall_interruption_support()` has been called, system call
  * interruption is enabled by default. You can enable or disable system call
  * interruption in the current scope by creating instances of
  * boost::this_thread::enable_syscall_interruption or
@@ -63,7 +69,8 @@
  * boost::thread_interrupted, nor will they return EINTR errors. This is similar
  * to Boost thread interruption.
  *
- * <h2>How to interrupt</h2>
+ * ### How to interrupt
+ *
  * 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
@@ -89,12 +96,18 @@
  * 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
+ * **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.
+ *
+ * ## About random simulation of failures
+ *
+ * Call `oxt::setup_random_failure_simulation()` to initialize random
+ * failure simulation.
  */
 
 // This is one of the things that Java is good at and C++ sucks at. Sigh...
@@ -102,21 +115,14 @@
 namespace oxt {
 	static const int INTERRUPTION_SIGNAL = SIGUSR1; // SIGUSR2 is reserved by Valgrind...
 	
-	/**
-	 * 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. It also resets
-	 * the process signal mask.
-	 *
-	 * @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.
-	 */
+	struct ErrorChance {
+		double chance;
+		int errorCode;
+	};
+
 	void setup_syscall_interruption_support();
+
+	void setup_random_failure_simulation(const ErrorChance *errorChances, unsigned int n);
 	
 	/**
 	 * System call and C library call wrappers with interruption support.
@@ -133,6 +139,8 @@ namespace oxt {
 		int close(int fd);
 		int pipe(int filedes[2]);
 		int dup2(int filedes, int filedes2);
+		int mkdir(const char *pathname, mode_t mode);
+		int chown(const char *path, uid_t owner, gid_t group);
 		
 		int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
 		int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
@@ -155,6 +163,7 @@ namespace oxt {
 		int fclose(FILE *fp);
 		int unlink(const char *pathname);
 		int stat(const char *path, struct stat *buf);
+		int lstat(const char *path, struct stat *buf);
 		
 		time_t time(time_t *t);
 		unsigned int sleep(unsigned int seconds);
@@ -175,8 +184,12 @@ namespace this_thread {
 	/**
 	 * @intern
 	 */
-	extern thread_specific_ptr<bool> _syscalls_interruptable;
-	
+	#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+		extern __thread bool _syscalls_interruptable;
+	#else
+		extern thread_specific_ptr<bool> _syscalls_interruptable;
+	#endif
+
 	/**
 	 * Check whether system calls should be interruptable in
 	 * the calling thread.
@@ -194,17 +207,26 @@ namespace this_thread {
 		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;
-			}
+			#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+				last_value = _syscalls_interruptable;
+				_syscalls_interruptable = true;
+			#else
+				if (_syscalls_interruptable.get() == NULL) {
+					last_value = true;
+					_syscalls_interruptable.reset(new bool(true));
+				} else {
+					last_value = *_syscalls_interruptable;
+					*_syscalls_interruptable = true;
+				}
+			#endif
 		}
 		
 		~enable_syscall_interruption() {
-			*_syscalls_interruptable = last_value;
+			#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+				_syscalls_interruptable = last_value;
+			#else
+				*_syscalls_interruptable = last_value;
+			#endif
 		}
 	};
 	
@@ -220,17 +242,26 @@ namespace this_thread {
 		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;
-			}
+			#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+				last_value = _syscalls_interruptable;
+				_syscalls_interruptable = false;
+			#else
+				if (_syscalls_interruptable.get() == NULL) {
+					last_value = true;
+					_syscalls_interruptable.reset(new bool(false));
+				} else {
+					last_value = *_syscalls_interruptable;
+					*_syscalls_interruptable = false;
+				}
+			#endif
 		}
 		
 		~disable_syscall_interruption() {
-			*_syscalls_interruptable = last_value;
+			#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+				_syscalls_interruptable = last_value;
+			#else
+				*_syscalls_interruptable = last_value;
+			#endif
 		}
 	};
 	
@@ -243,13 +274,22 @@ namespace this_thread {
 		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;
+			#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+				last_value = _syscalls_interruptable;
+				_syscalls_interruptable = intr.last_value;
+			#else
+				assert(_syscalls_interruptable.get() != NULL);
+				last_value = *_syscalls_interruptable;
+				*_syscalls_interruptable = intr.last_value;
+			#endif
 		}
 		
 		~restore_syscall_interruption() {
-			*_syscalls_interruptable = last_value;
+			#ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
+				_syscalls_interruptable = last_value;
+			#else
+				*_syscalls_interruptable = last_value;
+			#endif
 		}
 	};
 

data/ext/oxt/thread.hpp

@@ -26,14 +26,11 @@
 #define _OXT_THREAD_HPP_
 
 #include <boost/thread.hpp>
-#include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
+#include <boost/make_shared.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include "system_calls.hpp"
-#include "backtrace.hpp"
-#ifdef OXT_BACKTRACE_IS_ENABLED
-	#include <sstream>
-#endif
+#include "detail/context.hpp"
 #include <string>
 #include <list>
 #include <unistd.h>
@@ -41,9 +38,6 @@
 
 namespace oxt {
 
-extern boost::mutex _next_thread_number_mutex;
-extern unsigned int _next_thread_number;
-
 /**
  * Enhanced thread class with support for:
  * - user-defined stack size.
@@ -52,63 +46,10 @@ extern unsigned int _next_thread_number;
  */
 class thread: public boost::thread {
 private:
-	struct thread_data {
-		std::string name;
-		#ifdef OXT_BACKTRACE_IS_ENABLED
-			thread_registration *registration;
-			boost::mutex registration_lock;
-			bool done;
-		#endif
-	};
-	
-	typedef boost::shared_ptr<thread_data> thread_data_ptr;
-	
-	thread_data_ptr data;
+	thread_local_context_ptr context;
 
-	void initialize_data(const std::string &thread_name) {
-		data = thread_data_ptr(new thread_data());
-		if (thread_name.empty()) {
-			boost::mutex::scoped_lock l(_next_thread_number_mutex);
-			std::stringstream str;
-			
-			str << "Thread #" << _next_thread_number;
-			_next_thread_number++;
-			data->name = str.str();
-		} else {
-			data->name = thread_name;
-		}
-		#ifdef OXT_BACKTRACE_IS_ENABLED
-			data->registration = NULL;
-			data->done = false;
-		#endif
-	}
-	
-	static void thread_main(const boost::function<void ()> func, thread_data_ptr data) {
-		#ifdef OXT_BACKTRACE_IS_ENABLED
-			initialize_backtrace_support_for_this_thread i(data->name);
-			data->registration = i.registration;
-		#endif
-		
-		#ifdef OXT_BACKTRACE_IS_ENABLED
-			// Put finalization code in a struct destructor,
-			// for exception safety.
-			struct finalization_routines {
-				thread_data_ptr &data;
-				
-				finalization_routines(thread_data_ptr &data_)
-					: data(data_) {}
-				
-				~finalization_routines() {
-					boost::mutex::scoped_lock l(data->registration_lock);
-					data->registration = NULL;
-					data->done = true;
-				}
-			};
-			finalization_routines f(data);
-		#endif
-		
-		func();
-	}
+	static std::string make_thread_name(const std::string &given_name);
+	static void thread_main(const boost::function<void ()> func, thread_local_context_ptr ctx);
 	
 public:
 	/**
@@ -129,10 +70,10 @@ public:
 	 * @throws boost::thread_resource_error Something went wrong during
 	 *     creation of the thread.
 	 */
-	explicit thread(const boost::function<void ()> func, const std::string &name = "", unsigned int stack_size = 0) {
-		initialize_data(name);
-		
-		set_thread_main_function(boost::bind(thread_main, func, data));
+	explicit thread(const boost::function<void ()> func, const std::string &name = std::string(), unsigned int stack_size = 0) {
+		context = thread_local_context::make_shared_ptr();
+		context->thread_name = make_thread_name(name);
+		set_thread_main_function(boost::bind(thread_main, func, context));
 		
 		unsigned long min_stack_size;
 		bool stack_min_size_defined;
@@ -180,53 +121,18 @@ public:
 	/**
 	 * Return this thread's name. The name was set during construction.
 	 */
-	std::string name() const throw() {
-		return data->name;
-	}
+	std::string name() const throw();
 	
 	/**
 	 * Return the current backtrace of the thread of execution, as a string.
 	 */
-	std::string backtrace() const throw() {
-		#ifdef OXT_BACKTRACE_IS_ENABLED
-			boost::mutex::scoped_lock l(data->registration_lock);
-			if (data->registration == NULL) {
-				if (data->done) {
-					return "     (no backtrace: thread has quit)";
-				} else {
-					return "     (no backtrace: thread hasn't been started yet)";
-				}
-			} else {
-				spin_lock::scoped_lock l2(*data->registration->backtrace_lock);
-				return _format_backtrace(data->registration->backtrace);
-			}
-		#else
-			return "    (backtrace support disabled during compile time)";
-		#endif
-	}
+	std::string backtrace() const throw();
 	
 	/**
 	 * Return the backtraces of all oxt::thread threads, as well as that of the
 	 * main thread, in a nicely formatted string.
 	 */
-	static std::string all_backtraces() throw() {
-		#ifdef OXT_BACKTRACE_IS_ENABLED
-			boost::mutex::scoped_lock l(_thread_registration_mutex);
-			list<thread_registration *>::const_iterator it;
-			std::stringstream result;
-			
-			for (it = _registered_threads.begin(); it != _registered_threads.end(); it++) {
-				thread_registration *r = *it;
-				result << "Thread '" << r->name << "':" << endl;
-				
-				spin_lock::scoped_lock l(*r->backtrace_lock);
-				result << _format_backtrace(r->backtrace) << endl;
-			}
-			return result.str();
-		#else
-			return "(backtrace support disabled during compile time)";
-		#endif
-	}
+	static std::string all_backtraces() throw();
 	
 	/**
 	 * Interrupt the thread. This method behaves just like
@@ -240,17 +146,7 @@ public:
 	 * interrupt_and_join() is a convenience method that implements this
 	 * pattern.
 	 */
-	void interrupt(bool interruptSyscalls = true) {
-		int ret;
-		
-		boost::thread::interrupt();
-		if (interruptSyscalls) {
-			do {
-				ret = pthread_kill(native_handle(),
-					INTERRUPTION_SIGNAL);
-			} while (ret == EINTR);
-		}
-	}
+	void interrupt(bool interruptSyscalls = true);
 	
 	/**
 	 * Keep interrupting the thread until it's done, then join it.

data/ext/ruby/passenger_native_support.c

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2010 Phusion
+ *  Copyright (c) 2010, 2011, 2012 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -33,6 +33,7 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
+#include <sys/wait.h>
 #include <sys/un.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
@@ -47,12 +48,12 @@
 #include <limits.h>
 #include <grp.h>
 #include <signal.h>
+#include <pthread.h>
 #ifdef HAVE_ALLOCA_H
 	#include <alloca.h>
 #endif
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
 	#define HAVE_KQUEUE
-	#include <pthread.h>
 	#include <sys/event.h>
 	#include <sys/time.h>
 #endif
@@ -83,213 +84,6 @@ static VALUE S_ProcessTimes;
 	static VALUE cFileSystemWatcher;
 #endif
 
-/*
- * call-seq: send_fd(socket_fd, fd_to_send)
- *
- * Send a file descriptor over the given Unix socket. You do not have to call
- * this function directly. A convenience wrapper is provided by IO#send_io.
- *
- * - +socket_fd+ (integer): The file descriptor of the socket.
- * - +fd_to_send+ (integer): The file descriptor to send.
- * - Raises +SystemCallError+ if something went wrong.
- */
-static VALUE
-send_fd(VALUE self, VALUE socket_fd, VALUE fd_to_send) {
-	struct msghdr msg;
-	struct iovec vec;
-	char dummy[1];
-	#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
-		struct {
-			struct cmsghdr header;
-			int fd;
-		} control_data;
-	#else
-		char control_data[CMSG_SPACE(sizeof(int))];
-	#endif
-	struct cmsghdr *control_header;
-	int control_payload;
-	
-	msg.msg_name = NULL;
-	msg.msg_namelen = 0;
-	
-	/* Linux and Solaris require msg_iov to be non-NULL. */
-	dummy[0]       = '\0';
-	vec.iov_base   = dummy;
-	vec.iov_len    = sizeof(dummy);
-	msg.msg_iov    = &vec;
-	msg.msg_iovlen = 1;
-	
-	msg.msg_control    = (caddr_t) &control_data;
-	msg.msg_controllen = sizeof(control_data);
-	msg.msg_flags      = 0;
-	
-	control_header = CMSG_FIRSTHDR(&msg);
-	control_header->cmsg_level = SOL_SOCKET;
-	control_header->cmsg_type  = SCM_RIGHTS;
-	control_payload = NUM2INT(fd_to_send);
-	#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
-		control_header->cmsg_len = sizeof(control_data);
-		control_data.fd = control_payload;
-	#else
-		control_header->cmsg_len = CMSG_LEN(sizeof(int));
-		memcpy(CMSG_DATA(control_header), &control_payload, sizeof(int));
-	#endif
-	
-	if (sendmsg(NUM2INT(socket_fd), &msg, 0) == -1) {
-		rb_sys_fail("sendmsg(2)");
-		return Qnil;
-	}
-	
-	return Qnil;
-}
-
-/*
- * call-seq: recv_fd(socket_fd)
- *
- * Receive a file descriptor from the given Unix socket. Returns the received
- * file descriptor as an integer. Raises +SystemCallError+ if something went
- * wrong.
- *
- * You do not have call this method directly. A convenience wrapper is
- * provided by IO#recv_io.
- */
-static VALUE
-recv_fd(VALUE self, VALUE socket_fd) {
-	struct msghdr msg;
-	struct iovec vec;
-	char dummy[1];
-	#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
-		// File descriptor passing macros (CMSG_*) seem to be broken
-		// on 64-bit MacOS X. This structure works around the problem.
-		struct {
-			struct cmsghdr header;
-			int fd;
-		} control_data;
-		#define EXPECTED_CMSG_LEN sizeof(control_data)
-	#else
-		char control_data[CMSG_SPACE(sizeof(int))];
-		#define EXPECTED_CMSG_LEN CMSG_LEN(sizeof(int))
-	#endif
-	struct cmsghdr *control_header;
-
-	msg.msg_name    = NULL;
-	msg.msg_namelen = 0;
-	
-	dummy[0]       = '\0';
-	vec.iov_base   = dummy;
-	vec.iov_len    = sizeof(dummy);
-	msg.msg_iov    = &vec;
-	msg.msg_iovlen = 1;
-
-	msg.msg_control    = (caddr_t) &control_data;
-	msg.msg_controllen = sizeof(control_data);
-	msg.msg_flags      = 0;
-	
-	if (recvmsg(NUM2INT(socket_fd), &msg, 0) == -1) {
-		rb_sys_fail("Cannot read file descriptor with recvmsg()");
-		return Qnil;
-	}
-	
-	control_header = CMSG_FIRSTHDR(&msg);
-	if (control_header == NULL) {
-		rb_raise(rb_eIOError, "No valid file descriptor received.");
-		return Qnil;
-	}
-	if (control_header->cmsg_len   != EXPECTED_CMSG_LEN
-	 || control_header->cmsg_level != SOL_SOCKET
-	 || control_header->cmsg_type  != SCM_RIGHTS) {
-		rb_raise(rb_eIOError, "No valid file descriptor received.");
-		return Qnil;
-	}
-	#if defined(__APPLE__) || defined(__SOLARIS__) || defined(__arm__)
-		return INT2NUM(control_data.fd);
-	#else
-		return INT2NUM(*((int *) CMSG_DATA(control_header)));
-	#endif
-}
-
-/*
- * call-seq: create_unix_socket(filename, backlog)
- *
- * Create a SOCK_STREAM server Unix socket. Unlike Ruby's UNIXServer class,
- * this function is also able to create Unix sockets on the abstract namespace
- * by prepending the filename with a null byte.
- *
- * - +filename+ (string): The filename of the Unix socket to create.
- * - +backlog+ (integer): The backlog to use for listening on the socket.
- * - Returns: The file descriptor of the created Unix socket, as an integer.
- * - Raises +SystemCallError+ if something went wrong.
- */
-static VALUE
-create_unix_socket(VALUE self, VALUE filename, VALUE backlog) {
-	int fd, ret;
-	struct sockaddr_un addr;
-	const char *filename_str;
-	long filename_length;
-	
-	filename_str = RSTRING_PTR(filename);
-	filename_length = RSTRING_LEN(filename);
-	
-	fd = socket(PF_UNIX, SOCK_STREAM, 0);
-	if (fd == -1) {
-		rb_sys_fail("Cannot create a Unix socket");
-		return Qnil;
-	}
-	
-	addr.sun_family = AF_UNIX;
-	memcpy(addr.sun_path, filename_str,
-		MIN((long) filename_length, (long) sizeof(addr.sun_path)));
-	addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
-	
-	ret = bind(fd, (const struct sockaddr *) &addr, sizeof(addr));
-	if (ret == -1) {
-		int e = errno;
-		close(fd);
-		errno = e;
-		rb_sys_fail("Cannot bind Unix socket");
-		return Qnil;
-	}
-	
-	ret = listen(fd, NUM2INT(backlog));
-	if (ret == -1) {
-		int e = errno;
-		close(fd);
-		errno = e;
-		rb_sys_fail("Cannot listen on Unix socket");
-		return Qnil;
-	}
-	return INT2NUM(fd);
-}
-
-/*
- * call-seq: close_all_file_descriptors(exceptions)
- *
- * Close all file descriptors, except those given in the +exceptions+ array.
- * For example, the following would close all file descriptors except standard
- * input (0) and standard output (1).
- *
- *  close_all_file_descriptors([0, 1])
- */
-static VALUE
-close_all_file_descriptors(VALUE self, VALUE exceptions) {
-	long i, j;
-	
-	for (i = sysconf(_SC_OPEN_MAX) - 1; i >= 0; i--) {
-		int is_exception = 0;
-		#ifdef RB_RESERVED_FD_P
-			is_exception = rb_reserved_fd_p((int) i);
-		#endif
-		for (j = 0; j < RARRAY_LEN(exceptions) && !is_exception; j++) {
-			long fd = NUM2INT(rb_ary_entry(exceptions, j));
-			is_exception = i == fd;
-		}
-		if (!is_exception) {
-			close((int) i);
-		}
-	}
-	return Qnil;
-}
-
 /*
  * call-seq: disable_stdio_buffering
  *
@@ -586,29 +380,6 @@ f_writev3(VALUE self, VALUE fd, VALUE components1, VALUE components2, VALUE comp
 	return f_generic_writev(fd, array_of_components, 3);
 }
 
-/**
- * Ruby's implementations of initgroups, setgid and setuid are broken various ways,
- * sigh...
- * Ruby's setgid and setuid can't handle negative UIDs and initgroups is just broken.
- * Work around it by using our own implementation.
- */
-static VALUE
-switch_user(VALUE self, VALUE username, VALUE uid, VALUE gid) {
-	uid_t the_uid = (uid_t) NUM2LL(uid);
-	gid_t the_gid = (gid_t) NUM2LL(gid);
-	
-	if (initgroups(RSTRING_PTR(username), the_gid) == -1) {
-		rb_sys_fail("initgroups");
-	}
-	if (setgid(the_gid) == -1) {
-		rb_sys_fail("setgid");
-	}
-	if (setuid(the_uid) == -1) {
-		rb_sys_fail("setuid");
-	}
-	return Qnil;
-}
-
 static VALUE
 process_times(VALUE self) {
 	struct rusage usage;
@@ -623,6 +394,82 @@ process_times(VALUE self) {
 	return rb_struct_new(S_ProcessTimes, rb_ull2inum(utime), rb_ull2inum(stime));
 }
 
+static void *
+detach_process_main(void *arg) {
+	pid_t pid = (pid_t) (long) arg;
+	int ret;
+	do {
+		ret = waitpid(pid, NULL, 0);
+	} while (ret == -1 && errno == EINTR);
+	return NULL;
+}
+
+static VALUE
+detach_process(VALUE self, VALUE pid) {
+	pthread_t thr;
+	pthread_attr_t attr;
+	size_t stack_size = 96 * 1024;
+	
+	unsigned long min_stack_size;
+	int stack_min_size_defined;
+	int round_stack_size;
+	
+	#ifdef PTHREAD_STACK_MIN
+		// PTHREAD_STACK_MIN may not be a constant macro so we need
+		// to evaluate it dynamically.
+		min_stack_size = PTHREAD_STACK_MIN;
+		stack_min_size_defined = 1;
+	#else
+		// Assume minimum stack size is 128 KB.
+		min_stack_size = 128 * 1024;
+		stack_min_size_defined = 0;
+	#endif
+	if (stack_size != 0 && stack_size < min_stack_size) {
+		stack_size = min_stack_size;
+		round_stack_size = !stack_min_size_defined;
+	} else {
+		round_stack_size = 1;
+	}
+	
+	if (round_stack_size) {
+		// Round stack size up to page boundary.
+		long page_size;
+		#if defined(_SC_PAGESIZE)
+			page_size = sysconf(_SC_PAGESIZE);
+		#elif defined(_SC_PAGE_SIZE)
+			page_size = sysconf(_SC_PAGE_SIZE);
+		#elif defined(PAGESIZE)
+			page_size = sysconf(PAGESIZE);
+		#elif defined(PAGE_SIZE)
+			page_size = sysconf(PAGE_SIZE);
+		#else
+			page_size = getpagesize();
+		#endif
+		if (stack_size % page_size != 0) {
+			stack_size = stack_size - (stack_size % page_size) + page_size;
+		}
+	}
+	
+	pthread_attr_init(&attr);
+	pthread_attr_setdetachstate(&attr, 1);
+	pthread_attr_setstacksize(&attr, stack_size);
+	pthread_create(&thr, &attr, detach_process_main, (void *) NUM2LONG(pid));
+	pthread_attr_destroy(&attr);
+	return Qnil;
+}
+
+/**
+ * Freeze the current process forever. On Ruby 1.9 this never unlocks the GIL.
+ * Useful for testing purposes.
+ */
+static VALUE
+freeze_process(VALUE self) {
+	while (1) {
+		usleep(60 * 1000000);
+	}
+	return Qnil;
+}
+
 #if defined(HAVE_KQUEUE) || defined(IN_DOXYGEN)
 typedef struct {
 	VALUE klass;
@@ -824,6 +671,7 @@ fs_watcher_new(VALUE klass, VALUE filenames, VALUE termination_pipe) {
 	if (status) {
 		fs_watcher_free(watcher);
 		rb_jump_tag(status);
+		return Qnil;
 	} else {
 		return result;
 	}
@@ -1010,17 +858,14 @@ Init_passenger_native_support() {
 	
 	S_ProcessTimes = rb_struct_define("ProcessTimes", "utime", "stime", NULL);
 	
-	rb_define_singleton_method(mNativeSupport, "send_fd", send_fd, 2);
-	rb_define_singleton_method(mNativeSupport, "recv_fd", recv_fd, 1);
-	rb_define_singleton_method(mNativeSupport, "create_unix_socket", create_unix_socket, 2);
-	rb_define_singleton_method(mNativeSupport, "close_all_file_descriptors", close_all_file_descriptors, 1);
 	rb_define_singleton_method(mNativeSupport, "disable_stdio_buffering", disable_stdio_buffering, 0);
 	rb_define_singleton_method(mNativeSupport, "split_by_null_into_hash", split_by_null_into_hash, 1);
 	rb_define_singleton_method(mNativeSupport, "writev", f_writev, 2);
 	rb_define_singleton_method(mNativeSupport, "writev2", f_writev2, 3);
 	rb_define_singleton_method(mNativeSupport, "writev3", f_writev3, 4);
-	rb_define_singleton_method(mNativeSupport, "switch_user", switch_user, 3);
 	rb_define_singleton_method(mNativeSupport, "process_times", process_times, 0);
+	rb_define_singleton_method(mNativeSupport, "detach_process", detach_process, 1);
+	rb_define_singleton_method(mNativeSupport, "freeze_process", freeze_process, 0);
 	
 	#ifdef HAVE_KQUEUE
 		cFileSystemWatcher = rb_define_class_under(mNativeSupport,