passenger 4.0.60 → 5.0.0.beta1

data/ext/common/ApplicationPool2/Implementation.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-2015 Phusion
+ *  Copyright (c) 2011-2014 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -152,7 +152,7 @@ void processAndLogNewSpawnException(SpawnException &e, const Options &options,
 {
 	TRACE_POINT();
 	UnionStation::TransactionPtr transaction;
-	ErrorRenderer renderer(config->resourceLocator);
+	ErrorRenderer renderer(*config->resourceLocator);
 	string appMessage = e.getErrorPage();
 	string errorId;
 	char filename[PATH_MAX];
@@ -184,6 +184,7 @@ void processAndLogNewSpawnException(SpawnException &e, const Options &options,
 
 	try {
 		int fd = -1;
+		FdGuard guard(fd, true);
 		string errorPage;
 
 		UPDATE_TRACE_POINT();
@@ -198,7 +199,6 @@ void processAndLogNewSpawnException(SpawnException &e, const Options &options,
 				getSystemTempDir());
 			fd = mkstemp(filename);
 		#endif
-		FdGuard guard(fd, true);
 		if (fd == -1) {
 			int e = errno;
 			throw SystemException("Cannot generate a temporary filename",
@@ -301,28 +301,48 @@ void processAndLogNewSpawnException(SpawnException &e, const Options &options,
 	}
 }
 
+void
+recreateString(psg_pool_t *pool, StaticString &str) {
+	str = psg_pstrdup(pool, str);
+}
+
 
 const SuperGroupPtr
 Pool::getSuperGroup(const char *name) {
-	return superGroups.get(name);
+	SuperGroupPtr *superGroup;
+	if (superGroups.lookup(name, &superGroup)) {
+		return *superGroup;
+	} else {
+		return SuperGroupPtr();
+	}
 }
 
 
 boost::mutex &
-SuperGroup::getPoolSyncher(const PoolPtr &pool) {
+SuperGroup::getPoolSyncher(Pool *pool) {
 	return pool->syncher;
 }
 
 void
-SuperGroup::runAllActions(const vector<Callback> &actions) {
+SuperGroup::runAllActions(const boost::container::vector<Callback> &actions) {
 	Pool::runAllActions(actions);
 }
 
+const PoolPtr
+SuperGroup::getPoolPtr() {
+	return getPool()->shared_from_this();
+}
+
 string
 SuperGroup::generateSecret() const {
 	return getPool()->getRandomGenerator()->generateAsciiString(43);
 }
 
+bool
+SuperGroup::selfCheckingEnabled() const {
+	return getPool()->selfchecking;
+}
+
 void
 SuperGroup::runInitializationHooks() const {
 	getPool()->runHookScripts("after_initialize_supergroup",
@@ -353,7 +373,7 @@ SuperGroup::realDoInitialize(const Options &options, unsigned int generation) {
 	vector<ComponentInfo>::const_iterator it;
 	ExceptionPtr exception;
 
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 
 	P_TRACE(2, "Initializing SuperGroup " << inspect() << " in the background...");
 	try {
@@ -374,7 +394,7 @@ SuperGroup::realDoInitialize(const Options &options, unsigned int generation) {
 	}
 
 	Pool::DebugSupportPtr debug = pool->debugSupport;
-	vector<Callback> actions;
+	boost::container::vector<Callback> actions;
 	{
 		if (debug != NULL && debug->superGroup) {
 			debug->debugger->send("About to finish SuperGroup initialization");
@@ -402,15 +422,16 @@ SuperGroup::realDoInitialize(const Options &options, unsigned int generation) {
 			actions.reserve(getWaitlist.size());
 			while (!getWaitlist.empty()) {
 				const GetWaiter &waiter = getWaitlist.front();
-				actions.push_back(boost::bind(waiter.callback,
-					SessionPtr(), exception));
+				actions.push_back(boost::bind(GetCallback::call,
+					waiter.callback, SessionPtr(), exception));
 				getWaitlist.pop_front();
 			}
 		} else {
 			for (it = componentInfos.begin(); it != componentInfos.end(); it++) {
 				const ComponentInfo &info = *it;
-				GroupPtr group = boost::make_shared<Group>(shared_from_this(),
+				GroupPtr group = boost::make_shared<Group>(this,
 					options, info);
+				group->initialize();
 				groups.push_back(group);
 				if (info.isDefault) {
 					defaultGroup = group.get();
@@ -437,7 +458,7 @@ SuperGroup::realDoRestart(const Options &options, unsigned int generation) {
 	vector<ComponentInfo> componentInfos = loadComponentInfos(options);
 	vector<ComponentInfo>::const_iterator it;
 
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 	Pool::DebugSupportPtr debug = pool->debugSupport;
 	if (debug != NULL && debug->superGroup) {
 		debug->debugger->send("About to finish SuperGroup restart");
@@ -452,11 +473,11 @@ SuperGroup::realDoRestart(const Options &options, unsigned int generation) {
 	assert(state == RESTARTING);
 	verifyInvariants();
 
-	vector<GroupPtr> allGroups;
-	vector<GroupPtr> updatedGroups;
-	vector<GroupPtr> newGroups;
-	vector<GroupPtr>::const_iterator g_it;
-	vector<Callback> actions;
+	SuperGroup::GroupList allGroups;
+	SuperGroup::GroupList updatedGroups;
+	SuperGroup::GroupList newGroups;
+	SuperGroup::GroupList::const_iterator g_it;
+	boost::container::vector<Callback> actions;
 	this->options = options;
 
 	// Update the component information for existing groups.
@@ -474,8 +495,9 @@ SuperGroup::realDoRestart(const Options &options, unsigned int generation) {
 		} else {
 			// This is not an existing group but a new one,
 			// so create it.
-			group = boost::make_shared<Group>(shared_from_this(),
+			group = boost::make_shared<Group>(this,
 				options, info);
+			group->initialize();
 			newGroups.push_back(group);
 		}
 		// allGroups must be in the same order as componentInfos.
@@ -504,23 +526,26 @@ SuperGroup::realDoRestart(const Options &options, unsigned int generation) {
 }
 
 
-Group::Group(const SuperGroupPtr &_superGroup, const Options &_options, const ComponentInfo &info)
+Group::Group(SuperGroup *_superGroup, const Options &options, const ComponentInfo &info)
 	: superGroup(_superGroup),
 	  name(_superGroup->name + "#" + info.name),
-	  secret(generateSecret(_superGroup)),
 	  uuid(generateUuid(_superGroup)),
 	  componentInfo(info)
 {
-	resetOptions(_options);
+	generateSecret(_superGroup, secret);
 	enabledCount   = 0;
 	disablingCount = 0;
 	disabledCount  = 0;
+	nEnabledProcessesTotallyBusy = 0;
 	spawner        = getPool()->spawnerFactory->create(options);
 	restartsInitiated = 0;
 	processesBeingSpawned = 0;
 	m_spawning     = false;
 	m_restarting   = false;
-	lifeStatus     = ALIVE;
+	lifeStatus.store(ALIVE, boost::memory_order_relaxed);
+	lastRestartFileMtime = 0;
+	lastRestartFileCheckTime = 0;
+	alwaysRestartFileExists = false;
 	if (options.restartDir.empty()) {
 		restartFile = options.appRoot + "/tmp/restart.txt";
 		alwaysRestartFile = options.appRoot + "/tmp/always_restart.txt";
@@ -531,6 +556,7 @@ Group::Group(const SuperGroupPtr &_superGroup, const Options &_options, const Co
 		restartFile = options.appRoot + "/" + options.restartDir + "/restart.txt";
 		alwaysRestartFile = options.appRoot + "/" + options.restartDir + "/always_restart.txt";
 	}
+	resetOptions(options);
 
 	detachedProcessesCheckerActive = false;
 }
@@ -542,20 +568,46 @@ Group::~Group() {
 	}
 	assert(lifeStatus == SHUT_DOWN);
 	assert(!detachedProcessesCheckerActive);
+	assert(getWaitlist.empty());
+}
+
+void
+Group::initialize() {
+	nullProcess = boost::make_shared<Process>(
+		0, StaticString(),
+		FileDescriptor(), FileDescriptor(),
+		SocketList(), 0, 0);
+	nullProcess->dummy = true;
+	nullProcess->requiresShutdown = false;
+	nullProcess->setGroup(this);
 }
 
-PoolPtr
+OXT_FORCE_INLINE Pool *
 Group::getPool() const {
 	return getSuperGroup()->getPool();
 }
 
 void
-Group::onSessionInitiateFailure(const ProcessPtr &process, Session *session) {
-	vector<Callback> actions;
+Group::_onSessionInitiateFailure(Session *session) {
+	Process *process = session->getProcess();
+	assert(process != NULL);
+	process->getGroup()->onSessionInitiateFailure(process, session);
+}
+
+void
+Group::_onSessionClose(Session *session) {
+	Process *process = session->getProcess();
+	assert(process != NULL);
+	process->getGroup()->onSessionClose(process, session);
+}
+
+OXT_FORCE_INLINE void
+Group::onSessionInitiateFailure(Process *process, Session *session) {
+	boost::container::vector<Callback> actions;
 
 	TRACE_POINT();
 	// Standard resource management boilerplate stuff...
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 	boost::unique_lock<boost::mutex> lock(pool->syncher);
 	assert(process->isAlive());
 	assert(isAlive() || getLifeStatus() == SHUTTING_DOWN);
@@ -563,7 +615,7 @@ Group::onSessionInitiateFailure(const ProcessPtr &process, Session *session) {
 	UPDATE_TRACE_POINT();
 	P_DEBUG("Could not initiate a session with process " <<
 		process->inspect() << ", detaching from pool if possible");
-	if (!pool->detachProcessUnlocked(process, actions)) {
+	if (!pool->detachProcessUnlocked(process->shared_from_this(), actions)) {
 		P_DEBUG("Process was already detached");
 	}
 	pool->fullVerifyInvariants();
@@ -571,11 +623,11 @@ Group::onSessionInitiateFailure(const ProcessPtr &process, Session *session) {
 	runAllActions(actions);
 }
 
-void
-Group::onSessionClose(const ProcessPtr &process, Session *session) {
+OXT_FORCE_INLINE void
+Group::onSessionClose(Process *process, Session *session) {
 	TRACE_POINT();
 	// Standard resource management boilerplate stuff...
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 	boost::unique_lock<boost::mutex> lock(pool->syncher);
 	assert(process->isAlive());
 	assert(isAlive() || getLifeStatus() == SHUTTING_DOWN);
@@ -585,13 +637,18 @@ Group::onSessionClose(const ProcessPtr &process, Session *session) {
 	UPDATE_TRACE_POINT();
 
 	/* Update statistics. */
+	bool wasTotallyBusy = process->isTotallyBusy();
 	process->sessionClosed(session);
 	assert(process->getLifeStatus() == Process::ALIVE);
 	assert(process->enabled == Process::ENABLED
 		|| process->enabled == Process::DISABLING
 		|| process->enabled == Process::DETACHED);
 	if (process->enabled == Process::ENABLED) {
-		pqueue.decrease(process->pqHandle, process->busyness());
+		enabledProcessBusynessLevels[process->index] = process->busyness();
+		if (wasTotallyBusy) {
+			assert(nEnabledProcessesTotallyBusy >= 1);
+			nEnabledProcessesTotallyBusy--;
+		}
 	}
 
 	/* This group now has a process that's guaranteed to be not
@@ -622,7 +679,7 @@ Group::onSessionClose(const ProcessPtr &process, Session *session) {
 
 	if (shouldDetach || shouldDisable) {
 		UPDATE_TRACE_POINT();
-		vector<Callback> actions;
+		boost::container::vector<Callback> actions;
 
 		if (shouldDetach) {
 			if (detachingBecauseCapacityNeeded) {
@@ -642,11 +699,12 @@ Group::onSessionClose(const ProcessPtr &process, Session *session) {
 					" has reached its maximum number of requests (" <<
 					options.maxRequests << "); detaching it");
 			}
-			pool->detachProcessUnlocked(process, actions);
+			pool->detachProcessUnlocked(process->shared_from_this(), actions);
 		} else {
-			removeProcessFromList(process, disablingProcesses);
-			addProcessToList(process, disabledProcesses);
-			removeFromDisableWaitlist(process, DR_SUCCESS, actions);
+			ProcessPtr processPtr = process->shared_from_this();
+			removeProcessFromList(processPtr, disablingProcesses);
+			addProcessToList(processPtr, disabledProcesses);
+			removeFromDisableWaitlist(processPtr, DR_SUCCESS, actions);
 			maybeInitiateOobw(process);
 		}
 
@@ -674,7 +732,7 @@ Group::onSessionClose(const ProcessPtr &process, Session *session) {
 void
 Group::requestOOBW(const ProcessPtr &process) {
 	// Standard resource management boilerplate stuff...
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 	boost::unique_lock<boost::mutex> lock(pool->syncher);
 	if (isAlive() && process->isAlive() && process->oobwStatus == Process::OOBW_NOT_ACTIVE) {
 		process->oobwStatus = Process::OOBW_REQUESTED;
@@ -698,7 +756,7 @@ Group::oobwAllowed() const {
 }
 
 bool
-Group::shouldInitiateOobw(const ProcessPtr &process) const {
+Group::shouldInitiateOobw(Process *process) const {
 	return process->oobwStatus == Process::OOBW_REQUESTED
 		&& process->enabled != Process::DETACHED
 		&& process->isAlive()
@@ -706,9 +764,11 @@ Group::shouldInitiateOobw(const ProcessPtr &process) const {
 }
 
 void
-Group::maybeInitiateOobw(const ProcessPtr &process) {
+Group::maybeInitiateOobw(Process *process) {
 	if (shouldInitiateOobw(process)) {
-		initiateOobw(process);
+		// We keep an extra reference to prevent premature destruction.
+		ProcessPtr p = process->shared_from_this();
+		initiateOobw(p);
 	}
 }
 
@@ -718,7 +778,7 @@ Group::lockAndMaybeInitiateOobw(const ProcessPtr &process, DisableResult result,
 	TRACE_POINT();
 
 	// Standard resource management boilerplate stuff...
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 	boost::unique_lock<boost::mutex> lock(pool->syncher);
 	if (OXT_UNLIKELY(!process->isAlive() || !isAlive())) {
 		return;
@@ -731,7 +791,7 @@ Group::lockAndMaybeInitiateOobw(const ProcessPtr &process, DisableResult result,
 			P_DEBUG("Process " << process->inspect() << " disabled; proceeding " <<
 				"with out-of-band work");
 			process->oobwStatus = Process::OOBW_REQUESTED;
-			if (shouldInitiateOobw(process)) {
+			if (shouldInitiateOobw(process.get())) {
 				initiateOobw(process);
 			} else {
 				// We do not re-enable the process because it's likely that the
@@ -807,7 +867,7 @@ Group::spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process) {
 
 	Socket *socket;
 	Connection connection;
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 	Pool::DebugSupportPtr debug = pool->debugSupport;
 
 	UPDATE_TRACE_POINT();
@@ -840,8 +900,7 @@ Group::spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process) {
 
 		assert(process->oobwStatus == Process::OOBW_IN_PROGRESS);
 		assert(process->sessions == 0);
-		socket = process->sessionSockets.top();
-		assert(socket != NULL);
+		socket = process->findSessionSocketWithLowestBusyness();
 	}
 
 	UPDATE_TRACE_POINT();
@@ -863,11 +922,12 @@ Group::spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process) {
 		SmallVector<StaticString, 10> data;
 
 		data.push_back(StaticString(sizeField, sizeof(boost::uint32_t)));
-		data.push_back(makeStaticStringWithNull("REQUEST_METHOD"));
-		data.push_back(makeStaticStringWithNull("OOBW"));
+		data.push_back(P_STATIC_STRING_WITH_NULL("REQUEST_METHOD"));
+		data.push_back(P_STATIC_STRING_WITH_NULL("OOBW"));
 
-		data.push_back(makeStaticStringWithNull("PASSENGER_CONNECT_PASSWORD"));
-		data.push_back(makeStaticStringWithNull(process->connectPassword));
+		data.push_back(P_STATIC_STRING_WITH_NULL("PASSENGER_CONNECT_PASSWORD"));
+		data.push_back(StaticString(secret, SECRET_SIZE));
+		data.push_back(StaticString("", 1));
 
 		boost::uint32_t dataSize = 0;
 		for (unsigned int i = 1; i < data.size(); i++) {
@@ -887,10 +947,10 @@ Group::spawnThreadOOBWRequest(GroupPtr self, ProcessPtr process) {
 	}
 
 	UPDATE_TRACE_POINT();
-	vector<Callback> actions;
+	boost::container::vector<Callback> actions;
 	{
 		// Standard resource management boilerplate stuff...
-		PoolPtr pool = getPool();
+		Pool *pool = getPool();
 		boost::unique_lock<boost::mutex> lock(pool->syncher);
 		if (OXT_UNLIKELY(!process->isAlive() || !isAlive())) {
 			return;
@@ -922,7 +982,7 @@ Group::initiateNextOobwRequest() {
 	ProcessList::const_iterator it, end = enabledProcesses.end();
 	for (it = enabledProcesses.begin(); it != end; it++) {
 		const ProcessPtr &process = *it;
-		if (shouldInitiateOobw(process)) {
+		if (shouldInitiateOobw(process.get())) {
 			// We keep an extra reference to processes to prevent premature destruction.
 			ProcessPtr p = process;
 			initiateOobw(p);
@@ -943,7 +1003,7 @@ Group::spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options, un
 	this_thread::disable_interruption di;
 	this_thread::disable_syscall_interruption dsi;
 
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 	Pool::DebugSupportPtr debug = pool->debugSupport;
 
 	bool done = false;
@@ -971,6 +1031,7 @@ Group::spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options, un
 			shouldFail = message->name == "Fail spawn loop iteration " + iteration;
 		}
 
+		SpawnObject spawnObject;
 		ProcessPtr process;
 		ExceptionPtr exception;
 		try {
@@ -982,8 +1043,9 @@ Group::spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options, un
 				processAndLogNewSpawnException(e, options, pool->getSpawnerConfig());
 				throw e;
 			} else {
-				process = spawner->spawn(options);
-				process->setGroup(shared_from_this());
+				spawnObject = spawner->spawn(options);
+				process = spawnObject.process;
+				process->setGroup(this);
 			}
 		} catch (const thread_interrupted &) {
 			break;
@@ -1031,9 +1093,9 @@ Group::spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options, un
 		assert(processesBeingSpawned == 0);
 
 		UPDATE_TRACE_POINT();
-		vector<Callback> actions;
+		boost::container::vector<Callback> actions;
 		if (process != NULL) {
-			AttachResult result = attach(process, actions);
+			AttachResult result = attach(spawnObject, actions);
 			if (result == AR_OK) {
 				guard.clear();
 				if (getWaitlist.empty()) {
@@ -1064,7 +1126,7 @@ Group::spawnThreadRealMain(const SpawnerPtr &spawner, const Options &options, un
 		done = done
 			|| (processLowerLimitsSatisfied() && getWaitlist.empty())
 			|| processUpperLimitsReached()
-			|| pool->atFullCapacity(false);
+			|| pool->atFullCapacityUnlocked();
 		m_spawning = !done;
 		if (done) {
 			P_DEBUG("Spawn loop done");
@@ -1103,7 +1165,7 @@ Group::shouldSpawnForGetAction() const {
 
 void
 Group::restart(const Options &options, RestartMethod method) {
-	vector<Callback> actions;
+	boost::container::vector<Callback> actions;
 
 	assert(isAlive());
 	P_DEBUG("Restarting group " << name);
@@ -1119,7 +1181,6 @@ Group::restart(const Options &options, RestartMethod method) {
 	detachAll(actions);
 	getPool()->interruptableThreads.create_thread(
 		boost::bind(&Group::finalizeRestart, this, shared_from_this(),
-			this->options.copyAndPersist().clearPerRequestFields(),
 			options.copyAndPersist().clearPerRequestFields(),
 			method, getPool()->spawnerFactory, restartsInitiated, actions),
 		"Group restarter: " + name,
@@ -1129,12 +1190,9 @@ Group::restart(const Options &options, RestartMethod method) {
 
 // The 'self' parameter is for keeping the current Group object alive while this thread is running.
 void
-Group::finalizeRestart(GroupPtr self,
-	Options oldOptions,
-	Options newOptions, RestartMethod method,
-	SpawnerFactoryPtr spawnerFactory,
-	unsigned int restartsInitiated,
-	vector<Callback> postLockActions)
+Group::finalizeRestart(GroupPtr self, Options options, RestartMethod method,
+	SpawnerFactoryPtr spawnerFactory, unsigned int restartsInitiated,
+	boost::container::vector<Callback> postLockActions)
 {
 	TRACE_POINT();
 
@@ -1145,13 +1203,11 @@ Group::finalizeRestart(GroupPtr self,
 	this_thread::disable_syscall_interruption dsi;
 
 	// Create a new spawner.
-	Options spawnerOptions = oldOptions;
-	resetOptions(newOptions, &spawnerOptions);
-	SpawnerPtr newSpawner = spawnerFactory->create(spawnerOptions);
+	SpawnerPtr newSpawner = spawnerFactory->create(options);
 	SpawnerPtr oldSpawner;
 
 	UPDATE_TRACE_POINT();
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 
 	Pool::DebugSupportPtr debug = pool->debugSupport;
 	if (debug != NULL && debug->restarting) {
@@ -1183,7 +1239,7 @@ Group::finalizeRestart(GroupPtr self,
 	UPDATE_TRACE_POINT();
 
 	// Atomically swap the new spawner with the old one.
-	resetOptions(newOptions);
+	resetOptions(options);
 	oldSpawner = spawner;
 	spawner    = newSpawner;
 
@@ -1234,7 +1290,7 @@ Group::startCheckingDetachedProcesses(bool immediately) {
 void
 Group::detachedProcessesCheckerMain(GroupPtr self) {
 	TRACE_POINT();
-	PoolPtr pool = getPool();
+	Pool *pool = getPool();
 
 	Pool::DebugSupportPtr debug = pool->debugSupport;
 	if (debug != NULL && debug->detachedProcessesChecker) {
@@ -1257,9 +1313,10 @@ Group::detachedProcessesCheckerMain(GroupPtr self) {
 		if (!detachedProcesses.empty()) {
 			P_TRACE(2, "Checking whether any of the " << detachedProcesses.size() <<
 				" detached processes have exited...");
-			ProcessList::iterator it = detachedProcesses.begin();
-			ProcessList::iterator end = detachedProcesses.end();
-			while (it != end) {
+			ProcessList::iterator it, end = detachedProcesses.end();
+			ProcessList processesToRemove;
+
+			for (it = detachedProcesses.begin(); it != end; it++) {
 				const ProcessPtr process = *it;
 				switch (process->getLifeStatus()) {
 				case Process::ALIVE:
@@ -1269,29 +1326,29 @@ Group::detachedProcessesCheckerMain(GroupPtr self) {
 						process->triggerShutdown();
 						assert(process->getLifeStatus() == Process::SHUTDOWN_TRIGGERED);
 					}
-					it++;
 					break;
 				case Process::SHUTDOWN_TRIGGERED:
 					if (process->canCleanup()) {
 						P_DEBUG("Detached process " << process->inspect() << " has shut down. Cleaning up associated resources.");
 						process->cleanup();
 						assert(process->getLifeStatus() == Process::DEAD);
-						it++;
-						removeProcessFromList(process, detachedProcesses);
+						processesToRemove.push_back(process);
 					} else if (process->shutdownTimeoutExpired()) {
 						P_WARN("Detached process " << process->inspect() <<
 							" didn't shut down within " PROCESS_SHUTDOWN_TIMEOUT_DISPLAY
 							". Forcefully killing it with SIGKILL.");
 						kill(process->pid, SIGKILL);
-						it++;
-					} else {
-						it++;
 					}
 					break;
 				default:
 					P_BUG("Unknown 'lifeStatus' state " << (int) process->getLifeStatus());
 				}
 			}
+
+			end = processesToRemove.end();
+			for (it = processesToRemove.begin(); it != end; it++) {
+				removeProcessFromList(*it, detachedProcesses);
+			}
 		}
 
 		UPDATE_TRACE_POINT();
@@ -1300,7 +1357,7 @@ Group::detachedProcessesCheckerMain(GroupPtr self) {
 			P_DEBUG("Stopping detached processes checker");
 			detachedProcessesCheckerActive = false;
 
-			vector<Callback> actions;
+			boost::container::vector<Callback> actions;
 			if (shutdownCanFinish()) {
 				UPDATE_TRACE_POINT();
 				finishShutdown(actions);
@@ -1326,6 +1383,11 @@ Group::detachedProcessesCheckerMain(GroupPtr self) {
 	}
 }
 
+bool
+Group::selfCheckingEnabled() const {
+	return getPool()->selfchecking;
+}
+
 void
 Group::wakeUpGarbageCollector() {
 	getPool()->garbageCollectionCond.notify_all();
@@ -1333,7 +1395,7 @@ Group::wakeUpGarbageCollector() {
 
 bool
 Group::poolAtFullCapacity() const {
-	return getPool()->atFullCapacity(false);
+	return getPool()->atFullCapacityUnlocked();
 }
 
 bool
@@ -1341,24 +1403,33 @@ Group::anotherGroupIsWaitingForCapacity() const {
 	return findOtherGroupWaitingForCapacity() != NULL;
 }
 
-boost::shared_ptr<Group>
+Group *
 Group::findOtherGroupWaitingForCapacity() const {
-	PoolPtr pool = getPool();
-	StringMap<SuperGroupPtr>::const_iterator sg_it, sg_end = pool->superGroups.end();
-	for (sg_it = pool->superGroups.begin(); sg_it != sg_end; sg_it++) {
-		pair<StaticString, SuperGroupPtr> p = *sg_it;
-		vector<GroupPtr>::const_iterator g_it, g_end = p.second->groups.end();
-		for (g_it = p.second->groups.begin(); g_it != g_end; g_it++) {
+	Pool *pool = getPool();
+	// TODO: this only works if SuperGroup can only have one Group.
+	// If we ever extend SuperGroup then this needs to be changed.
+	if (pool->superGroups.size() == 1) {
+		return NULL;
+	}
+
+	SuperGroupMap::ConstIterator sg_it(pool->superGroups);
+	while (*sg_it != NULL) {
+		const SuperGroupPtr &superGroup = sg_it.getValue();
+		SuperGroup::GroupList::const_iterator g_it, g_end = superGroup->groups.end();
+		for (g_it = superGroup->groups.begin(); g_it != g_end; g_it++) {
 			if (g_it->get() != this && (*g_it)->isWaitingForCapacity()) {
-				return *g_it;
+				return g_it->get();
 			}
 		}
+		sg_it.next();
 	}
-	return GroupPtr();
+	return NULL;
 }
 
 ProcessPtr
-Group::poolForceFreeCapacity(const Group *exclude, vector<Callback> &postLockActions) {
+Group::poolForceFreeCapacity(const Group *exclude,
+	boost::container::vector<Callback> &postLockActions)
+{
 	return getPool()->forceFreeCapacity(exclude, postLockActions);
 }
 
@@ -1374,9 +1445,23 @@ Group::testOverflowRequestQueue() const {
 	}
 }
 
+void
+Group::callAbortLongRunningConnectionsCallback(const ProcessPtr &process) {
+	Pool::AbortLongRunningConnectionsCallback callback =
+		getPool()->abortLongRunningConnectionsCallback;
+	if (callback != NULL) {
+		callback(process);
+	}
+}
+
+psg_pool_t *
+Group::getPallocPool() const {
+	return getPool()->palloc;
+}
+
 const ResourceLocator &
 Group::getResourceLocator() const {
-	return getPool()->getSpawnerConfig()->resourceLocator;
+	return *getPool()->getSpawnerConfig()->resourceLocator;
 }
 
 // 'process' is not a reference so that bind(runAttachHooks, ...) causes the shared
@@ -1399,49 +1484,58 @@ Group::setupAttachOrDetachHook(const ProcessPtr process, HookScriptOptions &opti
 	options.environment.push_back(make_pair("PASSENGER_APP_ROOT", this->options.appRoot));
 }
 
-string
-Group::generateSecret(const SuperGroupPtr &superGroup) {
-	return superGroup->getPool()->getRandomGenerator()->generateAsciiString(43);
+void
+Group::generateSecret(const SuperGroup *superGroup, char *secret) {
+	superGroup->getPool()->getRandomGenerator()->generateAsciiString(secret, SECRET_SIZE);
 }
 
 string
-Group::generateUuid(const SuperGroupPtr &superGroup) {
+Group::generateUuid(const SuperGroup *superGroup) {
 	return superGroup->getPool()->getRandomGenerator()->generateAsciiString(20);
 }
 
 
-PoolPtr
+Pool *
 Process::getPool() const {
 	assert(getLifeStatus() != DEAD);
 	return getGroup()->getPool();
 }
 
-SuperGroupPtr
+SuperGroup *
 Process::getSuperGroup() const {
 	assert(getLifeStatus() != DEAD);
 	return getGroup()->getSuperGroup();
 }
 
-void
-Process::sendAbortLongRunningConnectionsMessage(const string &address) {
-	boost::function<void ()> func = boost::bind(
-		realSendAbortLongRunningConnectionsMessage, address);
-	return getPool()->nonInterruptableThreads.create_thread(
-		boost::bind(runAndPrintExceptions, func, false),
-		"Sending detached message to process " + toString(pid),
-		256 * 1024);
+StaticString
+Process::getGroupSecret() const {
+	return StaticString(getGroup()->secret, Group::SECRET_SIZE);
 }
 
-void
-Process::realSendAbortLongRunningConnectionsMessage(string address) {
-	TRACE_POINT();
-	FileDescriptor fd(connectToServer(address));
-	unsigned long long timeout = 3000000;
-	vector<string> args;
+SessionPtr
+Process::createSessionObject(Socket *socket) {
+	Pool *pool = NULL;
+	Group *group = getGroup();
+	if (group != NULL) {
+		// Backpointers are normally never NULL, but they can be
+		// NULL in unit tests
+		SuperGroup *superGroup = group->getSuperGroup();
+		if (superGroup != NULL) {
+			pool = superGroup->getPool();
+		}
+	}
 
-	UPDATE_TRACE_POINT();
-	args.push_back("abort_long_running_connections");
-	writeArrayMessage(fd, args, &timeout);
+	Session *session;
+	if (OXT_LIKELY(pool != NULL)) {
+		{
+			LockGuard l(pool->sessionObjectPoolSyncher);
+			session = pool->sessionObjectPool.malloc();
+		}
+		session = new (session) Session(pool, this, socket);
+	} else {
+		session = new Session(NULL, this, socket);
+	}
+	return SessionPtr(session, false);
 }
 
 string
@@ -1449,7 +1543,7 @@ Process::inspect() const {
 	assert(getLifeStatus() != DEAD);
 	stringstream result;
 	result << "(pid=" << pid;
-	GroupPtr group = getGroup();
+	Group *group = getGroup();
 	if (group != NULL) {
 		// This Process hasn't been attached to a Group yet.
 		result << ", group=" << group->name;
@@ -1459,9 +1553,9 @@ Process::inspect() const {
 }
 
 
-const string &
-Session::getConnectPassword() const {
-	return getProcess()->connectPassword;
+StaticString
+Session::getGroupSecret() const {
+	return StaticString(getGroup()->secret, Group::SECRET_SIZE);
 }
 
 pid_t
@@ -1469,9 +1563,10 @@ Session::getPid() const {
 	return getProcess()->pid;
 }
 
-const string &
+StaticString
 Session::getGupid() const {
-	return getProcess()->gupid;
+	const Process *process = getProcess();
+	return StaticString(process->gupid, process->gupidSize);
 }
 
 unsigned int
@@ -1479,14 +1574,14 @@ Session::getStickySessionId() const {
 	return getProcess()->stickySessionId;
 }
 
-const GroupPtr
+Group *
 Session::getGroup() const {
 	return getProcess()->getGroup();
 }
 
 void
 Session::requestOOBW() {
-	ProcessPtr process = getProcess();
+	ProcessPtr process = getProcess()->shared_from_this();
 	assert(process->isAlive());
 	process->getGroup()->requestOOBW(process);
 }
@@ -1496,6 +1591,20 @@ Session::kill(int signo) {
 	return getProcess()->kill(signo);
 }
 
+void
+Session::destroySelf() const {
+	Pool *pool = this->pool;
+	// Backpointers are normally never NULL, but they can be
+	// NULL in unit tests
+	if (pool != NULL) {
+		this->~Session();
+		LockGuard l(pool->sessionObjectPoolSyncher);
+		pool->sessionObjectPool.free(const_cast<Session *>(this));
+	} else {
+		delete this;
+	}
+}
+
 
 PipeWatcher::DataCallback PipeWatcher::onData;