| OLD | NEW |
|---|
| (Empty) |
| 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 "base/debug_util.h" | |
| 6 | |
| 7 #include <windows.h> | |
| 8 #include <dbghelp.h> | |
| 9 | |
| 10 #include <iostream> | |
| 11 | |
| 12 #include "base/basictypes.h" | |
| 13 #include "base/lock.h" | |
| 14 #include "base/logging.h" | |
| 15 #include "base/singleton.h" | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 // Minimalist key reader. | |
| 20 // Note: Does not use the CRT. | |
| 21 bool RegReadString(HKEY root, const wchar_t* subkey, | |
| 22 const wchar_t* value_name, wchar_t* buffer, int* len) { | |
| 23 HKEY key = NULL; | |
| 24 DWORD res = RegOpenKeyEx(root, subkey, 0, KEY_READ, &key); | |
| 25 if (ERROR_SUCCESS != res || key == NULL) | |
| 26 return false; | |
| 27 | |
| 28 DWORD type = 0; | |
| 29 DWORD buffer_size = *len * sizeof(wchar_t); | |
| 30 // We don't support REG_EXPAND_SZ. | |
| 31 res = RegQueryValueEx(key, value_name, NULL, &type, | |
| 32 reinterpret_cast<BYTE*>(buffer), &buffer_size); | |
| 33 if (ERROR_SUCCESS == res && buffer_size != 0 && type == REG_SZ) { | |
| 34 // Make sure the buffer is NULL terminated. | |
| 35 buffer[*len - 1] = 0; | |
| 36 *len = lstrlen(buffer); | |
| 37 RegCloseKey(key); | |
| 38 return true; | |
| 39 } | |
| 40 RegCloseKey(key); | |
| 41 return false; | |
| 42 } | |
| 43 | |
| 44 // Replaces each "%ld" in input per a value. Not efficient but it works. | |
| 45 // Note: Does not use the CRT. | |
| 46 bool StringReplace(const wchar_t* input, int value, wchar_t* output, | |
| 47 int output_len) { | |
| 48 memset(output, 0, output_len*sizeof(wchar_t)); | |
| 49 int input_len = lstrlen(input); | |
| 50 | |
| 51 for (int i = 0; i < input_len; ++i) { | |
| 52 int current_output_len = lstrlen(output); | |
| 53 | |
| 54 if (input[i] == L'%' && input[i + 1] == L'l' && input[i + 2] == L'd') { | |
| 55 // Make sure we have enough place left. | |
| 56 if ((current_output_len + 12) >= output_len) | |
| 57 return false; | |
| 58 | |
| 59 // Cheap _itow(). | |
| 60 wsprintf(output+current_output_len, L"%d", value); | |
| 61 i += 2; | |
| 62 } else { | |
| 63 if (current_output_len >= output_len) | |
| 64 return false; | |
| 65 output[current_output_len] = input[i]; | |
| 66 } | |
| 67 } | |
| 68 return true; | |
| 69 } | |
| 70 | |
| 71 // SymbolContext is a threadsafe singleton that wraps the DbgHelp Sym* family | |
| 72 // of functions. The Sym* family of functions may only be invoked by one | |
| 73 // thread at a time. SymbolContext code may access a symbol server over the | |
| 74 // network while holding the lock for this singleton. In the case of high | |
| 75 // latency, this code will adversly affect performance. | |
| 76 // | |
| 77 // There is also a known issue where this backtrace code can interact | |
| 78 // badly with breakpad if breakpad is invoked in a separate thread while | |
| 79 // we are using the Sym* functions. This is because breakpad does now | |
| 80 // share a lock with this function. See this related bug: | |
| 81 // | |
| 82 // http://code.google.com/p/google-breakpad/issues/detail?id=311 | |
| 83 // | |
| 84 // This is a very unlikely edge case, and the current solution is to | |
| 85 // just ignore it. | |
| 86 class SymbolContext { | |
| 87 public: | |
| 88 static SymbolContext* Get() { | |
| 89 // We use a leaky singleton because code may call this during process | |
| 90 // termination. | |
| 91 return | |
| 92 Singleton<SymbolContext, LeakySingletonTraits<SymbolContext> >::get(); | |
| 93 } | |
| 94 | |
| 95 // Returns the error code of a failed initialization. | |
| 96 DWORD init_error() const { | |
| 97 return init_error_; | |
| 98 } | |
| 99 | |
| 100 // For the given trace, attempts to resolve the symbols, and output a trace | |
| 101 // to the ostream os. The format for each line of the backtrace is: | |
| 102 // | |
| 103 // <tab>SymbolName[0xAddress+Offset] (FileName:LineNo) | |
| 104 // | |
| 105 // This function should only be called if Init() has been called. We do not | |
| 106 // LOG(FATAL) here because this code is called might be triggered by a | |
| 107 // LOG(FATAL) itself. | |
| 108 void OutputTraceToStream(const void* const* trace, | |
| 109 int count, | |
| 110 std::ostream* os) { | |
| 111 AutoLock lock(lock_); | |
| 112 | |
| 113 for (size_t i = 0; (i < count) && os->good(); ++i) { | |
| 114 const int kMaxNameLength = 256; | |
| 115 DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(trace[i]); | |
| 116 | |
| 117 // Code adapted from MSDN example: | |
| 118 // http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx | |
| 119 ULONG64 buffer[ | |
| 120 (sizeof(SYMBOL_INFO) + | |
| 121 kMaxNameLength * sizeof(wchar_t) + | |
| 122 sizeof(ULONG64) - 1) / | |
| 123 sizeof(ULONG64)]; | |
| 124 memset(buffer, 0, sizeof(buffer)); | |
| 125 | |
| 126 // Initialize symbol information retrieval structures. | |
| 127 DWORD64 sym_displacement = 0; | |
| 128 PSYMBOL_INFO symbol = reinterpret_cast<PSYMBOL_INFO>(&buffer[0]); | |
| 129 symbol->SizeOfStruct = sizeof(SYMBOL_INFO); | |
| 130 symbol->MaxNameLen = kMaxNameLength - 1; | |
| 131 BOOL has_symbol = SymFromAddr(GetCurrentProcess(), frame, | |
| 132 &sym_displacement, symbol); | |
| 133 | |
| 134 // Attempt to retrieve line number information. | |
| 135 DWORD line_displacement = 0; | |
| 136 IMAGEHLP_LINE64 line = {}; | |
| 137 line.SizeOfStruct = sizeof(IMAGEHLP_LINE64); | |
| 138 BOOL has_line = SymGetLineFromAddr64(GetCurrentProcess(), frame, | |
| 139 &line_displacement, &line); | |
| 140 | |
| 141 // Output the backtrace line. | |
| 142 (*os) << "\t"; | |
| 143 if (has_symbol) { | |
| 144 (*os) << symbol->Name << " [0x" << trace[i] << "+" | |
| 145 << sym_displacement << "]"; | |
| 146 } else { | |
| 147 // If there is no symbol informtion, add a spacer. | |
| 148 (*os) << "(No symbol) [0x" << trace[i] << "]"; | |
| 149 } | |
| 150 if (has_line) { | |
| 151 (*os) << " (" << line.FileName << ":" << line.LineNumber << ")"; | |
| 152 } | |
| 153 (*os) << "\n"; | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 private: | |
| 158 friend struct DefaultSingletonTraits<SymbolContext>; | |
| 159 | |
| 160 SymbolContext() : init_error_(ERROR_SUCCESS) { | |
| 161 // Initializes the symbols for the process. | |
| 162 // Defer symbol load until they're needed, use undecorated names, and | |
| 163 // get line numbers. | |
| 164 SymSetOptions(SYMOPT_DEFERRED_LOADS | | |
| 165 SYMOPT_UNDNAME | | |
| 166 SYMOPT_LOAD_LINES); | |
| 167 if (SymInitialize(GetCurrentProcess(), NULL, TRUE)) { | |
| 168 init_error_ = ERROR_SUCCESS; | |
| 169 } else { | |
| 170 init_error_ = GetLastError(); | |
| 171 // TODO(awong): Handle error: SymInitialize can fail with | |
| 172 // ERROR_INVALID_PARAMETER. | |
| 173 // When it fails, we should not call debugbreak since it kills the current | |
| 174 // process (prevents future tests from running or kills the browser | |
| 175 // process). | |
| 176 DLOG(ERROR) << "SymInitialize failed: " << init_error_; | |
| 177 } | |
| 178 } | |
| 179 | |
| 180 DWORD init_error_; | |
| 181 Lock lock_; | |
| 182 DISALLOW_COPY_AND_ASSIGN(SymbolContext); | |
| 183 }; | |
| 184 | |
| 185 } // namespace | |
| 186 | |
| 187 // Note: Does not use the CRT. | |
| 188 bool DebugUtil::SpawnDebuggerOnProcess(unsigned process_id) { | |
| 189 wchar_t reg_value[1026]; | |
| 190 int len = arraysize(reg_value); | |
| 191 if (RegReadString(HKEY_LOCAL_MACHINE, | |
| 192 L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug", | |
| 193 L"Debugger", reg_value, &len)) { | |
| 194 wchar_t command_line[1026]; | |
| 195 if (StringReplace(reg_value, process_id, command_line, | |
| 196 arraysize(command_line))) { | |
| 197 // We don't mind if the debugger is present because it will simply fail | |
| 198 // to attach to this process. | |
| 199 STARTUPINFO startup_info = {0}; | |
| 200 startup_info.cb = sizeof(startup_info); | |
| 201 PROCESS_INFORMATION process_info = {0}; | |
| 202 | |
| 203 if (CreateProcess(NULL, command_line, NULL, NULL, FALSE, 0, NULL, NULL, | |
| 204 &startup_info, &process_info)) { | |
| 205 CloseHandle(process_info.hThread); | |
| 206 WaitForInputIdle(process_info.hProcess, 10000); | |
| 207 CloseHandle(process_info.hProcess); | |
| 208 return true; | |
| 209 } | |
| 210 } | |
| 211 } | |
| 212 return false; | |
| 213 } | |
| 214 | |
| 215 // static | |
| 216 bool DebugUtil::BeingDebugged() { | |
| 217 return ::IsDebuggerPresent() != 0; | |
| 218 } | |
| 219 | |
| 220 // static | |
| 221 void DebugUtil::BreakDebugger() { | |
| 222 if (suppress_dialogs_) | |
| 223 _exit(1); | |
| 224 | |
| 225 __debugbreak(); | |
| 226 } | |
| 227 | |
| 228 StackTrace::StackTrace() { | |
| 229 // When walking our own stack, use CaptureStackBackTrace(). | |
| 230 count_ = CaptureStackBackTrace(0, arraysize(trace_), trace_, NULL); | |
| 231 } | |
| 232 | |
| 233 StackTrace::StackTrace(EXCEPTION_POINTERS* exception_pointers) { | |
| 234 // When walking an exception stack, we need to use StackWalk64(). | |
| 235 count_ = 0; | |
| 236 // Initialize stack walking. | |
| 237 STACKFRAME64 stack_frame; | |
| 238 memset(&stack_frame, 0, sizeof(stack_frame)); | |
| 239 #if defined(_WIN64) | |
| 240 int machine_type = IMAGE_FILE_MACHINE_AMD64; | |
| 241 stack_frame.AddrPC.Offset = exception_pointers->ContextRecord->Rip; | |
| 242 stack_frame.AddrFrame.Offset = exception_pointers->ContextRecord->Rbp; | |
| 243 stack_frame.AddrStack.Offset = exception_pointers->ContextRecord->Rsp; | |
| 244 #else | |
| 245 int machine_type = IMAGE_FILE_MACHINE_I386; | |
| 246 stack_frame.AddrPC.Offset = exception_pointers->ContextRecord->Eip; | |
| 247 stack_frame.AddrFrame.Offset = exception_pointers->ContextRecord->Ebp; | |
| 248 stack_frame.AddrStack.Offset = exception_pointers->ContextRecord->Esp; | |
| 249 #endif | |
| 250 stack_frame.AddrPC.Mode = AddrModeFlat; | |
| 251 stack_frame.AddrFrame.Mode = AddrModeFlat; | |
| 252 stack_frame.AddrStack.Mode = AddrModeFlat; | |
| 253 while (StackWalk64(machine_type, | |
| 254 GetCurrentProcess(), | |
| 255 GetCurrentThread(), | |
| 256 &stack_frame, | |
| 257 exception_pointers->ContextRecord, | |
| 258 NULL, | |
| 259 &SymFunctionTableAccess64, | |
| 260 &SymGetModuleBase64, | |
| 261 NULL) && | |
| 262 count_ < arraysize(trace_)) { | |
| 263 trace_[count_++] = reinterpret_cast<void*>(stack_frame.AddrPC.Offset); | |
| 264 } | |
| 265 } | |
| 266 | |
| 267 void StackTrace::PrintBacktrace() { | |
| 268 OutputToStream(&std::cerr); | |
| 269 } | |
| 270 | |
| 271 void StackTrace::OutputToStream(std::ostream* os) { | |
| 272 SymbolContext* context = SymbolContext::Get(); | |
| 273 DWORD error = context->init_error(); | |
| 274 if (error != ERROR_SUCCESS) { | |
| 275 (*os) << "Error initializing symbols (" << error | |
| 276 << "). Dumping unresolved backtrace:\n"; | |
| 277 for (int i = 0; (i < count_) && os->good(); ++i) { | |
| 278 (*os) << "\t" << trace_[i] << "\n"; | |
| 279 } | |
| 280 } else { | |
| 281 (*os) << "Backtrace:\n"; | |
| 282 context->OutputTraceToStream(trace_, count_, os); | |
| 283 } | |
| 284 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3945002:
Move debug-related stuff from base to the base/debug directory and use the... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/