[tracing] Dump child processes' memory metrics in browser

components/tracing/process_metrics_memory_dump_provider.cc

Index: components/tracing/process_metrics_memory_dump_provider.cc
diff --git a/components/tracing/process_metrics_memory_dump_provider.cc b/components/tracing/process_metrics_memory_dump_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..05437da5571b1b12794b921d448c0746e5590746
--- /dev/null
+++ b/components/tracing/process_metrics_memory_dump_provider.cc
@@ -0,0 +1,307 @@
+// 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/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/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"
+
+namespace tracing {
+
+namespace {
+
+base::LazyInstance<
+    std::map<base::ProcessId, scoped_ptr<ProcessMetricsMemoryDumpProvider>>>::
+    Leaky g_dump_providers_map = LAZY_INSTANCE_INITIALIZER;
+
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+const char kClearPeakRssCommand[] = "5";
+
+const uint32_t kMaxLineSize = 4096;
+
+bool ParseSmapsHeader(const char* header_line,
+                      base::trace_event::ProcessMemoryMaps::VMRegion* region) {
+  // e.g., "00400000-00421000 r-xp 00000000 fc:01 1234  /foo.so\n"
+  bool res = true;  // Whether this region should be appended or skipped.
+  uint64_t end_addr = 0;
+  char protection_flags[5] = {0};
+  char mapped_file[kMaxLineSize];
+
+  if (sscanf(header_line, "%" SCNx64 "-%" SCNx64 " %4c %*s %*s %*s%4095[^\n]\n",
+             &region->start_address, &end_addr, protection_flags,
+             mapped_file) != 4)
+    return false;
+
+  if (end_addr > region->start_address) {
+    region->size_in_bytes = end_addr - region->start_address;
+  } else {
+    // This is not just paranoia, it can actually happen (See crbug.com/461237).
+    region->size_in_bytes = 0;
+    res = false;
+  }
+
+  region->protection_flags = 0;
+  if (protection_flags[0] == 'r') {
+    region->protection_flags |=
+        base::trace_event::ProcessMemoryMaps::VMRegion::kProtectionFlagsRead;
+  }
+  if (protection_flags[1] == 'w') {
+    region->protection_flags |=
+        base::trace_event::ProcessMemoryMaps::VMRegion::kProtectionFlagsWrite;
+  }
+  if (protection_flags[2] == 'x') {
+    region->protection_flags |=
+        base::trace_event::ProcessMemoryMaps::VMRegion::kProtectionFlagsExec;
+  }
+
+  region->mapped_file = mapped_file;
+  base::TrimWhitespaceASCII(region->mapped_file, base::TRIM_ALL,
+                            &region->mapped_file);
+
+  return res;
+}
+
+uint64_t ReadCounterBytes(char* counter_line) {
+  uint64_t counter_value = 0;
+  int res = sscanf(counter_line, "%*s %" SCNu64 " kB", &counter_value);
+  return res == 1 ? counter_value * 1024 : 0;
+}
+
+uint32_t ParseSmapsCounter(
+    char* counter_line,
+    base::trace_event::ProcessMemoryMaps::VMRegion* region) {
+  // A smaps counter lines looks as follows: "RSS:  0 Kb\n"
+  uint32_t res = 1;
+  char counter_name[20];
+  int did_read = sscanf(counter_line, "%19[^\n ]", counter_name);
+  if (did_read != 1)
+    return 0;
+
+  if (strcmp(counter_name, "Pss:") == 0) {
+    region->byte_stats_proportional_resident = ReadCounterBytes(counter_line);
+  } else if (strcmp(counter_name, "Private_Dirty:") == 0) {
+    region->byte_stats_private_dirty_resident = ReadCounterBytes(counter_line);
+  } else if (strcmp(counter_name, "Private_Clean:") == 0) {
+    region->byte_stats_private_clean_resident = ReadCounterBytes(counter_line);
+  } else if (strcmp(counter_name, "Shared_Dirty:") == 0) {
+    region->byte_stats_shared_dirty_resident = ReadCounterBytes(counter_line);
+  } else if (strcmp(counter_name, "Shared_Clean:") == 0) {
+    region->byte_stats_shared_clean_resident = ReadCounterBytes(counter_line);
+  } else if (strcmp(counter_name, "Swap:") == 0) {
+    region->byte_stats_swapped = ReadCounterBytes(counter_line);
+  } else {
+    res = 0;
+  }
+
+  return res;
+}
+
+uint32_t ReadLinuxProcSmapsFile(FILE* smaps_file,
+                                base::trace_event::ProcessMemoryMaps* pmm) {
+  if (!smaps_file)
+    return 0;
+
+  fseek(smaps_file, 0, SEEK_SET);
+
+  char line[kMaxLineSize];
+  const uint32_t kNumExpectedCountersPerRegion = 6;
+  uint32_t counters_parsed_for_current_region = 0;
+  uint32_t num_valid_regions = 0;
+  base::trace_event::ProcessMemoryMaps::VMRegion region;
+  bool should_add_current_region = false;
+  for (;;) {
+    line[0] = '\0';
+    if (fgets(line, kMaxLineSize, smaps_file) == nullptr || !strlen(line))
+      break;
+    if (isxdigit(line[0]) && !isupper(line[0])) {
+      region = base::trace_event::ProcessMemoryMaps::VMRegion();
+      counters_parsed_for_current_region = 0;
+      should_add_current_region = ParseSmapsHeader(line, &region);
+    } else {
+      counters_parsed_for_current_region += ParseSmapsCounter(line, &region);
+      DCHECK_LE(counters_parsed_for_current_region,
+                kNumExpectedCountersPerRegion);
+      if (counters_parsed_for_current_region == kNumExpectedCountersPerRegion) {
+        if (should_add_current_region) {
+          pmm->AddVMRegion(region);
+          ++num_valid_regions;
+          should_add_current_region = false;
+        }
+      }
+    }
+  }
+  return num_valid_regions;
+}
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+
+scoped_ptr<base::ProcessMetrics> CreateProcessMetrics(base::ProcessId process) {
+  if (process == base::kNullProcessId)
+    return make_scoped_ptr(base::ProcessMetrics::CreateCurrentProcessMetrics());
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  // Just pass ProcessId instead of handle since they are the same in linux and
+  // android.
+  return make_scoped_ptr(base::ProcessMetrics::CreateProcessMetrics(process));
+#else
+  // Creating process metrics for child processes in mac or windows requires
+  // additional information like ProcessHandle or port provider. This is a non
+  // needed use case.
+  NOTREACHED();
+  return scoped_ptr<base::ProcessMetrics>();
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+}
+
+}  // namespace
+
+// static
+uint64_t ProcessMetricsMemoryDumpProvider::rss_bytes_for_testing = 0;
+
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+
+// static
+FILE* ProcessMetricsMemoryDumpProvider::proc_smaps_for_testing = nullptr;
+
+bool ProcessMetricsMemoryDumpProvider::DumpProcessMemoryMaps(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  uint32_t res = 0;
+  if (proc_smaps_for_testing) {
+    res = ReadLinuxProcSmapsFile(proc_smaps_for_testing, pmd->process_mmaps());
+  } else {
+    std::string file_name = "/proc/" + (process_ == base::kNullProcessId
+                                            ? "self"
+                                            : base::IntToString(process_)) +
+                            "/smaps";
+    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)
+
+// static
+void ProcessMetricsMemoryDumpProvider::RegisterForProcess(
+    base::ProcessId process) {
+  scoped_ptr<ProcessMetricsMemoryDumpProvider> metrics_provider(
+      new ProcessMetricsMemoryDumpProvider(process));
+  base::trace_event::MemoryDumpProvider::Options options(process);
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      metrics_provider.get(), "ProcessMemoryMetrics", nullptr, options);
+  bool did_insert =
+      g_dump_providers_map.Get()
+          .insert(std::make_pair(process, std::move(metrics_provider)))
+          .second;
+  if (!did_insert) {
+    LOG(ERROR) << "ProcessMetricsMemoryDumpProvider already registered for "

[Primiano Tucci (use gerrit), 2016/01/07 11:34:35]

if you say that this can actually happen on CrOs, make it a DLOG, so won't spam
on production builds.

[ssid, 2016/01/07 13:03:10]

Done.

+               << (process == base::kNullProcessId
+                       ? "current process"
+                       : "process id " + base::IntToString(process));
+  }
+}
+
+// static
+void ProcessMetricsMemoryDumpProvider::UnregisterForProcess(
+    base::ProcessId process) {
+  auto iter = g_dump_providers_map.Get().find(process);
+  if (iter == g_dump_providers_map.Get().end()) {
+    NOTREACHED();

[Primiano Tucci (use gerrit), 2016/01/07 11:34:35]

at this point, given your comment on the pid=1, I guess you should remove this
notreached, as you might have more >1 providers unregistering for pid=1

[ssid, 2016/01/07 13:03:09]

Acknowledged.

+    return;
+  }
+  base::trace_event::MemoryDumpManager::GetInstance()
+      ->UnregisterAndDeleteDumpProviderSoon(std::move(iter->second));
+  g_dump_providers_map.Get().erase(iter);
+}
+
+ProcessMetricsMemoryDumpProvider::ProcessMetricsMemoryDumpProvider(
+    base::ProcessId process)
+    : process_(process),
+      process_metrics_(CreateProcessMetrics(process)),
+      is_rss_peak_resettable_(true) {}
+
+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)
+  // Snapshot of memory maps is taken only for detailed dump requests.

