Include calling address in tracked activities.

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 <memory>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
+#include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 
 struct PendingTask;
 
@@ skipping 181 matching lines @@
     // 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"
   // but when returned in a snapshot, it is "wall time".
   int64_t time_internal;
 
+  // The address that pushed the activity onto the stack as a raw number.
+  uint64_t calling_address;
+
   // The address that is the origin of the activity if it not obvious from
   // the call stack. This is useful for things like tasks that are posted
   // from a completely different thread though most activities will leave
   // it null.
   uint64_t origin_address;
 
   // Array of program-counters that make up the top of the call stack.
   // Despite the fixed size, this list is always null-terminated. Entries
   // after the terminator have no meaning and may or may not also be null.
   // The list will be completely empty if call-stack collection is not
   // enabled.
   uint64_t call_stack[kActivityCallStackSize];
 
   // The (enumerated) type of the activity. This defines what fields of the
   // |data| record are valid.
   uint8_t activity_type;
 
   // Padding to ensure that the next member begins on a 64-bit boundary
   // even on 32-bit builds which ensures inter-operability between CPU
   // architectures. New fields can be taken from this space.
   uint8_t padding[7];
 
   // Information specific to the |activity_type|.
   ActivityData data;
 
   static void FillFrom(Activity* activity,
+                       const void* program_counter,
                        const void* origin,
                        Type type,
                        const ActivityData& data);
 };
 
 // This structure holds a copy of all the internal data at the moment the
 // "snapshot" operation is done. It is disconnected from the live tracker
 // so that continued operation of the thread will not cause changes here.
 struct BASE_EXPORT ActivitySnapshot {
   // Explicit constructor/destructor are needed because of complex types
@@ skipping 33 matching lines @@
 // objects.
 class BASE_EXPORT ThreadActivityTracker {
  public:
   // 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,
                    const void* origin,
                    Activity::Type type,
                    const ActivityData& data)
         : tracker_(tracker) {
       if (tracker_)
-        tracker_->PushActivity(origin, type, data);
+        tracker_->PushActivity(program_counter, origin, type, data);
     }
 
     ~ScopedActivity() {
       if (tracker_)
         tracker_->PopActivity();
     }
 
     void ChangeTypeAndData(Activity::Type type, const ActivityData& data) {
       if (tracker_)
         tracker_->ChangeActivity(type, data);
     }
 
    private:
     // The thread tracker to which this object reports. It can be null if
     // activity tracking is not (yet) enabled.
     ThreadActivityTracker* const tracker_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedActivity);
   };
 
   // A ThreadActivityTracker runs on top of memory that is managed externally.
   // It must be large enough for the internal header and a few Activity
   // blocks. See SizeForStackDepth().
   ThreadActivityTracker(void* base, size_t size);
   virtual ~ThreadActivityTracker();
 
   // Indicates that an activity has started from a given |origin| address in
   // the code, though it can be null if the creator's address is not known.
-  // The |type| and |data| describe the activity.
+  // The |type| and |data| describe the activity. |program_counter| should be
+  // the result of GetProgramCounter() where push is called.
+  void PushActivity(const void* program_counter,
+                    const void* origin,
+                    Activity::Type type,
+                    const ActivityData& data);
+
+  // An inlined version of the above that gets the program counter where it
+  // is called.
+  ALWAYS_INLINE
   void PushActivity(const void* origin,
                     Activity::Type type,
-                    const ActivityData& data);
+                    const ActivityData& data) {
+    PushActivity(::tracked_objects::GetProgramCounter(), origin, type, data);
+  }
 
   // Changes the activity |type| and |data| of the top-most entry on the stack.
   // This is useful if the information has changed and it is desireable to
   // track that change without creating a new stack entry. If the type is
   // ACT_NULL or the data is kNullActivityData then that value will remain
   // unchanged. The type, if changed, must remain in the same category.
   // Changing both is not atomic so a snapshot operation could occur between
   // the update of |type| and |data| or between update of |data| fields.
   void ChangeActivity(Activity::Type type, const ActivityData& data);
 
@@ skipping 39 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 + 1,  // SHA1(ActivityTracker) v1
+    kTypeIdActivityTracker     = 0x5D7381AF + 2,  // SHA1(ActivityTracker) v2
     kTypeIdActivityTrackerFree = ~kTypeIdActivityTracker,
   };
 
   // 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* origin,
+    ScopedThreadActivity(const void* program_counter,
+                         const void* origin,
                          Activity::Type type,
                          const ActivityData& data,
                          bool lock_allowed)
         : ThreadActivityTracker::ScopedActivity(
               GetOrCreateTracker(lock_allowed),
+              program_counter,
               origin,
               type,
               data) {}
 
    private:
     // Gets (or creates) a tracker for the current thread. If locking is not
     // allowed (because a lock is being tracked which would cause recursion)
     // then the attempt to create one if none found will be skipped. Once
     // the tracker for this thread has been created for other reasons, locks
     // will be tracked. The thread-tracker uses locks.
@@ skipping 149 matching lines @@
   // |info|. None of these values affect operation; they're all purely
   // for association and analysis. To have unique identifiers across a
   // diverse code-base, create the number by taking the first 8 characters
   // of the hash of the activity being tracked.
   //
   // For example:
   //   Tracking method: void MayNeverExit(uint32_t foo) {...}
   //   echo -n "MayNeverExit" | sha1sum   =>   e44873ccab21e2b71270da24aa1...
   //
   //   void MayNeverExit(int32_t foo) {
