passenger 6.0.27 → 6.1.0

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/ruby_supportlib/phusion_passenger/platform_info/compiler.rb

@@ -532,25 +532,21 @@ module PhusionPassenger
       end
     end
 
-    def self.cxx_11_flag
-      # C++11 support on FreeBSD 10.0 + Clang seems to be bugged.
-      # http://llvm.org/bugs/show_bug.cgi?id=18310
-      return nil if os_name_simple == "freebsd"
-
+    def self.cxx_14_flag
       source = %{
         struct Foo {
           Foo(Foo &&f) { }
         };
       }
-      if try_compile("Checking for C++ -std=gnu++11 compiler flag", :cxx, source, '-std=gnu++11')
-        return "-std=gnu++11"
-      elsif try_compile("Checking for C++ -std=c++11 compiler flag", :cxx, source, '-std=c++11')
-        return "-std=c++11"
+      if try_compile("Checking for C++ -std=gnu++14 compiler flag", :cxx, source, '-std=gnu++14')
+        return "-std=gnu++14"
+      elsif try_compile("Checking for C++ -std=c++14 compiler flag", :cxx, source, '-std=c++14')
+        return "-std=c++14"
       else
         return nil
       end
     end
-    memoize :cxx_11_flag, true
+    memoize :cxx_14_flag, true
 
     def self.has_rt_library?
       return try_link("Checking for -lrt support",

data/src/ruby_supportlib/phusion_passenger/platform_info/cxx_portability.rb

@@ -138,7 +138,7 @@ module PhusionPassenger
 
       if cc_or_cxx == :cxx
         flags << debugging_cxxflags
-        flags << cxx_11_flag if cxx_11_flag
+        flags << cxx_14_flag if cxx_14_flag
 
         if cxx_supports_wno_unused_local_typedefs_flag?
           # Avoids some compilaton warnings with Boost on Ubuntu 14.04.
@@ -192,7 +192,7 @@ module PhusionPassenger
 
     def self.portability_c_or_cxx_ldflags(cc_or_cxx)
       result = ''
-      result << cxx_11_flag if cc_or_cxx == :cxx && cxx_11_flag
+      result << cxx_14_flag if cc_or_cxx == :cxx && cxx_14_flag
       if os_name_simple == "solaris"
         result << ' -lxnet -lsocket -lnsl -lpthread'
       else

data/src/ruby_supportlib/phusion_passenger/rack_handler.rb

@@ -41,7 +41,7 @@ require 'rbconfig'
 require 'rackup' if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.4.0')
 
 # Rackup was removed in Rack 3, it is now a separate gem
-if Object.const_defined? :Rackup
+if Object.const_defined?(:Rackup) && ::Rackup.const_defined?(:Handler)
   module Rackup
     module Handler
       module PhusionPassenger
@@ -57,7 +57,7 @@ if Object.const_defined? :Rackup
       register :passenger, PhusionPassenger
     end
   end
-elsif Object.const_defined?(:Rack) && Rack.release < '3'
+elsif Object.const_defined?(:Rack) && ::Rack.release < '3'
   module Rack
     module Handler
       module PhusionPassenger

data/src/ruby_supportlib/phusion_passenger.rb

@@ -31,7 +31,7 @@ module PhusionPassenger
 
   PACKAGE_NAME = 'passenger'
   # Run 'rake src/cxx_supportlib/Constants.h configkit_schemas_inline_comments' after changing this number.
-  VERSION_STRING = '6.0.27'
+  VERSION_STRING = '6.1.0'
 
   # Tip: find the SHA-256 with ./dev/nginx_version_sha256 <VERSION>
   PREFERRED_NGINX_VERSION = '1.26.3'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: passenger
 version: !ruby/object:Gem::Version
-  version: 6.0.27
+  version: 6.1.0
 platform: ruby
 authors:
 - Phusion - http://www.phusion.nl/
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-04-01 00:00:00.000000000 Z
+date: 2025-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -536,10 +536,6 @@ files:
 - src/cxx_supportlib/oxt/detail/backtrace_disabled.hpp
 - src/cxx_supportlib/oxt/detail/backtrace_enabled.hpp
 - src/cxx_supportlib/oxt/detail/context.hpp
-- src/cxx_supportlib/oxt/detail/spin_lock_darwin.hpp
-- src/cxx_supportlib/oxt/detail/spin_lock_gcc_x86.hpp
-- src/cxx_supportlib/oxt/detail/spin_lock_portable.hpp
-- src/cxx_supportlib/oxt/detail/spin_lock_pthreads.hpp
 - src/cxx_supportlib/oxt/detail/tracable_exception_disabled.hpp
 - src/cxx_supportlib/oxt/detail/tracable_exception_enabled.hpp
 - src/cxx_supportlib/oxt/dynamic_thread_group.hpp
@@ -4386,7 +4382,7 @@ homepage: https://www.phusionpassenger.com/
 licenses: []
 metadata:
   bug_tracker_uri: https://github.com/phusion/passenger/issues
-  changelog_uri: https://github.com/phusion/passenger/blob/stable-6.0/CHANGELOG
+  changelog_uri: https://github.com/phusion/passenger/blob/stable-6.1/CHANGELOG
   documentation_uri: https://www.phusionpassenger.com/docs/
   homepage_uri: https://www.phusionpassenger.com/
   source_code_uri: https://github.com/phusion/passenger