passenger 5.1.10 → 5.1.11

data/src/cxx_supportlib/ProcessManagement/Utils.h

@@ -0,0 +1,107 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-2017 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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 _PASSENGER_PROCESS_MANAGEMENT_UTILS_H_
+#define _PASSENGER_PROCESS_MANAGEMENT_UTILS_H_
+
+#include <sys/types.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+/**
+ * Thread-safe and async-signal safe way to fork().
+ *
+ * On Linux, the fork() glibc wrapper grabs a ptmalloc lock, so
+ * if malloc causes a segfault then we can't fork.
+ * http://sourceware.org/bugzilla/show_bug.cgi?id=4737
+ *
+ * OS X apparently does something similar, except they use a
+ * spinlock so it results in 100% CPU. See _cthread_fork_prepare()
+ * at http://www.opensource.apple.com/source/Libc/Libc-166/threads.subproj/cthreads.c
+ * However, since POSIX in OS X is implemented on top of a Mach layer,
+ * calling asyncFork() can mess up the state of the Mach layer, causing
+ * some POSIX functions to mysteriously fail. See
+ * https://code.google.com/p/phusion-passenger/issues/detail?id=1094
+ * You should therefore not use asyncFork() unless you're in a signal
+ * handler or if you only perform async-signal-safe stuff in the child.
+ *
+ * On 2017 October 9 with macOS 10.11 El Capitan, we also confirmed
+ * a case in which the child process can get stuck indefinitely with 0% CPU.
+ * If we we create a thread which performs memory allocation, and shortly
+ * after thread creation we fork, then the child process gets stuck because
+ * one of its pthread_atfork() handlers tries to allocate memory, which tries
+ * to grab a lock which was already locked. This means that on macOS
+ * we pretty much can never use regular fork() at all in a multithreaded
+ * environment.
+ */
+pid_t asyncFork();
+
+/**
+ * Resets the current process's signal handler disposition and signal mask
+ * to default values. One should call this every time one forks a child process;
+ * non-default signal masks/handler dispositions can cause all kinds of weird quirks,
+ * like waitpid() malfunctioning on macOS.
+ *
+ * This function is async-signal safe.
+ */
+void resetSignalHandlersAndMask();
+
+/**
+ * Disables malloc() debugging facilities on macOS.
+ */
+void disableMallocDebugging();
+
+/**
+ * Close all file descriptors that are higher than `lastToKeepOpen`.
+ *
+ * If you set `asyncSignalSafe` to true, then this function becomes fully async-signal,
+ * through the use of asyncFork() instead of fork(). However, read the documentation
+ * for asyncFork() to learn about its caveats.
+ *
+ * Also, regardless of whether `asyncSignalSafe` is true or not, this function is not
+ * *thread* safe. Make sure there are no other threads running that might open file
+ * descriptors, otherwise some file descriptors might not be closed even though they
+ * should be.
+ */
+void closeAllFileDescriptors(int lastToKeepOpen, bool asyncSignalSafe = false);
+
+/**
+ * Given a failed exec() syscall and its resulting errno
+ * value, print an appropriate error message to STDERR.
+ *
+ * This function is async signal-safe. Its main intended use is to be the
+ * default value for the `onExecFail` parameter for the
+ * `runCommand()` and `runCommandAndCaptureOutput()` functions.
+ */
+void printExecError(const char **command, int errcode);
+void printExecError2(const char **command, int errcode, char *buf, size_t size);
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_PROCESS_MANAGEMENT_UTILS_H_ */

data/src/cxx_supportlib/Utils.cpp

@@ -30,6 +30,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cerrno>
@@ -55,6 +56,8 @@
 #include <FileDescriptor.h>
 #include <ResourceLocator.h>
 #include <Exceptions.h>
+#include <ProcessManagement/Spawn.h>
+#include <ProcessManagement/Utils.h>
 #include <Utils.h>
 #include <Utils/CachedFileStat.hpp>
 #include <Utils/StrIntUtils.h>
@@ -69,16 +72,9 @@
 		#define HOST_NAME_MAX 255
 	#endif
 #endif
