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)
+  auto& footprint = 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)
+    return false;
+  const static size_t page_size = base::GetPageSize();
+  uint64_t resident_pages;
+  uint64_t shared_pages;
+  bool success = GetResidentAndSharedPagesFromStatmFile(
+      statm_fd, &resident_pages, &shared_pages);
+  if (!success)
+    return false;
+
+  // TODO(hjd): Implement swap in the next CL.
+  footprint.rss_anon_bytes = (resident_pages - shared_pages) * page_size;
+#endif  // defined(OS_LINUX)
+
 #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();
     statm_fd = fast_polling_statm_fd_.get();
+    if (statm_fd == -1)
+      return;
   }
-  if (statm_fd == -1)
-    return;
 
   uint64_t rss_pages = 0;

[Primiano Tucci (use gerrit), 2017/05/04 11:11:16]

at this point call this "private_pages" for consistency

[hjd, 2017/05/05 14:59:35]

thanks, Used resident_pages to match arg name

-  if (!GetResidentSizeFromStatmFile(statm_fd, &rss_pages))
+  uint64_t shared_pages = 0;

[Primiano Tucci (use gerrit), 2017/05/04 11:11:16]

and I'd call this "ignored" (or ignored_shared_pages, up to you) to document
that we actually mean to ignore it

[hjd, 2017/05/05 14:59:35]

Done.

+  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