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