-#if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__sun)
-	// Introduced in Solaris 9. Let's hope nobody actually uses
-	// a version that doesn't support this.
-	#define HAS_CLOSEFROM
-#endif
 
 namespace Passenger {
 
-static string passengerTempDir;
-
 namespace {
 	/**
 	 * Given a filename, FileGuard will unlink the file in its destructor, unless
@@ -717,54 +713,38 @@ makeDirTree(const string &path, const StaticString &mode, uid_t owner, gid_t gro
 	}
 }
 
-void
-removeDirTree(const string &path) {
-	boost::this_thread::disable_interruption di;
-	boost::this_thread::disable_syscall_interruption dsi;
-	const char *c_path = path.c_str();
-	pid_t pid;
-
-	pid = syscalls::fork();
-	if (pid == 0) {
-		resetSignalHandlersAndMask();
-		disableMallocDebugging();
-		int devnull = open("/dev/null", O_RDONLY);
-		if (devnull != -1) {
-			dup2(devnull, 2);
-		}
-		closeAllFileDescriptors(2);
-		execlp("chmod", "chmod", "-R", "u+rwx", c_path, (char * const) 0);
-		perror("Cannot execute chmod");
-		_exit(1);
-
-	} else if (pid == -1) {
-		int e = errno;
-		throw SystemException("Cannot fork a new process", e);
-
-	} else {
-		boost::this_thread::restore_interruption ri(di);
-		boost::this_thread::restore_syscall_interruption rsi(dsi);
-		syscalls::waitpid(pid, NULL, 0);
+static void
+redirectStderrToDevNull() {
+	int devnull = open("/dev/null", O_RDONLY);
+	if (devnull > 2) {
+		dup2(devnull, 2);
+		close(devnull);
 	}
+}
 
-	pid = syscalls::fork();
-	if (pid == 0) {
-		resetSignalHandlersAndMask();
-		disableMallocDebugging();
-		closeAllFileDescriptors(2);
-		execlp("rm", "rm", "-rf", c_path, (char * const) 0);
-		perror("Cannot execute rm");
-		_exit(1);
-
-	} else if (pid == -1) {
-		int e = errno;
-		throw SystemException("Cannot fork a new process", e);
-
-	} else {
-		boost::this_thread::restore_interruption ri(di);
-		boost::this_thread::restore_syscall_interruption rsi(dsi);
-		int status;
-		if (syscalls::waitpid(pid, &status, 0) == -1 || status != 0) {
+void
+removeDirTree(const string &path) {
+	{
+		const char *command[] = {
+			"chmod",
+			"-R",
+			"u+rwx",
+			path.c_str(),
+			NULL
+		};
+		SubprocessInfo info;
+		runCommand(command, info, true, true, redirectStderrToDevNull);
+	}
+	{
+		const char *command[] = {
+			"rm",
+			"-rf",
+			path.c_str(),
+			NULL
+		};
+		SubprocessInfo info;
+		runCommand(command, info, true, true, redirectStderrToDevNull);
+		if (info.status != 0 && info.status != -2) {
 			throw RuntimeException("Cannot remove directory '" + path + "'");
 		}
 	}
@@ -782,8 +762,6 @@ prestartWebApps(const ResourceLocator &locator, const string &ruby,
 	 */
 	syscalls::sleep(2);
 
-	boost::this_thread::disable_interruption di;
-	boost::this_thread::disable_syscall_interruption dsi;
 	vector<string>::const_iterator it;
 	string prespawnScript = locator.getHelperScriptsDir() + "/prespawn";
 
@@ -794,47 +772,15 @@ prestartWebApps(const ResourceLocator &locator, const string &ruby,
 			continue;
 		}
 
-		pid_t pid;
+		const char *command[] = {
+			ruby.c_str(),
+			prespawnScript.c_str(),
+			it->c_str(),
+			NULL
+		};
+		SubprocessInfo info;
+		runCommand(command, info);
 
-		pid = fork();
-		if (pid == 0) {
-			long max_fds, i;
-			int e;
-
-			// Close all unnecessary file descriptors.
-			max_fds = sysconf(_SC_OPEN_MAX);
-			for (i = 3; i < max_fds; i++) {
-				syscalls::close(i);
-			}
-
-			execlp(ruby.c_str(),
-				ruby.c_str(),
-				prespawnScript.c_str(),
-				it->c_str(),
-				(char *) 0);
-			e = errno;
-			fprintf(stderr, "Cannot execute '%s %s %s': %s (%d)\n",
-				ruby.c_str(),
-				prespawnScript.c_str(), it->c_str(),
-				strerror(e), e);
-			fflush(stderr);
-			_exit(1);
-		} else if (pid == -1) {
-			perror("fork()");
-		} else {
-			try {
-				boost::this_thread::restore_interruption si(di);
-				boost::this_thread::restore_syscall_interruption ssi(dsi);
-				syscalls::waitpid(pid, NULL, 0);
-			} catch (const thread_interrupted &) {
-				syscalls::kill(SIGKILL, pid);
-				syscalls::waitpid(pid, NULL, 0);
-				throw;
-			}
-		}
-
-		boost::this_thread::restore_interruption si(di);
-		boost::this_thread::restore_syscall_interruption ssi(dsi);
 		syscalls::sleep(1);
 		it++;
 	}
@@ -923,472 +869,6 @@ getSignalName(int sig) {
 	}
 }
 
