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);
   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;
   }
 
@@ skipping 174 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,
+      ActivityTrackerMemoryAllocator* allocator);
+
   // 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 19 matching lines @@
   // An enumeration of common process life stages. All entries are given an
   // explicit number so they are known and remain constant; this allows for
   // cross-version analysis either locally or on a server.
   enum ProcessPhase : int {
     // The phases are generic and may have meaning to the tracker.
     PROCESS_PHASE_UNKNOWN = 0,
     PROCESS_LAUNCHED = 1,
     PROCESS_LAUNCH_FAILED = 2,
     PROCESS_EXITED_CLEANLY = 10,
     PROCESS_EXITED_WITH_CODE = 11,
+    PROCESS_UNHANDLED_EXCEPTION = 50,

[manzagop (departed), 2017/02/24 19:06:14]

Perhaps this should be kept separate (e.g. a hit-exception key set to true), so
we keep the information about the state when the exception occurred. The
exception might also be recovered from.

[bcwhite, 2017/02/24 19:10:58]

Actually, I need to remove it because it writes to process_data which has a
lock.

 
     // Add here whatever is useful for analysis.
     PROCESS_SHUTDOWN_STARTED = 100,
     PROCESS_MAIN_LOOP_STARTED = 101,
   };
 
   // A callback made when a process exits to allow immediate analysis of its
   // data. Note that the system may reuse the |process_id| so when fetching
   // records its important to ensure that what is returned was created before
   // the |exit_stamp|. Movement of |process_data| information is allowed.
@@ skipping 158 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);

[Sigurður Ásgeirsson, 2017/02/24 18:37:41]

no - this the program counter will have to come from the exception record.
There'll only be one or two places where you record this, and those places are
incidental.

This is however useful for ScopedFromHereAnnotation-style things, used to drill
into e.g. frequently occurring tasks...

[bcwhite, 2017/02/24 19:10:58]

Every activity holds the PC of where it was created so this is just for
consistency.  The "origin" has the source of the exception.

+  }
+
   // 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);
+
   // 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_