[tracing] Add memory maps dumper impl for Linux/Android

base/trace_event/process_memory_maps_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 "base/trace_event/process_memory_maps_dump_provider.h"
 
 #include <fstream>
 
 #include "base/process/process_metrics.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/process_memory_maps.h"
 
 namespace base {
 namespace trace_event {
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 // static
 std::istream* ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = nullptr;
 
 namespace {
 uint32 ReadLinuxProcSmapsFile(std::istream* smaps, ProcessMemoryMaps* pmm) {
   if (!smaps->good()) {
     LOG(ERROR) << "Could not read smaps file.";
     return 0;
   }
+  const uint32 kNumExpectedCountersPerRegion = 2;
+  const uint32 kMaxLineSize = 4096;
+  uint32 counters_parsed_for_current_region = 0;
   uint32 num_regions_processed = 0;
-  // TODO(primiano): in next CLs add the actual code to process the smaps file.
+  ProcessMemoryMaps::VMRegion region;
+  for (;;) {
+    int next = smaps->peek();
+    if (next == std::ifstream::traits_type::eof() || next == '\n')
+      break;
+    if ((next >= '0' && next <= '9') || (next >= 'a' && next <= 'f')) {

[dsinclair, 2015/02/23 15:37:12]

What about A-Z? (There is a isxdigit() in <cctype> can we use that?)

[Primiano Tucci (use gerrit), 2015/02/23 16:57:03]

![A-F] is deliberate. The kernel always used (so far) lowercase hex in smaps.
This parser uses 1 char lookahead (which is easy and fast) to determine whether
the current line is a header (a-f0-9) or a counter (A-Z).*.

If I just use isxdigit() this will break when encountering "Anonymous", as the
"A" will be confused with the start of an address.
And using longer lookahead will make the entire code less readable and less
performant IMHO  without any actual benefit (i.e. I thing that if the kernel
starts using uppercase letters in the hex addresses that will be a major ABI
break).

+      // Parse head line: "00400000-00421000 r-xp 00000000 fc:01 1234  /foo.so"

[dsinclair, 2015/02/23 15:37:12]

Add the \n to the end since, it looks like, it will be consumed with the getLine
below

[Primiano Tucci (use gerrit), 2015/02/23 16:57:03]

Done.

+      uint64 end_addr;
+      std::string prot_flags;
+      std::string ignored;
+      region = {0};
+      counters_parsed_for_current_region = 0;
+
+      *smaps >> std::hex >> region.start_address;
+      smaps->ignore(1);
+      *smaps >> std::hex >> end_addr;
+      region.size_in_bytes = end_addr - region.start_address;
+      region.protection_flags = 0;
+      *smaps >> prot_flags;
+      CHECK(4UL == prot_flags.size());
+      if (prot_flags[0] == 'r')
+        region.protection_flags |= ProcessMemoryMaps::VMRegion::kProtRead;
+      if (prot_flags[1] == 'w')
+        region.protection_flags |= ProcessMemoryMaps::VMRegion::kProtWrite;
+      if (prot_flags[2] == 'x')
+        region.protection_flags |= ProcessMemoryMaps::VMRegion::kProtExec;
+      *smaps >> std::hex >> region.mapped_file_offset;
+      *smaps >> ignored;  // Ignore device maj-min (fc:01 in the example above).
+      *smaps >> ignored;  // Ignore inode number (1234 in the example above).
+
+      while (smaps->peek() == ' ')
+        smaps->ignore(1);
+      char mapped_file[kMaxLineSize];
+      smaps->getline(mapped_file, sizeof(mapped_file));
+      region.mapped_file = mapped_file;

[dsinclair, 2015/02/23 15:37:12]

Can the bodies of the if/else get pulled out into methods easily?

[Primiano Tucci (use gerrit), 2015/02/23 16:57:03]

Done.

+    } else {
+      // Parse counter line: "VmRSS:  0 Kb"

[dsinclair, 2015/02/23 15:37:12]

If the \n gets consumed below, add it to the example above.

[Primiano Tucci (use gerrit), 2015/02/23 16:57:03]

Done.

+      std::string counter_name;
+      *smaps >> counter_name;
+      // TODO(primiano): "Swap" should also be accounted as resident. Check
+      // whether Rss isn't already counting swapped and fix below if that is
+      // the case.
+      if (counter_name == "Rss:") {
+        *smaps >> std::dec >> region.bytes_stats_resident;
+        region.bytes_stats_resident *= 1024;
+        ++counters_parsed_for_current_region;
+      } else if (counter_name == "Anonymous:") {
+        *smaps >> std::dec >> region.bytes_stats_anonymous;
+        region.bytes_stats_anonymous *= 1024;
+        ++counters_parsed_for_current_region;
+      }
+      smaps->ignore(kMaxLineSize, '\n');
+      if (counters_parsed_for_current_region == kNumExpectedCountersPerRegion) {
+        pmm->AddVMRegion(region);
+        ++num_regions_processed;
+        counters_parsed_for_current_region = 0;
+      }
+    }
+  }
   return num_regions_processed;
 }
 }  // namespace
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
 // static
 ProcessMemoryMapsDumpProvider* ProcessMemoryMapsDumpProvider::GetInstance() {
   return Singleton<ProcessMemoryMapsDumpProvider,
                    LeakySingletonTraits<ProcessMemoryMapsDumpProvider>>::get();
 }
@@ skipping 19 matching lines @@
 #else
   LOG(ERROR) << "ProcessMemoryMaps dump provider is supported only on Linux";
 #endif
 
   if (res > 0)
     pmd->set_has_process_mmaps();
 }
 
 }  // namespace trace_event
 }  // namespace base