| // Copyright (c) 2006, Google Inc. | |
| // All rights reserved. | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are | |
| // met: | |
| // | |
| // * Redistributions of source code must retain the above copyright | |
| // notice, this list of conditions and the following disclaimer. | |
| // * Redistributions in binary form must reproduce the above | |
| // copyright notice, this list of conditions and the following disclaimer | |
| // in the documentation and/or other materials provided with the | |
| // distribution. | |
| // * Neither the name of Google Inc. nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| #include <objbase.h> | |
| #include <algorithm> | |
| #include <cassert> | |
| #include <cstdio> | |
| #include "common/windows/string_utils-inl.h" | |
| #include "client/windows/common/ipc_protocol.h" | |
| #include "client/windows/handler/exception_handler.h" | |
| #include "common/windows/guid_string.h" | |
| namespace google_breakpad { | |
| // This is passed as the context to the MinidumpWriteDump callback. | |
| typedef struct { | |
| AppMemoryList::const_iterator iter; | |
| AppMemoryList::const_iterator end; | |
| } MinidumpCallbackContext; | |
| // This define is new to Windows 10. | |
| #ifndef DBG_PRINTEXCEPTION_WIDE_C | |
| #define DBG_PRINTEXCEPTION_WIDE_C ((DWORD)0x4001000A) | |
| #endif | |
| vector<ExceptionHandler*>* ExceptionHandler::handler_stack_ = NULL; | |
| LONG ExceptionHandler::handler_stack_index_ = 0; | |
| CRITICAL_SECTION ExceptionHandler::handler_stack_critical_section_; | |
| volatile LONG ExceptionHandler::instance_count_ = 0; | |
| ExceptionHandler::ExceptionHandler(const wstring& dump_path, | |
| FilterCallback filter, | |
| MinidumpCallback callback, | |
| void* callback_context, | |
| int handler_types, | |
| MINIDUMP_TYPE dump_type, | |
| const wchar_t* pipe_name, | |
| const CustomClientInfo* custom_info) { | |
| Initialize(dump_path, | |
| filter, | |
| callback, | |
| callback_context, | |
| handler_types, | |
| dump_type, | |
| pipe_name, | |
| NULL, // pipe_handle | |
| NULL, // crash_generation_client | |
| custom_info); | |
| } | |
| ExceptionHandler::ExceptionHandler(const wstring& dump_path, | |
| FilterCallback filter, | |
| MinidumpCallback callback, | |
| void* callback_context, | |
| int handler_types, | |
| MINIDUMP_TYPE dump_type, | |
| HANDLE pipe_handle, | |
| const CustomClientInfo* custom_info) { | |
| Initialize(dump_path, | |
| filter, | |
| callback, | |
| callback_context, | |
| handler_types, | |
| dump_type, | |
| NULL, // pipe_name | |
| pipe_handle, | |
| NULL, // crash_generation_client | |
| custom_info); | |
| } | |
| ExceptionHandler::ExceptionHandler( | |
| const wstring& dump_path, | |
| FilterCallback filter, | |
| MinidumpCallback callback, | |
| void* callback_context, | |
| int handler_types, | |
| CrashGenerationClient* crash_generation_client) { | |
| // The dump_type, pipe_name and custom_info that are passed in to Initialize() | |
| // are not used. The ones set in crash_generation_client are used instead. | |
| Initialize(dump_path, | |
| filter, | |
| callback, | |
| callback_context, | |
| handler_types, | |
| MiniDumpNormal, // dump_type - not used | |
| NULL, // pipe_name - not used | |
| NULL, // pipe_handle | |
| crash_generation_client, | |
| NULL); // custom_info - not used | |
| } | |
| ExceptionHandler::ExceptionHandler(const wstring &dump_path, | |
| FilterCallback filter, | |
| MinidumpCallback callback, | |
| void* callback_context, | |
| int handler_types) { | |
| Initialize(dump_path, | |
| filter, | |
| callback, | |
| callback_context, | |
| handler_types, | |
| MiniDumpNormal, | |
| NULL, // pipe_name | |
| NULL, // pipe_handle | |
| NULL, // crash_generation_client | |
| NULL); // custom_info | |
| } | |
| void ExceptionHandler::Initialize( | |
| const wstring& dump_path, | |
| FilterCallback filter, | |
| MinidumpCallback callback, | |
| void* callback_context, | |
| int handler_types, | |
| MINIDUMP_TYPE dump_type, | |
| const wchar_t* pipe_name, | |
| HANDLE pipe_handle, | |
| CrashGenerationClient* crash_generation_client, | |
| const CustomClientInfo* custom_info) { | |
| LONG instance_count = InterlockedIncrement(&instance_count_); | |
| filter_ = filter; | |
| callback_ = callback; | |
| callback_context_ = callback_context; | |
| dump_path_c_ = NULL; | |
| next_minidump_id_c_ = NULL; | |
| next_minidump_path_c_ = NULL; | |
| dbghelp_module_ = NULL; | |
| minidump_write_dump_ = NULL; | |
| dump_type_ = dump_type; | |
| rpcrt4_module_ = NULL; | |
| uuid_create_ = NULL; | |
| handler_types_ = handler_types; | |
| previous_filter_ = NULL; | |
| #if _MSC_VER >= 1400 // MSVC 2005/8 | |
| previous_iph_ = NULL; | |
| #endif // _MSC_VER >= 1400 | |
| previous_pch_ = NULL; | |
| handler_thread_ = NULL; | |
| is_shutdown_ = false; | |
| handler_start_semaphore_ = NULL; | |
| handler_finish_semaphore_ = NULL; | |
| requesting_thread_id_ = 0; | |
| exception_info_ = NULL; | |
| assertion_ = NULL; | |
| handler_return_value_ = false; | |
| handle_debug_exceptions_ = false; | |
| consume_invalid_handle_exceptions_ = false; | |
| // Attempt to use out-of-process if user has specified a pipe or a | |
| // crash generation client. | |
| scoped_ptr<CrashGenerationClient> client; | |
| if (crash_generation_client) { | |
| client.reset(crash_generation_client); | |
| } else if (pipe_name) { | |
| client.reset( | |
| new CrashGenerationClient(pipe_name, dump_type_, custom_info)); | |
| } else if (pipe_handle) { | |
| client.reset( | |
| new CrashGenerationClient(pipe_handle, dump_type_, custom_info)); | |
| } | |
| if (client.get() != NULL) { | |
| // If successful in registering with the monitoring process, | |
| // there is no need to setup in-process crash generation. | |
| if (client->Register()) { | |
| crash_generation_client_.reset(client.release()); | |
| } | |
| } | |
| if (!IsOutOfProcess()) { | |
| // Either client did not ask for out-of-process crash generation | |
| // or registration with the server process failed. In either case, | |
| // setup to do in-process crash generation. | |
| // Set synchronization primitives and the handler thread. Each | |
| // ExceptionHandler object gets its own handler thread because that's the | |
| // only way to reliably guarantee sufficient stack space in an exception, | |
| // and it allows an easy way to get a snapshot of the requesting thread's | |
| // context outside of an exception. | |
| InitializeCriticalSection(&handler_critical_section_); | |
| handler_start_semaphore_ = CreateSemaphore(NULL, 0, 1, NULL); | |
| assert(handler_start_semaphore_ != NULL); | |
| handler_finish_semaphore_ = CreateSemaphore(NULL, 0, 1, NULL); | |
| assert(handler_finish_semaphore_ != NULL); | |
| // Don't attempt to create the thread if we could not create the semaphores. | |
| if (handler_finish_semaphore_ != NULL && handler_start_semaphore_ != NULL) { | |
| DWORD thread_id; | |
| const int kExceptionHandlerThreadInitialStackSize = 64 * 1024; | |
| handler_thread_ = CreateThread(NULL, // lpThreadAttributes | |
| kExceptionHandlerThreadInitialStackSize, | |
| ExceptionHandlerThreadMain, | |
| this, // lpParameter | |
| 0, // dwCreationFlags | |
| &thread_id); | |
| assert(handler_thread_ != NULL); | |
| } | |
| dbghelp_module_ = LoadLibrary(L"dbghelp.dll"); | |
| if (dbghelp_module_) { | |
| minidump_write_dump_ = reinterpret_cast<MiniDumpWriteDump_type>( | |
| GetProcAddress(dbghelp_module_, "MiniDumpWriteDump")); | |
| } | |
| // Load this library dynamically to not affect existing projects. Most | |
| // projects don't link against this directly, it's usually dynamically | |
| // loaded by dependent code. | |
| rpcrt4_module_ = LoadLibrary(L"rpcrt4.dll"); | |
| if (rpcrt4_module_) { | |
| uuid_create_ = reinterpret_cast<UuidCreate_type>( | |
| GetProcAddress(rpcrt4_module_, "UuidCreate")); | |
| } | |
| // set_dump_path calls UpdateNextID. This sets up all of the path and id | |
| // strings, and their equivalent c_str pointers. | |
| set_dump_path(dump_path); | |
| } | |
| // Reserve one element for the instruction memory | |
| AppMemory instruction_memory; | |
| instruction_memory.ptr = NULL; | |
| instruction_memory.length = 0; | |
| app_memory_info_.push_back(instruction_memory); | |
| // There is a race condition here. If the first instance has not yet | |
| // initialized the critical section, the second (and later) instances may | |
| // try to use uninitialized critical section object. The feature of multiple | |
| // instances in one module is not used much, so leave it as is for now. | |
| // One way to solve this in the current design (that is, keeping the static | |
| // handler stack) is to use spin locks with volatile bools to synchronize | |
| // the handler stack. This works only if the compiler guarantees to generate | |
| // cache coherent code for volatile. | |
| // TODO(munjal): Fix this in a better way by changing the design if possible. | |
| // Lazy initialization of the handler_stack_critical_section_ | |
| if (instance_count == 1) { | |
| InitializeCriticalSection(&handler_stack_critical_section_); | |
| } | |
| if (handler_types != HANDLER_NONE) { | |
| EnterCriticalSection(&handler_stack_critical_section_); | |
| // The first time an ExceptionHandler that installs a handler is | |
| // created, set up the handler stack. | |
| if (!handler_stack_) { | |
| handler_stack_ = new vector<ExceptionHandler*>(); | |
| } | |
| handler_stack_->push_back(this); | |
| if (handler_types & HANDLER_EXCEPTION) | |
| previous_filter_ = SetUnhandledExceptionFilter(HandleException); | |
| #if _MSC_VER >= 1400 // MSVC 2005/8 | |
| if (handler_types & HANDLER_INVALID_PARAMETER) | |
| previous_iph_ = _set_invalid_parameter_handler(HandleInvalidParameter); | |
| #endif // _MSC_VER >= 1400 | |
| if (handler_types & HANDLER_PURECALL) | |
| previous_pch_ = _set_purecall_handler(HandlePureVirtualCall); | |
| LeaveCriticalSection(&handler_stack_critical_section_); | |
| } | |
| } | |
| ExceptionHandler::~ExceptionHandler() { | |
| if (dbghelp_module_) { | |
| FreeLibrary(dbghelp_module_); | |
| } | |
| if (rpcrt4_module_) { | |
| FreeLibrary(rpcrt4_module_); | |
| } | |
| if (handler_types_ != HANDLER_NONE) { | |
| EnterCriticalSection(&handler_stack_critical_section_); | |
| if (handler_types_ & HANDLER_EXCEPTION) | |
| SetUnhandledExceptionFilter(previous_filter_); | |
| #if _MSC_VER >= 1400 // MSVC 2005/8 | |
| if (handler_types_ & HANDLER_INVALID_PARAMETER) | |
| _set_invalid_parameter_handler(previous_iph_); | |
| #endif // _MSC_VER >= 1400 | |
| if (handler_types_ & HANDLER_PURECALL) | |
| _set_purecall_handler(previous_pch_); | |
| if (handler_stack_->back() == this) { | |
| handler_stack_->pop_back(); | |
| } else { | |
| // TODO(mmentovai): use advapi32!ReportEvent to log the warning to the | |
| // system's application event log. | |
| fprintf(stderr, "warning: removing Breakpad handler out of order\n"); | |
| vector<ExceptionHandler*>::iterator iterator = handler_stack_->begin(); | |
| while (iterator != handler_stack_->end()) { | |
| if (*iterator == this) { | |
| iterator = handler_stack_->erase(iterator); | |
| } else { | |
| ++iterator; | |
| } | |
| } | |
| } | |
| if (handler_stack_->empty()) { | |
| // When destroying the last ExceptionHandler that installed a handler, | |
| // clean up the handler stack. | |
| delete handler_stack_; | |
| handler_stack_ = NULL; | |
| } | |
| LeaveCriticalSection(&handler_stack_critical_section_); | |
| } | |
| // Some of the objects were only initialized if out of process | |
| // registration was not done. | |
| if (!IsOutOfProcess()) { | |
| #ifdef BREAKPAD_NO_TERMINATE_THREAD | |
| // Clean up the handler thread and synchronization primitives. The handler | |
| // thread is either waiting on the semaphore to handle a crash or it is | |
| // handling a crash. Coming out of the wait is fast but wait more in the | |
| // eventuality a crash is handled. This compilation option results in a | |
| // deadlock if the exception handler is destroyed while executing code | |
| // inside DllMain. | |
| is_shutdown_ = true; | |
| ReleaseSemaphore(handler_start_semaphore_, 1, NULL); | |
| const int kWaitForHandlerThreadMs = 60000; | |
| WaitForSingleObject(handler_thread_, kWaitForHandlerThreadMs); | |
| #else | |
| TerminateThread(handler_thread_, 1); | |
| #endif // BREAKPAD_NO_TERMINATE_THREAD | |
| CloseHandle(handler_thread_); | |
| handler_thread_ = NULL; | |
| DeleteCriticalSection(&handler_critical_section_); | |
| CloseHandle(handler_start_semaphore_); | |
| CloseHandle(handler_finish_semaphore_); | |
| } | |
| // There is a race condition in the code below: if this instance is | |
| // deleting the static critical section and a new instance of the class | |
| // is created, then there is a possibility that the critical section be | |
| // initialized while the same critical section is being deleted. Given the | |
| // usage pattern for the code, this race condition is unlikely to hit, but it | |
| // is a race condition nonetheless. | |
| if (InterlockedDecrement(&instance_count_) == 0) { | |
| DeleteCriticalSection(&handler_stack_critical_section_); | |
| } | |
| } | |
| bool ExceptionHandler::RequestUpload(DWORD crash_id) { | |
| return crash_generation_client_->RequestUpload(crash_id); | |
| } | |
| // static | |
| DWORD ExceptionHandler::ExceptionHandlerThreadMain(void* lpParameter) { | |
| ExceptionHandler* self = reinterpret_cast<ExceptionHandler *>(lpParameter); | |
| assert(self); | |
| assert(self->handler_start_semaphore_ != NULL); | |
| assert(self->handler_finish_semaphore_ != NULL); | |
| for (;;) { | |
| if (WaitForSingleObject(self->handler_start_semaphore_, INFINITE) == | |
| WAIT_OBJECT_0) { | |
| // Perform the requested action. | |
| if (self->is_shutdown_) { | |
| // The instance of the exception handler is being destroyed. | |
| break; | |
| } else { | |
| self->handler_return_value_ = | |
| self->WriteMinidumpWithException(self->requesting_thread_id_, | |
| self->exception_info_, | |
| self->assertion_); | |
| } | |
| // Allow the requesting thread to proceed. | |
| ReleaseSemaphore(self->handler_finish_semaphore_, 1, NULL); | |
| } | |
| } | |
| // This statement is not reached when the thread is unconditionally | |
| // terminated by the ExceptionHandler destructor. | |
| return 0; | |
| } | |
| // HandleException and HandleInvalidParameter must create an | |
| // AutoExceptionHandler object to maintain static state and to determine which | |
| // ExceptionHandler instance to use. The constructor locates the correct | |
| // instance, and makes it available through get_handler(). The destructor | |
| // restores the state in effect prior to allocating the AutoExceptionHandler. | |
| class AutoExceptionHandler { | |
| public: | |
| AutoExceptionHandler() { | |
| // Increment handler_stack_index_ so that if another Breakpad handler is | |
| // registered using this same HandleException function, and it needs to be | |
| // called while this handler is running (either because this handler | |
| // declines to handle the exception, or an exception occurs during | |
| // handling), HandleException will find the appropriate ExceptionHandler | |
| // object in handler_stack_ to deliver the exception to. | |
| // | |
| // Because handler_stack_ is addressed in reverse (as |size - index|), | |
| // preincrementing handler_stack_index_ avoids needing to subtract 1 from | |
| // the argument to |at|. | |
| // | |
| // The index is maintained instead of popping elements off of the handler | |
| // stack and pushing them at the end of this method. This avoids ruining | |
| // the order of elements in the stack in the event that some other thread | |
| // decides to manipulate the handler stack (such as creating a new | |
| // ExceptionHandler object) while an exception is being handled. | |
| EnterCriticalSection(&ExceptionHandler::handler_stack_critical_section_); | |
| handler_ = ExceptionHandler::handler_stack_->at( | |
| ExceptionHandler::handler_stack_->size() - | |
| ++ExceptionHandler::handler_stack_index_); | |
| // In case another exception occurs while this handler is doing its thing, | |
| // it should be delivered to the previous filter. | |
| SetUnhandledExceptionFilter(handler_->previous_filter_); | |
| #if _MSC_VER >= 1400 // MSVC 2005/8 | |
| _set_invalid_parameter_handler(handler_->previous_iph_); | |
| #endif // _MSC_VER >= 1400 | |
| _set_purecall_handler(handler_->previous_pch_); | |
| } | |
| ~AutoExceptionHandler() { | |
| // Put things back the way they were before entering this handler. | |
| SetUnhandledExceptionFilter(ExceptionHandler::HandleException); | |
| #if _MSC_VER >= 1400 // MSVC 2005/8 | |
| _set_invalid_parameter_handler(ExceptionHandler::HandleInvalidParameter); | |
| #endif // _MSC_VER >= 1400 | |
| _set_purecall_handler(ExceptionHandler::HandlePureVirtualCall); | |
| --ExceptionHandler::handler_stack_index_; | |
| LeaveCriticalSection(&ExceptionHandler::handler_stack_critical_section_); | |
| } | |
| ExceptionHandler* get_handler() const { return handler_; } | |
| private: | |
| ExceptionHandler* handler_; | |
| }; | |
| // static | |
| LONG ExceptionHandler::HandleException(EXCEPTION_POINTERS* exinfo) { | |
| AutoExceptionHandler auto_exception_handler; | |
| ExceptionHandler* current_handler = auto_exception_handler.get_handler(); | |
| // Ignore EXCEPTION_BREAKPOINT and EXCEPTION_SINGLE_STEP exceptions. This | |
| // logic will short-circuit before calling WriteMinidumpOnHandlerThread, | |
| // allowing something else to handle the breakpoint without incurring the | |
| // overhead transitioning to and from the handler thread. This behavior | |
| // can be overridden by calling ExceptionHandler::set_handle_debug_exceptions. | |
| DWORD code = exinfo->ExceptionRecord->ExceptionCode; | |
| LONG action; | |
| bool is_debug_exception = (code == EXCEPTION_BREAKPOINT) || | |
| (code == EXCEPTION_SINGLE_STEP) || | |
| (code == DBG_PRINTEXCEPTION_C) || | |
| (code == DBG_PRINTEXCEPTION_WIDE_C); | |
| if (code == EXCEPTION_INVALID_HANDLE && | |
| current_handler->consume_invalid_handle_exceptions_) { | |
| return EXCEPTION_CONTINUE_EXECUTION; | |
| } | |
| bool success = false; | |
| if (!is_debug_exception || | |
| current_handler->get_handle_debug_exceptions()) { | |
| // If out-of-proc crash handler client is available, we have to use that | |
| // to generate dump and we cannot fall back on in-proc dump generation | |
| // because we never prepared for an in-proc dump generation | |
| // In case of out-of-process dump generation, directly call | |
| // WriteMinidumpWithException since there is no separate thread running. | |
| if (current_handler->IsOutOfProcess()) { | |
| success = current_handler->WriteMinidumpWithException( | |
| GetCurrentThreadId(), | |
| exinfo, | |
| NULL); | |
| } else { | |
| success = current_handler->WriteMinidumpOnHandlerThread(exinfo, NULL); | |
| } | |
| } | |
| // The handler fully handled the exception. Returning | |
| // EXCEPTION_EXECUTE_HANDLER indicates this to the system, and usually | |
| // results in the application being terminated. | |
| // | |
| // Note: If the application was launched from within the Cygwin | |
| // environment, returning EXCEPTION_EXECUTE_HANDLER seems to cause the | |
| // application to be restarted. | |
| if (success) { | |
| action = EXCEPTION_EXECUTE_HANDLER; | |
| } else { | |
| // There was an exception, it was a breakpoint or something else ignored | |
| // above, or it was passed to the handler, which decided not to handle it. | |
| // This could be because the filter callback didn't want it, because | |
| // minidump writing failed for some reason, or because the post-minidump | |
| // callback function indicated failure. Give the previous handler a | |
| // chance to do something with the exception. If there is no previous | |
| // handler, return EXCEPTION_CONTINUE_SEARCH, which will allow a debugger | |
| // or native "crashed" dialog to handle the exception. | |
| if (current_handler->previous_filter_) { | |
| action = current_handler->previous_filter_(exinfo); | |
| } else { | |
| action = EXCEPTION_CONTINUE_SEARCH; | |
| } | |
| } | |
| return action; | |
| } | |
| #if _MSC_VER >= 1400 // MSVC 2005/8 | |
| // static | |
| void ExceptionHandler::HandleInvalidParameter(const wchar_t* expression, | |
| const wchar_t* function, | |
| const wchar_t* file, | |
| unsigned int line, | |
| uintptr_t reserved) { | |
| // This is an invalid parameter, not an exception. It's safe to play with | |
| // sprintf here. | |
| AutoExceptionHandler auto_exception_handler; | |
| ExceptionHandler* current_handler = auto_exception_handler.get_handler(); | |
| MDRawAssertionInfo assertion; | |
| memset(&assertion, 0, sizeof(assertion)); | |
| _snwprintf_s(reinterpret_cast<wchar_t*>(assertion.expression), | |
| sizeof(assertion.expression) / sizeof(assertion.expression[0]), | |
| _TRUNCATE, L"%s", expression); | |
| _snwprintf_s(reinterpret_cast<wchar_t*>(assertion.function), | |
| sizeof(assertion.function) / sizeof(assertion.function[0]), | |
| _TRUNCATE, L"%s", function); | |
| _snwprintf_s(reinterpret_cast<wchar_t*>(assertion.file), | |
| sizeof(assertion.file) / sizeof(assertion.file[0]), | |
| _TRUNCATE, L"%s", file); | |
| assertion.line = line; | |
| assertion.type = MD_ASSERTION_INFO_TYPE_INVALID_PARAMETER; | |
| // Make up an exception record for the current thread and CPU context | |
| // to make it possible for the crash processor to classify these | |
| // as do regular crashes, and to make it humane for developers to | |
| // analyze them. | |
| EXCEPTION_RECORD exception_record = {}; | |
| CONTEXT exception_context = {}; | |
| EXCEPTION_POINTERS exception_ptrs = { &exception_record, &exception_context }; | |
| ::RtlCaptureContext(&exception_context); | |
| exception_record.ExceptionCode = STATUS_INVALID_PARAMETER; | |
| // We store pointers to the the expression and function strings, | |
| // and the line as exception parameters to make them easy to | |
| // access by the developer on the far side. | |
| exception_record.NumberParameters = 3; | |
| exception_record.ExceptionInformation[0] = | |
| reinterpret_cast<ULONG_PTR>(&assertion.expression); | |
| exception_record.ExceptionInformation[1] = | |
| reinterpret_cast<ULONG_PTR>(&assertion.file); | |
| exception_record.ExceptionInformation[2] = assertion.line; | |
| bool success = false; | |
| // In case of out-of-process dump generation, directly call | |
| // WriteMinidumpWithException since there is no separate thread running. | |
| if (current_handler->IsOutOfProcess()) { | |
| success = current_handler->WriteMinidumpWithException( | |
| GetCurrentThreadId(), | |
| &exception_ptrs, | |
| &assertion); | |
| } else { | |
| success = current_handler->WriteMinidumpOnHandlerThread(&exception_ptrs, | |
| &assertion); | |
| } | |
| if (!success) { | |
| if (current_handler->previous_iph_) { | |
| // The handler didn't fully handle the exception. Give it to the | |
| // previous invalid parameter handler. | |
| current_handler->previous_iph_(expression, | |
| function, | |
| file, | |
| line, | |
| reserved); | |
| } else { | |
| // If there's no previous handler, pass the exception back in to the | |
| // invalid parameter handler's core. That's the routine that called this | |
| // function, but now, since this function is no longer registered (and in | |
| // fact, no function at all is registered), this will result in the | |
| // default code path being taken: _CRT_DEBUGGER_HOOK and _invoke_watson. | |
| // Use _invalid_parameter where it exists (in _DEBUG builds) as it passes | |
| // more information through. In non-debug builds, it is not available, | |
| // so fall back to using _invalid_parameter_noinfo. See invarg.c in the | |
| // CRT source. | |
| #ifdef _DEBUG | |
| _invalid_parameter(expression, function, file, line, reserved); | |
| #else // _DEBUG | |
| _invalid_parameter_noinfo(); | |
| #endif // _DEBUG | |
| } | |
| } | |
| // The handler either took care of the invalid parameter problem itself, | |
| // or passed it on to another handler. "Swallow" it by exiting, paralleling | |
| // the behavior of "swallowing" exceptions. | |
| exit(0); | |
| } | |
| #endif // _MSC_VER >= 1400 | |
| // static | |
| void ExceptionHandler::HandlePureVirtualCall() { | |
| // This is an pure virtual function call, not an exception. It's safe to | |
| // play with sprintf here. | |
| AutoExceptionHandler auto_exception_handler; | |
| ExceptionHandler* current_handler = auto_exception_handler.get_handler(); | |
| MDRawAssertionInfo assertion; | |
| memset(&assertion, 0, sizeof(assertion)); | |
| assertion.type = MD_ASSERTION_INFO_TYPE_PURE_VIRTUAL_CALL; | |
| // Make up an exception record for the current thread and CPU context | |
| // to make it possible for the crash processor to classify these | |
| // as do regular crashes, and to make it humane for developers to | |
| // analyze them. | |
| EXCEPTION_RECORD exception_record = {}; | |
| CONTEXT exception_context = {}; | |
| EXCEPTION_POINTERS exception_ptrs = { &exception_record, &exception_context }; | |
| ::RtlCaptureContext(&exception_context); | |
| exception_record.ExceptionCode = STATUS_NONCONTINUABLE_EXCEPTION; | |
| // We store pointers to the the expression and function strings, | |
| // and the line as exception parameters to make them easy to | |
| // access by the developer on the far side. | |
| exception_record.NumberParameters = 3; | |
| exception_record.ExceptionInformation[0] = | |
| reinterpret_cast<ULONG_PTR>(&assertion.expression); | |
| exception_record.ExceptionInformation[1] = | |
| reinterpret_cast<ULONG_PTR>(&assertion.file); | |
| exception_record.ExceptionInformation[2] = assertion.line; | |
| bool success = false; | |
| // In case of out-of-process dump generation, directly call | |
| // WriteMinidumpWithException since there is no separate thread running. | |
| if (current_handler->IsOutOfProcess()) { | |
| success = current_handler->WriteMinidumpWithException( | |
| GetCurrentThreadId(), | |
| &exception_ptrs, | |
| &assertion); | |
| } else { | |
| success = current_handler->WriteMinidumpOnHandlerThread(&exception_ptrs, | |
| &assertion); | |
| } | |
| if (!success) { | |
| if (current_handler->previous_pch_) { | |
| // The handler didn't fully handle the exception. Give it to the | |
| // previous purecall handler. | |
| current_handler->previous_pch_(); | |
| } else { | |
| // If there's no previous handler, return and let _purecall handle it. | |
| // This will just put up an assertion dialog. | |
| return; | |
| } | |
| } | |
| // The handler either took care of the invalid parameter problem itself, | |
| // or passed it on to another handler. "Swallow" it by exiting, paralleling | |
| // the behavior of "swallowing" exceptions. | |
| exit(0); | |
| } | |
| bool ExceptionHandler::WriteMinidumpOnHandlerThread( | |
| EXCEPTION_POINTERS* exinfo, MDRawAssertionInfo* assertion) { | |
| EnterCriticalSection(&handler_critical_section_); | |
| // There isn't much we can do if the handler thread | |
| // was not successfully created. | |
| if (handler_thread_ == NULL) { | |
| LeaveCriticalSection(&handler_critical_section_); | |
| return false; | |
| } | |
| // The handler thread should only be created when the semaphores are valid. | |
| assert(handler_start_semaphore_ != NULL); | |
| assert(handler_finish_semaphore_ != NULL); | |
| // Set up data to be passed in to the handler thread. | |
| requesting_thread_id_ = GetCurrentThreadId(); | |
| exception_info_ = exinfo; | |
| assertion_ = assertion; | |
| // This causes the handler thread to call WriteMinidumpWithException. | |
| ReleaseSemaphore(handler_start_semaphore_, 1, NULL); | |
| // Wait until WriteMinidumpWithException is done and collect its return value. | |
| WaitForSingleObject(handler_finish_semaphore_, INFINITE); | |
| bool status = handler_return_value_; | |
| // Clean up. | |
| requesting_thread_id_ = 0; | |
| exception_info_ = NULL; | |
| assertion_ = NULL; | |
| LeaveCriticalSection(&handler_critical_section_); | |
| return status; | |
| } | |
| bool ExceptionHandler::WriteMinidump() { | |
| // Make up an exception record for the current thread and CPU context | |
| // to make it possible for the crash processor to classify these | |
| // as do regular crashes, and to make it humane for developers to | |
| // analyze them. | |
| EXCEPTION_RECORD exception_record = {}; | |
| CONTEXT exception_context = {}; | |
| EXCEPTION_POINTERS exception_ptrs = { &exception_record, &exception_context }; | |
| ::RtlCaptureContext(&exception_context); | |
| exception_record.ExceptionCode = STATUS_NONCONTINUABLE_EXCEPTION; | |
| return WriteMinidumpForException(&exception_ptrs); | |
| } | |
| bool ExceptionHandler::WriteMinidumpForException(EXCEPTION_POINTERS* exinfo) { | |
| // In case of out-of-process dump generation, directly call | |
| // WriteMinidumpWithException since there is no separate thread running. | |
| if (IsOutOfProcess()) { | |
| return WriteMinidumpWithException(GetCurrentThreadId(), | |
| exinfo, | |
| NULL); | |
| } | |
| bool success = WriteMinidumpOnHandlerThread(exinfo, NULL); | |
| UpdateNextID(); | |
| return success; | |
| } | |
| // static | |
| bool ExceptionHandler::WriteMinidump(const wstring &dump_path, | |
| MinidumpCallback callback, | |
| void* callback_context, | |
| MINIDUMP_TYPE dump_type) { | |
| ExceptionHandler handler(dump_path, NULL, callback, callback_context, | |
| HANDLER_NONE, dump_type, (HANDLE)NULL, NULL); | |
| return handler.WriteMinidump(); | |
| } | |
| // static | |
| bool ExceptionHandler::WriteMinidumpForChild(HANDLE child, | |
| DWORD child_blamed_thread, | |
| const wstring& dump_path, | |
| MinidumpCallback callback, | |
| void* callback_context, | |
| MINIDUMP_TYPE dump_type) { | |
| EXCEPTION_RECORD ex; | |
| CONTEXT ctx; | |
| EXCEPTION_POINTERS exinfo = { NULL, NULL }; | |
| // As documented on MSDN, on failure SuspendThread returns (DWORD) -1 | |
| const DWORD kFailedToSuspendThread = static_cast<DWORD>(-1); | |
| DWORD last_suspend_count = kFailedToSuspendThread; | |
| HANDLE child_thread_handle = OpenThread(THREAD_GET_CONTEXT | | |
| THREAD_QUERY_INFORMATION | | |
| THREAD_SUSPEND_RESUME, | |
| FALSE, | |
| child_blamed_thread); | |
| // This thread may have died already, so not opening the handle is a | |
| // non-fatal error. | |
| if (child_thread_handle != NULL) { | |
| last_suspend_count = SuspendThread(child_thread_handle); | |
| if (last_suspend_count != kFailedToSuspendThread) { | |
| ctx.ContextFlags = CONTEXT_ALL; | |
| if (GetThreadContext(child_thread_handle, &ctx)) { | |
| memset(&ex, 0, sizeof(ex)); | |
| ex.ExceptionCode = EXCEPTION_BREAKPOINT; | |
| #if defined(_M_IX86) | |
| ex.ExceptionAddress = reinterpret_cast<PVOID>(ctx.Eip); | |
| #elif defined(_M_X64) | |
| ex.ExceptionAddress = reinterpret_cast<PVOID>(ctx.Rip); | |
| #endif | |
| exinfo.ExceptionRecord = &ex; | |
| exinfo.ContextRecord = &ctx; | |
| } | |
| } | |
| } | |
| ExceptionHandler handler(dump_path, NULL, callback, callback_context, | |
| HANDLER_NONE, dump_type, (HANDLE)NULL, NULL); | |
| bool success = handler.WriteMinidumpWithExceptionForProcess( | |
| child_blamed_thread, | |
| exinfo.ExceptionRecord ? &exinfo : NULL, | |
| NULL, child, false); | |
| if (last_suspend_count != kFailedToSuspendThread) { | |
| ResumeThread(child_thread_handle); | |
| } | |
| CloseHandle(child_thread_handle); | |
| if (callback) { | |
| success = callback(handler.dump_path_c_, handler.next_minidump_id_c_, | |
| callback_context, NULL, NULL, success); | |
| } | |
| return success; | |
| } | |
| bool ExceptionHandler::WriteMinidumpWithException( | |
| DWORD requesting_thread_id, | |
| EXCEPTION_POINTERS* exinfo, | |
| MDRawAssertionInfo* assertion) { | |
| // Give user code a chance to approve or prevent writing a minidump. If the | |
| // filter returns false, don't handle the exception at all. If this method | |
| // was called as a result of an exception, returning false will cause | |
| // HandleException to call any previous handler or return | |
| // EXCEPTION_CONTINUE_SEARCH on the exception thread, allowing it to appear | |
| // as though this handler were not present at all. | |
| if (filter_ && !filter_(callback_context_, exinfo, assertion)) { | |
| return false; | |
| } | |
| bool success = false; | |
| if (IsOutOfProcess()) { | |
| success = crash_generation_client_->RequestDump(exinfo, assertion); | |
| } else { | |
| success = WriteMinidumpWithExceptionForProcess(requesting_thread_id, | |
| exinfo, | |
| assertion, | |
| GetCurrentProcess(), | |
| true); | |
| } | |
| if (callback_) { | |
| // TODO(munjal): In case of out-of-process dump generation, both | |
| // dump_path_c_ and next_minidump_id_ will be NULL. For out-of-process | |
| // scenario, the server process ends up creating the dump path and dump | |
| // id so they are not known to the client. | |
| success = callback_(dump_path_c_, next_minidump_id_c_, callback_context_, | |
| exinfo, assertion, success); | |
| } | |
| return success; | |
| } | |
| // static | |
| BOOL CALLBACK ExceptionHandler::MinidumpWriteDumpCallback( | |
| PVOID context, | |
| const PMINIDUMP_CALLBACK_INPUT callback_input, | |
| PMINIDUMP_CALLBACK_OUTPUT callback_output) { | |
| switch (callback_input->CallbackType) { | |
| case MemoryCallback: { | |
| MinidumpCallbackContext* callback_context = | |
| reinterpret_cast<MinidumpCallbackContext*>(context); | |
| if (callback_context->iter == callback_context->end) | |
| return FALSE; | |
| // Include the specified memory region. | |
| callback_output->MemoryBase = callback_context->iter->ptr; | |
| callback_output->MemorySize = callback_context->iter->length; | |
| callback_context->iter++; | |
| return TRUE; | |
| } | |
| // Include all modules. | |
| case IncludeModuleCallback: | |
| case ModuleCallback: | |
| return TRUE; | |
| // Include all threads. | |
| case IncludeThreadCallback: | |
| case ThreadCallback: | |
| return TRUE; | |
| // Stop receiving cancel callbacks. | |
| case CancelCallback: | |
| callback_output->CheckCancel = FALSE; | |
| callback_output->Cancel = FALSE; | |
| return TRUE; | |
| } | |
| // Ignore other callback types. | |
| return FALSE; | |
| } | |
| bool ExceptionHandler::WriteMinidumpWithExceptionForProcess( | |
| DWORD requesting_thread_id, | |
| EXCEPTION_POINTERS* exinfo, | |
| MDRawAssertionInfo* assertion, | |
| HANDLE process, | |
| bool write_requester_stream) { | |
| bool success = false; | |
| if (minidump_write_dump_) { | |
| HANDLE dump_file = CreateFile(next_minidump_path_c_, | |
| GENERIC_WRITE, | |
| 0, // no sharing | |
| NULL, | |
| CREATE_NEW, // fail if exists | |
| FILE_ATTRIBUTE_NORMAL, | |
| NULL); | |
| if (dump_file != INVALID_HANDLE_VALUE) { | |
| MINIDUMP_EXCEPTION_INFORMATION except_info; | |
| except_info.ThreadId = requesting_thread_id; | |
| except_info.ExceptionPointers = exinfo; | |
| except_info.ClientPointers = FALSE; | |
| // Leave room in user_stream_array for possible breakpad and | |
| // assertion info streams. | |
| MINIDUMP_USER_STREAM user_stream_array[2]; | |
| MINIDUMP_USER_STREAM_INFORMATION user_streams; | |
| user_streams.UserStreamCount = 0; | |
| user_streams.UserStreamArray = user_stream_array; | |
| if (write_requester_stream) { | |
| // Add an MDRawBreakpadInfo stream to the minidump, to provide | |
| // additional information about the exception handler to the Breakpad | |
| // processor. The information will help the processor determine which | |
| // threads are relevant. The Breakpad processor does not require this | |
| // information but can function better with Breakpad-generated dumps | |
| // when it is present. The native debugger is not harmed by the | |
| // presence of this information. | |
| MDRawBreakpadInfo breakpad_info; | |
| breakpad_info.validity = MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID | | |
| MD_BREAKPAD_INFO_VALID_REQUESTING_THREAD_ID; | |
| breakpad_info.dump_thread_id = GetCurrentThreadId(); | |
| breakpad_info.requesting_thread_id = requesting_thread_id; | |
| int index = user_streams.UserStreamCount; | |
| user_stream_array[index].Type = MD_BREAKPAD_INFO_STREAM; | |
| user_stream_array[index].BufferSize = sizeof(breakpad_info); | |
| user_stream_array[index].Buffer = &breakpad_info; | |
| ++user_streams.UserStreamCount; | |
| } | |
| if (assertion) { | |
| int index = user_streams.UserStreamCount; | |
| user_stream_array[index].Type = MD_ASSERTION_INFO_STREAM; | |
| user_stream_array[index].BufferSize = sizeof(MDRawAssertionInfo); | |
| user_stream_array[index].Buffer = assertion; | |
| ++user_streams.UserStreamCount; | |
| } | |
| // Older versions of DbgHelp.dll don't correctly put the memory around | |
| // the faulting instruction pointer into the minidump. This | |
| // callback will ensure that it gets included. | |
| if (exinfo) { | |
| // Find a memory region of 256 bytes centered on the | |
| // faulting instruction pointer. | |
| const ULONG64 instruction_pointer = | |
| #if defined(_M_IX86) | |
| exinfo->ContextRecord->Eip; | |
| #elif defined(_M_AMD64) | |
| exinfo->ContextRecord->Rip; | |
| #elif defined(_M_ARM64) | |
| exinfo->ContextRecord->Pc; | |
| #else | |
| #error Unsupported platform | |
| #endif | |
| MEMORY_BASIC_INFORMATION info; | |
| if (VirtualQueryEx(process, | |
| reinterpret_cast<LPCVOID>(instruction_pointer), | |
| &info, | |
| sizeof(MEMORY_BASIC_INFORMATION)) != 0 && | |
| info.State == MEM_COMMIT) { | |
| // Attempt to get 128 bytes before and after the instruction | |
| // pointer, but settle for whatever's available up to the | |
| // boundaries of the memory region. | |
| const ULONG64 kIPMemorySize = 256; | |
| ULONG64 base = | |
| (std::max)(reinterpret_cast<ULONG64>(info.BaseAddress), | |
| instruction_pointer - (kIPMemorySize / 2)); | |
| ULONG64 end_of_range = | |
| (std::min)(instruction_pointer + (kIPMemorySize / 2), | |
| reinterpret_cast<ULONG64>(info.BaseAddress) | |
| + info.RegionSize); | |
| ULONG size = static_cast<ULONG>(end_of_range - base); | |
| AppMemory& elt = app_memory_info_.front(); | |
| elt.ptr = base; | |
| elt.length = size; | |
| } | |
| } | |
| MinidumpCallbackContext context; | |
| context.iter = app_memory_info_.begin(); | |
| context.end = app_memory_info_.end(); | |
| // Skip the reserved element if there was no instruction memory | |
| if (context.iter->ptr == 0) { | |
| context.iter++; | |
| } | |
| MINIDUMP_CALLBACK_INFORMATION callback; | |
| callback.CallbackRoutine = MinidumpWriteDumpCallback; | |
| callback.CallbackParam = reinterpret_cast<void*>(&context); | |
| // The explicit comparison to TRUE avoids a warning (C4800). | |
| success = (minidump_write_dump_(process, | |
| GetProcessId(process), | |
| dump_file, | |
| dump_type_, | |
| exinfo ? &except_info : NULL, | |
| &user_streams, | |
| &callback) == TRUE); | |
| CloseHandle(dump_file); | |
| } | |
| } | |
| return success; | |
| } | |
| void ExceptionHandler::UpdateNextID() { | |
| assert(uuid_create_); | |
| UUID id = {0}; | |
| if (uuid_create_) { | |
| uuid_create_(&id); | |
| } | |
| next_minidump_id_ = GUIDString::GUIDToWString(&id); | |
| next_minidump_id_c_ = next_minidump_id_.c_str(); | |
| wchar_t minidump_path[MAX_PATH]; | |
| swprintf(minidump_path, MAX_PATH, L"%s\\%s.dmp", | |
| dump_path_c_, next_minidump_id_c_); | |
| // remove when VC++7.1 is no longer supported | |
| minidump_path[MAX_PATH - 1] = L'\0'; | |
| next_minidump_path_ = minidump_path; | |
| next_minidump_path_c_ = next_minidump_path_.c_str(); | |
| } | |
| void ExceptionHandler::RegisterAppMemory(void* ptr, size_t length) { | |
| AppMemoryList::iterator iter = | |
| std::find(app_memory_info_.begin(), app_memory_info_.end(), ptr); | |
| if (iter != app_memory_info_.end()) { | |
| // Don't allow registering the same pointer twice. | |
| return; | |
| } | |
| AppMemory app_memory; | |
| app_memory.ptr = reinterpret_cast<ULONG64>(ptr); | |
| app_memory.length = static_cast<ULONG>(length); | |
| app_memory_info_.push_back(app_memory); | |
| } | |
| void ExceptionHandler::UnregisterAppMemory(void* ptr) { | |
| AppMemoryList::iterator iter = | |
| std::find(app_memory_info_.begin(), app_memory_info_.end(), ptr); | |
| if (iter != app_memory_info_.end()) { | |
| app_memory_info_.erase(iter); | |
| } | |
| } | |
| } // namespace google_breakpad |