Support running memory watch under vista, plus other tweaks...

tools/memory_watcher/call_stack.cc

 // Copyright (c) 2006-2008 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 "call_stack.h"
 #include <shlwapi.h>
 #include <tlhelp32.h>
 
 #include "memory_hook.h"
 #include "base/string_util.h"
@@ skipping 15 matching lines @@
                                                  PIMAGEHLP_LINE64);
 typedef BOOL (__stdcall *t_SymInitialize)(HANDLE, PCTSTR, BOOL);
 typedef DWORD (__stdcall *t_SymGetOptions)(void);
 typedef DWORD (__stdcall *t_SymSetOptions)(DWORD);
 typedef BOOL (__stdcall *t_SymGetSearchPath)(HANDLE, PTSTR, DWORD);
 typedef DWORD64 (__stdcall *t_SymLoadModule64)(HANDLE, HANDLE, PCSTR,
                                                PCSTR, DWORD64, DWORD);
 typedef BOOL (__stdcall *t_SymGetModuleInfo64)(HANDLE, DWORD64,
                                                PIMAGEHLP_MODULE64);
 
-// According to http://msdn2.microsoft.com/en-us/library/ms680650(VS.85).aspx
-// "All DbgHelp functions, such as this one, are single threaded.  Therefore,
-// calls from more than one thread to this function will likely result in
-// unexpected behavior or memory corruption.  To avoid this, you must
-// synchromize all concurrent calls from one thread to this function."
-//
-// dbghelp_lock_ is used to serialize access across all calls to the DbgHelp
-// library.  This may be overly conservative (serializing them all together),
-// but does guarantee correctness.
-static Lock dbghelp_lock_;
+// static
+Lock CallStack::dbghelp_lock_;
+// static
+bool CallStack::dbghelp_loaded_ = false;
+// static
+DWORD CallStack::active_thread_id_ = 0;
+
 
 static t_StackWalk64 pStackWalk64 = NULL;
 static t_SymCleanup pSymCleanup = NULL;
 static t_SymGetSymFromAddr64 pSymGetSymFromAddr64 = NULL;
 static t_SymFunctionTableAccess64 pSymFunctionTableAccess64 = NULL;
 static t_SymGetModuleBase64 pSymGetModuleBase64 = NULL;
 static t_SymGetLineFromAddr64 pSymGetLineFromAddr64 = NULL;
 static t_SymInitialize pSymInitialize = NULL;
 static t_SymGetOptions pSymGetOptions = NULL;
 static t_SymSetOptions pSymSetOptions = NULL;
 static t_SymGetModuleInfo64 pSymGetModuleInfo64 = NULL;
 static t_SymGetSearchPath pSymGetSearchPath = NULL;
 static t_SymLoadModule64 pSymLoadModule64 = NULL;
 
 #define LOADPROC(module, name)  do {                                    \
   p##name = reinterpret_cast<t_##name>(GetProcAddress(module, #name));  \
   if (p##name == NULL) return false;                                    \
 } while (0)
 
