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

base/debug/activity_tracker.h

 // 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.
 
 // Activity tracking provides a low-overhead method of collecting information
 // about the state of the application for analysis both while it is running
 // and after it has terminated unexpectedly. Its primary purpose is to help
 // locate reasons the browser becomes unresponsive by providing insight into
 // what all the various threads and processes are (or were) doing.
 
@@ skipping 628 matching lines @@
   enum : uint32_t {
     kTypeIdActivityTracker = 0x5D7381AF + 3,   // SHA1(ActivityTracker) v3
     kTypeIdUserDataRecord = 0x615EDDD7 + 2,    // SHA1(UserDataRecord) v2
     kTypeIdGlobalLogMessage = 0x4CF434F9 + 1,  // SHA1(GlobalLogMessage) v1
     kTypeIdGlobalDataRecord = kTypeIdUserDataRecord + 1000,
 
     kTypeIdActivityTrackerFree = ~kTypeIdActivityTracker,
     kTypeIdUserDataRecordFree = ~kTypeIdUserDataRecord,
   };
 
+  // This structure contains information about a loaded module, as shown to
+  // users of the tracker.
+  struct BASE_EXPORT ModuleInfo {
+    ModuleInfo();
+    ModuleInfo(ModuleInfo&& rhs);
+    ModuleInfo(const ModuleInfo& rhs);
+    ~ModuleInfo();
+
+    ModuleInfo& operator=(ModuleInfo&& rhs);
+    ModuleInfo& operator=(const ModuleInfo& rhs);
+
+    // Information about where and when the module was loaded/unloaded.
+    bool is_loaded = false;
+    uintptr_t address = 0;
+    size_t size = 0;

[manzagop (departed), 2017/01/23 20:33:29]

Size should probably go below with things that cannot change. If it does change,
likely identifier, guid, etc are no longer right either.

[bcwhite, 2017/01/24 13:45:53]

Done.

I was thinking of it like mapped memory where it's possible to map only a
portion of it.

+    int64_t timestamp = 0;

[manzagop (departed), 2017/01/23 20:33:29]

Would loader_timestamp lift confusion wrt below timestamp?

[bcwhite, 2017/01/24 13:45:53]

Done.

+
+    // Information about the module itself. These never change no matter how
+    // many times a module may be loaded and unloaded.
+    uint32_t identifier;

[manzagop (departed), 2017/01/23 20:33:29]

Is this the module's timestamp which we'll combine with the size to get the
identifier?

[bcwhite, 2017/01/24 13:45:53]

Oh, sorry.  I misread the comments in your email.

+    uint32_t age;

[manzagop (departed), 2017/01/23 20:33:29]

Wdyt of debug_age, debug_guid?

[bcwhite, 2017/01/24 13:45:53]

Would those be directly tied to that of the main module?  Easy enough to add,
now or in the future, if you'll have the data source to populate them.

[manzagop (departed), 2017/01/24 14:42:46]

Oh I meant that age and guid are properties of the module's debug file. No need
to add anything.

[manzagop (departed), 2017/01/25 14:53:29]

But prefixing with debug_ might lift some ambiguity.

+    uint64_t guid;

[manzagop (departed), 2017/01/23 20:33:29]

I said 8 bytes and I was wrong. It's 16 bytes:
https://msdn.microsoft.com/en-us/library/system.guid(v=vs.110).aspx

[bcwhite, 2017/01/24 13:45:53]

Done.  Though "guid" sounds like a windows-specific thing.  Perhaps "identifier"
would be better?

[manzagop (departed), 2017/01/24 14:42:46]

You're right other platforms likely don't have a guid but I don't know what they
have. Identifier would be confusing though because the debug identifier is a
function of (age, guid). Ignore for now since we're windows only for now?

[bcwhite, 2017/01/24 14:54:39]

Perhaps it should just be a std::string then since the length is platform
specific.  You can still save raw bytes in a std::string.

I don't think we have to be concerned about naming ambiguities.  Windows can
have a "win_id" when you build it.  To this class, it's just an opaque
identifier.

+    std::string file;
+    std::string debug_file;
+  };
+
   // This is a thin wrapper around the thread-tracker's ScopedActivity that
   // accesses the global tracker to provide some of the information, notably
   // which thread-tracker to use. It is safe to create even if activity
   // tracking is not enabled.
   class BASE_EXPORT ScopedThreadActivity
       : public ThreadActivityTracker::ScopedActivity {
    public:
     ScopedThreadActivity(const void* program_counter,
                          const void* origin,
                          Activity::Type type,
@@ skipping 83 matching lines @@
   // Creates an activity-tracker for the current thread.
   ThreadActivityTracker* CreateTrackerForCurrentThread();
 
   // Releases the activity-tracker for the current thread (for testing only).
   void ReleaseTrackerForCurrentThreadForTesting();
 
   // Records a log message. The current implementation does NOT recycle these
   // only store critical messages such as FATAL ones.
   void RecordLogMessage(StringPiece message);
 
+  // Records a module load/unload event. This is safe to call multiple times
+  // even with the same information.
+  void RecordModuleInfo(const ModuleInfo& info);
+
   // Accesses the global data record for storing arbitrary key/value pairs.
   ActivityUserData& user_data() { return user_data_; }
 
  private:
+  friend class GlobalActivityAnalyzer;
   friend class ScopedThreadActivity;
   friend class ActivityTrackerTest;
 
   enum : int {
     // The maximum number of threads that can be tracked within a process. If
     // more than this number run concurrently, tracking of new ones may cease.
     kMaxThreadCount = 100,
     kCachedThreadMemories = 10,
     kCachedUserDataMemories = 10,
   };
 
+  // State of a module as stored in persistent memory. This supports a single
+  // loading of a module only. If modules are loaded multiple times at
+  // different addresses, only the last will be recorded and an unload will
+  // not revert to the information of any other addresses.
+  struct BASE_EXPORT ModuleInfoRecord {
+    // SHA1(ModuleInfoRecord): Increment this if structure changes!
+    static constexpr uint32_t kPersistentTypeId = 0x05DB5F41 + 1;
+
+    // Expected size for 32/64-bit check by PersistentMemoryAllocator.
+    static constexpr size_t kExpectedInstanceSize = 48;
+
+    // The atomic unfortunately makes this a "complex" class on some compilers
+    // and thus requires an out-of-line constructor & destructor even though
+    // they do nothing.
+    ModuleInfoRecord();
+    ~ModuleInfoRecord();
+
+    uint64_t address;               // The base address of the module.
+    uint64_t size;                  // The size of the module in bytes.
+    uint64_t timestamp;             // Time of last load/unload.
+    uint32_t identifier;            // Unique identifier for this module.
+    uint32_t age;                   // The age of the module.
+    uint64_t guid;                  // GUID of the module.
+    std::atomic<uint32_t> changes;  // Number load/unload actions.
+    uint16_t pickle_size;           // The size of the following pickle.
+    uint8_t loaded;                 // Flag if module is loaded or not.
+    char pickle[1];                 // Other strings; may allocate larger.
+
+    // Decodes/encodes storage structure from more generic info structure.
+    bool DecodeTo(GlobalActivityTracker::ModuleInfo* info,
+                  size_t record_size) const;
+    bool EncodeFrom(const GlobalActivityTracker::ModuleInfo& info,
+                    size_t record_size);
+
+    // 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);
+
+    // Determines the required memory size for the encoded storage.
+    static size_t EncodedSize(const GlobalActivityTracker::ModuleInfo& info);
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(ModuleInfoRecord);
+  };
+
   // A thin wrapper around the main thread-tracker that keeps additional
   // information that the global tracker needs to handle joined threads.
   class ManagedActivityTracker : public ThreadActivityTracker {
    public:
     ManagedActivityTracker(PersistentMemoryAllocator::Reference mem_reference,
                            void* base,
                            size_t size);
     ~ManagedActivityTracker() override;
 
     // The reference into persistent memory from which the thread-tracker's
@@ skipping 41 matching lines @@
   base::Lock thread_tracker_allocator_lock_;
 
   // A caching memory allocator for user data attached to activity data.
   ActivityTrackerMemoryAllocator user_data_allocator_;
   base::Lock user_data_allocator_lock_;
 
   // An object for holding global arbitrary key value pairs. Values must always
   // be written from the main UI thread.
   ActivityUserData user_data_;
 
+  // A map of global module information, keyed by module path.
+  std::map<const std::string, ModuleInfoRecord*> modules_;
+  base::Lock modules_lock_;
+
   // The active global activity tracker.
   static GlobalActivityTracker* g_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(GlobalActivityTracker);
 };
 
 
 // Record entry in to and out of an arbitrary block of code.
 class BASE_EXPORT ScopedActivity
     : public GlobalActivityTracker::ScopedThreadActivity {
@@ skipping 117 matching lines @@
   ScopedProcessWaitActivity(const void* program_counter,
                             const base::Process* process);
   DISALLOW_COPY_AND_ASSIGN(ScopedProcessWaitActivity);
 };
 #endif
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_ACTIVITY_TRACKER_H_