[tracing] Dump child processes' memory metrics in browser

components/tracing/process_metrics_memory_dump_provider_posix.cc

Index: components/tracing/process_metrics_memory_dump_provider_posix.cc
diff --git a/base/trace_event/process_memory_maps_dump_provider.cc b/components/tracing/process_metrics_memory_dump_provider_posix.cc
similarity index 57%
rename from base/trace_event/process_memory_maps_dump_provider.cc
rename to components/tracing/process_metrics_memory_dump_provider_posix.cc
index 19f8d891618c10be3ae1d7a65d088b7aecacfb42..b599a5253fe4f6ff0ac1598159810c72ec339906 100644
--- a/base/trace_event/process_memory_maps_dump_provider.cc
+++ b/components/tracing/process_metrics_memory_dump_provider_posix.cc
@@ -2,27 +2,31 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/trace_event/process_memory_maps_dump_provider.h"
+#include "components/tracing/process_metrics_memory_dump_provider.h"
 
+#include <fcntl.h>
+
+#include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/format_macros.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/process_memory_dump.h"
 #include "base/trace_event/process_memory_maps.h"
 
-namespace base {
-namespace trace_event {
-
-// static
-FILE* ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = nullptr;
+namespace tracing {
 
 namespace {
 
+bool kernel_supports_rss_peak_reset = true;
+const char kClearPeakRssCommand[] = "5";
+
 const uint32 kMaxLineSize = 4096;
 
 bool ParseSmapsHeader(const char* header_line,
-                      ProcessMemoryMaps::VMRegion* region) {
+                      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 end_addr = 0;
@@ -45,19 +49,20 @@ bool ParseSmapsHeader(const char* header_line,
   region->protection_flags = 0;
   if (protection_flags[0] == 'r') {
     region->protection_flags |=
-        ProcessMemoryMaps::VMRegion::kProtectionFlagsRead;
+        base::trace_event::ProcessMemoryMaps::VMRegion::kProtectionFlagsRead;
   }
   if (protection_flags[1] == 'w') {
     region->protection_flags |=
-        ProcessMemoryMaps::VMRegion::kProtectionFlagsWrite;
+        base::trace_event::ProcessMemoryMaps::VMRegion::kProtectionFlagsWrite;
   }
   if (protection_flags[2] == 'x') {
     region->protection_flags |=
-        ProcessMemoryMaps::VMRegion::kProtectionFlagsExec;
+        base::trace_event::ProcessMemoryMaps::VMRegion::kProtectionFlagsExec;
   }
 
   region->mapped_file = mapped_file;
-  TrimWhitespaceASCII(region->mapped_file, TRIM_ALL, &region->mapped_file);
+  base::TrimWhitespaceASCII(region->mapped_file, base::TRIM_ALL,
+                            &region->mapped_file);
 
   return res;
 }
@@ -69,8 +74,9 @@ uint64 ReadCounterBytes(char* counter_line) {
   return counter_value * 1024;
 }
 
-uint32 ParseSmapsCounter(char* counter_line,
-                         ProcessMemoryMaps::VMRegion* region) {
+uint32 ParseSmapsCounter(
+    char* counter_line,
+    base::trace_event::ProcessMemoryMaps::VMRegion* region) {
   // A smaps counter lines looks as follows: "RSS:  0 Kb\n"
   uint32 res = 1;
   char counter_name[20];
@@ -96,7 +102,8 @@ uint32 ParseSmapsCounter(char* counter_line,
   return res;
 }
 
-uint32 ReadLinuxProcSmapsFile(FILE* smaps_file, ProcessMemoryMaps* pmm) {
+uint32 ReadLinuxProcSmapsFile(FILE* smaps_file,
+                              base::trace_event::ProcessMemoryMaps* pmm) {
   if (!smaps_file)
     return 0;
 
@@ -106,7 +113,7 @@ uint32 ReadLinuxProcSmapsFile(FILE* smaps_file, ProcessMemoryMaps* pmm) {
   const uint32 kNumExpectedCountersPerRegion = 6;
   uint32 counters_parsed_for_current_region = 0;
   uint32 num_valid_regions = 0;
-  ProcessMemoryMaps::VMRegion region;
+  base::trace_event::ProcessMemoryMaps::VMRegion region;
   bool should_add_current_region = false;
   for (;;) {
     line[0] = '\0';
@@ -114,7 +121,7 @@ uint32 ReadLinuxProcSmapsFile(FILE* smaps_file, ProcessMemoryMaps* pmm) {
       break;
     DCHECK_GT(strlen(line), 0u);
     if (isxdigit(line[0]) && !isupper(line[0])) {
-      region = ProcessMemoryMaps::VMRegion();
+      region = base::trace_event::ProcessMemoryMaps::VMRegion();
       counters_parsed_for_current_region = 0;
       should_add_current_region = ParseSmapsHeader(line, &region);
     } else {
@@ -136,39 +143,59 @@ uint32 ReadLinuxProcSmapsFile(FILE* smaps_file, ProcessMemoryMaps* pmm) {
 }  // namespace
 
 // static
-ProcessMemoryMapsDumpProvider* ProcessMemoryMapsDumpProvider::GetInstance() {
-  return Singleton<ProcessMemoryMapsDumpProvider,
-                   LeakySingletonTraits<ProcessMemoryMapsDumpProvider>>::get();
-}
-
-ProcessMemoryMapsDumpProvider::ProcessMemoryMapsDumpProvider() {
-}
+FILE* ProcessMetricsMemoryDumpProvider::proc_smaps_for_testing = nullptr;
+
+void ProcessMetricsMemoryDumpProvider::DumpProcessTotals(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  const uint64 rss_bytes = rss_bytes_for_testing
+                               ? rss_bytes_for_testing
+                               : process_metrics_->GetWorkingSetSize();
+
+  uint64 peak_rss_bytes = 0;
+  peak_rss_bytes = process_metrics_->GetPeakWorkingSetSize();
+
+  // This file cannot be wriiten for other processes. So, do not try.
+  if (kernel_supports_rss_peak_reset && process_ == base::kNullProcessHandle) {
+    int clear_refs_fd = open("/proc/self/clear_refs", O_WRONLY);
+    if (clear_refs_fd > 0 &&
+        base::WriteFileDescriptor(clear_refs_fd, kClearPeakRssCommand,
+                                  sizeof(kClearPeakRssCommand))) {
+      pmd->process_totals()->set_is_peak_rss_resetable(true);
+    } else {
+      kernel_supports_rss_peak_reset = false;
+    }
+    close(clear_refs_fd);
+  }
 
-ProcessMemoryMapsDumpProvider::~ProcessMemoryMapsDumpProvider() {
+  DCHECK(rss_bytes);
+  pmd->process_totals()->set_resident_set_bytes(rss_bytes);
+  pmd->process_totals()->set_peak_resident_set_bytes(peak_rss_bytes);
+  pmd->set_has_process_totals();
 }
 
-// Called at trace dump point time. Creates a snapshot of the memory maps for
-// the current process.
-bool ProcessMemoryMapsDumpProvider::OnMemoryDump(const MemoryDumpArgs& args,
-                                                 ProcessMemoryDump* pmd) {
-  // Snapshot of memory maps is not taken for light dump requests.
-  if (args.level_of_detail == MemoryDumpLevelOfDetail::LIGHT)
-    return true;
+void ProcessMetricsMemoryDumpProvider::DumpProcessMemoryMaps(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  // Snapshot of memory maps is taken only for detailed dump requests.
+  if (args.level_of_detail !=
+      base::trace_event::MemoryDumpLevelOfDetail::DETAILED)
+    return;
 
   uint32 res = 0;
   if (UNLIKELY(proc_smaps_for_testing)) {
     res = ReadLinuxProcSmapsFile(proc_smaps_for_testing, pmd->process_mmaps());
   } else {
-    ScopedFILE smaps_file(fopen("/proc/self/smaps", "r"));
+    std::string file_name = "/proc/" + (process_ == base::kNullProcessHandle
+                                            ? "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 > 0) {
+  if (res)
     pmd->set_has_process_mmaps();

[Primiano Tucci (use gerrit), 2015/12/14 10:52:21]

what happens if something fails? we don't get any output anymore?
Not even a DCHECK?
Why not keeping returning true / false if this can fail?

[ssid, 2016/01/04 20:54:38]

Done.

-    return true;
-  }
-  return false;
 }
 
-}  // namespace trace_event
-}  // namespace base
+}  // namespace tracing