Stack sampling profiler: handle unloaded and unloading modules

base/profiler/native_stack_sampler_win.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 <objbase.h>
 #include <windows.h>
 #include <winternl.h>
 
 #include <cstdlib>
 #include <map>
@@ skipping 122 matching lines @@
   const void** end = reinterpret_cast<const void**>(
       reinterpret_cast<char*>(stack_copy) + (top - bottom));
   for (const void** loc = start; loc < end; ++loc)
     RewritePointerIfInOriginalStack(top, bottom, stack_copy, loc);
 #endif
 }
 
 // Walks the stack represented by |context| from the current frame downwards,
 // recording the instruction pointers for each frame in |instruction_pointers|.
 int RecordStack(CONTEXT* context, int max_stack_size,
-                const void* instruction_pointers[]) {
+                const void* instruction_pointers[],
+                ScopedModuleHandle modules[]) {

[brucedawson, 2015/10/30 00:15:59]

Having array function parameters is frustrating because, of course, they come in
as pointers rather than arrays, so you have to pass in the max_stack_size value.

This may be out-of-scope for this change but there is a solution which is to use
array references, like this:

    const void* (&instruction_pointers)[max_stack_size],
    ScopedModuleHandle (&modules)[max_stack_size]

where max_stack_size is not a function parameter (that parameter goes away) but
instead is an integral constant. It reduces flexibility (unless you template on
the size) but it means you get to use ARRAYSIZE() on |instruction_pointers| and
|modules|. Calling the function is simpler because you don't have to pass in the
size, and calling the function incorrectly is impossible - a wonderful feature.

Food for thought.

[Mike Wittman, 2015/10/30 17:08:07]

That's a nice alternative, but unfortunately it would violate the style guide
here since mutable reference parameters are prohibited. I suppose the parameters
could be passed by pointer but that might be more confusing than its worth.

In any case, these will probably get changed to vectors in a future CL since
this code no longer is restricted from doing memory allocation.

 #ifdef _WIN64
   Win32StackFrameUnwinder frame_unwinder;
   int i = 0;
   for (; (i < max_stack_size) && context->Rip; ++i) {
     instruction_pointers[i] = reinterpret_cast<const void*>(context->Rip);
-    if (!frame_unwinder.TryUnwind(context))
+    if (!frame_unwinder.TryUnwind(context, &modules[i]))
       return i + 1;
   }
   return i;
 #else
   return 0;
 #endif
 }
 
-// Fills in |module_handles| corresponding to the pointers to code in
-// |addresses|. The module handles are returned with reference counts
-// incremented and should be freed with FreeModuleHandles. See note in
-// SuspendThreadAndRecordStack for why |addresses| and |module_handles| are
-// arrays.
-void FindModuleHandlesForAddresses(const void* const addresses[],
-                                   HMODULE module_handles[], int stack_depth) {
-  for (int i = 0; i < stack_depth; ++i) {
-    HMODULE module_handle = NULL;
-    if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
-                          reinterpret_cast<LPCTSTR>(addresses[i]),
-                          &module_handle)) {
-      // HMODULE actually represents the base address of the module, so we can
-      // use it directly as an address.
-      DCHECK_LE(reinterpret_cast<const void*>(module_handle), addresses[i]);
-      module_handles[i] = module_handle;
-    }
-  }
-}
-
-// Frees the modules handles returned by FindModuleHandlesForAddresses. See note
-// in SuspendThreadAndRecordStack for why |module_handles| is an array.
-void FreeModuleHandles(int stack_depth, HMODULE module_handles[]) {
-  for (int i = 0; i < stack_depth; ++i) {
-    if (module_handles[i])
-      ::FreeLibrary(module_handles[i]);
-  }
-}
-
 // Gets the unique build ID for a module. Windows build IDs are created by a
 // concatenation of a GUID and AGE fields found in the headers of a module. The
 // GUID is stored in the first 16 bytes and the AGE is stored in the last 4
 // bytes. Returns the empty string if the function fails to get the build ID.
 //
 // Example:
 // dumpbin chrome.exe /headers | find "Format:"
 //   ... Format: RSDS, {16B2A428-1DED-442E-9A36-FCE8CBD29726}, 10, ...
 //
 // The resulting buildID string of this instance of chrome.exe is
 // "16B2A4281DED442E9A36FCE8CBD2972610".
 //
 // Note that the AGE field is encoded in decimal, not hex.

[brucedawson, 2015/10/30 00:15:59]

Unless you are using it for symbol server purposes when it is hexadecimal.
Sigh...

[Mike Wittman, 2015/10/30 17:08:07]