[Primiano Tucci (use gerrit), 2016/01/07 11:34:35]

I think this comment is a bit redundant, the code below is perfectly readable :)

[ssid, 2016/01/07 13:03:09]

Done.

+  if (args.level_of_detail ==
+      base::trace_event::MemoryDumpLevelOfDetail::DETAILED)
+    res &= DumpProcessMemoryMaps(args, pmd);
+#endif
+  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();
+
+  // rss_bytes will be 0 if the process ended while dumping.
+  if (!rss_bytes)
+    return false;
+
+  uint64_t peak_rss_bytes = 0;
+
+#if !defined(OS_IOS)
+  peak_rss_bytes = process_metrics_->GetPeakWorkingSetSize();
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+  if (is_rss_peak_resettable_) {
+    std::string clear_refs_file =
+        "/proc/" +
+        (process_ == base::kNullProcessId ? "self"
+                                          : base::IntToString(process_)) +
+        "/clear_refs";
+    int clear_refs_fd = open(clear_refs_file.c_str(), O_WRONLY);
+    if (clear_refs_fd > 0 &&
+        base::WriteFileDescriptor(clear_refs_fd, kClearPeakRssCommand,

[Primiano Tucci (use gerrit), 2016/01/07 11:34:35]

you need to look at the return value of WriteFileDescriptor.
What is going to happen on old kernels is that you will be able to open the file
successfully, but the actual write() will fail.
So if you see WriteFIleDescriptor failing, you need to set is_peak_resettable to
false and avoid trying again.

[ssid, 2016/01/07 13:03:09]

Acknowledged.

+                                  sizeof(kClearPeakRssCommand))) {
+      pmd->process_totals()->set_is_peak_rss_resetable(true);
+    } else {
+      is_rss_peak_resettable_ = false;
+    }
+    close(clear_refs_fd);
+  }
+#elif defined(MACOSX)
+  size_t private_bytes;
+  bool res = process_metrics_->GetMemoryBytes(&private_bytes,
+                                              nullptr /* shared_bytes */);
+  if (res)
+    pmd->process_totals()->SetExtraFieldInBytes("private_bytes", private_bytes);
+#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+#endif  // !defined(OS_IOS)
+
+  pmd->process_totals()->set_resident_set_bytes(rss_bytes);
+  pmd->set_has_process_totals();
+  pmd->process_totals()->set_peak_resident_set_bytes(peak_rss_bytes);
+
+  // Returns true even if other metrics failed, since rss is reported.
+  return true;
+}
+
+}  // namespace tracing