/thirdparty/breakpad/client/linux/minidump_writer/linux_dumper.h

http://github.com/tomahawk-player/tomahawk · C Header · 235 lines · 108 code · 42 blank · 85 comment · 3 complexity · cc1a0aaeb074480221688f52cd2dc4fb MD5 · raw file

  1. // Copyright (c) 2010, Google Inc.
  2. // All rights reserved.
  3. //
  4. // Redistribution and use in source and binary forms, with or without
  5. // modification, are permitted provided that the following conditions are
  6. // met:
  7. //
  8. // * Redistributions of source code must retain the above copyright
  9. // notice, this list of conditions and the following disclaimer.
  10. // * Redistributions in binary form must reproduce the above
  11. // copyright notice, this list of conditions and the following disclaimer
  12. // in the documentation and/or other materials provided with the
  13. // distribution.
  14. // * Neither the name of Google Inc. nor the names of its
  15. // contributors may be used to endorse or promote products derived from
  16. // this software without specific prior written permission.
  17. //
  18. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29. // linux_dumper.h: Define the google_breakpad::LinuxDumper class, which
  30. // is a base class for extracting information of a crashed process. It
  31. // was originally a complete implementation using the ptrace API, but
  32. // has been refactored to allow derived implementations supporting both
  33. // ptrace and core dump. A portion of the original implementation is now
  34. // in google_breakpad::LinuxPtraceDumper (see linux_ptrace_dumper.h for
  35. // details).
  36. #ifndef CLIENT_LINUX_MINIDUMP_WRITER_LINUX_DUMPER_H_
  37. #define CLIENT_LINUX_MINIDUMP_WRITER_LINUX_DUMPER_H_
  38. #include <elf.h>
  39. #include <linux/limits.h>
  40. #include <stdint.h>
  41. #include <sys/types.h>
  42. #if !defined(__ANDROID__)
  43. #include <sys/user.h>
  44. #endif
  45. #include "common/memory.h"
  46. #include "google_breakpad/common/minidump_format.h"
  47. namespace google_breakpad {
  48. #if defined(__i386) || defined(__x86_64)
  49. typedef typeof(((struct user*) 0)->u_debugreg[0]) debugreg_t;
  50. #endif
  51. // Typedef for our parsing of the auxv variables in /proc/pid/auxv.
  52. #if defined(__i386) || defined(__ARM_EABI__)
  53. #if !defined(__ANDROID__)
  54. typedef Elf32_auxv_t elf_aux_entry;
  55. #else
  56. // Android is missing this structure definition
  57. typedef struct
  58. {
  59. uint32_t a_type; /* Entry type */
  60. union
  61. {
  62. uint32_t a_val; /* Integer value */
  63. } a_un;
  64. } elf_aux_entry;
  65. #if !defined(AT_SYSINFO_EHDR)
  66. #define AT_SYSINFO_EHDR 33
  67. #endif
  68. #endif // __ANDROID__
  69. #elif defined(__x86_64)
  70. typedef Elf64_auxv_t elf_aux_entry;
  71. #endif
  72. // When we find the VDSO mapping in the process's address space, this
  73. // is the name we use for it when writing it to the minidump.
  74. // This should always be less than NAME_MAX!
  75. const char kLinuxGateLibraryName[] = "linux-gate.so";
  76. // We produce one of these structures for each thread in the crashed process.
  77. struct ThreadInfo {
  78. pid_t tgid; // thread group id
  79. pid_t ppid; // parent process
  80. // Even on platforms where the stack grows down, the following will point to
  81. // the smallest address in the stack.
  82. const void* stack; // pointer to the stack area
  83. size_t stack_len; // length of the stack to copy
  84. #if defined(__i386) || defined(__x86_64)
  85. user_regs_struct regs;
  86. user_fpregs_struct fpregs;
  87. static const unsigned kNumDebugRegisters = 8;
  88. debugreg_t dregs[8];
  89. #if defined(__i386)
  90. user_fpxregs_struct fpxregs;
  91. #endif // defined(__i386)
  92. #elif defined(__ARM_EABI__)
  93. // Mimicking how strace does this(see syscall.c, search for GETREGS)
  94. #if defined(__ANDROID__)
  95. struct pt_regs regs;
  96. #else
  97. struct user_regs regs;
  98. struct user_fpregs fpregs;
  99. #endif // __ANDROID__
  100. #endif
  101. };
  102. // One of these is produced for each mapping in the process (i.e. line in
  103. // /proc/$x/maps).
  104. struct MappingInfo {
  105. uintptr_t start_addr;
  106. size_t size;
  107. size_t offset; // offset into the backed file.
  108. char name[NAME_MAX];
  109. };
  110. class LinuxDumper {
  111. public:
  112. explicit LinuxDumper(pid_t pid);
  113. virtual ~LinuxDumper();
  114. // Parse the data for |threads| and |mappings|.
  115. virtual bool Init();
  116. // Return true if the dumper performs a post-mortem dump.
  117. virtual bool IsPostMortem() const = 0;
  118. // Suspend/resume all threads in the given process.
  119. virtual bool ThreadsSuspend() = 0;
  120. virtual bool ThreadsResume() = 0;
  121. // Read information about the |index|-th thread of |threads_|.
  122. // Returns true on success. One must have called |ThreadsSuspend| first.
  123. virtual bool GetThreadInfoByIndex(size_t index, ThreadInfo* info) = 0;
  124. // These are only valid after a call to |Init|.
  125. const wasteful_vector<pid_t> &threads() { return threads_; }
  126. const wasteful_vector<MappingInfo*> &mappings() { return mappings_; }
  127. const MappingInfo* FindMapping(const void* address) const;
  128. // Find a block of memory to take as the stack given the top of stack pointer.
  129. // stack: (output) the lowest address in the memory area
  130. // stack_len: (output) the length of the memory area
  131. // stack_top: the current top of the stack
  132. bool GetStackInfo(const void** stack, size_t* stack_len, uintptr_t stack_top);
  133. PageAllocator* allocator() { return &allocator_; }
  134. // Copy content of |length| bytes from a given process |child|,
  135. // starting from |src|, into |dest|.
  136. virtual void CopyFromProcess(void* dest, pid_t child, const void* src,
  137. size_t length) = 0;
  138. // Builds a proc path for a certain pid for a node (/proc/<pid>/<node>).
  139. // |path| is a character array of at least NAME_MAX bytes to return the
  140. // result.|node| is the final node without any slashes. Returns true on
  141. // success.
  142. virtual bool BuildProcPath(char* path, pid_t pid, const char* node) const = 0;
  143. // Generate a File ID from the .text section of a mapped entry.
  144. // If not a member, mapping_id is ignored.
  145. bool ElfFileIdentifierForMapping(const MappingInfo& mapping,
  146. bool member,
  147. unsigned int mapping_id,
  148. uint8_t identifier[sizeof(MDGUID)]);
  149. // Utility method to find the location of where the kernel has
  150. // mapped linux-gate.so in memory(shows up in /proc/pid/maps as
  151. // [vdso], but we can't guarantee that it's the only virtual dynamic
  152. // shared object. Parsing the auxilary vector for AT_SYSINFO_EHDR
  153. // is the safest way to go.)
  154. void* FindBeginningOfLinuxGateSharedLibrary(pid_t pid) const;
  155. // Utility method to find the entry point location.
  156. void* FindEntryPoint(pid_t pid) const;
  157. uintptr_t crash_address() const { return crash_address_; }
  158. void set_crash_address(uintptr_t crash_address) {
  159. crash_address_ = crash_address;
  160. }
  161. int crash_signal() const { return crash_signal_; }
  162. void set_crash_signal(int crash_signal) { crash_signal_ = crash_signal; }
  163. pid_t crash_thread() const { return crash_thread_; }
  164. void set_crash_thread(pid_t crash_thread) { crash_thread_ = crash_thread; }
  165. protected:
  166. virtual bool EnumerateMappings();
  167. virtual bool EnumerateThreads() = 0;
  168. // For the case where a running program has been deleted, it'll show up in
  169. // /proc/pid/maps as "/path/to/program (deleted)". If this is the case, then
  170. // see if '/path/to/program (deleted)' matches /proc/pid/exe and return
  171. // /proc/pid/exe in |path| so ELF identifier generation works correctly. This
  172. // also checks to see if '/path/to/program (deleted)' exists, so it does not
  173. // get fooled by a poorly named binary.
  174. // For programs that don't end with ' (deleted)', this is a no-op.
  175. // This assumes |path| is a buffer with length NAME_MAX.
  176. // Returns true if |path| is modified.
  177. bool HandleDeletedFileInMapping(char* path) const;
  178. // ID of the crashed process.
  179. const pid_t pid_;
  180. // Virtual address at which the process crashed.
  181. uintptr_t crash_address_;
  182. // Signal that terminated the crashed process.
  183. int crash_signal_;
  184. // ID of the crashed thread.
  185. pid_t crash_thread_;
  186. mutable PageAllocator allocator_;
  187. // IDs of all the threads.
  188. wasteful_vector<pid_t> threads_;
  189. // Info from /proc/<pid>/maps.
  190. wasteful_vector<MappingInfo*> mappings_;
  191. };
  192. } // namespace google_breakpad
  193. #endif // CLIENT_LINUX_HANDLER_LINUX_DUMPER_H_