passenger 6.0.27 → 6.1.1

data/src/cxx_supportlib/IOTools/IOUtils.h

@@ -43,16 +43,15 @@ namespace Passenger {
 
 using namespace std;
 
+
+/****** Server address types support ******/
+
 enum ServerAddressType {
 	SAT_UNIX,
 	SAT_TCP,
 	SAT_UNKNOWN
 };
 
-typedef ssize_t (*WritevFunction)(int fildes, const struct iovec *iov, int iovcnt);
-
-bool purgeStdio(FILE *f);
-
 /**
  * Accepts a server address in one of the following formats, and returns which one it is:
  *
@@ -95,30 +94,8 @@ void parseTcpSocketAddress(const StaticString & restrict_ref address,
  */
 bool isLocalSocketAddress(const StaticString &address);
 
-/**
- * Sets a socket in blocking mode.
- *
- * @throws SystemException Something went wrong.
- * @ingroup Support
- */
-void setBlocking(int fd);
 
-/**
- * Sets a socket in non-blocking mode.
- *
- * @throws SystemException Something went wrong.
- * @ingroup Support
- */
-void setNonBlocking(int fd);
-
-/**
- * Try to call the Linux accept4() system call. If the system call is
- * not available, then -1 is returned and errno is set to ENOSYS.
- */
-int callAccept4(int sock,
-	struct sockaddr * restrict addr,
-	socklen_t * restrict addr_len,
-	int options);
+/****** Server socket creation ******/
 
 /**
  * Create a new Unix or TCP server socket, depending on the address type.
@@ -139,7 +116,7 @@ int callAccept4(int sock,
  * @throws boost::thread_interrupted A system call has been interrupted.
  * @ingroup Support
  */
-int createServer(const StaticString &address,
+ int createServer(const StaticString &address,
 	unsigned int backlogSize = 0,
 	bool autoDelete = true,
 	const char *file = __FILE__,
@@ -191,6 +168,9 @@ int createTcpServer(const char *address = "0.0.0.0",
 	const char *file = __FILE__,
 	unsigned int line = __LINE__);
 
+
+/****** Socket connection establishment (blocking) ******/
+
 /**
  * Connect to a server at the given address in a blocking manner.
  *
@@ -206,7 +186,7 @@ int createTcpServer(const char *address = "0.0.0.0",
  * @throws boost::thread_interrupted A system call has been interrupted.
  * @ingroup Support
  */
-int connectToServer(const StaticString &address, const char *file,
+ int connectToServer(const StaticString &address, const char *file,
 	unsigned int line);
 
 /**
@@ -243,138 +223,120 @@ int connectToTcpServer(const StaticString &hostname, unsigned int port,
 	const char *file, unsigned int line);
 
 
-/** State structure for non-blocking connectToUnixServer(). */
-struct NUnix_State {
-	FileDescriptor fd;
-	string filename;
-};
-
-/** State structure for non-blocking connectToTcpServer(). */
-struct NTCP_State {
-	FileDescriptor fd;
-	struct addrinfo hints, *res;
-	string hostname;
-	int port;
-
-	NTCP_State() {
-		memset(&hints, 0, sizeof(hints));
-		res = NULL;
-		port = 0;
-	}
-
-	~NTCP_State() {
-		if (res != NULL) {
-			freeaddrinfo(res);
-		}
-	}
-};
+/****** Socket connection establishment (non-blocking) ******/
 
 /**
- * Setup a Unix domain socket for non-blocking connecting. When done,
- * the file descriptor can be accessed through <tt>state.fd</tt>.
+ * Establish a socket connection in non-blocking mode.
  *
- * @param state A state structure.
- * @param filename The filename of the socket to connect to.
+ * @param address An address as accepted by getSocketAddressType().
  * @param file The name of the source file that called this function,
  *             for file descriptor logging purposes.
  * @param line The line in the source file that called this function.
+ * @return The file descriptor of the connected client socket, plus whether
+ *   it was immediately connected (true) or pending (false). If pending,
+ *   the caller should poll() on the socket until it's writable.
+ * @throws ArgumentException Something went wrong.
+ * @throws IOException Something went wrong.
  * @throws SystemException Something went wrong.
  * @throws boost::thread_interrupted A system call has been interrupted.
- * @ingroup Support
  */
-void setupNonBlockingUnixSocket(NUnix_State & restrict_ref state,
-	const StaticString & restrict_ref filename, const char *file,
-	unsigned int line);
+std::pair<int, bool> createNonBlockingSocketConnection(const StaticString &address, const char *file, unsigned int line);
 
 /**
- * Connect a Unix domain socket in non-blocking mode.
+ * Establish a Unix domain socket connection in non-blocking mode.
  *
- * @param state A state structure.
- * @return True if the socket was successfully connected, false if the socket isn't
- *         ready yet, in which case the caller should select() on the socket until it's writable.
- * @throws RuntimeException Something went wrong.
+ * @param filename The filename of the socket to connect to.
+ * @param file The name of the source file that called this function,
+ *             for file descriptor logging purposes.
+ * @param line The line in the source file that called this function.
+ * @return The file descriptor of the connected client socket, plus whether
+ *   it was immediately connected (true) or pending (false). If pending,
+ *   the caller should poll() on the socket until it's writable.
+ * @throws ArgumentException Something went wrong.
  * @throws SystemException Something went wrong while connecting to the Unix server.
  * @throws boost::thread_interrupted A system call has been interrupted.
- * @ingroup Support
  */
-bool connectToUnixServer(NUnix_State &state);
+std::pair<int, bool> createNonBlockingUnixSocketConnection(const StaticString &filename, const char *file, unsigned int line);
 
 /**
- * Setup a TCP socket for non-blocking connecting. When done,
- * the file descriptor can be accessed through <tt>state.fd</tt>.
+ * Establish a TCP socket connection in non-blocking mode.
  *
- * @param state A state structure.
  * @param hostname The host name of the TCP server.
  * @param port The port number of the TCP server.
  * @param file The name of the source file that called this function,
  *             for file descriptor logging purposes.
  * @param line The line in the source file that called this function.
+ * @return The file descriptor of the connected client socket, plus whether
+ *   it was immediately connected (true) or pending (false). If pending,
+ *   the caller should poll() on the socket until it's writable.
  * @throws IOException Something went wrong.
  * @throws SystemException Something went wrong.
  * @throws boost::thread_interrupted A system call has been interrupted.
- * @ingroup Support
  */
-void setupNonBlockingTcpSocket(NTCP_State & restrict_ref state,
-	const StaticString & restrict_ref hostname,
-	int port, const char *file, unsigned int line);
+std::pair<int, bool> createNonBlockingTcpSocketConnection(const StaticString &hostname, unsigned int port, const char *file, unsigned int line);
 
-/**
- * Connect a TCP socket in non-blocking mode.
- *
- * @param state A state structure.
- * @return True if the socket was successfully connected, false if the socket isn't
- *         ready yet, in which case the caller should select() on the socket until it's writable.
- * @throws SystemException Something went wrong while connecting to the server.
- * @throws boost::thread_interrupted A system call has been interrupted.
- * @ingroup Support
- */
-bool connectToTcpServer(NTCP_State &state);
 
-struct NConnect_State {
+/****** Scope guards ******/
+
+/** RAII construct for ensuring that a file descriptor gets closed at scope exit. */
+class FdGuard {
 private:
-	NUnix_State s_unix;
-	NTCP_State s_tcp;
+	int mFd = -1;
 
 public:
-	ServerAddressType type;
+	FdGuard() { }
+	FdGuard(const FdGuard &other) = delete;
+	FdGuard(FdGuard &&other);
+	FdGuard(int fd, const char *sourceFile, unsigned int sourceLine);
+	/** @throws SystemException File descriptor close error. If exception is already being thrown, then only warns. */
+	~FdGuard() noexcept(false);
 
-	/**
-	 * Setup a socket for non-blocking connecting to the given address.
-	 *
-	 * @param address An address as accepted by getSocketAddressType().
-	 * @param file The name of the source file that called this function,
-	 *             for file descriptor logging purposes.
-	 * @param line The line in the source file that called this function.
-	 * @throws ArgumentException Unknown address type.
-	 * @throws RuntimeException Something went wrong.
-	 * @throws SystemException Something went wrong.
-	 * @throws IOException Something went wrong.
-	 * @throws boost::thread_interrupted A system call has been interrupted.
-	 */
-	NConnect_State(const StaticString & restrict_ref address, const char *file, unsigned int line);
+	FdGuard &operator=(const FdGuard &other) = delete;
+	FdGuard &operator=(FdGuard &&other);
 
-	NUnix_State &asNUnix_State();
-	NTCP_State &asNTCP_State();
+	/** Don't close file descriptor at object destruction. */
+	void clear() noexcept;
 
 	/**
-	 * Connect a socket in non-blocking mode.
+	 * Close file descriptor now. Idempotent.
 	 *
-	 * @return True if the socket was successfully connected, false if the socket isn't
-	 *         ready yet, in which case the caller should select() on the socket until it's writable.
-	 * @throws RuntimeException Something went wrong.
-	 * @throws SystemException Something went wrong.
-	 * @throws boost::thread_interrupted A system call has been interrupted.
+	 * @throws SystemException
 	 */
-	bool connectToServer();
-
-	/**
-	 * Gets the connection file descriptor.
-	 *
-	 * @pre \c connectToServer() was called
-	 */
-	FileDescriptor &getFd();
+	void runNow() noexcept(false);
 };
 
+
+/****** Other ******/
+
+typedef ssize_t (*WritevFunction)(int fildes, const struct iovec *iov, int iovcnt);
+
+bool purgeStdio(FILE *f);
+
+/**
+ * Sets a socket in blocking mode.
+ *
+ * @throws SystemException Something went wrong.
+ * @ingroup Support
+ */
+void setBlocking(int fd);
+
+/**
+ * Sets a socket in non-blocking mode.
+ *
+ * @throws SystemException Something went wrong.
+ * @ingroup Support
+ */
+void setNonBlocking(int fd);
+
+/**
+ * Try to call the Linux accept4() system call. If the system call is
+ * not available, then -1 is returned and errno is set to ENOSYS.
+ */
+int callAccept4(int sock,
+	struct sockaddr * restrict addr,
+	socklen_t * restrict addr_len,
+	int options);
+
 /**
  * Checks whether the given TCP server is connectable. Because this check
  * can take (in theory) an arbitrary amount of time, you must also supply
@@ -382,6 +344,7 @@ public:
  * deducted from the `*timeout` value. A timeout of 100000 microseconds is
  * recommended for most use cases.
  *
+ * @throws ArgumentException Something went wrong.
  * @throws IOException Something went wrong.
  * @throws SystemException Something went wrong.
  * @throws boost::thread_interrupted A system call has been interrupted.

data/src/cxx_supportlib/ServerKit/Config.h

@@ -26,12 +26,7 @@
 #ifndef _PASSENGER_SERVER_KIT_CONFIG_H_
 #define _PASSENGER_SERVER_KIT_CONFIG_H_
 
-// for std::swap()
-#if __cplusplus >= 201103L
-	#include <utility>
-#else
-	#include <algorithm>
-#endif
+#include <utility>
 #include <string>
 #include <boost/config.hpp>
 #include <boost/scoped_ptr.hpp>

data/src/cxx_supportlib/ServerKit/FileBufferedChannel.h

@@ -933,7 +933,7 @@ private:
 			if (req->result >= 0) {
 				FBC_DEBUG_FROM_CALLBACK(fcContext,
 					"Writer: creation of file " << fcContext->path <<
-					"canceled. Deleting file in the background");
+					" canceled. Deleting file in the background");
 				closeBufferFileInBackground(fcContext);
 				// Will take care of deleting fcContext
 				unlinkBufferFileInBackground(fcContext);

data/src/cxx_supportlib/StaticString.h

@@ -26,12 +26,7 @@
 #ifndef _PASSENGER_STATIC_STRING_H_
 #define _PASSENGER_STATIC_STRING_H_
 
-// for std::swap()
-#if __cplusplus >= 201103L
-	#include <utility>
-#else
-	#include <algorithm>
-#endif
+#include <utility>
 #include <boost/config.hpp>
 #include <oxt/macros.hpp>
 #include <sys/types.h>

data/src/cxx_supportlib/Utils/Curl.h

@@ -47,12 +47,7 @@
  * don't do anything.
  */
 
-// for std::swap()
-#if __cplusplus >= 201103L
-	#include <utility>
-#else
-	#include <algorithm>
-#endif
+#include <utility>
 #include <string>
 #include <cstring>
 #include <curl/curl.h>

data/src/cxx_supportlib/Utils/ScopeGuard.h

@@ -117,38 +117,6 @@ public:
 	}
 };
 
-class FdGuard: public noncopyable {
-private:
-	int fd;
-	bool ignoreErrors;
-
-public:
-	FdGuard(int _fd, const char *file, unsigned int line, bool _ignoreErrors = false)
-		: fd(_fd),
-		  ignoreErrors(_ignoreErrors)
-	{
-		if (_fd != -1 && file != NULL) {
-			P_LOG_FILE_DESCRIPTOR_OPEN3(_fd, file, line);
-		}
-	}
-
-	~FdGuard() {
-		runNow();
-	}
-
-	void clear() {
-		fd = -1;
-	}
-
-	void runNow() {
-		if (fd != -1) {
-			safelyClose(fd, ignoreErrors);
-			P_LOG_FILE_DESCRIPTOR_CLOSE(fd);
-			fd = -1;
-		}
-	}
-};
-
 
 } // namespace Passenger
 

data/src/cxx_supportlib/oxt/implementation.cpp

@@ -272,14 +272,14 @@ tracable_exception &
 tracable_exception::operator=(const tracable_exception &other) {
 	if (this != &other) {
 		// Clean up existing backtrace points
-		for (auto p: backtrace_copy) {
+		for (trace_point * p: backtrace_copy) {
 			delete p;
 		}
 		backtrace_copy.clear();
 
 		// Copy backtrace points from other
 		backtrace_copy.reserve(other.backtrace_copy.size());
-		for (const auto p2: other.backtrace_copy) {
+		for (const trace_point *const p2: other.backtrace_copy) {
 			trace_point *p;
 			if (p2->m_hasDataFunc) {
 				p = new trace_point(

data/src/cxx_supportlib/oxt/spin_lock.hpp

@@ -25,28 +25,99 @@
 #ifndef _OXT_SPIN_LOCK_HPP_
 #define _OXT_SPIN_LOCK_HPP_
 
-#include "macros.hpp"
-
-// These operating systems don't support pthread spin locks:
-// - OpenBSD 4.3 (last checked: July 22, 2008)
-// - Solaris 9 (last checked: July 22, 2008)
-// - MacOS X (last checked: July 22, 2012)
-#if defined(__OpenBSD__) || defined(__SOLARIS9__) || defined(__APPLE__)
-	#define OXT_NO_PTHREAD_SPINLOCKS
-#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
+#include <thread>
+#include <atomic>
 
-#endif /* _OXT_SPIN_LOCK_HPP_ */
+namespace oxt {
+
+/**
+ * A spin lock that's specifically designed to yield the CPU once in a while to
+ * avoid starving other threads.
+ *
+ * We use spin locks because on many platforms, mutexes are slower when there's little
+ * or no contention. OS-native mutexes work better in highly contended scenarios due
+ * to better scheduler integration. However, in Passenger we have a couple of scenarios
+ * where we know there's going to be little or no contention. In oxt::system_calls,
+ * contention is rare and mostly limited to thread interruption during aborts or process
+ * shutdown. As a result, we use spin locks to prioritize performance in the uncontended
+ * case.
+ *
+ * We avoid OS-native spinlocks for two reasons:
+ * - There's no widely-available standard spinlock. We want to keep the code simple,
+ *   avoiding OS-specific implementations.
+ * - OS-native spinlocks such as pthread_spin_lock_t don't guarantee scheduler integration,
+ *   but we need it in order to avoid starvation that would interfere with thread
+ *   interruption.
+ */
+class spin_lock {
+private:
+	// Our main use case is to allow threads to only be interruptable when
+	// blocked on certain system calls (oxt::thread_local_context::syscall_interruption_lock).
+	// That is locked most of the time, only unlocked during a syscall.
+	// An oxt::thread::interrupt() call may need to wait for a long time before it's unlocked.
+	// So keep the spin count low so we yield the CPU often.
+	static constexpr unsigned int MAX_SPINS = 100;
+
+	std::atomic_flag flag = ATOMIC_FLAG_INIT;
+
+public:
+	/**
+	* Instantiate this class to lock a spin lock within a scope.
+	*/
+	class scoped_lock {
+	private:
+		spin_lock &l;
+
+	public:
+		scoped_lock(const scoped_lock &other) = delete;
+		scoped_lock &operator=(const scoped_lock &other) = delete;
 
+		scoped_lock(spin_lock &lock) noexcept: l(lock) {
+			l.lock();
+		}
+
+		~scoped_lock() noexcept {
+			l.unlock();
+		}
+	};
+
+	/**
+	* Lock this spin lock.
+	*/
+	void lock() noexcept {
+		while (true) {
+			for (unsigned int i = 0; i < MAX_SPINS; i++) {
+				if (flag.test_and_set(std::memory_order_acquire)) {
+					#if defined(__cpp_lib_atomic_wait) && __cpp_lib_atomic_wait >= 201907L
+						flag.wait(true, std::memory_order_relaxed);
+					#endif
+				} else {
+					return; // lock acquired
+				}
+			}
+
+			// Yield the CPU every once in a while to allow other threads to
+			// run. On systems with bad schedulers (including Valgrind),
+			// not yielding can lead to starvation, which looks like a deadlock.
+			std::this_thread::yield();
+		}
+	}
+
+	/**
+	* Unlock this spin lock.
+	*/
+	void unlock() noexcept {
+		flag.clear(std::memory_order_release);
+		#if defined(__cpp_lib_atomic_wait) && __cpp_lib_atomic_wait >= 201907L
+			flag.notify_one();
+		#endif
+	}
+
+	bool try_lock() noexcept {
+		return !flag.test_and_set(std::memory_order_acquire);
+	}
+};
+
+} // namespace oxt
+
+#endif /* _OXT_SPIN_LOCK_HPP_ */

data/src/cxx_supportlib/vendor-modified/boost/assert/source_location.hpp

@@ -9,11 +9,14 @@
 
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
-#include <iosfwd>
 #include <string>
 #include <cstdio>
 #include <cstring>
 
+#if !defined(BOOST_NO_IOSTREAM)
+#include <iosfwd>
+#endif
+
 #if defined(__cpp_lib_source_location) && __cpp_lib_source_location >= 201907L
 # include <source_location>
 #endif
@@ -132,12 +135,16 @@ public:
     }
 };
 
+#if !defined(BOOST_NO_IOSTREAM)
+
 template<class E, class T> std::basic_ostream<E, T> & operator<<( std::basic_ostream<E, T> & os, source_location const & loc )
 {
     os << loc.to_string();
     return os;
 }
 
+#endif
+
 } // namespace boost
 
 #if defined(BOOST_DISABLE_CURRENT_LOCATION)

data/src/cxx_supportlib/vendor-modified/boost/assert.hpp

@@ -46,7 +46,13 @@
 
 namespace boost
 {
+#if defined(BOOST_ASSERT_HANDLER_IS_NORETURN)
+    BOOST_NORETURN
+#endif
     void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
+#if defined(BOOST_ASSERT_HANDLER_IS_NORETURN)
+    BOOST_NORETURN
+#endif
     void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line); // user defined
 } // namespace boost