Fill in PlatformPrivateFootprint on Linux

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>
@@ skipping 162 matching lines @@
           pmm->AddVMRegion(region);
           ++num_valid_regions;
           should_add_current_region = false;
         }
       }
     }
   }
   return num_valid_regions;
 }
 
-bool GetResidentSizeFromStatmFile(int fd, uint64_t* resident_pages) {
+bool GetResidentAndSharedPagesFromStatmFile(int fd,
+                                            uint64_t* resident_pages,
+                                            uint64_t* shared_pages) {
   lseek(fd, 0, SEEK_SET);
   char line[kMaxLineSize];
   int res = read(fd, line, kMaxLineSize - 1);
   if (res <= 0)
     return false;
   line[res] = '\0';
-  int num_scanned = sscanf(line, "%*s %" SCNu64, resident_pages);
-  return num_scanned == 1;
+  int num_scanned =
+      sscanf(line, "%*s %" SCNu64 " %" SCNu64, resident_pages, shared_pages);
+  return num_scanned == 2;
 }
 
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
 std::unique_ptr<base::ProcessMetrics> CreateProcessMetrics(
     base::ProcessId process) {
   if (process == base::kNullProcessId)
     return base::ProcessMetrics::CreateCurrentProcessMetrics();
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   // Just pass ProcessId instead of handle since they are the same in linux and
@@ skipping 424 matching lines @@
 #endif  // defined(OS_MACOSX)
   if (rss_bytes_for_testing)
     rss_bytes = rss_bytes_for_testing;
 
   // 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_LINUX) || defined(OS_ANDROID)
+  base::trace_event::ProcessMemoryTotals::PlatformPrivateFootprint& footprint =

[Primiano Tucci (use gerrit), 2017/05/03 19:21:21]

const auto& footprint = ...?

[hjd, 2017/05/04 10:46:35]

After this the line is *exactly* 80 chars => Best review comment ever!

Although actually I think that it can't be const? We write to field below. :(

+      pmd->process_totals()->GetPlatformPrivateFootprint();
+
+  base::ScopedFD autoclose;
+  int statm_fd = fast_polling_statm_fd_.get();
+  if (statm_fd == -1) {
+    autoclose = OpenStatm();
+    statm_fd = autoclose.get();
+  }
+  if (statm_fd != -1) {

[Primiano Tucci (use gerrit), 2017/05/03 19:21:21]

I'd just return false if statm_Fd == -1  here. Given the importance I am not
sure we wanto silently ignore this failure.

[hjd, 2017/05/04 10:46:35]

Done.

+    static size_t page_size = base::GetPageSize();

[Primiano Tucci (use gerrit), 2017/05/03 19:21:22]

static const size_t kPageSize

[hjd, 2017/05/04 10:46:35]

Done.

+    uint64_t resident_pages;
+    uint64_t shared_pages;
+    bool success = GetResidentAndSharedPagesFromStatmFile(
+        statm_fd, &resident_pages, &shared_pages);
+    if (success) {

[Primiano Tucci (use gerrit), 2017/05/03 19:21:21]

ditto, if(!success) return false;

[hjd, 2017/05/04 10:46:35]

Done.

+      footprint.rss_anon_bytes = (resident_pages - shared_pages) * page_size;
+    }
+  }
+#endif  // defined(OS_LINUX)

[Primiano Tucci (use gerrit), 2017/05/03 19:21:21]

add a // TODO(hjd): implement swap in the next CL.

[hjd, 2017/05/04 10:46:35]

Done.

+
 #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);
@@ skipping 23 matching lines @@
 #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;
 }
 
+base::ScopedFD ProcessMetricsMemoryDumpProvider::OpenStatm() {
+  std::string name =
+      "/proc/" +
+      (process_ == base::kNullProcessId ? "self"
+                                        : base::IntToString(process_)) +
+      "/statm";
+  base::ScopedFD fd = base::ScopedFD(open(name.c_str(), O_RDONLY));
+  DCHECK(fd.is_valid());
+  return fd;
+}
+
 void ProcessMetricsMemoryDumpProvider::PollFastMemoryTotal(
     uint64_t* memory_total) {
   *memory_total = 0;
 #if defined(OS_LINUX) || defined(OS_ANDROID)
+
   int statm_fd = fast_polling_statm_fd_for_testing;
-  if (statm_fd == -1) {
-    if (!fast_polling_statm_fd_.is_valid()) {
-      std::string name = "/proc/" + (process_ == base::kNullProcessId
-                                         ? "self"
-                                         : base::IntToString(process_)) +
-                         "/statm";
-      fast_polling_statm_fd_.reset(open(name.c_str(), O_RDONLY));
-      DCHECK(fast_polling_statm_fd_.is_valid());
-    }
+  if (!fast_polling_statm_fd_.is_valid())
+    fast_polling_statm_fd_ = OpenStatm();
+  if (statm_fd == -1)

[Primiano Tucci (use gerrit), 2017/05/03 19:21:21]

I think this is changing the semantic for the for_testing .
the previous code was first checking for invalidity of the statm_fd (which is
the for_testing) and then if -1 resorting to open

[hjd, 2017/05/04 10:46:35]

Done, thanks!

     statm_fd = fast_polling_statm_fd_.get();
-  }
   if (statm_fd == -1)
     return;
 
   uint64_t rss_pages = 0;
-  if (!GetResidentSizeFromStatmFile(statm_fd, &rss_pages))
+  uint64_t shared_pages = 0;
+  if (!GetResidentAndSharedPagesFromStatmFile(statm_fd, &rss_pages,
+                                              &shared_pages))
     return;
 
   static size_t page_size = base::GetPageSize();
   *memory_total = rss_pages * page_size;
 #else
   *memory_total = process_metrics_->GetWorkingSetSize();
 #endif
 }
 
 void ProcessMetricsMemoryDumpProvider::SuspendFastMemoryPolling() {
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   fast_polling_statm_fd_.reset();
 #endif
 }
 
 }  // namespace tracing