/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "mozilla/JSONWriter.h" #include "mozilla/UniquePtr.h" #include "mozilla/nsMemoryInfoDumper.h" #include "mozilla/DebugOnly.h" #include "nsDumpUtils.h" #include "mozilla/Unused.h" #include "mozilla/dom/ContentParent.h" #include "mozilla/dom/ContentChild.h" #include "nsIConsoleService.h" #include "nsCycleCollector.h" #include "nsICycleCollectorListener.h" #include "nsIMemoryReporter.h" #include "nsDirectoryServiceDefs.h" #include "nsGZFileWriter.h" #include "nsJSEnvironment.h" #include "nsPrintfCString.h" #include "nsISimpleEnumerator.h" #include "nsServiceManagerUtils.h" #include "nsIFile.h" #ifdef XP_WIN #include <process.h> #ifndef getpid #define getpid _getpid #endif #else #include <unistd.h> #endif #ifdef XP_UNIX #define MOZ_SUPPORTS_FIFO 1 #endif #if defined(XP_LINUX) || defined(__FreeBSD__) #define MOZ_SUPPORTS_RT_SIGNALS 1 #endif #if defined(MOZ_SUPPORTS_RT_SIGNALS) #include <fcntl.h> #include <sys/types.h> #include <sys/stat.h> #endif #if defined(MOZ_SUPPORTS_FIFO) #include "mozilla/Preferences.h" #endif using namespace mozilla; using namespace mozilla::dom; namespace { class DumpMemoryInfoToTempDirRunnable : public Runnable { public: DumpMemoryInfoToTempDirRunnable(const nsAString& aIdentifier, bool aAnonymize, bool aMinimizeMemoryUsage) : mIdentifier(aIdentifier) , mAnonymize(aAnonymize) , mMinimizeMemoryUsage(aMinimizeMemoryUsage) { } NS_IMETHOD Run() override { nsCOMPtr<nsIMemoryInfoDumper> dumper = do_GetService("@mozilla.org/memory-info-dumper;1"); dumper->DumpMemoryInfoToTempDir(mIdentifier, mAnonymize, mMinimizeMemoryUsage); return NS_OK; } private: const nsString mIdentifier; const bool mAnonymize; const bool mMinimizeMemoryUsage; }; class GCAndCCLogDumpRunnable final : public Runnable , public nsIDumpGCAndCCLogsCallback { public: NS_DECL_ISUPPORTS_INHERITED GCAndCCLogDumpRunnable(const nsAString& aIdentifier, bool aDumpAllTraces, bool aDumpChildProcesses) : mIdentifier(aIdentifier) , mDumpAllTraces(aDumpAllTraces) , mDumpChildProcesses(aDumpChildProcesses) { } NS_IMETHOD Run() override { nsCOMPtr<nsIMemoryInfoDumper> dumper = do_GetService("@mozilla.org/memory-info-dumper;1"); dumper->DumpGCAndCCLogsToFile(mIdentifier, mDumpAllTraces, mDumpChildProcesses, this); return NS_OK; } NS_IMETHOD OnDump(nsIFile* aGCLog, nsIFile* aCCLog, bool aIsParent) override { return NS_OK; } NS_IMETHOD OnFinish() override { return NS_OK; } private: ~GCAndCCLogDumpRunnable() {} const nsString mIdentifier; const bool mDumpAllTraces; const bool mDumpChildProcesses; }; NS_IMPL_ISUPPORTS_INHERITED(GCAndCCLogDumpRunnable, Runnable, nsIDumpGCAndCCLogsCallback) } // namespace #if defined(MOZ_SUPPORTS_RT_SIGNALS) // { namespace { /* * The following code supports dumping about:memory upon receiving a signal. * * We listen for the following signals: * * - SIGRTMIN: Dump our memory reporters (and those of our child * processes), * - SIGRTMIN + 1: Dump our memory reporters (and those of our child * processes) after minimizing memory usage, and * - SIGRTMIN + 2: Dump the GC and CC logs in this and our child processes. * * When we receive one of these signals, we write the signal number to a pipe. * The IO thread then notices that the pipe has been written to, and kicks off * the appropriate task on the main thread. * * This scheme is similar to using signalfd(), except it's portable and it * doesn't require the use of sigprocmask, which is problematic because it * masks signals received by child processes. * * In theory, we could use Chromium's MessageLoopForIO::CatchSignal() for this. * But that uses libevent, which does not handle the realtime signals (bug * 794074). */ // It turns out that at least on some systems, SIGRTMIN is not a compile-time // constant, so these have to be set at runtime. static uint8_t sDumpAboutMemorySignum; // SIGRTMIN static uint8_t sDumpAboutMemoryAfterMMUSignum; // SIGRTMIN + 1 static uint8_t sGCAndCCDumpSignum; // SIGRTMIN + 2 void doMemoryReport(const uint8_t aRecvSig) { // Dump our memory reports (but run this on the main thread!). bool minimize = aRecvSig == sDumpAboutMemoryAfterMMUSignum; LOG("SignalWatcher(sig %d) dispatching memory report runnable.", aRecvSig); RefPtr<DumpMemoryInfoToTempDirRunnable> runnable = new DumpMemoryInfoToTempDirRunnable(/* identifier = */ EmptyString(), /* anonymize = */ false, minimize); NS_DispatchToMainThread(runnable); } void doGCCCDump(const uint8_t aRecvSig) { LOG("SignalWatcher(sig %d) dispatching GC/CC log runnable.", aRecvSig); // Dump GC and CC logs (from the main thread). RefPtr<GCAndCCLogDumpRunnable> runnable = new GCAndCCLogDumpRunnable(/* identifier = */ EmptyString(), /* allTraces = */ true, /* dumpChildProcesses = */ true); NS_DispatchToMainThread(runnable); } } // namespace #endif // MOZ_SUPPORTS_RT_SIGNALS } #if defined(MOZ_SUPPORTS_FIFO) // { namespace { void doMemoryReport(const nsCString& aInputStr) { bool minimize = aInputStr.EqualsLiteral("minimize memory report"); LOG("FifoWatcher(command:%s) dispatching memory report runnable.", aInputStr.get()); RefPtr<DumpMemoryInfoToTempDirRunnable> runnable = new DumpMemoryInfoToTempDirRunnable(/* identifier = */ EmptyString(), /* anonymize = */ false, minimize); NS_DispatchToMainThread(runnable); } void doGCCCDump(const nsCString& aInputStr) { bool doAllTracesGCCCDump = aInputStr.EqualsLiteral("gc log"); LOG("FifoWatcher(command:%s) dispatching GC/CC log runnable.", aInputStr.get()); RefPtr<GCAndCCLogDumpRunnable> runnable = new GCAndCCLogDumpRunnable(/* identifier = */ EmptyString(), doAllTracesGCCCDump, /* dumpChildProcesses = */ true); NS_DispatchToMainThread(runnable); } bool SetupFifo() { #ifdef DEBUG static bool fifoCallbacksRegistered = false; #endif if (!FifoWatcher::MaybeCreate()) { return false; } MOZ_ASSERT(!fifoCallbacksRegistered, "FifoWatcher callbacks should be registered only once"); FifoWatcher* fw = FifoWatcher::GetSingleton(); // Dump our memory reports (but run this on the main thread!). fw->RegisterCallback(NS_LITERAL_CSTRING("memory report"), doMemoryReport); fw->RegisterCallback(NS_LITERAL_CSTRING("minimize memory report"), doMemoryReport); // Dump GC and CC logs (from the main thread). fw->RegisterCallback(NS_LITERAL_CSTRING("gc log"), doGCCCDump); fw->RegisterCallback(NS_LITERAL_CSTRING("abbreviated gc log"), doGCCCDump); #ifdef DEBUG fifoCallbacksRegistered = true; #endif return true; } void OnFifoEnabledChange(const char* /*unused*/, void* /*unused*/) { LOG("%s changed", FifoWatcher::kPrefName); if (SetupFifo()) { Preferences::UnregisterCallback(OnFifoEnabledChange, FifoWatcher::kPrefName, nullptr); } } } // namespace #endif // MOZ_SUPPORTS_FIFO } NS_IMPL_ISUPPORTS(nsMemoryInfoDumper, nsIMemoryInfoDumper) nsMemoryInfoDumper::nsMemoryInfoDumper() { } nsMemoryInfoDumper::~nsMemoryInfoDumper() { } /* static */ void nsMemoryInfoDumper::Initialize() { #if defined(MOZ_SUPPORTS_RT_SIGNALS) SignalPipeWatcher* sw = SignalPipeWatcher::GetSingleton(); // Dump memory reporters (and those of our child processes) sDumpAboutMemorySignum = SIGRTMIN; sw->RegisterCallback(sDumpAboutMemorySignum, doMemoryReport); // Dump our memory reporters after minimizing memory usage sDumpAboutMemoryAfterMMUSignum = SIGRTMIN + 1; sw->RegisterCallback(sDumpAboutMemoryAfterMMUSignum, doMemoryReport); // Dump the GC and CC logs in this and our child processes. sGCAndCCDumpSignum = SIGRTMIN + 2; sw->RegisterCallback(sGCAndCCDumpSignum, doGCCCDump); #endif #if defined(MOZ_SUPPORTS_FIFO) if (!SetupFifo()) { // NB: This gets loaded early enough that it's possible there is a user pref // set to enable the fifo watcher that has not been loaded yet. Register // to attempt to initialize if the fifo watcher becomes enabled by // a user pref. Preferences::RegisterCallback(OnFifoEnabledChange, FifoWatcher::kPrefName, nullptr); } #endif } static void EnsureNonEmptyIdentifier(nsAString& aIdentifier) { if (!aIdentifier.IsEmpty()) { return; } // If the identifier is empty, set it to the number of whole seconds since the // epoch. This identifier will appear in the files that this process // generates and also the files generated by this process's children, allowing // us to identify which files are from the same memory report request. aIdentifier.AppendInt(static_cast<int64_t>(PR_Now()) / 1000000); } // Use XPCOM refcounting to fire |onFinish| when all reference-holders // (remote dump actors or the |DumpGCAndCCLogsToFile| activation itself) // have gone away. class nsDumpGCAndCCLogsCallbackHolder final : public nsIDumpGCAndCCLogsCallback { public: NS_DECL_ISUPPORTS explicit nsDumpGCAndCCLogsCallbackHolder(nsIDumpGCAndCCLogsCallback* aCallback) : mCallback(aCallback) { } NS_IMETHOD OnFinish() override { return NS_ERROR_UNEXPECTED; } NS_IMETHOD OnDump(nsIFile* aGCLog, nsIFile* aCCLog, bool aIsParent) override { return mCallback->OnDump(aGCLog, aCCLog, aIsParent); } private: ~nsDumpGCAndCCLogsCallbackHolder() { Unused << mCallback->OnFinish(); } nsCOMPtr<nsIDumpGCAndCCLogsCallback> mCallback; }; NS_IMPL_ISUPPORTS(nsDumpGCAndCCLogsCallbackHolder, nsIDumpGCAndCCLogsCallback) NS_IMETHODIMP nsMemoryInfoDumper::DumpGCAndCCLogsToFile(const nsAString& aIdentifier, bool aDumpAllTraces, bool aDumpChildProcesses, nsIDumpGCAndCCLogsCallback* aCallback) { nsString identifier(aIdentifier); EnsureNonEmptyIdentifier(identifier); nsCOMPtr<nsIDumpGCAndCCLogsCallback> callbackHolder = new nsDumpGCAndCCLogsCallbackHolder(aCallback); if (aDumpChildProcesses) { nsTArray<ContentParent*> children; ContentParent::GetAll(children); for (uint32_t i = 0; i < children.Length(); i++) { ContentParent* cp = children[i]; nsCOMPtr<nsICycleCollectorLogSink> logSink = nsCycleCollector_createLogSink(); logSink->SetFilenameIdentifier(identifier); logSink->SetProcessIdentifier(cp->Pid()); Unused << cp->CycleCollectWithLogs(aDumpAllTraces, logSink, callbackHolder); } } nsCOMPtr<nsICycleCollectorListener> logger = do_CreateInstance("@mozilla.org/cycle-collector-logger;1"); if (aDumpAllTraces) { nsCOMPtr<nsICycleCollectorListener> allTracesLogger; logger->AllTraces(getter_AddRefs(allTracesLogger)); logger = allTracesLogger; } nsCOMPtr<nsICycleCollectorLogSink> logSink; logger->GetLogSink(getter_AddRefs(logSink)); logSink->SetFilenameIdentifier(identifier); nsJSContext::CycleCollectNow(logger); nsCOMPtr<nsIFile> gcLog, ccLog; logSink->GetGcLog(getter_AddRefs(gcLog)); logSink->GetCcLog(getter_AddRefs(ccLog)); callbackHolder->OnDump(gcLog, ccLog, /* parent = */ true); return NS_OK; } NS_IMETHODIMP nsMemoryInfoDumper::DumpGCAndCCLogsToSink(bool aDumpAllTraces, nsICycleCollectorLogSink* aSink) { nsCOMPtr<nsICycleCollectorListener> logger = do_CreateInstance("@mozilla.org/cycle-collector-logger;1"); if (aDumpAllTraces) { nsCOMPtr<nsICycleCollectorListener> allTracesLogger; logger->AllTraces(getter_AddRefs(allTracesLogger)); logger = allTracesLogger; } logger->SetLogSink(aSink); nsJSContext::CycleCollectNow(logger); return NS_OK; } static void MakeFilename(const char* aPrefix, const nsAString& aIdentifier, int aPid, const char* aSuffix, nsACString& aResult) { aResult = nsPrintfCString("%s-%s-%d.%s", aPrefix, NS_ConvertUTF16toUTF8(aIdentifier).get(), aPid, aSuffix); } // This class wraps GZFileWriter so it can be used with JSONWriter, overcoming // the following two problems: // - It provides a JSONWriterFunc::Write() that calls nsGZFileWriter::Write(). // - It can be stored as a UniquePtr, whereas nsGZFileWriter is refcounted. class GZWriterWrapper : public JSONWriteFunc { public: explicit GZWriterWrapper(nsGZFileWriter* aGZWriter) : mGZWriter(aGZWriter) {} void Write(const char* aStr) { // Ignore any failure because JSONWriteFunc doesn't have a mechanism for // handling errors. Unused << mGZWriter->Write(aStr); } nsresult Finish() { return mGZWriter->Finish(); } private: RefPtr<nsGZFileWriter> mGZWriter; }; // We need two callbacks: one that handles reports, and one that is called at // the end of reporting. Both the callbacks need access to the same JSONWriter, // so we implement both of them in this one class. class HandleReportAndFinishReportingCallbacks final : public nsIHandleReportCallback, public nsIFinishReportingCallback { public: NS_DECL_ISUPPORTS HandleReportAndFinishReportingCallbacks(UniquePtr<JSONWriter> aWriter, nsIFinishDumpingCallback* aFinishDumping, nsISupports* aFinishDumpingData) : mWriter(Move(aWriter)) , mFinishDumping(aFinishDumping) , mFinishDumpingData(aFinishDumpingData) { } // This is the callback for nsIHandleReportCallback. NS_IMETHOD Callback(const nsACString& aProcess, const nsACString& aPath, int32_t aKind, int32_t aUnits, int64_t aAmount, const nsACString& aDescription, nsISupports* aData) override { nsAutoCString process; if (aProcess.IsEmpty()) { // If the process is empty, the report originated with the process doing // the dumping. In that case, generate the process identifier, which is // of the form "$PROCESS_NAME (pid $PID)", or just "(pid $PID)" if we // don't have a process name. If we're the main process, we let // $PROCESS_NAME be "Main Process". if (XRE_IsParentProcess()) { // We're the main process. process.AssignLiteral("Main Process"); } else if (ContentChild* cc = ContentChild::GetSingleton()) { // Try to get the process name from ContentChild. cc->GetProcessName(process); } ContentChild::AppendProcessId(process); } else { // Otherwise, the report originated with another process and already has a // process name. Just use that. process = aProcess; } mWriter->StartObjectElement(); { mWriter->StringProperty("process", process.get()); mWriter->StringProperty("path", PromiseFlatCString(aPath).get()); mWriter->IntProperty("kind", aKind); mWriter->IntProperty("units", aUnits); mWriter->IntProperty("amount", aAmount); mWriter->StringProperty("description", PromiseFlatCString(aDescription).get()); } mWriter->EndObject(); return NS_OK; } // This is the callback for nsIFinishReportingCallback. NS_IMETHOD Callback(nsISupports* aData) override { mWriter->EndArray(); // end of "reports" array mWriter->End(); // The call to Finish() deallocates the memory allocated by the first Write // call. Because that memory was live while the memory reporters ran and // was measured by them -- by "heap-allocated" if nothing else -- we want // DMD to see it as well. So we deliberately don't call Finish() until // after DMD finishes. nsresult rv = static_cast<GZWriterWrapper*>(mWriter->WriteFunc())->Finish(); NS_ENSURE_SUCCESS(rv, rv); if (!mFinishDumping) { return NS_OK; } return mFinishDumping->Callback(mFinishDumpingData); } private: ~HandleReportAndFinishReportingCallbacks() {} UniquePtr<JSONWriter> mWriter; nsCOMPtr<nsIFinishDumpingCallback> mFinishDumping; nsCOMPtr<nsISupports> mFinishDumpingData; }; NS_IMPL_ISUPPORTS(HandleReportAndFinishReportingCallbacks, nsIHandleReportCallback, nsIFinishReportingCallback) class TempDirFinishCallback final : public nsIFinishDumpingCallback { public: NS_DECL_ISUPPORTS TempDirFinishCallback(nsIFile* aReportsTmpFile, const nsCString& aReportsFinalFilename) : mReportsTmpFile(aReportsTmpFile) , mReportsFilename(aReportsFinalFilename) { } NS_IMETHOD Callback(nsISupports* aData) override { // Rename the memory reports file, now that we're done writing all the // files. Its final name is "memory-report<-identifier>-<pid>.json.gz". nsCOMPtr<nsIFile> reportsFinalFile; nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(reportsFinalFile)); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } #ifdef ANDROID rv = reportsFinalFile->AppendNative(NS_LITERAL_CSTRING("memory-reports")); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } #endif rv = reportsFinalFile->AppendNative(mReportsFilename); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } rv = reportsFinalFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } nsAutoString reportsFinalFilename; rv = reportsFinalFile->GetLeafName(reportsFinalFilename); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } rv = mReportsTmpFile->MoveTo(/* directory */ nullptr, reportsFinalFilename); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } // Write a message to the console. nsCOMPtr<nsIConsoleService> cs = do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } nsString path; mReportsTmpFile->GetPath(path); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } nsString msg = NS_LITERAL_STRING("nsIMemoryInfoDumper dumped reports to "); msg.Append(path); return cs->LogStringMessage(msg.get()); } private: ~TempDirFinishCallback() {} nsCOMPtr<nsIFile> mReportsTmpFile; nsCString mReportsFilename; }; NS_IMPL_ISUPPORTS(TempDirFinishCallback, nsIFinishDumpingCallback) static nsresult DumpMemoryInfoToFile( nsIFile* aReportsFile, nsIFinishDumpingCallback* aFinishDumping, nsISupports* aFinishDumpingData, bool aAnonymize, bool aMinimizeMemoryUsage, nsAString& aDMDIdentifier) { RefPtr<nsGZFileWriter> gzWriter = new nsGZFileWriter(); nsresult rv = gzWriter->Init(aReportsFile); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } auto jsonWriter = MakeUnique<JSONWriter>(MakeUnique<GZWriterWrapper>(gzWriter)); nsCOMPtr<nsIMemoryReporterManager> mgr = do_GetService("@mozilla.org/memory-reporter-manager;1"); // This is the first write to the file, and it causes |aWriter| to allocate // over 200 KiB of memory. jsonWriter->Start(); { // Increment this number if the format changes. jsonWriter->IntProperty("version", 1); jsonWriter->BoolProperty("hasMozMallocUsableSize", mgr->GetHasMozMallocUsableSize()); jsonWriter->StartArrayProperty("reports"); } RefPtr<HandleReportAndFinishReportingCallbacks> handleReportAndFinishReporting = new HandleReportAndFinishReportingCallbacks(Move(jsonWriter), aFinishDumping, aFinishDumpingData); rv = mgr->GetReportsExtended(handleReportAndFinishReporting, nullptr, handleReportAndFinishReporting, nullptr, aAnonymize, aMinimizeMemoryUsage, aDMDIdentifier); return rv; } NS_IMETHODIMP nsMemoryInfoDumper::DumpMemoryReportsToNamedFile( const nsAString& aFilename, nsIFinishDumpingCallback* aFinishDumping, nsISupports* aFinishDumpingData, bool aAnonymize) { MOZ_ASSERT(!aFilename.IsEmpty()); // Create the file. nsCOMPtr<nsIFile> reportsFile; nsresult rv = NS_NewLocalFile(aFilename, false, getter_AddRefs(reportsFile)); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } reportsFile->InitWithPath(aFilename); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } bool exists; rv = reportsFile->Exists(&exists); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } if (!exists) { rv = reportsFile->Create(nsIFile::NORMAL_FILE_TYPE, 0644); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } } nsString dmdIdent = EmptyString(); return DumpMemoryInfoToFile(reportsFile, aFinishDumping, aFinishDumpingData, aAnonymize, /* minimizeMemoryUsage = */ false, dmdIdent); } NS_IMETHODIMP nsMemoryInfoDumper::DumpMemoryInfoToTempDir(const nsAString& aIdentifier, bool aAnonymize, bool aMinimizeMemoryUsage) { nsString identifier(aIdentifier); EnsureNonEmptyIdentifier(identifier); // Open a new file named something like // // incomplete-memory-report-<identifier>-<pid>.json.gz // // in NS_OS_TEMP_DIR for writing. When we're finished writing the report, // we'll rename this file and get rid of the "incomplete-" prefix. // // We do this because we don't want scripts which poll the filesystem // looking for memory report dumps to grab a file before we're finished // writing to it. // The "unified" indicates that we merge the memory reports from all // processes and write out one file, rather than a separate file for // each process as was the case before bug 946407. This is so that // the get_about_memory.py script in the B2G repository can // determine when it's done waiting for files to appear. nsCString reportsFinalFilename; MakeFilename("unified-memory-report", identifier, getpid(), "json.gz", reportsFinalFilename); nsCOMPtr<nsIFile> reportsTmpFile; nsresult rv; // In Android case, this function will open a file named aFilename under // specific folder (/data/local/tmp/memory-reports). Otherwise, it will // open a file named aFilename under "NS_OS_TEMP_DIR". rv = nsDumpUtils::OpenTempFile(NS_LITERAL_CSTRING("incomplete-") + reportsFinalFilename, getter_AddRefs(reportsTmpFile), NS_LITERAL_CSTRING("memory-reports")); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } RefPtr<TempDirFinishCallback> finishDumping = new TempDirFinishCallback(reportsTmpFile, reportsFinalFilename); return DumpMemoryInfoToFile(reportsTmpFile, finishDumping, nullptr, aAnonymize, aMinimizeMemoryUsage, identifier); } #ifdef MOZ_DMD dmd::DMDFuncs::Singleton dmd::DMDFuncs::sSingleton; nsresult nsMemoryInfoDumper::OpenDMDFile(const nsAString& aIdentifier, int aPid, FILE** aOutFile) { if (!dmd::IsRunning()) { *aOutFile = nullptr; return NS_OK; } // Create a filename like dmd-<identifier>-<pid>.json.gz, which will be used // if DMD is enabled. nsCString dmdFilename; MakeFilename("dmd", aIdentifier, aPid, "json.gz", dmdFilename); // Open a new DMD file named |dmdFilename| in NS_OS_TEMP_DIR for writing, // and dump DMD output to it. This must occur after the memory reporters // have been run (above), but before the memory-reports file has been // renamed (so scripts can detect the DMD file, if present). nsresult rv; nsCOMPtr<nsIFile> dmdFile; rv = nsDumpUtils::OpenTempFile(dmdFilename, getter_AddRefs(dmdFile), NS_LITERAL_CSTRING("memory-reports")); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } rv = dmdFile->OpenANSIFileDesc("wb", aOutFile); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "OpenANSIFileDesc failed"); // Print the path, because on some platforms (e.g. Mac) it's not obvious. nsCString path; rv = dmdFile->GetNativePath(path); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } dmd::StatusMsg("opened %s for writing\n", path.get()); return rv; } nsresult nsMemoryInfoDumper::DumpDMDToFile(FILE* aFile) { RefPtr<nsGZFileWriter> gzWriter = new nsGZFileWriter(); nsresult rv = gzWriter->InitANSIFileDesc(aFile); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } // Dump DMD's memory reports analysis to the file. dmd::Analyze(MakeUnique<GZWriterWrapper>(gzWriter)); rv = gzWriter->Finish(); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Finish failed"); return rv; } #endif // MOZ_DMD