Update logic for emitting region information from dyld.

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 241 matching lines @@
   kern_return_t kr =
       task_info(mach_task_self(), TASK_DYLD_INFO,
                 reinterpret_cast<task_info_t>(&dyld_info), &count);
   if (kr != KERN_SUCCESS)
     return false;
 
   const struct dyld_all_image_infos* all_image_infos =
       reinterpret_cast<const struct dyld_all_image_infos*>(
           dyld_info.all_image_info_addr);
 
+  bool emitted_linkedit_from_dyld_shared_cache = false;
   for (size_t i = 0; i < all_image_infos->infoArrayCount; i++) {
     const char* image_name = all_image_infos->infoArray[i].imageFilePath;
 
     // The public definition for dyld_all_image_infos/dyld_image_info is wrong
     // for 64-bit platforms. We explicitly cast to struct mach_header_64 even
     // though the public definition claims that this is a struct mach_header.
     const struct mach_header_64* const header =
         reinterpret_cast<const struct mach_header_64* const>(
             all_image_infos->infoArray[i].imageLoadAddress);
 
     uint64_t next_command = reinterpret_cast<uint64_t>(header + 1);
     uint64_t command_end = next_command + header->sizeofcmds;
-    for (unsigned int i = 0; i < header->ncmds; ++i) {
+    uint64_t slide = 0;
+    for (unsigned int j = 0; j < header->ncmds; ++j) {
       // Ensure that next_command doesn't run past header->sizeofcmds.
       if (next_command + sizeof(struct load_command) > command_end)
         return false;
       const struct load_command* load_cmd =
           reinterpret_cast<const struct load_command*>(next_command);
       next_command += load_cmd->cmdsize;
 
       if (load_cmd->cmd == LC_SEGMENT_64) {
         if (load_cmd->cmdsize < sizeof(segment_command_64))
           return false;
         const segment_command_64* seg =
             reinterpret_cast<const segment_command_64*>(load_cmd);
         if (strcmp(seg->segname, SEG_PAGEZERO) == 0)
           continue;
+        if (strcmp(seg->segname, SEG_TEXT) == 0) {
+          slide = reinterpret_cast<uint64_t>(header) - seg->vmaddr;
+        }
+
+        // Avoid emitting LINKEDIT regions in the dyld shared cache, since they
+        // all overlap.
+        if (IsAddressInSharedRegion(seg->vmaddr) &&
+            strcmp(seg->segname, SEG_LINKEDIT) == 0) {
+          if (emitted_linkedit_from_dyld_shared_cache) {
+            continue;
+          } else {
+            emitted_linkedit_from_dyld_shared_cache = true;
+            image_name = "LinkEditDyldSharedCache";

[Mark Mentovai, 2017/02/14 22:45:06]

It’d be nice to use the actual proc_regionfilename of the dyld shared cache
here.

[erikchen, 2017/02/14 23:31:58]

I went with "dyld shared cache combined __LINKEDIT", which is the name vmmap
gives this region. proc_regionfilename returns nothing.

+          }
+        }
 
         uint32_t protection_flags = 0;
         if (seg->initprot & VM_PROT_READ)
           protection_flags |= VMRegion::kProtectionFlagsRead;
         if (seg->initprot & VM_PROT_WRITE)
           protection_flags |= VMRegion::kProtectionFlagsWrite;
         if (seg->initprot & VM_PROT_EXECUTE)
           protection_flags |= VMRegion::kProtectionFlagsExec;
 
         VMRegion region;
         region.size_in_bytes = seg->vmsize;
         region.protection_flags = protection_flags;
         region.mapped_file = image_name;
-        region.start_address =
-            reinterpret_cast<uint64_t>(header) + seg->fileoff;
+        region.start_address = slide + seg->vmaddr;
 
         // We intentionally avoid setting any page information, which is not
         // available from dyld. The fields will be populated later.
         regions->push_back(region);
       }
     }
   }
   return true;
 }
 
@@ skipping 108 matching lines @@
   std::vector<VMRegion> dyld_regions;
   if (!GetDyldRegions(&dyld_regions))
     return false;
   std::vector<VMRegion> all_regions;
   if (!GetAllRegions(&all_regions))
     return false;
 
   // Cache information from dyld_regions in a data-structure more conducive to
   // fast lookups.
   std::unordered_map<uint64_t, VMRegion*> address_to_vm_region;
-  std::vector<uint64_t> addresses_in_shared_region;
   for (VMRegion& region : dyld_regions) {
-    if (IsAddressInSharedRegion(region.start_address))
-      addresses_in_shared_region.push_back(region.start_address);
     address_to_vm_region[region.start_address] = &region;
   }
 
   // Merge information from dyld regions and all regions.
   for (const VMRegion& region : all_regions) {
     // Check to see if the region already has a VMRegion created from a dyld
     // load command. If so, copy the byte stats and move on.
     auto it = address_to_vm_region.find(region.start_address);
     if (it != address_to_vm_region.end() &&
         it->second->size_in_bytes == region.size_in_bytes) {
       CopyRegionByteStats(it->second, region);
       continue;
     }
 
     // Check to see if the region is likely used for the dyld shared cache.
     if (IsAddressInSharedRegion(region.start_address)) {
       uint64_t end_address = region.start_address + region.size_in_bytes;
-      for (uint64_t address : addresses_in_shared_region) {
+      bool skip = false;
+      for (const VMRegion& dyld_region : dyld_regions) {
         // This region is likely used for the dyld shared cache. Don't record
         // any byte stats since:
         //   1. It's not possible to figure out which dyld regions the byte
         //      stats correspond to.
         //   2. The region is likely shared by non-Chrome processes, so there's
         //      no point in charging the pages towards Chrome.
-        if (address >= region.start_address && address < end_address) {
-          continue;
+        if (dyld_region.start_address >= region.start_address &&
+            dyld_region.start_address < end_address) {
+          skip = true;
+          break;
+        }
+        uint64_t dyld_end_address =
+            dyld_region.start_address + dyld_region.size_in_bytes;
+        if (dyld_end_address >= region.start_address &&
+            dyld_end_address < end_address) {
+          skip = true;
+          break;
         }
       }
+      if (skip)
+        continue;
     }
     pmd->process_mmaps()->AddVMRegion(region);
   }
 
   for (VMRegion& region : dyld_regions) {
     pmd->process_mmaps()->AddVMRegion(region);
   }
 
   pmd->set_has_process_mmaps();
   return true;
@@ skipping 148 matching lines @@
 #endif
 }
 
 void ProcessMetricsMemoryDumpProvider::SuspendFastMemoryPolling() {
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   fast_polling_statm_fd_.reset();
 #endif
 }
 
 }  // namespace tracing