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 17namespace __sanitizer { 18 19ThreadContextBase::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 26ThreadContextBase::~ThreadContextBase() { 27 // ThreadContextBase should never be deleted. 28 CHECK(0); 29} 30 31void 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 39void ThreadContextBase::SetDead() { 40 CHECK(status == ThreadStatusRunning || 41 status == ThreadStatusFinished); 42 status = ThreadStatusDead; 43 user_id = 0; 44 OnDead(); 45} 46 47void 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 56void ThreadContextBase::SetFinished() { 57 if (!detached) 58 status = ThreadStatusFinished; 59 OnFinished(); 60} 61 62void ThreadContextBase::SetStarted(uptr _os_id, void *arg) { 63 status = ThreadStatusRunning; 64 os_id = _os_id; 65 OnStarted(arg); 66} 67 68void 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 80void ThreadContextBase::Reset() { 81 status = ThreadStatusInvalid; 82 SetName(0); 83 OnReset(); 84} 85 86// ThreadRegistry implementation. 87 88const u32 ThreadRegistry::kUnknownTid = ~0U; 89 90ThreadRegistry::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 108void 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 116uptr ThreadRegistry::GetMaxAliveThreads() { 117 BlockingMutexLock l(&mtx_); 118 return max_alive_threads_; 119} 120 121u32 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#ifndef 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 157void 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 168u32 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 178ThreadContextBase * 179ThreadRegistry::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 189static bool FindThreadContextByOsIdCallback(ThreadContextBase *tctx, 190 void *arg) { 191 return (tctx->os_id == (uptr)arg && tctx->status != ThreadStatusInvalid && 192 tctx->status != ThreadStatusDead); 193} 194 195ThreadContextBase *ThreadRegistry::FindThreadContextByOsIDLocked(uptr os_id) { 196 return FindThreadContextLocked(FindThreadContextByOsIdCallback, 197 (void *)os_id); 198} 199 200void 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 209void 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 221void 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 239void 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 252void 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 269void 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 279void 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 295ThreadContextBase *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 304