[Android] Add 64-bit support to memdump (and memory_inspector parser)

tools/android/memdump/memdump.cc

 // Copyright (c) 2013 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 <fcntl.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <cstring>
 #include <fstream>
 #include <iostream>
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/containers/hash_tables.h"
 #include "base/file_util.h"
 #include "base/files/scoped_file.h"
+#include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 
 const unsigned int kPageSize = getpagesize();
 
 namespace {
 
 class BitSet {
  public:
   void resize(size_t nbits) {
     data_.resize((nbits + 7) / 8);
   }
 
   void set(uint32 bit) {
     const uint32 byte_idx = bit / 8;
     CHECK(byte_idx < data_.size());
     data_[byte_idx] |= (1 << (bit & 7));
   }
 
   std::string AsB64String() const {
-    std::string bits(&data_[0], data_.size());
+    // Simple optimization: strip trailing zeros from the bitmap. It can save
+    // some hundred ms. when printing large mmap-ed and non resident regions.

[Sami, 2014/09/09 10:44:26]

Trailing == most significant bits, hence likely to be zero? Just checking which
way around things are here :)

[Primiano Tucci (use gerrit), 2014/09/09 11:11:38]

Hmm no, least significant bytes, not bits.
Imagine a region of 32 pages, where pages 0-8,10-16 are resident.
The full bitmap would be:
11111111 11111100 00000000 00000000
The strip here would reduce this to:
11111111 11111100

The most common and interesting case is virtual address space reservations (i.e.
mmap(a_lot, PROT_NONE, ...) where all the bits are 0).

I'll reword the comment here.

[Sami, 2014/09/09 11:16:20]

Ah, somehow I was confusing this with addresses instead of a residency bit set.

+    size_t end = data_.size();
+    while (end > 0 && data_[end - 1] == '\0')
+      --end;
+    std::string bits(&data_[0], end);
     std::string b64_string;
     base::Base64Encode(bits, &b64_string);
     return b64_string;
   }
 
  private:
   std::vector<char> data_;
 };
 
 // An entry in /proc/<pid>/pagemap.
@@ skipping 13 matching lines @@
 struct PageCount {
   PageCount() : total_count(0), unevictable_count(0) {}
 
   int total_count;
   int unevictable_count;
 };
 
 struct MemoryMap {
   std::string name;
   std::string flags;
-  uint start_address;
-  uint end_address;
-  uint offset;
+  uint64 start_address;
+  uint64 end_address;
+  uint64 offset;
   PageCount private_pages;
   // app_shared_pages[i] contains the number of pages mapped in i+2 processes
   // (only among the processes that are being analyzed).
   std::vector<PageCount> app_shared_pages;
   PageCount other_shared_pages;
   std::vector<PageInfo> committed_pages;
   // committed_pages_bits is a bitset reflecting the present bit for all the
   // virtual pages of the mapping.
   BitSet committed_pages_bits;
 };
