// Copyright 2010 Google LLC // // 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 LLC 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. // minidump.h: A minidump reader. // // The basic structure of this module tracks the structure of the minidump // file itself. At the top level, a minidump file is represented by a // Minidump object. Like most other classes in this module, Minidump // provides a Read method that initializes the object with information from // the file. Most of the classes in this file are wrappers around the // "raw" structures found in the minidump file itself, and defined in // minidump_format.h. For example, each thread is represented by a // MinidumpThread object, whose parameters are specified in an MDRawThread // structure. A properly byte-swapped MDRawThread can be obtained from a // MinidumpThread easily by calling its thread() method. // // Most of the module lazily reads only the portion of the minidump file // necessary to fulfill the user's request. Calling Minidump::Read // only reads the minidump's directory. The thread list is not read until // it is needed, and even once it's read, the memory regions for each // thread's stack aren't read until they're needed. This strategy avoids // unnecessary file input, and allocating memory for data in which the user // has no interest. Note that although memory allocations for a typical // minidump file are not particularly large, it is possible for legitimate // minidumps to be sizable. A full-memory minidump, for example, contains // a snapshot of the entire mapped memory space. Even a normal minidump, // with stack memory only, can be large if, for example, the dump was // generated in response to a crash that occurred due to an infinite- // recursion bug that caused the stack's limits to be exceeded. Finally, // some users of this library will unfortunately find themselves in the // position of having to process potentially-hostile minidumps that might // attempt to cause problems by forcing the minidump processor to over- // allocate memory. // // Memory management in this module is based on a strict // you-don't-own-anything policy. The only object owned by the user is // the top-level Minidump object, the creation and destruction of which // must be the user's own responsibility. All other objects obtained // through interaction with this module are ultimately owned by the // Minidump object, and will be freed upon the Minidump object's destruction. // Because memory regions can potentially involve large allocations, a // FreeMemory method is provided by MinidumpMemoryRegion, allowing the user // to release data when it is no longer needed. Use of this method is // optional but recommended. If freed data is later required, it will // be read back in from the minidump file again. // // There is one exception to this memory management policy: // Minidump::ReadString will return a string object to the user, and the user // is responsible for its deletion. // // Author: Mark Mentovai #ifndef GOOGLE_BREAKPAD_PROCESSOR_MINIDUMP_H__ #define GOOGLE_BREAKPAD_PROCESSOR_MINIDUMP_H__ #include <stdint.h> #ifndef _WIN32 #include <unistd.h> #endif #include <iostream> #include <map> #include <string> #include <vector> #include "common/using_std_string.h" #include "google_breakpad/processor/code_module.h" #include "google_breakpad/processor/code_modules.h" #include "google_breakpad/processor/dump_context.h" #include "google_breakpad/processor/dump_object.h" #include "google_breakpad/processor/memory_region.h" #include "google_breakpad/processor/proc_maps_linux.h" namespace google_breakpad { map; vector; class Minidump; template<typename AddressType, typename EntryType> class RangeMap; // MinidumpObject is the base of all Minidump* objects except for Minidump // itself. class MinidumpObject : public DumpObject { … }; // This class exists primarily to provide a virtual destructor in a base // class common to all objects that might be stored in // Minidump::mStreamObjects. Some object types will never be stored in // Minidump::mStreamObjects, but are represented as streams and adhere to the // same interface, and may be derived from this class. class MinidumpStream : public MinidumpObject { … }; // MinidumpContext carries a CPU-specific MDRawContext structure, which // contains CPU context such as register states. Each thread has its // own context, and the exception record, if present, also has its own // context. Note that if the exception record is present, the context it // refers to is probably what the user wants to use for the exception // thread, instead of that thread's own context. The exception thread's // context (as opposed to the exception record's context) will contain // context for the exception handler (which performs minidump generation), // and not the context that caused the exception (which is probably what the // user wants). class MinidumpContext : public DumpContext { … }; // MinidumpMemoryRegion does not wrap any MDRaw structure, and only contains // a reference to an MDMemoryDescriptor. This object is intended to wrap // portions of a minidump file that contain memory dumps. In normal // minidumps, each MinidumpThread owns a MinidumpMemoryRegion corresponding // to the thread's stack memory. MinidumpMemoryList also gives access to // memory regions in its list as MinidumpMemoryRegions. This class // adheres to MemoryRegion so that it may be used as a data provider to // the Stackwalker family of classes. class MinidumpMemoryRegion : public MinidumpObject, public MemoryRegion { … }; // MinidumpThread contains information about a thread of execution, // including a snapshot of the thread's stack and CPU context. For // the thread that caused an exception, the context carried by // MinidumpException is probably desired instead of the CPU context // provided here. // Note that a MinidumpThread may be valid() even if it does not // contain a memory region or context. class MinidumpThread : public MinidumpObject { … }; // MinidumpThreadList contains all of the threads (as MinidumpThreads) in // a process. class MinidumpThreadList : public MinidumpStream { … }; // MinidumpThreadName contains the name of a thread. class MinidumpThreadName : public MinidumpObject { … }; // MinidumpThreadNameList contains all of the names of the threads (as // MinidumpThreadNames) in a process. class MinidumpThreadNameList : public MinidumpStream { … }; // MinidumpModule wraps MDRawModule, which contains information about loaded // code modules. Access is provided to various data referenced indirectly // by MDRawModule, such as the module's name and a specification for where // to locate debugging information for the module. class MinidumpModule : public MinidumpObject, public CodeModule { … }; // MinidumpModuleList contains all of the loaded code modules for a process // in the form of MinidumpModules. It maintains a map of these modules // so that it may easily provide a code module corresponding to a specific // address. class MinidumpModuleList : public MinidumpStream, public CodeModules { … }; // MinidumpMemoryList corresponds to a minidump's MEMORY_LIST_STREAM stream, // which references the snapshots of all of the memory regions contained // within the minidump. For a normal minidump, this includes stack memory // (also referenced by each MinidumpThread, in fact, the MDMemoryDescriptors // here and in MDRawThread both point to exactly the same data in a // minidump file, conserving space), as well as a 256-byte snapshot of memory // surrounding the instruction pointer in the case of an exception. Other // types of minidumps may contain significantly more memory regions. Full- // memory minidumps contain all of a process' mapped memory. class MinidumpMemoryList : public MinidumpStream { … }; // MinidumpException wraps MDRawExceptionStream, which contains information // about the exception that caused the minidump to be generated, if the // minidump was generated in an exception handler called as a result of an // exception. It also provides access to a MinidumpContext object, which // contains the CPU context for the exception thread at the time the exception // occurred. class MinidumpException : public MinidumpStream { … }; // MinidumpAssertion wraps MDRawAssertionInfo, which contains information // about an assertion that caused the minidump to be generated. class MinidumpAssertion : public MinidumpStream { … }; // MinidumpSystemInfo wraps MDRawSystemInfo and provides information about // the system on which the minidump was generated. See also MinidumpMiscInfo. class MinidumpSystemInfo : public MinidumpStream { … }; // MinidumpUnloadedModule wraps MDRawUnloadedModule class MinidumpUnloadedModule : public MinidumpObject, public CodeModule { … }; // MinidumpUnloadedModuleList contains all the unloaded code modules for a // process in the form of MinidumpUnloadedModules. It maintains a map of // these modules so that it may easily provide a code module corresponding // to a specific address. If multiple modules in the list have identical // ranges, only the first module encountered is recorded in the range map. class MinidumpUnloadedModuleList : public MinidumpStream, public CodeModules { … }; // MinidumpMiscInfo wraps MDRawMiscInfo and provides information about // the process that generated the minidump, and optionally additional system // information. See also MinidumpSystemInfo. class MinidumpMiscInfo : public MinidumpStream { … }; // MinidumpBreakpadInfo wraps MDRawBreakpadInfo, which is an optional stream in // a minidump that provides additional information about the process state // at the time the minidump was generated. class MinidumpBreakpadInfo : public MinidumpStream { … }; // MinidumpMemoryInfo wraps MDRawMemoryInfo, which provides information // about mapped memory regions in a process, including their ranges // and protection. class MinidumpMemoryInfo : public MinidumpObject { … }; // MinidumpMemoryInfoList contains a list of information about // mapped memory regions for a process in the form of MDRawMemoryInfo. // It maintains a map of these structures so that it may easily provide // info corresponding to a specific address. class MinidumpMemoryInfoList : public MinidumpStream { … }; // MinidumpLinuxMaps wraps information about a single mapped memory region // from /proc/self/maps. class MinidumpLinuxMaps : public MinidumpObject { … }; // MinidumpLinuxMapsList corresponds to the Linux-exclusive MD_LINUX_MAPS // stream, which contains the contents of /prod/self/maps, which contains // the mapped memory regions and their access permissions. class MinidumpLinuxMapsList : public MinidumpStream { … }; // MinidumpCrashpadInfo wraps MDRawCrashpadInfo, which is an optional stream in // a minidump that provides additional information about the process state // at the time the minidump was generated. class MinidumpCrashpadInfo : public MinidumpStream { … }; // Minidump is the user's interface to a minidump file. It wraps MDRawHeader // and provides access to the minidump's top-level stream directory. class Minidump { … }; } // namespace google_breakpad #endif // GOOGLE_BREAKPAD_PROCESSOR_MINIDUMP_H__