Update Crashpad to 32981a3ee9d7c2769fb27afa038fe2e194cfa329

third_party/crashpad/crashpad/client/crashpad_client_win.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "client/crashpad_client.h"
 
 #include <windows.h>
+#include <signal.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
 
 #include "base/atomicops.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/scoped_generic.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "util/file/file_io.h"
 #include "util/misc/random_string.h"
 #include "util/win/address_types.h"
+#include "util/win/capture_context.h"
 #include "util/win/command_line.h"
 #include "util/win/critical_section_with_debug_info.h"
 #include "util/win/get_function.h"
 #include "util/win/handle.h"
 #include "util/win/initial_client_data.h"
 #include "util/win/nt_internals.h"
 #include "util/win/ntstatus_logging.h"
 #include "util/win/process_info.h"
 #include "util/win/registration_protocol_win.h"
 #include "util/win/scoped_process_suspend.h"
@@ skipping 57 matching lines @@
   while (
       (startup_state = base::subtle::Release_Load(&g_handler_startup_state)) ==
       static_cast<int>(StartupState::kNotReady)) {
     Sleep(1);
   }
 
   return static_cast<StartupState>(startup_state);
 }
 
 #if defined(ADDRESS_SANITIZER)
-extern "C" LONG
-__asan_unhandled_exception_filter(EXCEPTION_POINTERS* info);
+extern "C" LONG __asan_unhandled_exception_filter(EXCEPTION_POINTERS* info);
 #endif
 
 LONG WINAPI UnhandledExceptionHandler(EXCEPTION_POINTERS* exception_pointers) {
+#if defined(ADDRESS_SANITIZER)
   // In ASan builds, delegate to the ASan exception filter.
-#if defined(ADDRESS_SANITIZER)
   LONG status = __asan_unhandled_exception_filter(exception_pointers);
   if (status != EXCEPTION_CONTINUE_SEARCH)
     return status;
 #endif
 
   if (BlockUntilHandlerStartedOrFailed() == StartupState::kFailed) {
     // If we know for certain that the handler has failed to start, then abort
     // here, rather than trying to signal to a handler that will never arrive,
     // and then sleeping unnecessarily.
     LOG(ERROR) << "crash server failed to launch, self-terminating";
@@ skipping 40 matching lines @@
   // around. This would ideally never happen.
   Sleep(kMillisecondsUntilTerminate);
 
   LOG(ERROR) << "crash server did not respond, self-terminating";
 
   TerminateProcess(GetCurrentProcess(), kTerminationCodeCrashNoDump);
 
   return EXCEPTION_CONTINUE_SEARCH;
 }
 
+void HandleAbortSignal(int signum) {
+  DCHECK_EQ(signum, SIGABRT);
+
+  CONTEXT context;
+  CaptureContext(&context);
+
+  EXCEPTION_RECORD record = {};
+  record.ExceptionCode = STATUS_FATAL_APP_EXIT;
+  record.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
+#if defined(ARCH_CPU_64_BITS)
+  record.ExceptionAddress = reinterpret_cast<void*>(context.Rip);
+#else
+  record.ExceptionAddress = reinterpret_cast<void*>(context.Eip);
+#endif  // ARCH_CPU_64_BITS
+
+  EXCEPTION_POINTERS exception_pointers;
+  exception_pointers.ContextRecord = &context;
+  exception_pointers.ExceptionRecord = &record;
+
+  UnhandledExceptionHandler(&exception_pointers);
+}
+
 std::wstring FormatArgumentString(const std::string& name,
                                   const std::wstring& value) {
   return std::wstring(L"--") + base::UTF8ToUTF16(name) + L"=" + value;
 }
 
 struct ScopedProcThreadAttributeListTraits {
   static PPROC_THREAD_ATTRIBUTE_LIST InvalidValue() { return nullptr; }
 
   static void Free(PPROC_THREAD_ATTRIBUTE_LIST proc_thread_attribute_list) {
     // This is able to use GET_FUNCTION_REQUIRED() instead of GET_FUNCTION()
@@ skipping 317 matching lines @@
   // allows us to walk the list at crash time to gather data for !locks. A
   // debugger would instead inspect ntdll!RtlCriticalSectionList to get the head
   // of the list. But that is not an exported symbol, so on an arbitrary client
   // machine, we don't have a way of getting that pointer.
   InitializeCriticalSectionWithDebugInfoIfPossible(
       &g_critical_section_with_debug_info);
 
   g_non_crash_dump_lock = new base::Lock();
 }
 
+void RegisterHandlers() {
+  SetUnhandledExceptionFilter(&UnhandledExceptionHandler);
+
+  // The Windows CRT's signal.h lists:
+  // - SIGINT
+  // - SIGILL
+  // - SIGFPE
+  // - SIGSEGV
+  // - SIGTERM
+  // - SIGBREAK
+  // - SIGABRT
+  // SIGILL and SIGTERM are documented as not being generated. SIGBREAK and
+  // SIGINT are for Ctrl-Break and Ctrl-C, and aren't something for which
+  // capturing a dump is warranted. SIGFPE and SIGSEGV are captured as regular
+  // exceptions through the unhandled exception filter. This leaves SIGABRT. In
+  // the standard CRT, abort() is implemented as a synchronous call to the
+  // SIGABRT signal handler if installed, but after doing so, the unhandled
+  // exception filter is not triggered (it instead __fastfail()s). So, register
+  // to handle SIGABRT to catch abort() calls, as client code might use this and
+  // expect it to cause a crash dump. This will only work when the abort()
+  // that's called in client code is the same (or has the same behavior) as the
+  // one in use here.
+  void (*rv)(int) = signal(SIGABRT, HandleAbortSignal);
+  DCHECK_NE(rv, SIG_ERR);
+}
+
 }  // namespace
 
 CrashpadClient::CrashpadClient() : ipc_pipe_(), handler_start_thread_() {}
 
 CrashpadClient::~CrashpadClient() {}
 
 bool CrashpadClient::StartHandler(
     const base::FilePath& handler,
     const base::FilePath& database,
     const base::FilePath& metrics_dir,
@@ skipping 16 matching lines @@
 
   g_signal_exception =
       CreateEvent(&security_attributes, false /* auto reset */, false, nullptr);
   g_signal_non_crash_dump =
       CreateEvent(&security_attributes, false /* auto reset */, false, nullptr);
   g_non_crash_dump_done =
       CreateEvent(&security_attributes, false /* auto reset */, false, nullptr);
 
   CommonInProcessInitialization();
 
-  SetUnhandledExceptionFilter(&UnhandledExceptionHandler);
+  RegisterHandlers();
 
   auto data = new BackgroundHandlerStartThreadData(handler,
                                                    database,
                                                    metrics_dir,
                                                    url,
                                                    annotations,
                                                    arguments,
                                                    ipc_pipe_,
                                                    std::move(ipc_pipe_handle));
 
@@ skipping 52 matching lines @@
   message.registration.critical_section_address =
       reinterpret_cast<WinVMAddress>(&g_critical_section_with_debug_info);
 
   ServerToClientMessage response = {};
 
   if (!SendToCrashHandlerServer(ipc_pipe_, message, &response)) {
     return false;
   }
 
   SetHandlerStartupState(StartupState::kSucceeded);
-  SetUnhandledExceptionFilter(&UnhandledExceptionHandler);
+
+  RegisterHandlers();
 
   // The server returns these already duplicated to be valid in this process.
   g_signal_exception =
       IntToHandle(response.registration.request_crash_dump_event);
   g_signal_non_crash_dump =
       IntToHandle(response.registration.request_non_crash_dump_event);
   g_non_crash_dump_done =
       IntToHandle(response.registration.non_crash_dump_completed_event);
 
   return true;
@@ skipping 334 matching lines @@
   status = NtClose(injected_thread);
   if (!NT_SUCCESS(status)) {
     NTSTATUS_LOG(ERROR, status) << "NtClose";
     result = false;
   }
 
   return result;
 }
 
 }  // namespace crashpad