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