gecko-dev/ipc/glue/CrashReporterHost.cpp

315 строки
9.1 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 "CrashReporterHost.h"
#include "CrashReporterMetadataShmem.h"
#include "mozilla/LazyIdleThread.h"
#include "mozilla/Sprintf.h"
#include "mozilla/SyncRunnable.h"
#include "mozilla/Telemetry.h"
#ifdef MOZ_CRASHREPORTER
# include "nsIAsyncShutdown.h"
# include "nsICrashService.h"
#endif
namespace mozilla {
namespace ipc {
CrashReporterHost::CrashReporterHost(GeckoProcessType aProcessType,
const Shmem& aShmem,
CrashReporter::ThreadId aThreadId)
: mProcessType(aProcessType),
mShmem(aShmem),
mThreadId(aThreadId),
mStartTime(::time(nullptr)),
mFinalized(false)
{
}
#ifdef MOZ_CRASHREPORTER
bool
CrashReporterHost::GenerateCrashReport(base::ProcessId aPid)
{
if (!TakeCrashedChildMinidump(aPid, nullptr)) {
return false;
}
return FinalizeCrashReport();
}
RefPtr<nsIFile>
CrashReporterHost::TakeCrashedChildMinidump(base::ProcessId aPid, uint32_t* aOutSequence)
{
MOZ_ASSERT(!HasMinidump());
RefPtr<nsIFile> crashDump;
if (!XRE_TakeMinidumpForChild(aPid, getter_AddRefs(crashDump), aOutSequence)) {
return nullptr;
}
if (!AdoptMinidump(crashDump)) {
return nullptr;
}
return crashDump.get();
}
bool
CrashReporterHost::AdoptMinidump(nsIFile* aFile)
{
return CrashReporter::GetIDFromMinidump(aFile, mDumpID);
}
bool
CrashReporterHost::FinalizeCrashReport()
{
MOZ_ASSERT(!mFinalized);
MOZ_ASSERT(HasMinidump());
CrashReporter::AnnotationTable notes;
nsAutoCString type;
switch (mProcessType) {
case GeckoProcessType_Content:
type = NS_LITERAL_CSTRING("content");
break;
case GeckoProcessType_Plugin:
case GeckoProcessType_GMPlugin:
type = NS_LITERAL_CSTRING("plugin");
break;
case GeckoProcessType_GPU:
type = NS_LITERAL_CSTRING("gpu");
break;
default:
NS_ERROR("unknown process type");
break;
}
notes.Put(NS_LITERAL_CSTRING("ProcessType"), type);
char startTime[32];
SprintfLiteral(startTime, "%lld", static_cast<long long>(mStartTime));
notes.Put(NS_LITERAL_CSTRING("StartupTime"), nsDependentCString(startTime));
// We might not have shmem (for example, when running crashreporter tests).
if (mShmem.IsReadable()) {
CrashReporterMetadataShmem::ReadAppNotes(mShmem, &notes);
}
CrashReporter::AppendExtraData(mDumpID, mExtraNotes);
CrashReporter::AppendExtraData(mDumpID, notes);
// Use mExtraNotes, since NotifyCrashService looks for "PluginHang" which is
// set in the parent process.
NotifyCrashService(mProcessType, mDumpID, &mExtraNotes);
mFinalized = true;
return true;
}
/**
* Runnable used to execute the minidump analyzer program asynchronously after
* a crash. This should run on a background thread not to block the main thread
* over the potentially long minidump analysis. Once analysis is over, the
* crash information will be relayed to the crash manager via another runnable
* sent to the main thread. Shutdown will be blocked for the duration of the
* entire process to ensure this information is sent.
*/
class AsyncMinidumpAnalyzer final : public nsIRunnable
, public nsIAsyncShutdownBlocker
{
public:
/**
* Create a new minidump analyzer runnable, this will also block shutdown
* until the associated crash has been added to the crash manager.
*/
AsyncMinidumpAnalyzer(int32_t aProcessType,
int32_t aCrashType,
const nsString& aChildDumpID)
: mProcessType(aProcessType)
, mCrashType(aCrashType)
, mChildDumpID(aChildDumpID)
, mName(NS_LITERAL_STRING("Crash reporter: blocking on minidump analysis"))
{
MOZ_ASSERT(NS_IsMainThread());
nsresult rv = GetShutdownBarrier()->AddBlocker(
this, NS_LITERAL_STRING(__FILE__), __LINE__,
NS_LITERAL_STRING("Minidump analysis"));
Unused << NS_WARN_IF(NS_FAILED(rv));
}
NS_IMETHOD Run() override
{
MOZ_ASSERT(!NS_IsMainThread());
if (mProcessType == nsICrashService::PROCESS_TYPE_CONTENT) {
CrashReporter::RunMinidumpAnalyzer(mChildDumpID);
}
// Make a copy of these so we can copy them into the runnable lambda
int32_t processType = mProcessType;
int32_t crashType = mCrashType;
nsString childDumpID(mChildDumpID);
nsCOMPtr<nsIAsyncShutdownBlocker> self(this);
NS_DispatchToMainThread(NS_NewRunnableFunction([
self, processType, crashType, childDumpID
] {
nsCOMPtr<nsICrashService> crashService =
do_GetService("@mozilla.org/crashservice;1");
if (crashService) {
crashService->AddCrash(processType, crashType, childDumpID);
}
nsCOMPtr<nsIAsyncShutdownClient> barrier = GetShutdownBarrier();
if (barrier) {
barrier->RemoveBlocker(self);
}
}));
return NS_OK;
}
NS_IMETHOD BlockShutdown(nsIAsyncShutdownClient* aBarrierClient) override
{
return NS_OK;
}
NS_IMETHOD GetName(nsAString& aName) override
{
aName = mName;
return NS_OK;
}
NS_IMETHOD GetState(nsIPropertyBag**) override
{
return NS_OK;
}
NS_DECL_THREADSAFE_ISUPPORTS
private:
~AsyncMinidumpAnalyzer() {}
// Returns the profile-before-change shutdown barrier
static nsCOMPtr<nsIAsyncShutdownClient> GetShutdownBarrier()
{
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIAsyncShutdownService> svc = services::GetAsyncShutdown();
nsCOMPtr<nsIAsyncShutdownClient> barrier;
nsresult rv = svc->GetProfileBeforeChange(getter_AddRefs(barrier));
if (NS_WARN_IF(NS_FAILED(rv))) {
return nullptr;
}
return barrier.forget();
}
int32_t mProcessType;
int32_t mCrashType;
const nsString mChildDumpID;
const nsString mName;
};
NS_IMPL_ISUPPORTS(AsyncMinidumpAnalyzer, nsIRunnable, nsIAsyncShutdownBlocker)
/**
* Add information about a crash to the crash manager. This method runs the
* various activities required to gather additional information and notify the
* crash manager asynchronously, since many of them involve I/O or potentially
* long processing.
*
* @param aProcessType The type of process that crashed
* @param aCrashType The type of crash (crash or hang)
* @param aChildDumpID A string holding the ID of the dump associated with this
* crash
*/
/* static */ void
CrashReporterHost::AsyncAddCrash(int32_t aProcessType,
int32_t aCrashType,
const nsString& aChildDumpID)
{
MOZ_ASSERT(NS_IsMainThread());
static StaticRefPtr<LazyIdleThread> sBackgroundThread;
if (!sBackgroundThread) {
// Background thread used for running minidump analysis. It will be
// destroyed immediately after it's done with the task.
sBackgroundThread =
new LazyIdleThread(0, NS_LITERAL_CSTRING("CrashReporterHost"));
ClearOnShutdown(&sBackgroundThread);
}
RefPtr<AsyncMinidumpAnalyzer> task =
new AsyncMinidumpAnalyzer(aProcessType, aCrashType, aChildDumpID);
Unused << sBackgroundThread->Dispatch(task, NS_DISPATCH_NORMAL);
}
/* static */ void
CrashReporterHost::NotifyCrashService(GeckoProcessType aProcessType,
const nsString& aChildDumpID,
const AnnotationTable* aNotes)
{
if (!NS_IsMainThread()) {
RefPtr<Runnable> runnable = NS_NewRunnableFunction([=] () -> void {
CrashReporterHost::NotifyCrashService(aProcessType, aChildDumpID, aNotes);
});
RefPtr<nsIThread> mainThread = do_GetMainThread();
SyncRunnable::DispatchToThread(mainThread, runnable);
return;
}
MOZ_ASSERT(!aChildDumpID.IsEmpty());
int32_t processType;
int32_t crashType = nsICrashService::CRASH_TYPE_CRASH;
nsCString telemetryKey;
switch (aProcessType) {
case GeckoProcessType_Content:
processType = nsICrashService::PROCESS_TYPE_CONTENT;
telemetryKey.AssignLiteral("content");
break;
case GeckoProcessType_Plugin: {
processType = nsICrashService::PROCESS_TYPE_PLUGIN;
telemetryKey.AssignLiteral("plugin");
nsAutoCString val;
if (aNotes->Get(NS_LITERAL_CSTRING("PluginHang"), &val) &&
val.Equals(NS_LITERAL_CSTRING("1"))) {
crashType = nsICrashService::CRASH_TYPE_HANG;
telemetryKey.AssignLiteral("pluginhang");
}
break;
}
case GeckoProcessType_GMPlugin:
processType = nsICrashService::PROCESS_TYPE_GMPLUGIN;
telemetryKey.AssignLiteral("gmplugin");
break;
case GeckoProcessType_GPU:
processType = nsICrashService::PROCESS_TYPE_GPU;
telemetryKey.AssignLiteral("gpu");
break;
default:
NS_ERROR("unknown process type");
return;
}
AsyncAddCrash(processType, crashType, aChildDumpID);
Telemetry::Accumulate(Telemetry::SUBPROCESS_CRASHES_WITH_DUMP, telemetryKey, 1);
}
void
CrashReporterHost::AddNote(const nsCString& aKey, const nsCString& aValue)
{
mExtraNotes.Put(aKey, aValue);
}
#endif
} // namespace ipc
} // namespace mozilla