chrome_frame/crash_reporting/crash_report.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // crash_report.cc : Implementation crash reporting.
   6 #include "chrome_frame/crash_reporting/crash_report.h"
   7
   8 #include "base/basictypes.h"
   9 #include "base/synchronization/lock.h"
  10 #include "breakpad/src/client/windows/handler/exception_handler.h"
  11 #include "chrome_frame/crash_reporting/crash_metrics.h"
  12
  13 // TODO(joshia): factor out common code with chrome used for crash reporting
  14 const wchar_t kGoogleUpdatePipeName[] = L"\\\\.\\pipe\\GoogleCrashServices\\";
  15
  16 // This lock protects against concurrent access to g_breakpad.
  17 static base::Lock g_breakpad_lock;
  18 static google_breakpad::ExceptionHandler* g_breakpad = NULL;
  19
  20 // These minidump flag combinations have been tested safe against the
  21 // DbgHelp.dll version that ships with Windows XP SP2.
  22 const MINIDUMP_TYPE kSmallDumpType = static_cast<MINIDUMP_TYPE>(
  23     MiniDumpWithProcessThreadData |  // Get PEB and TEB.
  24     MiniDumpWithUnloadedModules);  // Get unloaded modules when available.
  25
  26 const MINIDUMP_TYPE kLargerDumpType = static_cast<MINIDUMP_TYPE>(
  27     MiniDumpWithProcessThreadData |  // Get PEB and TEB.
  28     MiniDumpWithUnloadedModules |  // Get unloaded modules when available.
  29     MiniDumpWithIndirectlyReferencedMemory);  // Get memory referenced by stack.
  30
  31 // Large dump with all process memory.
  32 const MINIDUMP_TYPE kFullDumpType = static_cast<MINIDUMP_TYPE>(
  33     MiniDumpWithFullMemory |  // Full memory from process.
  34     MiniDumpWithProcessThreadData |  // Get PEB and TEB.
  35     MiniDumpWithHandleData |  // Get all handle information.
  36     MiniDumpWithUnloadedModules);  // Get unloaded modules when available.
  37
  38 #pragma code_seg(push, ".text$va")
  39 static void veh_segment_start() {}
  40 #pragma code_seg(pop)
  41
  42 #pragma code_seg(push, ".text$vz")
  43 static void veh_segment_end() {}
  44 #pragma code_seg(pop)
  45
  46 // Place code in .text$veh_m.
  47 #pragma code_seg(push, ".text$vm")
  48 #include "chrome_frame/crash_reporting/vectored_handler-impl.h"
  49
  50 class CrashHandler {
  51  public:
  52   CrashHandler() : veh_id_(NULL), handler_(&crash_api_) {}
  53
  54   // Note that breakpad_lock is used to protect accesses to breakpad and must
  55   // be held when Init() is called.
  56   bool Init(google_breakpad::ExceptionHandler* breakpad,
  57             base::Lock* breakpad_lock);
  58
  59   void Shutdown();
  60  private:
  61   VectoredHandlerT<CrashHandlerTraits> handler_;
  62   CrashHandlerTraits crash_api_;
  63   void* veh_id_;
  64
  65   static LONG WINAPI VectoredHandlerEntryPoint(EXCEPTION_POINTERS* exptrs);
  66 };
  67
  68 static CrashHandler g_crash_handler;
  69
  70 // Turn off FPO optimization, so ::RtlCaptureStackBackTrace returns sane result.
  71 #pragma optimize("y", off)
  72 LONG WINAPI CrashHandler::VectoredHandlerEntryPoint(
  73     EXCEPTION_POINTERS* exptrs) {
  74   return g_crash_handler.handler_.Handler(exptrs);
  75 }
  76 #pragma optimize("y", on)
  77
  78 #pragma code_seg(pop)
  79
  80 bool CrashHandler::Init(google_breakpad::ExceptionHandler* breakpad,
  81                         base::Lock* breakpad_lock) {
  82   DCHECK(breakpad);
  83   DCHECK(breakpad_lock);
  84   breakpad_lock->AssertAcquired();
  85
  86   if (veh_id_)
  87     return true;
  88
  89   crash_api_.Init(&veh_segment_start, &veh_segment_end,
  90                   &WriteMinidumpForException);
  91
  92   void* id = ::AddVectoredExceptionHandler(FALSE, &VectoredHandlerEntryPoint);
  93   if (id != NULL) {
  94     veh_id_ = id;
  95     return true;
  96   } else {
  97     crash_api_.Shutdown();
  98     return false;
  99   }
 100 }
 101
 102 void CrashHandler::Shutdown() {
 103   if (veh_id_) {
 104     ::RemoveVectoredExceptionHandler(veh_id_);
 105     veh_id_ = NULL;
 106   }
 107
 108   crash_api_.Shutdown();
 109 }
 110
 111 std::wstring GetCrashServerPipeName(const std::wstring& user_sid) {
 112   std::wstring pipe_name = kGoogleUpdatePipeName;
 113   pipe_name += user_sid;
 114   return pipe_name;
 115 }
 116
 117 bool InitializeVectoredCrashReportingWithPipeName(
 118     bool full_dump,
 119     const wchar_t* pipe_name,
 120     const std::wstring& dump_path,
 121     google_breakpad::CustomClientInfo* client_info) {
 122   base::AutoLock lock(g_breakpad_lock);
 123   if (g_breakpad)
 124     return true;
 125
 126   if (dump_path.empty()) {
 127     return false;
 128   }
 129
 130   // TODO(siggi): Consider switching to kSmallerDumpType post-beta.
 131   MINIDUMP_TYPE dump_type = full_dump ? kFullDumpType : kLargerDumpType;
 132   g_breakpad = new google_breakpad::ExceptionHandler(
 133       dump_path, NULL, NULL, NULL,
 134       google_breakpad::ExceptionHandler::HANDLER_INVALID_PARAMETER |
 135       google_breakpad::ExceptionHandler::HANDLER_PURECALL, dump_type,
 136       pipe_name, client_info);
 137
 138   if (!g_breakpad)
 139     return false;
 140
 141   if (!g_crash_handler.Init(g_breakpad, &g_breakpad_lock)) {
 142     delete g_breakpad;
 143     g_breakpad = NULL;
 144     return false;
 145   }
 146
 147   return true;
 148 }
 149
 150 bool InitializeVectoredCrashReporting(
 151     bool full_dump,
 152     const wchar_t* user_sid,
 153     const std::wstring& dump_path,
 154     google_breakpad::CustomClientInfo* client_info) {
 155   DCHECK(user_sid);
 156   DCHECK(client_info);
 157
 158   std::wstring pipe_name = GetCrashServerPipeName(user_sid);
 159
 160   return InitializeVectoredCrashReportingWithPipeName(full_dump,
 161                                                       pipe_name.c_str(),
 162                                                       dump_path,
 163                                                       client_info);
 164 }
 165
 166 bool ShutdownVectoredCrashReporting() {
 167   g_crash_handler.Shutdown();
 168   base::AutoLock lock(g_breakpad_lock);
 169   delete g_breakpad;
 170   g_breakpad = NULL;
 171   return true;
 172 }
 173
 174 bool WriteMinidumpForException(EXCEPTION_POINTERS* p) {
 175   base::AutoLock lock(g_breakpad_lock);
 176   CrashMetricsReporter::GetInstance()->IncrementMetric(
 177       CrashMetricsReporter::CRASH_COUNT);
 178   bool success = false;
 179   if (g_breakpad) {
 180     success = g_breakpad->WriteMinidumpForException(p);
 181   }
 182   return success;
 183 }