@@ skipping 25 matching lines @@
 bool ParseMemoryMapLine(const std::string& line,
                         std::vector<std::string>* tokens,
                         MemoryMap* memory_map) {
   tokens->clear();
   base::SplitString(line, ' ', tokens);
   if (tokens->size() < 2)
     return false;
   const std::string& addr_range = tokens->at(0);
   std::vector<std::string> range_tokens;
   base::SplitString(addr_range, '-', &range_tokens);
-  uint64 tmp = 0;
   const std::string& start_address_token = range_tokens.at(0);
-  if (!base::HexStringToUInt64(start_address_token, &tmp)) {
+  if (!base::HexStringToUInt64(start_address_token,
+                               &memory_map->start_address)) {
     return false;
   }
-  memory_map->start_address = static_cast<uint>(tmp);
   const std::string& end_address_token = range_tokens.at(1);
-  if (!base::HexStringToUInt64(end_address_token, &tmp)) {
+  if (!base::HexStringToUInt64(end_address_token, &memory_map->end_address)) {
     return false;
   }
-  memory_map->end_address = static_cast<uint>(tmp);
   if (tokens->at(1).size() != strlen("rwxp"))
     return false;
   memory_map->flags.swap(tokens->at(1));
-  if (!base::HexStringToUInt64(tokens->at(2), &tmp))
+  if (!base::HexStringToUInt64(tokens->at(2), &memory_map->offset))
     return false;
-  memory_map->offset = static_cast<uint>(tmp);
   memory_map->committed_pages_bits.resize(
       (memory_map->end_address - memory_map->start_address) / kPageSize);
   const int map_name_index = 5;
   if (tokens->size() >= map_name_index + 1) {
     for (std::vector<std::string>::const_iterator it =
              tokens->begin() + map_name_index; it != tokens->end(); ++it) {
       if (!it->empty()) {
         if (!memory_map->name.empty())
           memory_map->name.append(" ");
         memory_map->name.append(*it);
@@ skipping 42 matching lines @@
 // provided memory map.
 bool GetPagesForMemoryMap(int pagemap_fd,
                           const MemoryMap& memory_map,
                           std::vector<PageInfo>* committed_pages,
                           BitSet* committed_pages_bits) {
   const off64_t offset = memory_map.start_address / kPageSize;
   if (lseek64(pagemap_fd, offset * sizeof(PageMapEntry), SEEK_SET) < 0) {
     PLOG(ERROR) << "lseek";
     return false;
   }
-  for (uint addr = memory_map.start_address, page_index = 0;
+  for (uint64 addr = memory_map.start_address, page_index = 0;
        addr < memory_map.end_address;
        addr += kPageSize, ++page_index) {
     DCHECK_EQ(0, addr % kPageSize);
     PageMapEntry page_map_entry = {};
     COMPILE_ASSERT(sizeof(PageMapEntry) == sizeof(uint64), unexpected_size);
     ssize_t bytes = read(pagemap_fd, &page_map_entry, sizeof(page_map_entry));
     if (bytes != sizeof(PageMapEntry) && bytes != 0) {
       PLOG(ERROR) << "read";
       return false;
     }
@@ skipping 188 matching lines @@
     const ProcessMemory& process_memory = *it;
     std::cout << "[ PID=" << process_memory.pid << "]" << '\n';
     const std::vector<MemoryMap>& memory_maps = process_memory.memory_maps;
     for (std::vector<MemoryMap>::const_iterator it = memory_maps.begin();
          it != memory_maps.end(); ++it) {
       const MemoryMap& memory_map = *it;
       app_shared_buf.clear();
       AppendAppSharedField(memory_map.app_shared_pages, &app_shared_buf);
       base::SStringPrintf(
           &buf,
-          "%x-%x %s %x private_unevictable=%d private=%d shared_app=%s "
-          "shared_other_unevictable=%d shared_other=%d \"%s\" [%s]\n",
+          "%"PRIx64"-%"PRIx64" %s %"PRIx64" private_unevictable=%d private=%d "
+          "shared_app=%s shared_other_unevictable=%d shared_other=%d "
+          "\"%s\" [%s]\n",
           memory_map.start_address,
           memory_map.end_address,
           memory_map.flags.c_str(),
           memory_map.offset,
           memory_map.private_pages.unevictable_count * kPageSize,
           memory_map.private_pages.total_count * kPageSize,
           app_shared_buf.c_str(),
           memory_map.other_shared_pages.unevictable_count * kPageSize,
           memory_map.other_shared_pages.total_count * kPageSize,
           memory_map.name.c_str(),
@@ skipping 87 matching lines @@
     }
   }
 
   ClassifyPages(&processes_memory);
   if (short_output)
     DumpProcessesMemoryMapsInShortFormat(processes_memory);
   else
     DumpProcessesMemoryMapsInExtendedFormat(processes_memory);
   return EXIT_SUCCESS;
 }