-void
-resetSignalHandlersAndMask() {
-	struct sigaction action;
-	action.sa_handler = SIG_DFL;
-	action.sa_flags   = SA_RESTART;
-	sigemptyset(&action.sa_mask);
-	sigaction(SIGHUP,  &action, NULL);
-	sigaction(SIGINT,  &action, NULL);
-	sigaction(SIGQUIT, &action, NULL);
-	sigaction(SIGILL,  &action, NULL);
-	sigaction(SIGTRAP, &action, NULL);
-	sigaction(SIGABRT, &action, NULL);
-	#ifdef SIGEMT
-		sigaction(SIGEMT,  &action, NULL);
-	#endif
-	sigaction(SIGFPE,  &action, NULL);
-	sigaction(SIGBUS,  &action, NULL);
-	sigaction(SIGSEGV, &action, NULL);
-	sigaction(SIGSYS,  &action, NULL);
-	sigaction(SIGPIPE, &action, NULL);
-	sigaction(SIGALRM, &action, NULL);
-	sigaction(SIGTERM, &action, NULL);
-	sigaction(SIGURG,  &action, NULL);
-	sigaction(SIGSTOP, &action, NULL);
-	sigaction(SIGTSTP, &action, NULL);
-	sigaction(SIGCONT, &action, NULL);
-	sigaction(SIGCHLD, &action, NULL);
-	#ifdef SIGINFO
-		sigaction(SIGINFO, &action, NULL);
-	#endif
-	sigaction(SIGUSR1, &action, NULL);
-	sigaction(SIGUSR2, &action, NULL);
-
-	// We reset the signal mask after resetting the signal handlers,
-	// because prior to calling resetSignalHandlersAndMask(), the
-	// process might be blocked on some signals. We want those signals
-	// to be processed after installing the new signal handlers
-	// so that bugs like https://github.com/phusion/passenger/pull/97
-	// can be prevented.
-
-	sigset_t signal_set;
-	int ret;
-
-	sigemptyset(&signal_set);
-	do {
-		ret = sigprocmask(SIG_SETMASK, &signal_set, NULL);
-	} while (ret == -1 && errno == EINTR);
-}
-
-void
-disableMallocDebugging() {
-	unsetenv("MALLOC_FILL_SPACE");
-	unsetenv("MALLOC_PROTECT_BEFORE");
-	unsetenv("MallocGuardEdges");
-	unsetenv("MallocScribble");
-	unsetenv("MallocPreScribble");
-	unsetenv("MallocCheckHeapStart");
-	unsetenv("MallocCheckHeapEach");
-	unsetenv("MallocCheckHeapAbort");
-	unsetenv("MallocBadFreeAbort");
-	unsetenv("MALLOC_CHECK_");
-
-	const char *libs = getenv("DYLD_INSERT_LIBRARIES");
-	if (libs != NULL && strstr(libs, "/usr/lib/libgmalloc.dylib")) {
-		string newLibs = libs;
-		string::size_type pos = newLibs.find("/usr/lib/libgmalloc.dylib");
-		size_t len = strlen("/usr/lib/libgmalloc.dylib");
-
-		// Erase all leading ':' too.
-		while (pos > 0 && newLibs[pos - 1] == ':') {
-			pos--;
-			len++;
-		}
-		// Erase all trailing ':' too.
-		while (pos + len < newLibs.size() && newLibs[pos + len] == ':') {
-			len++;
-		}
-
-		newLibs.erase(pos, len);
-		if (newLibs.empty()) {
-			unsetenv("DYLD_INSERT_LIBRARIES");
-		} else {
-			setenv("DYLD_INSERT_LIBRARIES", newLibs.c_str(), 1);
-		}
-	}
-}
-
-int
-runShellCommand(const StaticString &command) {
-	pid_t pid = fork();
-	if (pid == 0) {
-		resetSignalHandlersAndMask();
-		disableMallocDebugging();
-		closeAllFileDescriptors(2);
-		execlp("/bin/sh", "/bin/sh", "-c", command.data(), (char * const) 0);
-		_exit(1);
-	} else if (pid == -1) {
-		return -1;
-	} else {
-		int status;
-		if (waitpid(pid, &status, 0) == -1) {
-			return -1;
-		} else {
-			return status;
-		}
-	}
-}
-
-string
-runCommandAndCaptureOutput(const char **command, int *status) {
-	pid_t pid, waitRet;
-	int e, waitStatus;
-	Pipe p;
-
-	p = createPipe(__FILE__, __LINE__);
-
-	boost::this_thread::disable_syscall_interruption dsi;
-	pid = syscalls::fork();
-	if (pid == 0) {
-		// Make ps nicer, we want to have as little impact on the rest
-		// of the system as possible while collecting the metrics.
-		int prio = getpriority(PRIO_PROCESS, getpid());
-		prio++;
-		if (prio > 20) {
-			prio = 20;
-		}
-		setpriority(PRIO_PROCESS, getpid(), prio);
-
-		dup2(p[1], 1);
-		close(p[0]);
-		close(p[1]);
-		closeAllFileDescriptors(2);
-		execvp(command[0], (char * const *) command);
-		_exit(1);
-	} else if (pid == -1) {
-		e = errno;
-		throw SystemException("Cannot fork() a new process", e);
-	} else {
-		bool done = false;
-		string result;
-
-		p[1].close();
-		while (!done) {
-			char buf[1024 * 4];
-			ssize_t ret;
-
-			try {
-				boost::this_thread::restore_syscall_interruption rsi(dsi);
-				ret = syscalls::read(p[0], buf, sizeof(buf));
-			} catch (const thread_interrupted &) {
-				syscalls::kill(SIGKILL, pid);
-				syscalls::waitpid(pid, NULL, 0);
-				throw;
-			}
-			if (ret == -1) {
-				e = errno;
-				syscalls::kill(SIGKILL, pid);
-				syscalls::waitpid(pid, NULL, 0);
-				throw SystemException(string("Cannot read output from the '") +
-					command[0] + "' command", e);
-			}
-			done = ret == 0;
-			result.append(buf, ret);
-		}
-		p[0].close();
-
-		waitRet = syscalls::waitpid(pid, &waitStatus, 0);
-		if (waitRet != -1) {
-			if (status != NULL) {
-				*status = waitStatus;
-			}
-		} else if (errno == ECHILD || errno == ESRCH) {
-			if (status != NULL) {
-				*status = -1;
-			}
-		} else {
-			int e = errno;
-			throw SystemException(string("Error waiting for the '") +
-				command[0] + "' command", e);
-		}
-		return result;
-	}
-}
-
-#ifdef __APPLE__
-	// http://www.opensource.apple.com/source/Libc/Libc-825.26/sys/fork.c
-	// This bypasses atfork handlers.
-	extern "C" {
-		extern pid_t __fork(void);
-	}
-#endif
-
-pid_t
-asyncFork() {
-	#if defined(__linux__)
-		#if defined(SYS_fork)
-			return (pid_t) syscall(SYS_fork);
-		#else
-			return syscall(SYS_clone, SIGCHLD, 0, 0, 0, 0);
-		#endif
-	#elif defined(__APPLE__)
-		return __fork();
-	#else
-		return fork();
-	#endif
-}
-
-// Async-signal safe way to get the current process's hard file descriptor limit.
-static int
-getFileDescriptorLimit() {
-	long long sysconfResult = sysconf(_SC_OPEN_MAX);
-
-	struct rlimit rl;
-	long long rlimitResult;
-	if (getrlimit(RLIMIT_NOFILE, &rl) == -1) {
-		rlimitResult = 0;
-	} else {
-		rlimitResult = (long long) rl.rlim_max;
-	}
-
-	long result;
-	// OS X 10.9 returns LLONG_MAX. It doesn't make sense
-	// to use that result so we limit ourselves to the
-	// sysconf result.
-	if (rlimitResult >= INT_MAX || sysconfResult > rlimitResult) {
-		result = sysconfResult;
-	} else {
-		result = rlimitResult;
-	}
-
-	if (result < 0) {
-		// Unable to query the file descriptor limit.
-		result = 9999;
-	} else if (result < 2) {
-		// The calls reported broken values.
-		result = 2;
-	}
-	return result;
-}
-
-// Async-signal safe function to get the highest file
-// descriptor that the process is currently using.
-// See also http://stackoverflow.com/questions/899038/getting-the-highest-allocated-file-descriptor
-static int
-getHighestFileDescriptor(bool asyncSignalSafe) {
-#if defined(F_MAXFD)
-	int ret;
-
-	do {
-		ret = fcntl(0, F_MAXFD);
-	} while (ret == -1 && errno == EINTR);
-	if (ret == -1) {
-		ret = getFileDescriptorLimit();
-	}
-	return ret;
-
-#else
-	int p[2], ret, flags;
-	pid_t pid = -1;
-	int result = -1;
-
-	/* Since opendir() may not be async signal safe and thus may lock up
-	 * or crash, we use it in a child process which we kill if we notice
-	 * that things are going wrong.
-	 */
-
-	// Make a pipe.
-	p[0] = p[1] = -1;
-	do {
-		ret = pipe(p);
-	} while (ret == -1 && errno == EINTR);
-	if (ret == -1) {
-		goto done;
-	}
-
-	// Make the read side non-blocking.
-	do {
-		flags = fcntl(p[0], F_GETFL);
-	} while (flags == -1 && errno == EINTR);
-	if (flags == -1) {
-		goto done;
-	}
-	do {
-		fcntl(p[0], F_SETFL, flags | O_NONBLOCK);
-	} while (ret == -1 && errno == EINTR);
-	if (ret == -1) {
-		goto done;
-	}
-
-	if (asyncSignalSafe) {
-		do {
-			pid = asyncFork();
-		} while (pid == -1 && errno == EINTR);
-	} else {
-		do {
-			pid = fork();
-		} while (pid == -1 && errno == EINTR);
-	}
-
-	if (pid == 0) {
-		// Don't close p[0] here or it might affect the result.
-
-		resetSignalHandlersAndMask();
-
-		struct sigaction action;
-		action.sa_handler = _exit;
-		action.sa_flags   = SA_RESTART;
-		sigemptyset(&action.sa_mask);
-		sigaction(SIGSEGV, &action, NULL);
-		sigaction(SIGPIPE, &action, NULL);
-		sigaction(SIGBUS, &action, NULL);
-		sigaction(SIGILL, &action, NULL);
-		sigaction(SIGFPE, &action, NULL);
-		sigaction(SIGABRT, &action, NULL);
-
-		DIR *dir = NULL;
-		#ifdef __APPLE__
-			/* /dev/fd can always be trusted on OS X. */
-			dir = opendir("/dev/fd");
-		#else
-			/* On FreeBSD and possibly other operating systems, /dev/fd only
-			 * works if fdescfs is mounted. If it isn't mounted then /dev/fd
-			 * still exists but always returns [0, 1, 2] and thus can't be
-			 * trusted. If /dev and /dev/fd are on different filesystems
-			 * then that probably means fdescfs is mounted.
-			 */
-			struct stat dirbuf1, dirbuf2;
-			if (stat("/dev", &dirbuf1) == -1
-			 || stat("/dev/fd", &dirbuf2) == -1) {
-				_exit(1);
-			}
-			if (dirbuf1.st_dev != dirbuf2.st_dev) {
-				dir = opendir("/dev/fd");
-			}
-		#endif
-		if (dir == NULL) {
-			dir = opendir("/proc/self/fd");
-			if (dir == NULL) {
-				_exit(1);
-			}
-		}
-
-		struct dirent *ent;
-		union {
-			int highest;
-			char data[sizeof(int)];
-		} u;
-		u.highest = -1;
-
-		while ((ent = readdir(dir)) != NULL) {
-			if (ent->d_name[0] != '.') {
-				int number = atoi(ent->d_name);
-				if (number > u.highest) {
-					u.highest = number;
-				}
-			}
-		}
-		if (u.highest != -1) {
-			ssize_t ret, written = 0;
-			do {
-				ret = write(p[1], u.data + written, sizeof(int) - written);
-				if (ret == -1) {
-					_exit(1);
-				}
-				written += ret;
-			} while (written < (ssize_t) sizeof(int));
-		}
-		closedir(dir);
-		_exit(0);
-
-	} else if (pid == -1) {
-		goto done;
-
-	} else {
-		close(p[1]); // Do not retry on EINTR: http://news.ycombinator.com/item?id=3363819
-		p[1] = -1;
-
-		union {
-			int highest;
-			char data[sizeof(int)];
-		} u;
-		ssize_t ret, bytesRead = 0;
-		struct pollfd pfd;
-		pfd.fd = p[0];
-		pfd.events = POLLIN;
-
-		do {
-			do {
-				// The child process must finish within 30 ms, otherwise
-				// we might as well query sysconf.
-				ret = poll(&pfd, 1, 30);
-			} while (ret == -1 && errno == EINTR);
-			if (ret <= 0) {
-				goto done;
-			}
-
-			do {
-				ret = read(p[0], u.data + bytesRead, sizeof(int) - bytesRead);
-			} while (ret == -1 && errno == EINTR);
-			if (ret == -1) {
-				if (errno != EAGAIN) {
-					goto done;
-				}
-			} else if (ret == 0) {
-				goto done;
-			} else {
-				bytesRead += ret;
-			}
-		} while (bytesRead < (ssize_t) sizeof(int));
-
-		result = u.highest;
-		goto done;
-	}
-
-done:
-	// Do not retry on EINTR: http://news.ycombinator.com/item?id=3363819
-	if (p[0] != -1) {
-		close(p[0]);
-	}
-	if (p[1] != -1) {
-		close(p[1]);
-	}
-	if (pid != -1) {
-		do {
-			ret = kill(pid, SIGKILL);
-		} while (ret == -1 && errno == EINTR);
-		do {
-			ret = waitpid(pid, NULL, 0);
-		} while (ret == -1 && errno == EINTR);
-	}
-
-	if (result == -1) {
-		result = getFileDescriptorLimit();
-	}
-	return result;
-#endif
-}
-
-void
-closeAllFileDescriptors(int lastToKeepOpen, bool asyncSignalSafe) {
-	#if defined(F_CLOSEM)
-		int ret;
-		do {
-			ret = fcntl(lastToKeepOpen + 1, F_CLOSEM);
-		} while (ret == -1 && errno == EINTR);
-		if (ret != -1) {
-			return;
-		}
-	#elif defined(HAS_CLOSEFROM)
-		closefrom(lastToKeepOpen + 1);
-		return;
-	#endif
-
-	for (int i = getHighestFileDescriptor(asyncSignalSafe); i > lastToKeepOpen; i--) {
-		/* Even though we normally shouldn't retry on EINTR
-		 * (http://news.ycombinator.com/item?id=3363819)
-		 * it's okay to do that here because because this function
-		 * may only be called in a single-threaded environment.
-		 */
-		int ret;
-		do {
-			ret = close(i);
-		} while (ret == -1 && errno == EINTR);
-	}
-}
-
 void
 breakpoint() {
 	// No-op.