Support storing information about what modules are loaded in the process.

base/debug/activity_tracker.cc

 // Copyright 2016 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/debug/activity_tracker.h"
 
 #include <algorithm>
 
 #include "base/debug/stack_trace.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/pending_task.h"
+#include "base/pickle.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 namespace debug {
 
 namespace {
@@ skipping 857 matching lines @@
 }
 
 // static
 size_t ThreadActivityTracker::SizeForStackDepth(int stack_depth) {
   return static_cast<size_t>(stack_depth) * sizeof(Activity) + sizeof(Header);
 }
 
 
 GlobalActivityTracker* GlobalActivityTracker::g_tracker_ = nullptr;
 
+GlobalActivityTracker::ModuleInfo::ModuleInfo() {}
+GlobalActivityTracker::ModuleInfo::ModuleInfo(ModuleInfo&& rhs) = default;
+GlobalActivityTracker::ModuleInfo::ModuleInfo(const ModuleInfo& rhs) = default;
+GlobalActivityTracker::ModuleInfo::~ModuleInfo() {}
+
+GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
+    ModuleInfo&& rhs) = default;
+GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
+    const ModuleInfo& rhs) = default;
+
+bool GlobalActivityTracker::ModuleInfoRecord::DecodeTo(
+    GlobalActivityTracker::ModuleInfo* info,
+    size_t record_size) const {
+  std::atomic_thread_fence(std::memory_order_acquire);
+  if (offsetof(ModuleInfoRecord, pickle) + pickle_size > record_size)
+    return false;
+
+  info->is_loaded = loaded != 0;
+  info->address = static_cast<uintptr_t>(address);
+  info->size = static_cast<size_t>(size);
+
+  Pickle pickler(pickle, pickle_size);
+  PickleIterator iter(pickler);
+  return iter.ReadString(&info->file) && iter.ReadString(&info->version) &&
+         iter.ReadString(&info->identifier) &&
+         iter.ReadString(&info->debug_file) &&
+         iter.ReadString(&info->debug_identifier);
+}
+
+bool GlobalActivityTracker::ModuleInfoRecord::EncodeFrom(
+    const GlobalActivityTracker::ModuleInfo& info,
+    size_t record_size) {
+  Pickle pickler;
+  bool okay = pickler.WriteString(info.file) &&
+              pickler.WriteString(info.version) &&
+              pickler.WriteString(info.identifier) &&
+              pickler.WriteString(info.debug_file) &&
+              pickler.WriteString(info.debug_identifier);
+  if (!okay) {
+    NOTREACHED();
+    return false;
+  }
+  if (offsetof(ModuleInfoRecord, pickle) + pickler.size() > record_size) {
+    NOTREACHED();
+    return false;
+  }
+
+  memcpy(pickle, pickler.data(), pickler.size());
+  pickle_size = pickler.size();
+  return UpdateFrom(info);
+}
+
+bool GlobalActivityTracker::ModuleInfoRecord::UpdateFrom(
+    const GlobalActivityTracker::ModuleInfo& info) {
+  address = info.address;
+  size = info.size;
+  loaded = info.is_loaded ? 1 : 0;
+  std::atomic_thread_fence(std::memory_order_release);
+  return true;
+}
+
+// static
+size_t GlobalActivityTracker::ModuleInfoRecord::EncodedSize(
+    const GlobalActivityTracker::ModuleInfo& info) {
+  PickleSizer sizer;
+  sizer.AddString(info.file);
+  sizer.AddString(info.version);
+  sizer.AddString(info.identifier);
+  sizer.AddString(info.debug_file);
+  sizer.AddString(info.debug_identifier);
+
+  return offsetof(ModuleInfoRecord, pickle) + sizer.payload_size();
+}
+
 GlobalActivityTracker::ScopedThreadActivity::ScopedThreadActivity(
     const void* program_counter,
     const void* origin,
     Activity::Type type,
     const ActivityData& data,
     bool lock_allowed)
     : ThreadActivityTracker::ScopedActivity(GetOrCreateTracker(lock_allowed),
                                             program_counter,
                                             origin,
                                             type,
@@ skipping 152 matching lines @@
   PersistentMemoryAllocator::Reference ref =
       allocator_->Allocate(message.size() + 1, kTypeIdGlobalLogMessage);
   char* memory = allocator_->GetAsArray<char>(ref, kTypeIdGlobalLogMessage,
                                               message.size() + 1);
   if (memory) {
     memcpy(memory, message.data(), message.size());
     allocator_->MakeIterable(ref);
   }
 }
 
+void GlobalActivityTracker::RecordModuleInfo(const ModuleInfo& info) {
+  AutoLock lock(modules_lock_);
+  auto found = modules_.find(info.file);
+  if (found != modules_.end()) {
+    ModuleInfoRecord* record = allocator_->GetAsObject<ModuleInfoRecord>(
+        found->second, kTypeIdModuleInfoRecord);
+    DCHECK(record);
+
+    // Get should never fail but need to be tolerant in production.
+    if (record) {
+      // Update the basic state of module information that has been already
+      // recorded. It is assumed that the string information (identifier,
+      // version, etc.) remain unchanged which means that there's no need
+      // to create a new record to accommodate a possibly longer length.
+      record->UpdateFrom(info);
+      return;
+    }
+  }
+
+  size_t required_size = ModuleInfoRecord::EncodedSize(info);
+  PersistentMemoryAllocator::Reference ref =
+      allocator_->Allocate(required_size, kTypeIdModuleInfoRecord);
+  ModuleInfoRecord* record =
+      allocator_->GetAsObject<ModuleInfoRecord>(ref, kTypeIdModuleInfoRecord);
+  if (!record)
+    return;
+
+  bool success = record->EncodeFrom(info, allocator_->GetAllocSize(ref));
+  DCHECK(success);
+  allocator_->MakeIterable(ref);
+  modules_.insert(std::make_pair(info.file, ref));
+}
+
 GlobalActivityTracker::GlobalActivityTracker(
     std::unique_ptr<PersistentMemoryAllocator> allocator,
     int stack_depth)
     : allocator_(std::move(allocator)),
       stack_memory_size_(ThreadActivityTracker::SizeForStackDepth(stack_depth)),
       this_thread_tracker_(&OnTLSDestroy),
       thread_tracker_count_(0),
       thread_tracker_allocator_(allocator_.get(),
                                 kTypeIdActivityTracker,
                                 kTypeIdActivityTrackerFree,
@@ skipping 13 matching lines @@
               PersistentMemoryAllocator::kSizeAny),
           kGlobalDataSize) {
   // Ensure the passed memory is valid and empty (iterator finds nothing).
   uint32_t type;
   DCHECK(!PersistentMemoryAllocator::Iterator(allocator_.get()).GetNext(&type));
 
   // Ensure that there is no other global object and then make this one such.
   DCHECK(!g_tracker_);
   g_tracker_ = this;
 
-  // The global user-data record must be iterable in order to be found by an
-  // analyzer.
+  // The global records must be iterable in order to be found by an analyzer.
   allocator_->MakeIterable(allocator_->GetAsReference(
       user_data_.GetBaseAddress(), kTypeIdGlobalDataRecord));
 }
 
 GlobalActivityTracker::~GlobalActivityTracker() {
   DCHECK_EQ(g_tracker_, this);
   DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
   g_tracker_ = nullptr;
 }
 
@@ skipping 96 matching lines @@
     : GlobalActivityTracker::ScopedThreadActivity(
           program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base