Enable storing last-dispatched exception per-thread.

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 <limits>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #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/lazy_instance.h"
 #include "base/logging.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"
@@ skipping 19 matching lines @@
 // A constant used to indicate that module information is changing.
 const uint32_t kModuleInformationChanging = 0x80000000;
 
 // The key used to record process information.
 const char kProcessPhaseDataKey[] = "process-phase";
 
 // An atomically incrementing number, used to check for recreations of objects
 // in the same memory space.
 StaticAtomicSequenceNumber g_next_id;
 
+// An reusable user-data sink that just discards all data saved to it.
+LazyInstance<ActivityUserData>::Leaky g_data_sink;
+
 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
@@ skipping 244 matching lines @@
 // thus clang requires explicit out-of-line constructors and destructors even
 // when they do nothing.
 ActivityUserData::ValueInfo::ValueInfo() {}
 ActivityUserData::ValueInfo::ValueInfo(ValueInfo&&) = default;
 ActivityUserData::ValueInfo::~ValueInfo() {}
 ActivityUserData::MemoryHeader::MemoryHeader() {}
 ActivityUserData::MemoryHeader::~MemoryHeader() {}
 ActivityUserData::FieldHeader::FieldHeader() {}
 ActivityUserData::FieldHeader::~FieldHeader() {}
 