Yeah, it needs to be this way to match the server-side implementation. I can't
see us interacting with symbol servers on the client, so chances for confusion
are likely pretty low.

 std::string GetBuildIDForModule(HMODULE module_handle) {
   GUID guid;
   DWORD age;
   win::PEImage(module_handle).GetDebugId(&guid, &age);
   const int kGUIDSize = 39;
   std::wstring build_id;
   int result =
       ::StringFromGUID2(guid, WriteInto(&build_id, kGUIDSize), kGUIDSize);
   if (result != kGUIDSize)
     return std::string();
@@ skipping 83 matching lines @@
 // IMPORTANT NOTE: No allocations from the default heap may occur in the
 // ScopedSuspendThread scope, including indirectly via use of DCHECK/CHECK or
 // other logging statements. Otherwise this code can deadlock on heap locks in
 // the default heap acquired by the target thread before it was suspended. This
 // is why we pass instruction pointers as preallocated arrays.
 int SuspendThreadAndRecordStack(HANDLE thread_handle,
                                 const void* base_address,
                                 void* stack_copy_buffer,
                                 size_t stack_copy_buffer_size,
                                 int max_stack_size,
-                                const void* instruction_pointers[]) {
+                                const void* instruction_pointers[],
+                                ScopedModuleHandle modules[],
+                                NativeStackSamplerTestDelegate* test_delegate) {
   CONTEXT thread_context = {0};
   thread_context.ContextFlags = CONTEXT_FULL;
   // The stack bounds are saved to uintptr_ts for use outside
   // ScopedSuspendThread, as the thread's memory is not safe to dereference
   // beyond that point.
   const uintptr_t top = reinterpret_cast<uintptr_t>(base_address);
   uintptr_t bottom = 0u;
 
   {
     ScopedSuspendThread suspend_thread(thread_handle);
 
     if (!suspend_thread.was_successful())
       return 0;
 
     if (!::GetThreadContext(thread_handle, &thread_context))
       return 0;
 #if defined(_WIN64)
     bottom = thread_context.Rsp;
 #else
     bottom = thread_context.Esp;
 #endif
 
     if ((top - bottom) > stack_copy_buffer_size)
       return 0;
 
     std::memcpy(stack_copy_buffer, reinterpret_cast<const void*>(bottom),
                 top - bottom);
   }
 
+  if (test_delegate)
+    test_delegate->OnPreStackWalk();
+
   RewritePointersToStackMemory(top, bottom, &thread_context, stack_copy_buffer);
 
-  return RecordStack(&thread_context, max_stack_size, instruction_pointers);
+  return RecordStack(&thread_context, max_stack_size, instruction_pointers,
+                     modules);
 }
 
 // NativeStackSamplerWin ------------------------------------------------------
 
 class NativeStackSamplerWin : public NativeStackSampler {
  public:
-  explicit NativeStackSamplerWin(win::ScopedHandle thread_handle);
+  NativeStackSamplerWin(win::ScopedHandle thread_handle,
+                        NativeStackSamplerTestDelegate* test_delegate);
   ~NativeStackSamplerWin() override;
 
   // StackSamplingProfiler::NativeStackSampler:
   void ProfileRecordingStarting(
       std::vector<StackSamplingProfiler::Module>* modules) override;
   void RecordStackSample(StackSamplingProfiler::Sample* sample) override;
   void ProfileRecordingStopped() override;
 
  private:
   enum {
@@ skipping 13 matching lines @@
   // Gets the index for the Module corresponding to |module_handle| in
   // |modules|, adding it if it's not already present. Returns
   // StackSamplingProfiler::Frame::kUnknownModuleIndex if no Module can be
   // determined for |module|.
   size_t GetModuleIndex(HMODULE module_handle,
                         std::vector<StackSamplingProfiler::Module>* modules);
 
   // Copies the stack information represented by |instruction_pointers| into
   // |sample| and |modules|.
   void CopyToSample(const void* const instruction_pointers[],
-                    const HMODULE module_handles[],
+                    const ScopedModuleHandle module_handles[],
                     int stack_depth,
                     StackSamplingProfiler::Sample* sample,
                     std::vector<StackSamplingProfiler::Module>* modules);
 
   win::ScopedHandle thread_handle_;
 
+  NativeStackSamplerTestDelegate* const test_delegate_;
+
   // The stack base address corresponding to |thread_handle_|.
   const void* const thread_stack_base_address_;
 
   // Buffer to use for copies of the stack. We use the same buffer for all the
   // samples to avoid the overhead of multiple allocations and frees.
   const scoped_ptr<unsigned char[]> stack_copy_buffer_;
 
   // Weak. Points to the modules associated with the profile being recorded
   // between ProfileRecordingStarting() and ProfileRecordingStopped().
   std::vector<StackSamplingProfiler::Module>* current_modules_;
 
   // Maps a module handle to the corresponding Module's index within
   // current_modules_.
   std::map<HMODULE, size_t> profile_module_index_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerWin);
 };
 
-NativeStackSamplerWin::NativeStackSamplerWin(win::ScopedHandle thread_handle)
-    : thread_handle_(thread_handle.Take()),
+NativeStackSamplerWin::NativeStackSamplerWin(
+    win::ScopedHandle thread_handle,
+    NativeStackSamplerTestDelegate* test_delegate)
+    : thread_handle_(thread_handle.Take()), test_delegate_(test_delegate),
       thread_stack_base_address_(
           GetThreadEnvironmentBlock(thread_handle_.Get())->Tib.StackBase),
       stack_copy_buffer_(new unsigned char[kStackCopyBufferSize]) {
 }
 
 NativeStackSamplerWin::~NativeStackSamplerWin() {
 }
 
 void NativeStackSamplerWin::ProfileRecordingStarting(
     std::vector<StackSamplingProfiler::Module>* modules) {
   current_modules_ = modules;
   profile_module_index_.clear();
 }
 
 void NativeStackSamplerWin::RecordStackSample(
     StackSamplingProfiler::Sample* sample) {
   DCHECK(current_modules_);
 
   if (!stack_copy_buffer_)
     return;
 
   const int max_stack_size = 64;
   const void* instruction_pointers[max_stack_size] = {0};
-  HMODULE module_handles[max_stack_size] = {0};
+  ScopedModuleHandle modules[max_stack_size];
 
   int stack_depth = SuspendThreadAndRecordStack(thread_handle_.Get(),
                                                 thread_stack_base_address_,
                                                 stack_copy_buffer_.get(),
                                                 kStackCopyBufferSize,
                                                 max_stack_size,
-                                                instruction_pointers);
-  FindModuleHandlesForAddresses(instruction_pointers, module_handles,
-                                stack_depth);
-  CopyToSample(instruction_pointers, module_handles, stack_depth, sample,
+                                                instruction_pointers,
+                                                modules,
+                                                test_delegate_);
+  CopyToSample(instruction_pointers, modules, stack_depth, sample,
                current_modules_);
-  FreeModuleHandles(stack_depth, module_handles);
 }
 
 void NativeStackSamplerWin::ProfileRecordingStopped() {
   current_modules_ = nullptr;
 }
 
 // static
 bool NativeStackSamplerWin::GetModuleForHandle(
     HMODULE module_handle,
     StackSamplingProfiler::Module* module) {
@@ skipping 28 matching lines @@
     modules->push_back(module);
     loc = profile_module_index_.insert(std::make_pair(
         module_handle, modules->size() - 1)).first;
   }
 
   return loc->second;
 }
 
 void NativeStackSamplerWin::CopyToSample(
     const void* const instruction_pointers[],
-    const HMODULE module_handles[],
+    const ScopedModuleHandle module_handles[],
     int stack_depth,
     StackSamplingProfiler::Sample* sample,
-    std::vector<StackSamplingProfiler::Module>* module) {
+    std::vector<StackSamplingProfiler::Module>* modules) {
   sample->clear();
   sample->reserve(stack_depth);
 
   for (int i = 0; i < stack_depth; ++i) {
     sample->push_back(StackSamplingProfiler::Frame(
         reinterpret_cast<uintptr_t>(instruction_pointers[i]),
-        GetModuleIndex(module_handles[i], module)));
+        GetModuleIndex(module_handles[i].Get(), modules)));
   }
 }
 
 }  // namespace
 
 scoped_ptr<NativeStackSampler> NativeStackSampler::Create(
-    PlatformThreadId thread_id) {
+    PlatformThreadId thread_id,
+    NativeStackSamplerTestDelegate* test_delegate) {
 #if _WIN64
   // Get the thread's handle.
   HANDLE thread_handle = ::OpenThread(
       THREAD_GET_CONTEXT | THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION,
       FALSE,
       thread_id);
 
   if (thread_handle) {
     return scoped_ptr<NativeStackSampler>(new NativeStackSamplerWin(
-        win::ScopedHandle(thread_handle)));
+        win::ScopedHandle(thread_handle),
+        test_delegate));
   }
 #endif
   return scoped_ptr<NativeStackSampler>();
 }
 
 }  // namespace base