Enable storing last-dispatched exception per-thread.

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 78 matching lines @@
   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 {
+  // Expected size for 32/64-bit check.
+  // TODO(bcwhite): VC2015 doesn't allow statics in unions. Fix when it does.
+  // static constexpr size_t kExpectedInstanceSize = 8;
+
   // 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;
   struct {
     uint64_t sequence_id;  // The sequence identifier of the posted task.
   } task;
   struct {
     uint64_t lock_address;  // The memory address of the lock object.
@@ skipping 117 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ActivityTrackerMemoryAllocator);
 };
 
 
 // This structure is the full contents recorded for every activity pushed
 // onto the stack. The |activity_type| indicates what is actually stored in
 // the |data| field. All fields must be explicitly sized types to ensure no
 // interoperability problems between 32-bit and 64-bit systems.
 struct Activity {
+  // Expected size for 32/64-bit check.
+  static constexpr size_t kExpectedInstanceSize =
+      40 + 8 * kActivityCallStackSize +
+      /*ActivityData::kExpectedInstanceSize=*/8;
+
   // The type of an activity on the stack. Activities are broken into
   // categories with the category ID taking the top 4 bits and the lower
   // bits representing an action within that category. This combination
   // makes it easy to "switch" based on the type during analysis.
   enum Type : uint8_t {
     // This "null" constant is used to indicate "do not change" in calls.
     ACT_NULL = 0,
 
     // Task activities involve callbacks posted to a thread or thread-pool
     // using the PostTask() method or any of its friends.
@@ skipping 13 matching lines @@
     // Thread activities involve the life management of threads.
     ACT_THREAD = 4 << 4,
     ACT_THREAD_START = ACT_THREAD,
     ACT_THREAD_JOIN,
 
     // Process activities involve the life management of processes.
     ACT_PROCESS = 5 << 4,
     ACT_PROCESS_START = ACT_PROCESS,
     ACT_PROCESS_WAIT,
 
+    // Exception activities indicate the occurence of something unexpected.
+    ACT_EXCEPTION = 14 << 4,
+
     // Generic activities are user defined and can be anything.
     ACT_GENERIC = 15 << 4,
 
     // These constants can be used to separate the category and action from
     // a combined activity type.
     ACT_CATEGORY_MASK = 0xF << 4,
     ACT_ACTION_MASK = 0xF
   };
 
   // Internal representation of time. During collection, this is in "ticks"
@@ skipping 91 matching lines @@
     friend class ActivityUserData;
 
     ValueType type_;
     uint64_t short_value_;    // Used to hold copy of numbers, etc.
     std::string long_value_;  // Used to hold copy of raw/string data.
     StringPiece ref_value_;   // Used to hold reference to external data.
   };
 
   using Snapshot = std::map<std::string, TypedValue>;
 
+  ActivityUserData();
   ActivityUserData(void* memory, size_t size);

[manzagop (departed), 2017/02/27 16:05:16]

Mention memory points to zeroed out memory.

[bcwhite, 2017/03/14 12:53:26]

Done.

   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 header_ ? header_->owner.data_id.load(std::memory_order_relaxed) : 0;
   }
 
+  // Resets everything back to nothing stored.
+  void Reset();
+
   // 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
   // recording depth.
   void Set(StringPiece name, const void* memory, size_t size) {
@@ skipping 98 matching lines @@
     void* memory;                     // Where the "value" is held.
     std::atomic<uint16_t>* size_ptr;  // Address of the actual size of value.
     size_t extent;                    // The total storage of the value,
   };                                  // typically rounded up for alignment.
 
   void SetReference(StringPiece name,
                     ValueType type,
                     const void* memory,
                     size_t size);
 
+  // Performs initialization on empty memory.
+  void Initialize();
+
   // Loads any data already in the memory segment. This allows for accessing
   // records created previously.
   void ImportExistingData() const;
 
   // A map of all the values within the memory block, keyed by name for quick
   // 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