+ActivityUserData::ActivityUserData() : ActivityUserData(nullptr, 0) {}
+
 ActivityUserData::ActivityUserData(void* memory, size_t size)
     : memory_(reinterpret_cast<char*>(memory)),
       available_(RoundDownToAlignment(size, kMemoryAlignment)),
       header_(reinterpret_cast<MemoryHeader*>(memory)) {
   // It's possible that no user data is being stored.
   if (!memory_)
     return;
 
   static_assert(0 == sizeof(MemoryHeader) % kMemoryAlignment, "invalid header");
   DCHECK_LT(sizeof(MemoryHeader), available_);
@@ skipping 221 matching lines @@
 // This information is kept for every thread that is tracked. It is filled
 // the very first time the thread is seen. All fields must be of exact sizes
 // so there is no issue moving between 32 and 64-bit builds.
 struct ThreadActivityTracker::Header {
   // Defined in .h for analyzer access. Increment this if structure changes!
   static constexpr uint32_t kPersistentTypeId =
       GlobalActivityTracker::kTypeIdActivityTracker;
 
   // Expected size for 32/64-bit check.
   static constexpr size_t kExpectedInstanceSize =
-      OwningProcess::kExpectedInstanceSize + 72;
+      OwningProcess::kExpectedInstanceSize + Activity::kExpectedInstanceSize +
+      72;
 
   // This information uniquely identifies a process.
   OwningProcess owner;
 
   // The thread-id (thread_ref.as_id) to which this data belongs. This number
   // is not guaranteed to mean anything but combined with the process-id from
   // OwningProcess is unique among all active trackers.
   ThreadRef thread_ref;
 
   // The start-time and start-ticks when the data was created. Each activity
   // record has a |time_internal| value that can be converted to a "wall time"
   // with these two values.
   int64_t start_time;
   int64_t start_ticks;
 
   // The number of Activity slots (spaces that can hold an Activity) that
   // immediately follow this structure in memory.
   uint32_t stack_slots;
 
   // Some padding to keep everything 64-bit aligned.
   uint32_t padding;
 
   // The current depth of the stack. This may be greater than the number of
   // slots. If the depth exceeds the number of slots, the newest entries
   // won't be recorded.
   std::atomic<uint32_t> current_depth;
 
   // A memory location used to indicate if changes have been made to the stack

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

update comment

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

Done.

   // that would invalidate an in-progress read of its contents. The active
   // tracker will zero the value whenever something gets popped from the
   // stack. A monitoring tracker can write a non-zero value here, copy the
   // stack contents, and read the value to know, if it is still non-zero, that
   // the contents didn't change while being copied. This can handle concurrent
   // snapshot operations only if each snapshot writes a different bit (which
   // is not the current implementation so no parallel snapshots allowed).
-  std::atomic<uint32_t> stack_unchanged;
+  std::atomic<uint32_t> data_unchanged;
+
+  // The last "exception" activity. This can't be stored on the stack because
+  // that could get popped as things unwind.
+  Activity last_exception;
 
   // The name of the thread (up to a maximum length). Dynamic-length names
   // are not practical since the memory has to come from the same persistent
   // allocator that holds this structure and to which this object has no
   // reference.
   char thread_name[32];
 };
 
 ThreadActivityTracker::Snapshot::Snapshot() {}
 ThreadActivityTracker::Snapshot::~Snapshot() {}
@@ skipping 57 matching lines @@
   // Provided memory should either be completely initialized or all zeros.
   if (header_->owner.data_id.load(std::memory_order_relaxed) == 0) {
     // This is a new file. Double-check other fields and then initialize.
     DCHECK_EQ(0, header_->owner.process_id);
     DCHECK_EQ(0, header_->owner.create_stamp);
     DCHECK_EQ(0, header_->thread_ref.as_id);
     DCHECK_EQ(0, header_->start_time);
     DCHECK_EQ(0, header_->start_ticks);
     DCHECK_EQ(0U, header_->stack_slots);
     DCHECK_EQ(0U, header_->current_depth.load(std::memory_order_relaxed));
-    DCHECK_EQ(0U, header_->stack_unchanged.load(std::memory_order_relaxed));
+    DCHECK_EQ(0U, header_->data_unchanged.load(std::memory_order_relaxed));
     DCHECK_EQ(0, stack_[0].time_internal);
     DCHECK_EQ(0U, stack_[0].origin_address);
     DCHECK_EQ(0U, stack_[0].call_stack[0]);
     DCHECK_EQ(0U, stack_[0].data.task.sequence_id);
 
 #if defined(OS_WIN)
     header_->thread_ref.as_tid = PlatformThread::CurrentId();
 #elif defined(OS_POSIX)
     header_->thread_ref.as_handle =
         PlatformThread::CurrentHandle().platform_handle();
@@ skipping 93 matching lines @@
   // Validate that everything is running correctly.
   DCHECK_EQ(id, depth);
 
   // A thread-checker creates a lock to check the thread-id which means
   // re-entry into this code if lock acquisitions are being tracked.
   DCHECK(stack_[depth].activity_type == Activity::ACT_LOCK_ACQUIRE ||
          thread_checker_.CalledOnValidThread());
 
   // The stack has shrunk meaning that some other thread trying to copy the
   // contents for reporting purposes could get bad data. That thread would
-  // have written a non-zero value into |stack_unchanged|; clearing it here
+  // have written a non-zero value into |data_unchanged|; clearing it here
   // will let that thread detect that something did change. This needs to
   // happen after the atomic |depth| operation above so a "release" store
   // is required.
-  header_->stack_unchanged.store(0, std::memory_order_release);
+  header_->data_unchanged.store(0, std::memory_order_release);
 }
 
 std::unique_ptr<ActivityUserData> ThreadActivityTracker::GetUserData(
     ActivityId id,
     ActivityTrackerMemoryAllocator* allocator) {
-  // User-data is only stored for activities actually held in the stack.
-  if (id < stack_slots_) {
-    // Don't allow user data for lock acquisition as recursion may occur.
-    if (stack_[id].activity_type == Activity::ACT_LOCK_ACQUIRE) {
-      NOTREACHED();
-      return MakeUnique<ActivityUserData>(nullptr, 0);
-    }
-
-    // Get (or reuse) a block of memory and create a real UserData object
-    // on it.
-    PersistentMemoryAllocator::Reference ref = allocator->GetObjectReference();
-    void* memory =
-        allocator->GetAsArray<char>(ref, PersistentMemoryAllocator::kSizeAny);
-    if (memory) {
-      std::unique_ptr<ActivityUserData> user_data =
-          MakeUnique<ActivityUserData>(memory, kUserDataSize);
-      stack_[id].user_data_ref = ref;
-      stack_[id].user_data_id = user_data->id();
-      return user_data;
-    }
+  // Don't allow user data for lock acquisition as recursion may occur.
+  if (stack_[id].activity_type == Activity::ACT_LOCK_ACQUIRE) {
+    NOTREACHED();
+    return MakeUnique<ActivityUserData>();
   }
 
-  // Return a dummy object that will still accept (but ignore) Set() calls.
-  return MakeUnique<ActivityUserData>(nullptr, 0);
+  // User-data is only stored for activities actually held in the stack.
+  if (id >= stack_slots_)
+    return MakeUnique<ActivityUserData>();
+
+  // Create and return a real UserData object.
+  return CreateUserDataForActivity(&stack_[id], allocator);
 }
 
 bool ThreadActivityTracker::HasUserData(ActivityId id) {
   // User-data is only stored for activities actually held in the stack.
   return (id < stack_slots_ && stack_[id].user_data_ref);
 }
 
 void ThreadActivityTracker::ReleaseUserData(
     ActivityId id,
     ActivityTrackerMemoryAllocator* allocator) {
   // User-data is only stored for activities actually held in the stack.
   if (id < stack_slots_ && stack_[id].user_data_ref) {
     allocator->ReleaseObjectReference(stack_[id].user_data_ref);
     stack_[id].user_data_ref = 0;
   }
+  // Release user-data for an exception.
+  if (header_->last_exception.user_data_ref) {
+    exception_data.reset();
+    allocator->ReleaseObjectReference(header_->last_exception.user_data_ref);
+    header_->last_exception.user_data_ref = 0;
+  }
+}
+
+ActivityUserData& ThreadActivityTracker::ExceptionActivity(
+    const void* program_counter,
+    const void* origin,

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

is this the exception address? If so, maybe name it that.
If not, we'd want to record the exception address somewhere, somehow.
Also we want to explicitly record the exception code.

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

Yes, it's for holding the address where the exception occurred.

I've got 4+64 bits of information I can save in the activity.  Anything beyond
that has to be "user data" in key/value pairs.

+    Activity::Type type,
+    const ActivityData& data,
+    ActivityTrackerMemoryAllocator* allocator) {

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

Note that here you will be executing in the context of an exception, which may -
as a case in point - occur in your own code, leading to reentrancy. EXTREME
caution is warranted here, as if you goof, most likely there will be no record
of this happening anywhere, as you've blown our chance to get a crash report
from the field.

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

There are two points that need hardening:

1) Creation of the thread-tracker object needs a lock but getting an existing
one does not.  I'll just get on the assumption that the tracker already exists. 
This will leave us blind during thread start-up, however.

2) The user-data object.  That also requires a lock to create.  The alternative
is to create one in advance, per-thread, and then return it when needed.  That
seems bad.  Perhaps I could keep one on reserve globally, extract it atomically
if needed, and refill it later on during normal program operation.  Two
exceptions in a row could result in no user-data for the second, but that's
probably the lesser concern.

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

IIRC the locks are to enable memory reuse. Another option is to just "leak"
(give up on reuse) the allocator memory used in those cases. 

That said, it would be a problem if threads keep spinning up and hitting
recoverable exceptions.

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

Correct on all counts.  Better to avoid the leaks if possible.

+  // A thread-checker creates a lock to check the thread-id which means
+  // re-entry into this code if lock acquisitions are being tracked.
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // If there was a previous exception, release its user-data.
+  if (header_->last_exception.user_data_ref) {
+    allocator->ReleaseObjectReference(header_->last_exception.user_data_ref);
+    header_->last_exception.user_data_ref = 0;
+  }
+
+  // Fill the reusable exception activity.
+  Activity::FillFrom(&header_->last_exception, program_counter, origin, type,
+                     data);
+
+  // Create a new user-data object for holding additional information.
+  exception_data =
+      CreateUserDataForActivity(&header_->last_exception, allocator);
+
+  // The data has changed meaning that some other thread trying to copy the
+  // contents for reporting purposes could get bad data.
+  header_->data_unchanged.store(0, std::memory_order_relaxed);
+
+  return *exception_data;
 }
 
 bool ThreadActivityTracker::IsValid() const {
   if (header_->owner.data_id.load(std::memory_order_acquire) == 0 ||
       header_->owner.process_id == 0 || header_->thread_ref.as_id == 0 ||
       header_->start_time == 0 || header_->start_ticks == 0 ||
       header_->stack_slots != stack_slots_ ||
       header_->thread_name[sizeof(header_->thread_name) - 1] != '\0') {
     return false;
   }
@@ skipping 24 matching lines @@
 
   for (int attempt = 0; attempt < kMaxAttempts; ++attempt) {
     // Remember the data IDs to ensure nothing is replaced during the snapshot
     // operation. Use "acquire" so that all the non-atomic fields of the
     // structure are valid (at least at the current moment in time).
     const uint32_t starting_id =
         header_->owner.data_id.load(std::memory_order_acquire);
     const int64_t starting_process_id = header_->owner.process_id;
     const int64_t starting_thread_id = header_->thread_ref.as_id;
 
-    // Write a non-zero value to |stack_unchanged| so it's possible to detect
+    // Write a non-zero value to |data_unchanged| so it's possible to detect
     // at the end that nothing has changed since copying the data began. A
     // "cst" operation is required to ensure it occurs before everything else.
     // Using "cst" memory ordering is relatively expensive but this is only
     // done during analysis so doesn't directly affect the worker threads.
-    header_->stack_unchanged.store(1, std::memory_order_seq_cst);
+    header_->data_unchanged.store(1, std::memory_order_seq_cst);
 
     // Fetching the current depth also "acquires" the contents of the stack.
     depth = header_->current_depth.load(std::memory_order_acquire);
     uint32_t count = std::min(depth, stack_slots_);
     output_snapshot->activity_stack.resize(count);
     if (count > 0) {
       // Copy the existing contents. Memcpy is used for speed.
       memcpy(&output_snapshot->activity_stack[0], stack_,
              count * sizeof(Activity));
     }
 
+    // Capture the last exception.
+    memcpy(&output_snapshot->last_exception, &header_->last_exception,
+           sizeof(Activity));
+
+    // TODO(bcwhite): Snapshot other things here.
+
     // Retry if something changed during the copy. A "cst" operation ensures
     // it must happen after all the above operations.
-    if (!header_->stack_unchanged.load(std::memory_order_seq_cst))
+    if (!header_->data_unchanged.load(std::memory_order_seq_cst))
       continue;
 
     // Stack copied. Record it's full depth.
     output_snapshot->activity_stack_depth = depth;
 
-    // TODO(bcwhite): Snapshot other things here.
-
     // Get the general thread information.
     output_snapshot->thread_name =
         std::string(header_->thread_name, sizeof(header_->thread_name) - 1);
     output_snapshot->thread_id = header_->thread_ref.as_id;
     output_snapshot->process_id = header_->owner.process_id;
 
     // All characters of the thread-name buffer were copied so as to not break
     // if the trailing NUL were missing. Now limit the length if the actual
     // name is shorter.
     output_snapshot->thread_name.resize(
@@ skipping 15 matching lines @@
 
     // Change all the timestamps in the activities from "ticks" to "wall" time.
     const Time start_time = Time::FromInternalValue(header_->start_time);
     const int64_t start_ticks = header_->start_ticks;
     for (Activity& activity : output_snapshot->activity_stack) {
       activity.time_internal =
           (start_time +
            TimeDelta::FromInternalValue(activity.time_internal - start_ticks))
               .ToInternalValue();
     }
+    output_snapshot->last_exception.time_internal =
+        (start_time +
+         TimeDelta::FromInternalValue(
+             output_snapshot->last_exception.time_internal - start_ticks))
+            .ToInternalValue();
 
     // Success!
     return true;
   }
 
   // Too many attempts.
   return false;
 }
 
 const void* ThreadActivityTracker::GetBaseAddress() {
@@ skipping 11 matching lines @@
                                                int64_t* out_stamp) {
   const Header* header = reinterpret_cast<const Header*>(memory);
   return OwningProcess::GetOwningProcessId(&header->owner, out_id, out_stamp);
 }
 
 // static
 size_t ThreadActivityTracker::SizeForStackDepth(int stack_depth) {
   return static_cast<size_t>(stack_depth) * sizeof(Activity) + sizeof(Header);
 }
 
+std::unique_ptr<ActivityUserData>
+ThreadActivityTracker::CreateUserDataForActivity(
+    Activity* activity,
+    ActivityTrackerMemoryAllocator* allocator) {
+  DCHECK_EQ(0U, activity->user_data_ref);
+
+  PersistentMemoryAllocator::Reference ref = allocator->GetObjectReference();
+  void* memory = allocator->GetAsArray<char>(ref, kUserDataSize);
+  if (memory) {
+    std::unique_ptr<ActivityUserData> user_data =
+        MakeUnique<ActivityUserData>(memory, kUserDataSize);
+    activity->user_data_ref = ref;
+    activity->user_data_id = user_data->id();
+    return user_data;
+  }
+
+  // Return a dummy object that will still accept (but ignore) Set() calls.
+  return MakeUnique<ActivityUserData>();
+}
+
 // The instantiation of the GlobalActivityTracker object.
 // The object held here will obviously not be destructed at process exit
 // but that's best since PersistentMemoryAllocator objects (that underlie
 // GlobalActivityTracker objects) are explicitly forbidden from doing anything
 // essential at exit anyway due to the fact that they depend on data managed
 // elsewhere and which could be destructed first. An AtomicWord is used instead
 // of std::atomic because the latter can create global ctors and dtors.
 subtle::AtomicWord GlobalActivityTracker::g_tracker_ = 0;
 
 GlobalActivityTracker::ModuleInfo::ModuleInfo() {}
@@ skipping 133 matching lines @@
 }
 
 ActivityUserData& GlobalActivityTracker::ScopedThreadActivity::user_data() {
   if (!user_data_) {
     if (tracker_) {
       GlobalActivityTracker* global = GlobalActivityTracker::Get();
       AutoLock lock(global->user_data_allocator_lock_);
       user_data_ =
           tracker_->GetUserData(activity_id_, &global->user_data_allocator_);
     } else {
-      user_data_ = MakeUnique<ActivityUserData>(nullptr, 0);
+      user_data_ = MakeUnique<ActivityUserData>();
     }
   }
   return *user_data_;
 }
 
 GlobalActivityTracker::ThreadSafeUserData::ThreadSafeUserData(void* memory,
                                                               size_t size)
     : ActivityUserData(memory, size) {}
 
 GlobalActivityTracker::ThreadSafeUserData::~ThreadSafeUserData() {}
