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 {
 
 // 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 kUserDataSize = 1024;       // bytes
+const size_t kGlobalDataSize = 4096;     // bytes
+const size_t kGlobalModulesSize = 4096;  // bytes
 const size_t kMaxUserDataNameLength =
     static_cast<size_t>(std::numeric_limits<uint8_t>::max());
 
 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
   // is no one correct way to convert it to a numerical identifier.
   PlatformThreadHandle::Handle as_handle;
 #endif
 };
 
+// State of a module as stared in persistent memory.

[manzagop (departed), 2016/12/14 20:08:53]

typo: stared -> stored

[bcwhite, 2016/12/14 21:59:05]

Done.

+struct ModuleInfoStore {
+  // Expected size for 32/64-bit check.
+  static constexpr size_t kExpectedInstanceSize = 24;

[manzagop (departed), 2016/12/14 20:08:53]

nit: I like having units in variable names (kExpectedInstanceSizeBytes).
Personal preference, up to you. 

[manzagop (departed), 2016/12/14 20:08:53]

Unused?

[bcwhite, 2016/12/14 21:59:05]

The constant is required (and used) by the PersistentMemoryAllocator. The name
is fixed.

+
+  uint64_t address;      // The base address of the module.
+  uint64_t size;         // The size of the module in bytes.
+  uint16_t pickle_size;  // The size of the following pickle.
+  uint8_t loaded;        // Flag indicating if module is loaded or not.
+  char pickle[5];        // Other strings; may allocate larger.
+
+  // Decodes/encodes storage structure from more generic info structure.
+  bool DecodeTo(GlobalActivityTracker::ModuleInfo* info);
+  bool EncodeFrom(const GlobalActivityTracker::ModuleInfo& info, size_t size);

[manzagop (departed), 2016/12/14 20:08:53]

Why do you need the size? Ah it's the size budget. Maybe rename (max_size or ?)
and possibly add a comment.

[bcwhite, 2016/12/14 21:59:05]

Done.

+
+  // Updates the core information without changing the encoded strings. This is
+  // useful when a known module changes state (i.e. new load or unload).
+  bool UpdateFrom(const GlobalActivityTracker::ModuleInfo& info);
+
+  // Deterimes the required memory size for the encoded storage.

[manzagop (departed), 2016/12/14 20:08:53]

typo: Deterimes

[bcwhite, 2016/12/14 21:59:05]

Done.

+  static size_t EncodedSize(const GlobalActivityTracker::ModuleInfo& info);
+};
+
+static constexpr size_t kModuleInfoStoreHeaderSize =
+    sizeof(ModuleInfoStore) - sizeof(((ModuleInfoStore*)0)->pickle);

[manzagop (departed), 2016/12/14 20:08:53]

Size of on the null pointer smells funny to me. Would offsetof(ModuleInfoStore,
pickle) work?

[bcwhite, 2016/12/14 21:59:05]

Done.

+
+bool ModuleInfoStore::DecodeTo(GlobalActivityTracker::ModuleInfo* info) {
+  std::atomic_thread_fence(std::memory_order_acquire);
+  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 ModuleInfoStore::EncodeFrom(const GlobalActivityTracker::ModuleInfo& info,
+                                 size_t 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 (pickler.size() + kModuleInfoStoreHeaderSize > size) {
+    NOTREACHED();
+    return false;
+  }
+
+  memcpy(pickle, pickler.data(), pickler.size());
+  return UpdateFrom(info);
+}
+
+bool ModuleInfoStore::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 ModuleInfoStore::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 kModuleInfoStoreHeaderSize + sizer.payload_size();
+}
+
 // Determines the previous aligned index.
 size_t RoundDownToAlignment(size_t index, size_t alignment) {
   return index & (0 - alignment);
 }
 
 // Determines the next aligned index.
 size_t RoundUpToAlignment(size_t index, size_t alignment) {
   return (index + (alignment - 1)) & (0 - alignment);
 }
 
@@ skipping 987 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()) {
+    ModuleInfoStore* store = allocator_->GetAsObject<ModuleInfoStore>(
+        found->second, kTypeIdModulesRecord);
+    DCHECK(store);
+
+    // Get should never fail but need to be tolerant in production.
+    if (store) {
+      // 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 accomodate a possibly longer length.

[manzagop (departed), 2016/12/14 20:08:53]

typo: accommodate

[bcwhite, 2016/12/14 21:59:05]

Done.

+      store->UpdateFrom(info);
+      return;

[manzagop (departed), 2016/12/14 20:08:53]

return outside the if(store)?

[bcwhite, 2016/12/14 21:59:05]

If it fails to load it, a new record will be created below.

[manzagop (departed), 2016/12/16 16:09:31]

But then the map insertion will fail as the key already exists?

[bcwhite, 2016/12/16 18:35:15]

Good point.  Always return.

+    }
+  }
+
+  size_t required_size = ModuleInfoStore::EncodedSize(info);
+  PersistentMemoryAllocator::Reference ref =
+      allocator_->Allocate(required_size, kTypeIdModulesRecord);
+  ModuleInfoStore* store =
+      allocator_->GetAsObject<ModuleInfoStore>(ref, kTypeIdModulesRecord);
+  if (!store)
+    return;
+
+  bool success = store->EncodeFrom(info, allocator_->GetAllocSize(ref));
+  DCHECK(success);
+  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