Emit VMRegions for macOS when doing process memory dumps.

components/tracing/common/process_metrics_memory_dump_provider.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 "components/tracing/common/process_metrics_memory_dump_provider.h"
 
 #include <fcntl.h>
 #include <stdint.h>
 
 #include <map>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/process_memory_maps.h"
 #include "base/trace_event/process_memory_totals.h"
 #include "build/build_config.h"
 
+#if defined(OS_MACOSX)
+#include <libproc.h>
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#include <sys/param.h>
+#endif  // defined(OS_MACOSX)
+
 namespace tracing {
 
 namespace {
 
 base::LazyInstance<
     std::map<base::ProcessId,
              std::unique_ptr<ProcessMetricsMemoryDumpProvider>>>::Leaky
     g_dump_providers_map = LAZY_INSTANCE_INITIALIZER;
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
@@ skipping 175 matching lines @@
     base::ScopedFILE smaps_file(fopen(file_name.c_str(), "r"));
     res = ReadLinuxProcSmapsFile(smaps_file.get(), pmd->process_mmaps());
   }
 
   if (res)
     pmd->set_has_process_mmaps();
   return res;
 }
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
+#if defined(OS_MACOSX)
+bool ProcessMetricsMemoryDumpProvider::DumpProcessMemoryMaps(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  const int pid = getpid();
+  using VMRegion = base::trace_event::ProcessMemoryMaps::VMRegion;
+  using RegionInfo = vm_region_submap_info_64;
+  mach_vm_address_t address = 0;
+  mach_vm_size_t vmsize = 0;
+  natural_t depth = 0;
+  RegionInfo vminfo;
+  mach_msg_type_number_t count = sizeof(RegionInfo);
+  while (true) {
+    kern_return_t kr = mach_vm_region_recurse(mach_task_self(), &address,
+        &vmsize, &depth, reinterpret_cast<vm_region_info_t>(&vminfo), &count);
+    if (kr == KERN_INVALID_ADDRESS)  // nothing else left
+      break;
+    if (kr != KERN_SUCCESS)  // something bad
+      return false;
+
+    if (vminfo.is_submap) {
+      ++depth;
+      continue;
+    }
+
+    VMRegion region;
+
+    // See vm_map_region_walk and vm_map_region_look_for_page in
+    // osfmk/vm/vm_map.c for more details.
+    if (vminfo.share_mode == SM_EMPTY) {
+      if (vminfo.share_mode == SM_LARGE_PAGE)

[Mark Mentovai, 2017/01/31 20:29:13]

How can share_mode be both SM_EMPTY and SM_LARGE_PAGE?

[erikchen, 2017/01/31 20:54:10]

whoops, left over debugging that wasn't even in the right place. removed.

+        LOG(ERROR) << "large page";
+    } else if (vminfo.share_mode == SM_COW) {
+      region.byte_stats_private_dirty_resident =
+          vminfo.pages_shared_now_private * PAGE_SIZE;
+      region.byte_stats_shared_clean_resident =
+          (vminfo.pages_resident - vminfo.pages_shared_now_private) *
+          PAGE_SIZE;
+    } else if (vminfo.share_mode == SM_PRIVATE ||
+               vminfo.share_mode == SM_LARGE_PAGE) {
+      region.byte_stats_private_dirty_resident =
+          vminfo.pages_dirtied * PAGE_SIZE;
+      region.byte_stats_private_clean_resident =
+          (vminfo.pages_resident - vminfo.pages_dirtied) * PAGE_SIZE;
+    } else if (vminfo.share_mode == SM_SHARED ||
+               vminfo.share_mode == SM_PRIVATE_ALIASED ||
+               vminfo.share_mode == SM_TRUESHARED ||
+               vminfo.share_mode == SM_SHARED_ALIASED) {
+      region.byte_stats_shared_dirty_resident =
+          vminfo.pages_dirtied * PAGE_SIZE;
+      region.byte_stats_shared_clean_resident =
+          (vminfo.pages_resident - vminfo.pages_dirtied) * PAGE_SIZE;
+    } else {
+      NOTREACHED();
+    }
+
+    if (vminfo.protection & VM_PROT_READ)
+      region.protection_flags |= VMRegion::kProtectionFlagsRead;
+    if (vminfo.protection & VM_PROT_WRITE)
+      region.protection_flags |= VMRegion::kProtectionFlagsWrite;
+    if (vminfo.protection & VM_PROT_EXECUTE)
+      region.protection_flags |= VMRegion::kProtectionFlagsExec;
+
+    char buffer[MAXPATHLEN];
+    int length = proc_regionfilename(pid, address, buffer, MAXPATHLEN);
+    if (length != 0)
+      region.mapped_file.assign(buffer, length);
+
+    region.byte_stats_swapped = vminfo.pages_swapped_out * PAGE_SIZE;
+    region.start_address = address;
+    region.size_in_bytes = vmsize;
+    pmd->process_mmaps()->AddVMRegion(region);
+
+    if (__builtin_add_overflow(address, vmsize, &address))
+      break;
+  }
+
+  pmd->set_has_process_mmaps();
+  return true;
+}
+#endif  // defined(OS_MACOSX)
+
 // static
 void ProcessMetricsMemoryDumpProvider::RegisterForProcess(
     base::ProcessId process) {
   std::unique_ptr<ProcessMetricsMemoryDumpProvider> metrics_provider(
       new ProcessMetricsMemoryDumpProvider(process));
   base::trace_event::MemoryDumpProvider::Options options;
   options.target_pid = process;
   options.is_fast_polling_supported = true;
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       metrics_provider.get(), "ProcessMemoryMetrics", nullptr, options);
@@ skipping 28 matching lines @@
 
 ProcessMetricsMemoryDumpProvider::~ProcessMetricsMemoryDumpProvider() {}
 
 // Called at trace dump point time. Creates a snapshot of the memory maps for
 // the current process.
 bool ProcessMetricsMemoryDumpProvider::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   bool res = DumpProcessTotals(args, pmd);
 
-#if defined(OS_LINUX) || defined(OS_ANDROID)
+#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_MACOSX)
   if (args.level_of_detail ==
       base::trace_event::MemoryDumpLevelOfDetail::DETAILED)
     res &= DumpProcessMemoryMaps(args, pmd);
-#endif
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_MACOSX)
   return res;
 }
 
 bool ProcessMetricsMemoryDumpProvider::DumpProcessTotals(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   const uint64_t rss_bytes = rss_bytes_for_testing
                                  ? rss_bytes_for_testing
                                  : process_metrics_->GetWorkingSetSize();
 
@@ skipping 82 matching lines @@
 #endif
 }
 
 void ProcessMetricsMemoryDumpProvider::SuspendFastMemoryPolling() {
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   fast_polling_statm_fd_.reset();
 #endif
 }
 
 }  // namespace tracing