Stack sampling profiler: handle unloaded and unloading modules

base/profiler/win32_stack_frame_unwinder.cc

 // Copyright 2015 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/profiler/win32_stack_frame_unwinder.h"
 
+#include <windows.h>
+
 #include "base/containers/hash_tables.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 
 namespace base {
 
 // Win32UnwindFunctions -------------------------------------------------------
 
+const HMODULE ModuleHandleTraits::kNonNullModuleForTesting =
+    reinterpret_cast<HMODULE>(static_cast<uintptr_t>(-1));
+
+// static
+bool ModuleHandleTraits::CloseHandle(HMODULE handle) {
+  if (handle == kNonNullModuleForTesting)
+    return true;
+
+  return ::FreeLibrary(handle) != 0;
+}
+
+// static
+bool ModuleHandleTraits::IsHandleValid(HMODULE handle) {
+  return handle != nullptr;
+}
+
+// static
+HMODULE ModuleHandleTraits::NullHandle() {
+  return nullptr;
+}
+
 namespace {
 
 // Implements the UnwindFunctions interface for the corresponding Win32
 // functions.
 class Win32UnwindFunctions : public Win32StackFrameUnwinder::UnwindFunctions {
 public:
   Win32UnwindFunctions();
   ~Win32UnwindFunctions() override;
 
   PRUNTIME_FUNCTION LookupFunctionEntry(DWORD64 program_counter,
                                         PDWORD64 image_base) override;
 
   void VirtualUnwind(DWORD64 image_base,
                      DWORD64 program_counter,
                      PRUNTIME_FUNCTION runtime_function,
                      CONTEXT* context) override;
 
+  ScopedModuleHandle GetModuleForProgramCounter(
+      DWORD64 program_counter) override;
+
 private:
   DISALLOW_COPY_AND_ASSIGN(Win32UnwindFunctions);
 };
 
 Win32UnwindFunctions::Win32UnwindFunctions() {}
 Win32UnwindFunctions::~Win32UnwindFunctions() {}
 
 PRUNTIME_FUNCTION Win32UnwindFunctions::LookupFunctionEntry(
     DWORD64 program_counter,
     PDWORD64 image_base) {
@@ skipping 14 matching lines @@
   ULONG64 establisher_frame;
   KNONVOLATILE_CONTEXT_POINTERS nvcontext = {};
   RtlVirtualUnwind(UNW_FLAG_NHANDLER, image_base, program_counter,
                    runtime_function, context, &handler_data,
                    &establisher_frame, &nvcontext);
 #else
   NOTREACHED();
 #endif
 }
 
+ScopedModuleHandle Win32UnwindFunctions::GetModuleForProgramCounter(
+    DWORD64 program_counter) {
+  HMODULE module_handle = nullptr;
+  // GetModuleHandleEx() increments the module reference count, which is then
+  // managed and ultimately decremented by ScopedModuleHandle.
+  if (!::GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+                           reinterpret_cast<LPCTSTR>(program_counter),
+                           &module_handle)) {
+    const DWORD error = ::GetLastError();
+    DCHECK_EQ(ERROR_MOD_NOT_FOUND, static_cast<int>(error));
+  }
+  return ScopedModuleHandle(module_handle);
+}
+
 // LeafUnwindBlacklist --------------------------------------------------------
 
 // Records modules that are known to have functions that violate the Microsoft
 // x64 calling convention and would be dangerous to manually unwind if
 // encountered as the last frame on the call stack. Functions like these have
 // been observed in injected third party modules that either do not provide
 // function unwind information, or do not provide the required function prologue
 // and epilogue. The former case was observed in several AV products and the
 // latter in a WndProc function associated with Actual Window
 // Manager/aimemb64.dll. See https://crbug.com/476422.
@@ skipping 57 matching lines @@
 
 Win32StackFrameUnwinder::UnwindFunctions::~UnwindFunctions() {}
 Win32StackFrameUnwinder::UnwindFunctions::UnwindFunctions() {}
 
 Win32StackFrameUnwinder::Win32StackFrameUnwinder()
     : Win32StackFrameUnwinder(make_scoped_ptr(new Win32UnwindFunctions)) {
 }
 
 Win32StackFrameUnwinder::~Win32StackFrameUnwinder() {}
 
-bool Win32StackFrameUnwinder::TryUnwind(CONTEXT* context) {
+bool Win32StackFrameUnwinder::TryUnwind(CONTEXT* context,
+                                        ScopedModuleHandle* module) {
 #ifdef _WIN64
   CHECK(!at_top_frame_ || unwind_info_present_for_all_frames_);
 
+  ScopedModuleHandle frame_module =
+      unwind_functions_->GetModuleForProgramCounter(context->Rip);
+  // The module may have been unloaded since we recorded the stack. Note that if
+  // this check detects module as valid, it still could be a different module at
+  // the same instruction pointer address (i.e. if the module was unloaded and a
+  // different module loaded in overlapping memory). This should occur extremely
+  // rarely.
+  if (!frame_module.IsValid())
+    return false;
+
   ULONG64 image_base;
   // Try to look up unwind metadata for the current function.
   PRUNTIME_FUNCTION runtime_function =
       unwind_functions_->LookupFunctionEntry(context->Rip, &image_base);
 
   if (runtime_function) {
     if (!SanityCheckRuntimeFunction(runtime_function, image_base, context->Rip))
       return false;
 
     unwind_functions_->VirtualUnwind(image_base, context->Rip, runtime_function,
@@ skipping 65 matching lines @@
         // frame is case 2. But it's possible that the initial frame was case
         // 2 but hadn't been blacklisted yet, and we've started to go off into
         // the weeds. Since we can't be sure, just bail out without
         // blacklisting the module; chances are we'll later encounter the same
         // function on a stack with full unwind information.
       }
       return false;
     }
   }
 
+  module->Set(frame_module.Take());
   return true;
 #else
   NOTREACHED();
   return false;
 #endif
 }
 
 Win32StackFrameUnwinder::Win32StackFrameUnwinder(
     scoped_ptr<UnwindFunctions> unwind_functions)
     : at_top_frame_(true),
       unwind_info_present_for_all_frames_(true),
       unwind_functions_(unwind_functions.Pass()) {
 }
 
 }  // namespace base