compiler-rt/lib/memprof/memprof_thread.h

   1 //===-- memprof_thread.h ---------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file is a part of MemProfiler, a memory profiler.
  10 //
  11 // MemProf-private header for memprof_thread.cpp.
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef MEMPROF_THREAD_H
  15 #define MEMPROF_THREAD_H
  16
  17 #include "memprof_allocator.h"
  18 #include "memprof_internal.h"
  19 #include "memprof_stats.h"
  20 #include "sanitizer_common/sanitizer_common.h"
  21 #include "sanitizer_common/sanitizer_libc.h"
  22 #include "sanitizer_common/sanitizer_thread_registry.h"
  23
  24 namespace __sanitizer {
  25 struct DTLS;
  26 } // namespace __sanitizer
  27
  28 namespace __memprof {
  29
  30 class MemprofThread;
  31
  32 // These objects are created for every thread and are never deleted,
  33 // so we can find them by tid even if the thread is long dead.
  34 struct MemprofThreadContext final : public ThreadContextBase {
  35   explicit MemprofThreadContext(int tid)
  36       : ThreadContextBase(tid), announced(false),
  37         destructor_iterations(GetPthreadDestructorIterations()), stack_id(0),
  38         thread(nullptr) {}
  39   bool announced;
  40   u8 destructor_iterations;
  41   u32 stack_id;
  42   MemprofThread *thread;
  43
  44   void OnCreated(void *arg) override;
  45   void OnFinished() override;
  46
  47   struct CreateThreadContextArgs {
  48     MemprofThread *thread;
  49     StackTrace *stack;
  50   };
  51 };
  52
  53 // MemprofThreadContext objects are never freed, so we need many of them.
  54 COMPILER_CHECK(sizeof(MemprofThreadContext) <= 256);
  55
  56 // MemprofThread are stored in TSD and destroyed when the thread dies.
  57 class MemprofThread {
  58 public:
  59   static MemprofThread *Create(thread_callback_t start_routine, void *arg,
  60                                u32 parent_tid, StackTrace *stack,
  61                                bool detached);
  62   static void TSDDtor(void *tsd);
  63   void Destroy();
  64
  65   struct InitOptions;
  66   void Init(const InitOptions *options = nullptr);
  67
  68   thread_return_t ThreadStart(tid_t os_id,
  69                               atomic_uintptr_t *signal_thread_is_registered);
  70
  71   uptr stack_top();
  72   uptr stack_bottom();
  73   uptr stack_size();
  74   uptr tls_begin() { return tls_begin_; }
  75   uptr tls_end() { return tls_end_; }
  76   DTLS *dtls() { return dtls_; }
  77   u32 tid() { return context_->tid; }
  78   MemprofThreadContext *context() { return context_; }
  79   void set_context(MemprofThreadContext *context) { context_ = context; }
  80
  81   bool AddrIsInStack(uptr addr);
  82
  83   // True is this thread is currently unwinding stack (i.e. collecting a stack
  84   // trace). Used to prevent deadlocks on platforms where libc unwinder calls
  85   // malloc internally. See PR17116 for more details.
  86   bool isUnwinding() const { return unwinding_; }
  87   void setUnwinding(bool b) { unwinding_ = b; }
  88
  89   MemprofThreadLocalMallocStorage &malloc_storage() { return malloc_storage_; }
  90   MemprofStats &stats() { return stats_; }
  91
  92 private:
  93   // NOTE: There is no MemprofThread constructor. It is allocated
  94   // via mmap() and *must* be valid in zero-initialized state.
  95
  96   void SetThreadStackAndTls(const InitOptions *options);
  97
  98   struct StackBounds {
  99     uptr bottom;
 100     uptr top;
 101   };
 102   StackBounds GetStackBounds() const;
 103
 104   MemprofThreadContext *context_;
 105   thread_callback_t start_routine_;
 106   void *arg_;
 107
 108   uptr stack_top_;
 109   uptr stack_bottom_;
 110
 111   uptr tls_begin_;
 112   uptr tls_end_;
 113   DTLS *dtls_;
 114
 115   MemprofThreadLocalMallocStorage malloc_storage_;
 116   MemprofStats stats_;
 117   bool unwinding_;
 118 };
 119
 120 // Returns a single instance of registry.
 121 ThreadRegistry &memprofThreadRegistry();
 122
 123 // Must be called under ThreadRegistryLock.
 124 MemprofThreadContext *GetThreadContextByTidLocked(u32 tid);
 125
 126 // Get the current thread. May return 0.
 127 MemprofThread *GetCurrentThread();
 128 void SetCurrentThread(MemprofThread *t);
 129 u32 GetCurrentTidOrInvalid();
 130
 131 // Used to handle fork().
 132 void EnsureMainThreadIDIsCorrect();
 133 } // namespace __memprof
 134
 135 #endif // MEMPROF_THREAD_H