passenger 6.0.20 → 6.0.21

data/src/agent/Watchdog/WatchdogMain.cpp

@@ -71,12 +71,14 @@
 #include <Constants.h>
 #include <InstanceDirectory.h>
 #include <FileDescriptor.h>
+#include <FileTools/PathManip.h>
 #include <FileTools/PathSecurityCheck.h>
 #include <SystemTools/UserDatabase.h>
 #include <SystemTools/ContainerHelpers.h>
 #include <RandomGenerator.h>
 #include <BackgroundEventLoop.h>
 #include <LoggingKit/LoggingKit.h>
+#include <MainFunctions.h>
 #include <Exceptions.h>
 #include <StaticString.h>
 #include <Hooks.h>
@@ -101,12 +103,9 @@ enum OomFileType {
 	OOM_SCORE_ADJ
 };
 
-#define REQUEST_SOCKET_PASSWORD_SIZE     64
-
 class InstanceDirToucher;
 class AgentWatcher;
 
-
 /***** Working objects *****/
 
 namespace Passenger {
@@ -409,18 +408,12 @@ waitForStarterProcessOrWatchers(const WorkingObjectsPtr &wo, vector<AgentWatcher
 	}
 }
 
-string
-relative(string filename){
-	string dir = filename.substr(filename.find_last_of('/')+1);
-	return dir;
-}
-
 static vector<pid_t>
 readCleanupPids(const WorkingObjectsPtr &wo) {
 	vector<pid_t> result;
 
 	foreach (string filename, wo->cleanupPidfiles) {
-		FILE *f = fopen(relative(filename).c_str(), "r");
+		FILE *f = fopen(extractBaseName(filename).c_str(), "r");
 		if (f != NULL) {
 			char buf[33];
 			size_t ret;
@@ -431,10 +424,10 @@ readCleanupPids(const WorkingObjectsPtr &wo) {
 				buf[ret] = '\0';
 				result.push_back(atoi(buf));
 			} else {
-				P_WARN("Cannot read cleanup PID file " << relative(filename).c_str() << " (" << filename << ")");
+				P_WARN("Cannot read cleanup PID file " << extractBaseName(filename).c_str() << " (" << filename << ")");
 			}
 		} else {
-			P_WARN("Cannot open cleanup PID file " << relative(filename).c_str() << " (" << filename << ")");
+			P_WARN("Cannot open cleanup PID file " << extractBaseName(filename).c_str() << " (" << filename << ")");
 		}
 	}
 

data/src/apache2_module/Hooks.cpp

@@ -664,10 +664,22 @@ private:
 			bucketState = boost::make_shared<PassengerBucketState>(conn);
 			b = passenger_bucket_create(bucketState, r->connection->bucket_alloc,
 				config->getBufferResponse());
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnull-pointer-subtraction"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnull-pointer-subtraction"
 			APR_BRIGADE_INSERT_TAIL(bb, b);
+#pragma GCC diagnostic pop
+#pragma clang diagnostic pop
 
 			b = apr_bucket_eos_create(r->connection->bucket_alloc);
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnull-pointer-subtraction"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnull-pointer-subtraction"
 			APR_BRIGADE_INSERT_TAIL(bb, b);
+#pragma GCC diagnostic pop
+#pragma clang diagnostic pop
 
 			/* Now read the HTTP response header, parse it and fill relevant
 			 * information in our request_rec structure. We skip the status line
@@ -1077,9 +1089,15 @@ private:
 		apr_status_t rv;
 		int done = 0;
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnull-pointer-subtraction"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnull-pointer-subtraction"
 		while ((dst < dst_end) && !done && e != APR_BRIGADE_SENTINEL(bb)
 			&& !APR_BUCKET_IS_EOS(e))
 		{
+#pragma GCC diagnostic pop
+#pragma clang diagnostic pop
 			const char *bucket_data;
 			apr_size_t bucket_data_len;
 			const char *src;
@@ -1180,7 +1198,14 @@ private:
 		 * it needs to learn how to properly handle APR_BLOCK_READ requests by
 		 * returning data when requested.
 		 */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnull-pointer-subtraction"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnull-pointer-subtraction"
+			// we have no control over how this is implemented
 		if (APR_BRIGADE_EMPTY(bb)) {
+#pragma GCC diagnostic pop
+#pragma clang diagnostic pop
 			throw RuntimeException("An error occurred while receiving HTTP upload data: "
 				"the next filter in the input filter chain has "
 				"a bug. Please contact the author who wrote this filter about "
@@ -1615,9 +1640,9 @@ destroy_hooks(void *arg) {
 		boost::this_thread::disable_interruption di;
 		boost::this_thread::disable_syscall_interruption dsi;
 		P_DEBUG("Shutting down Phusion Passenger...");
+		delete hooks;
 		LoggingKit::shutdown();
 		oxt::shutdown();
-		delete hooks;
 		hooks = NULL;
 	} catch (const thread_interrupted &) {
 		// Ignore interruptions, we're shutting down anyway.

data/src/cxx_supportlib/ConfigKit/Common.h

@@ -67,7 +67,7 @@ enum Flags {
 	SECRET = 1 << 3,
 
 	_DYNAMIC_DEFAULT_VALUE = 1 << 30,
-	_FROM_SUBSCHEMA = 1 << 31
+	_FROM_SUBSCHEMA = 1U << 31
 };
 
 /** Represents a validation error. */

data/src/cxx_supportlib/Constants.h

@@ -83,7 +83,7 @@
 #define PASSENGER_API_VERSION_MAJOR 0
 #define PASSENGER_API_VERSION_MINOR 3
 #define PASSENGER_DEFAULT_USER "nobody"
-#define PASSENGER_VERSION "6.0.20"
+#define PASSENGER_VERSION "6.0.21"
 #define POOL_HELPER_THREAD_STACK_SIZE 262144
 #define PROCESS_SHUTDOWN_TIMEOUT 60
 #define PROCESS_SHUTDOWN_TIMEOUT_DISPLAY "1 minute"

data/src/cxx_supportlib/DataStructures/StringKeyTable.h

@@ -161,7 +161,7 @@ private:
 
 		if (m_storageUsed + key.size() + 1 > m_storageSize) {
 			// Resize storage area when of insufficient size.
-			unsigned int newStorageSize = (m_storageSize + key.size() + 1) * 1.5;
+			unsigned int newStorageSize = ((m_storageSize + key.size() + 1) * 3) / 2;
 			char *newStorage = (char *) realloc(m_storage, newStorageSize);
 			if (OXT_UNLIKELY(newStorage == NULL)) {
 				throw std::bad_alloc();

data/src/cxx_supportlib/FileTools/PathManip.cpp

@@ -30,6 +30,12 @@
 #include <limits.h>
 #include <libgen.h>
 
+#ifdef __has_include
+#if __has_include(<filesystem>)
+#include <filesystem>
+#endif
+#endif
+
 #include <vector>
 #include <cerrno>
 #include <cstring>
@@ -230,12 +236,15 @@ extractDirNameStatic(const StaticString &path) {
 
 string
 extractBaseName(const StaticString &path) {
+#if defined(_LIBCPP_FILESYSTEM) && _LIBCPP_STD_VER > 14
+    return filesystem::path(path).filename();
+#else
 	DynamicBuffer pathNt(path.size() + 1);
 	memcpy(pathNt.data, path.data(), path.size());
 	pathNt.data[path.size()] = '\0';
 	string result = basename(pathNt.data);
 	return result;
+#endif
 }
 
-
 } // namespace Passenger

data/src/cxx_supportlib/IOTools/IOUtils.cpp

@@ -530,7 +530,6 @@ connectToUnixServer(const StaticString &filename, const char *file,
 		}
 	}
 	abort();   // Never reached.
-	return -1; // Shut up compiler warning.
 }
 
 void
@@ -782,9 +781,6 @@ pingTcpServer(const StaticString &host, unsigned int port, unsigned long long *t
 			#else
 				throw e;
 			#endif
-
-			// Never reached, shut up compiler warning.
-			return false;
 		} else {
 			throw e;
 		}
@@ -919,7 +915,7 @@ staticStringArrayToIoVec(const StaticString ary[], size_t count, struct iovec *v
 			 * platforms it's still defined as non-const char *
 			 * :-(
 			 */
-			vec[vecCount].iov_base = (char *) ary[i].data();
+			vec[vecCount].iov_base = const_cast<char *>(ary[i].data());
 			vec[vecCount].iov_len  = ary[i].size();
 			total += ary[i].size();
 			vecCount++;
@@ -1030,7 +1026,7 @@ realGatheredWrite(int fd, const StaticString *data, unsigned int dataCount, stri
 			return totalSize;
 		}
 	} else {
-		iov[0].iov_base = (char *) restBuffer.data();
+		iov[0].iov_base = const_cast<char *>(restBuffer.data());
 		iov[0].iov_len  = restBuffer.size();
 		totalSize = staticStringArrayToIoVec(data, dataCount, iov + 1, iovCount);
 		totalSize += restBuffer.size();

data/src/cxx_supportlib/Integrations/LibevJsonUtils.h

@@ -62,7 +62,7 @@ evTimeToJson(ev_tstamp evTime, ev_tstamp evNow, unsigned long long now = 0) {
 
 	Json::Value doc;
 	unsigned long long wallClockTimeUsec = now
-		+ (evTime - evNow) * 1000000ull;
+		+ llround((evTime - evNow) * 1000000);
 	time_t wallClockTime = (time_t) (wallClockTimeUsec / 1000000ull);
 	char buf[32];
 	size_t len;
@@ -79,9 +79,9 @@ evTimeToJson(ev_tstamp evTime, ev_tstamp evNow, unsigned long long now = 0) {
 
 	doc["relative_timestamp"] = evTime - evNow;
 	if (evTime > evNow) {
-		doc["relative"] = distanceOfTimeInWords(evTime, evNow) + " from now";
+		doc["relative"] = distanceOfTimeInWords(llround(evTime), llround(evNow)) + " from now";
 	} else {
-		doc["relative"] = distanceOfTimeInWords(evTime, evNow) + " ago";
+		doc["relative"] = distanceOfTimeInWords(llround(evTime), llround(evNow)) + " ago";
 	}
 	return doc;
 }

data/src/cxx_supportlib/JsonTools/CBindings.cpp

@@ -73,7 +73,6 @@ psg_json_value_new_with_type(PsgJsonValueType type) {
 	default:
 		fprintf(stderr, "BUG: Unrecognized PsgJsonValueType %d\n", (int) type);
 		abort();
-		break;
 	}
 	return new Json::Value(realType);
 }
@@ -164,7 +163,6 @@ psg_json_value_type(const PsgJsonValue *doc) {
 	default:
 		fprintf(stderr, "BUG: Unrecognized Json::ValueType %d\n", (int) cxxdoc.type());
 		abort();
-		return PSG_JSON_VALUE_TYPE_NULL;
 	}
 }
 

data/src/cxx_supportlib/JsonTools/JsonUtils.h

@@ -435,9 +435,9 @@ inline Json::Value
 byteSpeedToJson(double speed, const string &per) {
 	Json::Value doc;
 	if (speed >= 0) {
-		doc = byteSizeToJson(speed);
+		doc = byteSizeToJson(llround(speed));
 	} else {
-		doc = signedByteSizeToJson(speed);
+		doc = signedByteSizeToJson(llround(speed));
 	}
 	doc["per"] = per;
 	return doc;
@@ -449,9 +449,9 @@ byteSpeedToJson(double speed, double nullValue, const string &per) {
 	if (speed == nullValue) {
 		doc["bytes"] = Json::Value(Json::nullValue);
 	} else if (speed >= 0) {
-		doc = byteSizeToJson(speed);
+		doc = byteSizeToJson(llround(speed));
 	} else {
-		doc = signedByteSizeToJson(speed);
+		doc = signedByteSizeToJson(llround(speed));
 	}
 	doc["per"] = per;
 	return doc;

data/src/cxx_supportlib/LoggingKit/Context.h

@@ -70,16 +70,7 @@ public:
 	typedef LoggingKit::ConfigChangeRequest ConfigChangeRequest;
 
 private:
-	Schema schema;
-	mutable boost::mutex syncher;
-	ConfigKit::Store config;
-	boost::atomic<ConfigRealization *> configRlz;
-
-	mutable boost::mutex gcSyncher;
-	oxt::thread *gcThread;
-	boost::condition_variable gcShuttingDownCond, gcHasShutDownCond;
-	std::queue< pair<ConfigRealization *, MonotonicTimeUsec> > oldConfigs;
-	bool shuttingDown;
+	friend struct ConfigRealization;
 
 	struct TimestampedLog {
 		// time at which time the log entered the core, which is unfortunately somewhat
@@ -97,8 +88,22 @@ private:
 		SimpleLogMap watchFileLog; // a separate log buffer per (watched file name)
 	};
 	typedef StringKeyTable<AppGroupLog> LogStore;
+
+	Schema schema;
+	mutable boost::mutex syncher;
+	ConfigKit::Store config;
+	boost::atomic<ConfigRealization *> configRlz;
 	LogStore logStore;
 
+	mutable boost::mutex gcSyncher;
+	boost::condition_variable gcSyncherCond;
+	oxt::thread *gcThread;
+	std::queue< pair<ConfigRealization *, MonotonicTimeUsec> > oldConfigRlzs;
+	bool gcShuttingDown;
+
+	void freeOldConfigRlzLater(ConfigRealization *oldConfigRlz, MonotonicTimeUsec monotonicNow);
+	void gcThreadMain();
+
 public:
 	Context(const Json::Value &initialConfig = Json::Value(),
 		const ConfigKit::Translator &translator = ConfigKit::DummyTranslator());
@@ -124,22 +129,12 @@ public:
 	const ConfigRealization *getConfigRealization() const {
 		return configRlz.load(boost::memory_order_acquire);
 	}
-
-	void pushOldConfigAndCreateGcThread(ConfigRealization *oldConfigRlz, MonotonicTimeUsec monotonicNow);
-	void gcThreadMain();
-
-private:
-	pair<ConfigRealization*,MonotonicTimeUsec> peekOldConfig();
-	void popOldConfig(ConfigRealization *oldConfig);
-	bool oldConfigsExist();
-	void createGcThread();
-	void killGcThread();
-	void gcLockless(bool wait, boost::unique_lock<boost::mutex> &lock);
 };
 
 
 void initialize(const Json::Value &initialConfig = Json::Value(),
 	const ConfigKit::Translator &translator = ConfigKit::DummyTranslator());
+void shutdown();
 
 
 } // namespace LoggingKit

data/src/cxx_supportlib/LoggingKit/Forward.h

@@ -73,8 +73,6 @@ enum TargetType {
 
 extern Context *context;
 
-void shutdown();
-
 const char *_strdupFastStringStream(const FastStringStream<> &stream);
 bool _passesLogLevel(const Context *context, Level level, const ConfigRealization **outputConfigRlz);
 bool _shouldLogFileDescriptors(const Context *context, const ConfigRealization **outputConfigRlz);

data/src/cxx_supportlib/LoggingKit/Implementation.cpp

@@ -527,29 +527,31 @@ normalizeConfig(const Json::Value &effectiveValues) {
 Context::Context(const Json::Value &initialConfig,
 	const ConfigKit::Translator &translator)
 	: config(schema, initialConfig, translator),
-	  gcThread(NULL),
-	  shuttingDown(false)
+	  gcShuttingDown(false)
 {
 	configRlz.store(new ConfigRealization(config));
 	configRlz.load()->apply(config, NULL);
 	configRlz.load()->finalize();
+	gcThread = new oxt::thread(boost::bind(&Context::gcThreadMain, this),
+		"LoggingKit config garbage collector thread",
+		128 * 1024);
 }
 
 Context::~Context() {
-	boost::unique_lock<boost::mutex> l(gcSyncher);
-
-	// If a gc thread exists, tell it to shut down and
-	// wait until it has done so.
-	shuttingDown = true;
-	gcShuttingDownCond.notify_one();
-	while (gcThread != NULL) {
-		gcHasShutDownCond.wait(l);
+	{
+		boost::unique_lock<boost::mutex> l(gcSyncher);
+		gcShuttingDown = true;
+		gcSyncherCond.notify_one();
 	}
+	gcThread->join();
 
-	killGcThread();
-	gcLockless(false, l);
-
+	delete gcThread;
 	delete configRlz.load();
+
+	while (!oldConfigRlzs.empty()) {
+		delete oldConfigRlzs.front().first;
+		oldConfigRlzs.pop();
+	}
 }
 
 ConfigKit::Store
@@ -596,33 +598,8 @@ Context::inspectConfig() const {
 	return config.inspect();
 }
 
-pair<ConfigRealization*,MonotonicTimeUsec>
-Context::peekOldConfig() {
-	return oldConfigs.front();
-}
-
-void
-Context::popOldConfig(ConfigRealization *oldConfig) {
-	delete oldConfig;
-	oldConfigs.pop();
-}
-
-void
-Context::createGcThread() {
-	if (gcThread == NULL) {
-		try {
-			gcThread = new oxt::thread(boost::bind(&Context::gcThreadMain, this),
-				"LoggingKit config garbage collector thread",
-				128 * 1024);
-		} catch (const std::exception &e) {
-			P_ERROR("Error spawning background thread to garbage collect"
-				" old LoggingKit configuration: " << e.what());
-		}
-	}
-}
-
 void
-Context::pushOldConfigAndCreateGcThread(ConfigRealization *oldConfigRlz, MonotonicTimeUsec monotonicNow) {
+Context::freeOldConfigRlzLater(ConfigRealization *oldConfigRlz, MonotonicTimeUsec monotonicNow) {
 	// Garbage collect old config realization in 5 minutes.
 	// There is no way to cheaply find out whether oldConfigRlz
 	// is still being used (we don't want to resort to more atomic
@@ -630,47 +607,34 @@ Context::pushOldConfigAndCreateGcThread(ConfigRealization *oldConfigRlz, Monoton
 	// waiting 5 minutes should be good enough.
 	MonotonicTimeUsec gcTime = monotonicNow + 5llu * 60llu * 1000000llu;
 	boost::unique_lock<boost::mutex> l(gcSyncher);
-	oldConfigs.push(make_pair(oldConfigRlz, gcTime));
-	createGcThread();
-}
-
-bool
-Context::oldConfigsExist() {
-	return !oldConfigs.empty();
+	oldConfigRlzs.push(make_pair(oldConfigRlz, gcTime));
+	gcSyncherCond.notify_one();
 }
 
 void
 Context::gcThreadMain() {
 	boost::unique_lock<boost::mutex> l(gcSyncher);
-	gcLockless(true, l);
-}
-
-void
-Context::gcLockless(bool wait, boost::unique_lock<boost::mutex> &lock) {
-	while (!shuttingDown && oldConfigsExist()) {
-		pair<ConfigRealization *, MonotonicTimeUsec> p = peekOldConfig();
-		for (MonotonicTimeUsec now = SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_1SEC>();
-			 !shuttingDown && wait && now < p.second;
-			 now = SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_1SEC>())
-		{
-			// Wait until it's time to GC this config object,
-			// or until the destructor tells us that we're shutting down.
-			gcShuttingDownCond.timed_wait(lock, boost::posix_time::microseconds(p.second - now));
+	while (true) {
+		while (oldConfigRlzs.empty() && !gcShuttingDown) {
+			gcSyncherCond.wait(l);
 		}
-		if (!shuttingDown) {
-			popOldConfig(p.first);
+		if (gcShuttingDown) {
+			break;
 		}
-	}
-	killGcThread();
-}
 
-void
-Context::killGcThread() {
-	if (gcThread != NULL) {
-		delete gcThread;
-		gcThread = NULL;
+		pair<ConfigRealization *, MonotonicTimeUsec> p = oldConfigRlzs.front();
+		MonotonicTimeUsec now = SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_1SEC>();
+		// Wait until it's time to GC this config object,
+		// or until the destructor tells us that we're shutting down.
+		while (!gcShuttingDown && now < p.second) {
+			gcSyncherCond.timed_wait(l, boost::posix_time::microseconds(p.second - now));
+			now = SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_1SEC>();
+		}
+		if (!gcShuttingDown) {
+			delete p.first;
+			oldConfigRlzs.pop();
+		}
 	}
-	gcHasShutDownCond.notify_one();
 }
 
 Json::Value
@@ -916,7 +880,7 @@ ConfigRealization::apply(const ConfigKit::Store &config, ConfigRealization *oldC
 
 	if (oldConfigRlz != NULL) {
 		MonotonicTimeUsec monotonicNow = SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_1SEC>();
-		context->pushOldConfigAndCreateGcThread(oldConfigRlz, monotonicNow);
+		context->freeOldConfigRlzLater(oldConfigRlz, monotonicNow);
 	}
 }
 

data/src/cxx_supportlib/MemoryKit/mbuf.cpp

@@ -16,6 +16,7 @@
  * limitations under the License.
  */
 
+#include <cassert>
 #include <cstdlib>
 #include <cstring>
 #include <oxt/macros.hpp>
@@ -110,7 +111,9 @@ _mbuf_block_init(struct mbuf_pool *pool, char *buf, size_t block_offset)
 	 *                                    \
 	 *                                    block
 	 */
-	mbuf_block = (struct mbuf_block *)(buf + block_offset);
+	uintptr_t ptr = reinterpret_cast<uintptr_t>(buf + block_offset);
+	assert(ptr % alignof(struct mbuf_block) == 0);
+	mbuf_block = reinterpret_cast<struct mbuf_block*>(ptr);
 	mbuf_block->magic = MBUF_BLOCK_MAGIC;
 	mbuf_block->pool  = pool;
 	mbuf_block->offset = 0;
@@ -138,7 +141,7 @@ _mbuf_block_get(struct mbuf_pool *pool)
 		return mbuf_block;
 	}
 
-	buf = (char *) malloc(pool->mbuf_block_chunk_size);
+	buf = (char *) aligned_alloc(alignof(struct mbuf_block), pool->mbuf_block_chunk_size);
 	if (OXT_UNLIKELY(buf == NULL)) {
 		return NULL;
 	}
@@ -180,7 +183,10 @@ mbuf_block_new_standalone(struct mbuf_pool *pool, size_t size)
 	char *buf;
 
 	block_offset = std::max<size_t>(size, mbuf_pool_data_size(pool));
-	buf = (char *) malloc(MBUF_BLOCK_HSIZE + block_offset);
+	if (OXT_UNLIKELY(block_offset % alignof(struct mbuf_block) != 0)) {
+		return NULL;
+	}
+	buf = (char *) aligned_alloc(alignof(struct mbuf_block), MBUF_BLOCK_HSIZE + block_offset);
 	if (OXT_UNLIKELY(buf == NULL)) {
 		return NULL;
 	}
@@ -279,7 +285,9 @@ mbuf_pool_init(struct mbuf_pool *pool)
 		TAILQ_INIT(&pool->active_mbuf_blockq);
 	#endif
 
-	pool->mbuf_block_offset = pool->mbuf_block_chunk_size - MBUF_BLOCK_HSIZE;
+	size_t block_offset = pool->mbuf_block_chunk_size - MBUF_BLOCK_HSIZE;
+	assert((block_offset % alignof(struct mbuf_block)) == 0);
+	pool->mbuf_block_offset = block_offset;
 }
 
 void

data/src/cxx_supportlib/MemoryKit/mbuf.h

@@ -108,7 +108,6 @@ struct mbuf_pool {
 #define MBUF_BLOCK_MAGIC      0xdeadbeef
 #define MBUF_BLOCK_MIN_SIZE   512
 #define MBUF_BLOCK_MAX_SIZE   16777216
-#define MBUF_BLOCK_SIZE       16384
 #define MBUF_BLOCK_HSIZE      sizeof(struct mbuf_block)
 
 #define MBUF_BLOCK_EMPTY(mbuf_block) ((mbuf_block)->pos  == (mbuf_block)->last)
@@ -120,6 +119,7 @@ size_t mbuf_pool_data_size(struct mbuf_pool *pool);
 unsigned int mbuf_pool_compact(struct mbuf_pool *pool);
 
 struct mbuf_block *mbuf_block_get(struct mbuf_pool *pool);
+struct mbuf_block *mbuf_block_new_standalone(struct mbuf_pool *pool, size_t size);
 void mbuf_block_put(struct mbuf_block *mbuf_block);
 
 void mbuf_block_ref(struct mbuf_block *mbuf_block);

data/src/cxx_supportlib/ProcessManagement/Utils.cpp

@@ -52,7 +52,7 @@
 #include <ProcessManagement/Utils.h>
 #include <Utils/AsyncSignalSafeUtils.h>
 
-#if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__sun)
+#if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__sun) || defined(__FreeBSD__)
 	// Introduced in Solaris 9. Let's hope nobody actually uses
 	// a version that doesn't support this.
 	#define HAS_CLOSEFROM

data/src/cxx_supportlib/ResourceLocator.h

@@ -175,7 +175,7 @@ public:
 		bool found;
 		try {
 			found = fileExists(path);
-		} catch (const SystemException &e) {
+		} catch (const SystemException&) {
 			found = false;
 		}
 		if (found) {