@@ skipping 46 matching lines @@
     int64_t process_id = 0;
     int64_t thread_id = 0;
 
     // The current stack of activities that are underway for this thread. It
     // is limited in its maximum size with later entries being left off.
     std::vector<Activity> activity_stack;
 
     // The current total depth of the activity stack, including those later
     // entries not recorded in the |activity_stack| vector.
     uint32_t activity_stack_depth = 0;
+
+    // The last recorded "exception" activity.
+    Activity last_exception;
   };
 
   // This is the base class for having the compiler manage an activity on the
   // tracker's stack. It does nothing but call methods on the passed |tracker|
   // if it is not null, making it safe (and cheap) to create these objects
   // even if activity tracking is not enabled.
   class BASE_EXPORT ScopedActivity {
    public:
     ScopedActivity(ThreadActivityTracker* tracker,
                    const void* program_counter,
@@ skipping 63 matching lines @@
       ActivityTrackerMemoryAllocator* allocator);
 
   // Returns if there is true use-data associated with a given ActivityId since
   // it's possible than any returned object is just a sink.
   bool HasUserData(ActivityId id);
 
   // Release the user-data information for an activity.
   void ReleaseUserData(ActivityId id,
                        ActivityTrackerMemoryAllocator* allocator);
 
+  // Save an exception and return space for additional information.
+  ActivityUserData& ExceptionActivity(const void* program_counter,
+                                      const void* origin,
+                                      Activity::Type type,
+                                      const ActivityData& data);
+
   // 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;
 
@@ skipping 10 matching lines @@
                                  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;
 
+  std::unique_ptr<ActivityUserData> CreateUserDataForActivity(
+      Activity* activity,
+      ActivityTrackerMemoryAllocator* allocator);
+
   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.
 
   bool valid_ = false;          // Tracks whether the data is valid or not.
 
+  // A user-data object for information associated with the last exception.
+  std::unique_ptr<ActivityUserData> exception_data;
+
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadActivityTracker);
 };
 
 
 // The global tracker manages all the individual thread trackers. Memory for
 // the thread trackers is taken from a PersistentMemoryAllocator which allows
 // for the data to be analyzed by a parallel process or even post-mortem.
 class BASE_EXPORT GlobalActivityTracker {
@@ skipping 197 matching lines @@
                                            const FilePath::StringType& args) {
     GlobalActivityTracker* tracker = Get();
     if (tracker)
       tracker->RecordProcessLaunch(process_id, exe, args);
   }
   static void RecordProcessExitIfEnabled(ProcessId process_id, int exit_code) {
     GlobalActivityTracker* tracker = Get();
     if (tracker)
       tracker->RecordProcessExit(process_id, exit_code);
   }
+
   // Sets the "phase" of the current process, useful for knowing what it was
   // doing when it last reported.
   void SetProcessPhase(ProcessPhase phase);
   static void SetProcessPhaseIfEnabled(ProcessPhase phase) {
     GlobalActivityTracker* tracker = Get();
     if (tracker)
       tracker->SetProcessPhase(phase);
   }
 
   // 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);
 
+  // Record exception information for the current thread and return space where
+  // additional information may be recorded.
+  // TODO(bcwhite): More parameters (space for 4 + 64 bits).
+  ALWAYS_INLINE
+  ActivityUserData& RecordException(const void* origin) {
+    return RecordExceptionImpl(::tracked_objects::GetProgramCounter(), origin);
+  }
+
   // 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;
@@ skipping 97 matching lines @@
   // Creates a global tracker using a given persistent-memory |allocator| and
   // providing the given |stack_depth| to each thread tracker it manages. The
   // created object is activated so tracking has already started upon return.
   GlobalActivityTracker(std::unique_ptr<PersistentMemoryAllocator> allocator,
                         int stack_depth);
 
   // 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);
 
+  // Records exception information.
+  ActivityUserData& RecordExceptionImpl(const void* pc, const void* origin);
+
+  // Reserves an ActivityUserData object for storing exception information.
+  void ReserveExceptionData();
+
   // 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,
                            int exit_code,
                            std::string&& command_line);
@@ skipping 173 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_