DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (cdf352f02ac4)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
/* -*- 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/. */

#ifndef mozilla_ipc_CrashReporterHost_h
#define mozilla_ipc_CrashReporterHost_h

#include <functional>

#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/Shmem.h"
#include "base/process.h"
#include "nsExceptionHandler.h"
#include "nsThreadUtils.h"
#include "ProtocolUtils.h"

namespace mozilla {
namespace ipc {

// This is the newer replacement for CrashReporterParent. It is created in
// response to a InitCrashReporter message on a top-level actor, and simply
// holds the metadata shmem alive until the process ends. When the process
// terminates abnormally, the top-level should call GenerateCrashReport to
// automatically integrate metadata.
class CrashReporterHost {
  typedef mozilla::ipc::Shmem Shmem;
  typedef CrashReporter::AnnotationTable AnnotationTable;

 public:
  CrashReporterHost(GeckoProcessType aProcessType, const Shmem& aShmem,
                    CrashReporter::ThreadId aThreadId);

  // Helper function for generating a crash report for a process that probably
  // crashed (i.e., had an AbnormalShutdown in ActorDestroy). Returns true if
  // the process has a minidump attached and we were able to generate a report.
  bool GenerateCrashReport(base::ProcessId aPid);

  // Given an existing minidump for a crashed child process, take ownership of
  // it from IPDL. After this, FinalizeCrashReport may be called.
  RefPtr<nsIFile> TakeCrashedChildMinidump(base::ProcessId aPid,
                                           uint32_t* aOutSequence);

  // Replace the stored minidump with a new one. After this,
  // FinalizeCrashReport may be called.
  bool AdoptMinidump(nsIFile* aFile, const AnnotationTable& aAnnotations);

  // If a minidump was already captured (e.g. via the hang reporter), this
  // finalizes the existing report by attaching metadata, writing out the
  // .extra file and notifying the crash service.
  bool FinalizeCrashReport();

  // Generate a paired minidump. This does not take the crash report, as
  // GenerateCrashReport does. After this, FinalizeCrashReport may be called.
  //
  // This calls TakeCrashedChildMinidump and FinalizeCrashReport.
  template <typename Toplevel>
  bool GenerateMinidumpAndPair(Toplevel* aToplevelProtocol,
                               nsIFile* aMinidumpToPair,
                               const nsACString& aPairName) {
    ScopedProcessHandle childHandle;
#ifdef XP_MACOSX
    childHandle = aToplevelProtocol->Process()->GetChildTask();
#else
    if (!base::OpenPrivilegedProcessHandle(aToplevelProtocol->OtherPid(),
                                           &childHandle.rwget())) {
      NS_WARNING("Failed to open child process handle.");
      return false;
    }
#endif

    nsCOMPtr<nsIFile> targetDump;
    if (!CrashReporter::CreateMinidumpsAndPair(
            childHandle, mThreadId, aPairName, aMinidumpToPair,
            mExtraAnnotations, getter_AddRefs(targetDump))) {
      return false;
    }

    return CrashReporter::GetIDFromMinidump(targetDump, mDumpID);
  }

  void AddAnnotation(CrashReporter::Annotation aKey, bool aValue);
  void AddAnnotation(CrashReporter::Annotation aKey, int aValue);
  void AddAnnotation(CrashReporter::Annotation aKey, unsigned int aValue);
  void AddAnnotation(CrashReporter::Annotation aKey, const nsACString& aValue);

  bool HasMinidump() const { return !mDumpID.IsEmpty(); }
  const nsString& MinidumpID() const {
    MOZ_ASSERT(HasMinidump());
    return mDumpID;
  }
  const nsCString& AdditionalMinidumps() const {
    return mExtraAnnotations[CrashReporter::Annotation::additional_minidumps];
  }

  // Return `true` if this crash reporter has been identified as a likely OOM.
  //
  // At the time of this writing, OOMs detection is considered reliable under
  // Windows but other platforms quite often return false negatives.
  //
  // `CrashReporterHost::FinalizeCrashReport()` MUST have been called already.
  bool IsLikelyOOM();

  // This is a static helper function to notify the crash service that a
  // crash has occurred and record the crash with telemetry. This can be called
  // from any thread, and if not called from the main thread, will post a
  // synchronous message to the main thread.
  static void RecordCrash(GeckoProcessType aProcessType, int32_t aCrashType,
                          const nsString& aChildDumpID);

 private:
  // Get the nsICrashService crash type to use for an impending crash.
  int32_t GetCrashType();

  static void RecordCrashWithTelemetry(GeckoProcessType aProcessType,
                                       int32_t aCrashType);
  static void NotifyCrashService(GeckoProcessType aProcessType,
                                 int32_t aCrashType,
                                 const nsString& aChildDumpID);

 private:
  GeckoProcessType mProcessType;
  Shmem mShmem;
  CrashReporter::ThreadId mThreadId;
  time_t mStartTime;
  AnnotationTable mExtraAnnotations;
  nsString mDumpID;
  bool mFinalized;
};

}  // namespace ipc
}  // namespace mozilla

#endif  // mozilla_ipc_CrashReporterHost_h