Add process lifetime annotations to stack samples.

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 "base/profiler/native_stack_sampler.h"
 
 #include <objbase.h>
 #include <windows.h>
 #include <stddef.h>
 #include <winternl.h>
@@ skipping 301 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.
 void SuspendThreadAndRecordStack(
     HANDLE thread_handle,
     const void* base_address,
     void* stack_copy_buffer,
     size_t stack_copy_buffer_size,
     std::vector<RecordedFrame>* stack,
+    NativeStackSampler::AnnotateCallback annotator,
+    StackSamplingProfiler::Sample* sample,
     NativeStackSamplerTestDelegate* test_delegate) {
   DCHECK(stack->empty());
 
   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;
@@ skipping 14 matching lines @@
 
     if ((top - bottom) > stack_copy_buffer_size)
       return;
 
     // Dereferencing a pointer in the guard page in a thread that doesn't own
     // the stack results in a STATUS_GUARD_PAGE_VIOLATION exception and a crash.
     // This occurs very rarely, but reliably over the population.
     if (PointsToGuardPage(bottom))
       return;
 
+    (*annotator)(sample);
+
     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);
 
   RecordStack(&thread_context, stack);
 }
 
 // NativeStackSamplerWin ------------------------------------------------------
 
 class NativeStackSamplerWin : public NativeStackSampler {
  public:
   NativeStackSamplerWin(win::ScopedHandle thread_handle,
+                        AnnotateCallback annotator,
                         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:
@@ skipping 18 matching lines @@
   size_t GetModuleIndex(HMODULE module_handle,
                         std::vector<StackSamplingProfiler::Module>* modules);
 
   // Copies the information represented by |stack| into |sample| and |modules|.
   void CopyToSample(const std::vector<RecordedFrame>& stack,
                     StackSamplingProfiler::Sample* sample,
                     std::vector<StackSamplingProfiler::Module>* modules);
 
   win::ScopedHandle thread_handle_;
 
+  const AnnotateCallback annotator_;
+
   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 std::unique_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,
+    AnnotateCallback annotator,
     NativeStackSamplerTestDelegate* test_delegate)
-    : thread_handle_(thread_handle.Take()), test_delegate_(test_delegate),
+    : thread_handle_(thread_handle.Take()),
+      annotator_(annotator),
+      test_delegate_(test_delegate),
       thread_stack_base_address_(
           GetThreadEnvironmentBlock(thread_handle_.Get())->Tib.StackBase),
       stack_copy_buffer_(new unsigned char[kStackCopyBufferSize]) {
+  DCHECK(annotator_);
 }
 
 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;
 
   std::vector<RecordedFrame> stack;
   SuspendThreadAndRecordStack(thread_handle_.Get(), thread_stack_base_address_,
                               stack_copy_buffer_.get(), kStackCopyBufferSize,
-                              &stack, test_delegate_);
+                              &stack, annotator_, sample, test_delegate_);
   CopyToSample(stack, sample, current_modules_);
 }
 
 void NativeStackSamplerWin::ProfileRecordingStopped() {
   current_modules_ = nullptr;
 }
 
 // static
 bool NativeStackSamplerWin::GetModuleForHandle(
     HMODULE module_handle,
@@ skipping 31 matching lines @@
         module_handle, modules->size() - 1)).first;
   }
 
   return loc->second;
 }
 
 void NativeStackSamplerWin::CopyToSample(
     const std::vector<RecordedFrame>& stack,
     StackSamplingProfiler::Sample* sample,
     std::vector<StackSamplingProfiler::Module>* modules) {
-  sample->clear();
-  sample->reserve(stack.size());
+  sample->frames.clear();
+  sample->frames.reserve(stack.size());
 
   for (const RecordedFrame& frame : stack) {
-    sample->push_back(StackSamplingProfiler::Frame(
+    sample->frames.push_back(StackSamplingProfiler::Frame(
         reinterpret_cast<uintptr_t>(frame.instruction_pointer),
         GetModuleIndex(frame.module.Get(), modules)));
   }
 }
 
 }  // namespace
 
 std::unique_ptr<NativeStackSampler> NativeStackSampler::Create(
     PlatformThreadId thread_id,
+    AnnotateCallback annotator,
     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 std::unique_ptr<NativeStackSampler>(new NativeStackSamplerWin(
-        win::ScopedHandle(thread_handle), test_delegate));
+        win::ScopedHandle(thread_handle), annotator, test_delegate));
   }
 #endif
   return std::unique_ptr<NativeStackSampler>();
 }
 
 }  // namespace base