7d9829fbec
Previously the handling for the IO thread was split between BrowserProcessSubThread (a replication of the background thread infrastructure used by Chromium during the IPC import, which is only used for the IO thread in Gecko), and IOThreadChild (a wrapper around ChildThread, which was imported from Chromium's source). This meant that there was little code-sharing between the parent and child processes, and that the lifecycle of the IO thread was perhaps less clear. This refactors the code to centralize handling of these threads, and provide a basic common interface. At the moment, actually hooking up async IO listeners is still done using the Chromium interfaces. Differential Revision: https://phabricator.services.mozilla.com/D227739
141 lines
4.7 KiB
C++
141 lines
4.7 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/ipc/ProcessChild.h"
|
|
|
|
#include "Endpoint.h"
|
|
#include "nsDebug.h"
|
|
|
|
#ifdef XP_WIN
|
|
# include <stdlib.h> // for _exit()
|
|
# include <synchapi.h>
|
|
#else
|
|
# include <unistd.h> // for _exit()
|
|
# include <time.h>
|
|
# include "base/eintr_wrapper.h"
|
|
# include "prenv.h"
|
|
#endif
|
|
|
|
#include "nsAppRunner.h"
|
|
#include "mozilla/AppShutdown.h"
|
|
#include "mozilla/ipc/IOThread.h"
|
|
#include "mozilla/ipc/ProcessUtils.h"
|
|
#include "mozilla/GeckoArgs.h"
|
|
|
|
namespace mozilla {
|
|
namespace ipc {
|
|
|
|
ProcessChild* ProcessChild::gProcessChild;
|
|
StaticMutex ProcessChild::gIPCShutdownStateLock;
|
|
MOZ_CONSTINIT nsCString ProcessChild::gIPCShutdownStateAnnotation;
|
|
|
|
static Atomic<bool> sExpectingShutdown(false);
|
|
|
|
ProcessChild::ProcessChild(IPC::Channel::ChannelHandle aClientChannel,
|
|
ProcessId aParentPid, const nsID& aMessageChannelId)
|
|
: mUILoop(MessageLoop::current()),
|
|
mParentPid(aParentPid),
|
|
mMessageChannelId(aMessageChannelId),
|
|
mChildThread(
|
|
MakeUnique<IOThreadChild>(std::move(aClientChannel), aParentPid)) {
|
|
MOZ_ASSERT(mUILoop, "UILoop should be created by now");
|
|
MOZ_ASSERT(!gProcessChild, "should only be one ProcessChild");
|
|
CrashReporter::RegisterAnnotationNSCString(
|
|
CrashReporter::Annotation::IPCShutdownState,
|
|
&gIPCShutdownStateAnnotation);
|
|
gProcessChild = this;
|
|
}
|
|
|
|
/* static */
|
|
void ProcessChild::AddPlatformBuildID(geckoargs::ChildProcessArgs& aExtraArgs) {
|
|
nsCString parentBuildID(mozilla::PlatformBuildID());
|
|
geckoargs::sParentBuildID.Put(parentBuildID.get(), aExtraArgs);
|
|
}
|
|
|
|
/* static */
|
|
bool ProcessChild::InitPrefs(int aArgc, char* aArgv[]) {
|
|
Maybe<SharedMemoryHandle> prefsHandle =
|
|
geckoargs::sPrefsHandle.Get(aArgc, aArgv);
|
|
Maybe<SharedMemoryHandle> prefMapHandle =
|
|
geckoargs::sPrefMapHandle.Get(aArgc, aArgv);
|
|
Maybe<uint64_t> prefsLen = geckoargs::sPrefsLen.Get(aArgc, aArgv);
|
|
Maybe<uint64_t> prefMapSize = geckoargs::sPrefMapSize.Get(aArgc, aArgv);
|
|
|
|
if (prefsLen.isNothing() || prefMapSize.isNothing() ||
|
|
prefsHandle.isNothing() || prefMapHandle.isNothing()) {
|
|
return false;
|
|
}
|
|
|
|
SharedPreferenceDeserializer deserializer;
|
|
return deserializer.DeserializeFromSharedMemory(std::move(*prefsHandle),
|
|
std::move(*prefMapHandle),
|
|
*prefsLen, *prefMapSize);
|
|
}
|
|
|
|
#ifdef ENABLE_TESTS
|
|
// Allow tests to cause a synthetic delay/"hang" during child process
|
|
// shutdown by setting environment variables.
|
|
# ifdef XP_UNIX
|
|
static void ReallySleep(int aSeconds) {
|
|
struct ::timespec snooze = {aSeconds, 0};
|
|
HANDLE_EINTR(nanosleep(&snooze, &snooze));
|
|
}
|
|
# else
|
|
static void ReallySleep(int aSeconds) { ::Sleep(aSeconds * 1000); }
|
|
# endif // Unix/Win
|
|
static void SleepIfEnv(const char* aName) {
|
|
if (auto* value = PR_GetEnv(aName)) {
|
|
ReallySleep(atoi(value));
|
|
}
|
|
}
|
|
#else // not tests
|
|
static void SleepIfEnv(const char* aName) {}
|
|
#endif
|
|
|
|
ProcessChild::~ProcessChild() {
|
|
#ifdef NS_FREE_PERMANENT_DATA
|
|
// In this case, we won't early-exit and we'll wait indefinitely for
|
|
// child processes to terminate. This sleep is late enough that, in
|
|
// content processes, it won't block parent process shutdown, so
|
|
// we'll get into late IPC shutdown with processes still running.
|
|
SleepIfEnv("MOZ_TEST_CHILD_EXIT_HANG");
|
|
#endif
|
|
gIPCShutdownStateAnnotation = ""_ns;
|
|
gProcessChild = nullptr;
|
|
}
|
|
|
|
/* static */
|
|
void ProcessChild::NotifiedImpendingShutdown() {
|
|
sExpectingShutdown = true;
|
|
ProcessChild::AppendToIPCShutdownStateAnnotation(
|
|
"NotifiedImpendingShutdown"_ns);
|
|
}
|
|
|
|
/* static */
|
|
bool ProcessChild::ExpectingShutdown() { return sExpectingShutdown; }
|
|
|
|
/* static */
|
|
void ProcessChild::QuickExit() {
|
|
#ifndef NS_FREE_PERMANENT_DATA
|
|
// In this case, we're going to terminate the child process before
|
|
// we get to ~ProcessChild above (and terminate the parent process
|
|
// before the shutdown hook in ProcessWatcher). Instead, blocking
|
|
// earlier will let us exercise ProcessWatcher's kill timer.
|
|
SleepIfEnv("MOZ_TEST_CHILD_EXIT_HANG");
|
|
#endif
|
|
AppShutdown::DoImmediateExit();
|
|
}
|
|
|
|
UntypedEndpoint ProcessChild::TakeInitialEndpoint() {
|
|
return UntypedEndpoint{PrivateIPDLInterface{},
|
|
mChildThread->TakeInitialPort(), mMessageChannelId,
|
|
EndpointProcInfo::Current(),
|
|
EndpointProcInfo{.mPid = mParentPid, .mChildID = 0}};
|
|
}
|
|
|
|
} // namespace ipc
|
|
} // namespace mozilla
|