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 <limits>
 #include <utility>
 
 #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/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 {
 
 // A number that identifies the memory as having been initialized. It's
 // arbitrary but happens to be the first 4 bytes of SHA1(ThreadActivityTracker).
 // A version number is added on so that major structure changes won't try to
 // read an older version (since the cookie won't match).
 const uint32_t kHeaderCookie = 0xC0029B24UL + 2;  // v2
 
 // The minimum depth a stack should support.
 const int kMinStackDepth = 2;
 
 // The amount of memory set aside for holding arbitrary user data (key/value
 // pairs) globally or associated with ActivityData entries.
 const size_t kUserDataSize = 1024;    // bytes
 const size_t kGlobalDataSize = 4096;  // bytes
 const size_t kMaxUserDataNameLength =
     static_cast<size_t>(std::numeric_limits<uint8_t>::max());
 
+// A constant used to indicate that module information is changing.
+const uint32_t kModuleInformationChanging = 0x80000000;
+
 union ThreadRef {
   int64_t as_id;
 #if defined(OS_WIN)
   // On Windows, the handle itself is often a pseudo-handle with a common
   // value meaning "this thread" and so the thread-id is used. The former
   // can be converted to a thread-id with a system call.
   PlatformThreadId as_tid;
 #elif defined(OS_POSIX)
   // On Posix, the handle is always a unique identifier so no conversion
   // needs to be done. However, it's value is officially opaque so there
@@ skipping 414 matching lines @@
 const void* ActivityUserData::GetBaseAddress() {
   // The |memory_| pointer advances as elements are written but the |id_|
   // value is always at the start of the block so just return that.
   return id_;
 }
 
 // This information is kept for every thread that is tracked. It is filled
 // the very first time the thread is seen. All fields must be of exact sizes
 // so there is no issue moving between 32 and 64-bit builds.
 struct ThreadActivityTracker::Header {
+  // Defined in .h for analyzer access. Increment this if structure changes!
+  static constexpr uint32_t kPersistentTypeId =
+      GlobalActivityTracker::kTypeIdActivityTracker;
+
   // Expected size for 32/64-bit check.
   static constexpr size_t kExpectedInstanceSize = 80;
 
   // This unique number indicates a valid initialization of the memory.
   std::atomic<uint32_t> cookie;
 
   // The number of Activity slots (spaces that can hold an Activity) that
   // immediately follow this structure in memory.
   uint32_t stack_slots;
 
@@ skipping 396 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;
+
+GlobalActivityTracker::ModuleInfoRecord::ModuleInfoRecord() {}
+GlobalActivityTracker::ModuleInfoRecord::~ModuleInfoRecord() {}
+
+bool GlobalActivityTracker::ModuleInfoRecord::DecodeTo(
+    GlobalActivityTracker::ModuleInfo* info,
+    size_t record_size) const {
+  // Get the current "changes" indicator, acquiring all the other values.
+  uint32_t current_changes = changes.load(std::memory_order_acquire);
+
+  // Copy out the information.
+  info->address = static_cast<uintptr_t>(address);
+  info->size = static_cast<size_t>(size);
+  info->is_loaded = loaded != 0;
+
+  // Check to make sure no information changed while being read. A "seq-cst"
+  // operation is expensive but is only done during analysis and it's the only
+  // way to ensure this occurs after all the accesses above. If changes did
+  // occur then return a "not loaded" result so that |size| and |address|
+  // aren't expected to be accurate.
+  if ((current_changes & kModuleInformationChanging) != 0 ||
+      changes.load(std::memory_order_seq_cst) != current_changes) {
+    info->is_loaded = false;
+  }
+
+  // Pickled information never changes so can always be returned.
+  if (offsetof(ModuleInfoRecord, pickle) + pickle_size > record_size)
+    return false;
+  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;
+  }
+
+  // The pickle never changes and this is done before the record is made
+  // iterable so no thread protection is necessary.
+  memcpy(pickle, pickler.data(), pickler.size());
+  pickle_size = pickler.size();
+  changes.store(0, std::memory_order_relaxed);
+  return UpdateFrom(info);
+}
+
+bool GlobalActivityTracker::ModuleInfoRecord::UpdateFrom(
+    const GlobalActivityTracker::ModuleInfo& info) {
+  // Updates can occur after the record is made visible so make changes atomic.
+  // A "strong" exchange ensures no false failures.
+  uint32_t old_changes = changes.load(std::memory_order_relaxed);
+  uint32_t new_changes = old_changes | kModuleInformationChanging;
+  if ((old_changes & kModuleInformationChanging) != 0 ||
+      !changes.compare_exchange_strong(old_changes, new_changes,
+                                       std::memory_order_acquire,
+                                       std::memory_order_acquire)) {
+    NOTREACHED() << "Multiple sources are updating module information.";
+    return false;
+  }
+
+  address = info.address;
+  size = info.size;
+  loaded = info.is_loaded ? 1 : 0;
+
+  bool success = changes.compare_exchange_strong(new_changes, old_changes + 1,
+                                                 std::memory_order_release,
+                                                 std::memory_order_relaxed);
+  DCHECK(success);
+  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);

[manzagop (departed), 2017/01/13 23:01:02]

Siggi was suggesting we do as little work for storing and store the most compact
possible. In that line, we may want to store whatever the calling code provides
us with. Do you know if it provides the identifiers, or the underlying info?

For the code identifier, it's the size and timestamp.

For the debug identifier, a guid and an age.
https://cs.chromium.org/chromium/src/base/profiler/native_stack_sampler_win.c...

[bcwhite, 2017/01/14 01:23:24]

According to my brief conversation with Chris, it provides nothing but a handle
to the module from which code can be written to gather whatever information is
desired.

These fields reflect what would be given to the proto during upload.  I can
change it to anything you wish and have the reporting code translate it or I can
leave it as is and have the code that loads this information do whatever
translation is necessary.  Or the proto could be changed plus either of the
above.  :-)

