272 lines
9.3 KiB
C++
272 lines
9.3 KiB
C++
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
|
||
|
|
// Use of this source code is governed by a BSD-style license that can be
|
||
|
|
// found in the LICENSE file.
|
||
|
|
|
||
|
|
#include "base/debug/stack_trace.h"
|
||
|
|
|
||
|
|
#include <windows.h>
|
||
|
|
#include <dbghelp.h>
|
||
|
|
|
||
|
|
#include <iostream>
|
||
|
|
|
||
|
|
#include "base/basictypes.h"
|
||
|
|
#include "base/logging.h"
|
||
|
|
#include "base/memory/singleton.h"
|
||
|
|
#include "base/path_service.h"
|
||
|
|
#include "base/process/launch.h"
|
||
|
|
#include "base/strings/string_util.h"
|
||
|
|
#include "base/synchronization/lock.h"
|
||
|
|
#include "base/win/windows_version.h"
|
||
|
|
|
||
|
|
namespace base {
|
||
|
|
namespace debug {
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
// Previous unhandled filter. Will be called if not NULL when we intercept an
|
||
|
|
// exception. Only used in unit tests.
|
||
|
|
LPTOP_LEVEL_EXCEPTION_FILTER g_previous_filter = NULL;
|
||
|
|
|
||
|
|
// Prints the exception call stack.
|
||
|
|
// This is the unit tests exception filter.
|
||
|
|
long WINAPI StackDumpExceptionFilter(EXCEPTION_POINTERS* info) {
|
||
|
|
debug::StackTrace(info).PrintBacktrace();
|
||
|
|
if (g_previous_filter)
|
||
|
|
return g_previous_filter(info);
|
||
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
||
|
|
}
|
||
|
|
|
||
|
|
// SymbolContext is a threadsafe singleton that wraps the DbgHelp Sym* family
|
||
|
|
// of functions. The Sym* family of functions may only be invoked by one
|
||
|
|
// thread at a time. SymbolContext code may access a symbol server over the
|
||
|
|
// network while holding the lock for this singleton. In the case of high
|
||
|
|
// latency, this code will adversely affect performance.
|
||
|
|
//
|
||
|
|
// There is also a known issue where this backtrace code can interact
|
||
|
|
// badly with breakpad if breakpad is invoked in a separate thread while
|
||
|
|
// we are using the Sym* functions. This is because breakpad does now
|
||
|
|
// share a lock with this function. See this related bug:
|
||
|
|
//
|
||
|
|
// http://code.google.com/p/google-breakpad/issues/detail?id=311
|
||
|
|
//
|
||
|
|
// This is a very unlikely edge case, and the current solution is to
|
||
|
|
// just ignore it.
|
||
|
|
class SymbolContext {
|
||
|
|
public:
|
||
|
|
static SymbolContext* GetInstance() {
|
||
|
|
// We use a leaky singleton because code may call this during process
|
||
|
|
// termination.
|
||
|
|
return
|
||
|
|
Singleton<SymbolContext, LeakySingletonTraits<SymbolContext> >::get();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns the error code of a failed initialization.
|
||
|
|
DWORD init_error() const {
|
||
|
|
return init_error_;
|
||
|
|
}
|
||
|
|
|
||
|
|
// For the given trace, attempts to resolve the symbols, and output a trace
|
||
|
|
// to the ostream os. The format for each line of the backtrace is:
|
||
|
|
//
|
||
|
|
// <tab>SymbolName[0xAddress+Offset] (FileName:LineNo)
|
||
|
|
//
|
||
|
|
// This function should only be called if Init() has been called. We do not
|
||
|
|
// LOG(FATAL) here because this code is called might be triggered by a
|
||
|
|
// LOG(FATAL) itself.
|
||
|
|
void OutputTraceToStream(const void* const* trace,
|
||
|
|
size_t count,
|
||
|
|
std::ostream* os) {
|
||
|
|
base::AutoLock lock(lock_);
|
||
|
|
|
||
|
|
for (size_t i = 0; (i < count) && os->good(); ++i) {
|
||
|
|
const int kMaxNameLength = 256;
|
||
|
|
DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(trace[i]);
|
||
|
|
|
||
|
|
// Code adapted from MSDN example:
|
||
|
|
// http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx
|
||
|
|
ULONG64 buffer[
|
||
|
|
(sizeof(SYMBOL_INFO) +
|
||
|
|
kMaxNameLength * sizeof(wchar_t) +
|
||
|
|
sizeof(ULONG64) - 1) /
|
||
|
|
sizeof(ULONG64)];
|
||
|
|
memset(buffer, 0, sizeof(buffer));
|
||
|
|
|
||
|
|
// Initialize symbol information retrieval structures.
|
||
|
|
DWORD64 sym_displacement = 0;
|
||
|
|
PSYMBOL_INFO symbol = reinterpret_cast<PSYMBOL_INFO>(&buffer[0]);
|
||
|
|
symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
|
||
|
|
symbol->MaxNameLen = kMaxNameLength - 1;
|
||
|
|
BOOL has_symbol = SymFromAddr(GetCurrentProcess(), frame,
|
||
|
|
&sym_displacement, symbol);
|
||
|
|
|
||
|
|
// Attempt to retrieve line number information.
|
||
|
|
DWORD line_displacement = 0;
|
||
|
|
IMAGEHLP_LINE64 line = {};
|
||
|
|
line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
|
||
|
|
BOOL has_line = SymGetLineFromAddr64(GetCurrentProcess(), frame,
|
||
|
|
&line_displacement, &line);
|
||
|
|
|
||
|
|
// Output the backtrace line.
|
||
|
|
(*os) << "\t";
|
||
|
|
if (has_symbol) {
|
||
|
|
(*os) << symbol->Name << " [0x" << trace[i] << "+"
|
||
|
|
<< sym_displacement << "]";
|
||
|
|
} else {
|
||
|
|
// If there is no symbol information, add a spacer.
|
||
|
|
(*os) << "(No symbol) [0x" << trace[i] << "]";
|
||
|
|
}
|
||
|
|
if (has_line) {
|
||
|
|
(*os) << " (" << line.FileName << ":" << line.LineNumber << ")";
|
||
|
|
}
|
||
|
|
(*os) << "\n";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
friend struct DefaultSingletonTraits<SymbolContext>;
|
||
|
|
|
||
|
|
SymbolContext() : init_error_(ERROR_SUCCESS) {
|
||
|
|
// Initializes the symbols for the process.
|
||
|
|
// Defer symbol load until they're needed, use undecorated names, and
|
||
|
|
// get line numbers.
|
||
|
|
SymSetOptions(SYMOPT_DEFERRED_LOADS |
|
||
|
|
SYMOPT_UNDNAME |
|
||
|
|
SYMOPT_LOAD_LINES);
|
||
|
|
if (!SymInitialize(GetCurrentProcess(), NULL, TRUE)) {
|
||
|
|
init_error_ = GetLastError();
|
||
|
|
// TODO(awong): Handle error: SymInitialize can fail with
|
||
|
|
// ERROR_INVALID_PARAMETER.
|
||
|
|
// When it fails, we should not call debugbreak since it kills the current
|
||
|
|
// process (prevents future tests from running or kills the browser
|
||
|
|
// process).
|
||
|
|
DLOG(ERROR) << "SymInitialize failed: " << init_error_;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
init_error_ = ERROR_SUCCESS;
|
||
|
|
|
||
|
|
// Work around a mysterious hang on Windows XP.
|
||
|
|
if (base::win::GetVersion() < base::win::VERSION_VISTA)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// When transferring the binaries e.g. between bots, path put
|
||
|
|
// into the executable will get off. To still retrieve symbols correctly,
|
||
|
|
// add the directory of the executable to symbol search path.
|
||
|
|
// All following errors are non-fatal.
|
||
|
|
wchar_t symbols_path[1024];
|
||
|
|
|
||
|
|
// Note: The below function takes buffer size as number of characters,
|
||
|
|
// not number of bytes!
|
||
|
|
if (!SymGetSearchPathW(GetCurrentProcess(),
|
||
|
|
symbols_path,
|
||
|
|
arraysize(symbols_path))) {
|
||
|
|
DLOG(WARNING) << "SymGetSearchPath failed: ";
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
FilePath module_path;
|
||
|
|
if (!PathService::Get(FILE_EXE, &module_path)) {
|
||
|
|
DLOG(WARNING) << "PathService::Get(FILE_EXE) failed.";
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::wstring new_path(std::wstring(symbols_path) +
|
||
|
|
L";" + module_path.DirName().value());
|
||
|
|
if (!SymSetSearchPathW(GetCurrentProcess(), new_path.c_str())) {
|
||
|
|
DLOG(WARNING) << "SymSetSearchPath failed.";
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
DWORD init_error_;
|
||
|
|
base::Lock lock_;
|
||
|
|
DISALLOW_COPY_AND_ASSIGN(SymbolContext);
|
||
|
|
};
|
||
|
|
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
bool EnableInProcessStackDumping() {
|
||
|
|
// Add stack dumping support on exception on windows. Similar to OS_POSIX
|
||
|
|
// signal() handling in process_util_posix.cc.
|
||
|
|
g_previous_filter = SetUnhandledExceptionFilter(&StackDumpExceptionFilter);
|
||
|
|
RouteStdioToConsole();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Disable optimizations for the StackTrace::StackTrace function. It is
|
||
|
|
// important to disable at least frame pointer optimization ("y"), since
|
||
|
|
// that breaks CaptureStackBackTrace() and prevents StackTrace from working
|
||
|
|
// in Release builds (it may still be janky if other frames are using FPO,
|
||
|
|
// but at least it will make it further).
|
||
|
|
#if defined(COMPILER_MSVC)
|
||
|
|
#pragma optimize("", off)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
StackTrace::StackTrace() {
|
||
|
|
// When walking our own stack, use CaptureStackBackTrace().
|
||
|
|
count_ = CaptureStackBackTrace(0, arraysize(trace_), trace_, NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
#if defined(COMPILER_MSVC)
|
||
|
|
#pragma optimize("", on)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
StackTrace::StackTrace(EXCEPTION_POINTERS* exception_pointers) {
|
||
|
|
// When walking an exception stack, we need to use StackWalk64().
|
||
|
|
count_ = 0;
|
||
|
|
// Initialize stack walking.
|
||
|
|
STACKFRAME64 stack_frame;
|
||
|
|
memset(&stack_frame, 0, sizeof(stack_frame));
|
||
|
|
#if defined(_WIN64)
|
||
|
|
int machine_type = IMAGE_FILE_MACHINE_AMD64;
|
||
|
|
stack_frame.AddrPC.Offset = exception_pointers->ContextRecord->Rip;
|
||
|
|
stack_frame.AddrFrame.Offset = exception_pointers->ContextRecord->Rbp;
|
||
|
|
stack_frame.AddrStack.Offset = exception_pointers->ContextRecord->Rsp;
|
||
|
|
#else
|
||
|
|
int machine_type = IMAGE_FILE_MACHINE_I386;
|
||
|
|
stack_frame.AddrPC.Offset = exception_pointers->ContextRecord->Eip;
|
||
|
|
stack_frame.AddrFrame.Offset = exception_pointers->ContextRecord->Ebp;
|
||
|
|
stack_frame.AddrStack.Offset = exception_pointers->ContextRecord->Esp;
|
||
|
|
#endif
|
||
|
|
stack_frame.AddrPC.Mode = AddrModeFlat;
|
||
|
|
stack_frame.AddrFrame.Mode = AddrModeFlat;
|
||
|
|
stack_frame.AddrStack.Mode = AddrModeFlat;
|
||
|
|
while (StackWalk64(machine_type,
|
||
|
|
GetCurrentProcess(),
|
||
|
|
GetCurrentThread(),
|
||
|
|
&stack_frame,
|
||
|
|
exception_pointers->ContextRecord,
|
||
|
|
NULL,
|
||
|
|
&SymFunctionTableAccess64,
|
||
|
|
&SymGetModuleBase64,
|
||
|
|
NULL) &&
|
||
|
|
count_ < arraysize(trace_)) {
|
||
|
|
trace_[count_++] = reinterpret_cast<void*>(stack_frame.AddrPC.Offset);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (size_t i = count_; i < arraysize(trace_); ++i)
|
||
|
|
trace_[i] = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
void StackTrace::PrintBacktrace() const {
|
||
|
|
OutputToStream(&std::cerr);
|
||
|
|
}
|
||
|
|
|
||
|
|
void StackTrace::OutputToStream(std::ostream* os) const {
|
||
|
|
SymbolContext* context = SymbolContext::GetInstance();
|
||
|
|
DWORD error = context->init_error();
|
||
|
|
if (error != ERROR_SUCCESS) {
|
||
|
|
(*os) << "Error initializing symbols (" << error
|
||
|
|
<< "). Dumping unresolved backtrace:\n";
|
||
|
|
for (int i = 0; (i < count_) && os->good(); ++i) {
|
||
|
|
(*os) << "\t" << trace_[i] << "\n";
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
(*os) << "Backtrace:\n";
|
||
|
|
context->OutputTraceToStream(trace_, count_, os);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace debug
|
||
|
|
} // namespace base
|