1 // Copyright (c) 2012 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 "base/debug/stack_trace.h"
6
7 #include <errno.h>
8 #include <execinfo.h>
9 #include <fcntl.h>
10 #include <signal.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <sys/param.h>
14 #include <sys/stat.h>
15 #include <sys/types.h>
16 #include <unistd.h>
17
18 #include <ostream>
19
20 #if defined(__GLIBCXX__)
21 #include <cxxabi.h>
22 #endif
23
24 #if defined(OS_MACOSX)
25 #include <AvailabilityMacros.h>
26 #endif
27
28 #include "base/basictypes.h"
29 #include "base/debug/debugger.h"
30 #include "base/logging.h"
31 #include "base/memory/scoped_ptr.h"
32 #include "base/posix/eintr_wrapper.h"
33 #include "base/strings/string_number_conversions.h"
34
35 #if defined(USE_SYMBOLIZE)
36 #include "base/third_party/symbolize/symbolize.h"
37 #endif
38
39 namespace base {
40 namespace debug {
41
42 namespace {
43
44 volatile sig_atomic_t in_signal_handler = 0;
45
46 #if !defined(USE_SYMBOLIZE) && defined(__GLIBCXX__)
47 // The prefix used for mangled symbols, per the Itanium C++ ABI:
48 // http://www.codesourcery.com/cxx-abi/abi.html#mangling
49 const char kMangledSymbolPrefix[] = "_Z";
50
51 // Characters that can be used for symbols, generated by Ruby:
52 // (('a'..'z').to_a+('A'..'Z').to_a+('0'..'9').to_a + ['_']).join
53 const char kSymbolCharacters[] =
54 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
55 #endif // !defined(USE_SYMBOLIZE) && defined(__GLIBCXX__)
56
57 #if !defined(USE_SYMBOLIZE)
58 // Demangles C++ symbols in the given text. Example:
59 //
60 // "out/Debug/base_unittests(_ZN10StackTraceC1Ev+0x20) [0x817778c]"
61 // =>
62 // "out/Debug/base_unittests(StackTrace::StackTrace()+0x20) [0x817778c]"
DemangleSymbols(std::string * text)63 void DemangleSymbols(std::string* text) {
64 // Note: code in this function is NOT async-signal safe (std::string uses
65 // malloc internally).
66
67 #if defined(__GLIBCXX__)
68
69 std::string::size_type search_from = 0;
70 while (search_from < text->size()) {
71 // Look for the start of a mangled symbol, from search_from.
72 std::string::size_type mangled_start =
73 text->find(kMangledSymbolPrefix, search_from);
74 if (mangled_start == std::string::npos) {
75 break; // Mangled symbol not found.
76 }
77
78 // Look for the end of the mangled symbol.
79 std::string::size_type mangled_end =
80 text->find_first_not_of(kSymbolCharacters, mangled_start);
81 if (mangled_end == std::string::npos) {
82 mangled_end = text->size();
83 }
84 std::string mangled_symbol =
85 text->substr(mangled_start, mangled_end - mangled_start);
86
87 // Try to demangle the mangled symbol candidate.
88 int status = 0;
89 scoped_ptr_malloc<char> demangled_symbol(
90 abi::__cxa_demangle(mangled_symbol.c_str(), NULL, 0, &status));
91 if (status == 0) { // Demangling is successful.
92 // Remove the mangled symbol.
93 text->erase(mangled_start, mangled_end - mangled_start);
94 // Insert the demangled symbol.
95 text->insert(mangled_start, demangled_symbol.get());
96 // Next time, we'll start right after the demangled symbol we inserted.
97 search_from = mangled_start + strlen(demangled_symbol.get());
98 } else {
99 // Failed to demangle. Retry after the "_Z" we just found.
100 search_from = mangled_start + 2;
101 }
102 }
103
104 #endif // defined(__GLIBCXX__)
105 }
106 #endif // !defined(USE_SYMBOLIZE)
107
108 class BacktraceOutputHandler {
109 public:
110 virtual void HandleOutput(const char* output) = 0;
111
112 protected:
~BacktraceOutputHandler()113 virtual ~BacktraceOutputHandler() {}
114 };
115
OutputPointer(void * pointer,BacktraceOutputHandler * handler)116 void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
117 char buf[1024] = { '\0' };
118 handler->HandleOutput(" [0x");
119 internal::itoa_r(reinterpret_cast<intptr_t>(pointer),
120 buf, sizeof(buf), 16, 12);
121 handler->HandleOutput(buf);
122 handler->HandleOutput("]");
123 }
124
ProcessBacktrace(void * const * trace,int size,BacktraceOutputHandler * handler)125 void ProcessBacktrace(void *const *trace,
126 int size,
127 BacktraceOutputHandler* handler) {
128 // NOTE: This code MUST be async-signal safe (it's used by in-process
129 // stack dumping signal handler). NO malloc or stdio is allowed here.
130
131 #if defined(USE_SYMBOLIZE)
132 for (int i = 0; i < size; ++i) {
133 OutputPointer(trace[i], handler);
134 handler->HandleOutput(" ");
135
136 char buf[1024] = { '\0' };
137
138 // Subtract by one as return address of function may be in the next
139 // function when a function is annotated as noreturn.
140 void* address = static_cast<char*>(trace[i]) - 1;
141 if (google::Symbolize(address, buf, sizeof(buf)))
142 handler->HandleOutput(buf);
143 else
144 handler->HandleOutput("<unknown>");
145
146 handler->HandleOutput("\n");
147 }
148 #else
149 bool printed = false;
150
151 // Below part is async-signal unsafe (uses malloc), so execute it only
152 // when we are not executing the signal handler.
153 if (in_signal_handler == 0) {
154 scoped_ptr_malloc<char*> trace_symbols(backtrace_symbols(trace, size));
155 if (trace_symbols.get()) {
156 for (int i = 0; i < size; ++i) {
157 std::string trace_symbol = trace_symbols.get()[i];
158 DemangleSymbols(&trace_symbol);
159 handler->HandleOutput(trace_symbol.c_str());
160 handler->HandleOutput("\n");
161 }
162
163 printed = true;
164 }
165 }
166
167 if (!printed) {
168 for (int i = 0; i < size; ++i) {
169 OutputPointer(trace[i], handler);
170 handler->HandleOutput("\n");
171 }
172 }
173 #endif // defined(USE_SYMBOLIZE)
174 }
175
PrintToStderr(const char * output)176 void PrintToStderr(const char* output) {
177 // NOTE: This code MUST be async-signal safe (it's used by in-process
178 // stack dumping signal handler). NO malloc or stdio is allowed here.
179 ignore_result(HANDLE_EINTR(write(STDERR_FILENO, output, strlen(output))));
180 }
181
182 #if !defined(OS_IOS)
StackDumpSignalHandler(int signal,siginfo_t * info,void * void_context)183 void StackDumpSignalHandler(int signal, siginfo_t* info, void* void_context) {
184 // NOTE: This code MUST be async-signal safe.
185 // NO malloc or stdio is allowed here.
186
187 // Record the fact that we are in the signal handler now, so that the rest
188 // of StackTrace can behave in an async-signal-safe manner.
189 in_signal_handler = 1;
190
191 if (BeingDebugged())
192 BreakDebugger();
193
194 PrintToStderr("Received signal ");
195 char buf[1024] = { 0 };
196 internal::itoa_r(signal, buf, sizeof(buf), 10, 0);
197 PrintToStderr(buf);
198 if (signal == SIGBUS) {
199 if (info->si_code == BUS_ADRALN)
200 PrintToStderr(" BUS_ADRALN ");
201 else if (info->si_code == BUS_ADRERR)
202 PrintToStderr(" BUS_ADRERR ");
203 else if (info->si_code == BUS_OBJERR)
204 PrintToStderr(" BUS_OBJERR ");
205 else
206 PrintToStderr(" <unknown> ");
207 } else if (signal == SIGFPE) {
208 if (info->si_code == FPE_FLTDIV)
209 PrintToStderr(" FPE_FLTDIV ");
210 else if (info->si_code == FPE_FLTINV)
211 PrintToStderr(" FPE_FLTINV ");
212 else if (info->si_code == FPE_FLTOVF)
213 PrintToStderr(" FPE_FLTOVF ");
214 else if (info->si_code == FPE_FLTRES)
215 PrintToStderr(" FPE_FLTRES ");
216 else if (info->si_code == FPE_FLTSUB)
217 PrintToStderr(" FPE_FLTSUB ");
218 else if (info->si_code == FPE_FLTUND)
219 PrintToStderr(" FPE_FLTUND ");
220 else if (info->si_code == FPE_INTDIV)
221 PrintToStderr(" FPE_INTDIV ");
222 else if (info->si_code == FPE_INTOVF)
223 PrintToStderr(" FPE_INTOVF ");
224 else
225 PrintToStderr(" <unknown> ");
226 } else if (signal == SIGILL) {
227 if (info->si_code == ILL_BADSTK)
228 PrintToStderr(" ILL_BADSTK ");
229 else if (info->si_code == ILL_COPROC)
230 PrintToStderr(" ILL_COPROC ");
231 else if (info->si_code == ILL_ILLOPN)
232 PrintToStderr(" ILL_ILLOPN ");
233 else if (info->si_code == ILL_ILLADR)
234 PrintToStderr(" ILL_ILLADR ");
235 else if (info->si_code == ILL_ILLTRP)
236 PrintToStderr(" ILL_ILLTRP ");
237 else if (info->si_code == ILL_PRVOPC)
238 PrintToStderr(" ILL_PRVOPC ");
239 else if (info->si_code == ILL_PRVREG)
240 PrintToStderr(" ILL_PRVREG ");
241 else
242 PrintToStderr(" <unknown> ");
243 } else if (signal == SIGSEGV) {
244 if (info->si_code == SEGV_MAPERR)
245 PrintToStderr(" SEGV_MAPERR ");
246 else if (info->si_code == SEGV_ACCERR)
247 PrintToStderr(" SEGV_ACCERR ");
248 else
249 PrintToStderr(" <unknown> ");
250 }
251 if (signal == SIGBUS || signal == SIGFPE ||
252 signal == SIGILL || signal == SIGSEGV) {
253 internal::itoa_r(reinterpret_cast<intptr_t>(info->si_addr),
254 buf, sizeof(buf), 16, 12);
255 PrintToStderr(buf);
256 }
257 PrintToStderr("\n");
258
259 debug::StackTrace().Print();
260
261 #if defined(OS_LINUX)
262 #if ARCH_CPU_X86_FAMILY
263 ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
264 const struct {
265 const char* label;
266 greg_t value;
267 } registers[] = {
268 #if ARCH_CPU_32_BITS
269 { " gs: ", context->uc_mcontext.gregs[REG_GS] },
270 { " fs: ", context->uc_mcontext.gregs[REG_FS] },
271 { " es: ", context->uc_mcontext.gregs[REG_ES] },
272 { " ds: ", context->uc_mcontext.gregs[REG_DS] },
273 { " edi: ", context->uc_mcontext.gregs[REG_EDI] },
274 { " esi: ", context->uc_mcontext.gregs[REG_ESI] },
275 { " ebp: ", context->uc_mcontext.gregs[REG_EBP] },
276 { " esp: ", context->uc_mcontext.gregs[REG_ESP] },
277 { " ebx: ", context->uc_mcontext.gregs[REG_EBX] },
278 { " edx: ", context->uc_mcontext.gregs[REG_EDX] },
279 { " ecx: ", context->uc_mcontext.gregs[REG_ECX] },
280 { " eax: ", context->uc_mcontext.gregs[REG_EAX] },
281 { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
282 { " err: ", context->uc_mcontext.gregs[REG_ERR] },
283 { " ip: ", context->uc_mcontext.gregs[REG_EIP] },
284 { " cs: ", context->uc_mcontext.gregs[REG_CS] },
285 { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
286 { " usp: ", context->uc_mcontext.gregs[REG_UESP] },
287 { " ss: ", context->uc_mcontext.gregs[REG_SS] },
288 #elif ARCH_CPU_64_BITS
289 { " r8: ", context->uc_mcontext.gregs[REG_R8] },
290 { " r9: ", context->uc_mcontext.gregs[REG_R9] },
291 { " r10: ", context->uc_mcontext.gregs[REG_R10] },
292 { " r11: ", context->uc_mcontext.gregs[REG_R11] },
293 { " r12: ", context->uc_mcontext.gregs[REG_R12] },
294 { " r13: ", context->uc_mcontext.gregs[REG_R13] },
295 { " r14: ", context->uc_mcontext.gregs[REG_R14] },
296 { " r15: ", context->uc_mcontext.gregs[REG_R15] },
297 { " di: ", context->uc_mcontext.gregs[REG_RDI] },
298 { " si: ", context->uc_mcontext.gregs[REG_RSI] },
299 { " bp: ", context->uc_mcontext.gregs[REG_RBP] },
300 { " bx: ", context->uc_mcontext.gregs[REG_RBX] },
301 { " dx: ", context->uc_mcontext.gregs[REG_RDX] },
302 { " ax: ", context->uc_mcontext.gregs[REG_RAX] },
303 { " cx: ", context->uc_mcontext.gregs[REG_RCX] },
304 { " sp: ", context->uc_mcontext.gregs[REG_RSP] },
305 { " ip: ", context->uc_mcontext.gregs[REG_RIP] },
306 { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
307 { " cgf: ", context->uc_mcontext.gregs[REG_CSGSFS] },
308 { " erf: ", context->uc_mcontext.gregs[REG_ERR] },
309 { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
310 { " msk: ", context->uc_mcontext.gregs[REG_OLDMASK] },
311 { " cr2: ", context->uc_mcontext.gregs[REG_CR2] },
312 #endif
313 };
314
315 #if ARCH_CPU_32_BITS
316 const int kRegisterPadding = 8;
317 #elif ARCH_CPU_64_BITS
318 const int kRegisterPadding = 16;
319 #endif
320
321 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(registers); i++) {
322 PrintToStderr(registers[i].label);
323 internal::itoa_r(registers[i].value, buf, sizeof(buf),
324 16, kRegisterPadding);
325 PrintToStderr(buf);
326
327 if ((i + 1) % 4 == 0)
328 PrintToStderr("\n");
329 }
330 PrintToStderr("\n");
331 #endif
332 #elif defined(OS_MACOSX)
333 // TODO(shess): Port to 64-bit.
334 #if ARCH_CPU_X86_FAMILY && ARCH_CPU_32_BITS
335 ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
336 size_t len;
337
338 // NOTE: Even |snprintf()| is not on the approved list for signal
339 // handlers, but buffered I/O is definitely not on the list due to
340 // potential for |malloc()|.
341 len = static_cast<size_t>(
342 snprintf(buf, sizeof(buf),
343 "ax: %x, bx: %x, cx: %x, dx: %x\n",
344 context->uc_mcontext->__ss.__eax,
345 context->uc_mcontext->__ss.__ebx,
346 context->uc_mcontext->__ss.__ecx,
347 context->uc_mcontext->__ss.__edx));
348 write(STDERR_FILENO, buf, std::min(len, sizeof(buf) - 1));
349
350 len = static_cast<size_t>(
351 snprintf(buf, sizeof(buf),
352 "di: %x, si: %x, bp: %x, sp: %x, ss: %x, flags: %x\n",
353 context->uc_mcontext->__ss.__edi,
354 context->uc_mcontext->__ss.__esi,
355 context->uc_mcontext->__ss.__ebp,
356 context->uc_mcontext->__ss.__esp,
357 context->uc_mcontext->__ss.__ss,
358 context->uc_mcontext->__ss.__eflags));
359 write(STDERR_FILENO, buf, std::min(len, sizeof(buf) - 1));
360
361 len = static_cast<size_t>(
362 snprintf(buf, sizeof(buf),
363 "ip: %x, cs: %x, ds: %x, es: %x, fs: %x, gs: %x\n",
364 context->uc_mcontext->__ss.__eip,
365 context->uc_mcontext->__ss.__cs,
366 context->uc_mcontext->__ss.__ds,
367 context->uc_mcontext->__ss.__es,
368 context->uc_mcontext->__ss.__fs,
369 context->uc_mcontext->__ss.__gs));
370 write(STDERR_FILENO, buf, std::min(len, sizeof(buf) - 1));
371 #endif // ARCH_CPU_32_BITS
372 #endif // defined(OS_MACOSX)
373 _exit(1);
374 }
375 #endif // !defined(OS_IOS)
376
377 class PrintBacktraceOutputHandler : public BacktraceOutputHandler {
378 public:
PrintBacktraceOutputHandler()379 PrintBacktraceOutputHandler() {}
380
HandleOutput(const char * output)381 virtual void HandleOutput(const char* output) OVERRIDE {
382 // NOTE: This code MUST be async-signal safe (it's used by in-process
383 // stack dumping signal handler). NO malloc or stdio is allowed here.
384 PrintToStderr(output);
385 }
386
387 private:
388 DISALLOW_COPY_AND_ASSIGN(PrintBacktraceOutputHandler);
389 };
390
391 class StreamBacktraceOutputHandler : public BacktraceOutputHandler {
392 public:
StreamBacktraceOutputHandler(std::ostream * os)393 explicit StreamBacktraceOutputHandler(std::ostream* os) : os_(os) {
394 }
395
HandleOutput(const char * output)396 virtual void HandleOutput(const char* output) OVERRIDE {
397 (*os_) << output;
398 }
399
400 private:
401 std::ostream* os_;
402
403 DISALLOW_COPY_AND_ASSIGN(StreamBacktraceOutputHandler);
404 };
405
406 #if !defined(OS_IOS)
WarmUpBacktrace()407 void WarmUpBacktrace() {
408 // Warm up stack trace infrastructure. It turns out that on the first
409 // call glibc initializes some internal data structures using pthread_once,
410 // and even backtrace() can call malloc(), leading to hangs.
411 //
412 // Example stack trace snippet (with tcmalloc):
413 //
414 // #8 0x0000000000a173b5 in tc_malloc
415 // at ./third_party/tcmalloc/chromium/src/debugallocation.cc:1161
416 // #9 0x00007ffff7de7900 in _dl_map_object_deps at dl-deps.c:517
417 // #10 0x00007ffff7ded8a9 in dl_open_worker at dl-open.c:262
418 // #11 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
419 // #12 0x00007ffff7ded31a in _dl_open (file=0x7ffff625e298 "libgcc_s.so.1")
420 // at dl-open.c:639
421 // #13 0x00007ffff6215602 in do_dlopen at dl-libc.c:89
422 // #14 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
423 // #15 0x00007ffff62156c4 in dlerror_run at dl-libc.c:48
424 // #16 __GI___libc_dlopen_mode at dl-libc.c:165
425 // #17 0x00007ffff61ef8f5 in init
426 // at ../sysdeps/x86_64/../ia64/backtrace.c:53
427 // #18 0x00007ffff6aad400 in pthread_once
428 // at ../nptl/sysdeps/unix/sysv/linux/x86_64/pthread_once.S:104
429 // #19 0x00007ffff61efa14 in __GI___backtrace
430 // at ../sysdeps/x86_64/../ia64/backtrace.c:104
431 // #20 0x0000000000752a54 in base::debug::StackTrace::StackTrace
432 // at base/debug/stack_trace_posix.cc:175
433 // #21 0x00000000007a4ae5 in
434 // base::(anonymous namespace)::StackDumpSignalHandler
435 // at base/process_util_posix.cc:172
436 // #22 <signal handler called>
437 StackTrace stack_trace;
438 }
439 #endif // !defined(OS_IOS)
440
441 } // namespace
442
443 #if !defined(OS_IOS)
EnableInProcessStackDumping()444 bool EnableInProcessStackDumping() {
445 // When running in an application, our code typically expects SIGPIPE
446 // to be ignored. Therefore, when testing that same code, it should run
447 // with SIGPIPE ignored as well.
448 struct sigaction sigpipe_action;
449 memset(&sigpipe_action, 0, sizeof(sigpipe_action));
450 sigpipe_action.sa_handler = SIG_IGN;
451 sigemptyset(&sigpipe_action.sa_mask);
452 bool success = (sigaction(SIGPIPE, &sigpipe_action, NULL) == 0);
453
454 // Avoid hangs during backtrace initialization, see above.
455 WarmUpBacktrace();
456
457 struct sigaction action;
458 memset(&action, 0, sizeof(action));
459 action.sa_flags = SA_RESETHAND | SA_SIGINFO;
460 action.sa_sigaction = &StackDumpSignalHandler;
461 sigemptyset(&action.sa_mask);
462
463 success &= (sigaction(SIGILL, &action, NULL) == 0);
464 success &= (sigaction(SIGABRT, &action, NULL) == 0);
465 success &= (sigaction(SIGFPE, &action, NULL) == 0);
466 success &= (sigaction(SIGBUS, &action, NULL) == 0);
467 success &= (sigaction(SIGSEGV, &action, NULL) == 0);
468 success &= (sigaction(SIGSYS, &action, NULL) == 0);
469
470 return success;
471 }
472 #endif // !defined(OS_IOS)
473
StackTrace()474 StackTrace::StackTrace() {
475 // NOTE: This code MUST be async-signal safe (it's used by in-process
476 // stack dumping signal handler). NO malloc or stdio is allowed here.
477
478 // Though the backtrace API man page does not list any possible negative
479 // return values, we take no chance.
480 count_ = std::max(backtrace(trace_, arraysize(trace_)), 0);
481 }
482
Print() const483 void StackTrace::Print() const {
484 // NOTE: This code MUST be async-signal safe (it's used by in-process
485 // stack dumping signal handler). NO malloc or stdio is allowed here.
486
487 PrintBacktraceOutputHandler handler;
488 ProcessBacktrace(trace_, count_, &handler);
489 }
490
OutputToStream(std::ostream * os) const491 void StackTrace::OutputToStream(std::ostream* os) const {
492 StreamBacktraceOutputHandler handler(os);
493 ProcessBacktrace(trace_, count_, &handler);
494 }
495
496 namespace internal {
497
498 // NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
itoa_r(intptr_t i,char * buf,size_t sz,int base,size_t padding)499 char *itoa_r(intptr_t i, char *buf, size_t sz, int base, size_t padding) {
500 // Make sure we can write at least one NUL byte.
501 size_t n = 1;
502 if (n > sz)
503 return NULL;
504
505 if (base < 2 || base > 16) {
506 buf[0] = '\000';
507 return NULL;
508 }
509
510 char *start = buf;
511
512 uintptr_t j = i;
513
514 // Handle negative numbers (only for base 10).
515 if (i < 0 && base == 10) {
516 j = -i;
517
518 // Make sure we can write the '-' character.
519 if (++n > sz) {
520 buf[0] = '\000';
521 return NULL;
522 }
523 *start++ = '-';
524 }
525
526 // Loop until we have converted the entire number. Output at least one
527 // character (i.e. '0').
528 char *ptr = start;
529 do {
530 // Make sure there is still enough space left in our output buffer.
531 if (++n > sz) {
532 buf[0] = '\000';
533 return NULL;
534 }
535
536 // Output the next digit.
537 *ptr++ = "0123456789abcdef"[j % base];
538 j /= base;
539
540 if (padding > 0)
541 padding--;
542 } while (j > 0 || padding > 0);
543
544 // Terminate the output with a NUL character.
545 *ptr = '\000';
546
547 // Conversion to ASCII actually resulted in the digits being in reverse
548 // order. We can't easily generate them in forward order, as we can't tell
549 // the number of characters needed until we are done converting.
550 // So, now, we reverse the string (except for the possible "-" sign).
551 while (--ptr > start) {
552 char ch = *ptr;
553 *ptr = *start;
554 *start++ = ch;
555 }
556 return buf;
557 }
558
559 } // namespace internal
560
561 } // namespace debug
562 } // namespace base
563