| // Copyright (c) 2008, 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. |
| |
| #ifndef CLIENT_WINDOWS_CRASH_GENERATION_MINIDUMP_GENERATOR_H_ |
| #define CLIENT_WINDOWS_CRASH_GENERATION_MINIDUMP_GENERATOR_H_ |
| |
| #include <windows.h> |
| #include <dbghelp.h> |
| #include <rpc.h> |
| #include <list> |
| #include <string> |
| #include "google_breakpad/common/minidump_format.h" |
| |
| namespace google_breakpad { |
| |
| // Abstraction for various objects and operations needed to generate |
| // minidump on Windows. This abstraction is useful to hide all the gory |
| // details for minidump generation and provide a clean interface to |
| // the clients to generate minidumps. |
| class MinidumpGenerator { |
| public: |
| // Creates an instance with the given parameters. |
| // is_client_pointers specifies whether the exception_pointers and |
| // assert_info point into the process that is being dumped. |
| // Before calling WriteMinidump on the returned instance a dump file muct be |
| // specified by a call to either SetDumpFile() or GenerateDumpFile(). |
| // If a full dump file will be requested via a subsequent call to either |
| // SetFullDumpFile or GenerateFullDumpFile() dump_type must include |
| // MiniDumpWithFullMemory. |
| MinidumpGenerator(const std::wstring& dump_path, |
| const HANDLE process_handle, |
| const DWORD process_id, |
| const DWORD thread_id, |
| const DWORD requesting_thread_id, |
| EXCEPTION_POINTERS* exception_pointers, |
| MDRawAssertionInfo* assert_info, |
| const MINIDUMP_TYPE dump_type, |
| const bool is_client_pointers); |
| |
| ~MinidumpGenerator(); |
| |
| void SetDumpFile(const HANDLE dump_file) { dump_file_ = dump_file; } |
| void SetFullDumpFile(const HANDLE full_dump_file) { |
| full_dump_file_ = full_dump_file; |
| } |
| |
| // Generate the name for the dump file that will be written to once |
| // WriteMinidump() is called. Can only be called once and cannot be called |
| // if the dump file is set via SetDumpFile(). |
| bool GenerateDumpFile(std::wstring* dump_path); |
| |
| // Generate the name for the full dump file that will be written to once |
| // WriteMinidump() is called. Cannot be called unless the minidump type |
| // includes MiniDumpWithFullMemory. Can only be called once and cannot be |
| // called if the dump file is set via SetFullDumpFile(). |
| bool GenerateFullDumpFile(std::wstring* full_dump_path); |
| |
| void SetAdditionalStreams( |
| MINIDUMP_USER_STREAM_INFORMATION* additional_streams) { |
| additional_streams_ = additional_streams; |
| } |
| |
| void SetCallback(MINIDUMP_CALLBACK_INFORMATION* callback_info) { |
| callback_info_ = callback_info; |
| } |
| |
| // Writes the minidump with the given parameters. Stores the |
| // dump file path in the dump_path parameter if dump generation |
| // succeeds. |
| bool WriteMinidump(); |
| |
| private: |
| // Function pointer type for MiniDumpWriteDump, which is looked up |
| // dynamically. |
| typedef BOOL (WINAPI* MiniDumpWriteDumpType)( |
| HANDLE hProcess, |
| DWORD ProcessId, |
| HANDLE hFile, |
| MINIDUMP_TYPE DumpType, |
| CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, |
| CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, |
| CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam); |
| |
| // Function pointer type for UuidCreate, which is looked up dynamically. |
| typedef RPC_STATUS (RPC_ENTRY* UuidCreateType)(UUID* Uuid); |
| |
| // Loads the appropriate DLL lazily in a thread safe way. |
| HMODULE GetDbghelpModule(); |
| |
| // Loads the appropriate DLL and gets a pointer to the MiniDumpWriteDump |
| // function lazily and in a thread-safe manner. |
| MiniDumpWriteDumpType GetWriteDump(); |
| |
| // Loads the appropriate DLL lazily in a thread safe way. |
| HMODULE GetRpcrt4Module(); |
| |
| // Loads the appropriate DLL and gets a pointer to the UuidCreate |
| // function lazily and in a thread-safe manner. |
| UuidCreateType GetCreateUuid(); |
| |
| // Returns the path for the file to write dump to. |
| bool GenerateDumpFilePath(std::wstring* file_path); |
| |
| // Handle to dynamically loaded DbgHelp.dll. |
| HMODULE dbghelp_module_; |
| |
| // Pointer to the MiniDumpWriteDump function. |
| MiniDumpWriteDumpType write_dump_; |
| |
| // Handle to dynamically loaded rpcrt4.dll. |
| HMODULE rpcrt4_module_; |
| |
| // Pointer to the UuidCreate function. |
| UuidCreateType create_uuid_; |
| |
| // Handle for the process to dump. |
| HANDLE process_handle_; |
| |
| // Process ID for the process to dump. |
| DWORD process_id_; |
| |
| // The crashing thread ID. |
| DWORD thread_id_; |
| |
| // The thread ID which is requesting the dump. |
| DWORD requesting_thread_id_; |
| |
| // Pointer to the exception information for the crash. This may point to an |
| // address in the crashing process so it should not be dereferenced. |
| EXCEPTION_POINTERS* exception_pointers_; |
| |
| // Assertion info for the report. |
| MDRawAssertionInfo* assert_info_; |
| |
| // Type of minidump to generate. |
| MINIDUMP_TYPE dump_type_; |
| |
| // Specifies whether the exception_pointers_ reference memory in the crashing |
| // process. |
| bool is_client_pointers_; |
| |
| // Folder path to store dump files. |
| std::wstring dump_path_; |
| |
| // The file where the dump will be written. |
| HANDLE dump_file_; |
| |
| // The file where the full dump will be written. |
| HANDLE full_dump_file_; |
| |
| // Tracks whether the dump file handle is managed externally. |
| bool dump_file_is_internal_; |
| |
| // Tracks whether the full dump file handle is managed externally. |
| bool full_dump_file_is_internal_; |
| |
| // Additional streams to be written to the dump. |
| MINIDUMP_USER_STREAM_INFORMATION* additional_streams_; |
| |
| // The user defined callback for the various stages of the dump process. |
| MINIDUMP_CALLBACK_INFORMATION* callback_info_; |
| |
| // Critical section to sychronize action of loading modules dynamically. |
| CRITICAL_SECTION module_load_sync_; |
| |
| // Critical section to synchronize action of dynamically getting function |
| // addresses from modules. |
| CRITICAL_SECTION get_proc_address_sync_; |
| }; |
| |
| } // namespace google_breakpad |
| |
| #endif // CLIENT_WINDOWS_CRASH_GENERATION_MINIDUMP_GENERATOR_H_ |