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

base/trace_event/process_memory_maps_dump_provider.cc

Index: base/trace_event/process_memory_maps_dump_provider.cc
diff --git a/base/trace_event/process_memory_maps_dump_provider.cc b/base/trace_event/process_memory_maps_dump_provider.cc
index b6fba80c73629809808a83f0e61f30cad00ee269..4ad6169715d9e09921026176b58c20894a9e8057 100644
--- a/base/trace_event/process_memory_maps_dump_provider.cc
+++ b/base/trace_event/process_memory_maps_dump_provider.cc
@@ -4,6 +4,7 @@
 
 #include "base/trace_event/process_memory_maps_dump_provider.h"
 
+#include <cctype>
 #include <fstream>
 
 #include "base/logging.h"
@@ -19,15 +20,110 @@ namespace trace_event {
 std::istream* ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = nullptr;
 
 namespace {
+
+const uint32 kMaxLineSize = 4096;
+
+bool ParseSmapsHeader(std::istream* smaps,
+                      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;
+  std::string prot_flags;

[dsinclair, 2015/02/23 17:10:34]

nit: s/prot/protected/

[Primiano Tucci (use gerrit), 2015/02/24 09:16:14]

I assume you meant protection not protected, by consistency with below, right?

[dsinclair, 2015/02/24 14:43:13]

Yes (whatever the correct expanded version of prot is, heh)

+  std::string ignored;
+  *smaps >> std::hex >> region->start_address;
+  smaps->ignore(1);
+  *smaps >> std::hex >> end_addr;
+  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 b/17402069).

[dsinclair, 2015/02/23 17:10:34]

Do we want b/ links in open code?

[Primiano Tucci (use gerrit), 2015/02/24 09:16:14]

I created a public bug to mirror the internal one.

Just FYI, there is anyways a number (123) of other b/ cases in the codebase.
https://code.google.com/p/chromium/codesearch#search/&q=%5Cbb/%5Cd%7B5,%7D%5C...

+    region->size_in_bytes = 0;
+    res = false;
+  }
+
+  region->protection_flags = 0;
+  *smaps >> prot_flags;
+  CHECK(4UL == prot_flags.size());
+  if (prot_flags[0] == 'r') {
+    region->protection_flags |=
+        ProcessMemoryMaps::VMRegion::kProtectionFlagsRead;
+  }
+  if (prot_flags[1] == 'w') {
+    region->protection_flags |=
+        ProcessMemoryMaps::VMRegion::kProtectionFlagsWrite;
+  }
+  if (prot_flags[2] == 'x') {
+    region->protection_flags |=
+        ProcessMemoryMaps::VMRegion::kProtectionFlagsExec;
+  }
+  *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;
+
+  return res;
+}
+
+uint32 ParseSmapsCounter(std::istream* smaps,
+                         ProcessMemoryMaps::VMRegion* region) {
+  // e.g., "RSS:  0 Kb\n"
+  uint32 res = 0;
+  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->byte_stats_resident;
+    region->byte_stats_resident *= 1024;
+    res = 1;
+  } else if (counter_name == "Anonymous:") {
+    *smaps >> std::dec >> region->byte_stats_anonymous;
+    region->byte_stats_anonymous *= 1024;
+    res = 1;
+  }
+  smaps->ignore(kMaxLineSize, '\n');
+
+  return res;
+}
+
 uint32 ReadLinuxProcSmapsFile(std::istream* smaps, ProcessMemoryMaps* pmm) {
   if (!smaps->good()) {
     LOG(ERROR) << "Could not read smaps file.";
     return 0;
   }
+  const uint32 kNumExpectedCountersPerRegion = 2;
+  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;
+  bool is_current_region_valid = false;
+  for (;;) {
+    int next = smaps->peek();
+    if (next == std::ifstream::traits_type::eof() || next == '\n')
+      break;
+    if (isxdigit(next) && !isupper(next)) {
+      region = {0};
+      counters_parsed_for_current_region = 0;
+      is_current_region_valid = ParseSmapsHeader(smaps, &region);
+    } else {
+      counters_parsed_for_current_region += ParseSmapsCounter(smaps, &region);

[dsinclair, 2015/02/23 17:10:34]

is it worth adding an ASSERT(counters_parsed_for_current_region <=
kNumExpectedCountersPerRegion)?

[Primiano Tucci (use gerrit), 2015/02/24 09:16:14]

Uhm that cannot technically happen, even if the kernel is screwed up, because
the counter is reset below when reaches kNumExpected.

[dsinclair, 2015/02/24 14:43:13]

I'm more worried about ParseSnmapsCounter getting changed and outputting say +=
3 which is > kNumExpectedCountersPerRegion.

[Primiano Tucci (use gerrit), 2015/02/24 15:43:25]

Ok I see your concern. I think that PS5 should address that.

+      if (counters_parsed_for_current_region == kNumExpectedCountersPerRegion) {
+        if (is_current_region_valid)
+          pmm->AddVMRegion(region);
+        ++num_regions_processed;
+        counters_parsed_for_current_region = 0;
+      }
+    }
+  }
   return num_regions_processed;
 }
+
 }  // namespace
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)