-// Dynamically load the DbgHelp library and supporting routines that we
-// will use.
-static bool LoadDbgHelp() {
-  static bool loaded = false;
-  if (!loaded) {
+// This code has to be VERY careful to not induce any allocations, as memory
+// watching code may cause recursion, which may obscure the stack for the truly
+// offensive issue.  We use this function to break into a debugger, and it
+// is guaranteed to not do any allocations (in fact, not do anything).
+static void UltraSafeDebugBreak() {
+  _asm int(3);
+}
+
+// static
+bool CallStack::LoadDbgHelp() {
+  if (!dbghelp_loaded_) {
     AutoLock Lock(dbghelp_lock_);
 
     // Re-check if we've loaded successfully now that we have the lock.
-    if (loaded)
+    if (dbghelp_loaded_)
       return true;
 
     // Load dbghelp.dll, and obtain pointers to the exported functions that we
     // will be using.
     HMODULE dbghelp_module = LoadLibrary(L"dbghelp.dll");
     if (dbghelp_module) {
       LOADPROC(dbghelp_module, StackWalk64);
       LOADPROC(dbghelp_module, SymFunctionTableAccess64);
       LOADPROC(dbghelp_module, SymGetModuleBase64);
       LOADPROC(dbghelp_module, SymCleanup);
       LOADPROC(dbghelp_module, SymGetSymFromAddr64);
       LOADPROC(dbghelp_module, SymGetLineFromAddr64);
       LOADPROC(dbghelp_module, SymInitialize);
       LOADPROC(dbghelp_module, SymGetOptions);
       LOADPROC(dbghelp_module, SymSetOptions);
       LOADPROC(dbghelp_module, SymGetModuleInfo64);
       LOADPROC(dbghelp_module, SymGetSearchPath);
       LOADPROC(dbghelp_module, SymLoadModule64);
-      loaded = true;
+      dbghelp_loaded_ = true;
     } else {
+      UltraSafeDebugBreak();
       return false;
     }
   }
-  return loaded;
+  return dbghelp_loaded_;
 }
 
 // Load the symbols for generating stack traces.
 static bool LoadSymbols(HANDLE process_handle) {
   static bool symbols_loaded = false;
   if (symbols_loaded) return true;
 
   BOOL ok;
 
   // Initialize the symbol engine.
@@ skipping 53 matching lines @@
   // the MemoryHook heap is alive.
   symbol_cache_ = new SymbolCache();
   return LoadDbgHelp();
 }
 
 CallStack::CallStack() {
   static LONG callstack_id = 0;
   frame_count_ = 0;
   hash_ = 0;
   id_ = InterlockedIncrement(&callstack_id);
+  valid_ = false;
 
-  LoadDbgHelp();
-  CHECK(GetStackTrace());
+  if (!dbghelp_loaded_) {
+    UltraSafeDebugBreak();  // Initialize should have been called.
+    return;
+  }
+
+  GetStackTrace();
 }
 
 bool CallStack::IsEqual(const CallStack &target) {
   if (frame_count_ != target.frame_count_)
     return false;  // They can't be equal if the sizes are different.
 
   // Walk the frames array until we
   // either find a mismatch, or until we reach the end of the call stacks.
   for (int index = 0; index < frame_count_; index++) {
     if (frames_[index] != target.frames_[index])
@@ skipping 11 matching lines @@
   // Create a unique id for this CallStack.
   pc = pc + (frame_count_ * 13);  // Alter the PC based on position in stack.
   hash_ = ~hash_ + (pc << 15);
   hash_ = hash_ ^ (pc >> 12);
   hash_ = hash_ + (pc << 2);
   hash_ = hash_ ^ (pc >> 4);
   hash_ = hash_ * 2057;
   hash_ = hash_ ^ (pc >> 16);
 }
 
+bool CallStack::LockedRecursionDetected() const {
+  if (!active_thread_id_) return false;
+  DWORD thread_id = GetCurrentThreadId();
+  // TODO(jar): Perchance we should use atomic access to member.
+  return thread_id == active_thread_id_;
+}
+
 bool CallStack::GetStackTrace() {
+  if (LockedRecursionDetected())
+    return false;
+
   // Initialize the context record.
   CONTEXT context;
   memset(&context, 0, sizeof(context));
   context.ContextFlags = CONTEXT_FULL;
   __asm    call x
   __asm x: pop eax
   __asm    mov context.Eip, eax
   __asm    mov context.Ebp, ebp
   __asm    mov context.Esp, esp
 
@@ skipping 11 matching lines @@
 #elif
   NOT IMPLEMENTED!
 #endif
 
   HANDLE current_process = GetCurrentProcess();
   HANDLE current_thread = GetCurrentThread();
 
   // Walk the stack.
   unsigned int count = 0;
   {
-    AutoLock lock(dbghelp_lock_);
+    AutoDbgHelpLock thread_monitoring_lock;
 
     while (count < kMaxTraceFrames) {
       count++;
       if (!pStackWalk64(image_type,
                         current_process,
                         current_thread,
                         &frame,
                         &context,
                         0,
                         pSymFunctionTableAccess64,
                         pSymGetModuleBase64,
                         NULL))
         break;  // Couldn't trace back through any more frames.
 
       if (frame.AddrFrame.Offset == 0)
         continue;  // End of stack.
 
       // Push this frame's program counter onto the provided CallStack.
       AddFrame((DWORD_PTR)frame.AddrPC.Offset);
     }
+    valid_ = true;
   }
   return true;
 }
 
-void CallStack::ToString(std::string* output) {
+void CallStack::ToString(PrivateAllocatorString* output) {
   static const int kStackWalkMaxNameLen = MAX_SYM_NAME;
   HANDLE current_process = GetCurrentProcess();
 
   if (!LoadSymbols(current_process)) {
     *output = "Error";
     return;
   }
 
   AutoLock lock(dbghelp_lock_);
 
   // Iterate through each frame in the call stack.
   for (int32 index = 0; index < frame_count_; index++) {
-    std::string line;
+    PrivateAllocatorString line;
 
     DWORD_PTR intruction_pointer = frame(index);
 
     SymbolCache::iterator it;
-    it = symbol_cache_->find( intruction_pointer );
+    it = symbol_cache_->find(intruction_pointer);
     if (it != symbol_cache_->end()) {
       line = it->second;
     } else {
       // Try to locate a symbol for this frame.
       DWORD64 symbol_displacement = 0;
       ULONG64 buffer[(sizeof(IMAGEHLP_SYMBOL64) +
                       sizeof(TCHAR)*kStackWalkMaxNameLen +
                       sizeof(ULONG64) - 1) / sizeof(ULONG64)];
       IMAGEHLP_SYMBOL64* symbol = reinterpret_cast<IMAGEHLP_SYMBOL64*>(buffer);
       memset(buffer, 0, sizeof(buffer));
@@ skipping 13 matching lines @@
                                    intruction_pointer,
                                    &line_displacement,
                                    &Line);
         if (ok) {
           // Skip junk symbols from our internal stuff.
           if (strstr(symbol->Name, "CallStack::") ||
               strstr(symbol->Name, "MemoryWatcher::") ||
               strstr(symbol->Name, "Perftools_") ||
               strstr(symbol->Name, "MemoryHook::") ) {
             // Just record a blank string.
-            (*symbol_cache_)[intruction_pointer] = std::string("");
+            (*symbol_cache_)[intruction_pointer] = "";
             continue;
           }
 
           line += "    ";
           line += static_cast<char*>(Line.FileName);
           line += " (";
-          line += IntToString(Line.LineNumber);
+          // TODO(jar): get something like this template to work :-/
+          // line += IntToCustomString<PrivateAllocatorString>(Line.LineNumber);
+          // ...and then delete this line, which uses std::string.
+          line += IntToString(Line.LineNumber).c_str();
           line += "): ";
           line += symbol->Name;
           line += "\n";
         } else {
           line += "    unknown (0):";
           line += symbol->Name;
           line += "\n";
         }
       } else {
         // OK - couldn't get any info.  Try for the module.
@@ skipping 34 matching lines @@
   return MemoryHook::Alloc(size);
 }
 
 void AllocationStack::operator delete(void* ptr) {
   AllocationStack *stack = reinterpret_cast<AllocationStack*>(ptr);
   AutoLock lock(freelist_lock_);
   DCHECK(stack->next_ == NULL);
   stack->next_ = freelist_;
   freelist_ = stack;
 }