diff options
Diffstat (limited to 'src/client/windows/handler/exception_handler.h')
-rw-r--r-- | src/client/windows/handler/exception_handler.h | 92 |
1 files changed, 64 insertions, 28 deletions
diff --git a/src/client/windows/handler/exception_handler.h b/src/client/windows/handler/exception_handler.h index fc9af326..870025fb 100644 --- a/src/client/windows/handler/exception_handler.h +++ b/src/client/windows/handler/exception_handler.h @@ -68,7 +68,9 @@ #include <string> #include <vector> +#include "client/windows/crash_generation/crash_generation_client.h" #include "google_breakpad/common/minidump_format.h" +#include "processor/scoped_ptr.h" namespace google_breakpad { @@ -88,8 +90,8 @@ class ExceptionHandler { // attempting to write a minidump. If a FilterCallback returns false, Breakpad // will immediately report the exception as unhandled without writing a // minidump, allowing another handler the opportunity to handle it. - typedef bool (*FilterCallback)(void *context, EXCEPTION_POINTERS *exinfo, - MDRawAssertionInfo *assertion); + typedef bool (*FilterCallback)(void* context, EXCEPTION_POINTERS* exinfo, + MDRawAssertionInfo* assertion); // A callback function to run after the minidump has been written. // minidump_id is a unique id for the dump, so the minidump @@ -110,11 +112,16 @@ class ExceptionHandler { // should normally return the value of |succeeded|, or when they wish to // not report an exception of handled, false. Callbacks will rarely want to // return true directly (unless |succeeded| is true). - typedef bool (*MinidumpCallback)(const wchar_t *dump_path, - const wchar_t *minidump_id, - void *context, - EXCEPTION_POINTERS *exinfo, - MDRawAssertionInfo *assertion, + // + // For out-of-process dump generation, dump path and minidump ID will always + // be NULL. In case of out-of-process dump generation, the dump path and + // minidump id are controlled by the server process and are not communicated + // back to the crashing process. + typedef bool (*MinidumpCallback)(const wchar_t* dump_path, + const wchar_t* minidump_id, + void* context, + EXCEPTION_POINTERS* exinfo, + MDRawAssertionInfo* assertion, bool succeeded); // HandlerType specifies which types of handlers should be installed, if @@ -139,11 +146,25 @@ class ExceptionHandler { // minidump. Minidump files will be written to dump_path, and the optional // callback is called after writing the dump file, as described above. // handler_types specifies the types of handlers that should be installed. - ExceptionHandler(const wstring &dump_path, + ExceptionHandler(const wstring& dump_path, FilterCallback filter, MinidumpCallback callback, - void *callback_context, + void* callback_context, int handler_types); + + // Creates a new ExcetpionHandler instance that can attempt to perform + // out-of-process dump generation if pipe_name is not NULL. If pipe_name is + // NULL, or if out-of-process dump generation registration step fails, + // in-process dump generation will be used. This also allows specifying + // the dump type to generate. + ExceptionHandler(const wstring& dump_path, + FilterCallback filter, + MinidumpCallback callback, + void* callback_context, + int handler_types, + MINIDUMP_TYPE dump_type, + const wchar_t* pipe_name); + ~ExceptionHandler(); // Get and set the minidump path. @@ -160,12 +181,12 @@ class ExceptionHandler { // Writes a minidump immediately, with the user-supplied exception // information. - bool WriteMinidumpForException(EXCEPTION_POINTERS *exinfo); + bool WriteMinidumpForException(EXCEPTION_POINTERS* exinfo); // Convenience form of WriteMinidump which does not require an // ExceptionHandler instance. static bool WriteMinidump(const wstring &dump_path, - MinidumpCallback callback, void *callback_context); + MinidumpCallback callback, void* callback_context); // Get the thread ID of the thread requesting the dump (either the exception // thread or any other thread that called WriteMinidump directly). This @@ -179,9 +200,21 @@ class ExceptionHandler { handle_debug_exceptions_ = handle_debug_exceptions; } + // Returns whether out-of-process dump generation is used or not. + bool IsOutOfProcess() const { return crash_generation_client_.get() != NULL; } + private: friend class AutoExceptionHandler; + // Initializes the instance with given values. + void Initialize(const wstring& dump_path, + FilterCallback filter, + MinidumpCallback callback, + void* callback_context, + int handler_types, + MINIDUMP_TYPE dump_type, + const wchar_t* pipe_name); + // Function pointer type for MiniDumpWriteDump, which is looked up // dynamically. typedef BOOL (WINAPI *MiniDumpWriteDump_type)( @@ -194,14 +227,14 @@ class ExceptionHandler { CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam); // Function pointer type for UuidCreate, which is looked up dynamically. - typedef RPC_STATUS (RPC_ENTRY *UuidCreate_type)(UUID *Uuid); + typedef RPC_STATUS (RPC_ENTRY *UuidCreate_type)(UUID* Uuid); // Runs the main loop for the exception handler thread. - static DWORD WINAPI ExceptionHandlerThreadMain(void *lpParameter); + static DWORD WINAPI ExceptionHandlerThreadMain(void* lpParameter); // Called on the exception thread when an unhandled exception occurs. // Signals the exception handler thread to handle the exception. - static LONG WINAPI HandleException(EXCEPTION_POINTERS *exinfo); + static LONG WINAPI HandleException(EXCEPTION_POINTERS* exinfo); #if _MSC_VER >= 1400 // MSVC 2005/8 // This function will be called by some CRT functions when they detect @@ -209,9 +242,9 @@ class ExceptionHandler { // the CRT may display an assertion dialog before calling this function, // and the function will not be called unless the assertion dialog is // dismissed by clicking "Ignore." - static void HandleInvalidParameter(const wchar_t *expression, - const wchar_t *function, - const wchar_t *file, + static void HandleInvalidParameter(const wchar_t* expression, + const wchar_t* function, + const wchar_t* file, unsigned int line, uintptr_t reserved); #endif // _MSC_VER >= 1400 @@ -229,8 +262,8 @@ class ExceptionHandler { // is NULL. If the dump is requested as a result of an assertion // (such as an invalid parameter being passed to a CRT function), // assertion contains data about the assertion, otherwise, it is NULL. - bool WriteMinidumpOnHandlerThread(EXCEPTION_POINTERS *exinfo, - MDRawAssertionInfo *assertion); + bool WriteMinidumpOnHandlerThread(EXCEPTION_POINTERS* exinfo, + MDRawAssertionInfo* assertion); // This function does the actual writing of a minidump. It is called // on the handler thread. requesting_thread_id is the ID of the thread @@ -238,8 +271,8 @@ class ExceptionHandler { // an exception, exinfo contains exception information, otherwise, // it is NULL. bool WriteMinidumpWithException(DWORD requesting_thread_id, - EXCEPTION_POINTERS *exinfo, - MDRawAssertionInfo *assertion); + EXCEPTION_POINTERS* exinfo, + MDRawAssertionInfo* assertion); // Generates a new ID and stores it in next_minidump_id_, and stores the // path of the next minidump to be written in next_minidump_path_. @@ -247,7 +280,9 @@ class ExceptionHandler { FilterCallback filter_; MinidumpCallback callback_; - void *callback_context_; + void* callback_context_; + + scoped_ptr<CrashGenerationClient> crash_generation_client_; // The directory in which a minidump will be written, set by the dump_path // argument to the constructor, or set_dump_path. @@ -266,12 +301,13 @@ class ExceptionHandler { // pointers are not owned by the ExceptionHandler object, but their lifetimes // should be equivalent to the lifetimes of the associated wstring, provided // that the wstrings are not altered. - const wchar_t *dump_path_c_; - const wchar_t *next_minidump_id_c_; - const wchar_t *next_minidump_path_c_; + const wchar_t* dump_path_c_; + const wchar_t* next_minidump_id_c_; + const wchar_t* next_minidump_path_c_; HMODULE dbghelp_module_; MiniDumpWriteDump_type minidump_write_dump_; + MINIDUMP_TYPE dump_type_; HMODULE rpcrt4_module_; UuidCreate_type uuid_create_; @@ -322,11 +358,11 @@ class ExceptionHandler { // The exception info passed to the exception handler on the exception // thread, if an exception occurred. NULL for user-requested dumps. - EXCEPTION_POINTERS *exception_info_; + EXCEPTION_POINTERS* exception_info_; // If the handler is invoked due to an assertion, this will contain a // pointer to the assertion information. It is NULL at other times. - MDRawAssertionInfo *assertion_; + MDRawAssertionInfo* assertion_; // The return value of the handler, passed from the handler thread back to // the requesting thread. @@ -342,7 +378,7 @@ class ExceptionHandler { // which ExceptionHandler object to route an exception to. When an // ExceptionHandler is created with install_handler true, it will append // itself to this list. - static vector<ExceptionHandler *> *handler_stack_; + static vector<ExceptionHandler*>* handler_stack_; // The index of the ExceptionHandler in handler_stack_ that will handle the // next exception. Note that 0 means the last entry in handler_stack_, 1 |