+
+  return offsetof(ModuleInfoRecord, pickle) + sizeof(Pickle::Header) +
+         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 108 matching lines @@
   // Convert the memory block found above into an actual memory address.
   // Doing the conversion as a Header object enacts the 32/64-bit size
   // consistency checks which would not otherwise be done. Unfortunately,
   // some older compilers and MSVC don't have standard-conforming definitions
   // of std::atomic which cause it not to be plain-old-data. Don't check on
   // those platforms assuming that the checks on other platforms will be
   // sufficient.
   // TODO(bcwhite): Review this after major compiler releases.
   DCHECK(mem_reference);
   void* mem_base;
-#if 0  // TODO(bcwhite): Update this for new GetAsObject functionality.
-  mem_base = allocator_->GetAsObject<ThreadActivityTracker::Header>(
-      mem_reference, kTypeIdActivityTracker);
-#else
-  mem_base = allocator_->GetAsArray<char>(mem_reference, kTypeIdActivityTracker,
-                                          PersistentMemoryAllocator::kSizeAny);
-#endif
+  mem_base =
+      allocator_->GetAsObject<ThreadActivityTracker::Header>(mem_reference);
 
   DCHECK(mem_base);
   DCHECK_LE(stack_memory_size_, allocator_->GetAllocSize(mem_reference));
 
   // Create a tracker with the acquired memory and set it as the tracker
   // for this particular thread in thread-local-storage.
   ManagedActivityTracker* tracker =
       new ManagedActivityTracker(mem_reference, mem_base, stack_memory_size_);
   DCHECK(tracker->IsValid());
   this_thread_tracker_.Set(tracker);
@@ skipping 17 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 = found->second;
+    DCHECK(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);
+  ModuleInfoRecord* record =
+      allocator_->AllocateObject<ModuleInfoRecord>(required_size);
+  if (!record)
+    return;
+
+  bool success = record->EncodeFrom(info, required_size);
+  DCHECK(success);
+  allocator_->MakeIterable(record);
+  modules_.insert(std::make_pair(info.file, record));
+}
+
 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