@@ skipping 411 matching lines @@
 
   // Remove the destructed tracker from the set of known ones.
   DCHECK_LE(1, thread_tracker_count_.load(std::memory_order_relaxed));
   thread_tracker_count_.fetch_sub(1, std::memory_order_relaxed);
 
   // Release this memory for re-use at a later time.
   base::AutoLock autolock(thread_tracker_allocator_lock_);
   thread_tracker_allocator_.ReleaseObjectReference(mem_reference);
 }
 
+ActivityUserData& GlobalActivityTracker::RecordExceptionImpl(
+    const void* pc,
+    const void* origin) {
+  ThreadActivityTracker* tracker = GetOrCreateTrackerForCurrentThread();
+  if (!tracker)
+    return g_data_sink.Get();
+
+  AutoLock lock(user_data_allocator_lock_);
+  return tracker->ExceptionActivity(pc, origin, Activity::ACT_EXCEPTION,
+                                    ActivityData::ForGeneric(0, 0),
+                                    &user_data_allocator_);
+}
+
 // static
 void GlobalActivityTracker::OnTLSDestroy(void* value) {
   delete reinterpret_cast<ManagedActivityTracker*>(value);
 }
 
 ScopedActivity::ScopedActivity(const void* program_counter,
                                uint8_t action,
                                uint32_t id,
                                int32_t info)
     : GlobalActivityTracker::ScopedThreadActivity(
@@ skipping 70 matching lines @@
     : GlobalActivityTracker::ScopedThreadActivity(
           program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base