passenger 5.0.26 → 5.0.27

data/src/cxx_supportlib/Utils.cpp

@@ -286,11 +286,10 @@ resolveSymlink(const StaticString &path) {
 
 string
 extractDirName(const StaticString &path) {
-	char *path_copy = strdup(path.c_str());
-	char *result = dirname(path_copy);
-	string result_string(result);
-	free(path_copy);
-	return result_string;
+	DynamicBuffer pathCopy(path.size() + 1);
+	memcpy(pathCopy.data, path.data(), path.size());
+	pathCopy.data[path.size()] = '\0';
+	return string(dirname(pathCopy.data));
 }
 
 StaticString

data/src/cxx_supportlib/Utils.h

@@ -178,8 +178,8 @@ string canonicalizePath(const string &path);
 string resolveSymlink(const StaticString &path);
 
 /**
- * Given a path, extracts its directory name.
- * <em>path</em> MUST be null-terminated!
+ * Given a path, extracts its directory name. 'path' does not
+ * have to be NULL terminated.
  *
  * @ingroup Support
  */

data/src/cxx_supportlib/Utils/IOUtils.cpp

@@ -772,7 +772,7 @@ waitUntilIOEvent(int fd, short event, unsigned long long *timeout) {
 	pfd.events = event;
 	pfd.revents = 0;
 
-	Timer timer;
+	Timer<> timer;
 	ret = syscalls::poll(&pfd, 1, *timeout / 1000);
 	if (ret == -1) {
 		int e = errno;

data/src/cxx_supportlib/Utils/JsonUtils.h

@@ -208,27 +208,29 @@ timeToJson(unsigned long long timestamp, unsigned long long now = 0) {
 	}
 
 	Json::Value doc;
-	time_t time = (time_t) timestamp / 1000000;
-	char buf[32];
+	time_t wallClockTime = (time_t) (timestamp / 1000000ull);
+	char wallClockTimeStr[32];
 	size_t len;
 
 	if (now == 0) {
 		now = SystemTime::getUsec();
 	}
 
-	doc["timestamp"] = timestamp / (double) 1000000;
-
-	ctime_r(&time, buf);
-	len = strlen(buf);
+	ctime_r(&wallClockTime, wallClockTimeStr);
+	len = strlen(wallClockTimeStr);
 	if (len > 0) {
 		// Get rid of trailing newline
-		buf[len - 1] = '\0';
+		wallClockTimeStr[len - 1] = '\0';
 	}
-	doc["local"] = buf;
+
+	doc["timestamp"] = timestamp / 1000000.0;
+	doc["local"] = wallClockTimeStr;
 	if (timestamp > now) {
-		doc["relative"] = distanceOfTimeInWords(time) + " from now";
+		doc["relative_timestamp"] = (timestamp - now) / 1000000.0;
+		doc["relative"] = distanceOfTimeInWords(wallClockTime, now / 1000000ull) + " from now";
 	} else {
-		doc["relative"] = distanceOfTimeInWords(time) + " ago";
+		doc["relative_timestamp"] = (now - timestamp) / -1000000.0;
+		doc["relative"] = distanceOfTimeInWords(wallClockTime, now / 1000000ull) + " ago";
 	}
 
 	return doc;

data/src/cxx_supportlib/Utils/MessagePassing.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2012-2015 Phusion Holding B.V.
+ *  Copyright (c) 2012-2016 Phusion Holding B.V.
  *
  *  "Passenger", "Phusion Passenger" and "Union Station" are registered
  *  trademarks of Phusion Holding B.V.
@@ -183,7 +183,7 @@ class MessageBox: public boost::enable_shared_from_this<MessageBox> {
 	}
 
 	void substractTimePassed(unsigned long long *timeout, unsigned long long beginTime) {
-		unsigned long long now = SystemTime::getMsec();
+		unsigned long long now = SystemTime::getMonotonicUsec();
 		unsigned long long diff;
 		if (now > beginTime) {
 			diff = now - beginTime;
@@ -224,7 +224,7 @@ public:
 		posix_time::ptime deadline;
 		unsigned long long beginTime = 0; // Shut up compiler warning.
 		if (timeout != NULL) {
-			beginTime = SystemTime::getUsec();
+			beginTime = SystemTime::getMonotonicUsec();
 			deadline = posix_time::microsec_clock::local_time() +
 				posix_time::microsec(*timeout);
 		}
@@ -263,7 +263,7 @@ public:
 		posix_time::ptime deadline;
 		unsigned long long beginTime = 0; // Shut up compiler warning.
 		if (timeout != NULL) {
-			beginTime = SystemTime::getUsec();
+			beginTime = SystemTime::getMonotonicUsec();
 			deadline = posix_time::microsec_clock::local_time() +
 				posix_time::microsec(*timeout);
 		}

data/src/cxx_supportlib/Utils/StrIntUtils.cpp

@@ -654,9 +654,13 @@ escapeHTML(const StaticString &input) {
 		if (ch & 128) {
 			// Multibyte UTF-8 character.
 			const char *prev = current;
-			utf8::advance(current, 1, end);
-			result.append(prev, current - prev);
-
+			try {
+				utf8::advance(current, 1, end);
+				result.append(prev, current - prev);
+			} catch (const utf8::invalid_utf8 &e) {
+				result.append("?"); // Oops, not UTF-8 after all, don't parse it.
+				current++;
+			}
 		} else {
 			// ASCII character <= 127.
 			if (ch == '<') {

data/src/cxx_supportlib/Utils/SystemTime.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010 Phusion Holding B.V.
+ *  Copyright (c) 2010-2016 Phusion Holding B.V.
  *
  *  "Passenger", "Phusion Passenger" and "Union Station" are registered
  *  trademarks of Phusion Holding B.V.
@@ -24,15 +24,26 @@
  *  THE SOFTWARE.
  */
 
-#include <time.h>
+#include <Utils/SystemTime.h>
 
 namespace Passenger {
 	namespace SystemTimeData {
+		bool initialized = false;
 		bool hasForcedValue = false;
 		time_t forcedValue = 0;
-		bool hasForcedMsecValue = false;
-		unsigned long long forcedMsecValue = 0;
 		bool hasForcedUsecValue = false;
 		unsigned long long forcedUsecValue = 0;
+
+		#if BOOST_OS_MACOS
+			mach_timebase_info_data_t timeInfo;
+		#elif defined(SYSTEM_TIME_HAVE_MONOTONIC_CLOCK)
+			#ifdef SYSTEM_TIME_HAVE_CLOCK_MONOTONIC_COARSE
+				unsigned long long monotonicCoarseResolutionNs = 0;
+			#endif
+			#ifdef SYSTEM_TIME_HAVE_CLOCK_MONOTONIC_FAST
+				unsigned long long monotonicFastResolutionNs = 0;
+			#endif
+			unsigned long long monotonicResolutionNs;
+		#endif
 	}
 }

data/src/cxx_supportlib/Utils/SystemTime.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010 Phusion Holding B.V.
+ *  Copyright (c) 2010-2016 Phusion Holding B.V.
  *
  *  "Passenger", "Phusion Passenger" and "Union Station" are registered
  *  trademarks of Phusion Holding B.V.
@@ -27,34 +27,221 @@
 #define _PASSENGER_SYSTEM_TIME_H_
 
 #include <boost/thread.hpp>
+#include <boost/predef.h>
+#include <oxt/macros.hpp>
 #include <oxt/system_calls.hpp>
-#include "../Exceptions.h"
+#include <sys/time.h>
+#include <cerrno>
+#include <time.h>
+#include <unistd.h>
+#include <Exceptions.h>
+
+#if BOOST_OS_MACOS
+	#include <mach/mach.h>
+	#include <mach/mach_time.h>
+	#include <cstring>
+#elif BOOST_OS_AIX
+	#include <sys/systemcfg.h>
+#elif defined(_POSIX_MONOTONIC_CLOCK) || defined(CLOCK_MONOTONIC)
+	#define SYSTEM_TIME_HAVE_MONOTONIC_CLOCK
+	#ifdef CLOCK_MONOTONIC_COARSE
+		#define SYSTEM_TIME_HAVE_CLOCK_MONOTONIC_COARSE
+	#endif
+	#ifdef CLOCK_MONOTONIC_FAST
+		#define SYSTEM_TIME_HAVE_CLOCK_MONOTONIC_FAST
+	#endif
+#endif
 
 namespace Passenger {
 
+using namespace std;
 using namespace oxt;
 
 namespace SystemTimeData {
+	extern bool initialized;
 	extern bool hasForcedValue;
 	extern time_t forcedValue;
-	extern bool hasForcedMsecValue;
-	extern unsigned long long forcedMsecValue;
 	extern bool hasForcedUsecValue;
 	extern unsigned long long forcedUsecValue;
+
+	#if BOOST_OS_MACOS
+		extern mach_timebase_info_data_t timeInfo;
+	#elif defined(SYSTEM_TIME_HAVE_MONOTONIC_CLOCK)
+		#ifdef SYSTEM_TIME_HAVE_CLOCK_MONOTONIC_COARSE
+			extern unsigned long long monotonicCoarseResolutionNs;
+		#endif
+		#ifdef SYSTEM_TIME_HAVE_CLOCK_MONOTONIC_FAST
+			extern unsigned long long monotonicFastResolutionNs;
+		#endif
+		extern unsigned long long monotonicResolutionNs;
+	#endif
 }
 
+typedef unsigned long long MonotonicTimeUsec;
+
 /**
  * This class allows one to obtain the system time, similar to time() and
  * gettimeofday(). Unlike time(), it is possible to force a certain time
  * to be returned, which is useful for testing code that depends on the
  * system time.
  *
- * get() provides seconds resolution while getMsec() provides milliseconds
+ * get() provides seconds resolution while getUsec() provides microseconds
  * resolution. Both clocks can be independently forced to a certain value
- * through force() and forceMsec().
+ * through force() and forceUsec().
+ *
+ * In addition, getMonotonicUsec() returns the monotonic clock in
+ * microseconds. This can also be forced to a certain value using forceUsec().
+ *
+ * Before using any SystemTime functions, you should call
+ * SystemTime::initialize(). If you don't do that, then initialize() will be
+ * called for you, but since initialize() isn't thread-safe you should
+ * call it at the beginning of your program.
  */
 class SystemTime {
 public:
+	enum Granularity {
+		GRAN_1SEC   = 1000000000,   // 1 millisecond granularity
+		GRAN_10MSEC = 10000000,     // 10 milliseconds granularity
+		GRAN_1MSEC  = 1000000,      // 1 millisecond granularity
+		GRAN_1USEC  = 1000          // 1 microsecond granularty
+	};
+
+private:
+	static void initializeIfNeeded() {
+		if (OXT_UNLIKELY(!SystemTimeData::initialized)) {
+			initialize();
+		}
+	}
+
+	template<Granularity granularityNs>
+	static MonotonicTimeUsec _getMonotonicUsec() {
+		if (OXT_UNLIKELY(SystemTimeData::hasForcedUsecValue)) {
+			return SystemTimeData::hasForcedValue;
+		}
+
+		#if BOOST_OS_MACOS
+			initializeIfNeeded();
+			if (SystemTimeData::timeInfo.numer == 0
+			 && SystemTimeData::timeInfo.denom == 0)
+			{
+				return getUsec();
+			} else {
+				return mach_absolute_time()
+					* SystemTimeData::timeInfo.numer
+					/ SystemTimeData::timeInfo.denom
+					/ 1000;
+			}
+
+		#elif BOOST_OS_SOLARIS
+			return gethrtime() / 1000ull;
+
+		#elif BOOST_OS_AIX
+			timebasestruct_t t;
+			read_wall_time(&t, TIMEBASE_SZ);
+			time_base_to_time(&t, TIMEBASE_SZ);
+			return t.tb_high * 1000000ull + t.tb_low / 1000ull;
+
+		#elif defined(SYSTEM_TIME_HAVE_MONOTONIC_CLOCK)
+			clockid_t clockId = (clockid_t) -1;
+			struct timespec ts;
+			int ret;
+
+			initializeIfNeeded();
+
+			// We choose a different monotonic clock
+			// based on the resolution we need. In general,
+			// coarser resolutions are faster, for example
+			// because (on Linux) they are implemented
+			// through VDSOs instead of system calls.
+			//
+			// Benchmarks and properties as of 10 March 2016:
+			//
+			// FreeBSD 10.2 (200000 iterations):
+			// CLOCK_MONOTONIC           1m 9s      11 nanosec resolution
+			// CLOCK_MONOTONIC_PRECISE   1m 9s      11 nanosec resolution
+			// CLOCK_MONOTONIC_FAST      2s         11 nanosec resolution
+			// gettimeofday              1m 9s
+			//
+			// Linux 3.13.0 (100000000 iterations):
+			// CLOCK_MONOTONIC           1.5s        1 nanosec resolution
+			// CLOCK_MONOTONIC_COARSE    0.45s       4 millisec resolution
+			// gettimeofday              1.5s
+
+			#ifdef SYSTEM_TIME_HAVE_CLOCK_MONOTONIC_COARSE
+				if (clockId == -1
+				 && SystemTimeData::monotonicCoarseResolutionNs != 0
+				 && SystemTimeData::monotonicCoarseResolutionNs <= granularityNs)
+				{
+					clockId = CLOCK_MONOTONIC_COARSE;
+				}
+			#endif
+			#ifdef SYSTEM_TIME_HAVE_CLOCK_MONOTONIC_FAST
+				if (clockId == -1
+				 && SystemTimeData::monotonicFastResolutionNs != 0
+				 && SystemTimeData::monotonicFastResolutionNs <= granularityNs)
+				{
+					clockId = CLOCK_MONOTONIC_FAST;
+				}
+			#endif
+			if (clockId == -1
+			 && SystemTimeData::monotonicResolutionNs != 0
+			 && SystemTimeData::monotonicResolutionNs <= granularityNs)
+			{
+				clockId = CLOCK_MONOTONIC;
+			}
+
+			if (clockId == (clockid_t) -1) {
+				return getUsec();
+			} else {
+				do {
+					ret = clock_gettime(clockId, &ts);
+				} while (ret == -1 && errno == EINTR);
+				if (ret == -1) {
+					int e = errno;
+					throw TimeRetrievalException(
+						"Unable to retrieve the system time",
+						e);
+				}
+				return ts.tv_sec * 1000000ull + ts.tv_nsec / 1000ull;
+			}
+
+		#else
+			return getUsec();
+		#endif
+	}
+
+public:
+	static void initialize() {
+		SystemTimeData::initialized = true;
+		#if BOOST_OS_MACOS
+			if (mach_timebase_info(&SystemTimeData::timeInfo) != KERN_SUCCESS) {
+				memset(&SystemTimeData::timeInfo, 0, sizeof(SystemTimeData::timeInfo));
+			}
+		#elif defined(SYSTEM_TIME_HAVE_MONOTONIC_CLOCK)
+			struct timespec ts;
+
+			#ifdef CLOCK_MONOTONIC_COARSE
+				if (clock_getres(CLOCK_MONOTONIC_COARSE, &ts) == 0) {
+					SystemTimeData::monotonicCoarseResolutionNs =
+						ts.tv_sec * 1000000000ull +
+						ts.tv_nsec;
+				}
+			#endif
+			#ifdef CLOCK_MONOTONIC_FAST
+				if (clock_getres(CLOCK_MONOTONIC_FAST, &ts) == 0) {
+					SystemTimeData::monotonicFastResolutionNs =
+						ts.tv_sec * 1000000000ull +
+						ts.tv_nsec;
+				}
+			#endif
+			if (clock_getres(CLOCK_MONOTONIC, &ts) == 0) {
+				SystemTimeData::monotonicResolutionNs =
+					ts.tv_sec * 1000000000ull +
+					ts.tv_nsec;
+			}
+		#endif
+	}
+
 	/**
 	 * Returns the time since the Epoch, measured in seconds. Or, if a time
 	 * was forced with force(), then the forced time is returned instead.
@@ -63,7 +250,7 @@ public:
 	 * @throws boost::thread_interrupted
 	 */
 	static time_t get() {
-		if (SystemTimeData::hasForcedValue) {
+		if (OXT_UNLIKELY(SystemTimeData::hasForcedValue)) {
 			return SystemTimeData::forcedValue;
 		} else {
 			time_t ret = syscalls::time(NULL);
@@ -78,16 +265,15 @@ public:
 	}
 
 	/**
-	 * Returns the time since the Epoch, measured in milliseconds. Or, if a
-	 * time was forced with forceMsec(), then the forced time is returned instead.
+	 * Returns the time since the Epoch, measured in microseconds. Or, if a
+	 * time was forced with forceUsec(), then the forced time is returned instead.
 	 *
-	 * @param real Whether to get the real time, even if a value was forced.
 	 * @throws TimeRetrievalException Something went wrong while retrieving the time.
 	 * @throws boost::thread_interrupted
 	 */
-	static unsigned long long getMsec(bool real = false) {
-		if (SystemTimeData::hasForcedMsecValue && !real) {
-			return SystemTimeData::forcedMsecValue;
+	static unsigned long long getUsec() {
+		if (OXT_UNLIKELY(SystemTimeData::hasForcedUsecValue)) {
+			return SystemTimeData::forcedUsecValue;
 		} else {
 			struct timeval t;
 			int ret;
@@ -101,35 +287,41 @@ public:
 					"Unable to retrieve the system time",
 					e);
 			}
-			return (unsigned long long) t.tv_sec * 1000 + t.tv_usec / 1000;
+			return (unsigned long long) t.tv_sec * 1000000 + t.tv_usec;
 		}
 	}
 
 	/**
-	 * Returns the time since the Epoch, measured in microseconds. Or, if a
-	 * time was forced with forceUsec(), then the forced time is returned instead.
+	 * Returns the time since an unspecified point in the last, measured in
+	 * microseconds, using the monotonic clock.
+	 *
+	 * The monotonic clock is not subject to clock drift, even if the user
+	 * changes the wall clock time. It is ideal for measuring time between
+	 * two intervals.
+	 *
+	 * The returned time is guaranteed to have a granularity of 1 microsecond
+	 * or better. In general, querying with coarser granularities is faster.
+	 * If you want a coarser granularity, use `getMonotonicUsecWithGranularity()`
+	 * instead.
+	 *
+	 * If the monotonic clock is not available (e.g. because the operating
+	 * system doesn't support it), then this function returns the regular
+	 * wall clock time instead (using `getUsec()`). If the monotonic clock
+	 * is available, but an error occurred querying it, then a
+	 * `TimeRetrievalException` is thrown.
+	 *
+	 * If the time was forced with forceUsed(), then the forced time is returned
+	 * instead.
 	 *
 	 * @throws TimeRetrievalException Something went wrong while retrieving the time.
-	 * @throws boost::thread_interrupted
 	 */
-	static unsigned long long getUsec() {
-		if (SystemTimeData::hasForcedUsecValue) {
-			return SystemTimeData::forcedUsecValue;
-		} else {
-			struct timeval t;
-			int ret;
+	static MonotonicTimeUsec getMonotonicUsec() {
+		return _getMonotonicUsec<GRAN_1USEC>();
+	}
 
-			do {
-				ret = gettimeofday(&t, NULL);
-			} while (ret == -1 && errno == EINTR);
-			if (ret == -1) {
-				int e = errno;
-				throw TimeRetrievalException(
-					"Unable to retrieve the system time",
-					e);
-			}
-			return (unsigned long long) t.tv_sec * 1000000 + t.tv_usec;
-		}
+	template<Granularity granularity>
+	static MonotonicTimeUsec getMonotonicUsecWithGranularity() {
+		return _getMonotonicUsec<granularity>();
 	}
 
 	/**
@@ -140,14 +332,6 @@ public:
 		SystemTimeData::forcedValue = value;
 	}
 
-	/**
-	 * Force getMsec() to return the given value.
-	 */
-	static void forceMsec(unsigned long long value) {
-		SystemTimeData::hasForcedMsecValue = true;
-		SystemTimeData::forcedMsecValue = value;
-	}
-
 	/**
 	 * Force getUsec() to return the given value.
 	 */
@@ -158,7 +342,6 @@ public:
 
 	static void forceAll(unsigned long long usec) {
 		force(usec / 1000000);
-		forceMsec(usec / 1000);
 		forceUsec(usec);
 	}
 
@@ -170,14 +353,6 @@ public:
 		SystemTimeData::hasForcedValue = false;
 	}
 
-	/**
-	 * Release the previously forced msec value, so that getMsec()
-	 * returns the system time once again.
-	 */
-	static void releaseMsec() {
-		SystemTimeData::hasForcedMsecValue = false;
-	}
-
 	/**
 	 * Release the previously forced usec value, so that getUsec()
 	 * returns the system time once again.
@@ -187,12 +362,11 @@ public:
 	}
 
 	/**
-	 * Release all previously forced values, so that get(), getMsec()
-	 * and getUsec() return the system time once again.
+	 * Release all previously forced values, so that get() and
+	 * getUsec() return the system time once again.
 	 */
 	static void releaseAll() {
 		SystemTimeData::hasForcedValue = false;
-		SystemTimeData::hasForcedMsecValue = false;
 		SystemTimeData::hasForcedUsecValue = false;
 	}
 };