1 // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "build/build_config.h"
6 #include "base/debug_util.h"
7
8 #include <errno.h>
9 #include <fcntl.h>
10 #include <stdio.h>
11 #include <sys/stat.h>
12 #include <sys/sysctl.h>
13 #include <sys/types.h>
14 #include <unistd.h>
15
16 #if defined(__GLIBCXX__)
17 #include <cxxabi.h>
18 #endif
19
20 #include <iostream>
21 #include <string>
22
23 #if defined(OS_MACOSX)
24 #include <AvailabilityMacros.h>
25 #endif
26
27 #include "base/basictypes.h"
28 #include "base/compat_execinfo.h"
29 #include "base/eintr_wrapper.h"
30 #include "base/logging.h"
31 #include "base/safe_strerror_posix.h"
32 #include "base/scoped_ptr.h"
33 #include "base/string_piece.h"
34 #include "base/string_util.h"
35
36 #if defined(USE_SYMBOLIZE)
37 #include "base/third_party/symbolize/symbolize.h"
38 #endif
39
40 namespace {
41 // The prefix used for mangled symbols, per the Itanium C++ ABI:
42 // http://www.codesourcery.com/cxx-abi/abi.html#mangling
43 const char kMangledSymbolPrefix[] = "_Z";
44
45 // Characters that can be used for symbols, generated by Ruby:
46 // (('a'..'z').to_a+('A'..'Z').to_a+('0'..'9').to_a + ['_']).join
47 const char kSymbolCharacters[] =
48 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
49
50 // Demangles C++ symbols in the given text. Example:
51 //
52 // "sconsbuild/Debug/base_unittests(_ZN10StackTraceC1Ev+0x20) [0x817778c]"
53 // =>
54 // "sconsbuild/Debug/base_unittests(StackTrace::StackTrace()+0x20) [0x817778c]"
DemangleSymbols(std::string * text)55 void DemangleSymbols(std::string* text) {
56 #if defined(__GLIBCXX__)
57
58 std::string::size_type search_from = 0;
59 while (search_from < text->size()) {
60 // Look for the start of a mangled symbol, from search_from.
61 std::string::size_type mangled_start =
62 text->find(kMangledSymbolPrefix, search_from);
63 if (mangled_start == std::string::npos) {
64 break; // Mangled symbol not found.
65 }
66
67 // Look for the end of the mangled symbol.
68 std::string::size_type mangled_end =
69 text->find_first_not_of(kSymbolCharacters, mangled_start);
70 if (mangled_end == std::string::npos) {
71 mangled_end = text->size();
72 }
73 std::string mangled_symbol =
74 text->substr(mangled_start, mangled_end - mangled_start);
75
76 // Try to demangle the mangled symbol candidate.
77 int status = 0;
78 scoped_ptr_malloc<char> demangled_symbol(
79 abi::__cxa_demangle(mangled_symbol.c_str(), NULL, 0, &status));
80 if (status == 0) { // Demangling is successful.
81 // Remove the mangled symbol.
82 text->erase(mangled_start, mangled_end - mangled_start);
83 // Insert the demangled symbol.
84 text->insert(mangled_start, demangled_symbol.get());
85 // Next time, we'll start right after the demangled symbol we inserted.
86 search_from = mangled_start + strlen(demangled_symbol.get());
87 } else {
88 // Failed to demangle. Retry after the "_Z" we just found.
89 search_from = mangled_start + 2;
90 }
91 }
92
93 #endif // defined(__GLIBCXX__)
94 }
95
96 // Gets the backtrace as a vector of strings. If possible, resolve symbol
97 // names and attach these. Otherwise just use raw addresses. Returns true
98 // if any symbol name is resolved.
GetBacktraceStrings(void ** trace,int size,std::vector<std::string> * trace_strings)99 bool GetBacktraceStrings(void **trace, int size,
100 std::vector<std::string>* trace_strings) {
101 bool symbolized = false;
102
103 #if defined(USE_SYMBOLIZE)
104 for (int i = 0; i < size; ++i) {
105 char symbol[1024];
106 // Subtract by one as return address of function may be in the next
107 // function when a function is annotated as noreturn.
108 if (google::Symbolize(static_cast<char *>(trace[i]) - 1,
109 symbol, sizeof(symbol))) {
110 // Don't call DemangleSymbols() here as the symbol is demangled by
111 // google::Symbolize().
112 trace_strings->push_back(StringPrintf("%s [%p]", symbol, trace[i]));
113 symbolized = true;
114 } else {
115 trace_strings->push_back(StringPrintf("%p", trace[i]));
116 }
117 }
118 #else
119 scoped_ptr_malloc<char*> trace_symbols(backtrace_symbols(trace, size));
120 if (trace_symbols.get()) {
121 for (int i = 0; i < size; ++i) {
122 std::string trace_symbol = trace_symbols.get()[i];
123 DemangleSymbols(&trace_symbol);
124 trace_strings->push_back(trace_symbol);
125 }
126 symbolized = true;
127 } else {
128 for (int i = 0; i < size; ++i) {
129 trace_strings->push_back(StringPrintf("%p", trace[i]));
130 }
131 }
132 #endif // defined(USE_SYMBOLIZE)
133
134 return symbolized;
135 }
136
137 } // namespace
138
139 // static
SpawnDebuggerOnProcess(unsigned)140 bool DebugUtil::SpawnDebuggerOnProcess(unsigned /* process_id */) {
141 NOTIMPLEMENTED();
142 return false;
143 }
144
145 #if defined(OS_MACOSX)
146
147 // Based on Apple's recommended method as described in
148 // http://developer.apple.com/qa/qa2004/qa1361.html
149 // static
BeingDebugged()150 bool DebugUtil::BeingDebugged() {
151 // If the process is sandboxed then we can't use the sysctl, so cache the
152 // value.
153 static bool is_set = false;
154 static bool being_debugged = false;
155
156 if (is_set) {
157 return being_debugged;
158 }
159
160 // Initialize mib, which tells sysctl what info we want. In this case,
161 // we're looking for information about a specific process ID.
162 int mib[] = {
163 CTL_KERN,
164 KERN_PROC,
165 KERN_PROC_PID,
166 getpid()
167 };
168
169 // Caution: struct kinfo_proc is marked __APPLE_API_UNSTABLE. The source and
170 // binary interfaces may change.
171 struct kinfo_proc info;
172 size_t info_size = sizeof(info);
173
174 int sysctl_result = sysctl(mib, arraysize(mib), &info, &info_size, NULL, 0);
175 DCHECK(sysctl_result == 0);
176 if (sysctl_result != 0) {
177 is_set = true;
178 being_debugged = false;
179 return being_debugged;
180 }
181
182 // This process is being debugged if the P_TRACED flag is set.
183 is_set = true;
184 being_debugged = (info.kp_proc.p_flag & P_TRACED) != 0;
185 return being_debugged;
186 }
187
188 #elif defined(OS_LINUX)
189
190 // We can look in /proc/self/status for TracerPid. We are likely used in crash
191 // handling, so we are careful not to use the heap or have side effects.
192 // Another option that is common is to try to ptrace yourself, but then we
193 // can't detach without forking(), and that's not so great.
194 // static
BeingDebugged()195 bool DebugUtil::BeingDebugged() {
196 int status_fd = open("/proc/self/status", O_RDONLY);
197 if (status_fd == -1)
198 return false;
199
200 // We assume our line will be in the first 1024 characters and that we can
201 // read this much all at once. In practice this will generally be true.
202 // This simplifies and speeds up things considerably.
203 char buf[1024];
204
205 ssize_t num_read = HANDLE_EINTR(read(status_fd, buf, sizeof(buf)));
206 if (HANDLE_EINTR(close(status_fd)) < 0)
207 return false;
208
209 if (num_read <= 0)
210 return false;
211
212 base::StringPiece status(buf, num_read);
213 base::StringPiece tracer("TracerPid:\t");
214
215 base::StringPiece::size_type pid_index = status.find(tracer);
216 if (pid_index == base::StringPiece::npos)
217 return false;
218
219 // Our pid is 0 without a debugger, assume this for any pid starting with 0.
220 pid_index += tracer.size();
221 return pid_index < status.size() && status[pid_index] != '0';
222 }
223
224 #elif defined(OS_FREEBSD)
225
BeingDebugged()226 bool DebugUtil::BeingDebugged() {
227 // TODO(benl): can we determine this under FreeBSD?
228 NOTIMPLEMENTED();
229 return false;
230 }
231
232 #endif
233
234 // static
BreakDebugger()235 void DebugUtil::BreakDebugger() {
236 #if defined(ARCH_CPU_ARM_FAMILY)
237 asm("bkpt 0");
238 #else
239 asm("int3");
240 #endif
241 }
242
StackTrace()243 StackTrace::StackTrace() {
244 #if defined(OS_MACOSX) && MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
245 if (backtrace == NULL) {
246 count_ = 0;
247 return;
248 }
249 #endif
250 // Though the backtrace API man page does not list any possible negative
251 // return values, we take no chance.
252 count_ = std::max(backtrace(trace_, arraysize(trace_)), 0);
253 }
254
PrintBacktrace()255 void StackTrace::PrintBacktrace() {
256 #if defined(OS_MACOSX) && MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
257 if (backtrace_symbols_fd == NULL)
258 return;
259 #endif
260 fflush(stderr);
261 std::vector<std::string> trace_strings;
262 GetBacktraceStrings(trace_, count_, &trace_strings);
263 for (size_t i = 0; i < trace_strings.size(); ++i) {
264 std::cerr << "\t" << trace_strings[i] << "\n";
265 }
266 }
267
OutputToStream(std::ostream * os)268 void StackTrace::OutputToStream(std::ostream* os) {
269 #if defined(OS_MACOSX) && MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
270 if (backtrace_symbols == NULL)
271 return;
272 #endif
273 std::vector<std::string> trace_strings;
274 if (GetBacktraceStrings(trace_, count_, &trace_strings)) {
275 (*os) << "Backtrace:\n";
276 } else {
277 (*os) << "Unable get symbols for backtrace (" << safe_strerror(errno)
278 << "). Dumping raw addresses in trace:\n";
279 }
280
281 for (size_t i = 0; i < trace_strings.size(); ++i) {
282 (*os) << "\t" << trace_strings[i] << "\n";
283 }
284 }
285