tsan_rtl_thread.cc revision 603c4be006d8c53905d736bf1f19a49f5ce98276
1//===-- tsan_rtl_thread.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 a part of ThreadSanitizer (TSan), a race detector. 11// 12//===----------------------------------------------------------------------===// 13 14#include "tsan_rtl.h" 15#include "tsan_mman.h" 16#include "tsan_placement_new.h" 17#include "tsan_platform.h" 18#include "tsan_report.h" 19#include "tsan_sync.h" 20 21namespace __tsan { 22 23const int kThreadQuarantineSize = 16; 24 25static void MaybeReportThreadLeak(ThreadContext *tctx) { 26 if (tctx->detached) 27 return; 28 if (tctx->status != ThreadStatusCreated 29 && tctx->status != ThreadStatusRunning 30 && tctx->status != ThreadStatusFinished) 31 return; 32 ScopedReport rep(ReportTypeThreadLeak); 33 rep.AddThread(tctx); 34 OutputReport(rep); 35} 36 37void ThreadFinalize(ThreadState *thr) { 38 CHECK_GT(thr->in_rtl, 0); 39 if (!flags()->report_thread_leaks) 40 return; 41 Context *ctx = CTX(); 42 Lock l(&ctx->thread_mtx); 43 for (unsigned i = 0; i < kMaxTid; i++) { 44 ThreadContext *tctx = ctx->threads[i]; 45 if (tctx == 0) 46 continue; 47 MaybeReportThreadLeak(tctx); 48 } 49} 50 51static void ThreadDead(ThreadState *thr, ThreadContext *tctx) { 52 Context *ctx = CTX(); 53 CHECK_GT(thr->in_rtl, 0); 54 CHECK(tctx->status == ThreadStatusRunning 55 || tctx->status == ThreadStatusFinished); 56 DPrintf("#%d: ThreadDead uid=%lu\n", thr->tid, tctx->user_id); 57 tctx->status = ThreadStatusDead; 58 tctx->user_id = 0; 59 tctx->sync.Reset(); 60 61 // Put to dead list. 62 tctx->dead_next = 0; 63 if (ctx->dead_list_size == 0) 64 ctx->dead_list_head = tctx; 65 else 66 ctx->dead_list_tail->dead_next = tctx; 67 ctx->dead_list_tail = tctx; 68 ctx->dead_list_size++; 69} 70 71int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached) { 72 CHECK_GT(thr->in_rtl, 0); 73 Context *ctx = CTX(); 74 Lock l(&ctx->thread_mtx); 75 StatInc(thr, StatThreadCreate); 76 int tid = -1; 77 ThreadContext *tctx = 0; 78 if (ctx->dead_list_size > kThreadQuarantineSize 79 || ctx->thread_seq >= kMaxTid) { 80 if (ctx->dead_list_size == 0) { 81 Printf("ThreadSanitizer: %d thread limit exceeded. Dying.\n", kMaxTid); 82 Die(); 83 } 84 StatInc(thr, StatThreadReuse); 85 tctx = ctx->dead_list_head; 86 ctx->dead_list_head = tctx->dead_next; 87 ctx->dead_list_size--; 88 if (ctx->dead_list_size == 0) { 89 CHECK_EQ(tctx->dead_next, 0); 90 ctx->dead_list_head = 0; 91 } 92 CHECK_EQ(tctx->status, ThreadStatusDead); 93 tctx->status = ThreadStatusInvalid; 94 tctx->reuse_count++; 95 tctx->sync.Reset(); 96 tid = tctx->tid; 97 DestroyAndFree(tctx->dead_info); 98 } else { 99 StatInc(thr, StatThreadMaxTid); 100 tid = ctx->thread_seq++; 101 void *mem = internal_alloc(MBlockThreadContex, sizeof(ThreadContext)); 102 tctx = new(mem) ThreadContext(tid); 103 ctx->threads[tid] = tctx; 104 } 105 CHECK_NE(tctx, 0); 106 CHECK_GE(tid, 0); 107 CHECK_LT(tid, kMaxTid); 108 DPrintf("#%d: ThreadCreate tid=%d uid=%lu\n", thr->tid, tid, uid); 109 CHECK_EQ(tctx->status, ThreadStatusInvalid); 110 ctx->alive_threads++; 111 if (ctx->max_alive_threads < ctx->alive_threads) { 112 ctx->max_alive_threads++; 113 CHECK_EQ(ctx->max_alive_threads, ctx->alive_threads); 114 StatInc(thr, StatThreadMaxAlive); 115 } 116 tctx->status = ThreadStatusCreated; 117 tctx->thr = 0; 118 tctx->user_id = uid; 119 tctx->unique_id = ctx->unique_thread_seq++; 120 tctx->detached = detached; 121 if (tid) { 122 thr->fast_state.IncrementEpoch(); 123 // Can't increment epoch w/o writing to the trace as well. 124 TraceAddEvent(thr, thr->fast_state.epoch(), EventTypeMop, 0); 125 thr->clock.set(thr->tid, thr->fast_state.epoch()); 126 thr->fast_synch_epoch = thr->fast_state.epoch(); 127 thr->clock.release(&tctx->sync); 128 StatInc(thr, StatSyncRelease); 129 130 tctx->creation_stack.ObtainCurrent(thr, pc); 131 } 132 return tid; 133} 134 135void ThreadStart(ThreadState *thr, int tid) { 136 CHECK_GT(thr->in_rtl, 0); 137 uptr stk_addr = 0; 138 uptr stk_size = 0; 139 uptr tls_addr = 0; 140 uptr tls_size = 0; 141 GetThreadStackAndTls(tid == 0, &stk_addr, &stk_size, &tls_addr, &tls_size); 142 143 if (tid) { 144 MemoryResetRange(thr, /*pc=*/ 1, stk_addr, stk_size); 145 146 // Check that the thr object is in tls; 147 const uptr thr_beg = (uptr)thr; 148 const uptr thr_end = (uptr)thr + sizeof(*thr); 149 CHECK_GE(thr_beg, tls_addr); 150 CHECK_LE(thr_beg, tls_addr + tls_size); 151 CHECK_GE(thr_end, tls_addr); 152 CHECK_LE(thr_end, tls_addr + tls_size); 153 // Since the thr object is huge, skip it. 154 MemoryResetRange(thr, /*pc=*/ 2, tls_addr, thr_beg - tls_addr); 155 MemoryResetRange(thr, /*pc=*/ 2, thr_end, tls_addr + tls_size - thr_end); 156 } 157 158 Lock l(&CTX()->thread_mtx); 159 ThreadContext *tctx = CTX()->threads[tid]; 160 CHECK_NE(tctx, 0); 161 CHECK_EQ(tctx->status, ThreadStatusCreated); 162 tctx->status = ThreadStatusRunning; 163 tctx->epoch0 = tctx->epoch1 + 1; 164 tctx->epoch1 = (u64)-1; 165 new(thr) ThreadState(CTX(), tid, tctx->epoch0, stk_addr, stk_size, 166 tls_addr, tls_size); 167 tctx->thr = thr; 168 thr->fast_synch_epoch = tctx->epoch0; 169 thr->clock.set(tid, tctx->epoch0); 170 thr->clock.acquire(&tctx->sync); 171 StatInc(thr, StatSyncAcquire); 172 DPrintf("#%d: ThreadStart epoch=%llu stk_addr=%lx stk_size=%lx " 173 "tls_addr=%lx tls_size=%lx\n", 174 tid, tctx->epoch0, stk_addr, stk_size, tls_addr, tls_size); 175} 176 177void ThreadFinish(ThreadState *thr) { 178 CHECK_GT(thr->in_rtl, 0); 179 StatInc(thr, StatThreadFinish); 180 // FIXME: Treat it as write. 181 if (thr->stk_addr && thr->stk_size) 182 MemoryResetRange(thr, /*pc=*/ 3, thr->stk_addr, thr->stk_size); 183 if (thr->tls_addr && thr->tls_size) { 184 const uptr thr_beg = (uptr)thr; 185 const uptr thr_end = (uptr)thr + sizeof(*thr); 186 // Since the thr object is huge, skip it. 187 MemoryResetRange(thr, /*pc=*/ 4, thr->tls_addr, thr_beg - thr->tls_addr); 188 MemoryResetRange(thr, /*pc=*/ 5, 189 thr_end, thr->tls_addr + thr->tls_size - thr_end); 190 } 191 Context *ctx = CTX(); 192 Lock l(&ctx->thread_mtx); 193 ThreadContext *tctx = ctx->threads[thr->tid]; 194 CHECK_NE(tctx, 0); 195 CHECK_EQ(tctx->status, ThreadStatusRunning); 196 CHECK_GT(ctx->alive_threads, 0); 197 ctx->alive_threads--; 198 if (tctx->detached) { 199 ThreadDead(thr, tctx); 200 } else { 201 thr->fast_state.IncrementEpoch(); 202 // Can't increment epoch w/o writing to the trace as well. 203 TraceAddEvent(thr, thr->fast_state.epoch(), EventTypeMop, 0); 204 thr->clock.set(thr->tid, thr->fast_state.epoch()); 205 thr->fast_synch_epoch = thr->fast_state.epoch(); 206 thr->clock.release(&tctx->sync); 207 StatInc(thr, StatSyncRelease); 208 tctx->status = ThreadStatusFinished; 209 } 210 211 // Save from info about the thread. 212 tctx->dead_info = new(internal_alloc(MBlockDeadInfo, sizeof(ThreadDeadInfo))) 213 ThreadDeadInfo(); 214 internal_memcpy(&tctx->dead_info->trace.events[0], 215 &thr->trace.events[0], sizeof(thr->trace.events)); 216 for (int i = 0; i < kTraceParts; i++) { 217 tctx->dead_info->trace.headers[i].stack0.CopyFrom( 218 thr->trace.headers[i].stack0); 219 } 220 tctx->epoch1 = thr->fast_state.epoch(); 221 222 thr->~ThreadState(); 223 StatAggregate(ctx->stat, thr->stat); 224 tctx->thr = 0; 225} 226 227int ThreadTid(ThreadState *thr, uptr pc, uptr uid) { 228 CHECK_GT(thr->in_rtl, 0); 229 Context *ctx = CTX(); 230 Lock l(&ctx->thread_mtx); 231 int res = -1; 232 for (unsigned tid = 0; tid < kMaxTid; tid++) { 233 ThreadContext *tctx = ctx->threads[tid]; 234 if (tctx != 0 && tctx->user_id == uid 235 && tctx->status != ThreadStatusInvalid) { 236 tctx->user_id = 0; 237 res = tid; 238 break; 239 } 240 } 241 DPrintf("#%d: ThreadTid uid=%lu tid=%d\n", thr->tid, uid, res); 242 return res; 243} 244 245void ThreadJoin(ThreadState *thr, uptr pc, int tid) { 246 CHECK_GT(thr->in_rtl, 0); 247 CHECK_GT(tid, 0); 248 CHECK_LT(tid, kMaxTid); 249 DPrintf("#%d: ThreadJoin tid=%d\n", thr->tid, tid); 250 Context *ctx = CTX(); 251 Lock l(&ctx->thread_mtx); 252 ThreadContext *tctx = ctx->threads[tid]; 253 if (tctx->status == ThreadStatusInvalid) { 254 Printf("ThreadSanitizer: join of non-existent thread\n"); 255 return; 256 } 257 CHECK_EQ(tctx->detached, false); 258 CHECK_EQ(tctx->status, ThreadStatusFinished); 259 thr->clock.acquire(&tctx->sync); 260 StatInc(thr, StatSyncAcquire); 261 ThreadDead(thr, tctx); 262} 263 264void ThreadDetach(ThreadState *thr, uptr pc, int tid) { 265 CHECK_GT(thr->in_rtl, 0); 266 CHECK_GT(tid, 0); 267 CHECK_LT(tid, kMaxTid); 268 Context *ctx = CTX(); 269 Lock l(&ctx->thread_mtx); 270 ThreadContext *tctx = ctx->threads[tid]; 271 if (tctx->status == ThreadStatusInvalid) { 272 Printf("ThreadSanitizer: detach of non-existent thread\n"); 273 return; 274 } 275 if (tctx->status == ThreadStatusFinished) { 276 ThreadDead(thr, tctx); 277 } else { 278 tctx->detached = true; 279 } 280} 281 282void MemoryAccessRange(ThreadState *thr, uptr pc, uptr addr, 283 uptr size, bool is_write) { 284 if (size == 0) 285 return; 286 287 u64 *shadow_mem = (u64*)MemToShadow(addr); 288 DPrintf2("#%d: MemoryAccessRange: @%p %p size=%d is_write=%d\n", 289 thr->tid, (void*)pc, (void*)addr, 290 (int)size, is_write); 291 292#if TSAN_DEBUG 293 if (!IsAppMem(addr)) { 294 Printf("Access to non app mem %lx\n", addr); 295 DCHECK(IsAppMem(addr)); 296 } 297 if (!IsAppMem(addr + size - 1)) { 298 Printf("Access to non app mem %lx\n", addr + size - 1); 299 DCHECK(IsAppMem(addr + size - 1)); 300 } 301 if (!IsShadowMem((uptr)shadow_mem)) { 302 Printf("Bad shadow addr %p (%lx)\n", shadow_mem, addr); 303 DCHECK(IsShadowMem((uptr)shadow_mem)); 304 } 305 if (!IsShadowMem((uptr)(shadow_mem + size * kShadowCnt / 8 - 1))) { 306 Printf("Bad shadow addr %p (%lx)\n", 307 shadow_mem + size * kShadowCnt / 8 - 1, addr + size - 1); 308 DCHECK(IsShadowMem((uptr)(shadow_mem + size * kShadowCnt / 8 - 1))); 309 } 310#endif 311 312 StatInc(thr, StatMopRange); 313 314 FastState fast_state = thr->fast_state; 315 if (fast_state.GetIgnoreBit()) 316 return; 317 318 fast_state.IncrementEpoch(); 319 thr->fast_state = fast_state; 320 TraceAddEvent(thr, fast_state.epoch(), EventTypeMop, pc); 321 322 bool unaligned = (addr % kShadowCell) != 0; 323 324 // Handle unaligned beginning, if any. 325 for (; addr % kShadowCell && size; addr++, size--) { 326 int const kAccessSizeLog = 0; 327 Shadow cur(fast_state); 328 cur.SetWrite(is_write); 329 cur.SetAddr0AndSizeLog(addr & (kShadowCell - 1), kAccessSizeLog); 330 MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, fast_state, 331 shadow_mem, cur); 332 } 333 if (unaligned) 334 shadow_mem += kShadowCnt; 335 // Handle middle part, if any. 336 for (; size >= kShadowCell; addr += kShadowCell, size -= kShadowCell) { 337 int const kAccessSizeLog = 3; 338 Shadow cur(fast_state); 339 cur.SetWrite(is_write); 340 cur.SetAddr0AndSizeLog(0, kAccessSizeLog); 341 MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, fast_state, 342 shadow_mem, cur); 343 shadow_mem += kShadowCnt; 344 } 345 // Handle ending, if any. 346 for (; size; addr++, size--) { 347 int const kAccessSizeLog = 0; 348 Shadow cur(fast_state); 349 cur.SetWrite(is_write); 350 cur.SetAddr0AndSizeLog(addr & (kShadowCell - 1), kAccessSizeLog); 351 MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, fast_state, 352 shadow_mem, cur); 353 } 354} 355 356void MemoryRead1Byte(ThreadState *thr, uptr pc, uptr addr) { 357 MemoryAccess(thr, pc, addr, 0, 0); 358} 359 360void MemoryWrite1Byte(ThreadState *thr, uptr pc, uptr addr) { 361 MemoryAccess(thr, pc, addr, 0, 1); 362} 363 364void MemoryRead8Byte(ThreadState *thr, uptr pc, uptr addr) { 365 MemoryAccess(thr, pc, addr, 3, 0); 366} 367 368void MemoryWrite8Byte(ThreadState *thr, uptr pc, uptr addr) { 369 MemoryAccess(thr, pc, addr, 3, 1); 370} 371} // namespace __tsan 372