src/compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cc

   1 //===-- sanitizer_thread_registry.cc --------------------------------------===//
   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 shared between sanitizer tools.
  11 //
  12 // General thread bookkeeping functionality.
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "sanitizer_thread_registry.h"
  16
  17 namespace __sanitizer {
  18
  19 ThreadContextBase::ThreadContextBase(u32 tid)
  20     : tid(tid), unique_id(0), reuse_count(), os_id(0), user_id(0),
  21       status(ThreadStatusInvalid),
  22       detached(false), parent_tid(0), next(0) {
  23   name[0] = '\0';
  24 }
  25
  26 ThreadContextBase::~ThreadContextBase() {
  27   // ThreadContextBase should never be deleted.
  28   CHECK(0);
  29 }
  30
  31 void ThreadContextBase::SetName(const char *new_name) {
  32   name[0] = '\0';
  33   if (new_name) {
  34     internal_strncpy(name, new_name, sizeof(name));
  35     name[sizeof(name) - 1] = '\0';
  36   }
  37 }
  38
  39 void ThreadContextBase::SetDead() {
  40   CHECK(status == ThreadStatusRunning ||
  41         status == ThreadStatusFinished);
  42   status = ThreadStatusDead;
  43   user_id = 0;
  44   OnDead();
  45 }
  46
  47 void ThreadContextBase::SetJoined(void *arg) {
  48   // FIXME(dvyukov): print message and continue (it's user error).
  49   CHECK_EQ(false, detached);
  50   CHECK_EQ(ThreadStatusFinished, status);
  51   status = ThreadStatusDead;
  52   user_id = 0;
  53   OnJoined(arg);
  54 }
  55
  56 void ThreadContextBase::SetFinished() {
  57   if (!detached)
  58     status = ThreadStatusFinished;
  59   OnFinished();
  60 }
  61
  62 void ThreadContextBase::SetStarted(uptr _os_id, void *arg) {
  63   status = ThreadStatusRunning;
  64   os_id = _os_id;
  65   OnStarted(arg);
  66 }
  67
  68 void ThreadContextBase::SetCreated(uptr _user_id, u64 _unique_id,
  69                                    bool _detached, u32 _parent_tid, void *arg) {
  70   status = ThreadStatusCreated;
  71   user_id = _user_id;
  72   unique_id = _unique_id;
  73   detached = _detached;
  74   // Parent tid makes no sense for the main thread.
  75   if (tid != 0)
  76     parent_tid = _parent_tid;
  77   OnCreated(arg);
  78 }
  79
  80 void ThreadContextBase::Reset() {
  81   status = ThreadStatusInvalid;
  82   SetName(0);
  83   OnReset();
  84 }
  85
  86 // ThreadRegistry implementation.
  87
  88 const u32 ThreadRegistry::kUnknownTid = ~0U;
  89
  90 ThreadRegistry::ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
  91                                u32 thread_quarantine_size, u32 max_reuse)
  92     : context_factory_(factory),
  93       max_threads_(max_threads),
  94       thread_quarantine_size_(thread_quarantine_size),
  95       max_reuse_(max_reuse),
  96       mtx_(),
  97       n_contexts_(0),
  98       total_threads_(0),
  99       alive_threads_(0),
 100       max_alive_threads_(0),
 101       running_threads_(0) {
 102   threads_ = (ThreadContextBase **)MmapOrDie(max_threads_ * sizeof(threads_[0]),
 103                                              "ThreadRegistry");
 104   dead_threads_.clear();
 105   invalid_threads_.clear();
 106 }
 107
 108 void ThreadRegistry::GetNumberOfThreads(uptr *total, uptr *running,
 109                                         uptr *alive) {
 110   BlockingMutexLock l(&mtx_);
 111   if (total) *total = n_contexts_;
 112   if (running) *running = running_threads_;
 113   if (alive) *alive = alive_threads_;
 114 }
 115
 116 uptr ThreadRegistry::GetMaxAliveThreads() {
 117   BlockingMutexLock l(&mtx_);
 118   return max_alive_threads_;
 119 }
 120
 121 u32 ThreadRegistry::CreateThread(uptr user_id, bool detached, u32 parent_tid,
 122                                  void *arg) {
 123   BlockingMutexLock l(&mtx_);
 124   u32 tid = kUnknownTid;
 125   ThreadContextBase *tctx = QuarantinePop();
 126   if (tctx) {
 127     tid = tctx->tid;
 128   } else if (n_contexts_ < max_threads_) {
 129     // Allocate new thread context and tid.
 130     tid = n_contexts_++;
 131     tctx = context_factory_(tid);
 132     threads_[tid] = tctx;
 133   } else {
 134 #if !SANITIZER_GO
 135     Report("%s: Thread limit (%u threads) exceeded. Dying.\n",
 136            SanitizerToolName, max_threads_);
 137 #else
 138     Printf("race: limit on %u simultaneously alive goroutines is exceeded,"
 139         " dying\n", max_threads_);
 140 #endif
 141     Die();
 142   }
 143   CHECK_NE(tctx, 0);
 144   CHECK_NE(tid, kUnknownTid);
 145   CHECK_LT(tid, max_threads_);
 146   CHECK_EQ(tctx->status, ThreadStatusInvalid);
 147   alive_threads_++;
 148   if (max_alive_threads_ < alive_threads_) {
 149     max_alive_threads_++;
 150     CHECK_EQ(alive_threads_, max_alive_threads_);
 151   }
 152   tctx->SetCreated(user_id, total_threads_++, detached,
 153                    parent_tid, arg);
 154   return tid;
 155 }
 156
 157 void ThreadRegistry::RunCallbackForEachThreadLocked(ThreadCallback cb,
 158                                                     void *arg) {
 159   CheckLocked();
 160   for (u32 tid = 0; tid < n_contexts_; tid++) {
 161     ThreadContextBase *tctx = threads_[tid];
 162     if (tctx == 0)
 163       continue;
 164     cb(tctx, arg);
 165   }
 166 }
 167
 168 u32 ThreadRegistry::FindThread(FindThreadCallback cb, void *arg) {
 169   BlockingMutexLock l(&mtx_);
 170   for (u32 tid = 0; tid < n_contexts_; tid++) {
 171     ThreadContextBase *tctx = threads_[tid];
 172     if (tctx != 0 && cb(tctx, arg))
 173       return tctx->tid;
 174   }
 175   return kUnknownTid;
 176 }
 177
 178 ThreadContextBase *
 179 ThreadRegistry::FindThreadContextLocked(FindThreadCallback cb, void *arg) {
 180   CheckLocked();
 181   for (u32 tid = 0; tid < n_contexts_; tid++) {
 182     ThreadContextBase *tctx = threads_[tid];
 183     if (tctx != 0 && cb(tctx, arg))
 184       return tctx;
 185   }
 186   return 0;
 187 }
 188
 189 static bool FindThreadContextByOsIdCallback(ThreadContextBase *tctx,
 190                                             void *arg) {
 191   return (tctx->os_id == (uptr)arg && tctx->status != ThreadStatusInvalid &&
 192       tctx->status != ThreadStatusDead);
 193 }
 194
 195 ThreadContextBase *ThreadRegistry::FindThreadContextByOsIDLocked(uptr os_id) {
 196   return FindThreadContextLocked(FindThreadContextByOsIdCallback,
 197                                  (void *)os_id);
 198 }
 199
 200 void ThreadRegistry::SetThreadName(u32 tid, const char *name) {
 201   BlockingMutexLock l(&mtx_);
 202   CHECK_LT(tid, n_contexts_);
 203   ThreadContextBase *tctx = threads_[tid];
 204   CHECK_NE(tctx, 0);
 205   CHECK_EQ(ThreadStatusRunning, tctx->status);
 206   tctx->SetName(name);
 207 }
 208
 209 void ThreadRegistry::SetThreadNameByUserId(uptr user_id, const char *name) {
 210   BlockingMutexLock l(&mtx_);
 211   for (u32 tid = 0; tid < n_contexts_; tid++) {
 212     ThreadContextBase *tctx = threads_[tid];
 213     if (tctx != 0 && tctx->user_id == user_id &&
 214         tctx->status != ThreadStatusInvalid) {
 215       tctx->SetName(name);
 216       return;
 217     }
 218   }
 219 }
 220
 221 void ThreadRegistry::DetachThread(u32 tid, void *arg) {
 222   BlockingMutexLock l(&mtx_);
 223   CHECK_LT(tid, n_contexts_);
 224   ThreadContextBase *tctx = threads_[tid];
 225   CHECK_NE(tctx, 0);
 226   if (tctx->status == ThreadStatusInvalid) {
 227     Report("%s: Detach of non-existent thread\n", SanitizerToolName);
 228     return;
 229   }
 230   tctx->OnDetached(arg);
 231   if (tctx->status == ThreadStatusFinished) {
 232     tctx->SetDead();
 233     QuarantinePush(tctx);
 234   } else {
 235     tctx->detached = true;
 236   }
 237 }
 238
 239 void ThreadRegistry::JoinThread(u32 tid, void *arg) {
 240   BlockingMutexLock l(&mtx_);
 241   CHECK_LT(tid, n_contexts_);
 242   ThreadContextBase *tctx = threads_[tid];
 243   CHECK_NE(tctx, 0);
 244   if (tctx->status == ThreadStatusInvalid) {
 245     Report("%s: Join of non-existent thread\n", SanitizerToolName);
 246     return;
 247   }
 248   tctx->SetJoined(arg);
 249   QuarantinePush(tctx);
 250 }
 251
 252 void ThreadRegistry::FinishThread(u32 tid) {
 253   BlockingMutexLock l(&mtx_);
 254   CHECK_GT(alive_threads_, 0);
 255   alive_threads_--;
 256   CHECK_GT(running_threads_, 0);
 257   running_threads_--;
 258   CHECK_LT(tid, n_contexts_);
 259   ThreadContextBase *tctx = threads_[tid];
 260   CHECK_NE(tctx, 0);
 261   CHECK_EQ(ThreadStatusRunning, tctx->status);
 262   tctx->SetFinished();
 263   if (tctx->detached) {
 264     tctx->SetDead();
 265     QuarantinePush(tctx);
 266   }
 267 }
 268
 269 void ThreadRegistry::StartThread(u32 tid, uptr os_id, void *arg) {
 270   BlockingMutexLock l(&mtx_);
 271   running_threads_++;
 272   CHECK_LT(tid, n_contexts_);
 273   ThreadContextBase *tctx = threads_[tid];
 274   CHECK_NE(tctx, 0);
 275   CHECK_EQ(ThreadStatusCreated, tctx->status);
 276   tctx->SetStarted(os_id, arg);
 277 }
 278
 279 void ThreadRegistry::QuarantinePush(ThreadContextBase *tctx) {
 280   if (tctx->tid == 0)
 281     return;  // Don't reuse the main thread.  It's a special snowflake.
 282   dead_threads_.push_back(tctx);
 283   if (dead_threads_.size() <= thread_quarantine_size_)
 284     return;
 285   tctx = dead_threads_.front();
 286   dead_threads_.pop_front();
 287   CHECK_EQ(tctx->status, ThreadStatusDead);
 288   tctx->Reset();
 289   tctx->reuse_count++;
 290   if (max_reuse_ > 0 && tctx->reuse_count >= max_reuse_)
 291     return;
 292   invalid_threads_.push_back(tctx);
 293 }
 294
 295 ThreadContextBase *ThreadRegistry::QuarantinePop() {
 296   if (invalid_threads_.size() == 0)
 297     return 0;
 298   ThreadContextBase *tctx = invalid_threads_.front();
 299   invalid_threads_.pop_front();
 300   return tctx;
 301 }
 302
 303 }  // namespace __sanitizer