src/tools/memory_watcher/call_stack.cc

   1 // Copyright (c) 2010 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 "tools/memory_watcher/call_stack.h"
   6
   7 #include <shlwapi.h>
   8 #include <tlhelp32.h>
   9
  10 #include "base/strings/string_number_conversions.h"
  11 #include "tools/memory_watcher/memory_hook.h"
  12
  13 // Typedefs for explicit dynamic linking with functions exported from
  14 // dbghelp.dll.
  15 typedef BOOL (__stdcall *t_StackWalk64)(DWORD, HANDLE, HANDLE,
  16                                         LPSTACKFRAME64, PVOID,
  17                                         PREAD_PROCESS_MEMORY_ROUTINE64,
  18                                         PFUNCTION_TABLE_ACCESS_ROUTINE64,
  19                                         PGET_MODULE_BASE_ROUTINE64,
  20                                         PTRANSLATE_ADDRESS_ROUTINE64);
  21 typedef PVOID (__stdcall *t_SymFunctionTableAccess64)(HANDLE, DWORD64);
  22 typedef DWORD64 (__stdcall *t_SymGetModuleBase64)(HANDLE, DWORD64);
  23 typedef BOOL (__stdcall *t_SymCleanup)(HANDLE);
  24 typedef BOOL (__stdcall *t_SymGetSymFromAddr64)(HANDLE, DWORD64,
  25                                                PDWORD64, PIMAGEHLP_SYMBOL64);
  26 typedef BOOL (__stdcall *t_SymGetLineFromAddr64)(HANDLE, DWORD64, PDWORD,
  27                                                  PIMAGEHLP_LINE64);
  28 typedef BOOL (__stdcall *t_SymInitialize)(HANDLE, PCTSTR, BOOL);
  29 typedef DWORD (__stdcall *t_SymGetOptions)(void);
  30 typedef DWORD (__stdcall *t_SymSetOptions)(DWORD);
  31 typedef BOOL (__stdcall *t_SymGetSearchPath)(HANDLE, PTSTR, DWORD);
  32 typedef DWORD64 (__stdcall *t_SymLoadModule64)(HANDLE, HANDLE, PCSTR,
  33                                                PCSTR, DWORD64, DWORD);
  34 typedef BOOL (__stdcall *t_SymGetModuleInfo64)(HANDLE, DWORD64,
  35                                                PIMAGEHLP_MODULE64);
  36
  37 // static
  38 base::Lock CallStack::dbghelp_lock_;
  39 // static
  40 bool CallStack::dbghelp_loaded_ = false;
  41 // static
  42 DWORD CallStack::active_thread_id_ = 0;
  43
  44
  45 static t_StackWalk64 pStackWalk64 = NULL;
  46 static t_SymCleanup pSymCleanup = NULL;
  47 static t_SymGetSymFromAddr64 pSymGetSymFromAddr64 = NULL;
  48 static t_SymFunctionTableAccess64 pSymFunctionTableAccess64 = NULL;
  49 static t_SymGetModuleBase64 pSymGetModuleBase64 = NULL;
  50 static t_SymGetLineFromAddr64 pSymGetLineFromAddr64 = NULL;
  51 static t_SymInitialize pSymInitialize = NULL;
  52 static t_SymGetOptions pSymGetOptions = NULL;
  53 static t_SymSetOptions pSymSetOptions = NULL;
  54 static t_SymGetModuleInfo64 pSymGetModuleInfo64 = NULL;
  55 static t_SymGetSearchPath pSymGetSearchPath = NULL;
  56 static t_SymLoadModule64 pSymLoadModule64 = NULL;
  57
  58 #define LOADPROC(module, name)  do {                                    \
  59   p##name = reinterpret_cast<t_##name>(GetProcAddress(module, #name));  \
  60   if (p##name == NULL) return false;                                    \
  61 } while (0)
  62
  63 // This code has to be VERY careful to not induce any allocations, as memory
  64 // watching code may cause recursion, which may obscure the stack for the truly
  65 // offensive issue.  We use this function to break into a debugger, and it
  66 // is guaranteed to not do any allocations (in fact, not do anything).
  67 static void UltraSafeDebugBreak() {
  68   _asm int(3);
  69 }
  70
  71 // static
  72 bool CallStack::LoadDbgHelp() {
  73   if (!dbghelp_loaded_) {
  74     base::AutoLock Lock(dbghelp_lock_);
  75
  76     // Re-check if we've loaded successfully now that we have the lock.
  77     if (dbghelp_loaded_)
  78       return true;
  79
  80     // Load dbghelp.dll, and obtain pointers to the exported functions that we
  81     // will be using.
  82     HMODULE dbghelp_module = LoadLibrary(L"dbghelp.dll");
  83     if (dbghelp_module) {
  84       LOADPROC(dbghelp_module, StackWalk64);
  85       LOADPROC(dbghelp_module, SymFunctionTableAccess64);
  86       LOADPROC(dbghelp_module, SymGetModuleBase64);
  87       LOADPROC(dbghelp_module, SymCleanup);
  88       LOADPROC(dbghelp_module, SymGetSymFromAddr64);
  89       LOADPROC(dbghelp_module, SymGetLineFromAddr64);
  90       LOADPROC(dbghelp_module, SymInitialize);
  91       LOADPROC(dbghelp_module, SymGetOptions);
  92       LOADPROC(dbghelp_module, SymSetOptions);
  93       LOADPROC(dbghelp_module, SymGetModuleInfo64);
  94       LOADPROC(dbghelp_module, SymGetSearchPath);
  95       LOADPROC(dbghelp_module, SymLoadModule64);
  96       dbghelp_loaded_ = true;
  97     } else {
  98       UltraSafeDebugBreak();
  99       return false;
 100     }
 101   }
 102   return dbghelp_loaded_;
 103 }
 104
 105 // Load the symbols for generating stack traces.
 106 static bool LoadSymbols(HANDLE process_handle) {
 107   static bool symbols_loaded = false;
 108   if (symbols_loaded) return true;
 109
 110   BOOL ok;
 111
 112   // Initialize the symbol engine.
 113   ok = pSymInitialize(process_handle,  /* hProcess */
 114                       NULL,            /* UserSearchPath */
 115                       FALSE);          /* fInvadeProcess */
 116   if (!ok) return false;
 117
 118   DWORD options = pSymGetOptions();
 119   options |= SYMOPT_LOAD_LINES;
 120   options |= SYMOPT_FAIL_CRITICAL_ERRORS;
 121   options |= SYMOPT_UNDNAME;
 122   options = pSymSetOptions(options);
 123
 124   const DWORD kMaxSearchPath = 1024;
 125   TCHAR buf[kMaxSearchPath] = {0};
 126   ok = pSymGetSearchPath(process_handle, buf, kMaxSearchPath);
 127   if (!ok)
 128     return false;
 129
 130   HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,
 131                                              GetCurrentProcessId());
 132   if (snapshot == INVALID_HANDLE_VALUE)
 133     return false;
 134
 135   MODULEENTRY32W module;
 136   module.dwSize = sizeof(module);  // Set the size of the structure.
 137   BOOL cont = Module32FirstW(snapshot, &module);
 138   while (cont) {
 139     DWORD64 base;
 140     // NOTE the SymLoadModule64 function has the peculiarity of accepting a
 141     // both unicode and ASCII strings even though the parameter is PSTR.
 142     base = pSymLoadModule64(process_handle,
 143                             0,
 144                             reinterpret_cast<PSTR>(module.szExePath),
 145                             reinterpret_cast<PSTR>(module.szModule),
 146                             reinterpret_cast<DWORD64>(module.modBaseAddr),
 147                             module.modBaseSize);
 148     if (base == 0) {
 149       int err = GetLastError();
 150       if (err != ERROR_MOD_NOT_FOUND && err != ERROR_INVALID_HANDLE)
 151           return false;
 152     }
 153     cont = Module32NextW(snapshot, &module);
 154   }
 155   CloseHandle(snapshot);
 156
 157   symbols_loaded = true;
 158   return true;
 159 }
 160
 161
 162 CallStack::SymbolCache* CallStack::symbol_cache_;
 163
 164 bool CallStack::Initialize() {
 165   // We need to delay load the symbol cache until after
 166   // the MemoryHook heap is alive.
 167   symbol_cache_ = new SymbolCache();
 168   return LoadDbgHelp();
 169 }
 170
 171 CallStack::CallStack() {
 172   static LONG callstack_id = 0;
 173   frame_count_ = 0;
 174   hash_ = 0;
 175   id_ = InterlockedIncrement(&callstack_id);
 176   valid_ = false;
 177
 178   if (!dbghelp_loaded_) {
 179     UltraSafeDebugBreak();  // Initialize should have been called.
 180     return;
 181   }
 182
 183   GetStackTrace();
 184 }
 185
 186 bool CallStack::IsEqual(const CallStack &target) {
 187   if (frame_count_ != target.frame_count_)
 188     return false;  // They can't be equal if the sizes are different.
 189
 190   // Walk the frames array until we
 191   // either find a mismatch, or until we reach the end of the call stacks.
 192   for (int index = 0; index < frame_count_; index++) {
 193     if (frames_[index] != target.frames_[index])
 194       return false;  // Found a mismatch. They are not equal.
 195   }
 196
 197   // Reached the end of the call stacks. They are equal.
 198   return true;
 199 }
 200
 201 void CallStack::AddFrame(DWORD_PTR pc) {
 202   DCHECK(frame_count_ < kMaxTraceFrames);
 203   frames_[frame_count_++] = pc;
 204
 205   // Create a unique id for this CallStack.
 206   pc = pc + (frame_count_ * 13);  // Alter the PC based on position in stack.
 207   hash_ = ~hash_ + (pc << 15);
 208   hash_ = hash_ ^ (pc >> 12);
 209   hash_ = hash_ + (pc << 2);
 210   hash_ = hash_ ^ (pc >> 4);
 211   hash_ = hash_ * 2057;
 212   hash_ = hash_ ^ (pc >> 16);
 213 }
 214
 215 bool CallStack::LockedRecursionDetected() const {
 216   if (!active_thread_id_) return false;
 217   DWORD thread_id = GetCurrentThreadId();
 218   // TODO(jar): Perchance we should use atomic access to member.
 219   return thread_id == active_thread_id_;
 220 }
 221
 222 bool CallStack::GetStackTrace() {
 223   if (LockedRecursionDetected())
 224     return false;
 225
 226   // Initialize the context record.
 227   CONTEXT context;
 228   memset(&context, 0, sizeof(context));
 229   context.ContextFlags = CONTEXT_FULL;
 230   __asm    call x
 231   __asm x: pop eax
 232   __asm    mov context.Eip, eax
 233   __asm    mov context.Ebp, ebp
 234   __asm    mov context.Esp, esp
 235
 236   STACKFRAME64 frame;
 237   memset(&frame, 0, sizeof(frame));
 238
 239 #ifdef _M_IX86
 240   DWORD image_type = IMAGE_FILE_MACHINE_I386;
 241   frame.AddrPC.Offset    = context.Eip;
 242   frame.AddrPC.Mode      = AddrModeFlat;
 243   frame.AddrFrame.Offset = context.Ebp;
 244   frame.AddrFrame.Mode   = AddrModeFlat;
 245   frame.AddrStack.Offset = context.Esp;
 246   frame.AddrStack.Mode   = AddrModeFlat;
 247 #elif
 248   NOT IMPLEMENTED!
 249 #endif
 250
 251   HANDLE current_process = GetCurrentProcess();
 252   HANDLE current_thread = GetCurrentThread();
 253
 254   // Walk the stack.
 255   unsigned int count = 0;
 256   {
 257     AutoDbgHelpLock thread_monitoring_lock;
 258
 259     while (count < kMaxTraceFrames) {
 260       count++;
 261       if (!pStackWalk64(image_type,
 262                         current_process,
 263                         current_thread,
 264                         &frame,
 265                         &context,
 266                         0,
 267                         pSymFunctionTableAccess64,
 268                         pSymGetModuleBase64,
 269                         NULL))
 270         break;  // Couldn't trace back through any more frames.
 271
 272       if (frame.AddrFrame.Offset == 0)
 273         continue;  // End of stack.
 274
 275       // Push this frame's program counter onto the provided CallStack.
 276       AddFrame((DWORD_PTR)frame.AddrPC.Offset);
 277     }
 278     valid_ = true;
 279   }
 280   return true;
 281 }
 282
 283 void CallStack::ToString(PrivateAllocatorString* output) {
 284   static const int kStackWalkMaxNameLen = MAX_SYM_NAME;
 285   HANDLE current_process = GetCurrentProcess();
 286
 287   if (!LoadSymbols(current_process)) {
 288     *output = "Error";
 289     return;
 290   }
 291
 292   base::AutoLock lock(dbghelp_lock_);
 293
 294   // Iterate through each frame in the call stack.
 295   for (int32 index = 0; index < frame_count_; index++) {
 296     PrivateAllocatorString line;
 297
 298     DWORD_PTR intruction_pointer = frame(index);
 299
 300     SymbolCache::iterator it;
 301     it = symbol_cache_->find(intruction_pointer);
 302     if (it != symbol_cache_->end()) {
 303       line = it->second;
 304     } else {
 305       // Try to locate a symbol for this frame.
 306       DWORD64 symbol_displacement = 0;
 307       ULONG64 buffer[(sizeof(IMAGEHLP_SYMBOL64) +
 308                       sizeof(TCHAR)*kStackWalkMaxNameLen +
 309                       sizeof(ULONG64) - 1) / sizeof(ULONG64)];
 310       IMAGEHLP_SYMBOL64* symbol = reinterpret_cast<IMAGEHLP_SYMBOL64*>(buffer);
 311       memset(buffer, 0, sizeof(buffer));
 312       symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
 313       symbol->MaxNameLength = kStackWalkMaxNameLen;
 314       BOOL ok = pSymGetSymFromAddr64(current_process,            // hProcess
 315                                      intruction_pointer,         // Address
 316                                      &symbol_displacement,       // Displacement
 317                                      symbol);                    // Symbol
 318       if (ok) {
 319         // Try to locate more source information for the symbol.
 320         IMAGEHLP_LINE64 Line;
 321         memset(&Line, 0, sizeof(Line));
 322         Line.SizeOfStruct = sizeof(Line);
 323         DWORD line_displacement;
 324         ok = pSymGetLineFromAddr64(current_process,
 325                                    intruction_pointer,
 326                                    &line_displacement,
 327                                    &Line);
 328         if (ok) {
 329           // Skip junk symbols from our internal stuff.
 330           if (strstr(symbol->Name, "CallStack::") ||
 331               strstr(symbol->Name, "MemoryWatcher::") ||
 332               strstr(symbol->Name, "Perftools_") ||
 333               strstr(symbol->Name, "MemoryHook::") ) {
 334             // Just record a blank string.
 335             (*symbol_cache_)[intruction_pointer] = "";
 336             continue;
 337           }
 338
 339           line += "    ";
 340           line += static_cast<char*>(Line.FileName);
 341           line += " (";
 342           // TODO(jar): get something like this template to work :-/
 343           // line += IntToCustomString<PrivateAllocatorString>(Line.LineNumber);
 344           // ...and then delete this line, which uses std::string.
 345           line += base::IntToString(Line.LineNumber).c_str();
 346           line += "): ";
 347           line += symbol->Name;
 348           line += "\n";
 349         } else {
 350           line += "    unknown (0):";
 351           line += symbol->Name;
 352           line += "\n";
 353         }
 354       } else {
 355         // OK - couldn't get any info.  Try for the module.
 356         IMAGEHLP_MODULE64 module_info;
 357         module_info.SizeOfStruct = sizeof(module_info);
 358         if (pSymGetModuleInfo64(current_process, intruction_pointer,
 359                                 &module_info)) {
 360           line += "    (";
 361           line += static_cast<char*>(module_info.ModuleName);
 362           line += ")\n";
 363         } else {
 364           line += "    ???\n";
 365         }
 366       }
 367     }
 368
 369     (*symbol_cache_)[intruction_pointer] = line;
 370     *output += line;
 371   }
 372   *output += "==================\n";
 373 }
 374
 375
 376 base::Lock AllocationStack::freelist_lock_;
 377 AllocationStack* AllocationStack::freelist_ = NULL;
 378
 379 void* AllocationStack::operator new(size_t size) {
 380   DCHECK(size == sizeof(AllocationStack));
 381   {
 382     base::AutoLock lock(freelist_lock_);
 383     if (freelist_ != NULL) {
 384       AllocationStack* stack = freelist_;
 385       freelist_ = freelist_->next_;
 386       stack->next_ = NULL;
 387       return stack;
 388     }
 389   }
 390   return MemoryHook::Alloc(size);
 391 }
 392
 393 void AllocationStack::operator delete(void* ptr) {
 394   AllocationStack *stack = reinterpret_cast<AllocationStack*>(ptr);
 395   base::AutoLock lock(freelist_lock_);
 396   DCHECK(stack->next_ == NULL);
 397   stack->next_ = freelist_;
 398   freelist_ = stack;
 399 }