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>
+
+#include "base/numerics/safe_math.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();
+  task_t task = mach_task_self();
+  using VMRegion = base::trace_event::ProcessMemoryMaps::VMRegion;
+  mach_vm_size_t size = 0;
+  vm_region_submap_info_64 info;
+  natural_t depth = 1;
+  mach_msg_type_number_t count = sizeof(info);
+  for (mach_vm_address_t address = MACH_VM_MIN_ADDRESS;; address += size) {
+    memset(&info, 0, sizeof(info));
+    kern_return_t kr = mach_vm_region_recurse(
+        task, &address, &size, &depth,
+        reinterpret_cast<vm_region_info_t>(&info), &count);
+    if (kr == KERN_INVALID_ADDRESS)  // nothing else left
+      break;
+    if (kr != KERN_SUCCESS)  // something bad
+      return false;
+    if (info.is_submap) {
+      size = 0;
+      ++depth;
+      continue;
+    }
+
+    if (info.share_mode == SM_COW && info.ref_count == 1)
+      info.share_mode = SM_PRIVATE;
+
+    VMRegion region;
+    uint64_t dirty_bytes = info.pages_dirtied * PAGE_SIZE;
+    uint64_t clean_bytes =
+        (info.pages_resident - info.pages_reusable - info.pages_dirtied) *
+        PAGE_SIZE;
+    switch (info.share_mode) {
+      case SM_LARGE_PAGE:
+      case SM_PRIVATE:
+        region.byte_stats_private_dirty_resident = dirty_bytes;
+        region.byte_stats_private_clean_resident = clean_bytes;
+        break;
+      case SM_COW:
+        region.byte_stats_private_dirty_resident = dirty_bytes;
+        region.byte_stats_shared_clean_resident = clean_bytes;
+        break;
+      case SM_SHARED:
+      case SM_PRIVATE_ALIASED:
+      case SM_TRUESHARED:
+      case SM_SHARED_ALIASED:
+        region.byte_stats_shared_dirty_resident = dirty_bytes;
+        region.byte_stats_shared_clean_resident = clean_bytes;
+        break;
+      case SM_EMPTY:
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+
+    if (info.protection & VM_PROT_READ)
+      region.protection_flags |= VMRegion::kProtectionFlagsRead;
+    if (info.protection & VM_PROT_WRITE)
+      region.protection_flags |= VMRegion::kProtectionFlagsWrite;
+    if (info.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 = info.pages_swapped_out * PAGE_SIZE;
+    region.start_address = address;
+    region.size_in_bytes = size;
+    pmd->process_mmaps()->AddVMRegion(region);
+
+    base::CheckedNumeric<mach_vm_address_t> numeric(address);
+    numeric += size;
+    if (!numeric.IsValid())
+      break;
+    address = numeric.ValueOrDie();
+  }
+
+  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