contrib/compiler-rt/lib/asan/asan_thread.h

   1 //===-- asan_thread.h -------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is a part of AddressSanitizer, an address sanity checker.
  11 //
  12 // ASan-private header for asan_thread.cc.
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef ASAN_THREAD_H
  16 #define ASAN_THREAD_H
  17
  18 #include "asan_allocator.h"
  19 #include "asan_internal.h"
  20 #include "asan_fake_stack.h"
  21 #include "asan_stats.h"
  22 #include "sanitizer_common/sanitizer_common.h"
  23 #include "sanitizer_common/sanitizer_libc.h"
  24 #include "sanitizer_common/sanitizer_thread_registry.h"
  25
  26 namespace __sanitizer {
  27 struct DTLS;
  28 }  // namespace __sanitizer
  29
  30 namespace __asan {
  31
  32 const u32 kInvalidTid = 0xffffff;  // Must fit into 24 bits.
  33 const u32 kMaxNumberOfThreads = (1 << 22);  // 4M
  34
  35 class AsanThread;
  36
  37 // These objects are created for every thread and are never deleted,
  38 // so we can find them by tid even if the thread is long dead.
  39 class AsanThreadContext : public ThreadContextBase {
  40  public:
  41   explicit AsanThreadContext(int tid)
  42       : ThreadContextBase(tid), announced(false),
  43         destructor_iterations(GetPthreadDestructorIterations()), stack_id(0),
  44         thread(nullptr) {}
  45   bool announced;
  46   u8 destructor_iterations;
  47   u32 stack_id;
  48   AsanThread *thread;
  49
  50   void OnCreated(void *arg) override;
  51   void OnFinished() override;
  52 };
  53
  54 // AsanThreadContext objects are never freed, so we need many of them.
  55 COMPILER_CHECK(sizeof(AsanThreadContext) <= 256);
  56
  57 // AsanThread are stored in TSD and destroyed when the thread dies.
  58 class AsanThread {
  59  public:
  60   static AsanThread *Create(thread_callback_t start_routine, void *arg,
  61                             u32 parent_tid, StackTrace *stack, bool detached);
  62   static void TSDDtor(void *tsd);
  63   void Destroy();
  64
  65   void Init();  // Should be called from the thread itself.
  66   thread_return_t ThreadStart(uptr os_id,
  67                               atomic_uintptr_t *signal_thread_is_registered);
  68
  69   uptr stack_top();
  70   uptr stack_bottom();
  71   uptr stack_size();
  72   uptr tls_begin() { return tls_begin_; }
  73   uptr tls_end() { return tls_end_; }
  74   DTLS *dtls() { return dtls_; }
  75   u32 tid() { return context_->tid; }
  76   AsanThreadContext *context() { return context_; }
  77   void set_context(AsanThreadContext *context) { context_ = context; }
  78
  79   struct StackFrameAccess {
  80     uptr offset;
  81     uptr frame_pc;
  82     const char *frame_descr;
  83   };
  84   bool GetStackFrameAccessByAddr(uptr addr, StackFrameAccess *access);
  85
  86   bool AddrIsInStack(uptr addr);
  87
  88   void DeleteFakeStack(int tid) {
  89     if (!fake_stack_) return;
  90     FakeStack *t = fake_stack_;
  91     fake_stack_ = nullptr;
  92     SetTLSFakeStack(nullptr);
  93     t->Destroy(tid);
  94   }
  95
  96   void StartSwitchFiber(FakeStack **fake_stack_save, uptr bottom, uptr size);
  97   void FinishSwitchFiber(FakeStack *fake_stack_save);
  98
  99   bool has_fake_stack() {
 100     return !atomic_load(&stack_switching_, memory_order_relaxed) &&
 101            (reinterpret_cast<uptr>(fake_stack_) > 1);
 102   }
 103
 104   FakeStack *fake_stack() {
 105     if (!__asan_option_detect_stack_use_after_return)
 106       return nullptr;
 107     if (atomic_load(&stack_switching_, memory_order_relaxed))
 108       return nullptr;
 109     if (!has_fake_stack())
 110       return AsyncSignalSafeLazyInitFakeStack();
 111     return fake_stack_;
 112   }
 113
 114   // True is this thread is currently unwinding stack (i.e. collecting a stack
 115   // trace). Used to prevent deadlocks on platforms where libc unwinder calls
 116   // malloc internally. See PR17116 for more details.
 117   bool isUnwinding() const { return unwinding_; }
 118   void setUnwinding(bool b) { unwinding_ = b; }
 119
 120   // True if we are in a deadly signal handler.
 121   bool isInDeadlySignal() const { return in_deadly_signal_; }
 122   void setInDeadlySignal(bool b) { in_deadly_signal_ = b; }
 123
 124   AsanThreadLocalMallocStorage &malloc_storage() { return malloc_storage_; }
 125   AsanStats &stats() { return stats_; }
 126
 127  private:
 128   // NOTE: There is no AsanThread constructor. It is allocated
 129   // via mmap() and *must* be valid in zero-initialized state.
 130   void SetThreadStackAndTls();
 131   void ClearShadowForThreadStackAndTLS();
 132   FakeStack *AsyncSignalSafeLazyInitFakeStack();
 133
 134   struct StackBounds {
 135     uptr bottom;
 136     uptr top;
 137   };
 138   StackBounds GetStackBounds() const;
 139
 140   AsanThreadContext *context_;
 141   thread_callback_t start_routine_;
 142   void *arg_;
 143
 144   uptr stack_top_;
 145   uptr stack_bottom_;
 146   // these variables are used when the thread is about to switch stack
 147   uptr next_stack_top_;
 148   uptr next_stack_bottom_;
 149   // true if switching is in progress
 150   atomic_uint8_t stack_switching_;
 151
 152   uptr tls_begin_;
 153   uptr tls_end_;
 154   DTLS *dtls_;
 155
 156   FakeStack *fake_stack_;
 157   AsanThreadLocalMallocStorage malloc_storage_;
 158   AsanStats stats_;
 159   bool unwinding_;
 160   bool in_deadly_signal_;
 161 };
 162
 163 // ScopedUnwinding is a scope for stacktracing member of a context
 164 class ScopedUnwinding {
 165  public:
 166   explicit ScopedUnwinding(AsanThread *t) : thread(t) {
 167     t->setUnwinding(true);
 168   }
 169   ~ScopedUnwinding() { thread->setUnwinding(false); }
 170
 171  private:
 172   AsanThread *thread;
 173 };
 174
 175 // ScopedDeadlySignal is a scope for handling deadly signals.
 176 class ScopedDeadlySignal {
 177  public:
 178   explicit ScopedDeadlySignal(AsanThread *t) : thread(t) {
 179     if (thread) thread->setInDeadlySignal(true);
 180   }
 181   ~ScopedDeadlySignal() {
 182     if (thread) thread->setInDeadlySignal(false);
 183   }
 184
 185  private:
 186   AsanThread *thread;
 187 };
 188
 189 // Returns a single instance of registry.
 190 ThreadRegistry &asanThreadRegistry();
 191
 192 // Must be called under ThreadRegistryLock.
 193 AsanThreadContext *GetThreadContextByTidLocked(u32 tid);
 194
 195 // Get the current thread. May return 0.
 196 AsanThread *GetCurrentThread();
 197 void SetCurrentThread(AsanThread *t);
 198 u32 GetCurrentTidOrInvalid();
 199 AsanThread *FindThreadByStackAddress(uptr addr);
 200
 201 // Used to handle fork().
 202 void EnsureMainThreadIDIsCorrect();
 203 } // namespace __asan
 204
 205 #endif // ASAN_THREAD_H