mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-11 02:56:06 +00:00
516 lines
14 KiB
C++
516 lines
14 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 "nsDumpUtils.h"
|
|
#include "nsDirectoryServiceDefs.h"
|
|
#include "nsDirectoryServiceUtils.h"
|
|
#include "prenv.h"
|
|
#include <errno.h>
|
|
#include "mozilla/Services.h"
|
|
#include "nsIObserverService.h"
|
|
#include "mozilla/ClearOnShutdown.h"
|
|
#include "mozilla/unused.h"
|
|
|
|
#ifdef XP_UNIX // {
|
|
#include "mozilla/Preferences.h"
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
using namespace mozilla;
|
|
|
|
/*
|
|
* The following code supports triggering a registered callback upon
|
|
* receiving a specific signal.
|
|
*
|
|
* Take about:memory for example, we register
|
|
* 1. doGCCCDump for doMemoryReport
|
|
* 2. doMemoryReport for sDumpAboutMemorySignum(SIGRTMIN)
|
|
* and sDumpAboutMemoryAfterMMUSignum(SIGRTMIN+1).
|
|
*
|
|
* When we receive one of these signals, we write the signal number to a pipe.
|
|
* The IO thread then notices that the pipe has been written to, and kicks off
|
|
* the appropriate task on the main thread.
|
|
*
|
|
* This scheme is similar to using signalfd(), except it's portable and it
|
|
* doesn't require the use of sigprocmask, which is problematic because it
|
|
* masks signals received by child processes.
|
|
*
|
|
* In theory, we could use Chromium's MessageLoopForIO::CatchSignal() for this.
|
|
* But that uses libevent, which does not handle the realtime signals (bug
|
|
* 794074).
|
|
*/
|
|
|
|
// This is the write-end of a pipe that we use to notice when a
|
|
// specific signal occurs.
|
|
static Atomic<int> sDumpPipeWriteFd(-1);
|
|
|
|
const char* const FifoWatcher::kPrefName =
|
|
"memory_info_dumper.watch_fifo.enabled";
|
|
|
|
static void
|
|
DumpSignalHandler(int aSignum)
|
|
{
|
|
// This is a signal handler, so everything in here needs to be
|
|
// async-signal-safe. Be careful!
|
|
|
|
if (sDumpPipeWriteFd != -1) {
|
|
uint8_t signum = static_cast<int>(aSignum);
|
|
Unused << write(sDumpPipeWriteFd, &signum, sizeof(signum));
|
|
}
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(FdWatcher, nsIObserver);
|
|
|
|
void
|
|
FdWatcher::Init()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
|
|
os->AddObserver(this, "xpcom-shutdown", /* ownsWeak = */ false);
|
|
|
|
XRE_GetIOMessageLoop()->PostTask(
|
|
FROM_HERE,
|
|
NewRunnableMethod(this, &FdWatcher::StartWatching));
|
|
}
|
|
|
|
// Implementations may call this function multiple times if they ensure that
|
|
// it's safe to call OpenFd() multiple times and they call StopWatching()
|
|
// first.
|
|
void
|
|
FdWatcher::StartWatching()
|
|
{
|
|
MOZ_ASSERT(XRE_GetIOMessageLoop() == MessageLoopForIO::current());
|
|
MOZ_ASSERT(mFd == -1);
|
|
|
|
mFd = OpenFd();
|
|
if (mFd == -1) {
|
|
LOG("FdWatcher: OpenFd failed.");
|
|
return;
|
|
}
|
|
|
|
MessageLoopForIO::current()->WatchFileDescriptor(
|
|
mFd, /* persistent = */ true,
|
|
MessageLoopForIO::WATCH_READ,
|
|
&mReadWatcher, this);
|
|
}
|
|
|
|
// Since implementations can call StartWatching() multiple times, they can of
|
|
// course call StopWatching() multiple times.
|
|
void
|
|
FdWatcher::StopWatching()
|
|
{
|
|
MOZ_ASSERT(XRE_GetIOMessageLoop() == MessageLoopForIO::current());
|
|
|
|
mReadWatcher.StopWatchingFileDescriptor();
|
|
if (mFd != -1) {
|
|
close(mFd);
|
|
mFd = -1;
|
|
}
|
|
}
|
|
|
|
StaticRefPtr<SignalPipeWatcher> SignalPipeWatcher::sSingleton;
|
|
|
|
/* static */ SignalPipeWatcher*
|
|
SignalPipeWatcher::GetSingleton()
|
|
{
|
|
if (!sSingleton) {
|
|
sSingleton = new SignalPipeWatcher();
|
|
sSingleton->Init();
|
|
ClearOnShutdown(&sSingleton);
|
|
}
|
|
return sSingleton;
|
|
}
|
|
|
|
void
|
|
SignalPipeWatcher::RegisterCallback(uint8_t aSignal,
|
|
PipeCallback aCallback)
|
|
{
|
|
MutexAutoLock lock(mSignalInfoLock);
|
|
|
|
for (SignalInfoArray::index_type i = 0; i < mSignalInfo.Length(); ++i) {
|
|
if (mSignalInfo[i].mSignal == aSignal) {
|
|
LOG("Register Signal(%d) callback failed! (DUPLICATE)", aSignal);
|
|
return;
|
|
}
|
|
}
|
|
SignalInfo signalInfo = { aSignal, aCallback };
|
|
mSignalInfo.AppendElement(signalInfo);
|
|
RegisterSignalHandler(signalInfo.mSignal);
|
|
}
|
|
|
|
void
|
|
SignalPipeWatcher::RegisterSignalHandler(uint8_t aSignal)
|
|
{
|
|
struct sigaction action;
|
|
memset(&action, 0, sizeof(action));
|
|
sigemptyset(&action.sa_mask);
|
|
action.sa_handler = DumpSignalHandler;
|
|
|
|
if (aSignal) {
|
|
if (sigaction(aSignal, &action, nullptr)) {
|
|
LOG("SignalPipeWatcher failed to register sig %d.", aSignal);
|
|
}
|
|
} else {
|
|
MutexAutoLock lock(mSignalInfoLock);
|
|
for (SignalInfoArray::index_type i = 0; i < mSignalInfo.Length(); i++) {
|
|
if (sigaction(mSignalInfo[i].mSignal, &action, nullptr)) {
|
|
LOG("SignalPipeWatcher failed to register signal(%d) "
|
|
"dump signal handler.", mSignalInfo[i].mSignal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SignalPipeWatcher::~SignalPipeWatcher()
|
|
{
|
|
if (sDumpPipeWriteFd != -1) {
|
|
StopWatching();
|
|
}
|
|
}
|
|
|
|
int
|
|
SignalPipeWatcher::OpenFd()
|
|
{
|
|
MOZ_ASSERT(XRE_GetIOMessageLoop() == MessageLoopForIO::current());
|
|
|
|
// Create a pipe. When we receive a signal in our signal handler, we'll
|
|
// write the signum to the write-end of this pipe.
|
|
int pipeFds[2];
|
|
if (pipe(pipeFds)) {
|
|
LOG("SignalPipeWatcher failed to create pipe.");
|
|
return -1;
|
|
}
|
|
|
|
// Close this pipe on calls to exec().
|
|
fcntl(pipeFds[0], F_SETFD, FD_CLOEXEC);
|
|
fcntl(pipeFds[1], F_SETFD, FD_CLOEXEC);
|
|
|
|
int readFd = pipeFds[0];
|
|
sDumpPipeWriteFd = pipeFds[1];
|
|
|
|
RegisterSignalHandler();
|
|
return readFd;
|
|
}
|
|
|
|
void
|
|
SignalPipeWatcher::StopWatching()
|
|
{
|
|
MOZ_ASSERT(XRE_GetIOMessageLoop() == MessageLoopForIO::current());
|
|
|
|
// Close sDumpPipeWriteFd /after/ setting the fd to -1.
|
|
// Otherwise we have the (admittedly far-fetched) race where we
|
|
//
|
|
// 1) close sDumpPipeWriteFd
|
|
// 2) open a new fd with the same number as sDumpPipeWriteFd
|
|
// had.
|
|
// 3) receive a signal, then write to the fd.
|
|
int pipeWriteFd = sDumpPipeWriteFd.exchange(-1);
|
|
close(pipeWriteFd);
|
|
|
|
FdWatcher::StopWatching();
|
|
}
|
|
|
|
void
|
|
SignalPipeWatcher::OnFileCanReadWithoutBlocking(int aFd)
|
|
{
|
|
MOZ_ASSERT(XRE_GetIOMessageLoop() == MessageLoopForIO::current());
|
|
|
|
uint8_t signum;
|
|
ssize_t numReceived = read(aFd, &signum, sizeof(signum));
|
|
if (numReceived != sizeof(signum)) {
|
|
LOG("Error reading from buffer in "
|
|
"SignalPipeWatcher::OnFileCanReadWithoutBlocking.");
|
|
return;
|
|
}
|
|
|
|
{
|
|
MutexAutoLock lock(mSignalInfoLock);
|
|
for (SignalInfoArray::index_type i = 0; i < mSignalInfo.Length(); i++) {
|
|
if (signum == mSignalInfo[i].mSignal) {
|
|
mSignalInfo[i].mCallback(signum);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
LOG("SignalPipeWatcher got unexpected signum.");
|
|
}
|
|
|
|
StaticRefPtr<FifoWatcher> FifoWatcher::sSingleton;
|
|
|
|
/* static */ FifoWatcher*
|
|
FifoWatcher::GetSingleton()
|
|
{
|
|
if (!sSingleton) {
|
|
nsAutoCString dirPath;
|
|
Preferences::GetCString(
|
|
"memory_info_dumper.watch_fifo.directory", &dirPath);
|
|
sSingleton = new FifoWatcher(dirPath);
|
|
sSingleton->Init();
|
|
ClearOnShutdown(&sSingleton);
|
|
}
|
|
return sSingleton;
|
|
}
|
|
|
|
/* static */ bool
|
|
FifoWatcher::MaybeCreate()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (!XRE_IsParentProcess()) {
|
|
// We want this to be main-process only, since two processes can't listen
|
|
// to the same fifo.
|
|
return false;
|
|
}
|
|
|
|
if (!Preferences::GetBool(kPrefName, false)) {
|
|
LOG("Fifo watcher disabled via pref.");
|
|
return false;
|
|
}
|
|
|
|
// The FifoWatcher is held alive by the observer service.
|
|
if (!sSingleton) {
|
|
GetSingleton();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void
|
|
FifoWatcher::RegisterCallback(const nsCString& aCommand, FifoCallback aCallback)
|
|
{
|
|
MutexAutoLock lock(mFifoInfoLock);
|
|
|
|
for (FifoInfoArray::index_type i = 0; i < mFifoInfo.Length(); ++i) {
|
|
if (mFifoInfo[i].mCommand.Equals(aCommand)) {
|
|
LOG("Register command(%s) callback failed! (DUPLICATE)", aCommand.get());
|
|
return;
|
|
}
|
|
}
|
|
FifoInfo aFifoInfo = { aCommand, aCallback };
|
|
mFifoInfo.AppendElement(aFifoInfo);
|
|
}
|
|
|
|
FifoWatcher::~FifoWatcher()
|
|
{
|
|
}
|
|
|
|
int
|
|
FifoWatcher::OpenFd()
|
|
{
|
|
// If the memory_info_dumper.directory pref is specified, put the fifo
|
|
// there. Otherwise, put it into the system's tmp directory.
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
|
|
nsresult rv;
|
|
if (mDirPath.Length() > 0) {
|
|
rv = XRE_GetFileFromPath(mDirPath.get(), getter_AddRefs(file));
|
|
if (NS_FAILED(rv)) {
|
|
LOG("FifoWatcher failed to open file \"%s\"", mDirPath.get());
|
|
return -1;
|
|
}
|
|
} else {
|
|
rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(file));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
rv = file->AppendNative(NS_LITERAL_CSTRING("debug_info_trigger"));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return -1;
|
|
}
|
|
|
|
nsAutoCString path;
|
|
rv = file->GetNativePath(path);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return -1;
|
|
}
|
|
|
|
// unlink might fail because the file doesn't exist, or for other reasons.
|
|
// But we don't care it fails; any problems will be detected later, when we
|
|
// try to mkfifo or open the file.
|
|
if (unlink(path.get())) {
|
|
LOG("FifoWatcher::OpenFifo unlink failed; errno=%d. "
|
|
"Continuing despite error.", errno);
|
|
}
|
|
|
|
if (mkfifo(path.get(), 0766)) {
|
|
LOG("FifoWatcher::OpenFifo mkfifo failed; errno=%d", errno);
|
|
return -1;
|
|
}
|
|
|
|
#ifdef ANDROID
|
|
// Android runs with a umask, so we need to chmod our fifo to make it
|
|
// world-writable.
|
|
chmod(path.get(), 0666);
|
|
#endif
|
|
|
|
int fd;
|
|
do {
|
|
// The fifo will block until someone else has written to it. In
|
|
// particular, open() will block until someone else has opened it for
|
|
// writing! We want open() to succeed and read() to block, so we open
|
|
// with NONBLOCK and then fcntl that away.
|
|
fd = open(path.get(), O_RDONLY | O_NONBLOCK);
|
|
} while (fd == -1 && errno == EINTR);
|
|
|
|
if (fd == -1) {
|
|
LOG("FifoWatcher::OpenFifo open failed; errno=%d", errno);
|
|
return -1;
|
|
}
|
|
|
|
// Make fd blocking now that we've opened it.
|
|
if (fcntl(fd, F_SETFL, 0)) {
|
|
close(fd);
|
|
return -1;
|
|
}
|
|
|
|
return fd;
|
|
}
|
|
|
|
void
|
|
FifoWatcher::OnFileCanReadWithoutBlocking(int aFd)
|
|
{
|
|
MOZ_ASSERT(XRE_GetIOMessageLoop() == MessageLoopForIO::current());
|
|
|
|
char buf[1024];
|
|
int nread;
|
|
do {
|
|
// sizeof(buf) - 1 to leave space for the null-terminator.
|
|
nread = read(aFd, buf, sizeof(buf));
|
|
} while (nread == -1 && errno == EINTR);
|
|
|
|
if (nread == -1) {
|
|
// We want to avoid getting into a situation where
|
|
// OnFileCanReadWithoutBlocking is called in an infinite loop, so when
|
|
// something goes wrong, stop watching the fifo altogether.
|
|
LOG("FifoWatcher hit an error (%d) and is quitting.", errno);
|
|
StopWatching();
|
|
return;
|
|
}
|
|
|
|
if (nread == 0) {
|
|
// If we get EOF, that means that the other side closed the fifo. We need
|
|
// to close and re-open the fifo; if we don't,
|
|
// OnFileCanWriteWithoutBlocking will be called in an infinite loop.
|
|
|
|
LOG("FifoWatcher closing and re-opening fifo.");
|
|
StopWatching();
|
|
StartWatching();
|
|
return;
|
|
}
|
|
|
|
nsAutoCString inputStr;
|
|
inputStr.Append(buf, nread);
|
|
|
|
// Trimming whitespace is important because if you do
|
|
// |echo "foo" >> debug_info_trigger|,
|
|
// it'll actually write "foo\n" to the fifo.
|
|
inputStr.Trim("\b\t\r\n");
|
|
|
|
{
|
|
MutexAutoLock lock(mFifoInfoLock);
|
|
|
|
for (FifoInfoArray::index_type i = 0; i < mFifoInfo.Length(); i++) {
|
|
const nsCString commandStr = mFifoInfo[i].mCommand;
|
|
if (inputStr == commandStr.get()) {
|
|
mFifoInfo[i].mCallback(inputStr);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
LOG("Got unexpected value from fifo; ignoring it.");
|
|
}
|
|
|
|
#endif // XP_UNIX }
|
|
|
|
// In Android case, this function will open a file named aFilename under
|
|
// /data/local/tmp/"aFoldername".
|
|
// Otherwise, it will open a file named aFilename under "NS_OS_TEMP_DIR".
|
|
/* static */ nsresult
|
|
nsDumpUtils::OpenTempFile(const nsACString& aFilename, nsIFile** aFile,
|
|
const nsACString& aFoldername, Mode aMode)
|
|
{
|
|
#ifdef ANDROID
|
|
// For Android, first try the downloads directory which is world-readable
|
|
// rather than the temp directory which is not.
|
|
if (!*aFile) {
|
|
char* env = PR_GetEnv("DOWNLOADS_DIRECTORY");
|
|
if (env) {
|
|
NS_NewNativeLocalFile(nsCString(env), /* followLinks = */ true, aFile);
|
|
}
|
|
}
|
|
#endif
|
|
nsresult rv;
|
|
if (!*aFile) {
|
|
rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, aFile);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
#ifdef ANDROID
|
|
// /data/local/tmp is a true tmp directory; anyone can create a file there,
|
|
// but only the user which created the file can remove it. We want non-root
|
|
// users to be able to remove these files, so we write them into a
|
|
// subdirectory of the temp directory and chmod 777 that directory.
|
|
if (aFoldername != EmptyCString()) {
|
|
rv = (*aFile)->AppendNative(aFoldername);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// It's OK if this fails; that probably just means that the directory already
|
|
// exists.
|
|
(*aFile)->Create(nsIFile::DIRECTORY_TYPE, 0777);
|
|
|
|
nsAutoCString dirPath;
|
|
rv = (*aFile)->GetNativePath(dirPath);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
while (chmod(dirPath.get(), 0777) == -1 && errno == EINTR) {
|
|
}
|
|
}
|
|
#endif
|
|
|
|
nsCOMPtr<nsIFile> file(*aFile);
|
|
|
|
rv = file->AppendNative(aFilename);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (aMode == CREATE_UNIQUE) {
|
|
rv = file->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0666);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
} else {
|
|
file->Create(nsIFile::NORMAL_FILE_TYPE, 0666);
|
|
}
|
|
|
|
#ifdef ANDROID
|
|
// Make this file world-read/writable; the permissions passed to the
|
|
// CreateUnique call above are not sufficient on Android, which runs with a
|
|
// umask.
|
|
nsAutoCString path;
|
|
rv = file->GetNativePath(path);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
while (chmod(path.get(), 0666) == -1 && errno == EINTR) {
|
|
}
|
|
#endif
|
|
|
|
return NS_OK;
|
|
}
|