| // 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/trace_event/winheap_dump_provider_win.h" |
| |
| #include <windows.h> |
| |
| #include "base/trace_event/process_memory_dump.h" |
| #include "base/win/windows_version.h" |
| |
| namespace base { |
| namespace trace_event { |
| |
| namespace { |
| |
| // Report a heap dump to a process memory dump. The |heap_info| structure |
| // contains the information about this heap, and |dump_absolute_name| will be |
| // used to represent it in the report. |
| void ReportHeapDump(ProcessMemoryDump* pmd, |
| const WinHeapInfo& heap_info, |
| const std::string& dump_absolute_name) { |
| MemoryAllocatorDump* outer_dump = |
| pmd->CreateAllocatorDump(dump_absolute_name); |
| outer_dump->AddScalar(MemoryAllocatorDump::kNameSize, |
| MemoryAllocatorDump::kUnitsBytes, |
| heap_info.committed_size); |
| |
| MemoryAllocatorDump* inner_dump = |
| pmd->CreateAllocatorDump(dump_absolute_name + "/allocated_objects"); |
| inner_dump->AddScalar(MemoryAllocatorDump::kNameSize, |
| MemoryAllocatorDump::kUnitsBytes, |
| heap_info.allocated_size); |
| inner_dump->AddScalar(MemoryAllocatorDump::kNameObjectsCount, |
| MemoryAllocatorDump::kUnitsObjects, |
| heap_info.block_count); |
| } |
| |
| } // namespace |
| |
| WinHeapDumpProvider* WinHeapDumpProvider::GetInstance() { |
| return Singleton<WinHeapDumpProvider, |
| LeakySingletonTraits<WinHeapDumpProvider>>::get(); |
| } |
| |
| bool WinHeapDumpProvider::OnMemoryDump(ProcessMemoryDump* pmd) { |
| // This method might be flaky for 2 reasons: |
| // - GetProcessHeaps is racy by design. It returns a snapshot of the |
| // available heaps, but there's no guarantee that that snapshot remains |
| // valid. If a heap disappears between GetProcessHeaps() and HeapWalk() |
| // then chaos should be assumed. This flakyness is acceptable for tracing. |
| // - The MSDN page for HeapLock says: "If the HeapLock function is called on |
| // a heap created with the HEAP_NO_SERIALIZATION flag, the results are |
| // undefined.". This is a problem on Windows XP where some system DLLs are |
| // known for creating heaps with this particular flag. For this reason |
| // this function should be disabled on XP. |
| // |
| // See https://crbug.com/487291 for more details about this. |
| if (base::win::GetVersion() < base::win::VERSION_VISTA) |
| return false; |
| |
| // Retrieves the number of heaps in the current process. |
| DWORD number_of_heaps = ::GetProcessHeaps(0, NULL); |
| WinHeapInfo all_heap_info = {0}; |
| |
| // Try to retrieve a handle to all the heaps owned by this process. Returns |
| // false if the number of heaps has changed. |
| // |
| // This is inherently racy as is, but it's not something that we observe a lot |
| // in Chrome, the heaps tend to be created at startup only. |
| scoped_ptr<HANDLE[]> all_heaps(new HANDLE[number_of_heaps]); |
| if (::GetProcessHeaps(number_of_heaps, all_heaps.get()) != number_of_heaps) |
| return false; |
| |
| // Skip the pointer to the heap array to avoid accounting the memory used by |
| // this dump provider. |
| std::set<void*> block_to_skip; |
| block_to_skip.insert(all_heaps.get()); |
| |
| // Retrieves some metrics about each heap. |
| for (size_t i = 0; i < number_of_heaps; ++i) { |
| WinHeapInfo heap_info = {0}; |
| heap_info.heap_id = all_heaps[i]; |
| GetHeapInformation(&heap_info, block_to_skip); |
| |
| all_heap_info.allocated_size += heap_info.allocated_size; |
| all_heap_info.committed_size += heap_info.committed_size; |
| all_heap_info.block_count += heap_info.block_count; |
| } |
| // Report the heap dump. |
| ReportHeapDump(pmd, all_heap_info, "winheap"); |
| return true; |
| } |
| |
| bool WinHeapDumpProvider::GetHeapInformation( |
| WinHeapInfo* heap_info, |
| const std::set<void*>& block_to_skip) { |
| CHECK(::HeapLock(heap_info->heap_id) == TRUE); |
| PROCESS_HEAP_ENTRY heap_entry; |
| heap_entry.lpData = nullptr; |
| // Walk over all the entries in this heap. |
| while (::HeapWalk(heap_info->heap_id, &heap_entry) != FALSE) { |
| if (block_to_skip.count(heap_entry.lpData) == 1) |
| continue; |
| if ((heap_entry.wFlags & PROCESS_HEAP_ENTRY_BUSY) != 0) { |
| heap_info->allocated_size += heap_entry.cbData; |
| heap_info->block_count++; |
| } else if ((heap_entry.wFlags & PROCESS_HEAP_REGION) != 0) { |
| heap_info->committed_size += heap_entry.Region.dwCommittedSize; |
| } |
| } |
| CHECK(::HeapUnlock(heap_info->heap_id) == TRUE); |
| return true; |
| } |
| |
| } // namespace trace_event |
| } // namespace base |