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

   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
  30 // linux_dumper.h: Define the google_breakpad::LinuxDumper class, which
  31 // is a base class for extracting information of a crashed process. It
  32 // was originally a complete implementation using the ptrace API, but
  33 // has been refactored to allow derived implementations supporting both
  34 // ptrace and core dump. A portion of the original implementation is now
  35 // in google_breakpad::LinuxPtraceDumper (see linux_ptrace_dumper.h for
  36 // details).
  37
  38 #ifndef CLIENT_LINUX_MINIDUMP_WRITER_LINUX_DUMPER_H_
  39 #define CLIENT_LINUX_MINIDUMP_WRITER_LINUX_DUMPER_H_
  40
  41 #include <elf.h>
  42 #include <linux/limits.h>
  43 #include <stdint.h>
  44 #include <sys/types.h>
  45 #include <sys/user.h>
  46
  47 #include "common/memory.h"
  48 #include "google_breakpad/common/minidump_format.h"
  49
  50 namespace google_breakpad {
  51
  52 #if defined(__i386) || defined(__x86_64)
  53 typedef typeof(((struct user*) 0)->u_debugreg[0]) debugreg_t;
  54 #endif
  55
  56 // Typedef for our parsing of the auxv variables in /proc/pid/auxv.
  57 #if defined(__i386) || defined(__ARM_EABI__) || defined(__mips__)
  58 typedef Elf32_auxv_t elf_aux_entry;
  59 #elif defined(__x86_64) || defined(__aarch64__)
  60 typedef Elf64_auxv_t elf_aux_entry;
  61 #endif
  62
  63 typedef typeof(((elf_aux_entry*) 0)->a_un.a_val) elf_aux_val_t;
  64
  65 // When we find the VDSO mapping in the process's address space, this
  66 // is the name we use for it when writing it to the minidump.
  67 // This should always be less than NAME_MAX!
  68 const char kLinuxGateLibraryName[] = "linux-gate.so";
  69
  70 // We produce one of these structures for each thread in the crashed process.
  71 struct ThreadInfo {
  72   pid_t tgid;   // thread group id
  73   pid_t ppid;   // parent process
  74
  75   uintptr_t stack_pointer;  // thread stack pointer
  76
  77
  78 #if defined(__i386) || defined(__x86_64)
  79   user_regs_struct regs;
  80   user_fpregs_struct fpregs;
  81   static const unsigned kNumDebugRegisters = 8;
  82   debugreg_t dregs[8];
  83 #if defined(__i386)
  84   user_fpxregs_struct fpxregs;
  85 #endif  // defined(__i386)
  86
  87 #elif defined(__ARM_EABI__)
  88   // Mimicking how strace does this(see syscall.c, search for GETREGS)
  89   struct user_regs regs;
  90   struct user_fpregs fpregs;
  91 #elif defined(__aarch64__)
  92   // Use the structures defined in <asm/ptrace.h>
  93   struct user_pt_regs regs;
  94   struct user_fpsimd_state fpregs;
  95 #elif defined(__mips__)
  96   user_regs_struct regs;
  97   user_fpregs_struct fpregs;
  98   uint32_t hi[3];
  99   uint32_t lo[3];
 100   uint32_t dsp_control;
 101 #endif
 102 };
 103
 104 // One of these is produced for each mapping in the process (i.e. line in
 105 // /proc/$x/maps).
 106 struct MappingInfo {
 107   uintptr_t start_addr;
 108   size_t size;
 109   size_t offset;  // offset into the backed file.
 110   char name[NAME_MAX];
 111 };
 112
 113 class LinuxDumper {
 114  public:
 115   explicit LinuxDumper(pid_t pid);
 116
 117   virtual ~LinuxDumper();
 118
 119   // Parse the data for |threads| and |mappings|.
 120   virtual bool Init();
 121
 122   // Return true if the dumper performs a post-mortem dump.
 123   virtual bool IsPostMortem() const = 0;
 124
 125   // Suspend/resume all threads in the given process.
 126   virtual bool ThreadsSuspend() = 0;
 127   virtual bool ThreadsResume() = 0;
 128
 129   // Read information about the |index|-th thread of |threads_|.
 130   // Returns true on success. One must have called |ThreadsSuspend| first.
 131   virtual bool GetThreadInfoByIndex(size_t index, ThreadInfo* info) = 0;
 132
 133   // These are only valid after a call to |Init|.
 134   const wasteful_vector<pid_t> &threads() { return threads_; }
 135   const wasteful_vector<MappingInfo*> &mappings() { return mappings_; }
 136   const MappingInfo* FindMapping(const void* address) const;
 137   const wasteful_vector<elf_aux_val_t>& auxv() { return auxv_; }
 138
 139   // Find a block of memory to take as the stack given the top of stack pointer.
 140   //   stack: (output) the lowest address in the memory area
 141   //   stack_len: (output) the length of the memory area
 142   //   stack_top: the current top of the stack
 143   bool GetStackInfo(const void** stack, size_t* stack_len, uintptr_t stack_top);
 144
 145   PageAllocator* allocator() { return &allocator_; }
 146
 147   // Copy content of |length| bytes from a given process |child|,
 148   // starting from |src|, into |dest|.
 149   virtual void CopyFromProcess(void* dest, pid_t child, const void* src,
 150                                size_t length) = 0;
 151
 152   // Builds a proc path for a certain pid for a node (/proc/<pid>/<node>).
 153   // |path| is a character array of at least NAME_MAX bytes to return the
 154   // result.|node| is the final node without any slashes. Returns true on
 155   // success.
 156   virtual bool BuildProcPath(char* path, pid_t pid, const char* node) const = 0;
 157
 158   // Generate a File ID from the .text section of a mapped entry.
 159   // If not a member, mapping_id is ignored.
 160   bool ElfFileIdentifierForMapping(const MappingInfo& mapping,
 161                                    bool member,
 162                                    unsigned int mapping_id,
 163                                    uint8_t identifier[sizeof(MDGUID)]);
 164
 165   uintptr_t crash_address() const { return crash_address_; }
 166   void set_crash_address(uintptr_t crash_address) {
 167     crash_address_ = crash_address;
 168   }
 169
 170   int crash_signal() const { return crash_signal_; }
 171   void set_crash_signal(int crash_signal) { crash_signal_ = crash_signal; }
 172
 173   pid_t crash_thread() const { return crash_thread_; }
 174   void set_crash_thread(pid_t crash_thread) { crash_thread_ = crash_thread; }
 175
 176  protected:
 177   bool ReadAuxv();
 178
 179   virtual bool EnumerateMappings();
 180
 181   virtual bool EnumerateThreads() = 0;
 182
 183   // For the case where a running program has been deleted, it'll show up in
 184   // /proc/pid/maps as "/path/to/program (deleted)". If this is the case, then
 185   // see if '/path/to/program (deleted)' matches /proc/pid/exe and return
 186   // /proc/pid/exe in |path| so ELF identifier generation works correctly. This
 187   // also checks to see if '/path/to/program (deleted)' exists, so it does not
 188   // get fooled by a poorly named binary.
 189   // For programs that don't end with ' (deleted)', this is a no-op.
 190   // This assumes |path| is a buffer with length NAME_MAX.
 191   // Returns true if |path| is modified.
 192   bool HandleDeletedFileInMapping(char* path) const;
 193
 194    // ID of the crashed process.
 195   const pid_t pid_;
 196
 197   // Virtual address at which the process crashed.
 198   uintptr_t crash_address_;
 199
 200   // Signal that terminated the crashed process.
 201   int crash_signal_;
 202
 203   // ID of the crashed thread.
 204   pid_t crash_thread_;
 205
 206   mutable PageAllocator allocator_;
 207
 208   // IDs of all the threads.
 209   wasteful_vector<pid_t> threads_;
 210
 211   // Info from /proc/<pid>/maps.
 212   wasteful_vector<MappingInfo*> mappings_;
 213
 214   // Info from /proc/<pid>/auxv
 215   wasteful_vector<elf_aux_val_t> auxv_;
 216 };
 217
 218 }  // namespace google_breakpad
 219
 220 #endif  // CLIENT_LINUX_HANDLER_LINUX_DUMPER_H_