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 "client/linux/dump_writer_common/mapping_info.h"
48#include "client/linux/dump_writer_common/thread_info.h"
49#include "common/memory.h"
50#include "google_breakpad/common/minidump_format.h"
51
52namespace google_breakpad {
53
54// Typedef for our parsing of the auxv variables in /proc/pid/auxv.
55#if defined(__i386) || defined(__ARM_EABI__) || \
56 (defined(__mips__) && _MIPS_SIM == _ABIO32)
57typedef Elf32_auxv_t elf_aux_entry;
58#elif defined(__x86_64) || defined(__aarch64__) || \
59     (defined(__mips__) && _MIPS_SIM != _ABIO32)
60typedef Elf64_auxv_t elf_aux_entry;
61#endif
62
63typedef __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!
68const char kLinuxGateLibraryName[] = "linux-gate.so";
69
70class LinuxDumper {
71 public:
72  explicit LinuxDumper(pid_t pid);
73
74  virtual ~LinuxDumper();
75
76  // Parse the data for |threads| and |mappings|.
77  virtual bool Init();
78
79  // Return true if the dumper performs a post-mortem dump.
80  virtual bool IsPostMortem() const = 0;
81
82  // Suspend/resume all threads in the given process.
83  virtual bool ThreadsSuspend() = 0;
84  virtual bool ThreadsResume() = 0;
85
86  // Read information about the |index|-th thread of |threads_|.
87  // Returns true on success. One must have called |ThreadsSuspend| first.
88  virtual bool GetThreadInfoByIndex(size_t index, ThreadInfo* info) = 0;
89
90  // These are only valid after a call to |Init|.
91  const wasteful_vector<pid_t> &threads() { return threads_; }
92  const wasteful_vector<MappingInfo*> &mappings() { return mappings_; }
93  const MappingInfo* FindMapping(const void* address) const;
94  const wasteful_vector<elf_aux_val_t>& auxv() { return auxv_; }
95
96  // Find a block of memory to take as the stack given the top of stack pointer.
97  //   stack: (output) the lowest address in the memory area
98  //   stack_len: (output) the length of the memory area
99  //   stack_top: the current top of the stack
100  bool GetStackInfo(const void** stack, size_t* stack_len, uintptr_t stack_top);
101
102  PageAllocator* allocator() { return &allocator_; }
103
104  // Copy content of |length| bytes from a given process |child|,
105  // starting from |src|, into |dest|. Returns true on success.
106  virtual bool CopyFromProcess(void* dest, pid_t child, const void* src,
107                               size_t length) = 0;
108
109  // Builds a proc path for a certain pid for a node (/proc/<pid>/<node>).
110  // |path| is a character array of at least NAME_MAX bytes to return the
111  // result.|node| is the final node without any slashes. Returns true on
112  // success.
113  virtual bool BuildProcPath(char* path, pid_t pid, const char* node) const = 0;
114
115  // Generate a File ID from the .text section of a mapped entry.
116  // If not a member, mapping_id is ignored. This method can also manipulate the
117  // |mapping|.name to truncate "(deleted)" from the file name if necessary.
118  bool ElfFileIdentifierForMapping(const MappingInfo& mapping,
119                                   bool member,
120                                   unsigned int mapping_id,
121                                   uint8_t identifier[sizeof(MDGUID)]);
122
123  uintptr_t crash_address() const { return crash_address_; }
124  void set_crash_address(uintptr_t crash_address) {
125    crash_address_ = crash_address;
126  }
127
128  int crash_signal() const { return crash_signal_; }
129  void set_crash_signal(int crash_signal) { crash_signal_ = crash_signal; }
130
131  pid_t crash_thread() const { return crash_thread_; }
132  void set_crash_thread(pid_t crash_thread) { crash_thread_ = crash_thread; }
133
134  // Extracts the effective path and file name of from |mapping|. In most cases
135  // the effective name/path are just the mapping's path and basename. In some
136  // other cases, however, a library can be mapped from an archive (e.g., when
137  // loading .so libs from an apk on Android) and this method is able to
138  // reconstruct the original file name.
139  static void GetMappingEffectiveNameAndPath(const MappingInfo& mapping,
140                                             char* file_path,
141                                             size_t file_path_size,
142                                             char* file_name,
143                                             size_t file_name_size);
144
145 protected:
146  bool ReadAuxv();
147
148  virtual bool EnumerateMappings();
149
150  virtual bool EnumerateThreads() = 0;
151
152  // For the case where a running program has been deleted, it'll show up in
153  // /proc/pid/maps as "/path/to/program (deleted)". If this is the case, then
154  // see if '/path/to/program (deleted)' matches /proc/pid/exe and return
155  // /proc/pid/exe in |path| so ELF identifier generation works correctly. This
156  // also checks to see if '/path/to/program (deleted)' exists, so it does not
157  // get fooled by a poorly named binary.
158  // For programs that don't end with ' (deleted)', this is a no-op.
159  // This assumes |path| is a buffer with length NAME_MAX.
160  // Returns true if |path| is modified.
161  bool HandleDeletedFileInMapping(char* path) const;
162
163   // ID of the crashed process.
164  const pid_t pid_;
165
166  // Virtual address at which the process crashed.
167  uintptr_t crash_address_;
168
169  // Signal that terminated the crashed process.
170  int crash_signal_;
171
172  // ID of the crashed thread.
173  pid_t crash_thread_;
174
175  mutable PageAllocator allocator_;
176
177  // IDs of all the threads.
178  wasteful_vector<pid_t> threads_;
179
180  // Info from /proc/<pid>/maps.
181  wasteful_vector<MappingInfo*> mappings_;
182
183  // Info from /proc/<pid>/auxv
184  wasteful_vector<elf_aux_val_t> auxv_;
185};
186
187}  // namespace google_breakpad
188
189#endif  // CLIENT_LINUX_HANDLER_LINUX_DUMPER_H_
190