passenger 6.0.26 → 6.1.0

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/Utils.h

@@ -33,13 +33,6 @@
 #include <sys/stat.h>
 #include <string>
 #include <vector>
-#include <utility>
-#include <sstream>
-#include <cstdio>
-#include <climits>
-#include <cstdlib>
-#include <cstring>
-#include <errno.h>
 #include <unistd.h>
 #include <StaticString.h>
 #include <Exceptions.h>
@@ -54,29 +47,6 @@ using namespace boost;
 
 class ResourceLocator;
 
-/**
- * Convenience shortcut for creating a <tt>shared_ptr</tt>.
- * Instead of:
- * @code
- *    boost::shared_ptr<Foo> foo;
- *    ...
- *    foo = boost::shared_ptr<Foo>(new Foo());
- * @endcode
- * one can write:
- * @code
- *    boost::shared_ptr<Foo> foo;
- *    ...
- *    foo = ptr(new Foo());
- * @endcode
- *
- * @param pointer The item to put in the boost::shared_ptr object.
- * @ingroup Support
- */
-template<typename T> boost::shared_ptr<T>
-ptr(T *pointer) {
-	return boost::shared_ptr<T>(pointer);
-}
-
 /**
  * Escape the given raw string into an XML value.
  *

data/src/cxx_supportlib/oxt/detail/tracable_exception_disabled.hpp

@@ -53,6 +53,10 @@ public:
 		// Do nothing.
 	}
 
+	tracable_exception &operator=(const tracable_exception &other) {
+		return *this; // Do nothing.
+	}
+
 	virtual std::string backtrace() const throw() {
 		return "     (backtrace support disabled during compile time)\n";
 	}

data/src/cxx_supportlib/oxt/detail/tracable_exception_enabled.hpp

@@ -42,6 +42,7 @@ public:
 	tracable_exception();
 	tracable_exception(const tracable_exception &other);
 	tracable_exception(const no_backtrace &tag);
+	tracable_exception &operator=(const tracable_exception &other);
 	virtual ~tracable_exception() throw();
 	virtual std::string backtrace() const throw();
 	virtual const char *what() const throw();

data/src/cxx_supportlib/oxt/implementation.cpp

@@ -34,8 +34,10 @@
 #include "thread.hpp"
 #include "spin_lock.hpp"
 #include "detail/context.hpp"
-#ifdef __linux__
+#if defined(__linux__)
 	#include <sys/syscall.h>
+#elif defined(__FreeBSD__)
+	#include <pthread_np.h> // for pthread_set_name_np()
 #endif
 
 #ifdef OXT_THREAD_LOCAL_KEYWORD_SUPPORTED
@@ -266,6 +268,41 @@ tracable_exception::tracable_exception(const no_backtrace &tag)
 	// Do nothing.
 }
 
+tracable_exception &
+tracable_exception::operator=(const tracable_exception &other) {
+	if (this != &other) {
+		// Clean up existing backtrace points
+		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 trace_point *const p2: other.backtrace_copy) {
+			trace_point *p;
+			if (p2->m_hasDataFunc) {
+				p = new trace_point(
+					p2->function,
+					p2->source,
+					p2->line,
+					p2->u.dataFunc.func,
+					p2->u.dataFunc.userData,
+					true);
+			} else {
+				p = new trace_point(
+					p2->function,
+					p2->source,
+					p2->line,
+					p2->u.data,
+					trace_point::detached());
+			}
+			backtrace_copy.push_back(p);
+		}
+	}
+	return *this;
+}
+
 tracable_exception::~tracable_exception() throw() {
 	vector<trace_point *>::iterator it, end = backtrace_copy.end();
 	for (it = backtrace_copy.begin(); it != end; it++) {
@@ -399,8 +436,10 @@ static void
 set_native_thread_name(const string &name) {
 	#if defined(__linux__)
 		pthread_setname_np(pthread_self(), name.c_str());
-	#elif defined(__APPLE__) || defined(__FreeBSD__)
+	#elif defined(__APPLE__)
 		pthread_setname_np(name.c_str());
+	#elif defined(__FreeBSD__)
+		pthread_set_name_np(pthread_self(), name.c_str());
 	#endif
 }
 

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/oxt/system_calls.cpp

@@ -26,6 +26,7 @@
 #include "detail/context.hpp"
 #include <boost/thread.hpp>
 #include <cerrno>
+#include <signal.h>
 
 using namespace boost;
 using namespace oxt;

data/src/cxx_supportlib/oxt/system_calls.hpp

@@ -35,11 +35,10 @@
 #include <pthread.h>
 #include <unistd.h>
 #include <fcntl.h>
-#include <signal.h>
 #include <poll.h>
+#include <signal.h> // IWYU pragma: keep; for SIGUSR1
 #include <cstdio>
 #include <ctime>
-#include <cassert>
 #include "macros.hpp"
 
 /**
@@ -113,8 +112,8 @@
 // This is one of the things that Java is good at and C++ sucks at. Sigh...
 
 namespace oxt {
-	static const int INTERRUPTION_SIGNAL = SIGUSR1; // SIGUSR2 is reserved by Valgrind...
-	#define OXT_MAX_ERROR_CHANCES 16
+	static constexpr int INTERRUPTION_SIGNAL = SIGUSR1; // SIGUSR2 is reserved by Valgrind...
+	static constexpr unsigned int OXT_MAX_ERROR_CHANCES = 16;
 
 	struct ErrorChance {
 		double chance;

data/src/cxx_supportlib/vendor-modified/boost/container/allocator.hpp

@@ -336,8 +336,8 @@ class allocator
       BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       dlmalloc_memchain ch;
       void *beg(&*chain.begin()), *last(&*chain.last());
-      size_t size(chain.size());
-      BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, beg, last, size);
+      size_t sz(chain.size());
+      BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, beg, last, sz);
       dlmalloc_multidealloc(&ch);
       //dlmalloc_multidealloc(move_detail::force_ptr<dlmalloc_memchain *>(&chain));
    }

data/src/cxx_supportlib/vendor-modified/boost/container/deque.hpp

@@ -1026,6 +1026,11 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    private:                      // Internal typedefs
+
+   //`allocator_type::value_type` must match container's `value type`. If this
+   //assertion fails, please review your allocator definition. 
+   BOOST_CONTAINER_STATIC_ASSERT((dtl::is_same<value_type, typename allocator_traits<ValAllocator>::value_type>::value));
+
    BOOST_COPYABLE_AND_MOVABLE(deque)
    typedef typename Base::ptr_alloc_ptr index_pointer;
    typedef allocator_traits<ValAllocator>                  allocator_traits_type;

data/src/cxx_supportlib/vendor-modified/boost/container/detail/config_begin.hpp

@@ -41,6 +41,7 @@
    #pragma warning (disable : 4671) //  the copy constructor is inaccessible
    #pragma warning (disable : 4673) //  throwing '' the following types will not be considered at the catch site
    #pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter
+   #pragma warning (disable : 4702) // unreachable code
    #pragma warning (disable : 4706) // assignment within conditional expression
    #pragma warning (disable : 4710) // function not inlined
    #pragma warning (disable : 4714) // "function": marked as __forceinline not inlined

data/src/cxx_supportlib/vendor-modified/boost/container/detail/container_or_allocator_rebind.hpp

@@ -38,8 +38,7 @@ struct container_or_allocator_rebind_impl<AllocatorOrContainer, ToType, false>
 
 template<class ToType>
 struct container_or_allocator_rebind_impl<void, ToType, false>
-   : real_allocator<ToType, void>
-{};
+{  typedef void type;  };
 
 template<class AllocatorOrContainer, class ToType>
 struct container_or_allocator_rebind

data/src/cxx_supportlib/vendor-modified/boost/container/detail/container_rebind.hpp

@@ -26,6 +26,16 @@ namespace boost {
 namespace container {
 namespace dtl {
 
+   template<class V, class A, class U>
+   struct void_or_portable_rebind_alloc
+   {
+      typedef typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type type;
+   };
+
+   template<class V, class U>
+   struct void_or_portable_rebind_alloc<V, void, U>
+   {  typedef void type;  };
+
    template <class Cont, class U>
    struct container_rebind;
 
@@ -34,14 +44,14 @@ namespace dtl {
    template <template <class, class, class...> class Cont, typename V, typename A, class... An, class U>
    struct container_rebind<Cont<V, A, An...>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, An...> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, An...> type;
    };
 
    //Needed for non-conforming compilers like GCC 4.3
    template <template <class, class> class Cont, typename V, typename A, class U>
    struct container_rebind<Cont<V, A>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type> type;
    };
 
    template <template <class> class Cont, typename V, class U>
@@ -65,7 +75,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type> type;
    };
 
    template <template <class, class, class> class Cont  //1arg
@@ -73,7 +83,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0> type;
    };
 
    template <template <class, class, class, class> class Cont  //2arg
@@ -81,7 +91,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0, P1> type;
    };
 
    template <template <class, class, class, class, class> class Cont  //3arg
@@ -89,7 +99,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0, P1, P2> type;
    };
 
    template <template <class, class, class, class, class, class> class Cont  //4arg
@@ -97,7 +107,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0, P1, P2, P3> type;
    };
 
    template <template <class, class, class, class, class, class, class> class Cont  //5arg
@@ -105,7 +115,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0, P1, P2, P3, P4> type;
    };
 
    template <template <class, class, class, class, class, class, class, class> class Cont  //6arg
@@ -113,7 +123,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0, P1, P2, P3, P4, P5> type;
    };
 
    template <template <class, class, class, class, class, class, class, class, class> class Cont  //7arg
@@ -121,7 +131,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5, P6>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0, P1, P2, P3, P4, P5, P6> type;
    };
 
    template <template <class, class, class, class, class, class, class, class, class, class> class Cont  //8arg
@@ -129,7 +139,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5, P6, P7>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0, P1, P2, P3, P4, P5, P6, P7> type;
    };
 
    template <template <class, class, class, class, class, class, class, class, class, class, class> class Cont  //9arg
@@ -137,7 +147,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5, P6, P7, P8>, U>
    {
-      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7, P8> type;
+      typedef Cont<U, typename void_or_portable_rebind_alloc<V, A, U>::type, P0, P1, P2, P3, P4, P5, P6, P7, P8> type;
    };
 
 #endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -147,7 +157,7 @@ namespace dtl {
    template <typename V, std::size_t N, typename A, typename O, class U>
    struct container_rebind<small_vector<V, N, A, O>, U>
    {
-      typedef small_vector<U, N, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, O> type;
+      typedef small_vector<U, N, typename void_or_portable_rebind_alloc<V, A, U>::type, O> type;
    };
 
    template <typename V, std::size_t N, typename O, class U>