-  //     base::debug::ScopedActivity track_me(FROM_HERE, 0, 0xE44873CC, foo);
+  //     base::debug::ScopedActivity track_me(0, 0xE44873CC, foo);
   //     ...
   //   }
-  ScopedActivity(const tracked_objects::Location& location,
-                 uint8_t action,
-                 uint32_t id,
-                 int32_t info);
-
-  // Because this is inline, the FROM_HERE macro will resolve the current
-  // program-counter as the location in the calling code.
-  ScopedActivity() : ScopedActivity(FROM_HERE, 0, 0, 0) {}
+  ALWAYS_INLINE
+  ScopedActivity(uint8_t action, uint32_t id, int32_t info)
+      : ScopedActivity(::tracked_objects::GetProgramCounter(),
+                       action,
+                       id,
+                       info) {}
+  ScopedActivity() : ScopedActivity(0, 0, 0) {}
 
   // Changes the |action| and/or |info| of this activity on the stack. This
   // is useful for tracking progress through a function, updating the action
   // to indicate "milestones" in the block (max 16 milestones: 0-15) or the
   // info to reflect other changes. Changing both is not atomic so a snapshot
   // operation could occur between the update of |action| and |info|.
   void ChangeAction(uint8_t action);
   void ChangeInfo(int32_t info);
   void ChangeActionAndInfo(uint8_t action, int32_t info);
 
  private:
+  // Constructs the object using a passed-in program-counter.
+  ScopedActivity(const void* program_counter,
+                 uint8_t action,
+                 uint32_t id,
+                 int32_t info);
+
   // A copy of the ID code so it doesn't have to be passed by the caller when
   // changing the |info| field.
   uint32_t id_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedActivity);
 };
 
 
 // These "scoped" classes provide easy tracking of various blocking actions.
 
 class BASE_EXPORT ScopedTaskRunActivity
     : public GlobalActivityTracker::ScopedThreadActivity {
  public:
-  explicit ScopedTaskRunActivity(const base::PendingTask& task);
+  ALWAYS_INLINE
+  explicit ScopedTaskRunActivity(const base::PendingTask& task)
+      : ScopedTaskRunActivity(::tracked_objects::GetProgramCounter(),
+                              task) {}
+
  private:
+  ScopedTaskRunActivity(const void* program_counter,
+                        const base::PendingTask& task);
   DISALLOW_COPY_AND_ASSIGN(ScopedTaskRunActivity);
 };
 
 class BASE_EXPORT ScopedLockAcquireActivity
     : public GlobalActivityTracker::ScopedThreadActivity {
  public:
-  explicit ScopedLockAcquireActivity(const base::internal::LockImpl* lock);
+  ALWAYS_INLINE
+  explicit ScopedLockAcquireActivity(const base::internal::LockImpl* lock)
+      : ScopedLockAcquireActivity(::tracked_objects::GetProgramCounter(),
+                                  lock) {}
+
  private:
+  ScopedLockAcquireActivity(const void* program_counter,
+                            const base::internal::LockImpl* lock);
   DISALLOW_COPY_AND_ASSIGN(ScopedLockAcquireActivity);
 };
 
 class BASE_EXPORT ScopedEventWaitActivity
     : public GlobalActivityTracker::ScopedThreadActivity {
  public:
-  explicit ScopedEventWaitActivity(const base::WaitableEvent* event);
+  ALWAYS_INLINE
+  explicit ScopedEventWaitActivity(const base::WaitableEvent* event)
+      : ScopedEventWaitActivity(::tracked_objects::GetProgramCounter(),
+                                event) {}
+
  private:
+  ScopedEventWaitActivity(const void* program_counter,
+                          const base::WaitableEvent* event);
   DISALLOW_COPY_AND_ASSIGN(ScopedEventWaitActivity);
 };
 
 class BASE_EXPORT ScopedThreadJoinActivity
     : public GlobalActivityTracker::ScopedThreadActivity {
  public:
-  explicit ScopedThreadJoinActivity(const base::PlatformThreadHandle* thread);
+  ALWAYS_INLINE
+  explicit ScopedThreadJoinActivity(const base::PlatformThreadHandle* thread)
+      : ScopedThreadJoinActivity(::tracked_objects::GetProgramCounter(),
+                                 thread) {}
+
  private:
+  ScopedThreadJoinActivity(const void* program_counter,
+                           const base::PlatformThreadHandle* thread);
   DISALLOW_COPY_AND_ASSIGN(ScopedThreadJoinActivity);
 };
 
 // Some systems don't have base::Process
 #if !defined(OS_NACL) && !defined(OS_IOS)
 class BASE_EXPORT ScopedProcessWaitActivity
     : public GlobalActivityTracker::ScopedThreadActivity {
  public:
-  explicit ScopedProcessWaitActivity(const base::Process* process);
+  ALWAYS_INLINE
+  explicit ScopedProcessWaitActivity(const base::Process* process)
+      : ScopedProcessWaitActivity(::tracked_objects::GetProgramCounter(),
+                                  process) {}
+
  private:
+  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_