diff options
Diffstat (limited to 'toolkit/crashreporter/nsExceptionHandler.cpp')
| -rw-r--r-- | toolkit/crashreporter/nsExceptionHandler.cpp | 4147 |
1 files changed, 4147 insertions, 0 deletions
diff --git a/toolkit/crashreporter/nsExceptionHandler.cpp b/toolkit/crashreporter/nsExceptionHandler.cpp new file mode 100644 index 000000000..1e0743192 --- /dev/null +++ b/toolkit/crashreporter/nsExceptionHandler.cpp @@ -0,0 +1,4147 @@ +/* -*- 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 "nsExceptionHandler.h" + +#include "nsAppDirectoryServiceDefs.h" +#include "nsDirectoryServiceDefs.h" +#include "nsDataHashtable.h" +#include "mozilla/ArrayUtils.h" +#include "mozilla/dom/CrashReporterChild.h" +#include "mozilla/ipc/CrashReporterClient.h" +#include "mozilla/Services.h" +#include "nsIObserverService.h" +#include "mozilla/Unused.h" +#include "mozilla/Sprintf.h" +#include "mozilla/SyncRunnable.h" +#include "mozilla/TimeStamp.h" + +#include "nsThreadUtils.h" +#include "nsXULAppAPI.h" +#include "jsfriendapi.h" + +#if defined(XP_WIN32) +#ifdef WIN32_LEAN_AND_MEAN +#undef WIN32_LEAN_AND_MEAN +#endif + +#include "nsXULAppAPI.h" +#include "nsIXULAppInfo.h" +#include "nsIWindowsRegKey.h" +#include "client/windows/crash_generation/client_info.h" +#include "client/windows/crash_generation/crash_generation_server.h" +#include "client/windows/handler/exception_handler.h" +#include <dbghelp.h> +#include <string.h> +#include "nsDirectoryServiceUtils.h" + +#include "nsWindowsDllInterceptor.h" +#elif defined(XP_MACOSX) +#include "client/mac/crash_generation/client_info.h" +#include "client/mac/crash_generation/crash_generation_server.h" +#include "client/mac/handler/exception_handler.h" +#include <string> +#include <Carbon/Carbon.h> +#include <CoreFoundation/CoreFoundation.h> +#include <crt_externs.h> +#include <fcntl.h> +#include <mach/mach.h> +#include <sys/types.h> +#include <spawn.h> +#include <unistd.h> +#include "mac_utils.h" +#elif defined(XP_LINUX) +#include "nsIINIParser.h" +#include "common/linux/linux_libc_support.h" +#include "third_party/lss/linux_syscall_support.h" +#include "client/linux/crash_generation/client_info.h" +#include "client/linux/crash_generation/crash_generation_server.h" +#include "client/linux/handler/exception_handler.h" +#include "common/linux/eintr_wrapper.h" +#include <fcntl.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> +#elif defined(XP_SOLARIS) +#include "client/solaris/handler/exception_handler.h" +#include <fcntl.h> +#include <sys/types.h> +#include <unistd.h> +#else +#error "Not yet implemented for this platform" +#endif // defined(XP_WIN32) + +#ifdef MOZ_CRASHREPORTER_INJECTOR +#include "InjectCrashReporter.h" +using mozilla::InjectCrashRunnable; +#endif + +#include <stdlib.h> +#include <time.h> +#include <prenv.h> +#include <prio.h> +#include <prmem.h> +#include "mozilla/Mutex.h" +#include "nsDebug.h" +#include "nsCRT.h" +#include "nsIFile.h" +#include "prprf.h" +#include <map> +#include <vector> + +#include "mozilla/double-conversion.h" +#include "mozilla/IOInterposer.h" +#include "mozilla/mozalloc_oom.h" +#include "mozilla/WindowsDllBlocklist.h" + +#if defined(XP_MACOSX) +CFStringRef reporterClientAppID = CFSTR("org.mozilla.crashreporter"); +#endif +#if defined(MOZ_WIDGET_ANDROID) +#include "common/linux/file_id.h" +#endif + +using google_breakpad::CrashGenerationServer; +using google_breakpad::ClientInfo; +#ifdef XP_LINUX +using google_breakpad::MinidumpDescriptor; +#endif +#if defined(MOZ_WIDGET_ANDROID) +using google_breakpad::auto_wasteful_vector; +using google_breakpad::FileID; +using google_breakpad::PageAllocator; +#endif +using namespace mozilla; +using mozilla::dom::CrashReporterChild; +using mozilla::dom::PCrashReporterChild; +using mozilla::ipc::CrashReporterClient; + +namespace CrashReporter { + +#ifdef XP_WIN32 +typedef wchar_t XP_CHAR; +typedef std::wstring xpstring; +#define XP_TEXT(x) L##x +#define CONVERT_XP_CHAR_TO_UTF16(x) x +#define XP_STRLEN(x) wcslen(x) +#define my_strlen strlen +#define CRASH_REPORTER_FILENAME "crashreporter.exe" +#define PATH_SEPARATOR "\\" +#define XP_PATH_SEPARATOR L"\\" +#define XP_PATH_SEPARATOR_CHAR L'\\' +#define XP_PATH_MAX (MAX_PATH + 1) +// "<reporter path>" "<minidump path>" +#define CMDLINE_SIZE ((XP_PATH_MAX * 2) + 6) +#ifdef _USE_32BIT_TIME_T +#define XP_TTOA(time, buffer, base) ltoa(time, buffer, base) +#else +#define XP_TTOA(time, buffer, base) _i64toa(time, buffer, base) +#endif +#define XP_STOA(size, buffer, base) _ui64toa(size, buffer, base) +#else +typedef char XP_CHAR; +typedef std::string xpstring; +#define XP_TEXT(x) x +#define CONVERT_XP_CHAR_TO_UTF16(x) NS_ConvertUTF8toUTF16(x) +#define CRASH_REPORTER_FILENAME "crashreporter" +#define PATH_SEPARATOR "/" +#define XP_PATH_SEPARATOR "/" +#define XP_PATH_SEPARATOR_CHAR '/' +#define XP_PATH_MAX PATH_MAX +#ifdef XP_LINUX +#define XP_STRLEN(x) my_strlen(x) +#define XP_TTOA(time, buffer, base) my_inttostring(time, buffer, sizeof(buffer)) +#define XP_STOA(size, buffer, base) my_inttostring(size, buffer, sizeof(buffer)) +#else +#define XP_STRLEN(x) strlen(x) +#define XP_TTOA(time, buffer, base) sprintf(buffer, "%ld", time) +#define XP_STOA(size, buffer, base) sprintf(buffer, "%zu", (size_t) size) +#define my_strlen strlen +#define sys_close close +#define sys_fork fork +#define sys_open open +#define sys_read read +#define sys_write write +#endif +#endif // XP_WIN32 + +#if defined(__GNUC__) +#define MAYBE_UNUSED __attribute__((unused)) +#else +#define MAYBE_UNUSED +#endif // defined(__GNUC__) + +#ifndef XP_LINUX +static const XP_CHAR dumpFileExtension[] = XP_TEXT(".dmp"); +#endif + +static const XP_CHAR childCrashAnnotationBaseName[] = XP_TEXT("GeckoChildCrash"); +static const XP_CHAR extraFileExtension[] = XP_TEXT(".extra"); +static const XP_CHAR memoryReportExtension[] = XP_TEXT(".memory.json.gz"); +static xpstring *defaultMemoryReportPath = nullptr; + +// A whitelist of crash annotations which do not contain sensitive data +// and are saved in the crash record and sent with Firefox Health Report. +static char const * const kCrashEventAnnotations[] = { + "AsyncShutdownTimeout", + "BuildID", + "ProductID", + "ProductName", + "ReleaseChannel", + "SecondsSinceLastCrash", + "ShutdownProgress", + "StartupCrash", + "TelemetryEnvironment", + "Version", + // The following entries are not normal annotations but are included + // in the crash record/FHR: + // "ContainsMemoryReport" + // "EventLoopNestingLevel" + // "IsGarbageCollecting" + // "AvailablePageFile" + // "AvailableVirtualMemory" + // "SystemMemoryUsePercentage" + // "OOMAllocationSize" + // "TotalPageFile" + // "TotalPhysicalMemory" + // "TotalVirtualMemory" + // "MozCrashReason" +}; + +static const char kCrashMainID[] = "crash.main.2\n"; + +static google_breakpad::ExceptionHandler* gExceptionHandler = nullptr; + +static XP_CHAR* pendingDirectory; +static XP_CHAR* crashReporterPath; +static XP_CHAR* memoryReportPath; + +// Where crash events should go. +static XP_CHAR* eventsDirectory; +static char* eventsEnv = nullptr; + +// The current telemetry session ID to write to the event file +static char* currentSessionId = nullptr; + +// If this is false, we don't launch the crash reporter +static bool doReport = true; + +// If this is true, we don't have a crash reporter +static bool headlessClient = false; + +// if this is true, we pass the exception on to the OS crash reporter +static bool showOSCrashReporter = false; + +// The time of the last recorded crash, as a time_t value. +static time_t lastCrashTime = 0; +// The pathname of a file to store the crash time in +static XP_CHAR lastCrashTimeFilename[XP_PATH_MAX] = {0}; + +// A marker file to hold the path to the last dump written, which +// will be checked on startup. +static XP_CHAR crashMarkerFilename[XP_PATH_MAX] = {0}; + +// Whether we've already looked for the marker file. +static bool lastRunCrashID_checked = false; +// The minidump ID contained in the marker file. +static nsString* lastRunCrashID = nullptr; + +#if defined(MOZ_WIDGET_ANDROID) +// on Android 4.2 and above there is a user serial number associated +// with the current process that gets lost when we fork so we need to +// explicitly pass it to am +static char* androidUserSerial = nullptr; +#endif + +// these are just here for readability +static const char kTimeSinceLastCrashParameter[] = "SecondsSinceLastCrash="; +static const int kTimeSinceLastCrashParameterLen = + sizeof(kTimeSinceLastCrashParameter)-1; + +// this holds additional data sent via the API +static Mutex* crashReporterAPILock; +static Mutex* notesFieldLock; +static AnnotationTable* crashReporterAPIData_Hash; +static nsCString* crashReporterAPIData = nullptr; +static nsCString* crashEventAPIData = nullptr; +static nsCString* notesField = nullptr; +static bool isGarbageCollecting; +static uint32_t eventloopNestingLevel = 0; + +// Avoid a race during application termination. +static Mutex* dumpSafetyLock; +static bool isSafeToDump = false; + +// OOP crash reporting +static CrashGenerationServer* crashServer; // chrome process has this + +static std::terminate_handler oldTerminateHandler = nullptr; + +#if (defined(XP_MACOSX) || defined(XP_WIN)) +// This field is valid in both chrome and content processes. +static xpstring* childProcessTmpDir = nullptr; +#endif + +# if defined(XP_WIN) || defined(XP_MACOSX) +// If crash reporting is disabled, we hand out this "null" pipe to the +// child process and don't attempt to connect to a parent server. +static const char kNullNotifyPipe[] = "-"; +static char* childCrashNotifyPipe; + +# elif defined(XP_LINUX) +static int serverSocketFd = -1; +static int clientSocketFd = -1; +static const int kMagicChildCrashReportFd = 4; + +# endif + +// |dumpMapLock| must protect all access to |pidToMinidump|. +static Mutex* dumpMapLock; +struct ChildProcessData : public nsUint32HashKey +{ + explicit ChildProcessData(KeyTypePointer aKey) + : nsUint32HashKey(aKey) + , sequence(0) +#ifdef MOZ_CRASHREPORTER_INJECTOR + , callback(nullptr) +#endif + { } + + nsCOMPtr<nsIFile> minidump; + // Each crashing process is assigned an increasing sequence number to + // indicate which process crashed first. + uint32_t sequence; +#ifdef MOZ_CRASHREPORTER_INJECTOR + InjectorCrashCallback* callback; +#endif +}; + +typedef nsTHashtable<ChildProcessData> ChildMinidumpMap; +static ChildMinidumpMap* pidToMinidump; +static uint32_t crashSequence; +static bool OOPInitialized(); + +#ifdef MOZ_CRASHREPORTER_INJECTOR +static nsIThread* sInjectorThread; + +class ReportInjectedCrash : public Runnable +{ +public: + explicit ReportInjectedCrash(uint32_t pid) : mPID(pid) { } + + NS_IMETHOD Run(); + +private: + uint32_t mPID; +}; +#endif // MOZ_CRASHREPORTER_INJECTOR + +// Crashreporter annotations that we don't send along in subprocess reports. +static const char* kSubprocessBlacklist[] = { + "FramePoisonBase", + "FramePoisonSize", + "StartupCrash", + "StartupTime", + "URL" +}; + +// If annotations are attempted before the crash reporter is enabled, +// they queue up here. +class DelayedNote; +nsTArray<nsAutoPtr<DelayedNote> >* gDelayedAnnotations; + +#if defined(XP_WIN) +// the following are used to prevent other DLLs reverting the last chance +// exception handler to the windows default. Any attempt to change the +// unhandled exception filter or to reset it is ignored and our crash +// reporter is loaded instead (in case it became unloaded somehow) +typedef LPTOP_LEVEL_EXCEPTION_FILTER (WINAPI *SetUnhandledExceptionFilter_func) + (LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter); +static SetUnhandledExceptionFilter_func stub_SetUnhandledExceptionFilter = 0; +static LPTOP_LEVEL_EXCEPTION_FILTER previousUnhandledExceptionFilter = nullptr; +static WindowsDllInterceptor gKernel32Intercept; +static bool gBlockUnhandledExceptionFilter = true; + +static LPTOP_LEVEL_EXCEPTION_FILTER GetUnhandledExceptionFilter() +{ + // Set a dummy value to get the current filter, then restore + LPTOP_LEVEL_EXCEPTION_FILTER current = SetUnhandledExceptionFilter(nullptr); + SetUnhandledExceptionFilter(current); + return current; +} + +static LPTOP_LEVEL_EXCEPTION_FILTER WINAPI +patched_SetUnhandledExceptionFilter (LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter) +{ + if (!gBlockUnhandledExceptionFilter) { + // don't intercept + return stub_SetUnhandledExceptionFilter(lpTopLevelExceptionFilter); + } + + if (lpTopLevelExceptionFilter == previousUnhandledExceptionFilter) { + // OK to swap back and forth between the previous filter + previousUnhandledExceptionFilter = + stub_SetUnhandledExceptionFilter(lpTopLevelExceptionFilter); + return previousUnhandledExceptionFilter; + } + + // intercept attempts to change the filter + return nullptr; +} + +static LPTOP_LEVEL_EXCEPTION_FILTER sUnhandledExceptionFilter = nullptr; + +static long +JitExceptionHandler(void *exceptionRecord, void *context) +{ + EXCEPTION_POINTERS pointers = { + (PEXCEPTION_RECORD)exceptionRecord, + (PCONTEXT)context + }; + return sUnhandledExceptionFilter(&pointers); +} + +/** + * Reserve some VM space. In the event that we crash because VM space is + * being leaked without leaking memory, freeing this space before taking + * the minidump will allow us to collect a minidump. + * + * This size is bigger than xul.dll plus some extra for MinidumpWriteDump + * allocations. + */ +static const SIZE_T kReserveSize = 0x4000000; // 64 MB +static void* gBreakpadReservedVM; +#endif + +#ifdef XP_MACOSX +static cpu_type_t pref_cpu_types[2] = { +#if defined(__i386__) + CPU_TYPE_X86, +#elif defined(__x86_64__) + CPU_TYPE_X86_64, +#elif defined(__ppc__) + CPU_TYPE_POWERPC, +#endif + CPU_TYPE_ANY }; + +static posix_spawnattr_t spawnattr; +#endif + +#if defined(MOZ_WIDGET_ANDROID) +// Android builds use a custom library loader, +// so the embedding will provide a list of shared +// libraries that are mapped into anonymous mappings. +typedef struct { + std::string name; + uintptr_t start_address; + size_t length; + size_t file_offset; +} mapping_info; +static std::vector<mapping_info> library_mappings; +typedef std::map<uint32_t,google_breakpad::MappingList> MappingMap; +#endif +} + +// Format a non-negative double to a string, without using C-library functions, +// which need to be avoided (.e.g. bug 1240160, comment 10). Leave the utility +// non-file static so that we can gtest it. Return false if we failed to +// get the formatting done correctly. +bool SimpleNoCLibDtoA(double aValue, char* aBuffer, int aBufferLength) +{ + // aBufferLength is the size of the buffer. Be paranoid. + aBuffer[aBufferLength-1] = '\0'; + + if (aValue < 0) { + return false; + } + + int length, point, i; + bool sign; + bool ok = true; + double_conversion::DoubleToStringConverter::DoubleToAscii( + aValue, + double_conversion::DoubleToStringConverter::SHORTEST, + 8, + aBuffer, + aBufferLength, + &sign, + &length, + &point); + + // length does not account for the 0 terminator. + if (length > point && (length+1) < (aBufferLength-1)) { + // We have to insert a decimal point. Not worried about adding a leading zero + // in the < 1 (point == 0) case. + aBuffer[length+1] = '\0'; + for (i=length; i>point; i-=1) { + aBuffer[i] = aBuffer[i-1]; + } + aBuffer[i] = '.'; // Not worried about locales + } else if (length < point) { + // Trailing zeros scenario + for (i=length; i<point; i+=1) { + if (i >= aBufferLength-2) { + ok = false; + } + aBuffer[i] = '0'; + } + aBuffer[i] = '\0'; + } + return ok; +} + +namespace CrashReporter { + +#ifdef XP_LINUX +inline void +my_inttostring(intmax_t t, char* buffer, size_t buffer_length) +{ + my_memset(buffer, 0, buffer_length); + my_uitos(buffer, t, my_uint_len(t)); +} +#endif + +#ifdef XP_WIN +static void +CreateFileFromPath(const xpstring& path, nsIFile** file) +{ + NS_NewLocalFile(nsDependentString(path.c_str()), false, file); +} + +static void +CreateFileFromPath(const wchar_t* path, nsIFile** file) +{ + CreateFileFromPath(std::wstring(path), file); +} + +static xpstring* +CreatePathFromFile(nsIFile* file) +{ + nsAutoString path; + nsresult rv = file->GetPath(path); + if (NS_FAILED(rv)) { + return nullptr; + } + return new xpstring(static_cast<wchar_t*>(path.get()), path.Length()); +} +#else +static void +CreateFileFromPath(const xpstring& path, nsIFile** file) +{ + NS_NewNativeLocalFile(nsDependentCString(path.c_str()), false, file); +} + +MAYBE_UNUSED static xpstring* +CreatePathFromFile(nsIFile* file) +{ + nsAutoCString path; + nsresult rv = file->GetNativePath(path); + if (NS_FAILED(rv)) { + return nullptr; + } + return new xpstring(path.get(), path.Length()); +} +#endif + +static XP_CHAR* +Concat(XP_CHAR* str, const XP_CHAR* toAppend, int* size) +{ + int appendLen = XP_STRLEN(toAppend); + if (appendLen >= *size) appendLen = *size - 1; + + memcpy(str, toAppend, appendLen * sizeof(XP_CHAR)); + str += appendLen; + *str = '\0'; + *size -= appendLen; + + return str; +} + +static size_t gOOMAllocationSize = 0; + +void AnnotateOOMAllocationSize(size_t size) +{ + gOOMAllocationSize = size; +} + +static size_t gTexturesSize = 0; + +void AnnotateTexturesSize(size_t size) +{ + gTexturesSize = size; +} + +static size_t gNumOfPendingIPC = 0; +static uint32_t gTopPendingIPCCount = 0; +static const char* gTopPendingIPCName = nullptr; +static uint32_t gTopPendingIPCType = 0; + +void AnnotatePendingIPC(size_t aNumOfPendingIPC, + uint32_t aTopPendingIPCCount, + const char* aTopPendingIPCName, + uint32_t aTopPendingIPCType) +{ + gNumOfPendingIPC = aNumOfPendingIPC; + gTopPendingIPCCount = aTopPendingIPCCount; + gTopPendingIPCName = aTopPendingIPCName; + gTopPendingIPCType = aTopPendingIPCType; +} + +#ifndef XP_WIN +// Like Windows CopyFile for *nix +bool copy_file(const char* from, const char* to) +{ + const int kBufSize = 4096; + int fdfrom = sys_open(from, O_RDONLY, 0); + if (fdfrom < 0) { + return false; + } + + bool ok = false; + + int fdto = sys_open(to, O_WRONLY | O_CREAT, 0666); + if (fdto < 0) { + sys_close(fdfrom); + return false; + } + + char buf[kBufSize]; + while (true) { + int r = sys_read(fdfrom, buf, kBufSize); + if (r == 0) { + ok = true; + break; + } + if (r < 0) { + break; + } + char* wbuf = buf; + while (r) { + int w = sys_write(fdto, wbuf, r); + if (w > 0) { + r -= w; + wbuf += w; + } else if (errno != EINTR) { + break; + } + } + if (r) { + break; + } + } + + sys_close(fdfrom); + sys_close(fdto); + + return ok; +} +#endif + +#ifdef XP_WIN + +class PlatformWriter +{ +public: + PlatformWriter() + : mHandle(INVALID_HANDLE_VALUE) + { } + + explicit PlatformWriter(const wchar_t* path) + : PlatformWriter() + { + Open(path); + } + + ~PlatformWriter() { + if (Valid()) { + CloseHandle(mHandle); + } + } + + void Open(const wchar_t* path) { + mHandle = CreateFile(path, GENERIC_WRITE, 0, + nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, + nullptr); + } + + bool Valid() { + return mHandle != INVALID_HANDLE_VALUE; + } + + void WriteBuffer(const char* buffer, size_t len) + { + if (!Valid()) { + return; + } + DWORD nBytes; + WriteFile(mHandle, buffer, len, &nBytes, nullptr); + } + + HANDLE Handle() { + return mHandle; + } + +private: + HANDLE mHandle; +}; + +#elif defined(XP_UNIX) + +class PlatformWriter +{ +public: + PlatformWriter() + : mFD(-1) + { } + + explicit PlatformWriter(const char* path) + : PlatformWriter() + { + Open(path); + } + + ~PlatformWriter() { + if (Valid()) { + sys_close(mFD); + } + } + + void Open(const char* path) { + mFD = sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0600); + } + + bool Valid() { + return mFD != -1; + } + + void WriteBuffer(const char* buffer, size_t len) { + if (!Valid()) { + return; + } + Unused << sys_write(mFD, buffer, len); + } + +private: + int mFD; +}; + +#else +#error "Need implementation of PlatformWrite for this platform" +#endif + +template<int N> +void +WriteLiteral(PlatformWriter& pw, const char (&str)[N]) +{ + pw.WriteBuffer(str, N - 1); +} + +static void +WriteString(PlatformWriter& pw, const char* str) { +#ifdef XP_LINUX + size_t len = my_strlen(str); +#else + size_t len = strlen(str); +#endif + + pw.WriteBuffer(str, len); +} + +template<int N> +static void +WriteAnnotation(PlatformWriter& pw, const char (&name)[N], + const char* value) { + WriteLiteral(pw, name); + WriteLiteral(pw, "="); + WriteString(pw, value); + WriteLiteral(pw, "\n"); +}; + +/** + * If minidump_id is null, we assume that dump_path contains the full + * dump file path. + */ +static void +OpenAPIData(PlatformWriter& aWriter, + const XP_CHAR* dump_path, const XP_CHAR* minidump_id = nullptr + ) +{ + static XP_CHAR extraDataPath[XP_PATH_MAX]; + int size = XP_PATH_MAX; + XP_CHAR* p; + if (minidump_id) { + p = Concat(extraDataPath, dump_path, &size); + p = Concat(p, XP_PATH_SEPARATOR, &size); + p = Concat(p, minidump_id, &size); + } else { + p = Concat(extraDataPath, dump_path, &size); + // Skip back past the .dmp extension, if any. + if (*(p - 4) == XP_TEXT('.')) { + p -= 4; + size += 4; + } + } + Concat(p, extraFileExtension, &size); + aWriter.Open(extraDataPath); +} + +#ifdef XP_WIN +void +WriteGlobalMemoryStatus(PlatformWriter* apiData, PlatformWriter* eventFile) +{ + char buffer[128]; + + // Try to get some information about memory. + MEMORYSTATUSEX statex; + statex.dwLength = sizeof(statex); + if (GlobalMemoryStatusEx(&statex)) { + +#define WRITE_STATEX_FIELD(field, name, conversionFunc) \ + conversionFunc(statex.field, buffer, 10); \ + if (apiData) { \ + WriteAnnotation(*apiData, name, buffer); \ + } \ + if (eventFile) { \ + WriteAnnotation(*eventFile, name, buffer); \ + } + + WRITE_STATEX_FIELD(dwMemoryLoad, "SystemMemoryUsePercentage", ltoa); + WRITE_STATEX_FIELD(ullTotalVirtual, "TotalVirtualMemory", _ui64toa); + WRITE_STATEX_FIELD(ullAvailVirtual, "AvailableVirtualMemory", _ui64toa); + WRITE_STATEX_FIELD(ullTotalPageFile, "TotalPageFile", _ui64toa); + WRITE_STATEX_FIELD(ullAvailPageFile, "AvailablePageFile", _ui64toa); + WRITE_STATEX_FIELD(ullTotalPhys, "TotalPhysicalMemory", _ui64toa); + WRITE_STATEX_FIELD(ullAvailPhys, "AvailablePhysicalMemory", _ui64toa); + +#undef WRITE_STATEX_FIELD + } +} +#endif + +bool MinidumpCallback( +#ifdef XP_LINUX + const MinidumpDescriptor& descriptor, +#else + const XP_CHAR* dump_path, + const XP_CHAR* minidump_id, +#endif + void* context, +#ifdef XP_WIN32 + EXCEPTION_POINTERS* exinfo, + MDRawAssertionInfo* assertion, +#endif + bool succeeded) +{ + bool returnValue = showOSCrashReporter ? false : succeeded; + + static XP_CHAR minidumpPath[XP_PATH_MAX]; + int size = XP_PATH_MAX; + XP_CHAR* p; +#ifndef XP_LINUX + p = Concat(minidumpPath, dump_path, &size); + p = Concat(p, XP_PATH_SEPARATOR, &size); + p = Concat(p, minidump_id, &size); + Concat(p, dumpFileExtension, &size); +#else + Concat(minidumpPath, descriptor.path(), &size); +#endif + + static XP_CHAR memoryReportLocalPath[XP_PATH_MAX]; + size = XP_PATH_MAX; +#ifndef XP_LINUX + p = Concat(memoryReportLocalPath, dump_path, &size); + p = Concat(p, XP_PATH_SEPARATOR, &size); + p = Concat(p, minidump_id, &size); +#else + p = Concat(memoryReportLocalPath, descriptor.path(), &size); + // Skip back past the .dmp extension + p -= 4; +#endif + Concat(p, memoryReportExtension, &size); + + if (memoryReportPath) { +#ifdef XP_WIN + CopyFile(memoryReportPath, memoryReportLocalPath, false); +#else + copy_file(memoryReportPath, memoryReportLocalPath); +#endif + } + + if (headlessClient) { + // Leave a marker indicating that there was a crash. + PlatformWriter markerFile(crashMarkerFilename); +#if defined(XP_WIN) + markerFile.WriteBuffer(reinterpret_cast<const char*>(minidumpPath), + 2*wcslen(minidumpPath)); +#elif defined(XP_UNIX) + markerFile.WriteBuffer(minidumpPath, my_strlen(minidumpPath)); +#endif + } + + char oomAllocationSizeBuffer[32] = ""; + if (gOOMAllocationSize) { + XP_STOA(gOOMAllocationSize, oomAllocationSizeBuffer, 10); + } + + char texturesSizeBuffer[32] = ""; + if (gTexturesSize) { + XP_STOA(gTexturesSize, texturesSizeBuffer, 10); + } + + char numOfPendingIPCBuffer[32] = ""; + char topPendingIPCCountBuffer[32] = ""; + char topPendingIPCTypeBuffer[11] = "0x"; + if (gNumOfPendingIPC) { + XP_STOA(gNumOfPendingIPC, numOfPendingIPCBuffer, 10); + if (gTopPendingIPCCount) { + XP_STOA(gTopPendingIPCCount, topPendingIPCCountBuffer, 10); + } + if (gTopPendingIPCType) { + XP_STOA(gTopPendingIPCType, &topPendingIPCTypeBuffer[2], 16); + } + } + + // calculate time since last crash (if possible), and store + // the time of this crash. + time_t crashTime; +#ifdef XP_LINUX + struct kernel_timeval tv; + sys_gettimeofday(&tv, nullptr); + crashTime = tv.tv_sec; +#else + crashTime = time(nullptr); +#endif + time_t timeSinceLastCrash = 0; + // stringified versions of the above + char crashTimeString[32]; + char timeSinceLastCrashString[32]; + + XP_TTOA(crashTime, crashTimeString, 10); + if (lastCrashTime != 0) { + timeSinceLastCrash = crashTime - lastCrashTime; + XP_TTOA(timeSinceLastCrash, timeSinceLastCrashString, 10); + } + // write crash time to file + if (lastCrashTimeFilename[0] != 0) { + PlatformWriter lastCrashFile(lastCrashTimeFilename); + WriteString(lastCrashFile, crashTimeString); + } + + bool ignored = false; + double uptimeTS = (TimeStamp::NowLoRes()- + TimeStamp::ProcessCreation(ignored)).ToSecondsSigDigits(); + char uptimeTSString[64]; + SimpleNoCLibDtoA(uptimeTS, uptimeTSString, sizeof(uptimeTSString)); + + // Write crash event file. + + // Minidump IDs are UUIDs (36) + NULL. + static char id_ascii[37]; +#ifdef XP_LINUX + const char * index = strrchr(descriptor.path(), '/'); + MOZ_ASSERT(index); + MOZ_ASSERT(strlen(index) == 1 + 36 + 4); // "/" + UUID + ".dmp" + for (uint32_t i = 0; i < 36; i++) { + id_ascii[i] = *(index + 1 + i); + } +#else + MOZ_ASSERT(XP_STRLEN(minidump_id) == 36); + for (uint32_t i = 0; i < 36; i++) { + id_ascii[i] = *((char *)(minidump_id + i)); + } +#endif + + { + PlatformWriter apiData; + PlatformWriter eventFile; + + if (eventsDirectory) { + static XP_CHAR crashEventPath[XP_PATH_MAX]; + int size = XP_PATH_MAX; + XP_CHAR* p; + p = Concat(crashEventPath, eventsDirectory, &size); + p = Concat(p, XP_PATH_SEPARATOR, &size); +#ifdef XP_LINUX + p = Concat(p, id_ascii, &size); +#else + p = Concat(p, minidump_id, &size); +#endif + + eventFile.Open(crashEventPath); + WriteLiteral(eventFile, kCrashMainID); + WriteString(eventFile, crashTimeString); + WriteLiteral(eventFile, "\n"); + WriteString(eventFile, id_ascii); + WriteLiteral(eventFile, "\n"); + if (currentSessionId) { + WriteAnnotation(eventFile, "TelemetrySessionId", currentSessionId); + } + if (crashEventAPIData) { + eventFile.WriteBuffer(crashEventAPIData->get(), crashEventAPIData->Length()); + } + } + + if (!crashReporterAPIData->IsEmpty()) { + // write out API data +#ifdef XP_LINUX + OpenAPIData(apiData, descriptor.path()); +#else + OpenAPIData(apiData, dump_path, minidump_id); +#endif + apiData.WriteBuffer(crashReporterAPIData->get(), crashReporterAPIData->Length()); + } + WriteAnnotation(apiData, "CrashTime", crashTimeString); + WriteAnnotation(eventFile, "CrashTime", crashTimeString); + + WriteAnnotation(apiData, "UptimeTS", uptimeTSString); + WriteAnnotation(eventFile, "UptimeTS", uptimeTSString); + + if (timeSinceLastCrash != 0) { + WriteAnnotation(apiData, "SecondsSinceLastCrash", + timeSinceLastCrashString); + WriteAnnotation(eventFile, "SecondsSinceLastCrash", + timeSinceLastCrashString); + } + if (isGarbageCollecting) { + WriteAnnotation(apiData, "IsGarbageCollecting", + isGarbageCollecting ? "1" : "0"); + WriteAnnotation(eventFile, "IsGarbageCollecting", + isGarbageCollecting ? "1" : "0"); + } + + char buffer[128]; + + if (eventloopNestingLevel > 0) { + XP_STOA(eventloopNestingLevel, buffer, 10); + WriteAnnotation(apiData, "EventLoopNestingLevel", buffer); + WriteAnnotation(eventFile, "EventLoopNestingLevel", buffer); + } + +#ifdef XP_WIN + if (gBreakpadReservedVM) { + _ui64toa(uintptr_t(gBreakpadReservedVM), buffer, 10); + WriteAnnotation(apiData, "BreakpadReserveAddress", buffer); + _ui64toa(kReserveSize, buffer, 10); + WriteAnnotation(apiData, "BreakpadReserveSize", buffer); + } + +#ifdef HAS_DLL_BLOCKLIST + if (apiData.Valid()) { + DllBlocklist_WriteNotes(apiData.Handle()); + DllBlocklist_WriteNotes(eventFile.Handle()); + } +#endif + WriteGlobalMemoryStatus(&apiData, &eventFile); +#endif // XP_WIN + + if (gMozCrashReason) { + WriteAnnotation(apiData, "MozCrashReason", gMozCrashReason); + WriteAnnotation(eventFile, "MozCrashReason", gMozCrashReason); + } + + if (oomAllocationSizeBuffer[0]) { + WriteAnnotation(apiData, "OOMAllocationSize", oomAllocationSizeBuffer); + WriteAnnotation(eventFile, "OOMAllocationSize", oomAllocationSizeBuffer); + } + + if (texturesSizeBuffer[0]) { + WriteAnnotation(apiData, "TextureUsage", texturesSizeBuffer); + WriteAnnotation(eventFile, "TextureUsage", texturesSizeBuffer); + } + + if (numOfPendingIPCBuffer[0]) { + WriteAnnotation(apiData, "NumberOfPendingIPC", numOfPendingIPCBuffer); + WriteAnnotation(eventFile, "NumberOfPendingIPC", numOfPendingIPCBuffer); + if (topPendingIPCCountBuffer[0]) { + WriteAnnotation(apiData, "TopPendingIPCCount", topPendingIPCCountBuffer); + WriteAnnotation(eventFile, "TopPendingIPCCount", topPendingIPCCountBuffer); + } + if (gTopPendingIPCName) { + WriteAnnotation(apiData, "TopPendingIPCName", gTopPendingIPCName); + WriteAnnotation(eventFile, "TopPendingIPCName", gTopPendingIPCName); + } + if (topPendingIPCTypeBuffer[2]) { + WriteAnnotation(apiData, "TopPendingIPCType", topPendingIPCTypeBuffer); + WriteAnnotation(eventFile, "TopPendingIPCType", topPendingIPCTypeBuffer); + } + } + + if (memoryReportPath) { + WriteLiteral(apiData, "ContainsMemoryReport=1\n"); + WriteLiteral(eventFile, "ContainsMemoryReport=1\n"); + } + } + +#ifdef XP_WIN + if (!doReport) { + TerminateProcess(GetCurrentProcess(), 1); + return returnValue; + } + + XP_CHAR cmdLine[CMDLINE_SIZE]; + size = CMDLINE_SIZE; + p = Concat(cmdLine, L"\"", &size); + p = Concat(p, crashReporterPath, &size); + p = Concat(p, L"\" \"", &size); + p = Concat(p, minidumpPath, &size); + Concat(p, L"\"", &size); + + STARTUPINFO si; + PROCESS_INFORMATION pi; + + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + si.dwFlags = STARTF_USESHOWWINDOW; + si.wShowWindow = SW_SHOWNORMAL; + ZeroMemory(&pi, sizeof(pi)); + + if (CreateProcess(nullptr, (LPWSTR)cmdLine, nullptr, nullptr, FALSE, 0, + nullptr, nullptr, &si, &pi)) { + CloseHandle( pi.hProcess ); + CloseHandle( pi.hThread ); + } + // we're not really in a position to do anything if the CreateProcess fails + TerminateProcess(GetCurrentProcess(), 1); +#elif defined(XP_UNIX) + if (!doReport) { + return returnValue; + } + +#ifdef XP_MACOSX + char* const my_argv[] = { + crashReporterPath, + minidumpPath, + nullptr + }; + + char **env = nullptr; + char ***nsEnv = _NSGetEnviron(); + if (nsEnv) + env = *nsEnv; + int result = posix_spawnp(nullptr, + my_argv[0], + nullptr, + &spawnattr, + my_argv, + env); + + if (result != 0) + return false; + +#else // !XP_MACOSX + pid_t pid = sys_fork(); + + if (pid == -1) + return false; + else if (pid == 0) { +#if !defined(MOZ_WIDGET_ANDROID) + // need to clobber this, as libcurl might load NSS, + // and we want it to load the system NSS. + unsetenv("LD_LIBRARY_PATH"); + Unused << execl(crashReporterPath, + crashReporterPath, minidumpPath, (char*)0); +#else + // Invoke the reportCrash activity using am + if (androidUserSerial) { + Unused << execlp("/system/bin/am", + "/system/bin/am", + "start", + "--user", androidUserSerial, + "-a", "org.mozilla.gecko.reportCrash", + "-n", crashReporterPath, + "--es", "minidumpPath", minidumpPath, + "--ez", "minidumpSuccess", succeeded ? "true" : "false", + (char*)0); + } else { + Unused << execlp("/system/bin/am", + "/system/bin/am", + "start", + "-a", "org.mozilla.gecko.reportCrash", + "-n", crashReporterPath, + "--es", "minidumpPath", minidumpPath, + "--ez", "minidumpSuccess", succeeded ? "true" : "false", + (char*)0); + } +#endif + _exit(1); +#ifdef MOZ_WIDGET_ANDROID + } else { + // We need to wait on the 'am start' command above to finish, otherwise everything will + // be killed by the ActivityManager as soon as the signal handler exits + int status; + Unused << HANDLE_EINTR(sys_waitpid(pid, &status, __WALL)); +#endif + } +#endif // XP_MACOSX +#endif // XP_UNIX + + return returnValue; +} + +#if defined(XP_MACOSX) || defined(__ANDROID__) || defined(XP_LINUX) +static size_t +EnsureTrailingSlash(XP_CHAR* aBuf, size_t aBufLen) +{ + size_t len = XP_STRLEN(aBuf); + if ((len + 1) < aBufLen + && len > 0 + && aBuf[len - 1] != XP_PATH_SEPARATOR_CHAR) { + aBuf[len] = XP_PATH_SEPARATOR_CHAR; + ++len; + aBuf[len] = 0; + } + return len; +} +#endif + +#if defined(XP_WIN32) + +static size_t +BuildTempPath(wchar_t* aBuf, size_t aBufLen) +{ + // first figure out buffer size + DWORD pathLen = GetTempPath(0, nullptr); + if (pathLen == 0 || pathLen >= aBufLen) { + return 0; + } + + return GetTempPath(pathLen, aBuf); +} + +static size_t +BuildTempPath(char16_t* aBuf, size_t aBufLen) +{ + return BuildTempPath(reinterpret_cast<wchar_t*>(aBuf), aBufLen); +} + +#elif defined(XP_MACOSX) + +static size_t +BuildTempPath(char* aBuf, size_t aBufLen) +{ + if (aBufLen < PATH_MAX) { + return 0; + } + + FSRef fsRef; + OSErr err = FSFindFolder(kUserDomain, kTemporaryFolderType, + kCreateFolder, &fsRef); + if (err != noErr) { + return 0; + } + + OSStatus status = FSRefMakePath(&fsRef, (UInt8*)aBuf, PATH_MAX); + if (status != noErr) { + return 0; + } + + return EnsureTrailingSlash(aBuf, aBufLen); +} + +#elif defined(__ANDROID__) + +static size_t +BuildTempPath(char* aBuf, size_t aBufLen) +{ + // GeckoAppShell or Gonk's init.rc sets this in the environment + const char *tempenv = PR_GetEnv("TMPDIR"); + if (!tempenv) { + return false; + } + int size = (int)aBufLen; + Concat(aBuf, tempenv, &size); + return EnsureTrailingSlash(aBuf, aBufLen); +} + +#elif defined(XP_UNIX) + +static size_t +BuildTempPath(char* aBuf, size_t aBufLen) +{ + const char *tempenv = PR_GetEnv("TMPDIR"); + const char *tmpPath = "/tmp/"; + if (!tempenv) { + tempenv = tmpPath; + } + int size = (int)aBufLen; + Concat(aBuf, tempenv, &size); + return EnsureTrailingSlash(aBuf, aBufLen); +} + +#else +#error "Implement this for your platform" +#endif + +template <typename CharT, size_t N> +static size_t +BuildTempPath(CharT (&aBuf)[N]) +{ + static_assert(N >= XP_PATH_MAX, "char array length is too small"); + return BuildTempPath(&aBuf[0], N); +} + +template <typename PathStringT> +static bool +BuildTempPath(PathStringT& aResult) +{ + aResult.SetLength(XP_PATH_MAX); + size_t actualLen = BuildTempPath(aResult.BeginWriting(), XP_PATH_MAX); + if (!actualLen) { + return false; + } + aResult.SetLength(actualLen); + return true; +} + +static void +PrepareChildExceptionTimeAnnotations() +{ + MOZ_ASSERT(!XRE_IsParentProcess()); + static XP_CHAR tempPath[XP_PATH_MAX] = {0}; + + // Get the temp path + int charsAvailable = XP_PATH_MAX; + XP_CHAR* p = tempPath; +#if (defined(XP_MACOSX) || defined(XP_WIN)) + if (!childProcessTmpDir || childProcessTmpDir->empty()) { + return; + } + p = Concat(p, childProcessTmpDir->c_str(), &charsAvailable); + // Ensure that this path ends with a path separator + if (p > tempPath && *(p - 1) != XP_PATH_SEPARATOR_CHAR) { + p = Concat(p, XP_PATH_SEPARATOR, &charsAvailable); + } +#else + size_t tempPathLen = BuildTempPath(tempPath); + if (!tempPathLen) { + return; + } + p += tempPathLen; + charsAvailable -= tempPathLen; +#endif + + // Generate and append the file name + p = Concat(p, childCrashAnnotationBaseName, &charsAvailable); + XP_CHAR pidBuffer[32] = XP_TEXT(""); +#if defined(XP_WIN32) + _ui64tow(GetCurrentProcessId(), pidBuffer, 10); +#else + XP_STOA(getpid(), pidBuffer, 10); +#endif + p = Concat(p, pidBuffer, &charsAvailable); + + // Now open the file... + PlatformWriter apiData; + OpenAPIData(apiData, tempPath); + + // ...and write out any annotations. These must be escaped if necessary + // (but don't call EscapeAnnotation here, because it touches the heap). +#ifdef XP_WIN + WriteGlobalMemoryStatus(&apiData, nullptr); +#endif + + char oomAllocationSizeBuffer[32] = ""; + if (gOOMAllocationSize) { + XP_STOA(gOOMAllocationSize, oomAllocationSizeBuffer, 10); + } + + if (oomAllocationSizeBuffer[0]) { + WriteAnnotation(apiData, "OOMAllocationSize", oomAllocationSizeBuffer); + } + + if (gMozCrashReason) { + WriteAnnotation(apiData, "MozCrashReason", gMozCrashReason); + } + + char numOfPendingIPCBuffer[32] = ""; + char topPendingIPCCountBuffer[32] = ""; + char topPendingIPCTypeBuffer[11] = "0x"; + if (gNumOfPendingIPC) { + XP_STOA(gNumOfPendingIPC, numOfPendingIPCBuffer, 10); + if (gTopPendingIPCCount) { + XP_STOA(gTopPendingIPCCount, topPendingIPCCountBuffer, 10); + } + if (gTopPendingIPCType) { + XP_STOA(gTopPendingIPCType, &topPendingIPCTypeBuffer[2], 16); + } + } + + if (numOfPendingIPCBuffer[0]) { + WriteAnnotation(apiData, "NumberOfPendingIPC", numOfPendingIPCBuffer); + if (topPendingIPCCountBuffer[0]) { + WriteAnnotation(apiData, "TopPendingIPCCount", topPendingIPCCountBuffer); + } + if (gTopPendingIPCName) { + WriteAnnotation(apiData, "TopPendingIPCName", gTopPendingIPCName); + } + if (topPendingIPCTypeBuffer[2]) { + WriteAnnotation(apiData, "TopPendingIPCType", topPendingIPCTypeBuffer); + } + } +} + +#ifdef XP_WIN +static void +ReserveBreakpadVM() +{ + if (!gBreakpadReservedVM) { + gBreakpadReservedVM = VirtualAlloc(nullptr, kReserveSize, MEM_RESERVE, + PAGE_NOACCESS); + } +} + +static void +FreeBreakpadVM() +{ + if (gBreakpadReservedVM) { + VirtualFree(gBreakpadReservedVM, 0, MEM_RELEASE); + } +} + +/** + * Filters out floating point exceptions which are handled by nsSigHandlers.cpp + * and should not be handled as crashes. + * + * Also calls FreeBreakpadVM if appropriate. + */ +static bool FPEFilter(void* context, EXCEPTION_POINTERS* exinfo, + MDRawAssertionInfo* assertion) +{ + if (!exinfo) { + mozilla::IOInterposer::Disable(); + FreeBreakpadVM(); + return true; + } + + PEXCEPTION_RECORD e = (PEXCEPTION_RECORD)exinfo->ExceptionRecord; + switch (e->ExceptionCode) { + case STATUS_FLOAT_DENORMAL_OPERAND: + case STATUS_FLOAT_DIVIDE_BY_ZERO: + case STATUS_FLOAT_INEXACT_RESULT: + case STATUS_FLOAT_INVALID_OPERATION: + case STATUS_FLOAT_OVERFLOW: + case STATUS_FLOAT_STACK_CHECK: + case STATUS_FLOAT_UNDERFLOW: + case STATUS_FLOAT_MULTIPLE_FAULTS: + case STATUS_FLOAT_MULTIPLE_TRAPS: + return false; // Don't write minidump, continue exception search + } + mozilla::IOInterposer::Disable(); + FreeBreakpadVM(); + return true; +} + +static bool +ChildFPEFilter(void* context, EXCEPTION_POINTERS* exinfo, + MDRawAssertionInfo* assertion) +{ + bool result = FPEFilter(context, exinfo, assertion); + if (result) { + PrepareChildExceptionTimeAnnotations(); + } + return result; +} + +MINIDUMP_TYPE GetMinidumpType() +{ + MINIDUMP_TYPE minidump_type = MiniDumpNormal; + + // Try to determine what version of dbghelp.dll we're using. + // MinidumpWithFullMemoryInfo is only available in 6.1.x or newer. + + DWORD version_size = GetFileVersionInfoSizeW(L"dbghelp.dll", nullptr); + if (version_size > 0) { + std::vector<BYTE> buffer(version_size); + if (GetFileVersionInfoW(L"dbghelp.dll", + 0, + version_size, + &buffer[0])) { + UINT len; + VS_FIXEDFILEINFO* file_info; + VerQueryValue(&buffer[0], L"\\", (void**)&file_info, &len); + WORD major = HIWORD(file_info->dwFileVersionMS), + minor = LOWORD(file_info->dwFileVersionMS), + revision = HIWORD(file_info->dwFileVersionLS); + if (major > 6 || (major == 6 && minor > 1) || + (major == 6 && minor == 1 && revision >= 7600)) { + minidump_type = MiniDumpWithFullMemoryInfo; + } + } + } + + const char* e = PR_GetEnv("MOZ_CRASHREPORTER_FULLDUMP"); + if (e && *e) { + minidump_type = MiniDumpWithFullMemory; + } + + return minidump_type; +} + +#endif // XP_WIN + +static bool ShouldReport() +{ + // this environment variable prevents us from launching + // the crash reporter client + const char *envvar = PR_GetEnv("MOZ_CRASHREPORTER_NO_REPORT"); + if (envvar && *envvar) { + return false; + } + + envvar = PR_GetEnv("MOZ_CRASHREPORTER_FULLDUMP"); + if (envvar && *envvar) { + return false; + } + + return true; +} + +static bool +Filter(void* context) +{ + mozilla::IOInterposer::Disable(); + return true; +} + +static bool +ChildFilter(void* context) +{ + bool result = Filter(context); + if (result) { + PrepareChildExceptionTimeAnnotations(); + } + return result; +} + +void TerminateHandler() +{ + MOZ_CRASH("Unhandled exception"); +} + +nsresult SetExceptionHandler(nsIFile* aXREDirectory, + bool force/*=false*/) +{ + if (gExceptionHandler) + return NS_ERROR_ALREADY_INITIALIZED; + +#if !defined(DEBUG) || defined(MOZ_WIDGET_GONK) + // In non-debug builds, enable the crash reporter by default, and allow + // disabling it with the MOZ_CRASHREPORTER_DISABLE environment variable. + // Also enable it by default in debug gonk builds as it is difficult to + // set environment on startup. + const char *envvar = PR_GetEnv("MOZ_CRASHREPORTER_DISABLE"); + if (envvar && *envvar && !force) + return NS_OK; +#else + // In debug builds, disable the crash reporter by default, and allow to + // enable it with the MOZ_CRASHREPORTER environment variable. + const char *envvar = PR_GetEnv("MOZ_CRASHREPORTER"); + if ((!envvar || !*envvar) && !force) + return NS_OK; +#endif + +#if defined(MOZ_WIDGET_GONK) + doReport = false; + headlessClient = true; +#elif defined(XP_WIN) + doReport = ShouldReport(); +#else + // this environment variable prevents us from launching + // the crash reporter client + doReport = ShouldReport(); +#endif + + // allocate our strings + crashReporterAPIData = new nsCString(); + crashEventAPIData = new nsCString(); + + NS_ASSERTION(!crashReporterAPILock, "Shouldn't have a lock yet"); + crashReporterAPILock = new Mutex("crashReporterAPILock"); + NS_ASSERTION(!notesFieldLock, "Shouldn't have a lock yet"); + notesFieldLock = new Mutex("notesFieldLock"); + + crashReporterAPIData_Hash = + new nsDataHashtable<nsCStringHashKey,nsCString>(); + NS_ENSURE_TRUE(crashReporterAPIData_Hash, NS_ERROR_OUT_OF_MEMORY); + + notesField = new nsCString(); + NS_ENSURE_TRUE(notesField, NS_ERROR_OUT_OF_MEMORY); + + if (!headlessClient) { + // locate crashreporter executable + nsCOMPtr<nsIFile> exePath; + nsresult rv = aXREDirectory->Clone(getter_AddRefs(exePath)); + NS_ENSURE_SUCCESS(rv, rv); + +#if defined(XP_MACOSX) + exePath->SetNativeLeafName(NS_LITERAL_CSTRING("MacOS")); + exePath->Append(NS_LITERAL_STRING("crashreporter.app")); + exePath->Append(NS_LITERAL_STRING("Contents")); + exePath->Append(NS_LITERAL_STRING("MacOS")); +#endif + + exePath->AppendNative(NS_LITERAL_CSTRING(CRASH_REPORTER_FILENAME)); + +#ifdef XP_WIN32 + nsString crashReporterPath_temp; + + exePath->GetPath(crashReporterPath_temp); + crashReporterPath = reinterpret_cast<wchar_t*>(ToNewUnicode(crashReporterPath_temp)); +#elif !defined(__ANDROID__) + nsCString crashReporterPath_temp; + + exePath->GetNativePath(crashReporterPath_temp); + crashReporterPath = ToNewCString(crashReporterPath_temp); +#else + // On Android, we launch using the application package name instead of a + // filename, so use the dynamically set MOZ_ANDROID_PACKAGE_NAME, or fall + // back to the static ANDROID_PACKAGE_NAME. + const char* androidPackageName = PR_GetEnv("MOZ_ANDROID_PACKAGE_NAME"); + if (androidPackageName != nullptr) { + nsCString package(androidPackageName); + package.Append("/org.mozilla.gecko.CrashReporter"); + crashReporterPath = ToNewCString(package); + } else { + nsCString package(ANDROID_PACKAGE_NAME "/org.mozilla.gecko.CrashReporter"); + crashReporterPath = ToNewCString(package); + } +#endif + } + + // get temp path to use for minidump path +#if defined(XP_WIN32) + nsString tempPath; +#else + nsCString tempPath; +#endif + if (!BuildTempPath(tempPath)) { + return NS_ERROR_FAILURE; + } + +#ifdef XP_MACOSX + // Initialize spawn attributes, since this calls malloc. + if (posix_spawnattr_init(&spawnattr) != 0) { + return NS_ERROR_FAILURE; + } + + // Set spawn attributes. + size_t attr_count = ArrayLength(pref_cpu_types); + size_t attr_ocount = 0; + if (posix_spawnattr_setbinpref_np(&spawnattr, + attr_count, + pref_cpu_types, + &attr_ocount) != 0 || + attr_ocount != attr_count) { + posix_spawnattr_destroy(&spawnattr); + return NS_ERROR_FAILURE; + } +#endif + +#ifdef XP_WIN32 + ReserveBreakpadVM(); +#endif // XP_WIN32 + +#ifdef MOZ_WIDGET_ANDROID + androidUserSerial = getenv("MOZ_ANDROID_USER_SERIAL_NUMBER"); +#endif + + // Initialize the flag and mutex used to avoid dump processing + // once browser termination has begun. + NS_ASSERTION(!dumpSafetyLock, "Shouldn't have a lock yet"); + // Do not deallocate this lock while it is still possible for + // isSafeToDump to be tested on another thread. + dumpSafetyLock = new Mutex("dumpSafetyLock"); + MutexAutoLock lock(*dumpSafetyLock); + isSafeToDump = true; + + // now set the exception handler +#ifdef XP_LINUX + MinidumpDescriptor descriptor(tempPath.get()); +#endif + +#ifdef XP_WIN + previousUnhandledExceptionFilter = GetUnhandledExceptionFilter(); +#endif + + gExceptionHandler = new google_breakpad:: + ExceptionHandler( +#ifdef XP_LINUX + descriptor, +#elif defined(XP_WIN) + std::wstring(tempPath.get()), +#else + tempPath.get(), +#endif + +#ifdef XP_WIN + FPEFilter, +#else + Filter, +#endif + MinidumpCallback, + nullptr, +#ifdef XP_WIN32 + google_breakpad::ExceptionHandler::HANDLER_ALL, + GetMinidumpType(), + (const wchar_t*) nullptr, + nullptr); +#else + true +#ifdef XP_MACOSX + , nullptr +#endif +#ifdef XP_LINUX + , -1 +#endif + ); +#endif // XP_WIN32 + + if (!gExceptionHandler) + return NS_ERROR_OUT_OF_MEMORY; + +#ifdef XP_WIN + gExceptionHandler->set_handle_debug_exceptions(true); + +#ifdef _WIN64 + // Tell JS about the new filter before we disable SetUnhandledExceptionFilter + sUnhandledExceptionFilter = GetUnhandledExceptionFilter(); + if (sUnhandledExceptionFilter) + js::SetJitExceptionHandler(JitExceptionHandler); +#endif + + // protect the crash reporter from being unloaded + gBlockUnhandledExceptionFilter = true; + gKernel32Intercept.Init("kernel32.dll"); + bool ok = gKernel32Intercept.AddHook("SetUnhandledExceptionFilter", + reinterpret_cast<intptr_t>(patched_SetUnhandledExceptionFilter), + (void**) &stub_SetUnhandledExceptionFilter); + +#ifdef DEBUG + if (!ok) + printf_stderr ("SetUnhandledExceptionFilter hook failed; crash reporter is vulnerable.\n"); +#endif +#endif + + // store application start time + char timeString[32]; + time_t startupTime = time(nullptr); + XP_TTOA(startupTime, timeString, 10); + AnnotateCrashReport(NS_LITERAL_CSTRING("StartupTime"), + nsDependentCString(timeString)); + +#if defined(XP_MACOSX) + // On OS X, many testers like to see the OS crash reporting dialog + // since it offers immediate stack traces. We allow them to set + // a default to pass exceptions to the OS handler. + Boolean keyExistsAndHasValidFormat = false; + Boolean prefValue = ::CFPreferencesGetAppBooleanValue(CFSTR("OSCrashReporter"), + kCFPreferencesCurrentApplication, + &keyExistsAndHasValidFormat); + if (keyExistsAndHasValidFormat) + showOSCrashReporter = prefValue; +#endif + +#if defined(MOZ_WIDGET_ANDROID) + for (unsigned int i = 0; i < library_mappings.size(); i++) { + PageAllocator allocator; + auto_wasteful_vector<uint8_t, sizeof(MDGUID)> guid(&allocator); + FileID::ElfFileIdentifierFromMappedFile( + (void const *)library_mappings[i].start_address, guid); + gExceptionHandler->AddMappingInfo(library_mappings[i].name, + guid.data(), + library_mappings[i].start_address, + library_mappings[i].length, + library_mappings[i].file_offset); + } +#endif + + mozalloc_set_oom_abort_handler(AnnotateOOMAllocationSize); + + oldTerminateHandler = std::set_terminate(&TerminateHandler); + + return NS_OK; +} + +bool GetEnabled() +{ + return gExceptionHandler != nullptr; +} + +bool GetMinidumpPath(nsAString& aPath) +{ + if (!gExceptionHandler) + return false; + +#ifndef XP_LINUX + aPath = CONVERT_XP_CHAR_TO_UTF16(gExceptionHandler->dump_path().c_str()); +#else + aPath = CONVERT_XP_CHAR_TO_UTF16( + gExceptionHandler->minidump_descriptor().directory().c_str()); +#endif + return true; +} + +nsresult SetMinidumpPath(const nsAString& aPath) +{ + if (!gExceptionHandler) + return NS_ERROR_NOT_INITIALIZED; + +#ifdef XP_WIN32 + gExceptionHandler->set_dump_path(std::wstring(char16ptr_t(aPath.BeginReading()))); +#elif defined(XP_LINUX) + gExceptionHandler->set_minidump_descriptor( + MinidumpDescriptor(NS_ConvertUTF16toUTF8(aPath).BeginReading())); +#else + gExceptionHandler->set_dump_path(NS_ConvertUTF16toUTF8(aPath).BeginReading()); +#endif + return NS_OK; +} + +static nsresult +WriteDataToFile(nsIFile* aFile, const nsACString& data) +{ + PRFileDesc* fd; + nsresult rv = aFile->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE, 00600, &fd); + NS_ENSURE_SUCCESS(rv, rv); + + rv = NS_OK; + if (PR_Write(fd, data.Data(), data.Length()) == -1) { + rv = NS_ERROR_FAILURE; + } + PR_Close(fd); + return rv; +} + +static nsresult +GetFileContents(nsIFile* aFile, nsACString& data) +{ + PRFileDesc* fd; + nsresult rv = aFile->OpenNSPRFileDesc(PR_RDONLY, 0, &fd); + NS_ENSURE_SUCCESS(rv, rv); + + rv = NS_OK; + int32_t filesize = PR_Available(fd); + if (filesize <= 0) { + rv = NS_ERROR_FILE_NOT_FOUND; + } + else { + data.SetLength(filesize); + if (PR_Read(fd, data.BeginWriting(), filesize) == -1) { + rv = NS_ERROR_FAILURE; + } + } + PR_Close(fd); + return rv; +} + +// Function typedef for initializing a piece of data that we +// don't already have. +typedef nsresult (*InitDataFunc)(nsACString&); + +// Attempt to read aFile's contents into aContents, if aFile +// does not exist, create it and initialize its contents +// by calling aInitFunc for the data. +static nsresult +GetOrInit(nsIFile* aDir, const nsACString& filename, + nsACString& aContents, InitDataFunc aInitFunc) +{ + bool exists; + + nsCOMPtr<nsIFile> dataFile; + nsresult rv = aDir->Clone(getter_AddRefs(dataFile)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = dataFile->AppendNative(filename); + NS_ENSURE_SUCCESS(rv, rv); + + rv = dataFile->Exists(&exists); + NS_ENSURE_SUCCESS(rv, rv); + + if (!exists) { + if (aInitFunc) { + // get the initial value and write it to the file + rv = aInitFunc(aContents); + NS_ENSURE_SUCCESS(rv, rv); + rv = WriteDataToFile(dataFile, aContents); + } + else { + // didn't pass in an init func + rv = NS_ERROR_FAILURE; + } + } + else { + // just get the file's contents + rv = GetFileContents(dataFile, aContents); + } + + return rv; +} + +// Init the "install time" data. We're taking an easy way out here +// and just setting this to "the time when this version was first run". +static nsresult +InitInstallTime(nsACString& aInstallTime) +{ + time_t t = time(nullptr); + char buf[16]; + SprintfLiteral(buf, "%ld", t); + aInstallTime = buf; + + return NS_OK; +} + +// Ensure a directory exists and create it if missing. +static nsresult +EnsureDirectoryExists(nsIFile* dir) +{ + nsresult rv = dir->Create(nsIFile::DIRECTORY_TYPE, 0700); + + if (NS_WARN_IF(NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS)) { + return rv; + } + + return NS_OK; +} + +// Annotate the crash report with a Unique User ID and time +// since install. Also do some prep work for recording +// time since last crash, which must be calculated at +// crash time. +// If any piece of data doesn't exist, initialize it first. +nsresult SetupExtraData(nsIFile* aAppDataDirectory, + const nsACString& aBuildID) +{ + nsCOMPtr<nsIFile> dataDirectory; + nsresult rv = aAppDataDirectory->Clone(getter_AddRefs(dataDirectory)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = dataDirectory->AppendNative(NS_LITERAL_CSTRING("Crash Reports")); + NS_ENSURE_SUCCESS(rv, rv); + + EnsureDirectoryExists(dataDirectory); + +#if defined(XP_WIN32) + nsAutoString dataDirEnv(NS_LITERAL_STRING("MOZ_CRASHREPORTER_DATA_DIRECTORY=")); + + nsAutoString dataDirectoryPath; + rv = dataDirectory->GetPath(dataDirectoryPath); + NS_ENSURE_SUCCESS(rv, rv); + + dataDirEnv.Append(dataDirectoryPath); + + _wputenv(dataDirEnv.get()); +#else + // Save this path in the environment for the crash reporter application. + nsAutoCString dataDirEnv("MOZ_CRASHREPORTER_DATA_DIRECTORY="); + + nsAutoCString dataDirectoryPath; + rv = dataDirectory->GetNativePath(dataDirectoryPath); + NS_ENSURE_SUCCESS(rv, rv); + + dataDirEnv.Append(dataDirectoryPath); + + char* env = ToNewCString(dataDirEnv); + NS_ENSURE_TRUE(env, NS_ERROR_OUT_OF_MEMORY); + + PR_SetEnv(env); +#endif + + nsAutoCString data; + if(NS_SUCCEEDED(GetOrInit(dataDirectory, + NS_LITERAL_CSTRING("InstallTime") + aBuildID, + data, InitInstallTime))) + AnnotateCrashReport(NS_LITERAL_CSTRING("InstallTime"), data); + + // this is a little different, since we can't init it with anything, + // since it's stored at crash time, and we can't annotate the + // crash report with the stored value, since we really want + // (now - LastCrash), so we just get a value if it exists, + // and store it in a time_t value. + if(NS_SUCCEEDED(GetOrInit(dataDirectory, NS_LITERAL_CSTRING("LastCrash"), + data, nullptr))) { + lastCrashTime = (time_t)atol(data.get()); + } + + // not really the best place to init this, but I have the path I need here + nsCOMPtr<nsIFile> lastCrashFile; + rv = dataDirectory->Clone(getter_AddRefs(lastCrashFile)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = lastCrashFile->AppendNative(NS_LITERAL_CSTRING("LastCrash")); + NS_ENSURE_SUCCESS(rv, rv); + memset(lastCrashTimeFilename, 0, sizeof(lastCrashTimeFilename)); + +#if defined(XP_WIN32) + nsAutoString filename; + rv = lastCrashFile->GetPath(filename); + NS_ENSURE_SUCCESS(rv, rv); + + if (filename.Length() < XP_PATH_MAX) + wcsncpy(lastCrashTimeFilename, filename.get(), filename.Length()); +#else + nsAutoCString filename; + rv = lastCrashFile->GetNativePath(filename); + NS_ENSURE_SUCCESS(rv, rv); + + if (filename.Length() < XP_PATH_MAX) + strncpy(lastCrashTimeFilename, filename.get(), filename.Length()); +#endif + + if (headlessClient) { + nsCOMPtr<nsIFile> markerFile; + rv = dataDirectory->Clone(getter_AddRefs(markerFile)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = markerFile->AppendNative(NS_LITERAL_CSTRING("LastCrashFilename")); + NS_ENSURE_SUCCESS(rv, rv); + memset(crashMarkerFilename, 0, sizeof(crashMarkerFilename)); + +#if defined(XP_WIN32) + nsAutoString markerFilename; + rv = markerFile->GetPath(markerFilename); + NS_ENSURE_SUCCESS(rv, rv); + + if (markerFilename.Length() < XP_PATH_MAX) + wcsncpy(crashMarkerFilename, markerFilename.get(), + markerFilename.Length()); +#else + nsAutoCString markerFilename; + rv = markerFile->GetNativePath(markerFilename); + NS_ENSURE_SUCCESS(rv, rv); + + if (markerFilename.Length() < XP_PATH_MAX) + strncpy(crashMarkerFilename, markerFilename.get(), + markerFilename.Length()); +#endif + } + + return NS_OK; +} + +static void OOPDeinit(); + +nsresult UnsetExceptionHandler() +{ + if (isSafeToDump) { + MutexAutoLock lock(*dumpSafetyLock); + isSafeToDump = false; + } + +#ifdef XP_WIN + // allow SetUnhandledExceptionFilter + gBlockUnhandledExceptionFilter = false; +#endif + + delete gExceptionHandler; + + // do this here in the unlikely case that we succeeded in allocating + // our strings but failed to allocate gExceptionHandler. + delete crashReporterAPIData_Hash; + crashReporterAPIData_Hash = nullptr; + + delete crashReporterAPILock; + crashReporterAPILock = nullptr; + + delete notesFieldLock; + notesFieldLock = nullptr; + + delete crashReporterAPIData; + crashReporterAPIData = nullptr; + + delete crashEventAPIData; + crashEventAPIData = nullptr; + + delete notesField; + notesField = nullptr; + + delete lastRunCrashID; + lastRunCrashID = nullptr; + + if (pendingDirectory) { + free(pendingDirectory); + pendingDirectory = nullptr; + } + + if (crashReporterPath) { + free(crashReporterPath); + crashReporterPath = nullptr; + } + + if (eventsDirectory) { + free(eventsDirectory); + eventsDirectory = nullptr; + } + + if (currentSessionId) { + free(currentSessionId); + currentSessionId = nullptr; + } + + if (memoryReportPath) { + free(memoryReportPath); + memoryReportPath = nullptr; + } + +#ifdef XP_MACOSX + posix_spawnattr_destroy(&spawnattr); +#endif + + if (!gExceptionHandler) + return NS_ERROR_NOT_INITIALIZED; + + gExceptionHandler = nullptr; + + OOPDeinit(); + + delete dumpSafetyLock; + dumpSafetyLock = nullptr; + + std::set_terminate(oldTerminateHandler); + + return NS_OK; +} + +static void ReplaceChar(nsCString& str, const nsACString& character, + const nsACString& replacement) +{ + nsCString::const_iterator iter, end; + + str.BeginReading(iter); + str.EndReading(end); + + while (FindInReadable(character, iter, end)) { + nsCString::const_iterator start; + str.BeginReading(start); + int32_t pos = end - start; + str.Replace(pos - 1, 1, replacement); + + str.BeginReading(iter); + iter.advance(pos + replacement.Length() - 1); + str.EndReading(end); + } +} + +static bool DoFindInReadable(const nsACString& str, const nsACString& value) +{ + nsACString::const_iterator start, end; + str.BeginReading(start); + str.EndReading(end); + + return FindInReadable(value, start, end); +} + +static bool +IsInWhitelist(const nsACString& key) +{ + for (size_t i = 0; i < ArrayLength(kCrashEventAnnotations); ++i) { + if (key.EqualsASCII(kCrashEventAnnotations[i])) { + return true; + } + } + return false; +} + +// This function is miscompiled with MSVC 2005/2008 when PGO is on. +#ifdef _MSC_VER +#pragma optimize("", off) +#endif +static nsresult +EscapeAnnotation(const nsACString& key, const nsACString& data, nsCString& escapedData) +{ + if (DoFindInReadable(key, NS_LITERAL_CSTRING("=")) || + DoFindInReadable(key, NS_LITERAL_CSTRING("\n"))) + return NS_ERROR_INVALID_ARG; + + if (DoFindInReadable(data, NS_LITERAL_CSTRING("\0"))) + return NS_ERROR_INVALID_ARG; + + escapedData = data; + + // escape backslashes + ReplaceChar(escapedData, NS_LITERAL_CSTRING("\\"), + NS_LITERAL_CSTRING("\\\\")); + // escape newlines + ReplaceChar(escapedData, NS_LITERAL_CSTRING("\n"), + NS_LITERAL_CSTRING("\\n")); + return NS_OK; +} +#ifdef _MSC_VER +#pragma optimize("", on) +#endif + +class DelayedNote +{ + public: + DelayedNote(const nsACString& aKey, const nsACString& aData) + : mKey(aKey), mData(aData), mType(Annotation) {} + + explicit DelayedNote(const nsACString& aData) + : mData(aData), mType(AppNote) {} + + void Run() + { + if (mType == Annotation) { + AnnotateCrashReport(mKey, mData); + } else { + AppendAppNotesToCrashReport(mData); + } + } + + private: + nsCString mKey; + nsCString mData; + enum AnnotationType { Annotation, AppNote } mType; +}; + +static void +EnqueueDelayedNote(DelayedNote* aNote) +{ + if (!gDelayedAnnotations) { + gDelayedAnnotations = new nsTArray<nsAutoPtr<DelayedNote> >(); + } + gDelayedAnnotations->AppendElement(aNote); +} + +class CrashReporterHelperRunnable : public Runnable { +public: + explicit CrashReporterHelperRunnable(const nsACString& aKey, + const nsACString& aData) + : mKey(aKey) + , mData(aData) + , mAppendAppNotes(false) + {} + explicit CrashReporterHelperRunnable(const nsACString& aData) + : mKey() + , mData(aData) + , mAppendAppNotes(true) + {} + + NS_IMETHOD Run() override; + +private: + nsCString mKey; + nsCString mData; + bool mAppendAppNotes; +}; + +nsresult AnnotateCrashReport(const nsACString& key, const nsACString& data) +{ + if (!GetEnabled()) + return NS_ERROR_NOT_INITIALIZED; + + nsCString escapedData; + nsresult rv = EscapeAnnotation(key, data, escapedData); + if (NS_FAILED(rv)) + return rv; + + if (!XRE_IsParentProcess()) { + // The newer CrashReporterClient can be used from any thread. + if (RefPtr<CrashReporterClient> client = CrashReporterClient::GetSingleton()) { + client->AnnotateCrashReport(nsCString(key), escapedData); + return NS_OK; + } + + // Otherwise, we have to handle this on the main thread since we will go + // through IPDL. + if (!NS_IsMainThread()) { + // Child process needs to handle this in the main thread: + nsCOMPtr<nsIRunnable> r = new CrashReporterHelperRunnable(key, data); + NS_DispatchToMainThread(r); + return NS_OK; + } + + MOZ_ASSERT(NS_IsMainThread()); + PCrashReporterChild* reporter = CrashReporterChild::GetCrashReporter(); + if (!reporter) { + EnqueueDelayedNote(new DelayedNote(key, data)); + return NS_OK; + } + if (!reporter->SendAnnotateCrashReport(nsCString(key), escapedData)) + return NS_ERROR_FAILURE; + return NS_OK; + } + + MutexAutoLock lock(*crashReporterAPILock); + + crashReporterAPIData_Hash->Put(key, escapedData); + + // now rebuild the file contents + crashReporterAPIData->Truncate(0); + crashEventAPIData->Truncate(0); + for (auto it = crashReporterAPIData_Hash->Iter(); !it.Done(); it.Next()) { + const nsACString& key = it.Key(); + nsCString entry = it.Data(); + if (!entry.IsEmpty()) { + NS_NAMED_LITERAL_CSTRING(kEquals, "="); + NS_NAMED_LITERAL_CSTRING(kNewline, "\n"); + nsAutoCString line = key + kEquals + entry + kNewline; + + crashReporterAPIData->Append(line); + if (IsInWhitelist(key)) { + crashEventAPIData->Append(line); + } + } + } + + return NS_OK; +} + +nsresult RemoveCrashReportAnnotation(const nsACString& key) +{ + return AnnotateCrashReport(key, NS_LITERAL_CSTRING("")); +} + +nsresult SetGarbageCollecting(bool collecting) +{ + if (!GetEnabled()) + return NS_ERROR_NOT_INITIALIZED; + + isGarbageCollecting = collecting; + + return NS_OK; +} + +void SetEventloopNestingLevel(uint32_t level) +{ + eventloopNestingLevel = level; +} + +nsresult AppendAppNotesToCrashReport(const nsACString& data) +{ + if (!GetEnabled()) + return NS_ERROR_NOT_INITIALIZED; + + if (DoFindInReadable(data, NS_LITERAL_CSTRING("\0"))) + return NS_ERROR_INVALID_ARG; + + if (!XRE_IsParentProcess()) { + // Since we don't go through AnnotateCrashReport in the parent process, + // we must ensure that the data is escaped and valid before the parent + // sees it. + nsCString escapedData; + nsresult rv = EscapeAnnotation(NS_LITERAL_CSTRING("Notes"), data, escapedData); + if (NS_FAILED(rv)) + return rv; + + if (RefPtr<CrashReporterClient> client = CrashReporterClient::GetSingleton()) { + client->AppendAppNotes(escapedData); + return NS_OK; + } + + if (!NS_IsMainThread()) { + // Child process needs to handle this in the main thread: + nsCOMPtr<nsIRunnable> r = new CrashReporterHelperRunnable(data); + NS_DispatchToMainThread(r); + return NS_OK; + } + + MOZ_ASSERT(NS_IsMainThread()); + PCrashReporterChild* reporter = CrashReporterChild::GetCrashReporter(); + if (!reporter) { + EnqueueDelayedNote(new DelayedNote(data)); + return NS_OK; + } + + if (!reporter->SendAppendAppNotes(escapedData)) + return NS_ERROR_FAILURE; + return NS_OK; + } + + MutexAutoLock lock(*notesFieldLock); + + notesField->Append(data); + return AnnotateCrashReport(NS_LITERAL_CSTRING("Notes"), *notesField); +} + +nsresult CrashReporterHelperRunnable::Run() +{ + // We expect this to be in the child process' main thread. If it isn't, + // something is happening we didn't design for. + MOZ_ASSERT(!XRE_IsParentProcess()); + MOZ_ASSERT(NS_IsMainThread()); + + // Don't just leave the assert, paranoid about infinite recursion + if (NS_IsMainThread()) { + if (mAppendAppNotes) { + return AppendAppNotesToCrashReport(mData); + } else { + return AnnotateCrashReport(mKey, mData); + } + } + return NS_ERROR_FAILURE; +} + +// Returns true if found, false if not found. +bool GetAnnotation(const nsACString& key, nsACString& data) +{ + if (!gExceptionHandler) + return false; + + nsAutoCString entry; + if (!crashReporterAPIData_Hash->Get(key, &entry)) + return false; + + data = entry; + return true; +} + +nsresult RegisterAppMemory(void* ptr, size_t length) +{ + if (!GetEnabled()) + return NS_ERROR_NOT_INITIALIZED; + +#if defined(XP_LINUX) || defined(XP_WIN32) + gExceptionHandler->RegisterAppMemory(ptr, length); + return NS_OK; +#else + return NS_ERROR_NOT_IMPLEMENTED; +#endif +} + +nsresult UnregisterAppMemory(void* ptr) +{ + if (!GetEnabled()) + return NS_ERROR_NOT_INITIALIZED; + +#if defined(XP_LINUX) || defined(XP_WIN32) + gExceptionHandler->UnregisterAppMemory(ptr); + return NS_OK; +#else + return NS_ERROR_NOT_IMPLEMENTED; +#endif +} + +bool GetServerURL(nsACString& aServerURL) +{ + if (!gExceptionHandler) + return false; + + return GetAnnotation(NS_LITERAL_CSTRING("ServerURL"), aServerURL); +} + +nsresult SetServerURL(const nsACString& aServerURL) +{ + // store server URL with the API data + // the client knows to handle this specially + return AnnotateCrashReport(NS_LITERAL_CSTRING("ServerURL"), + aServerURL); +} + +nsresult +SetRestartArgs(int argc, char** argv) +{ + if (!gExceptionHandler) + return NS_OK; + + int i; + nsAutoCString envVar; + char *env; + char *argv0 = getenv("MOZ_APP_LAUNCHER"); + for (i = 0; i < argc; i++) { + envVar = "MOZ_CRASHREPORTER_RESTART_ARG_"; + envVar.AppendInt(i); + envVar += "="; + if (argv0 && i == 0) { + // Is there a request to suppress default binary launcher? + envVar += argv0; + } else { + envVar += argv[i]; + } + + // PR_SetEnv() wants the string to be available for the lifetime + // of the app, so dup it here + env = ToNewCString(envVar); + if (!env) + return NS_ERROR_OUT_OF_MEMORY; + + PR_SetEnv(env); + } + + // make sure the arg list is terminated + envVar = "MOZ_CRASHREPORTER_RESTART_ARG_"; + envVar.AppendInt(i); + envVar += "="; + + // PR_SetEnv() wants the string to be available for the lifetime + // of the app, so dup it here + env = ToNewCString(envVar); + if (!env) + return NS_ERROR_OUT_OF_MEMORY; + + PR_SetEnv(env); + + // make sure we save the info in XUL_APP_FILE for the reporter + const char *appfile = PR_GetEnv("XUL_APP_FILE"); + if (appfile && *appfile) { + envVar = "MOZ_CRASHREPORTER_RESTART_XUL_APP_FILE="; + envVar += appfile; + env = ToNewCString(envVar); + PR_SetEnv(env); + } + + return NS_OK; +} + +#ifdef XP_WIN32 +nsresult WriteMinidumpForException(EXCEPTION_POINTERS* aExceptionInfo) +{ + if (!gExceptionHandler) + return NS_ERROR_NOT_INITIALIZED; + + return gExceptionHandler->WriteMinidumpForException(aExceptionInfo) ? NS_OK : NS_ERROR_FAILURE; +} +#endif + +#ifdef XP_LINUX +bool WriteMinidumpForSigInfo(int signo, siginfo_t* info, void* uc) +{ + if (!gExceptionHandler) { + // Crash reporting is disabled. + return false; + } + return gExceptionHandler->HandleSignal(signo, info, uc); +} +#endif + +#ifdef XP_MACOSX +nsresult AppendObjCExceptionInfoToAppNotes(void *inException) +{ + nsAutoCString excString; + GetObjCExceptionInfo(inException, excString); + AppendAppNotesToCrashReport(excString); + return NS_OK; +} +#endif + +/* + * Combined code to get/set the crash reporter submission pref on + * different platforms. + */ +static nsresult PrefSubmitReports(bool* aSubmitReports, bool writePref) +{ + nsresult rv; +#if defined(XP_WIN32) + /* + * NOTE! This needs to stay in sync with the preference checking code + * in toolkit/crashreporter/client/crashreporter_win.cpp + */ + nsCOMPtr<nsIXULAppInfo> appinfo = + do_GetService("@mozilla.org/xre/app-info;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString appVendor, appName; + rv = appinfo->GetVendor(appVendor); + NS_ENSURE_SUCCESS(rv, rv); + rv = appinfo->GetName(appName); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIWindowsRegKey> regKey + (do_CreateInstance("@mozilla.org/windows-registry-key;1", &rv)); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString regPath; + + regPath.AppendLiteral("Software\\"); + + // We need to ensure the registry keys are created so we can properly + // write values to it + + // Create appVendor key + if(!appVendor.IsEmpty()) { + regPath.Append(appVendor); + regKey->Create(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER, + NS_ConvertUTF8toUTF16(regPath), + nsIWindowsRegKey::ACCESS_SET_VALUE); + regPath.Append('\\'); + } + + // Create appName key + regPath.Append(appName); + regKey->Create(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER, + NS_ConvertUTF8toUTF16(regPath), + nsIWindowsRegKey::ACCESS_SET_VALUE); + regPath.Append('\\'); + + // Create Crash Reporter key + regPath.AppendLiteral("Crash Reporter"); + regKey->Create(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER, + NS_ConvertUTF8toUTF16(regPath), + nsIWindowsRegKey::ACCESS_SET_VALUE); + + // If we're saving the pref value, just write it to ROOT_KEY_CURRENT_USER + // and we're done. + if (writePref) { + rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER, + NS_ConvertUTF8toUTF16(regPath), + nsIWindowsRegKey::ACCESS_SET_VALUE); + NS_ENSURE_SUCCESS(rv, rv); + + uint32_t value = *aSubmitReports ? 1 : 0; + rv = regKey->WriteIntValue(NS_LITERAL_STRING("SubmitCrashReport"), value); + regKey->Close(); + return rv; + } + + // We're reading the pref value, so we need to first look under + // ROOT_KEY_LOCAL_MACHINE to see if it's set there, and then fall back to + // ROOT_KEY_CURRENT_USER. If it's not set in either place, the pref defaults + // to "true". + uint32_t value; + rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_LOCAL_MACHINE, + NS_ConvertUTF8toUTF16(regPath), + nsIWindowsRegKey::ACCESS_QUERY_VALUE); + if (NS_SUCCEEDED(rv)) { + rv = regKey->ReadIntValue(NS_LITERAL_STRING("SubmitCrashReport"), &value); + regKey->Close(); + if (NS_SUCCEEDED(rv)) { + *aSubmitReports = !!value; + return NS_OK; + } + } + + rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER, + NS_ConvertUTF8toUTF16(regPath), + nsIWindowsRegKey::ACCESS_QUERY_VALUE); + if (NS_FAILED(rv)) { + *aSubmitReports = true; + return NS_OK; + } + + rv = regKey->ReadIntValue(NS_LITERAL_STRING("SubmitCrashReport"), &value); + // default to true on failure + if (NS_FAILED(rv)) { + value = 1; + rv = NS_OK; + } + regKey->Close(); + + *aSubmitReports = !!value; + return NS_OK; +#elif defined(XP_MACOSX) + rv = NS_OK; + if (writePref) { + CFPropertyListRef cfValue = (CFPropertyListRef)(*aSubmitReports ? kCFBooleanTrue : kCFBooleanFalse); + ::CFPreferencesSetAppValue(CFSTR("submitReport"), + cfValue, + reporterClientAppID); + if (!::CFPreferencesAppSynchronize(reporterClientAppID)) + rv = NS_ERROR_FAILURE; + } + else { + *aSubmitReports = true; + Boolean keyExistsAndHasValidFormat = false; + Boolean prefValue = ::CFPreferencesGetAppBooleanValue(CFSTR("submitReport"), + reporterClientAppID, + &keyExistsAndHasValidFormat); + if (keyExistsAndHasValidFormat) + *aSubmitReports = !!prefValue; + } + return rv; +#elif defined(XP_UNIX) + /* + * NOTE! This needs to stay in sync with the preference checking code + * in toolkit/crashreporter/client/crashreporter_linux.cpp + */ + nsCOMPtr<nsIFile> reporterINI; + rv = NS_GetSpecialDirectory("UAppData", getter_AddRefs(reporterINI)); + NS_ENSURE_SUCCESS(rv, rv); + reporterINI->AppendNative(NS_LITERAL_CSTRING("Crash Reports")); + reporterINI->AppendNative(NS_LITERAL_CSTRING("crashreporter.ini")); + + bool exists; + rv = reporterINI->Exists(&exists); + NS_ENSURE_SUCCESS(rv, rv); + if (!exists) { + if (!writePref) { + // If reading the pref, default to true if .ini doesn't exist. + *aSubmitReports = true; + return NS_OK; + } + // Create the file so the INI processor can write to it. + rv = reporterINI->Create(nsIFile::NORMAL_FILE_TYPE, 0600); + NS_ENSURE_SUCCESS(rv, rv); + } + + nsCOMPtr<nsIINIParserFactory> iniFactory = + do_GetService("@mozilla.org/xpcom/ini-processor-factory;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIINIParser> iniParser; + rv = iniFactory->CreateINIParser(reporterINI, + getter_AddRefs(iniParser)); + NS_ENSURE_SUCCESS(rv, rv); + + // If we're writing the pref, just set and we're done. + if (writePref) { + nsCOMPtr<nsIINIParserWriter> iniWriter = do_QueryInterface(iniParser); + NS_ENSURE_TRUE(iniWriter, NS_ERROR_FAILURE); + + rv = iniWriter->SetString(NS_LITERAL_CSTRING("Crash Reporter"), + NS_LITERAL_CSTRING("SubmitReport"), + *aSubmitReports ? NS_LITERAL_CSTRING("1") : + NS_LITERAL_CSTRING("0")); + NS_ENSURE_SUCCESS(rv, rv); + rv = iniWriter->WriteFile(nullptr, 0); + return rv; + } + + nsAutoCString submitReportValue; + rv = iniParser->GetString(NS_LITERAL_CSTRING("Crash Reporter"), + NS_LITERAL_CSTRING("SubmitReport"), + submitReportValue); + + // Default to "true" if the pref can't be found. + if (NS_FAILED(rv)) + *aSubmitReports = true; + else if (submitReportValue.EqualsASCII("0")) + *aSubmitReports = false; + else + *aSubmitReports = true; + + return NS_OK; +#else + return NS_ERROR_NOT_IMPLEMENTED; +#endif +} + +nsresult GetSubmitReports(bool* aSubmitReports) +{ + return PrefSubmitReports(aSubmitReports, false); +} + +nsresult SetSubmitReports(bool aSubmitReports) +{ + nsresult rv; + + nsCOMPtr<nsIObserverService> obsServ = + mozilla::services::GetObserverService(); + if (!obsServ) { + return NS_ERROR_FAILURE; + } + + rv = PrefSubmitReports(&aSubmitReports, true); + if (NS_FAILED(rv)) { + return rv; + } + + obsServ->NotifyObservers(nullptr, "submit-reports-pref-changed", nullptr); + return NS_OK; +} + +static void +SetCrashEventsDir(nsIFile* aDir) +{ + nsCOMPtr<nsIFile> eventsDir = aDir; + + const char *env = PR_GetEnv("CRASHES_EVENTS_DIR"); + if (env && *env) { + NS_NewNativeLocalFile(nsDependentCString(env), + false, getter_AddRefs(eventsDir)); + EnsureDirectoryExists(eventsDir); + } + + if (eventsDirectory) { + free(eventsDirectory); + } + +#ifdef XP_WIN + nsString path; + eventsDir->GetPath(path); + eventsDirectory = reinterpret_cast<wchar_t*>(ToNewUnicode(path)); + + // Save the path in the environment for the crash reporter application. + nsAutoString eventsDirEnv(NS_LITERAL_STRING("MOZ_CRASHREPORTER_EVENTS_DIRECTORY=")); + eventsDirEnv.Append(path); + _wputenv(eventsDirEnv.get()); +#else + nsCString path; + eventsDir->GetNativePath(path); + eventsDirectory = ToNewCString(path); + + // Save the path in the environment for the crash reporter application. + nsAutoCString eventsDirEnv("MOZ_CRASHREPORTER_EVENTS_DIRECTORY="); + eventsDirEnv.Append(path); + + // PR_SetEnv() wants the string to be available for the lifetime + // of the app, so dup it here. + char* oldEventsEnv = eventsEnv; + eventsEnv = ToNewCString(eventsDirEnv); + PR_SetEnv(eventsEnv); + + if (oldEventsEnv) { + free(oldEventsEnv); + } +#endif +} + +void +SetProfileDirectory(nsIFile* aDir) +{ + nsCOMPtr<nsIFile> dir; + aDir->Clone(getter_AddRefs(dir)); + + dir->Append(NS_LITERAL_STRING("crashes")); + EnsureDirectoryExists(dir); + dir->Append(NS_LITERAL_STRING("events")); + EnsureDirectoryExists(dir); + SetCrashEventsDir(dir); +} + +void +SetUserAppDataDirectory(nsIFile* aDir) +{ + nsCOMPtr<nsIFile> dir; + aDir->Clone(getter_AddRefs(dir)); + + dir->Append(NS_LITERAL_STRING("Crash Reports")); + EnsureDirectoryExists(dir); + dir->Append(NS_LITERAL_STRING("events")); + EnsureDirectoryExists(dir); + SetCrashEventsDir(dir); +} + +void +UpdateCrashEventsDir() +{ + const char *env = PR_GetEnv("CRASHES_EVENTS_DIR"); + if (env && *env) { + SetCrashEventsDir(nullptr); + } + + nsCOMPtr<nsIFile> eventsDir; + nsresult rv = NS_GetSpecialDirectory("ProfD", getter_AddRefs(eventsDir)); + if (NS_SUCCEEDED(rv)) { + SetProfileDirectory(eventsDir); + return; + } + + rv = NS_GetSpecialDirectory("UAppData", getter_AddRefs(eventsDir)); + if (NS_SUCCEEDED(rv)) { + SetUserAppDataDirectory(eventsDir); + return; + } + + NS_WARNING("Couldn't get the user appdata directory. Crash events may not be produced."); +} + +bool GetCrashEventsDir(nsAString& aPath) +{ + if (!eventsDirectory) { + return false; + } + + aPath = CONVERT_XP_CHAR_TO_UTF16(eventsDirectory); + return true; +} + +void +SetMemoryReportFile(nsIFile* aFile) +{ + if (!gExceptionHandler) { + return; + } +#ifdef XP_WIN + nsString path; + aFile->GetPath(path); + memoryReportPath = reinterpret_cast<wchar_t*>(ToNewUnicode(path)); +#else + nsCString path; + aFile->GetNativePath(path); + memoryReportPath = ToNewCString(path); +#endif +} + +nsresult +GetDefaultMemoryReportFile(nsIFile** aFile) +{ + nsCOMPtr<nsIFile> defaultMemoryReportFile; + if (!defaultMemoryReportPath) { + nsresult rv = NS_GetSpecialDirectory(NS_APP_PROFILE_DIR_STARTUP, + getter_AddRefs(defaultMemoryReportFile)); + if (NS_FAILED(rv)) { + return rv; + } + defaultMemoryReportFile->AppendNative(NS_LITERAL_CSTRING("memory-report.json.gz")); + defaultMemoryReportPath = CreatePathFromFile(defaultMemoryReportFile); + if (!defaultMemoryReportPath) { + return NS_ERROR_FAILURE; + } + } else { + CreateFileFromPath(*defaultMemoryReportPath, + getter_AddRefs(defaultMemoryReportFile)); + if (!defaultMemoryReportFile) { + return NS_ERROR_FAILURE; + } + } + defaultMemoryReportFile.forget(aFile); + return NS_OK; +} + +void +SetTelemetrySessionId(const nsACString& id) +{ + if (!gExceptionHandler) { + return; + } + if (currentSessionId) { + free(currentSessionId); + } + currentSessionId = ToNewCString(id); +} + +static void +FindPendingDir() +{ + if (pendingDirectory) + return; + + nsCOMPtr<nsIFile> pendingDir; + nsresult rv = NS_GetSpecialDirectory("UAppData", getter_AddRefs(pendingDir)); + if (NS_FAILED(rv)) { + NS_WARNING("Couldn't get the user appdata directory, crash dumps will go in an unusual location"); + } + else { + pendingDir->Append(NS_LITERAL_STRING("Crash Reports")); + pendingDir->Append(NS_LITERAL_STRING("pending")); + +#ifdef XP_WIN + nsString path; + pendingDir->GetPath(path); + pendingDirectory = reinterpret_cast<wchar_t*>(ToNewUnicode(path)); +#else + nsCString path; + pendingDir->GetNativePath(path); + pendingDirectory = ToNewCString(path); +#endif + } +} + +// The "pending" dir is Crash Reports/pending, from which minidumps +// can be submitted. Because this method may be called off the main thread, +// we store the pending directory as a path. +static bool +GetPendingDir(nsIFile** dir) +{ + // MOZ_ASSERT(OOPInitialized()); + if (!pendingDirectory) { + return false; + } + + nsCOMPtr<nsIFile> pending = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID); + if (!pending) { + NS_WARNING("Can't set up pending directory during shutdown."); + return false; + } +#ifdef XP_WIN + pending->InitWithPath(nsDependentString(pendingDirectory)); +#else + pending->InitWithNativePath(nsDependentCString(pendingDirectory)); +#endif + pending.swap(*dir); + return true; +} + +// The "limbo" dir is where minidumps go to wait for something else to +// use them. If we're |ShouldReport()|, then the "something else" is +// a minidump submitter, and they're coming from the +// Crash Reports/pending/ dir. Otherwise, we don't know what the +// "somthing else" is, but the minidumps stay in [profile]/minidumps/ +// limbo. +static bool +GetMinidumpLimboDir(nsIFile** dir) +{ + if (ShouldReport()) { + return GetPendingDir(dir); + } + else { +#ifndef XP_LINUX + CreateFileFromPath(gExceptionHandler->dump_path(), dir); +#else + CreateFileFromPath(gExceptionHandler->minidump_descriptor().directory(), + dir); +#endif + return nullptr != *dir; + } +} + +void +DeleteMinidumpFilesForID(const nsAString& id) +{ + nsCOMPtr<nsIFile> minidumpFile; + GetMinidumpForID(id, getter_AddRefs(minidumpFile)); + bool exists = false; + if (minidumpFile && NS_SUCCEEDED(minidumpFile->Exists(&exists)) && exists) { + nsCOMPtr<nsIFile> childExtraFile; + GetExtraFileForMinidump(minidumpFile, getter_AddRefs(childExtraFile)); + if (childExtraFile) { + childExtraFile->Remove(false); + } + minidumpFile->Remove(false); + } +} + +bool +GetMinidumpForID(const nsAString& id, nsIFile** minidump) +{ + if (!GetMinidumpLimboDir(minidump)) + return false; + (*minidump)->Append(id + NS_LITERAL_STRING(".dmp")); + return true; +} + +bool +GetIDFromMinidump(nsIFile* minidump, nsAString& id) +{ + if (minidump && NS_SUCCEEDED(minidump->GetLeafName(id))) { + id.Replace(id.Length() - 4, 4, NS_LITERAL_STRING("")); + return true; + } + return false; +} + +bool +GetExtraFileForID(const nsAString& id, nsIFile** extraFile) +{ + if (!GetMinidumpLimboDir(extraFile)) + return false; + (*extraFile)->Append(id + NS_LITERAL_STRING(".extra")); + return true; +} + +bool +GetExtraFileForMinidump(nsIFile* minidump, nsIFile** extraFile) +{ + nsAutoString leafName; + nsresult rv = minidump->GetLeafName(leafName); + if (NS_FAILED(rv)) + return false; + + nsCOMPtr<nsIFile> extraF; + rv = minidump->Clone(getter_AddRefs(extraF)); + if (NS_FAILED(rv)) + return false; + + leafName.Replace(leafName.Length() - 3, 3, + NS_LITERAL_STRING("extra")); + rv = extraF->SetLeafName(leafName); + if (NS_FAILED(rv)) + return false; + + *extraFile = nullptr; + extraF.swap(*extraFile); + return true; +} + +bool +AppendExtraData(const nsAString& id, const AnnotationTable& data) +{ + nsCOMPtr<nsIFile> extraFile; + if (!GetExtraFileForID(id, getter_AddRefs(extraFile))) + return false; + return AppendExtraData(extraFile, data); +} + +//----------------------------------------------------------------------------- +// Helpers for AppendExtraData() +// +struct Blacklist { + Blacklist() : mItems(nullptr), mLen(0) { } + Blacklist(const char** items, int len) : mItems(items), mLen(len) { } + + bool Contains(const nsACString& key) const { + for (int i = 0; i < mLen; ++i) + if (key.EqualsASCII(mItems[i])) + return true; + return false; + } + + const char** mItems; + const int mLen; +}; + +static void +WriteAnnotation(PRFileDesc* fd, const nsACString& key, const nsACString& value) +{ + PR_Write(fd, key.BeginReading(), key.Length()); + PR_Write(fd, "=", 1); + PR_Write(fd, value.BeginReading(), value.Length()); + PR_Write(fd, "\n", 1); +} + +template<int N> +void +WriteLiteral(PRFileDesc* fd, const char (&str)[N]) +{ + PR_Write(fd, str, N - 1); +} + +static bool +WriteExtraData(nsIFile* extraFile, + const AnnotationTable& data, + const Blacklist& blacklist, + bool writeCrashTime=false, + bool truncate=false) +{ + PRFileDesc* fd; + int truncOrAppend = truncate ? PR_TRUNCATE : PR_APPEND; + nsresult rv = + extraFile->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE | truncOrAppend, + 0600, &fd); + if (NS_FAILED(rv)) + return false; + + for (auto iter = data.ConstIter(); !iter.Done(); iter.Next()) { + // Skip entries in the blacklist. + const nsACString& key = iter.Key(); + if (blacklist.Contains(key)) { + continue; + } + WriteAnnotation(fd, key, iter.Data()); + } + + if (writeCrashTime) { + time_t crashTime = time(nullptr); + char crashTimeString[32]; + XP_TTOA(crashTime, crashTimeString, 10); + + WriteAnnotation(fd, + nsDependentCString("CrashTime"), + nsDependentCString(crashTimeString)); + + bool ignored = false; + double uptimeTS = (TimeStamp::NowLoRes()- + TimeStamp::ProcessCreation(ignored)).ToSecondsSigDigits(); + char uptimeTSString[64]; + SimpleNoCLibDtoA(uptimeTS, uptimeTSString, sizeof(uptimeTSString)); + + WriteAnnotation(fd, + nsDependentCString("UptimeTS"), + nsDependentCString(uptimeTSString)); + } + + if (memoryReportPath) { + WriteLiteral(fd, "ContainsMemoryReport=1\n"); + } + + PR_Close(fd); + return true; +} + +bool +AppendExtraData(nsIFile* extraFile, const AnnotationTable& data) +{ + return WriteExtraData(extraFile, data, Blacklist()); +} + +static bool +GetExtraFileForChildPid(uint32_t aPid, nsIFile** aExtraFile) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + + nsCOMPtr<nsIFile> extraFile; + nsresult rv; + +#if defined(XP_WIN) || defined(XP_MACOSX) + if (!childProcessTmpDir) { + return false; + } + CreateFileFromPath(*childProcessTmpDir, getter_AddRefs(extraFile)); + if (!extraFile) { + return false; + } +#elif defined(XP_UNIX) + rv = NS_NewLocalFile(NS_LITERAL_STRING("/tmp"), false, + getter_AddRefs(extraFile)); + if (NS_FAILED(rv)) { + return false; + } +#else +#error "Implement this for your platform" +#endif + + nsAutoString leafName; +#if defined(XP_WIN) + leafName.AppendPrintf("%S%u%S", childCrashAnnotationBaseName, aPid, + extraFileExtension); +#else + leafName.AppendPrintf("%s%u%s", childCrashAnnotationBaseName, aPid, + extraFileExtension); +#endif + + rv = extraFile->Append(leafName); + if (NS_FAILED(rv)) { + return false; + } + + extraFile.forget(aExtraFile); + return true; +} + +static bool +IsDataEscaped(char* aData) +{ + if (strchr(aData, '\n')) { + // There should not be any newlines + return false; + } + char* pos = aData; + while ((pos = strchr(pos, '\\'))) { + if (*(pos + 1) != '\\') { + return false; + } + // Add 2 to account for the second pos + pos += 2; + } + return true; +} + +static void +ReadAndValidateExceptionTimeAnnotations(FILE*& aFd, + AnnotationTable& aAnnotations) +{ + char line[0x1000]; + while (fgets(line, sizeof(line), aFd)) { + char* data = strchr(line, '='); + if (!data) { + // bad data? Abort! + break; + } + // Move past the '=' + *data = 0; + ++data; + size_t dataLen = strlen(data); + // Chop off any trailing newline + if (dataLen > 0 && data[dataLen - 1] == '\n') { + data[dataLen - 1] = 0; + --dataLen; + } + // There should not be any newlines in the key + if (strchr(line, '\n')) { + break; + } + // Data should have been escaped by the child + if (!IsDataEscaped(data)) { + break; + } + // Looks good, save the (line,data) pair + aAnnotations.Put(nsDependentCString(line), + nsDependentCString(data, dataLen)); + } +} + +/** + * NOTE: One side effect of this function is that it deletes the + * GeckoChildCrash<pid>.extra file if it exists, once processed. + */ +static bool +WriteExtraForMinidump(nsIFile* minidump, + uint32_t pid, + const Blacklist& blacklist, + nsIFile** extraFile) +{ + nsCOMPtr<nsIFile> extra; + if (!GetExtraFileForMinidump(minidump, getter_AddRefs(extra))) { + return false; + } + + if (!WriteExtraData(extra, *crashReporterAPIData_Hash, + blacklist, + true /*write crash time*/, + true /*truncate*/)) { + return false; + } + + nsCOMPtr<nsIFile> exceptionTimeExtra; + FILE* fd; + if (pid && GetExtraFileForChildPid(pid, getter_AddRefs(exceptionTimeExtra)) && + NS_SUCCEEDED(exceptionTimeExtra->OpenANSIFileDesc("r", &fd))) { + AnnotationTable exceptionTimeAnnotations; + ReadAndValidateExceptionTimeAnnotations(fd, exceptionTimeAnnotations); + fclose(fd); + if (!AppendExtraData(extra, exceptionTimeAnnotations)) { + return false; + } + } + if (exceptionTimeExtra) { + exceptionTimeExtra->Remove(false); + } + + extra.forget(extraFile); + + return true; +} + +// It really only makes sense to call this function when +// ShouldReport() is true. +// Uses dumpFile's filename to generate memoryReport's filename (same name with +// a different extension) +static bool +MoveToPending(nsIFile* dumpFile, nsIFile* extraFile, nsIFile* memoryReport) +{ + nsCOMPtr<nsIFile> pendingDir; + if (!GetPendingDir(getter_AddRefs(pendingDir))) + return false; + + if (NS_FAILED(dumpFile->MoveTo(pendingDir, EmptyString()))) { + return false; + } + + if (extraFile && NS_FAILED(extraFile->MoveTo(pendingDir, EmptyString()))) { + return false; + } + + if (memoryReport) { + nsAutoString leafName; + nsresult rv = dumpFile->GetLeafName(leafName); + if (NS_FAILED(rv)) { + return false; + } + // Generate the correct memory report filename from the dumpFile's name + leafName.Replace(leafName.Length() - 4, 4, + static_cast<nsString>(CONVERT_XP_CHAR_TO_UTF16(memoryReportExtension))); + if (NS_FAILED(memoryReport->MoveTo(pendingDir, leafName))) { + return false; + } + } + + return true; +} + +static void +OnChildProcessDumpRequested(void* aContext, +#ifdef XP_MACOSX + const ClientInfo& aClientInfo, + const xpstring& aFilePath +#else + const ClientInfo* aClientInfo, + const xpstring* aFilePath +#endif + ) +{ + nsCOMPtr<nsIFile> minidump; + nsCOMPtr<nsIFile> extraFile; + + // Hold the mutex until the current dump request is complete, to + // prevent UnsetExceptionHandler() from pulling the rug out from + // under us. + MutexAutoLock lock(*dumpSafetyLock); + if (!isSafeToDump) + return; + + CreateFileFromPath( +#ifdef XP_MACOSX + aFilePath, +#else + *aFilePath, +#endif + getter_AddRefs(minidump)); + + uint32_t pid = +#ifdef XP_MACOSX + aClientInfo.pid(); +#else + aClientInfo->pid(); +#endif + + if (!WriteExtraForMinidump(minidump, pid, + Blacklist(kSubprocessBlacklist, + ArrayLength(kSubprocessBlacklist)), + getter_AddRefs(extraFile))) + return; + + if (ShouldReport()) { + nsCOMPtr<nsIFile> memoryReport; + if (memoryReportPath) { + CreateFileFromPath(memoryReportPath, getter_AddRefs(memoryReport)); + MOZ_ASSERT(memoryReport); + } + MoveToPending(minidump, extraFile, memoryReport); + } + + { + +#ifdef MOZ_CRASHREPORTER_INJECTOR + bool runCallback; +#endif + { + MutexAutoLock lock(*dumpMapLock); + ChildProcessData* pd = pidToMinidump->PutEntry(pid); + MOZ_ASSERT(!pd->minidump); + pd->minidump = minidump; + pd->sequence = ++crashSequence; +#ifdef MOZ_CRASHREPORTER_INJECTOR + runCallback = nullptr != pd->callback; +#endif + } +#ifdef MOZ_CRASHREPORTER_INJECTOR + if (runCallback) + NS_DispatchToMainThread(new ReportInjectedCrash(pid)); +#endif + } +} + +static bool +OOPInitialized() +{ + return pidToMinidump != nullptr; +} + +void +OOPInit() +{ + class ProxyToMainThread : public Runnable + { + public: + NS_IMETHOD Run() override { + OOPInit(); + return NS_OK; + } + }; + if (!NS_IsMainThread()) { + // This logic needs to run on the main thread + nsCOMPtr<nsIThread> mainThread = do_GetMainThread(); + mozilla::SyncRunnable::DispatchToThread(mainThread, new ProxyToMainThread()); + return; + } + + if (OOPInitialized()) + return; + + MOZ_ASSERT(NS_IsMainThread()); + + MOZ_ASSERT(gExceptionHandler != nullptr, + "attempt to initialize OOP crash reporter before in-process crashreporter!"); + +#if (defined(XP_WIN) || defined(XP_MACOSX)) + nsCOMPtr<nsIFile> tmpDir; +# if defined(MOZ_CONTENT_SANDBOX) + nsresult rv = NS_GetSpecialDirectory(NS_APP_CONTENT_PROCESS_TEMP_DIR, + getter_AddRefs(tmpDir)); + if (NS_FAILED(rv) && PR_GetEnv("XPCSHELL_TEST_PROFILE_DIR")) { + // Temporary hack for xpcshell, will be fixed in bug 1257098 + rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tmpDir)); + } + if (NS_SUCCEEDED(rv)) { + childProcessTmpDir = CreatePathFromFile(tmpDir); + } +# else + if (NS_SUCCEEDED(NS_GetSpecialDirectory(NS_OS_TEMP_DIR, + getter_AddRefs(tmpDir)))) { + childProcessTmpDir = CreatePathFromFile(tmpDir); + } +# endif // defined(MOZ_CONTENT_SANDBOX) +#endif // (defined(XP_WIN) || defined(XP_MACOSX)) + +#if defined(XP_WIN) + childCrashNotifyPipe = + PR_smprintf("\\\\.\\pipe\\gecko-crash-server-pipe.%i", + static_cast<int>(::GetCurrentProcessId())); + + const std::wstring dumpPath = gExceptionHandler->dump_path(); + crashServer = new CrashGenerationServer( + std::wstring(NS_ConvertASCIItoUTF16(childCrashNotifyPipe).get()), + nullptr, // default security attributes + nullptr, nullptr, // we don't care about process connect here + OnChildProcessDumpRequested, nullptr, + nullptr, nullptr, // we don't care about process exit here + nullptr, nullptr, // we don't care about upload request here + true, // automatically generate dumps + &dumpPath); + +#elif defined(XP_LINUX) + if (!CrashGenerationServer::CreateReportChannel(&serverSocketFd, + &clientSocketFd)) + NS_RUNTIMEABORT("can't create crash reporter socketpair()"); + + const std::string dumpPath = + gExceptionHandler->minidump_descriptor().directory(); + crashServer = new CrashGenerationServer( + serverSocketFd, + OnChildProcessDumpRequested, nullptr, + nullptr, nullptr, // we don't care about process exit here + true, + &dumpPath); + +#elif defined(XP_MACOSX) + childCrashNotifyPipe = + PR_smprintf("gecko-crash-server-pipe.%i", + static_cast<int>(getpid())); + const std::string dumpPath = gExceptionHandler->dump_path(); + + crashServer = new CrashGenerationServer( + childCrashNotifyPipe, + nullptr, + nullptr, + OnChildProcessDumpRequested, nullptr, + nullptr, nullptr, + true, // automatically generate dumps + dumpPath); +#endif + + if (!crashServer->Start()) + NS_RUNTIMEABORT("can't start crash reporter server()"); + + pidToMinidump = new ChildMinidumpMap(); + + dumpMapLock = new Mutex("CrashReporter::dumpMapLock"); + + FindPendingDir(); + UpdateCrashEventsDir(); +} + +static void +OOPDeinit() +{ + if (!OOPInitialized()) { + NS_WARNING("OOPDeinit() without successful OOPInit()"); + return; + } + +#ifdef MOZ_CRASHREPORTER_INJECTOR + if (sInjectorThread) { + sInjectorThread->Shutdown(); + NS_RELEASE(sInjectorThread); + } +#endif + + delete crashServer; + crashServer = nullptr; + + delete dumpMapLock; + dumpMapLock = nullptr; + + delete pidToMinidump; + pidToMinidump = nullptr; + +#if defined(XP_WIN) + PR_Free(childCrashNotifyPipe); + childCrashNotifyPipe = nullptr; +#endif +} + +#if defined(XP_WIN) || defined(XP_MACOSX) +// Parent-side API for children +const char* +GetChildNotificationPipe() +{ + if (!GetEnabled()) + return kNullNotifyPipe; + + MOZ_ASSERT(OOPInitialized()); + + return childCrashNotifyPipe; +} +#endif + +#ifdef MOZ_CRASHREPORTER_INJECTOR +void +InjectCrashReporterIntoProcess(DWORD processID, InjectorCrashCallback* cb) +{ + if (!GetEnabled()) + return; + + if (!OOPInitialized()) + OOPInit(); + + if (!sInjectorThread) { + if (NS_FAILED(NS_NewThread(&sInjectorThread))) + return; + } + + { + MutexAutoLock lock(*dumpMapLock); + ChildProcessData* pd = pidToMinidump->PutEntry(processID); + MOZ_ASSERT(!pd->minidump && !pd->callback); + pd->callback = cb; + } + + nsCOMPtr<nsIRunnable> r = new InjectCrashRunnable(processID); + sInjectorThread->Dispatch(r, nsIEventTarget::DISPATCH_NORMAL); +} + +NS_IMETHODIMP +ReportInjectedCrash::Run() +{ + // Crash reporting may have been disabled after this method was dispatched + if (!OOPInitialized()) + return NS_OK; + + InjectorCrashCallback* cb; + { + MutexAutoLock lock(*dumpMapLock); + ChildProcessData* pd = pidToMinidump->GetEntry(mPID); + if (!pd || !pd->callback) + return NS_OK; + + MOZ_ASSERT(pd->minidump); + + cb = pd->callback; + } + + cb->OnCrash(mPID); + return NS_OK; +} + +void +UnregisterInjectorCallback(DWORD processID) +{ + if (!OOPInitialized()) + return; + + MutexAutoLock lock(*dumpMapLock); + pidToMinidump->RemoveEntry(processID); +} + +#endif // MOZ_CRASHREPORTER_INJECTOR + +bool +CheckForLastRunCrash() +{ + if (lastRunCrashID) + return true; + + // The exception handler callback leaves the filename of the + // last minidump in a known file. + nsCOMPtr<nsIFile> lastCrashFile; + CreateFileFromPath(crashMarkerFilename, + getter_AddRefs(lastCrashFile)); + + bool exists; + if (NS_FAILED(lastCrashFile->Exists(&exists)) || !exists) { + return false; + } + + nsAutoCString lastMinidump_contents; + if (NS_FAILED(GetFileContents(lastCrashFile, lastMinidump_contents))) { + return false; + } + lastCrashFile->Remove(false); + +#ifdef XP_WIN + // Ugly but effective. + nsDependentString lastMinidump( + reinterpret_cast<const char16_t*>(lastMinidump_contents.get())); +#else + nsAutoCString lastMinidump = lastMinidump_contents; +#endif + nsCOMPtr<nsIFile> lastMinidumpFile; + CreateFileFromPath(lastMinidump.get(), + getter_AddRefs(lastMinidumpFile)); + + if (!lastMinidumpFile || NS_FAILED(lastMinidumpFile->Exists(&exists)) || !exists) { + return false; + } + + nsCOMPtr<nsIFile> lastExtraFile; + if (!GetExtraFileForMinidump(lastMinidumpFile, + getter_AddRefs(lastExtraFile))) { + return false; + } + + nsCOMPtr<nsIFile> memoryReportFile; + nsresult rv = GetDefaultMemoryReportFile(getter_AddRefs(memoryReportFile)); + if (NS_FAILED(rv) || NS_FAILED(memoryReportFile->Exists(&exists)) || !exists) { + memoryReportFile = nullptr; + } + + FindPendingDir(); + + // Move {dump,extra,memory} to pending folder + if (!MoveToPending(lastMinidumpFile, lastExtraFile, memoryReportFile)) { + return false; + } + + lastRunCrashID = new nsString(); + return GetIDFromMinidump(lastMinidumpFile, *lastRunCrashID); +} + +bool +GetLastRunCrashID(nsAString& id) +{ + if (!lastRunCrashID_checked) { + CheckForLastRunCrash(); + lastRunCrashID_checked = true; + } + + if (!lastRunCrashID) { + return false; + } + + id = *lastRunCrashID; + return true; +} + +#if defined(XP_WIN) || defined(XP_MACOSX) +void +InitChildProcessTmpDir() +{ + MOZ_ASSERT(!XRE_IsParentProcess()); + // When retrieved by the child process, this will always resolve to the + // correct directory regardless of sandbox level. + nsCOMPtr<nsIFile> tmpDir; + nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tmpDir)); + if (NS_SUCCEEDED(rv)) { + childProcessTmpDir = CreatePathFromFile(tmpDir); + } +} +#endif // defined(XP_WIN) || defined(XP_MACOSX) + +#if defined(XP_WIN) +// Child-side API +bool +SetRemoteExceptionHandler(const nsACString& crashPipe) +{ + // crash reporting is disabled + if (crashPipe.Equals(kNullNotifyPipe)) + return true; + + MOZ_ASSERT(!gExceptionHandler, "crash client already init'd"); + + gExceptionHandler = new google_breakpad:: + ExceptionHandler(L"", + ChildFPEFilter, + nullptr, // no minidump callback + nullptr, // no callback context + google_breakpad::ExceptionHandler::HANDLER_ALL, + GetMinidumpType(), + NS_ConvertASCIItoUTF16(crashPipe).get(), + nullptr); + gExceptionHandler->set_handle_debug_exceptions(true); + + mozalloc_set_oom_abort_handler(AnnotateOOMAllocationSize); + + oldTerminateHandler = std::set_terminate(&TerminateHandler); + + // we either do remote or nothing, no fallback to regular crash reporting + return gExceptionHandler->IsOutOfProcess(); +} + +//-------------------------------------------------- +#elif defined(XP_LINUX) + +// Parent-side API for children +bool +CreateNotificationPipeForChild(int* childCrashFd, int* childCrashRemapFd) +{ + if (!GetEnabled()) { + *childCrashFd = -1; + *childCrashRemapFd = -1; + return true; + } + + MOZ_ASSERT(OOPInitialized()); + + *childCrashFd = clientSocketFd; + *childCrashRemapFd = kMagicChildCrashReportFd; + + return true; +} + +// Child-side API +bool +SetRemoteExceptionHandler() +{ + MOZ_ASSERT(!gExceptionHandler, "crash client already init'd"); + + // MinidumpDescriptor requires a non-empty path. + google_breakpad::MinidumpDescriptor path("."); + + gExceptionHandler = new google_breakpad:: + ExceptionHandler(path, + ChildFilter, + nullptr, // no minidump callback + nullptr, // no callback context + true, // install signal handlers + kMagicChildCrashReportFd); + + if (gDelayedAnnotations) { + for (uint32_t i = 0; i < gDelayedAnnotations->Length(); i++) { + gDelayedAnnotations->ElementAt(i)->Run(); + } + delete gDelayedAnnotations; + } + + mozalloc_set_oom_abort_handler(AnnotateOOMAllocationSize); + + oldTerminateHandler = std::set_terminate(&TerminateHandler); + + // we either do remote or nothing, no fallback to regular crash reporting + return gExceptionHandler->IsOutOfProcess(); +} + +//-------------------------------------------------- +#elif defined(XP_MACOSX) +// Child-side API +bool +SetRemoteExceptionHandler(const nsACString& crashPipe) +{ + // crash reporting is disabled + if (crashPipe.Equals(kNullNotifyPipe)) + return true; + + MOZ_ASSERT(!gExceptionHandler, "crash client already init'd"); + + gExceptionHandler = new google_breakpad:: + ExceptionHandler("", + ChildFilter, + nullptr, // no minidump callback + nullptr, // no callback context + true, // install signal handlers + crashPipe.BeginReading()); + + mozalloc_set_oom_abort_handler(AnnotateOOMAllocationSize); + + oldTerminateHandler = std::set_terminate(&TerminateHandler); + + // we either do remote or nothing, no fallback to regular crash reporting + return gExceptionHandler->IsOutOfProcess(); +} +#endif // XP_WIN + + +bool +TakeMinidumpForChild(uint32_t childPid, nsIFile** dump, uint32_t* aSequence) +{ + if (!GetEnabled()) + return false; + + MutexAutoLock lock(*dumpMapLock); + + ChildProcessData* pd = pidToMinidump->GetEntry(childPid); + if (!pd) + return false; + + NS_IF_ADDREF(*dump = pd->minidump); + if (aSequence) { + *aSequence = pd->sequence; + } + + pidToMinidump->RemoveEntry(pd); + + return !!*dump; +} + +//----------------------------------------------------------------------------- +// CreatePairedMinidumps() and helpers +// + +void +RenameAdditionalHangMinidump(nsIFile* minidump, nsIFile* childMinidump, + const nsACString& name) +{ + nsCOMPtr<nsIFile> directory; + childMinidump->GetParent(getter_AddRefs(directory)); + if (!directory) + return; + + nsAutoCString leafName; + childMinidump->GetNativeLeafName(leafName); + + // turn "<id>.dmp" into "<id>-<name>.dmp + leafName.Insert(NS_LITERAL_CSTRING("-") + name, leafName.Length() - 4); + + if (NS_FAILED(minidump->MoveToNative(directory, leafName))) { + NS_WARNING("RenameAdditionalHangMinidump failed to move minidump."); + } +} + +static bool +PairedDumpCallback( +#ifdef XP_LINUX + const MinidumpDescriptor& descriptor, +#else + const XP_CHAR* dump_path, + const XP_CHAR* minidump_id, +#endif + void* context, +#ifdef XP_WIN32 + EXCEPTION_POINTERS* /*unused*/, + MDRawAssertionInfo* /*unused*/, +#endif + bool succeeded) +{ + nsCOMPtr<nsIFile>& minidump = *static_cast< nsCOMPtr<nsIFile>* >(context); + + xpstring dump; +#ifdef XP_LINUX + dump = descriptor.path(); +#else + dump = dump_path; + dump += XP_PATH_SEPARATOR; + dump += minidump_id; + dump += dumpFileExtension; +#endif + + CreateFileFromPath(dump, getter_AddRefs(minidump)); + return true; +} + +static bool +PairedDumpCallbackExtra( +#ifdef XP_LINUX + const MinidumpDescriptor& descriptor, +#else + const XP_CHAR* dump_path, + const XP_CHAR* minidump_id, +#endif + void* context, +#ifdef XP_WIN32 + EXCEPTION_POINTERS* /*unused*/, + MDRawAssertionInfo* /*unused*/, +#endif + bool succeeded) +{ + PairedDumpCallback( +#ifdef XP_LINUX + descriptor, +#else + dump_path, minidump_id, +#endif + context, +#ifdef XP_WIN32 + nullptr, nullptr, +#endif + succeeded); + + nsCOMPtr<nsIFile>& minidump = *static_cast< nsCOMPtr<nsIFile>* >(context); + + nsCOMPtr<nsIFile> extra; + return WriteExtraForMinidump(minidump, 0, Blacklist(), getter_AddRefs(extra)); +} + +ThreadId +CurrentThreadId() +{ +#if defined(XP_WIN) + return ::GetCurrentThreadId(); +#elif defined(XP_LINUX) + return sys_gettid(); +#elif defined(XP_MACOSX) + // Just return an index, since Mach ports can't be directly serialized + thread_act_port_array_t threads_for_task; + mach_msg_type_number_t thread_count; + + if (task_threads(mach_task_self(), &threads_for_task, &thread_count)) + return -1; + + for (unsigned int i = 0; i < thread_count; ++i) { + if (threads_for_task[i] == mach_thread_self()) + return i; + } + abort(); +#else +# error "Unsupported platform" +#endif +} + +#ifdef XP_MACOSX +static mach_port_t +GetChildThread(ProcessHandle childPid, ThreadId childBlamedThread) +{ + mach_port_t childThread = MACH_PORT_NULL; + thread_act_port_array_t threads_for_task; + mach_msg_type_number_t thread_count; + + if (task_threads(childPid, &threads_for_task, &thread_count) + == KERN_SUCCESS && childBlamedThread < thread_count) { + childThread = threads_for_task[childBlamedThread]; + } + + return childThread; +} +#endif + +bool TakeMinidump(nsIFile** aResult, bool aMoveToPending) +{ + if (!GetEnabled()) + return false; + + AutoIOInterposerDisable disableIOInterposition; + + xpstring dump_path; +#ifndef XP_LINUX + dump_path = gExceptionHandler->dump_path(); +#else + dump_path = gExceptionHandler->minidump_descriptor().directory(); +#endif + + // capture the dump + if (!google_breakpad::ExceptionHandler::WriteMinidump( + dump_path, +#ifdef XP_MACOSX + true, +#endif + PairedDumpCallback, + static_cast<void*>(aResult) +#ifdef XP_WIN32 + , GetMinidumpType() +#endif + )) { + return false; + } + + if (aMoveToPending) { + MoveToPending(*aResult, nullptr, nullptr); + } + return true; +} + +bool +CreateMinidumpsAndPair(ProcessHandle aTargetPid, + ThreadId aTargetBlamedThread, + const nsACString& aIncomingPairName, + nsIFile* aIncomingDumpToPair, + nsIFile** aMainDumpOut) +{ + if (!GetEnabled()) { + return false; + } + + AutoIOInterposerDisable disableIOInterposition; + +#ifdef XP_MACOSX + mach_port_t targetThread = GetChildThread(aTargetPid, aTargetBlamedThread); +#else + ThreadId targetThread = aTargetBlamedThread; +#endif + + xpstring dump_path; +#ifndef XP_LINUX + dump_path = gExceptionHandler->dump_path(); +#else + dump_path = gExceptionHandler->minidump_descriptor().directory(); +#endif + + // dump the target + nsCOMPtr<nsIFile> targetMinidump; + if (!google_breakpad::ExceptionHandler::WriteMinidumpForChild( + aTargetPid, + targetThread, + dump_path, + PairedDumpCallbackExtra, + static_cast<void*>(&targetMinidump) +#ifdef XP_WIN32 + , GetMinidumpType() +#endif + )) + return false; + + nsCOMPtr<nsIFile> targetExtra; + GetExtraFileForMinidump(targetMinidump, getter_AddRefs(targetExtra)); + + // If aIncomingDumpToPair isn't valid, create a dump of this process. + nsCOMPtr<nsIFile> incomingDump; + if (aIncomingDumpToPair == nullptr) { + if (!google_breakpad::ExceptionHandler::WriteMinidump( + dump_path, +#ifdef XP_MACOSX + true, +#endif + PairedDumpCallback, + static_cast<void*>(&incomingDump) +#ifdef XP_WIN32 + , GetMinidumpType() +#endif + )) { + targetMinidump->Remove(false); + targetExtra->Remove(false); + return false; + } + } else { + incomingDump = aIncomingDumpToPair; + } + + RenameAdditionalHangMinidump(incomingDump, targetMinidump, aIncomingPairName); + + if (ShouldReport()) { + MoveToPending(targetMinidump, targetExtra, nullptr); + MoveToPending(incomingDump, nullptr, nullptr); + } + + targetMinidump.forget(aMainDumpOut); + + return true; +} + +bool +CreateAdditionalChildMinidump(ProcessHandle childPid, + ThreadId childBlamedThread, + nsIFile* parentMinidump, + const nsACString& name) +{ + if (!GetEnabled()) + return false; + +#ifdef XP_MACOSX + mach_port_t childThread = GetChildThread(childPid, childBlamedThread); +#else + ThreadId childThread = childBlamedThread; +#endif + + xpstring dump_path; +#ifndef XP_LINUX + dump_path = gExceptionHandler->dump_path(); +#else + dump_path = gExceptionHandler->minidump_descriptor().directory(); +#endif + + // dump the child + nsCOMPtr<nsIFile> childMinidump; + if (!google_breakpad::ExceptionHandler::WriteMinidumpForChild( + childPid, + childThread, + dump_path, + PairedDumpCallback, + static_cast<void*>(&childMinidump) +#ifdef XP_WIN32 + , GetMinidumpType() +#endif + )) { + return false; + } + + RenameAdditionalHangMinidump(childMinidump, parentMinidump, name); + + return true; +} + +bool +UnsetRemoteExceptionHandler() +{ + std::set_terminate(oldTerminateHandler); + delete gExceptionHandler; + gExceptionHandler = nullptr; + return true; +} + +#if defined(MOZ_WIDGET_ANDROID) +void AddLibraryMapping(const char* library_name, + uintptr_t start_address, + size_t mapping_length, + size_t file_offset) +{ + if (!gExceptionHandler) { + mapping_info info; + info.name = library_name; + info.start_address = start_address; + info.length = mapping_length; + info.file_offset = file_offset; + library_mappings.push_back(info); + } + else { + PageAllocator allocator; + auto_wasteful_vector<uint8_t, sizeof(MDGUID)> guid(&allocator); + FileID::ElfFileIdentifierFromMappedFile((void const *)start_address, guid); + gExceptionHandler->AddMappingInfo(library_name, + guid.data(), + start_address, + mapping_length, + file_offset); + } +} +#endif + +} // namespace CrashReporter |