OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 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 "base/profiler/stack_sampling_profiler.h" |
| 6 |
| 7 #include <dbghelp.h> |
| 8 #include <map> |
| 9 #include <utility> |
| 10 #include <windows.h> |
| 11 |
| 12 #include "base/logging.h" |
| 13 #include "base/time/time.h" |
| 14 #include "base/win/pe_image.h" |
| 15 #include "base/win/scoped_handle.h" |
| 16 |
| 17 namespace base { |
| 18 |
| 19 namespace { |
| 20 |
| 21 class NativeStackSamplerWin : public StackSamplingProfiler::NativeStackSampler { |
| 22 public: |
| 23 explicit NativeStackSamplerWin(win::ScopedHandle thread_handle); |
| 24 ~NativeStackSamplerWin() override; |
| 25 |
| 26 // StackSamplingProfiler::NativeStackSampler: |
| 27 void ProfileRecordingStarting( |
| 28 StackSamplingProfiler::Profile* profile) override; |
| 29 void RecordStackSample(StackSamplingProfiler::Sample* sample) override; |
| 30 void ProfileRecordingStopped() override; |
| 31 |
| 32 private: |
| 33 static bool GetModuleInfo(HMODULE module, |
| 34 StackSamplingProfiler::Module* module_info); |
| 35 |
| 36 void CopyToSample(const void* const instruction_pointers[], |
| 37 const HMODULE modules[], |
| 38 int stack_depth, |
| 39 StackSamplingProfiler::Sample* sample, |
| 40 std::vector<StackSamplingProfiler::Module>* module_infos); |
| 41 |
| 42 win::ScopedHandle thread_handle_; |
| 43 // Weak. Points to the profile being recorded between |
| 44 // ProfileRecordingStarting() and ProfileRecordingStopped(). |
| 45 StackSamplingProfiler::Profile* current_profile_; |
| 46 // Maps a module to the module's index within current_profile_->modules. |
| 47 std::map<HMODULE, int> profile_module_index_; |
| 48 |
| 49 DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerWin); |
| 50 }; |
| 51 |
| 52 // Walk the stack represented by |context| from the current frame downwards, |
| 53 // recording the instruction pointers for each frame in |instruction_pointers|. |
| 54 int RecordStack(CONTEXT* context, |
| 55 int max_stack_size, |
| 56 const void* instruction_pointers[], |
| 57 bool* last_frame_is_unknown_function) { |
| 58 #ifdef _WIN64 |
| 59 *last_frame_is_unknown_function = false; |
| 60 |
| 61 IMAGEHLP_SYMBOL64 sym; |
| 62 sym.SizeOfStruct = sizeof(sym); |
| 63 sym.MaxNameLength = 0; |
| 64 |
| 65 for (int i = 0; i < max_stack_size; ++i) { |
| 66 // Try to look up unwind metadata for the current function. |
| 67 ULONG64 image_base; |
| 68 PRUNTIME_FUNCTION runtime_function = |
| 69 RtlLookupFunctionEntry(context->Rip, &image_base, nullptr); |
| 70 |
| 71 instruction_pointers[i] = reinterpret_cast<void*>(context->Rip); |
| 72 |
| 73 if (runtime_function) { |
| 74 KNONVOLATILE_CONTEXT_POINTERS nvcontext = {0}; |
| 75 void* handler_data; |
| 76 ULONG64 establisher_frame; |
| 77 RtlVirtualUnwind(0, image_base, context->Rip, runtime_function, context, |
| 78 &handler_data, &establisher_frame, &nvcontext); |
| 79 } else { |
| 80 // If we don't have a RUNTIME_FUNCTION, then we've encountered |
| 81 // a leaf function. Adjust the stack appropriately. |
| 82 context->Rip = *reinterpret_cast<PDWORD64>(context->Rsp); |
| 83 context->Rsp += 8; |
| 84 *last_frame_is_unknown_function = true; |
| 85 } |
| 86 |
| 87 if (!context->Rip) |
| 88 return i; |
| 89 } |
| 90 return max_stack_size; |
| 91 #else |
| 92 return 0; |
| 93 #endif |
| 94 } |
| 95 |
| 96 // Fills in |modules| corresponding to the pointers to code in |addresses|. The |
| 97 // modules are returned with reference counts incremented should be freed with |
| 98 // FreeModules. |
| 99 void FindModulesForAddresses(const void* const addresses[], HMODULE modules[], |
| 100 int stack_depth, |
| 101 bool last_frame_is_unknown_function) { |
| 102 const int module_frames = last_frame_is_unknown_function ? stack_depth - 1 : |
| 103 stack_depth; |
| 104 for (int i = 0; i < module_frames; ++i) { |
| 105 HMODULE module = NULL; |
| 106 if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, |
| 107 reinterpret_cast<LPCTSTR>(addresses[i]), |
| 108 &module)) { |
| 109 // HMODULE is the base address of the module. |
| 110 DCHECK_LT(reinterpret_cast<const void*>(module), addresses[i]); |
| 111 modules[i] = module; |
| 112 } |
| 113 } |
| 114 } |
| 115 |
| 116 // Free the modules returned by FindModulesForAddresses. |
| 117 void FreeModules(int stack_depth, HMODULE modules[]) { |
| 118 for (int i = 0; i < stack_depth; ++i) { |
| 119 if (modules[i]) |
| 120 ::FreeLibrary(modules[i]); |
| 121 } |
| 122 } |
| 123 |
| 124 // Disables priority boost on a thread for the lifetime of the object. |
| 125 class ScopedDisablePriorityBoost { |
| 126 public: |
| 127 ScopedDisablePriorityBoost(HANDLE thread_handle); |
| 128 ~ScopedDisablePriorityBoost(); |
| 129 |
| 130 private: |
| 131 HANDLE thread_handle_; |
| 132 BOOL got_previous_boost_state_; |
| 133 BOOL boost_state_was_disabled_; |
| 134 |
| 135 DISALLOW_COPY_AND_ASSIGN(ScopedDisablePriorityBoost); |
| 136 }; |
| 137 |
| 138 ScopedDisablePriorityBoost::ScopedDisablePriorityBoost(HANDLE thread_handle) |
| 139 : thread_handle_(thread_handle), |
| 140 got_previous_boost_state_(false), |
| 141 boost_state_was_disabled_(false) { |
| 142 got_previous_boost_state_ = |
| 143 ::GetThreadPriorityBoost(thread_handle_, &boost_state_was_disabled_); |
| 144 if (got_previous_boost_state_ && !boost_state_was_disabled_) { |
| 145 // Confusingly, TRUE disables priority boost ... |
| 146 ::SetThreadPriorityBoost(thread_handle_, TRUE); |
| 147 } |
| 148 } |
| 149 |
| 150 ScopedDisablePriorityBoost::~ScopedDisablePriorityBoost() { |
| 151 if (got_previous_boost_state_ && !boost_state_was_disabled_) { |
| 152 // ... and FALSE enables priority boost. |
| 153 ::SetThreadPriorityBoost(thread_handle_, FALSE); |
| 154 } |
| 155 } |
| 156 |
| 157 // Suspends the thread with |thread_handle|, records the stack into |
| 158 // |instruction_pointers|, then resumes the thread. Returns the size of the |
| 159 // stack. |
| 160 int SuspendThreadAndRecordStack(HANDLE thread_handle, int max_stack_size, |
| 161 const void* instruction_pointers[], |
| 162 bool* last_frame_is_unknown_function) { |
| 163 #if defined(_WIN64) |
| 164 if (RtlVirtualUnwind == nullptr || RtlLookupFunctionEntry == nullptr) |
| 165 return 0; |
| 166 #endif |
| 167 |
| 168 if (::SuspendThread(thread_handle) == -1) { |
| 169 LOG(ERROR) << "SuspendThread failed: " << GetLastError(); |
| 170 return 0; |
| 171 } |
| 172 |
| 173 CONTEXT thread_context = {0}; |
| 174 thread_context.ContextFlags = CONTEXT_FULL; |
| 175 if (!::GetThreadContext(thread_handle, &thread_context)) { |
| 176 LOG(ERROR) << "GetThreadContext failed: " << GetLastError(); |
| 177 } |
| 178 |
| 179 int stack_depth = RecordStack(&thread_context, max_stack_size, |
| 180 instruction_pointers, |
| 181 last_frame_is_unknown_function); |
| 182 |
| 183 { |
| 184 ScopedDisablePriorityBoost disable_priority_boost(thread_handle); |
| 185 if (::ResumeThread(thread_handle) == -1) |
| 186 LOG(ERROR) << "ResumeThread failed: " << GetLastError(); |
| 187 } |
| 188 |
| 189 return stack_depth; |
| 190 } |
| 191 |
| 192 } // namespace |
| 193 |
| 194 scoped_ptr<StackSamplingProfiler::NativeStackSampler> |
| 195 StackSamplingProfiler::NativeStackSampler::Create(PlatformThreadId thread_id) { |
| 196 #if _WIN64 |
| 197 // Get the thread's handle. |
| 198 HANDLE thread_handle = ::OpenThread( |
| 199 THREAD_GET_CONTEXT | THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION, |
| 200 FALSE, |
| 201 thread_id); |
| 202 DCHECK(thread_handle) << "OpenThread failed"; |
| 203 |
| 204 return scoped_ptr<NativeStackSampler>(new NativeStackSamplerWin( |
| 205 win::ScopedHandle(thread_handle))); |
| 206 #else |
| 207 return scoped_ptr<NativeStackSampler>(); |
| 208 #endif |
| 209 } |
| 210 |
| 211 NativeStackSamplerWin::NativeStackSamplerWin(win::ScopedHandle thread_handle) |
| 212 : thread_handle_(thread_handle.Take()) { |
| 213 #ifdef _WIN64 |
| 214 if (RtlVirtualUnwind == nullptr && RtlLookupFunctionEntry == nullptr) { |
| 215 const HMODULE nt_dll_handle = ::GetModuleHandle(L"ntdll.dll"); |
| 216 // This should always be non-null, but handle just in case. |
| 217 if (nt_dll_handle) { |
| 218 reinterpret_cast<void*&>(RtlVirtualUnwind) = |
| 219 ::GetProcAddress(nt_dll_handle, "RtlVirtualUnwind"); |
| 220 reinterpret_cast<void*&>(RtlLookupFunctionEntry) = |
| 221 ::GetProcAddress(nt_dll_handle, "RtlLookupFunctionEntry"); |
| 222 } |
| 223 } |
| 224 #endif |
| 225 } |
| 226 |
| 227 NativeStackSamplerWin::~NativeStackSamplerWin() { |
| 228 } |
| 229 |
| 230 void NativeStackSamplerWin::ProfileRecordingStarting( |
| 231 StackSamplingProfiler::Profile* profile) { |
| 232 current_profile_ = profile; |
| 233 profile_module_index_.clear(); |
| 234 } |
| 235 |
| 236 void NativeStackSamplerWin::RecordStackSample( |
| 237 StackSamplingProfiler::Sample* sample) { |
| 238 DCHECK(current_profile_); |
| 239 |
| 240 const int max_stack_size = 64; |
| 241 const void* instruction_pointers[max_stack_size] = {0}; |
| 242 HMODULE modules[max_stack_size] = {0}; |
| 243 |
| 244 bool last_frame_is_unknown_function = false; |
| 245 int stack_depth = SuspendThreadAndRecordStack( |
| 246 thread_handle_.Get(), max_stack_size, instruction_pointers, |
| 247 &last_frame_is_unknown_function); |
| 248 FindModulesForAddresses(instruction_pointers, modules, stack_depth, |
| 249 last_frame_is_unknown_function); |
| 250 CopyToSample(instruction_pointers, modules, stack_depth, sample, |
| 251 ¤t_profile_->modules); |
| 252 FreeModules(stack_depth, modules); |
| 253 } |
| 254 |
| 255 void NativeStackSamplerWin::ProfileRecordingStopped() { |
| 256 current_profile_ = nullptr; |
| 257 } |
| 258 |
| 259 // static |
| 260 bool NativeStackSamplerWin::GetModuleInfo( |
| 261 HMODULE module, |
| 262 StackSamplingProfiler::Module* module_info) { |
| 263 wchar_t module_name[MAX_PATH]; |
| 264 DWORD result_length = |
| 265 GetModuleFileName(module, module_name, arraysize(module_name)); |
| 266 if (result_length == 0) |
| 267 return false; |
| 268 |
| 269 module_info->filename = base::FilePath(module_name); |
| 270 |
| 271 module_info->base_address = reinterpret_cast<const void*>(module); |
| 272 |
| 273 GUID guid; |
| 274 DWORD age; |
| 275 win::PEImage(module).GetDebugId(&guid, &age); |
| 276 module_info->id.insert(module_info->id.end(), |
| 277 reinterpret_cast<char*>(&guid), |
| 278 reinterpret_cast<char*>(&guid + 1)); |
| 279 module_info->id.insert(module_info->id.end(), |
| 280 reinterpret_cast<char*>(&age), |
| 281 reinterpret_cast<char*>(&age + 1)); |
| 282 |
| 283 return true; |
| 284 } |
| 285 |
| 286 void NativeStackSamplerWin::CopyToSample( |
| 287 const void* const instruction_pointers[], |
| 288 const HMODULE modules[], |
| 289 int stack_depth, |
| 290 StackSamplingProfiler::Sample* sample, |
| 291 std::vector<StackSamplingProfiler::Module>* module_infos) { |
| 292 sample->clear(); |
| 293 sample->reserve(stack_depth); |
| 294 |
| 295 for (int i = 0; i < stack_depth; ++i) { |
| 296 sample->push_back(StackSamplingProfiler::Frame()); |
| 297 StackSamplingProfiler::Frame& frame = sample->back(); |
| 298 |
| 299 frame.instruction_pointer = instruction_pointers[i]; |
| 300 |
| 301 // Record an invalid module index if we don't have a valid module. |
| 302 if (!modules[i]) { |
| 303 frame.module_index = -1; |
| 304 continue; |
| 305 } |
| 306 |
| 307 auto loc = profile_module_index_.find(modules[i]); |
| 308 if (loc == profile_module_index_.end()) { |
| 309 StackSamplingProfiler::Module module_info; |
| 310 // Record an invalid module index if we have a module but can't find |
| 311 // information on it. |
| 312 if (!GetModuleInfo(modules[i], &module_info)) { |
| 313 frame.module_index = -1; |
| 314 continue; |
| 315 } |
| 316 module_infos->push_back(module_info); |
| 317 loc = profile_module_index_.insert(std::make_pair( |
| 318 modules[i], static_cast<int>(module_infos->size() - 1))).first; |
| 319 } |
| 320 |
| 321 frame.module_index = loc->second; |
| 322 } |
| 323 } |
| 324 |
| 325 } // namespace base |
OLD | NEW |