libsanitizer/sanitizer_common/sanitizer_thread_registry.cc

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