Multi-Process Tracking Support

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.
 
 #ifndef BASE_DEBUG_ACTIVITY_TRACKER_H_
 #define BASE_DEBUG_ACTIVITY_TRACKER_H_
 
 // std::atomic is undesired due to performance issues when used as global
 // variables. There are no such instances here. This module uses the
 // PersistentMemoryAllocator which also uses std::atomic and is written
 // by the same author.
 #include <atomic>
 #include <map>
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/location.h"
 #include "base/metrics/persistent_memory_allocator.h"
+#include "base/process/process_handle.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 
 struct PendingTask;
 
 class FilePath;
 class Lock;
 class PlatformThreadHandle;
 class Process;
-class StaticAtomicSequenceNumber;
 class WaitableEvent;
 
 namespace debug {
 
 class ThreadActivityTracker;
 
 
 enum : int {
   // The maximum number of call-stack addresses stored per activity. This
   // cannot be changed without also changing the version number of the
   // structure. See kTypeIdActivityTracker in GlobalActivityTracker.
   kActivityCallStackSize = 10,
 };
 
+struct ProcessInfo {
+  ProcessInfo();
+  ~ProcessInfo();
+
+  // Initializes structure with the current process id and the current time.
+  // These can uniquely identify a process. A unique non-zero data_id will be
+  // set making it possible to tell using atomic reads if the data has changed.
+  void Release_Initialize();
+
+  // Explicitly sets the process ID.
+  void SetOwningProcessIdForTesting(ProcessId pid, int64_t stamp);
+
+  // Gets the associated process ID, in native form, and the creation timestamp
+  // from tracker memory without loading the entire structure for analysis. This
+  // will return false if no valid process ID is available.
+  static bool OwningProcessId(const void* memory,
+                              ProcessId* out_id,
+                              int64_t* out_stamp);
+
+  // SHA1(base::debug::ProcessInfo): Increment this if structure changes!
+  static constexpr uint32_t kPersistentTypeId = 0xD485C718 + 1;
+
+  // Expected size for 32/64-bit check by PersistentMemoryAllocator.
+  static constexpr size_t kExpectedInstanceSize = 24;
+
+  std::atomic<uint32_t> data_id;
+  uint32_t padding;
+  int64_t process_id;
+  int64_t create_stamp;
+};
+
 // The data associated with an activity is dependent upon the activity type.
 // This union defines all of the various fields. All fields must be explicitly
 // sized types to ensure no interoperability problems between 32-bit and
 // 64-bit systems.
 union ActivityData {
   // Generic activities don't have any defined structure.
   struct {
     uint32_t id;   // An arbitrary identifier used for association.
     int32_t info;  // An arbitrary value used for information purposes.
   } generic;
@@ skipping 273 matching lines @@
 
   using Snapshot = std::map<std::string, TypedValue>;
 
   ActivityUserData(void* memory, size_t size);
   virtual ~ActivityUserData();
 
   // Gets the unique ID number for this user data. If this changes then the
   // contents have been overwritten by another thread. The return value is
   // always non-zero unless it's actually just a data "sink".
   uint32_t id() const {
-    return memory_ ? id_->load(std::memory_order_relaxed) : 0;
+    return header_
+               ? header_->process_info.data_id.load(std::memory_order_relaxed)
+               : 0;
   }
 
   // Writes a |value| (as part of a key/value pair) that will be included with
   // the activity in any reports. The same |name| can be written multiple times
   // with each successive call overwriting the previously stored |value|. For
   // raw and string values, the maximum size of successive writes is limited by
   // the first call. The length of "name" is limited to 255 characters.
   //
   // This information is stored on a "best effort" basis. It may be dropped if
   // the memory buffer is full or the associated activity is beyond the maximum
@@ skipping 35 matching lines @@
   // Creates a snapshot of the key/value pairs contained within. The returned
   // data will be fixed, independent of whatever changes afterward. There is
   // protection against concurrent modification of the values but no protection
   // against a complete overwrite of the contents; the caller must ensure that
   // the memory segment is not going to be re-initialized while this runs.
   bool CreateSnapshot(Snapshot* output_snapshot) const;
 
   // Gets the base memory address used for storing data.
   const void* GetBaseAddress();
 
+  // Explicitly sets the process ID.
+  void SetOwningProcessIdForTesting(ProcessId pid, int64_t stamp);
+
+  // Gets the associated process ID, in native form, and the creation timestamp
+  // from tracker memory without loading the entire structure for analysis. This
+  // will return false if no valid process ID is available.
+  static bool OwningProcessId(const void* memory,
+                              ProcessId* out_id,
+                              int64_t* out_stamp);
+
  protected:
   virtual void Set(StringPiece name,
                    ValueType type,
                    const void* memory,
                    size_t size);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ActivityTrackerTest, UserDataTest);
 
   enum : size_t { kMemoryAlignment = sizeof(uint64_t) };
 
   // A structure used to reference data held outside of persistent memory.
   struct ReferenceRecord {
     uint64_t address;
     uint64_t size;
   };
 
+  // A structure that defines the structure header in memory.
+  struct MemoryHeader {
+    MemoryHeader();
+    ~MemoryHeader();
+
+    ProcessInfo process_info;  // Information about the creating process.
+  };
+
   // Header to a key/value record held in persistent memory.
-  struct Header {
+  struct FieldHeader {
+    FieldHeader();
+    ~FieldHeader();
+
     std::atomic<uint8_t> type;         // Encoded ValueType
     uint8_t name_size;                 // Length of "name" key.
     std::atomic<uint16_t> value_size;  // Actual size of of the stored value.
     uint16_t record_size;              // Total storage of name, value, header.
   };
 
   // This record is used to hold known value is a map so that they can be
   // found and overwritten later.
   struct ValueInfo {
     ValueInfo();
@@ skipping 20 matching lines @@
   // updates of the values. This is "mutable" because it changes on "const"
   // objects even when the actual data values can't change.
   mutable std::map<StringPiece, ValueInfo> values_;
 
   // Information about the memory block in which new data can be stored. These
   // are "mutable" because they change even on "const" objects that are just
   // skipping already set values.
   mutable char* memory_;
   mutable size_t available_;
 
-  // A pointer to the unique ID for this instance.
-  std::atomic<uint32_t>* const id_;
-
-  // This ID is used to create unique indentifiers for user data so that it's
-  // possible to tell if the information has been overwritten.
-  static StaticAtomicSequenceNumber next_id_;
+  // A pointer to the memory header for this instance.
+  MemoryHeader* const header_;
 
   DISALLOW_COPY_AND_ASSIGN(ActivityUserData);
 };
 
 // This class manages tracking a stack of activities for a single thread in
 // a persistent manner, implementing a bounded-size stack in a fixed-size
 // memory allocation. In order to support an operational mode where another
 // thread is analyzing this data in real-time, atomic operations are used
 // where necessary to guarantee a consistent view from the outside.
 //
@@ skipping 122 matching lines @@
   // Returns whether the current data is valid or not. It is not valid if
   // corruption has been detected in the header or other data structures.
   bool IsValid() const;
 
   // Gets a copy of the tracker contents for analysis. Returns false if a
   // snapshot was not possible, perhaps because the data is not valid; the
   // contents of |output_snapshot| are undefined in that case. The current
   // implementation does not support concurrent snapshot operations.
   bool CreateSnapshot(Snapshot* output_snapshot) const;
 
+  // Gets the base memory address used for storing data.
+  const void* GetBaseAddress();
+
+  // Explicitly sets the process ID.
+  void SetOwningProcessIdForTesting(ProcessId pid, int64_t stamp);
+
+  // Gets the associated process ID, in native form, and the creation timestamp
+  // from tracker memory without loading the entire structure for analysis. This
+  // will return false if no valid process ID is available.
+  static bool OwningProcessId(const void* memory,
+                              ProcessId* out_id,
+                              int64_t* out_stamp);
+
   // Calculates the memory size required for a given stack depth, including
   // the internal header structure for the stack.
   static size_t SizeForStackDepth(int stack_depth);
 
  private:
   friend class ActivityTrackerTest;
 
   Header* const header_;        // Pointer to the Header structure.
   Activity* const stack_;       // The stack of activities.
   const uint32_t stack_slots_;  // The total number of stack slots.
@@ skipping 11 matching lines @@
 // for the data to be analyzed by a parallel process or even post-mortem.
 class BASE_EXPORT GlobalActivityTracker {
  public:
   // Type identifiers used when storing in persistent memory so they can be
   // identified during extraction; the first 4 bytes of the SHA1 of the name
   // is used as a unique integer. A "version number" is added to the base
   // so that, if the structure of that object changes, stored older versions
   // will be safely ignored. These are public so that an external process
   // can recognize records of this type within an allocator.
   enum : uint32_t {
-    kTypeIdActivityTracker = 0x5D7381AF + 3,   // SHA1(ActivityTracker) v3
-    kTypeIdUserDataRecord = 0x615EDDD7 + 2,    // SHA1(UserDataRecord) v2
+    kTypeIdActivityTracker = 0x5D7381AF + 4,   // SHA1(ActivityTracker) v4
+    kTypeIdUserDataRecord = 0x615EDDD7 + 3,    // SHA1(UserDataRecord) v3
     kTypeIdGlobalLogMessage = 0x4CF434F9 + 1,  // SHA1(GlobalLogMessage) v1
-    kTypeIdGlobalDataRecord = kTypeIdUserDataRecord + 1000,
+    kTypeIdProcessDataRecord = kTypeIdUserDataRecord + 0x100,
+    kTypeIdGlobalDataRecord = kTypeIdUserDataRecord + 0x200,
 
     kTypeIdActivityTrackerFree = ~kTypeIdActivityTracker,
     kTypeIdUserDataRecordFree = ~kTypeIdUserDataRecord,
+    kTypeIdProcessDataRecordFree = ~kTypeIdProcessDataRecord,
   };
 
   // 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();
 
@@ skipping 110 matching lines @@
       return tracker;
     return CreateTrackerForCurrentThread();
   }
 
   // Creates an activity-tracker for the current thread.
   ThreadActivityTracker* CreateTrackerForCurrentThread();
 
   // Releases the activity-tracker for the current thread (for testing only).
   void ReleaseTrackerForCurrentThreadForTesting();
 
+  // Sets a task-runner that can be used for background work.
+  void SetBackgroundTaskRunner(const scoped_refptr<TaskRunner>& runner);
+
+  // Manages process lifetimes.
+  void RecordProcessLaunch(ProcessId process_id);
+  void RecordProcessExit(ProcessId process_id, int exit_code);
+  static void RecordProcessLaunchIfEnabled(ProcessId process_id) {
+    GlobalActivityTracker* tracker = Get();
+    if (tracker)
+      tracker->RecordProcessLaunch(process_id);
+  }
+  static void RecordProcessExitIfEnabled(ProcessId process_id, int exit_code) {
+    GlobalActivityTracker* tracker = Get();
+    if (tracker)
+      tracker->RecordProcessExit(process_id, exit_code);
+  }
+
   // 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);
 
   // Record field trial information. This call is thread-safe. In addition to
   // this, construction of a GlobalActivityTracker will cause all existing
   // active field trials to be fetched and recorded.
   void RecordFieldTrial(const std::string& trial_name, StringPiece group_name);
 
+  // Accesses the process data record for storing arbitrary key/value pairs.
+  // Updates to this are thread-safe.
+  ActivityUserData& process_data() { return process_data_; }
+
   // Accesses the global data record for storing arbitrary key/value pairs.
+  // Updates to this are thread-safe.
   ActivityUserData& global_data() { return global_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,
   };
 
   // A wrapper around ActivityUserData that is thread-safe and thus can be used
   // in the global scope without the requirement of being called from only one
   // thread.
-  class GlobalUserData : public ActivityUserData {
+  class ThreadSafeUserData : public ActivityUserData {
    public:
-    GlobalUserData(void* memory, size_t size);
-    ~GlobalUserData() override;
+    ThreadSafeUserData(void* memory, size_t size);
+    ~ThreadSafeUserData() override;
 
    private:
     void Set(StringPiece name,
              ValueType type,
              const void* memory,
              size_t size) override;
 
     Lock data_lock_;
 
-    DISALLOW_COPY_AND_ASSIGN(GlobalUserData);
+    DISALLOW_COPY_AND_ASSIGN(ThreadSafeUserData);
   };
 
   // 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 = 56;
+    static constexpr size_t kExpectedInstanceSize =
+        ProcessInfo::kExpectedInstanceSize + 56;
 
     // 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();
 
+    ProcessInfo process_info;       // The process that created this record.
     uint64_t address;               // The base address of the module.
     uint64_t load_time;             // Time of last load/unload.
     uint64_t size;                  // The size of the module in bytes.
     uint32_t timestamp;             // Opaque timestamp of the module.
     uint32_t age;                   // Opaque "age" associated with the module.
     uint8_t identifier[16];         // Opaque identifier for 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.
@@ skipping 43 matching lines @@
 
   // Returns the memory used by an activity-tracker managed by this class.
   // It is called during the destruction of a ManagedActivityTracker object.
   void ReturnTrackerMemory(ManagedActivityTracker* tracker);
 
   // Releases the activity-tracker associcated with thread. It is called
   // automatically when a thread is joined and thus there is nothing more to
   // be tracked. |value| is a pointer to a ManagedActivityTracker.
   static void OnTLSDestroy(void* value);
 
+  // Does process-exit work. This can be run on any thread.
+  void CleanupAfterProcess(ProcessId process_id, int64_t exit_stamp);

[manzagop (departed), 2017/02/22 20:44:15]

I'm still not sure how we call CleanupAfterProcess if the child crashes. Eg, for
renderers, do we need to add a call in RenderProcessHost::ProcessDied or the
like?

[bcwhite, 2017/02/22 22:13:02]

Shouldn't.  The base Process code deals with the cleanup of child processes and
it updates the tracker.

+
   // The persistent-memory allocator from which the memory for all trackers
   // is taken.
   std::unique_ptr<PersistentMemoryAllocator> allocator_;
 
   // The size (in bytes) of memory required by a ThreadActivityTracker to
   // provide the stack-depth requested during construction.
   const size_t stack_memory_size_;
 
   // The activity tracker for the currently executing thread.
   base::ThreadLocalStorage::Slot this_thread_tracker_;
 
   // The number of thread trackers currently active.
   std::atomic<int> thread_tracker_count_;
 
   // A caching memory allocator for thread-tracker objects.
   ActivityTrackerMemoryAllocator thread_tracker_allocator_;
   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.
-  GlobalUserData global_data_;
+  // An object for holding arbitrary key value pairs with thread-safe access.
+  ThreadSafeUserData process_data_;
+  ThreadSafeUserData global_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 subtle::AtomicWord g_tracker_;
 
+  // A lock that is used to procect access to the following fields.
+  base::Lock global_tracker_lock_;
+
+  // The collection of processes being tracked.

[manzagop (departed), 2017/02/22 20:44:15]

This is not persistent information. Should it be?

The reason would be to avoid the time window after we've posted
CleanupAfterProcess but before the task was processed. If we crash during that
time window, we'll think the other process is still running.

[bcwhite, 2017/02/22 22:13:02]

That race would continue to exist because the process could exit but the browser
might crash before updating the list.

In any case it is possible to find a process that has "exited" among the crumbs
but that'll be recognizable during analysis because that process will have a
"phase" value indicating where it was at the time.

Perhaps more problematic is a browser crash where the subprocesses continue to
operate.  The crumbs would hold state information from after the browser death,
perhaps including a clean exit (though no clean-up).

+  std::set<int64_t> known_processes_;
+
+  // A task-runner that can be used for doing background processing.
+  scoped_refptr<TaskRunner> background_task_runner_;
+
   DISALLOW_COPY_AND_ASSIGN(GlobalActivityTracker);
 };
 
 
 // Record entry in to and out of an arbitrary block of code.
 class BASE_EXPORT ScopedActivity
     : public GlobalActivityTracker::ScopedThreadActivity {
  public:
   // Track activity at the specified FROM_HERE location for an arbitrary
   // 4-bit |action|, an arbitrary 32-bit |id|, and 32-bits of arbitrary
@@ skipping 114 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_