| OLD | NEW |
|---|
| (Empty) |
| 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 <windows.h> | |
| 8 #include <dbghelp.h> | |
| 9 | |
| 10 #include <iostream> | |
| 11 | |
| 12 #include "base/basictypes.h" | |
| 13 #include "base/logging.h" | |
| 14 #include "base/memory/singleton.h" | |
| 15 #include "base/process/launch.h" | |
| 16 #include "base/strings/string_util.h" | |
| 17 #include "base/synchronization/lock.h" | |
| 18 #include "base/win/windows_version.h" | |
| 19 | |
| 20 namespace base { | |
| 21 namespace debug { | |
| 22 | |
| 23 namespace { | |
| 24 | |
| 25 // Previous unhandled filter. Will be called if not NULL when we intercept an | |
| 26 // exception. Only used in unit tests. | |
| 27 LPTOP_LEVEL_EXCEPTION_FILTER g_previous_filter = NULL; | |
| 28 | |
| 29 // Prints the exception call stack. | |
| 30 // This is the unit tests exception filter. | |
| 31 long WINAPI StackDumpExceptionFilter(EXCEPTION_POINTERS* info) { | |
| 32 debug::StackTrace(info).Print(); | |
| 33 if (g_previous_filter) | |
| 34 return g_previous_filter(info); | |
| 35 return EXCEPTION_CONTINUE_SEARCH; | |
| 36 } | |
| 37 | |
| 38 FilePath GetExePath() { | |
| 39 wchar_t system_buffer[MAX_PATH]; | |
| 40 GetModuleFileName(NULL, system_buffer, MAX_PATH); | |
| 41 system_buffer[MAX_PATH - 1] = L'\0'; | |
| 42 return FilePath(system_buffer); | |
| 43 } | |
| 44 | |
| 45 // SymbolContext is a threadsafe singleton that wraps the DbgHelp Sym* family | |
| 46 // of functions. The Sym* family of functions may only be invoked by one | |
| 47 // thread at a time. SymbolContext code may access a symbol server over the | |
| 48 // network while holding the lock for this singleton. In the case of high | |
| 49 // latency, this code will adversely affect performance. | |
| 50 // | |
| 51 // There is also a known issue where this backtrace code can interact | |
| 52 // badly with breakpad if breakpad is invoked in a separate thread while | |
| 53 // we are using the Sym* functions. This is because breakpad does now | |
| 54 // share a lock with this function. See this related bug: | |
| 55 // | |
| 56 // http://code.google.com/p/google-breakpad/issues/detail?id=311 | |
| 57 // | |
| 58 // This is a very unlikely edge case, and the current solution is to | |
| 59 // just ignore it. | |
| 60 class SymbolContext { | |
| 61 public: | |
| 62 static SymbolContext* GetInstance() { | |
| 63 // We use a leaky singleton because code may call this during process | |
| 64 // termination. | |
| 65 return | |
| 66 Singleton<SymbolContext, LeakySingletonTraits<SymbolContext> >::get(); | |
| 67 } | |
| 68 | |
| 69 // Returns the error code of a failed initialization. | |
| 70 DWORD init_error() const { | |
| 71 return init_error_; | |
| 72 } | |
| 73 | |
| 74 // For the given trace, attempts to resolve the symbols, and output a trace | |
| 75 // to the ostream os. The format for each line of the backtrace is: | |
| 76 // | |
| 77 // <tab>SymbolName[0xAddress+Offset] (FileName:LineNo) | |
| 78 // | |
| 79 // This function should only be called if Init() has been called. We do not | |
| 80 // LOG(FATAL) here because this code is called might be triggered by a | |
| 81 // LOG(FATAL) itself. Also, it should not be calling complex code that is | |
| 82 // extensible like PathService since that can in turn fire CHECKs. | |
| 83 void OutputTraceToStream(const void* const* trace, | |
| 84 size_t count, | |
| 85 std::ostream* os) { | |
| 86 base::AutoLock lock(lock_); | |
| 87 | |
| 88 for (size_t i = 0; (i < count) && os->good(); ++i) { | |
| 89 const int kMaxNameLength = 256; | |
| 90 DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(trace[i]); | |
| 91 | |
| 92 // Code adapted from MSDN example: | |
| 93 // http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx | |
| 94 ULONG64 buffer[ | |
| 95 (sizeof(SYMBOL_INFO) + | |
| 96 kMaxNameLength * sizeof(wchar_t) + | |
| 97 sizeof(ULONG64) - 1) / | |
| 98 sizeof(ULONG64)]; | |
| 99 memset(buffer, 0, sizeof(buffer)); | |
| 100 | |
| 101 // Initialize symbol information retrieval structures. | |
| 102 DWORD64 sym_displacement = 0; | |
| 103 PSYMBOL_INFO symbol = reinterpret_cast<PSYMBOL_INFO>(&buffer[0]); | |
| 104 symbol->SizeOfStruct = sizeof(SYMBOL_INFO); | |
| 105 symbol->MaxNameLen = kMaxNameLength - 1; | |
| 106 BOOL has_symbol = SymFromAddr(GetCurrentProcess(), frame, | |
| 107 &sym_displacement, symbol); | |
| 108 | |
| 109 // Attempt to retrieve line number information. | |
| 110 DWORD line_displacement = 0; | |
| 111 IMAGEHLP_LINE64 line = {}; | |
| 112 line.SizeOfStruct = sizeof(IMAGEHLP_LINE64); | |
| 113 BOOL has_line = SymGetLineFromAddr64(GetCurrentProcess(), frame, | |
| 114 &line_displacement, &line); | |
| 115 | |
| 116 // Output the backtrace line. | |
| 117 (*os) << "\t"; | |
| 118 if (has_symbol) { | |
| 119 (*os) << symbol->Name << " [0x" << trace[i] << "+" | |
| 120 << sym_displacement << "]"; | |
| 121 } else { | |
| 122 // If there is no symbol information, add a spacer. | |
| 123 (*os) << "(No symbol) [0x" << trace[i] << "]"; | |
| 124 } | |
| 125 if (has_line) { | |
| 126 (*os) << " (" << line.FileName << ":" << line.LineNumber << ")"; | |
| 127 } | |
| 128 (*os) << "\n"; | |
| 129 } | |
| 130 } | |
| 131 | |
| 132 private: | |
| 133 friend struct DefaultSingletonTraits<SymbolContext>; | |
| 134 | |
| 135 SymbolContext() : init_error_(ERROR_SUCCESS) { | |
| 136 // Initializes the symbols for the process. | |
| 137 // Defer symbol load until they're needed, use undecorated names, and | |
| 138 // get line numbers. | |
| 139 SymSetOptions(SYMOPT_DEFERRED_LOADS | | |
| 140 SYMOPT_UNDNAME | | |
| 141 SYMOPT_LOAD_LINES); | |
| 142 if (!SymInitialize(GetCurrentProcess(), NULL, TRUE)) { | |
| 143 init_error_ = GetLastError(); | |
| 144 // TODO(awong): Handle error: SymInitialize can fail with | |
| 145 // ERROR_INVALID_PARAMETER. | |
| 146 // When it fails, we should not call debugbreak since it kills the current | |
| 147 // process (prevents future tests from running or kills the browser | |
| 148 // process). | |
| 149 DLOG(ERROR) << "SymInitialize failed: " << init_error_; | |
| 150 return; | |
| 151 } | |
| 152 | |
| 153 init_error_ = ERROR_SUCCESS; | |
| 154 | |
| 155 // When transferring the binaries e.g. between bots, path put | |
| 156 // into the executable will get off. To still retrieve symbols correctly, | |
| 157 // add the directory of the executable to symbol search path. | |
| 158 // All following errors are non-fatal. | |
| 159 const size_t kSymbolsArraySize = 1024; | |
| 160 scoped_ptr<wchar_t[]> symbols_path(new wchar_t[kSymbolsArraySize]); | |
| 161 | |
| 162 // Note: The below function takes buffer size as number of characters, | |
| 163 // not number of bytes! | |
| 164 if (!SymGetSearchPathW(GetCurrentProcess(), | |
| 165 symbols_path.get(), | |
| 166 kSymbolsArraySize)) { | |
| 167 DLOG(WARNING) << "SymGetSearchPath failed: "; | |
| 168 return; | |
| 169 } | |
| 170 | |
| 171 std::wstring new_path(std::wstring(symbols_path.get()) + | |
| 172 L";" + GetExePath().DirName().value()); | |
| 173 if (!SymSetSearchPathW(GetCurrentProcess(), new_path.c_str())) { | |
| 174 DLOG(WARNING) << "SymSetSearchPath failed."; | |
| 175 return; | |
| 176 } | |
| 177 } | |
| 178 | |
| 179 DWORD init_error_; | |
| 180 base::Lock lock_; | |
| 181 DISALLOW_COPY_AND_ASSIGN(SymbolContext); | |
| 182 }; | |
| 183 | |
| 184 } // namespace | |
| 185 | |
| 186 bool EnableInProcessStackDumping() { | |
| 187 // Add stack dumping support on exception on windows. Similar to OS_POSIX | |
| 188 // signal() handling in process_util_posix.cc. | |
| 189 g_previous_filter = SetUnhandledExceptionFilter(&StackDumpExceptionFilter); | |
| 190 RouteStdioToConsole(); | |
| 191 return true; | |
| 192 } | |
| 193 | |
| 194 // Disable optimizations for the StackTrace::StackTrace function. It is | |
| 195 // important to disable at least frame pointer optimization ("y"), since | |
| 196 // that breaks CaptureStackBackTrace() and prevents StackTrace from working | |
| 197 // in Release builds (it may still be janky if other frames are using FPO, | |
| 198 // but at least it will make it further). | |
| 199 #if defined(COMPILER_MSVC) | |
| 200 #pragma optimize("", off) | |
| 201 #endif | |
| 202 | |
| 203 StackTrace::StackTrace() { | |
| 204 // When walking our own stack, use CaptureStackBackTrace(). | |
| 205 count_ = CaptureStackBackTrace(0, arraysize(trace_), trace_, NULL); | |
| 206 } | |
| 207 | |
| 208 #if defined(COMPILER_MSVC) | |
| 209 #pragma optimize("", on) | |
| 210 #endif | |
| 211 | |
| 212 StackTrace::StackTrace(const EXCEPTION_POINTERS* exception_pointers) { | |
| 213 // StackWalk64() may modify context record passed to it, so we will | |
| 214 // use a copy. | |
| 215 CONTEXT context_record = *exception_pointers->ContextRecord; | |
| 216 InitTrace(&context_record); | |
| 217 } | |
| 218 | |
| 219 StackTrace::StackTrace(const CONTEXT* context) { | |
| 220 // StackWalk64() may modify context record passed to it, so we will | |
| 221 // use a copy. | |
| 222 CONTEXT context_record = *context; | |
| 223 InitTrace(&context_record); | |
| 224 } | |
| 225 | |
| 226 void StackTrace::InitTrace(CONTEXT* context_record) { | |
| 227 // When walking an exception stack, we need to use StackWalk64(). | |
| 228 count_ = 0; | |
| 229 // Initialize stack walking. | |
| 230 STACKFRAME64 stack_frame; | |
| 231 memset(&stack_frame, 0, sizeof(stack_frame)); | |
| 232 #if defined(_WIN64) | |
| 233 int machine_type = IMAGE_FILE_MACHINE_AMD64; | |
| 234 stack_frame.AddrPC.Offset = context_record->Rip; | |
| 235 stack_frame.AddrFrame.Offset = context_record->Rbp; | |
| 236 stack_frame.AddrStack.Offset = context_record->Rsp; | |
| 237 #else | |
| 238 int machine_type = IMAGE_FILE_MACHINE_I386; | |
| 239 stack_frame.AddrPC.Offset = context_record->Eip; | |
| 240 stack_frame.AddrFrame.Offset = context_record->Ebp; | |
| 241 stack_frame.AddrStack.Offset = context_record->Esp; | |
| 242 #endif | |
| 243 stack_frame.AddrPC.Mode = AddrModeFlat; | |
| 244 stack_frame.AddrFrame.Mode = AddrModeFlat; | |
| 245 stack_frame.AddrStack.Mode = AddrModeFlat; | |
| 246 while (StackWalk64(machine_type, | |
| 247 GetCurrentProcess(), | |
| 248 GetCurrentThread(), | |
| 249 &stack_frame, | |
| 250 context_record, | |
| 251 NULL, | |
| 252 &SymFunctionTableAccess64, | |
| 253 &SymGetModuleBase64, | |
| 254 NULL) && | |
| 255 count_ < arraysize(trace_)) { | |
| 256 trace_[count_++] = reinterpret_cast<void*>(stack_frame.AddrPC.Offset); | |
| 257 } | |
| 258 | |
| 259 for (size_t i = count_; i < arraysize(trace_); ++i) | |
| 260 trace_[i] = NULL; | |
| 261 } | |
| 262 | |
| 263 void StackTrace::Print() const { | |
| 264 OutputToStream(&std::cerr); | |
| 265 } | |
| 266 | |
| 267 void StackTrace::OutputToStream(std::ostream* os) const { | |
| 268 SymbolContext* context = SymbolContext::GetInstance(); | |
| 269 DWORD error = context->init_error(); | |
| 270 if (error != ERROR_SUCCESS) { | |
| 271 (*os) << "Error initializing symbols (" << error | |
| 272 << "). Dumping unresolved backtrace:\n"; | |
| 273 for (size_t i = 0; (i < count_) && os->good(); ++i) { | |
| 274 (*os) << "\t" << trace_[i] << "\n"; | |
| 275 } | |
| 276 } else { | |
| 277 (*os) << "Backtrace:\n"; | |
| 278 context->OutputTraceToStream(trace_, count_, os); | |
| 279 } | |
| 280 } | |
| 281 | |
| 282 } // namespace debug | |
| 283 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1446363003:
Deleted OS_WIN and all Windows specific files from base. (Closed)
Base URL: https://github.com/domokit/mojo.git@base_tests