base/debug/stack_trace_win.cc - mirrors/engine - Git at Google

 // 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/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).Print();
   if (g_previous_filter)
     return g_previous_filter(info);
   return EXCEPTION_CONTINUE_SEARCH;
 }

 FilePath GetExePath() {
   wchar_t system_buffer[MAX_PATH];
   GetModuleFileName(NULL, system_buffer, MAX_PATH);
   system_buffer[MAX_PATH - 1] = L'\0';
   return FilePath(system_buffer);
 }

 // 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. Also, it should not be calling complex code that is
   // extensible like PathService since that can in turn fire CHECKs.
   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;

     // 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.
     const size_t kSymbolsArraySize = 1024;
     scoped_ptr<wchar_t[]> symbols_path(new wchar_t[kSymbolsArraySize]);

     // Note: The below function takes buffer size as number of characters,
     // not number of bytes!
     if (!SymGetSearchPathW(GetCurrentProcess(),
                            symbols_path.get(),
                            kSymbolsArraySize)) {
       DLOG(WARNING) << "SymGetSearchPath failed: ";
       return;
     }

     std::wstring new_path(std::wstring(symbols_path.get()) +
                           L";" + GetExePath().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(const EXCEPTION_POINTERS* exception_pointers) {
   // StackWalk64() may modify context record passed to it, so we will
   // use a copy.
   CONTEXT context_record = *exception_pointers->ContextRecord;
   InitTrace(&context_record);
 }

 StackTrace::StackTrace(const CONTEXT* context) {
   // StackWalk64() may modify context record passed to it, so we will
   // use a copy.
   CONTEXT context_record = *context;
   InitTrace(&context_record);
 }

 void StackTrace::InitTrace(CONTEXT* context_record) {
   // 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 = context_record->Rip;
   stack_frame.AddrFrame.Offset = context_record->Rbp;
   stack_frame.AddrStack.Offset = context_record->Rsp;
 #else
   int machine_type = IMAGE_FILE_MACHINE_I386;
   stack_frame.AddrPC.Offset = context_record->Eip;
   stack_frame.AddrFrame.Offset = context_record->Ebp;
   stack_frame.AddrStack.Offset = context_record->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,
                      context_record,
                      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::Print() 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 (size_t 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
	// 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/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).Print();
	if (g_previous_filter)
	return g_previous_filter(info);
	return EXCEPTION_CONTINUE_SEARCH;
	}

	FilePath GetExePath() {
	wchar_t system_buffer[MAX_PATH];
	GetModuleFileName(NULL, system_buffer, MAX_PATH);
	system_buffer[MAX_PATH - 1] = L'\0';
	return FilePath(system_buffer);
	}

	// 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. Also, it should not be calling complex code that is
	// extensible like PathService since that can in turn fire CHECKs.
	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;

	// 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.
	const size_t kSymbolsArraySize = 1024;
	scoped_ptr<wchar_t[]> symbols_path(new wchar_t[kSymbolsArraySize]);

	// Note: The below function takes buffer size as number of characters,
	// not number of bytes!
	if (!SymGetSearchPathW(GetCurrentProcess(),
	symbols_path.get(),
	kSymbolsArraySize)) {
	DLOG(WARNING) << "SymGetSearchPath failed: ";
	return;
	}

	std::wstring new_path(std::wstring(symbols_path.get()) +
	L";" + GetExePath().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(const EXCEPTION_POINTERS* exception_pointers) {
	// StackWalk64() may modify context record passed to it, so we will
	// use a copy.
	CONTEXT context_record = *exception_pointers->ContextRecord;
	InitTrace(&context_record);
	}

	StackTrace::StackTrace(const CONTEXT* context) {
	// StackWalk64() may modify context record passed to it, so we will
	// use a copy.
	CONTEXT context_record = *context;
	InitTrace(&context_record);
	}

	void StackTrace::InitTrace(CONTEXT* context_record) {
	// 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 = context_record->Rip;
	stack_frame.AddrFrame.Offset = context_record->Rbp;
	stack_frame.AddrStack.Offset = context_record->Rsp;
	#else
	int machine_type = IMAGE_FILE_MACHINE_I386;
	stack_frame.AddrPC.Offset = context_record->Eip;
	stack_frame.AddrFrame.Offset = context_record->Ebp;
	stack_frame.AddrStack.Offset = context_record->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,
	context_record,
	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::Print() 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 (size_t 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