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