remoting/base/breakpad_win.cc

   1 // Copyright (c) 2012 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 // This module contains the necessary code to register the Breakpad exception
   6 // handler. This implementation is based on Chrome/Chrome Frame crash reporting
   7 // code. See:
   8 //   - src/components/breakpad/app/breakpad_win.cc
   9 //   - src/chrome_frame/crash_server_init.cc
  10 //   - src/chrome/installer/setup/setup_main.cc
  11 //   - src/chrome_frame/crash_reporting/crash_report.cc
  12
  13 #include "remoting/base/breakpad.h"
  14
  15 #include <windows.h>
  16 #include <string>
  17
  18 #include "base/atomicops.h"
  19 #include "base/file_version_info.h"
  20 #include "base/lazy_instance.h"
  21 #include "base/logging.h"
  22 #include "base/memory/scoped_ptr.h"
  23 #include "base/process/memory.h"
  24 #include "base/strings/utf_string_conversions.h"
  25 #include "base/win/wrapped_window_proc.h"
  26 #include "breakpad/src/client/windows/handler/exception_handler.h"
  27
  28 namespace remoting {
  29 void InitializeCrashReportingForTest(const wchar_t* pipe_name);
  30 }  // namespace remoting
  31
  32 namespace {
  33
  34 const wchar_t kBreakpadProductName[] = L"Chromoting";
  35 const wchar_t kBreakpadVersionEntry[] = L"ver";
  36 const wchar_t kBreakpadVersionDefault[] = L"0.1.0.0";
  37 const wchar_t kBreakpadProdEntry[] = L"prod";
  38 const wchar_t kBreakpadPlatformEntry[] = L"plat";
  39 const wchar_t kBreakpadPlatformWin32[] = L"Win32";
  40
  41 // The protocol for connecting to the out-of-process Breakpad crash
  42 // reporter is different for x86-32 and x86-64: the message sizes
  43 // are different because the message struct contains a pointer.  As
  44 // a result, there are two different named pipes to connect to.  The
  45 // 64-bit one is distinguished with an "-x64" suffix.
  46 #if defined(_WIN64)
  47 const wchar_t kGoogleUpdatePipeName[] =
  48     L"\\\\.\\pipe\\GoogleCrashServices\\S-1-5-18-x64";
  49 #else
  50 const wchar_t kGoogleUpdatePipeName[] =
  51     L"\\\\.\\pipe\\GoogleCrashServices\\S-1-5-18";
  52 #endif
  53
  54 using base::subtle::AtomicWord;
  55 using base::subtle::NoBarrier_CompareAndSwap;
  56
  57 class BreakpadWin {
  58  public:
  59   BreakpadWin();
  60   ~BreakpadWin();
  61
  62   static BreakpadWin* GetInstance();
  63
  64  private:
  65   // Returns the Custom information to be used for crash reporting.
  66   google_breakpad::CustomClientInfo* GetCustomInfo();
  67
  68   // This callback is executed when the process has crashed and *before*
  69   // the crash dump is created. To prevent duplicate crash reports we
  70   // make every thread calling this method, except the very first one,
  71   // go to sleep.
  72   static bool OnExceptionCallback(void* context,
  73                                   EXCEPTION_POINTERS* exinfo,
  74                                   MDRawAssertionInfo* assertion);
  75
  76   // Crashes the process after generating a dump for the provided exception.
  77   // Note that the crash reporter should be initialized before calling this
  78   // function for it to do anything.
  79   static int OnWindowProcedureException(EXCEPTION_POINTERS* exinfo);
  80
  81   // Breakpad's exception handler.
  82   scoped_ptr<google_breakpad::ExceptionHandler> breakpad_;
  83
  84   // This flag is used to indicate that an exception is already being handled.
  85   volatile AtomicWord handling_exception_;
  86
  87   // The testing hook below allows overriding the crash server pipe name.
  88   static const wchar_t* pipe_name_;
  89
  90   friend void ::remoting::InitializeCrashReportingForTest(const wchar_t*);
  91
  92   DISALLOW_COPY_AND_ASSIGN(BreakpadWin);
  93 };
  94
  95 // |LazyInstance| is used to guarantee that the exception handler will be
  96 // initialized exactly once.
  97 // N.B. LazyInstance does not allow this to be a static member of the class.
  98 static base::LazyInstance<BreakpadWin>::Leaky g_instance =
  99     LAZY_INSTANCE_INITIALIZER;
 100
 101 const wchar_t* BreakpadWin::pipe_name_ = kGoogleUpdatePipeName;
 102
 103 BreakpadWin::BreakpadWin() : handling_exception_(0) {
 104   // Disable the message box for assertions.
 105   _CrtSetReportMode(_CRT_ASSERT, 0);
 106
 107   // Get the alternate dump directory. We use the temp path.
 108   // N.B. We don't use base::GetTempDir() here to avoid running more code then
 109   //      necessary before crashes can be properly reported.
 110   wchar_t temp_directory[MAX_PATH + 1] = { 0 };
 111   DWORD length = GetTempPath(MAX_PATH, temp_directory);
 112   if (length == 0)
 113     return;
 114
 115   // Minidump with stacks, PEB, TEBs and unloaded module list.
 116   MINIDUMP_TYPE dump_type = static_cast<MINIDUMP_TYPE>(
 117       MiniDumpWithProcessThreadData |
 118       MiniDumpWithUnloadedModules);
 119   breakpad_.reset(
 120       new google_breakpad::ExceptionHandler(
 121           temp_directory, &OnExceptionCallback, NULL, NULL,
 122           google_breakpad::ExceptionHandler::HANDLER_ALL, dump_type,
 123           pipe_name_, GetCustomInfo()));
 124
 125   if (breakpad_->IsOutOfProcess()) {
 126     // Tells breakpad to handle breakpoint and single step exceptions.
 127     breakpad_->set_handle_debug_exceptions(true);
 128   }
 129
 130   // Catch exceptions thrown from a window procedure.
 131   base::win::WinProcExceptionFilter exception_filter =
 132       base::win::SetWinProcExceptionFilter(&OnWindowProcedureException);
 133   CHECK(!exception_filter);
 134 }
 135
 136 BreakpadWin::~BreakpadWin() {
 137   // This object should be leaked so that crashes occurred during the process
 138   // shutdown will be caught.
 139   NOTREACHED();
 140 }
 141
 142 // static
 143 BreakpadWin* BreakpadWin::GetInstance() {
 144   return &g_instance.Get();
 145 }
 146
 147 // Returns the Custom information to be used for crash reporting.
 148 google_breakpad::CustomClientInfo* BreakpadWin::GetCustomInfo() {
 149   HMODULE binary = base::GetModuleFromAddress(
 150       reinterpret_cast<void*>(&remoting::InitializeCrashReporting));
 151   scoped_ptr<FileVersionInfo> version_info(
 152       FileVersionInfo::CreateFileVersionInfoForModule(binary));
 153
 154   static wchar_t version[64];
 155   if (version_info.get()) {
 156     wcscpy_s(version, UTF16ToWide(version_info->product_version()).c_str());
 157   } else {
 158     wcscpy_s(version, kBreakpadVersionDefault);
 159   }
 160
 161   static google_breakpad::CustomInfoEntry ver_entry(
 162       kBreakpadVersionEntry, version);
 163   static google_breakpad::CustomInfoEntry prod_entry(
 164       kBreakpadProdEntry, kBreakpadProductName);
 165   static google_breakpad::CustomInfoEntry plat_entry(
 166       kBreakpadPlatformEntry, kBreakpadPlatformWin32);
 167   static google_breakpad::CustomInfoEntry entries[] = {
 168       ver_entry, prod_entry, plat_entry  };
 169   static google_breakpad::CustomClientInfo custom_info = {
 170       entries, arraysize(entries) };
 171   return &custom_info;
 172 }
 173
 174 // static
 175 bool BreakpadWin::OnExceptionCallback(void* /* context */,
 176                                       EXCEPTION_POINTERS* /* exinfo */,
 177                                       MDRawAssertionInfo* /* assertion */) {
 178   BreakpadWin* self = BreakpadWin::GetInstance();
 179   if (NoBarrier_CompareAndSwap(&self->handling_exception_, 0, 1) != 0) {
 180     // Capture every thread except the first one in the sleep. We don't
 181     // want multiple threads to concurrently report exceptions.
 182     ::Sleep(INFINITE);
 183   }
 184   return true;
 185 }
 186
 187 // static
 188 int BreakpadWin::OnWindowProcedureException(EXCEPTION_POINTERS* exinfo) {
 189   BreakpadWin* self = BreakpadWin::GetInstance();
 190   if (self->breakpad_.get() != NULL) {
 191     self->breakpad_->WriteMinidumpForException(exinfo);
 192     TerminateProcess(GetCurrentProcess(),
 193                      exinfo->ExceptionRecord->ExceptionCode);
 194   }
 195   return EXCEPTION_CONTINUE_SEARCH;
 196 }
 197
 198 }  // namespace
 199
 200 namespace remoting {
 201
 202 void InitializeCrashReporting() {
 203   // Touch the object to make sure it is initialized.
 204   BreakpadWin::GetInstance();
 205 }
 206
 207 void InitializeCrashReportingForTest(const wchar_t* pipe_name) {
 208   BreakpadWin::pipe_name_ = pipe_name;
 209   InitializeCrashReporting();
 210 }
 211
 212 }  // namespace remoting