compiler-rt/lib/asan/asan_thread.h

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